Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6

* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6: (222 commits)
  V4L/DVB (13033): pt1: Don't use a deprecated DMA_BIT_MASK macro
  V4L/DVB (13029): radio-si4713: remove #include <linux/version.h>
  V4L/DVB (13027): go7007: convert printks to v4l2_info
  V4L/DVB (13026): s2250-board: Implement brightness and contrast controls
  V4L/DVB (13025): s2250-board: Fix memory leaks
  V4L/DVB (13024): go7007: Implement vidioc_g_std and vidioc_querystd
  V4L/DVB (13023): go7007: Merge struct gofh and go declarations
  V4L/DVB (13022): go7007: Fix mpeg controls
  V4L/DVB (13021): go7007: Fix whitespace and line lengths
  V4L/DVB (13020): go7007: Updates to Kconfig and Makefile
  V4L/DVB (13019): video: initial support for ADV7180
  V4L/DVB (13018): kzalloc failure ignored in au8522_probe()
  V4L/DVB (13017): gspca: kmalloc failure ignored in sd_start()
  V4L/DVB (13016): kmalloc failure ignored in lgdt3304_attach() and s921_attach()
  V4L/DVB (13015): kmalloc failure ignored in m920x_firmware_download()
  V4L/DVB (13014): Add support for Compro VideoMate E800 (DVB-T part only)
  V4L/DVB (13013): FM TX: si4713: Kconfig: Fixed two typos.
  V4L/DVB (13012): uvc: introduce missing kfree
  V4L/DVB (13011): Change tuner type of BeholdTV cards
  V4L/DVB (13009): gspca - stv06xx-hdcs: Reduce exposure range
  ...

155 files changed, 31450 insertions, 3572 deletions

diff --git a/drivers/media/common/tuners/tda18271-common.c b/drivers/media/common/tuners/tda18271-common.c
index fc76c30e24f1..155c93eb75da 100644
--- a/drivers/media/common/tuners/tda18271-common.c
+++ b/drivers/media/common/tuners/tda18271-common.c
@@ -210,7 +210,8 @@ int tda18271_write_regs(struct dvb_frontend *fe, int idx, int len)
         tda18271_i2c_gate_ctrl(fe, 0);
 
         if (ret != 1)
-                tda_err("ERROR: i2c_transfer returned: %d\n", ret);
+                tda_err("ERROR: idx = 0x%x, len = %d, "
+                        "i2c_transfer returned: %d\n", idx, len, ret);
 
         return (ret == 1 ? 0 : ret);
 }
diff --git a/drivers/media/common/tuners/tda18271-fe.c b/drivers/media/common/tuners/tda18271-fe.c
index bc4b004ba7db..64595112000d 100644
--- a/drivers/media/common/tuners/tda18271-fe.c
+++ b/drivers/media/common/tuners/tda18271-fe.c
@@ -36,6 +36,27 @@ static LIST_HEAD(hybrid_tuner_instance_list);
 
 /*---------------------------------------------------------------------*/
 
+static int tda18271_toggle_output(struct dvb_frontend *fe, int standby)
+{
+        struct tda18271_priv *priv = fe->tuner_priv;
+
+        int ret = tda18271_set_standby_mode(fe, standby ? 1 : 0,
+                        priv->output_opt & TDA18271_OUTPUT_LT_OFF ? 1 : 0,
+                        priv->output_opt & TDA18271_OUTPUT_XT_OFF ? 1 : 0);
+
+        if (tda_fail(ret))
+                goto fail;
+
+        tda_dbg("%s mode: xtal oscillator %s, slave tuner loop thru %s\n",
+                standby ? "standby" : "active",
+                priv->output_opt & TDA18271_OUTPUT_XT_OFF ? "off" : "on",
+                priv->output_opt & TDA18271_OUTPUT_LT_OFF ? "off" : "on");
+fail:
+        return ret;
+}
+
+/*---------------------------------------------------------------------*/
+
 static inline int charge_pump_source(struct dvb_frontend *fe, int force)
 {
         struct tda18271_priv *priv = fe->tuner_priv;
@@ -271,7 +292,7 @@ static int tda18271c2_rf_tracking_filters_correction(struct dvb_frontend *fe,
         tda18271_lookup_map(fe, RF_CAL_DC_OVER_DT, &freq, &dc_over_dt);
 
         /* calculate temperature compensation */
-        rfcal_comp = dc_over_dt * (tm_current - priv->tm_rfcal);
+        rfcal_comp = dc_over_dt * (tm_current - priv->tm_rfcal) / 1000;
 
         regs[R_EB14] = approx + rfcal_comp;
         ret = tda18271_write_regs(fe, R_EB14, 1);
@@ -800,7 +821,7 @@ static int tda18271_init(struct dvb_frontend *fe)
 
         mutex_lock(&priv->lock);
 
-        /* power up */
+        /* full power up */
         ret = tda18271_set_standby_mode(fe, 0, 0, 0);
         if (tda_fail(ret))
                 goto fail;
@@ -818,6 +839,21 @@ fail:
         return ret;
 }
 
+static int tda18271_sleep(struct dvb_frontend *fe)
+{
+        struct tda18271_priv *priv = fe->tuner_priv;
+        int ret;
+
+        mutex_lock(&priv->lock);
+
+        /* enter standby mode, with required output features enabled */
+        ret = tda18271_toggle_output(fe, 1);
+
+        mutex_unlock(&priv->lock);
+
+        return ret;
+}
+
 /* ------------------------------------------------------------------ */
 
 static int tda18271_agc(struct dvb_frontend *fe)
@@ -827,8 +863,9 @@ static int tda18271_agc(struct dvb_frontend *fe)
 
         switch (priv->config) {
         case 0:
-                /* no LNA */
-                tda_dbg("no agc configuration provided\n");
+                /* no external agc configuration required */
+                if (tda18271_debug & DBG_ADV)
+                        tda_dbg("no agc configuration provided\n");
                 break;
         case 3:
                 /* switch with GPIO of saa713x */
@@ -1010,22 +1047,6 @@ fail:
         return ret;
 }
 
-static int tda18271_sleep(struct dvb_frontend *fe)
-{
-        struct tda18271_priv *priv = fe->tuner_priv;
-        int ret;
-
-        mutex_lock(&priv->lock);
-
-        /* standby mode w/ slave tuner output
-         * & loop thru & xtal oscillator on */
-        ret = tda18271_set_standby_mode(fe, 1, 0, 0);
-
-        mutex_unlock(&priv->lock);
-
-        return ret;
-}
-
 static int tda18271_release(struct dvb_frontend *fe)
 {
         struct tda18271_priv *priv = fe->tuner_priv;
@@ -1199,6 +1220,9 @@ struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
                 priv->gate = (cfg) ? cfg->gate : TDA18271_GATE_AUTO;
                 priv->role = (cfg) ? cfg->role : TDA18271_MASTER;
                 priv->config = (cfg) ? cfg->config : 0;
+                priv->small_i2c = (cfg) ? cfg->small_i2c : 0;
+                priv->output_opt = (cfg) ?
+                        cfg->output_opt : TDA18271_OUTPUT_LT_XT_ON;
 
                 /* tda18271_cal_on_startup == -1 when cal
                  * module option is unset */
@@ -1216,9 +1240,6 @@ struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
 
                 fe->tuner_priv = priv;
 
-                if (cfg)
-                        priv->small_i2c = cfg->small_i2c;
-
                 if (tda_fail(tda18271_get_id(fe)))
                         goto fail;
 
@@ -1238,9 +1259,19 @@ struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
                 /* 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;
+                /* allow dvb driver to override configuration settings */
+                if (cfg) {
+                        if (cfg->gate != TDA18271_GATE_ANALOG)
+                                priv->gate = cfg->gate;
+                        if (cfg->role)
+                                priv->role = cfg->role;
+                        if (cfg->config)
+                                priv->config = cfg->config;
+                        if (cfg->small_i2c)
+                                priv->small_i2c = cfg->small_i2c;
+                        if (cfg->output_opt)
+                                priv->output_opt = cfg->output_opt;
+                }
                 break;
         }
 
diff --git a/drivers/media/common/tuners/tda18271-maps.c b/drivers/media/common/tuners/tda18271-maps.c
index ab14ceb9e0ce..e21fdeff3ddf 100644
--- a/drivers/media/common/tuners/tda18271-maps.c
+++ b/drivers/media/common/tuners/tda18271-maps.c
@@ -962,10 +962,9 @@ struct tda18271_cid_target_map {
 static struct tda18271_cid_target_map tda18271_cid_target[] = {
         { .rfmax =  46000, .target = 0x04, .limit =  1800 },
         { .rfmax =  52200, .target = 0x0a, .limit =  1500 },
-        { .rfmax =  79100, .target = 0x01, .limit =  4000 },
+        { .rfmax =  70100, .target = 0x01, .limit =  4000 },
         { .rfmax = 136800, .target = 0x18, .limit =  4000 },
         { .rfmax = 156700, .target = 0x18, .limit =  4000 },
-        { .rfmax = 156700, .target = 0x18, .limit =  4000 },
         { .rfmax = 186250, .target = 0x0a, .limit =  4000 },
         { .rfmax = 230000, .target = 0x0a, .limit =  4000 },
         { .rfmax = 345000, .target = 0x18, .limit =  4000 },
diff --git a/drivers/media/common/tuners/tda18271-priv.h b/drivers/media/common/tuners/tda18271-priv.h
index e6a80ad09356..2bee229acd91 100644
--- a/drivers/media/common/tuners/tda18271-priv.h
+++ b/drivers/media/common/tuners/tda18271-priv.h
@@ -108,6 +108,7 @@ struct tda18271_priv {
         enum tda18271_role role;
         enum tda18271_i2c_gate gate;
         enum tda18271_ver id;
+        enum tda18271_output_options output_opt;
 
         unsigned int config; /* interface to saa713x / tda829x */
         unsigned int tm_rfcal;
diff --git a/drivers/media/common/tuners/tda18271.h b/drivers/media/common/tuners/tda18271.h
index 71bac9593f1e..323f2912128d 100644
--- a/drivers/media/common/tuners/tda18271.h
+++ b/drivers/media/common/tuners/tda18271.h
@@ -67,6 +67,17 @@ enum tda18271_i2c_gate {
         TDA18271_GATE_DIGITAL,
 };
 
+enum tda18271_output_options {
+        /* slave tuner output & loop thru & xtal oscillator always on */
+        TDA18271_OUTPUT_LT_XT_ON = 0,
+
+        /* slave tuner output loop thru off */
+        TDA18271_OUTPUT_LT_OFF = 1,
+
+        /* xtal oscillator off */
+        TDA18271_OUTPUT_XT_OFF = 2,
+};
+
 struct tda18271_config {
         /* override default if freq / std settings (optional) */
         struct tda18271_std_map *std_map;
@@ -77,6 +88,9 @@ struct tda18271_config {
         /* use i2c gate provided by analog or digital demod */
         enum tda18271_i2c_gate gate;
 
+        /* output options that can be disabled */
+        enum tda18271_output_options output_opt;
+
         /* force rf tracking filter calibration on startup */
         unsigned int rf_cal_on_startup:1;
 
diff --git a/drivers/media/common/tuners/tuner-types.c b/drivers/media/common/tuners/tuner-types.c
index 5c6ef1e23c94..2b876f3988c1 100644
--- a/drivers/media/common/tuners/tuner-types.c
+++ b/drivers/media/common/tuners/tuner-types.c
@@ -1320,6 +1320,23 @@ static struct tuner_params tuner_partsnic_pti_5nf05_params[] = {
         },
 };
 
+/* --------- TUNER_PHILIPS_CU1216L - DVB-C NIM ------------------------- */
+
+static struct tuner_range tuner_cu1216l_ranges[] = {
+        { 16 * 160.25 /*MHz*/, 0xce, 0x01 },
+        { 16 * 444.25 /*MHz*/, 0xce, 0x02 },
+        { 16 * 999.99        , 0xce, 0x04 },
+};
+
+static struct tuner_params tuner_philips_cu1216l_params[] = {
+        {
+                .type   = TUNER_PARAM_TYPE_DIGITAL,
+                .ranges = tuner_cu1216l_ranges,
+                .count  = ARRAY_SIZE(tuner_cu1216l_ranges),
+                .iffreq = 16 * 36.125, /*MHz*/
+        },
+};
+
 /* --------------------------------------------------------------------- */
 
 struct tunertype tuners[] = {
@@ -1778,6 +1795,16 @@ struct tunertype tuners[] = {
                 .params = tuner_partsnic_pti_5nf05_params,
                 .count  = ARRAY_SIZE(tuner_partsnic_pti_5nf05_params),
         },
+        [TUNER_PHILIPS_CU1216L] = {
+                .name = "Philips CU1216L",
+                .params = tuner_philips_cu1216l_params,
+                .count  = ARRAY_SIZE(tuner_philips_cu1216l_params),
+                .stepsize = 62500,
+        },
+        [TUNER_NXP_TDA18271] = {
+                .name   = "NXP TDA18271",
+                /* see tda18271-fe.c for details */
+        },
 };
 EXPORT_SYMBOL(tuners);
 
diff --git a/drivers/media/dvb/Kconfig b/drivers/media/dvb/Kconfig
index 1d0e4b1ef10c..35d0817126e9 100644
--- a/drivers/media/dvb/Kconfig
+++ b/drivers/media/dvb/Kconfig
@@ -68,6 +68,10 @@ comment "Supported FireWire (IEEE 1394) Adapters"
         depends on DVB_CORE && IEEE1394
 source "drivers/media/dvb/firewire/Kconfig"
 
+comment "Supported Earthsoft PT1 Adapters"
+        depends on DVB_CORE && PCI && I2C
+source "drivers/media/dvb/pt1/Kconfig"
+
 comment "Supported DVB Frontends"
         depends on DVB_CORE
 source "drivers/media/dvb/frontends/Kconfig"
diff --git a/drivers/media/dvb/Makefile b/drivers/media/dvb/Makefile
index 6092a5bb5a7d..16d262ddb45d 100644
--- a/drivers/media/dvb/Makefile
+++ b/drivers/media/dvb/Makefile
@@ -2,6 +2,6 @@
 # Makefile for the kernel multimedia device drivers.
 #
 
-obj-y        := dvb-core/ frontends/ ttpci/ ttusb-dec/ ttusb-budget/ b2c2/ bt8xx/ dvb-usb/ pluto2/ siano/ dm1105/
+obj-y        := dvb-core/ frontends/ ttpci/ ttusb-dec/ ttusb-budget/ b2c2/ bt8xx/ dvb-usb/ pluto2/ siano/ dm1105/ pt1/
 
 obj-$(CONFIG_DVB_FIREDTV)       += firewire/
diff --git a/drivers/media/dvb/dvb-core/dvb_frontend.c b/drivers/media/dvb/dvb-core/dvb_frontend.c
index d13ebcb0c6b6..ddf639ed2fd8 100644
--- a/drivers/media/dvb/dvb-core/dvb_frontend.c
+++ b/drivers/media/dvb/dvb-core/dvb_frontend.c
@@ -850,6 +850,49 @@ static int dvb_frontend_check_parameters(struct dvb_frontend *fe,
         return 0;
 }
 
+static int dvb_frontend_clear_cache(struct dvb_frontend *fe)
+{
+        int i;
+
+        memset(&(fe->dtv_property_cache), 0,
+                        sizeof(struct dtv_frontend_properties));
+
+        fe->dtv_property_cache.state = DTV_CLEAR;
+        fe->dtv_property_cache.delivery_system = SYS_UNDEFINED;
+        fe->dtv_property_cache.inversion = INVERSION_AUTO;
+        fe->dtv_property_cache.fec_inner = FEC_AUTO;
+        fe->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_AUTO;
+        fe->dtv_property_cache.bandwidth_hz = BANDWIDTH_AUTO;
+        fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_AUTO;
+        fe->dtv_property_cache.hierarchy = HIERARCHY_AUTO;
+        fe->dtv_property_cache.symbol_rate = QAM_AUTO;
+        fe->dtv_property_cache.code_rate_HP = FEC_AUTO;
+        fe->dtv_property_cache.code_rate_LP = FEC_AUTO;
+
+        fe->dtv_property_cache.isdbt_partial_reception = -1;
+        fe->dtv_property_cache.isdbt_sb_mode = -1;
+        fe->dtv_property_cache.isdbt_sb_subchannel = -1;
+        fe->dtv_property_cache.isdbt_sb_segment_idx = -1;
+        fe->dtv_property_cache.isdbt_sb_segment_count = -1;
+        fe->dtv_property_cache.isdbt_layer_enabled = 0x7;
+        for (i = 0; i < 3; i++) {
+                fe->dtv_property_cache.layer[i].fec = FEC_AUTO;
+                fe->dtv_property_cache.layer[i].modulation = QAM_AUTO;
+                fe->dtv_property_cache.layer[i].interleaving = -1;
+                fe->dtv_property_cache.layer[i].segment_count = -1;
+        }
+
+        return 0;
+}
+
+#define _DTV_CMD(n, s, b) \
+[n] = { \
+        .name = #n, \
+        .cmd  = n, \
+        .set  = s,\
+        .buffer = b \
+}
+
 static struct dtv_cmds_h dtv_cmds[] = {
         [DTV_TUNE] = {
                 .name   = "DTV_TUNE",
@@ -949,6 +992,47 @@ static struct dtv_cmds_h dtv_cmds[] = {
                 .cmd    = DTV_TRANSMISSION_MODE,
                 .set    = 1,
         },
+
+        _DTV_CMD(DTV_ISDBT_PARTIAL_RECEPTION, 1, 0),
+        _DTV_CMD(DTV_ISDBT_SOUND_BROADCASTING, 1, 0),
+        _DTV_CMD(DTV_ISDBT_SB_SUBCHANNEL_ID, 1, 0),
+        _DTV_CMD(DTV_ISDBT_SB_SEGMENT_IDX, 1, 0),
+        _DTV_CMD(DTV_ISDBT_SB_SEGMENT_COUNT, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYER_ENABLED, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERA_FEC, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERA_MODULATION, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERA_SEGMENT_COUNT, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERA_TIME_INTERLEAVING, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERB_FEC, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERB_MODULATION, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERB_SEGMENT_COUNT, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERB_TIME_INTERLEAVING, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERC_FEC, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERC_MODULATION, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERC_SEGMENT_COUNT, 1, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERC_TIME_INTERLEAVING, 1, 0),
+
+        _DTV_CMD(DTV_ISDBT_PARTIAL_RECEPTION, 0, 0),
+        _DTV_CMD(DTV_ISDBT_SOUND_BROADCASTING, 0, 0),
+        _DTV_CMD(DTV_ISDBT_SB_SUBCHANNEL_ID, 0, 0),
+        _DTV_CMD(DTV_ISDBT_SB_SEGMENT_IDX, 0, 0),
+        _DTV_CMD(DTV_ISDBT_SB_SEGMENT_COUNT, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYER_ENABLED, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERA_FEC, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERA_MODULATION, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERA_SEGMENT_COUNT, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERA_TIME_INTERLEAVING, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERB_FEC, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERB_MODULATION, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERB_SEGMENT_COUNT, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERB_TIME_INTERLEAVING, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERC_FEC, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERC_MODULATION, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERC_SEGMENT_COUNT, 0, 0),
+        _DTV_CMD(DTV_ISDBT_LAYERC_TIME_INTERLEAVING, 0, 0),
+
+        _DTV_CMD(DTV_ISDBS_TS_ID, 1, 0),
+
         /* Get */
         [DTV_DISEQC_SLAVE_REPLY] = {
                 .name   = "DTV_DISEQC_SLAVE_REPLY",
@@ -956,6 +1040,7 @@ static struct dtv_cmds_h dtv_cmds[] = {
                 .set    = 0,
                 .buffer = 1,
         },
+
         [DTV_API_VERSION] = {
                 .name   = "DTV_API_VERSION",
                 .cmd    = DTV_API_VERSION,
@@ -1165,14 +1250,21 @@ static void dtv_property_adv_params_sync(struct dvb_frontend *fe)
         if(c->delivery_system == SYS_ISDBT) {
                 /* Fake out a generic DVB-T request so we pass validation in the ioctl */
                 p->frequency = c->frequency;
-                p->inversion = INVERSION_AUTO;
+                p->inversion = c->inversion;
                 p->u.ofdm.constellation = QAM_AUTO;
                 p->u.ofdm.code_rate_HP = FEC_AUTO;
                 p->u.ofdm.code_rate_LP = FEC_AUTO;
-                p->u.ofdm.bandwidth = BANDWIDTH_AUTO;
                 p->u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO;
                 p->u.ofdm.guard_interval = GUARD_INTERVAL_AUTO;
                 p->u.ofdm.hierarchy_information = HIERARCHY_AUTO;
+                if (c->bandwidth_hz == 8000000)
+                        p->u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
+                else if (c->bandwidth_hz == 7000000)
+                        p->u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
+                else if (c->bandwidth_hz == 6000000)
+                        p->u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
+                else
+                        p->u.ofdm.bandwidth = BANDWIDTH_AUTO;
         }
 }
 
@@ -1274,6 +1366,65 @@ static int dtv_property_process_get(struct dvb_frontend *fe,
         case DTV_HIERARCHY:
                 tvp->u.data = fe->dtv_property_cache.hierarchy;
                 break;
+
+        /* ISDB-T Support here */
+        case DTV_ISDBT_PARTIAL_RECEPTION:
+                tvp->u.data = fe->dtv_property_cache.isdbt_partial_reception;
+                break;
+        case DTV_ISDBT_SOUND_BROADCASTING:
+                tvp->u.data = fe->dtv_property_cache.isdbt_sb_mode;
+                break;
+        case DTV_ISDBT_SB_SUBCHANNEL_ID:
+                tvp->u.data = fe->dtv_property_cache.isdbt_sb_subchannel;
+                break;
+        case DTV_ISDBT_SB_SEGMENT_IDX:
+                tvp->u.data = fe->dtv_property_cache.isdbt_sb_segment_idx;
+                break;
+        case DTV_ISDBT_SB_SEGMENT_COUNT:
+                tvp->u.data = fe->dtv_property_cache.isdbt_sb_segment_count;
+                break;
+        case DTV_ISDBT_LAYER_ENABLED:
+                tvp->u.data = fe->dtv_property_cache.isdbt_layer_enabled;
+                break;
+        case DTV_ISDBT_LAYERA_FEC:
+                tvp->u.data = fe->dtv_property_cache.layer[0].fec;
+                break;
+        case DTV_ISDBT_LAYERA_MODULATION:
+                tvp->u.data = fe->dtv_property_cache.layer[0].modulation;
+                break;
+        case DTV_ISDBT_LAYERA_SEGMENT_COUNT:
+                tvp->u.data = fe->dtv_property_cache.layer[0].segment_count;
+                break;
+        case DTV_ISDBT_LAYERA_TIME_INTERLEAVING:
+                tvp->u.data = fe->dtv_property_cache.layer[0].interleaving;
+                break;
+        case DTV_ISDBT_LAYERB_FEC:
+                tvp->u.data = fe->dtv_property_cache.layer[1].fec;
+                break;
+        case DTV_ISDBT_LAYERB_MODULATION:
+                tvp->u.data = fe->dtv_property_cache.layer[1].modulation;
+                break;
+        case DTV_ISDBT_LAYERB_SEGMENT_COUNT:
+                tvp->u.data = fe->dtv_property_cache.layer[1].segment_count;
+                break;
+        case DTV_ISDBT_LAYERB_TIME_INTERLEAVING:
+                tvp->u.data = fe->dtv_property_cache.layer[1].interleaving;
+                break;
+        case DTV_ISDBT_LAYERC_FEC:
+                tvp->u.data = fe->dtv_property_cache.layer[2].fec;
+                break;
+        case DTV_ISDBT_LAYERC_MODULATION:
+                tvp->u.data = fe->dtv_property_cache.layer[2].modulation;
+                break;
+        case DTV_ISDBT_LAYERC_SEGMENT_COUNT:
+                tvp->u.data = fe->dtv_property_cache.layer[2].segment_count;
+                break;
+        case DTV_ISDBT_LAYERC_TIME_INTERLEAVING:
+                tvp->u.data = fe->dtv_property_cache.layer[2].interleaving;
+                break;
+        case DTV_ISDBS_TS_ID:
+                tvp->u.data = fe->dtv_property_cache.isdbs_ts_id;
+                break;
         default:
                 r = -1;
         }
@@ -1302,10 +1453,8 @@ static int dtv_property_process_set(struct dvb_frontend *fe,
                 /* Reset a cache of data specific to the frontend here. This does
                  * not effect hardware.
                  */
+                dvb_frontend_clear_cache(fe);
                 dprintk("%s() Flushing property cache\n", __func__);
-                memset(&fe->dtv_property_cache, 0, sizeof(struct dtv_frontend_properties));
-                fe->dtv_property_cache.state = tvp->cmd;
-                fe->dtv_property_cache.delivery_system = SYS_UNDEFINED;
                 break;
         case DTV_TUNE:
                 /* interpret the cache of data, build either a traditional frontend
@@ -1371,6 +1520,65 @@ static int dtv_property_process_set(struct dvb_frontend *fe,
         case DTV_HIERARCHY:
                 fe->dtv_property_cache.hierarchy = tvp->u.data;
                 break;
+
+        /* ISDB-T Support here */
+        case DTV_ISDBT_PARTIAL_RECEPTION:
+                fe->dtv_property_cache.isdbt_partial_reception = tvp->u.data;
+                break;
+        case DTV_ISDBT_SOUND_BROADCASTING:
+                fe->dtv_property_cache.isdbt_sb_mode = tvp->u.data;
+                break;
+        case DTV_ISDBT_SB_SUBCHANNEL_ID:
+                fe->dtv_property_cache.isdbt_sb_subchannel = tvp->u.data;
+                break;
+        case DTV_ISDBT_SB_SEGMENT_IDX:
+                fe->dtv_property_cache.isdbt_sb_segment_idx = tvp->u.data;
+                break;
+        case DTV_ISDBT_SB_SEGMENT_COUNT:
+                fe->dtv_property_cache.isdbt_sb_segment_count = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYER_ENABLED:
+                fe->dtv_property_cache.isdbt_layer_enabled = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERA_FEC:
+                fe->dtv_property_cache.layer[0].fec = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERA_MODULATION:
+                fe->dtv_property_cache.layer[0].modulation = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERA_SEGMENT_COUNT:
+                fe->dtv_property_cache.layer[0].segment_count = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERA_TIME_INTERLEAVING:
+                fe->dtv_property_cache.layer[0].interleaving = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERB_FEC:
+                fe->dtv_property_cache.layer[1].fec = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERB_MODULATION:
+                fe->dtv_property_cache.layer[1].modulation = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERB_SEGMENT_COUNT:
+                fe->dtv_property_cache.layer[1].segment_count = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERB_TIME_INTERLEAVING:
+                fe->dtv_property_cache.layer[1].interleaving = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERC_FEC:
+                fe->dtv_property_cache.layer[2].fec = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERC_MODULATION:
+                fe->dtv_property_cache.layer[2].modulation = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERC_SEGMENT_COUNT:
+                fe->dtv_property_cache.layer[2].segment_count = tvp->u.data;
+                break;
+        case DTV_ISDBT_LAYERC_TIME_INTERLEAVING:
+                fe->dtv_property_cache.layer[2].interleaving = tvp->u.data;
+                break;
+        case DTV_ISDBS_TS_ID:
+                fe->dtv_property_cache.isdbs_ts_id = tvp->u.data;
+                break;
         default:
                 r = -1;
         }
diff --git a/drivers/media/dvb/dvb-core/dvb_frontend.h b/drivers/media/dvb/dvb-core/dvb_frontend.h
index e176da472d7a..810f07d63246 100644
--- a/drivers/media/dvb/dvb-core/dvb_frontend.h
+++ b/drivers/media/dvb/dvb-core/dvb_frontend.h
@@ -341,6 +341,23 @@ struct dtv_frontend_properties {
         fe_rolloff_t            rolloff;
 
         fe_delivery_system_t    delivery_system;
+
+        /* ISDB-T specifics */
+        u8                      isdbt_partial_reception;
+        u8                      isdbt_sb_mode;
+        u8                      isdbt_sb_subchannel;
+        u32                     isdbt_sb_segment_idx;
+        u32                     isdbt_sb_segment_count;
+        u8                      isdbt_layer_enabled;
+        struct {
+            u8                  segment_count;
+            fe_code_rate_t      fec;
+            fe_modulation_t     modulation;
+            u8                  interleaving;
+        } layer[3];
+
+        /* ISDB-T specifics */
+        u32                     isdbs_ts_id;
 };
 
 struct dvb_frontend {
diff --git a/drivers/media/dvb/dvb-usb/Kconfig b/drivers/media/dvb/dvb-usb/Kconfig
index 8b8bc04ee980..0e4b97fba384 100644
--- a/drivers/media/dvb/dvb-usb/Kconfig
+++ b/drivers/media/dvb/dvb-usb/Kconfig
@@ -71,6 +71,7 @@ config DVB_USB_DIB0700
         depends on DVB_USB
         select DVB_DIB7000P if !DVB_FE_CUSTOMISE
         select DVB_DIB7000M if !DVB_FE_CUSTOMISE
+        select DVB_DIB8000 if !DVB_FE_CUSTOMISE
         select DVB_DIB3000MC if !DVB_FE_CUSTOMISE
         select DVB_S5H1411 if !DVB_FE_CUSTOMISE
         select DVB_LGDT3305 if !DVB_FE_CUSTOMISE
@@ -87,7 +88,7 @@ config DVB_USB_DIB0700
           Avermedia and other big and small companies.
 
           For an up-to-date list of devices supported by this driver, have a look
-          on the Linux-DVB Wiki at www.linuxtv.org.
+          on the LinuxTV Wiki at www.linuxtv.org.
 
           Say Y if you own such a device and want to use it. You should build it as
           a module.
@@ -315,3 +316,9 @@ config DVB_USB_CE6230
         select MEDIA_TUNER_MXL5005S if !MEDIA_TUNER_CUSTOMISE
         help
           Say Y here to support the Intel CE6230 DVB-T USB2.0 receiver
+
+config DVB_USB_FRIIO
+        tristate "Friio ISDB-T USB2.0 Receiver support"
+        depends on DVB_USB
+        help
+          Say Y here to support the Japanese DTV receiver Friio.
diff --git a/drivers/media/dvb/dvb-usb/Makefile b/drivers/media/dvb/dvb-usb/Makefile
index f92734ed777a..85b83a43d55d 100644
--- a/drivers/media/dvb/dvb-usb/Makefile
+++ b/drivers/media/dvb/dvb-usb/Makefile
@@ -79,6 +79,9 @@ obj-$(CONFIG_DVB_USB_CINERGY_T2) += dvb-usb-cinergyT2.o
 dvb-usb-ce6230-objs = ce6230.o
 obj-$(CONFIG_DVB_USB_CE6230) += dvb-usb-ce6230.o
 
+dvb-usb-friio-objs = friio.o friio-fe.o
+obj-$(CONFIG_DVB_USB_FRIIO) += dvb-usb-friio.o
+
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core/ -Idrivers/media/dvb/frontends/
 # due to tuner-xc3028
 EXTRA_CFLAGS += -Idrivers/media/common/tuners
diff --git a/drivers/media/dvb/dvb-usb/af9015.c b/drivers/media/dvb/dvb-usb/af9015.c
index 99cdd0d101ca..cf042b309b46 100644
--- a/drivers/media/dvb/dvb-usb/af9015.c
+++ b/drivers/media/dvb/dvb-usb/af9015.c
@@ -61,10 +61,13 @@ static struct af9013_config af9015_af9013_config[] = {
 
 static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
 {
+#define BUF_LEN 63
+#define REQ_HDR_LEN 8 /* send header size */
+#define ACK_HDR_LEN 2 /* rece header size */
         int act_len, ret;
-        u8 buf[64];
+        u8 buf[BUF_LEN];
         u8 write = 1;
-        u8 msg_len = 8;
+        u8 msg_len = REQ_HDR_LEN;
         static u8 seq; /* packet sequence number */
 
         if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
@@ -94,7 +97,7 @@ static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
                 break;
         case WRITE_MEMORY:
                 if (((req->addr & 0xff00) == 0xff00) ||
-                    ((req->addr & 0xae00) == 0xae00))
+                    ((req->addr & 0xff00) == 0xae00))
                         buf[0] = WRITE_VIRTUAL_MEMORY;
         case WRITE_VIRTUAL_MEMORY:
         case COPY_FIRMWARE:
@@ -107,17 +110,26 @@ static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
                 goto error_unlock;
         }
 
+        /* buffer overflow check */
+        if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
+                (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
+                err("too much data; cmd:%d len:%d", req->cmd, req->data_len);
+                ret = -EINVAL;
+                goto error_unlock;
+        }
+
         /* write requested */
         if (write) {
-                memcpy(&buf[8], req->data, req->data_len);
+                memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
                 msg_len += req->data_len;
         }
+
         deb_xfer(">>> ");
         debug_dump(buf, msg_len, deb_xfer);
 
         /* send req */
         ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
-        &act_len, AF9015_USB_TIMEOUT);
+                &act_len, AF9015_USB_TIMEOUT);
         if (ret)
                 err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
         else
@@ -130,10 +142,14 @@ static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
         if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
                 goto exit_unlock;
 
-        /* receive ack and data if read req */
-        msg_len = 1 + 1 + req->data_len;  /* seq + status + data len */
+        /* write receives seq + status = 2 bytes
+           read receives seq + status + data = 2 + N bytes */
+        msg_len = ACK_HDR_LEN;
+        if (!write)
+                msg_len += req->data_len;
+
         ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
-                           &act_len, AF9015_USB_TIMEOUT);
+                &act_len, AF9015_USB_TIMEOUT);
         if (ret) {
                 err("recv bulk message failed:%d", ret);
                 ret = -1;
@@ -159,7 +175,7 @@ static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
 
         /* read request, copy returned data to return buf */
         if (!write)
-                memcpy(req->data, &buf[2], req->data_len);
+                memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
 
 error_unlock:
 exit_unlock:
@@ -369,12 +385,14 @@ static int af9015_init_endpoint(struct dvb_usb_device *d)
         u8  packet_size;
         deb_info("%s: USB speed:%d\n", __func__, d->udev->speed);
 
+        /* Windows driver uses packet count 21 for USB1.1 and 348 for USB2.0.
+           We use smaller - about 1/4 from the original, 5 and 87. */
 #define TS_PACKET_SIZE            188
 
-#define TS_USB20_PACKET_COUNT     348
+#define TS_USB20_PACKET_COUNT      87
 #define TS_USB20_FRAME_SIZE       (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
 
-#define TS_USB11_PACKET_COUNT      21
+#define TS_USB11_PACKET_COUNT       5
 #define TS_USB11_FRAME_SIZE       (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
 
 #define TS_USB20_MAX_PACKET_SIZE  512
@@ -868,13 +886,13 @@ static int af9015_read_config(struct usb_device *udev)
                 /* USB1.1 set smaller buffersize and disable 2nd adapter */
                 if (udev->speed == USB_SPEED_FULL) {
                         af9015_properties[i].adapter[0].stream.u.bulk.buffersize
-                                = TS_USB11_MAX_PACKET_SIZE;
+                                = TS_USB11_FRAME_SIZE;
                         /* disable 2nd adapter because we don't have
                            PID-filters */
                         af9015_config.dual_mode = 0;
                 } else {
                         af9015_properties[i].adapter[0].stream.u.bulk.buffersize
-                                = TS_USB20_MAX_PACKET_SIZE;
+                                = TS_USB20_FRAME_SIZE;
                 }
         }
 
@@ -1310,7 +1328,7 @@ static struct dvb_usb_device_properties af9015_properties[] = {
                                         .u = {
                                                 .bulk = {
                                                         .buffersize =
-                                                TS_USB20_MAX_PACKET_SIZE,
+                                                TS_USB20_FRAME_SIZE,
                                                 }
                                         }
                                 },
@@ -1416,7 +1434,7 @@ static struct dvb_usb_device_properties af9015_properties[] = {
                                         .u = {
                                                 .bulk = {
                                                         .buffersize =
-                                                TS_USB20_MAX_PACKET_SIZE,
+                                                TS_USB20_FRAME_SIZE,
                                                 }
                                         }
                                 },
@@ -1522,7 +1540,7 @@ static struct dvb_usb_device_properties af9015_properties[] = {
                                         .u = {
                                                 .bulk = {
                                                         .buffersize =
-                                                TS_USB20_MAX_PACKET_SIZE,
+                                                TS_USB20_FRAME_SIZE,
                                                 }
                                         }
                                 },
diff --git a/drivers/media/dvb/dvb-usb/anysee.c b/drivers/media/dvb/dvb-usb/anysee.c
index 7381aff4dcf6..2ae7f648effe 100644
--- a/drivers/media/dvb/dvb-usb/anysee.c
+++ b/drivers/media/dvb/dvb-usb/anysee.c
@@ -203,11 +203,11 @@ static struct i2c_algorithm anysee_i2c_algo = {
 
 static int anysee_mt352_demod_init(struct dvb_frontend *fe)
 {
-        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x28 };
-        static u8 reset []         = { RESET,      0x80 };
-        static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
-        static u8 agc_cfg []       = { AGC_TARGET, 0x28, 0x20 };
-        static u8 gpp_ctl_cfg []   = { GPP_CTL,    0x33 };
+        static u8 clock_config[]   = { CLOCK_CTL,  0x38, 0x28 };
+        static u8 reset[]          = { RESET,      0x80 };
+        static u8 adc_ctl_1_cfg[]  = { ADC_CTL_1,  0x40 };
+        static u8 agc_cfg[]        = { AGC_TARGET, 0x28, 0x20 };
+        static u8 gpp_ctl_cfg[]    = { GPP_CTL,    0x33 };
         static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
 
         mt352_write(fe, clock_config,   sizeof(clock_config));
@@ -485,7 +485,7 @@ static int anysee_probe(struct usb_interface *intf,
         return ret;
 }
 
-static struct usb_device_id anysee_table [] = {
+static struct usb_device_id anysee_table[] = {
         { USB_DEVICE(USB_VID_CYPRESS, USB_PID_ANYSEE) },
         { USB_DEVICE(USB_VID_AMT,     USB_PID_ANYSEE) },
         { }             /* Terminating entry */
@@ -511,7 +511,7 @@ static struct dvb_usb_device_properties anysee_properties = {
                                 .endpoint = 0x82,
                                 .u = {
                                         .bulk = {
-                                                .buffersize = 512,
+                                                .buffersize = (16*512),
                                         }
                                 }
                         },
diff --git a/drivers/media/dvb/dvb-usb/ce6230.c b/drivers/media/dvb/dvb-usb/ce6230.c
index 52badc00e673..0737c6377892 100644
--- a/drivers/media/dvb/dvb-usb/ce6230.c
+++ b/drivers/media/dvb/dvb-usb/ce6230.c
@@ -274,7 +274,7 @@ static struct dvb_usb_device_properties ce6230_properties = {
                                 .endpoint = 0x82,
                                 .u = {
                                         .bulk = {
-                                                .buffersize = 512,
+                                                .buffersize = (16*512),
                                         }
                                 }
                         },
diff --git a/drivers/media/dvb/dvb-usb/dib0700_devices.c b/drivers/media/dvb/dvb-usb/dib0700_devices.c
index d1d6f4491403..0b2812aa30a4 100644
--- a/drivers/media/dvb/dvb-usb/dib0700_devices.c
+++ b/drivers/media/dvb/dvb-usb/dib0700_devices.c
@@ -4,13 +4,14 @@
  *      under the terms of the GNU General Public License as published by the Free
  *      Software Foundation, version 2.
  *
- *  Copyright (C) 2005-7 DiBcom, SA
+ *  Copyright (C) 2005-9 DiBcom, SA et al
  */
 #include "dib0700.h"
 
 #include "dib3000mc.h"
 #include "dib7000m.h"
 #include "dib7000p.h"
+#include "dib8000.h"
 #include "mt2060.h"
 #include "mt2266.h"
 #include "tuner-xc2028.h"
@@ -1098,11 +1099,13 @@ static struct dibx000_agc_config dib7070_agc_config = {
 
 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
 {
+        deb_info("reset: %d", onoff);
         return dib7000p_set_gpio(fe, 8, 0, !onoff);
 }
 
 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
 {
+        deb_info("sleep: %d", onoff);
         return dib7000p_set_gpio(fe, 9, 0, onoff);
 }
 
@@ -1112,16 +1115,26 @@ static struct dib0070_config dib7070p_dib0070_config[2] = {
                 .reset = dib7070_tuner_reset,
                 .sleep = dib7070_tuner_sleep,
                 .clock_khz = 12000,
-                .clock_pad_drive = 4
+                .clock_pad_drive = 4,
+                .charge_pump = 2,
         }, {
                 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
                 .reset = dib7070_tuner_reset,
                 .sleep = dib7070_tuner_sleep,
                 .clock_khz = 12000,
-
+                .charge_pump = 2,
         }
 };
 
+static struct dib0070_config dib7770p_dib0070_config = {
+         .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
+         .reset = dib7070_tuner_reset,
+         .sleep = dib7070_tuner_sleep,
+         .clock_khz = 12000,
+         .clock_pad_drive = 0,
+         .flip_chip = 1,
+};
+
 static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
 {
         struct dvb_usb_adapter *adap = fe->dvb->priv;
@@ -1139,6 +1152,45 @@ static int dib7070_set_param_override(struct dvb_frontend *fe, struct dvb_fronte
         return state->set_param_save(fe, fep);
 }
 
+static int dib7770_set_param_override(struct dvb_frontend *fe,
+                struct dvb_frontend_parameters *fep)
+{
+         struct dvb_usb_adapter *adap = fe->dvb->priv;
+         struct dib0700_adapter_state *state = adap->priv;
+
+         u16 offset;
+         u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
+         switch (band) {
+         case BAND_VHF:
+                  dib7000p_set_gpio(fe, 0, 0, 1);
+                  offset = 850;
+                  break;
+         case BAND_UHF:
+         default:
+                  dib7000p_set_gpio(fe, 0, 0, 0);
+                  offset = 250;
+                  break;
+         }
+         deb_info("WBD for DiB7000P: %d\n", offset + dib0070_wbd_offset(fe));
+         dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
+         return state->set_param_save(fe, fep);
+}
+
+static int dib7770p_tuner_attach(struct dvb_usb_adapter *adap)
+{
+         struct dib0700_adapter_state *st = adap->priv;
+         struct i2c_adapter *tun_i2c = dib7000p_get_i2c_master(adap->fe,
+                         DIBX000_I2C_INTERFACE_TUNER, 1);
+
+         if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
+                                 &dib7770p_dib0070_config) == NULL)
+                 return -ENODEV;
+
+         st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+         adap->fe->ops.tuner_ops.set_params = dib7770_set_param_override;
+         return 0;
+}
+
 static int dib7070p_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct dib0700_adapter_state *st = adap->priv;
@@ -1217,6 +1269,306 @@ static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap)
         return adap->fe == NULL ? -ENODEV : 0;
 }
 
+/* DIB807x generic */
+static struct dibx000_agc_config dib807x_agc_config[2] = {
+        {
+                BAND_VHF,
+                /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
+                 * P_agc_freq_pwm_div=1, 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=5,
+                 * P_agc_write=0 */
+                (0 << 15) | (0 << 14) | (7 << 11) | (0 << 10) | (0 << 9) |
+                        (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
+                        (0 << 0), /* setup*/
+
+                600, /* inv_gain*/
+                10,  /* time_stabiliz*/
+
+                0,  /* alpha_level*/
+                118,  /* thlock*/
+
+                0,     /* wbd_inv*/
+                3530,  /* wbd_ref*/
+                1,     /* wbd_sel*/
+                5,     /* wbd_alpha*/
+
+                65535,  /* agc1_max*/
+                0,  /* agc1_min*/
+
+                65535,  /* agc2_max*/
+                0,      /* agc2_min*/
+
+                0,      /* agc1_pt1*/
+                40,     /* agc1_pt2*/
+                183,    /* agc1_pt3*/
+                206,    /* agc1_slope1*/
+                255,    /* agc1_slope2*/
+                72,     /* agc2_pt1*/
+                152,    /* agc2_pt2*/
+                88,     /* agc2_slope1*/
+                90,     /* agc2_slope2*/
+
+                17,  /* alpha_mant*/
+                27,  /* alpha_exp*/
+                23,  /* beta_mant*/
+                51,  /* beta_exp*/
+
+                0,  /* perform_agc_softsplit*/
+        }, {
+                BAND_UHF,
+                /* P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0,
+                 * P_agc_freq_pwm_div=1, 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=5,
+                 * P_agc_write=0 */
+                (0 << 15) | (0 << 14) | (1 << 11) | (0 << 10) | (0 << 9) |
+                        (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) |
+                        (0 << 0), /* setup */
+
+                600, /* inv_gain*/
+                10,  /* time_stabiliz*/
+
+                0,  /* alpha_level*/
+                118,  /* thlock*/
+
+                0,     /* wbd_inv*/
+                3530,  /* wbd_ref*/
+                1,     /* wbd_sel*/
+                5,     /* wbd_alpha*/
+
+                65535,  /* agc1_max*/
+                0,  /* agc1_min*/
+
+                65535,  /* agc2_max*/
+                0,      /* agc2_min*/
+
+                0,      /* agc1_pt1*/
+                40,     /* agc1_pt2*/
+                183,    /* agc1_pt3*/
+                206,    /* agc1_slope1*/
+                255,    /* agc1_slope2*/
+                72,     /* agc2_pt1*/
+                152,    /* agc2_pt2*/
+                88,     /* agc2_slope1*/
+                90,     /* agc2_slope2*/
+
+                17,  /* alpha_mant*/
+                27,  /* alpha_exp*/
+                23,  /* beta_mant*/
+                51,  /* beta_exp*/
+
+                0,  /* perform_agc_softsplit*/
+        }
+};
+
+static struct dibx000_bandwidth_config dib807x_bw_config_12_mhz = {
+        60000, 15000, /* internal, sampling*/
+        1, 20, 3, 1, 0, /* pll_cfg: prediv, ratio, range, reset, bypass*/
+        0, 0, 1, 1, 2, /* misc: refdiv, bypclk_div, IO_CLK_en_core,
+                          ADClkSrc, modulo */
+        (3 << 14) | (1 << 12) | (599 << 0), /* sad_cfg: refsel, sel, freq_15k*/
+        (0 << 25) | 0, /* ifreq = 0.000000 MHz*/
+        18179755, /* timf*/
+        12000000, /* xtal_hz*/
+};
+
+static struct dib8000_config dib807x_dib8000_config[2] = {
+        {
+                .output_mpeg2_in_188_bytes = 1,
+
+                .agc_config_count = 2,
+                .agc = dib807x_agc_config,
+                .pll = &dib807x_bw_config_12_mhz,
+                .tuner_is_baseband = 1,
+
+                .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
+                .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
+                .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
+
+                .hostbus_diversity = 1,
+                .div_cfg = 1,
+                .agc_control = &dib0070_ctrl_agc_filter,
+                .output_mode = OUTMODE_MPEG2_FIFO,
+                .drives = 0x2d98,
+        }, {
+                .output_mpeg2_in_188_bytes = 1,
+
+                .agc_config_count = 2,
+                .agc = dib807x_agc_config,
+                .pll = &dib807x_bw_config_12_mhz,
+                .tuner_is_baseband = 1,
+
+                .gpio_dir = DIB8000_GPIO_DEFAULT_DIRECTIONS,
+                .gpio_val = DIB8000_GPIO_DEFAULT_VALUES,
+                .gpio_pwm_pos = DIB8000_GPIO_DEFAULT_PWM_POS,
+
+                .hostbus_diversity = 1,
+                .agc_control = &dib0070_ctrl_agc_filter,
+                .output_mode = OUTMODE_MPEG2_FIFO,
+                .drives = 0x2d98,
+        }
+};
+
+static int dib807x_tuner_reset(struct dvb_frontend *fe, int onoff)
+{
+        return dib8000_set_gpio(fe, 5, 0, !onoff);
+}
+
+static int dib807x_tuner_sleep(struct dvb_frontend *fe, int onoff)
+{
+        return dib8000_set_gpio(fe, 0, 0, onoff);
+}
+
+static const struct dib0070_wbd_gain_cfg dib8070_wbd_gain_cfg[] = {
+    { 240,      7},
+    { 0xffff,   6},
+};
+
+static struct dib0070_config dib807x_dib0070_config[2] = {
+        {
+                .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
+                .reset = dib807x_tuner_reset,
+                .sleep = dib807x_tuner_sleep,
+                .clock_khz = 12000,
+                .clock_pad_drive = 4,
+                .vga_filter = 1,
+                .force_crystal_mode = 1,
+                .enable_third_order_filter = 1,
+                .charge_pump = 0,
+                .wbd_gain = dib8070_wbd_gain_cfg,
+                .osc_buffer_state = 0,
+                .freq_offset_khz_uhf = -100,
+                .freq_offset_khz_vhf = -100,
+        }, {
+                .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
+                .reset = dib807x_tuner_reset,
+                .sleep = dib807x_tuner_sleep,
+                .clock_khz = 12000,
+                .clock_pad_drive = 2,
+                .vga_filter = 1,
+                .force_crystal_mode = 1,
+                .enable_third_order_filter = 1,
+                .charge_pump = 0,
+                .wbd_gain = dib8070_wbd_gain_cfg,
+                .osc_buffer_state = 0,
+                .freq_offset_khz_uhf = -25,
+                .freq_offset_khz_vhf = -25,
+        }
+};
+
+static int dib807x_set_param_override(struct dvb_frontend *fe,
+                struct dvb_frontend_parameters *fep)
+{
+        struct dvb_usb_adapter *adap = fe->dvb->priv;
+        struct dib0700_adapter_state *state = adap->priv;
+
+        u16 offset = dib0070_wbd_offset(fe);
+        u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
+        switch (band) {
+        case BAND_VHF:
+                offset += 750;
+                break;
+        case BAND_UHF:  /* fall-thru wanted */
+        default:
+                offset += 250; break;
+        }
+        deb_info("WBD for DiB8000: %d\n", offset);
+        dib8000_set_wbd_ref(fe, offset);
+
+        return state->set_param_save(fe, fep);
+}
+
+static int dib807x_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        struct dib0700_adapter_state *st = adap->priv;
+        struct i2c_adapter *tun_i2c = dib8000_get_i2c_master(adap->fe,
+                        DIBX000_I2C_INTERFACE_TUNER, 1);
+
+        if (adap->id == 0) {
+                if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
+                                &dib807x_dib0070_config[0]) == NULL)
+                        return -ENODEV;
+        } else {
+                if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
+                                &dib807x_dib0070_config[1]) == NULL)
+                        return -ENODEV;
+        }
+
+        st->set_param_save = adap->fe->ops.tuner_ops.set_params;
+        adap->fe->ops.tuner_ops.set_params = dib807x_set_param_override;
+        return 0;
+}
+
+
+/* STK807x */
+static int stk807x_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(10);
+        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);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
+                                0x80);
+
+        adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
+                              &dib807x_dib8000_config[0]);
+
+        return adap->fe == NULL ?  -ENODEV : 0;
+}
+
+/* STK807xPVR */
+static int stk807xpvr_frontend_attach0(struct dvb_usb_adapter *adap)
+{
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0);
+        msleep(30);
+        dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1);
+        msleep(500);
+        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);
+
+        dib0700_ctrl_clock(adap->dev, 72, 1);
+
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1);
+        msleep(10);
+        dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1);
+
+        /* initialize IC 0 */
+        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x12, 0x80);
+
+        adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x80,
+                              &dib807x_dib8000_config[0]);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+static int stk807xpvr_frontend_attach1(struct dvb_usb_adapter *adap)
+{
+        /* initialize IC 1 */
+        dib8000_i2c_enumeration(&adap->dev->i2c_adap, 1, 0x22, 0x82);
+
+        adap->fe = dvb_attach(dib8000_attach, &adap->dev->i2c_adap, 0x82,
+                              &dib807x_dib8000_config[1]);
+
+        return adap->fe == NULL ? -ENODEV : 0;
+}
+
+
 /* STK7070PD */
 static struct dib7000p_config stk7070pd_dib7000p_config[2] = {
         {
@@ -1500,7 +1852,15 @@ struct usb_device_id dib0700_usb_id_table[] = {
         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T3) },
         { USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_T5) },
         { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D) },
-        { USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
+/* 55 */{ USB_DEVICE(USB_VID_YUAN,      USB_PID_YUAN_STK7700D_2) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73A) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV73ESE) },
+        { USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV282E) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK7770P) },
+/* 60 */{ USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_XXS_2) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XPVR) },
+        { USB_DEVICE(USB_VID_DIBCOM,    USB_PID_DIBCOM_STK807XP) },
+        { USB_DEVICE(USB_VID_PIXELVIEW, USB_PID_PIXELVIEW_SBTVD) },
         { 0 }           /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table);
@@ -1565,7 +1925,7 @@ struct dvb_usb_device_properties dib0700_devices[] = {
                                 { NULL },
                         },
                         {   "Leadtek Winfast DTV Dongle (STK7700P based)",
-                                { &dib0700_usb_id_table[8], &dib0700_usb_id_table[34] },
+                                { &dib0700_usb_id_table[8] },
                                 { NULL },
                         },
                         {   "AVerMedia AVerTV DVB-T Express",
@@ -1764,6 +2124,41 @@ struct dvb_usb_device_properties dib0700_devices[] = {
 
         }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
 
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .frontend_attach  = stk7070p_frontend_attach,
+                                .tuner_attach     = dib7070p_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv     = sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 3,
+                .devices = {
+                        {   "Pinnacle PCTV 73A",
+                                { &dib0700_usb_id_table[56], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV 73e SE",
+                                { &dib0700_usb_id_table[57], NULL },
+                                { NULL },
+                        },
+                        {   "Pinnacle PCTV 282e",
+                                { &dib0700_usb_id_table[58], 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
+
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
                 .num_adapters = 2,
                 .adapter = {
                         {
@@ -1927,6 +2322,102 @@ struct dvb_usb_device_properties dib0700_devices[] = {
                                 { NULL },
                         },
                 },
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .frontend_attach  = stk7070p_frontend_attach,
+                                .tuner_attach     = dib7770p_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 2,
+                .devices = {
+                        {   "DiBcom STK7770P reference design",
+                                { &dib0700_usb_id_table[59], NULL },
+                                { NULL },
+                        },
+                        {   "Terratec Cinergy T USB XXS (HD)",
+                                { &dib0700_usb_id_table[34], &dib0700_usb_id_table[60] },
+                                { 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
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 1,
+                .adapter = {
+                        {
+                                .frontend_attach  = stk807x_frontend_attach,
+                                .tuner_attach     = dib807x_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 2,
+                .devices = {
+                        {   "DiBcom STK807xP reference design",
+                                { &dib0700_usb_id_table[62], NULL },
+                                { NULL },
+                        },
+                        {   "Prolink Pixelview SBTVD",
+                                { &dib0700_usb_id_table[63], 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
+
+        }, { DIB0700_DEFAULT_DEVICE_PROPERTIES,
+                .num_adapters = 2,
+                .adapter = {
+                        {
+                                .frontend_attach  = stk807xpvr_frontend_attach0,
+                                .tuner_attach     = dib807x_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x02),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                        {
+                                .frontend_attach  = stk807xpvr_frontend_attach1,
+                                .tuner_attach     = dib807x_tuner_attach,
+
+                                DIB0700_DEFAULT_STREAMING_CONFIG(0x03),
+
+                                .size_of_priv =
+                                        sizeof(struct dib0700_adapter_state),
+                        },
+                },
+
+                .num_device_descs = 1,
+                .devices = {
+                        {   "DiBcom STK807xPVR reference design",
+                                { &dib0700_usb_id_table[61], 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/dvb-usb-ids.h b/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
index 185a5069b10b..a548c14c1944 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
@@ -46,6 +46,7 @@
 #define USB_VID_MSI_2                           0x1462
 #define USB_VID_OPERA1                          0x695c
 #define USB_VID_PINNACLE                        0x2304
+#define USB_VID_PIXELVIEW                       0x1554
 #define USB_VID_TECHNOTREND                     0x0b48
 #define USB_VID_TERRATEC                        0x0ccd
 #define USB_VID_TELESTAR                        0x10b9
@@ -59,6 +60,7 @@
 #define USB_VID_YUAN                            0x1164
 #define USB_VID_XTENSIONS                       0x1ae7
 #define USB_VID_HUMAX_COEX                      0x10b9
+#define USB_VID_774                             0x7a69
 
 /* Product IDs */
 #define USB_PID_ADSTECH_USB2_COLD                       0xa333
@@ -95,7 +97,10 @@
 #define USB_PID_DIBCOM_STK7700_U7000                    0x7001
 #define USB_PID_DIBCOM_STK7070P                         0x1ebc
 #define USB_PID_DIBCOM_STK7070PD                        0x1ebe
+#define USB_PID_DIBCOM_STK807XP                         0x1f90
+#define USB_PID_DIBCOM_STK807XPVR                       0x1f98
 #define USB_PID_DIBCOM_ANCHOR_2135_COLD                 0x2131
+#define USB_PID_DIBCOM_STK7770P                         0x1e80
 #define USB_PID_DPOSH_M9206_COLD                        0x9206
 #define USB_PID_DPOSH_M9206_WARM                        0xa090
 #define USB_PID_UNIWILL_STK7700P                        0x6003
@@ -184,6 +189,7 @@
 #define USB_PID_TERRATEC_CINERGY_HT_EXPRESS             0x0060
 #define USB_PID_TERRATEC_CINERGY_T_EXPRESS              0x0062
 #define USB_PID_TERRATEC_CINERGY_T_XXS                  0x0078
+#define USB_PID_TERRATEC_CINERGY_T_XXS_2                0x00ab
 #define USB_PID_TERRATEC_T3                             0x10a0
 #define USB_PID_TERRATEC_T5                             0x10a1
 #define USB_PID_PINNACLE_EXPRESSCARD_320CX              0x022e
@@ -195,6 +201,10 @@
 #define USB_PID_PINNACLE_PCTV73E                        0x0237
 #define USB_PID_PINNACLE_PCTV801E                       0x023a
 #define USB_PID_PINNACLE_PCTV801E_SE                    0x023b
+#define USB_PID_PINNACLE_PCTV73A                        0x0243
+#define USB_PID_PINNACLE_PCTV73ESE                      0x0245
+#define USB_PID_PINNACLE_PCTV282E                       0x0248
+#define USB_PID_PIXELVIEW_SBTVD                         0x5010
 #define USB_PID_PCTV_200E                               0x020e
 #define USB_PID_PCTV_400E                               0x020f
 #define USB_PID_PCTV_450E                               0x0222
@@ -265,5 +275,6 @@
 #define USB_PID_ELGATO_EYETV_DTT_Dlx                    0x0020
 #define USB_PID_DVB_T_USB_STICK_HIGH_SPEED_COLD         0x5000
 #define USB_PID_DVB_T_USB_STICK_HIGH_SPEED_WARM         0x5001
+#define USB_PID_FRIIO_WHITE                             0x0001
 
 #endif
diff --git a/drivers/media/dvb/dvb-usb/friio-fe.c b/drivers/media/dvb/dvb-usb/friio-fe.c
new file mode 100644
index 000000000000..c4dfe25cf60d
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/friio-fe.c
@@ -0,0 +1,483 @@
+/* DVB USB compliant Linux driver for the Friio USB2.0 ISDB-T receiver.
+ *
+ * Copyright (C) 2009 Akihiro Tsukada <tskd2@yahoo.co.jp>
+ *
+ * This module is based off the the gl861 and vp702x modules.
+ *
+ * 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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+
+#include "friio.h"
+
+struct jdvbt90502_state {
+        struct i2c_adapter *i2c;
+        struct dvb_frontend frontend;
+        struct jdvbt90502_config config;
+};
+
+/* NOTE: TC90502 has 16bit register-address? */
+/* register 0x0100 is used for reading PLL status, so reg is u16 here */
+static int jdvbt90502_reg_read(struct jdvbt90502_state *state,
+                               const u16 reg, u8 *buf, const size_t count)
+{
+        int ret;
+        u8 wbuf[3];
+        struct i2c_msg msg[2];
+
+        wbuf[0] = reg & 0xFF;
+        wbuf[1] = 0;
+        wbuf[2] = reg >> 8;
+
+        msg[0].addr = state->config.demod_address;
+        msg[0].flags = 0;
+        msg[0].buf = wbuf;
+        msg[0].len = sizeof(wbuf);
+
+        msg[1].addr = msg[0].addr;
+        msg[1].flags = I2C_M_RD;
+        msg[1].buf = buf;
+        msg[1].len = count;
+
+        ret = i2c_transfer(state->i2c, msg, 2);
+        if (ret != 2) {
+                deb_fe(" reg read failed.\n");
+                return -EREMOTEIO;
+        }
+        return 0;
+}
+
+/* currently 16bit register-address is not used, so reg is u8 here */
+static int jdvbt90502_single_reg_write(struct jdvbt90502_state *state,
+                                       const u8 reg, const u8 val)
+{
+        struct i2c_msg msg;
+        u8 wbuf[2];
+
+        wbuf[0] = reg;
+        wbuf[1] = val;
+
+        msg.addr = state->config.demod_address;
+        msg.flags = 0;
+        msg.buf = wbuf;
+        msg.len = sizeof(wbuf);
+
+        if (i2c_transfer(state->i2c, &msg, 1) != 1) {
+                deb_fe(" reg write failed.");
+                return -EREMOTEIO;
+        }
+        return 0;
+}
+
+static int _jdvbt90502_write(struct dvb_frontend *fe, u8 *buf, int len)
+{
+        struct jdvbt90502_state *state = fe->demodulator_priv;
+        int err, i;
+        for (i = 0; i < len - 1; i++) {
+                err = jdvbt90502_single_reg_write(state,
+                                                  buf[0] + i, buf[i + 1]);
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
+/* read pll status byte via the demodulator's I2C register */
+/* note: Win box reads it by 8B block at the I2C addr 0x30 from reg:0x80 */
+static int jdvbt90502_pll_read(struct jdvbt90502_state *state, u8 *result)
+{
+        int ret;
+
+        /* +1 for reading */
+        u8 pll_addr_byte = (state->config.pll_address << 1) + 1;
+
+        *result = 0;
+
+        ret = jdvbt90502_single_reg_write(state, JDVBT90502_2ND_I2C_REG,
+                                          pll_addr_byte);
+        if (ret)
+                goto error;
+
+        ret = jdvbt90502_reg_read(state, 0x0100, result, 1);
+        if (ret)
+                goto error;
+
+        deb_fe("PLL read val:%02x\n", *result);
+        return 0;
+
+error:
+        deb_fe("%s:ret == %d\n", __func__, ret);
+        return -EREMOTEIO;
+}
+
+
+/* set pll frequency via the demodulator's I2C register */
+static int jdvbt90502_pll_set_freq(struct jdvbt90502_state *state, u32 freq)
+{
+        int ret;
+        int retry;
+        u8 res1;
+        u8 res2[9];
+
+        u8 pll_freq_cmd[PLL_CMD_LEN];
+        u8 pll_agc_cmd[PLL_CMD_LEN];
+        struct i2c_msg msg[2];
+        u32 f;
+
+        deb_fe("%s: freq=%d, step=%d\n", __func__, freq,
+               state->frontend.ops.info.frequency_stepsize);
+        /* freq -> oscilator frequency conversion. */
+        /* freq: 473,000,000 + n*6,000,000 (no 1/7MHz shift to center freq) */
+        /* add 400[1/7 MHZ] = 57.142857MHz.   57MHz for the IF,  */
+        /*                                   1/7MHz for center freq shift */
+        f = freq / state->frontend.ops.info.frequency_stepsize;
+        f += 400;
+        pll_freq_cmd[DEMOD_REDIRECT_REG] = JDVBT90502_2ND_I2C_REG; /* 0xFE */
+        pll_freq_cmd[ADDRESS_BYTE] = state->config.pll_address << 1;
+        pll_freq_cmd[DIVIDER_BYTE1] = (f >> 8) & 0x7F;
+        pll_freq_cmd[DIVIDER_BYTE2] = f & 0xFF;
+        pll_freq_cmd[CONTROL_BYTE] = 0xB2; /* ref.divider:28, 4MHz/28=1/7MHz */
+        pll_freq_cmd[BANDSWITCH_BYTE] = 0x08;   /* UHF band */
+
+        msg[0].addr = state->config.demod_address;
+        msg[0].flags = 0;
+        msg[0].buf = pll_freq_cmd;
+        msg[0].len = sizeof(pll_freq_cmd);
+
+        ret = i2c_transfer(state->i2c, &msg[0], 1);
+        if (ret != 1)
+                goto error;
+
+        udelay(50);
+
+        pll_agc_cmd[DEMOD_REDIRECT_REG] = pll_freq_cmd[DEMOD_REDIRECT_REG];
+        pll_agc_cmd[ADDRESS_BYTE] = pll_freq_cmd[ADDRESS_BYTE];
+        pll_agc_cmd[DIVIDER_BYTE1] = pll_freq_cmd[DIVIDER_BYTE1];
+        pll_agc_cmd[DIVIDER_BYTE2] = pll_freq_cmd[DIVIDER_BYTE2];
+        pll_agc_cmd[CONTROL_BYTE] = 0x9A; /*  AGC_CTRL instead of BANDSWITCH */
+        pll_agc_cmd[AGC_CTRL_BYTE] = 0x50;
+        /* AGC Time Constant 2s, AGC take-over point:103dBuV(lowest) */
+
+        msg[1].addr = msg[0].addr;
+        msg[1].flags = 0;
+        msg[1].buf = pll_agc_cmd;
+        msg[1].len = sizeof(pll_agc_cmd);
+
+        ret = i2c_transfer(state->i2c, &msg[1], 1);
+        if (ret != 1)
+                goto error;
+
+        /* I don't know what these cmds are for,  */
+        /* but the USB log on a windows box contains them */
+        ret = jdvbt90502_single_reg_write(state, 0x01, 0x40);
+        ret |= jdvbt90502_single_reg_write(state, 0x01, 0x00);
+        if (ret)
+                goto error;
+        udelay(100);
+
+        /* wait for the demod to be ready? */
+#define RETRY_COUNT 5
+        for (retry = 0; retry < RETRY_COUNT; retry++) {
+                ret = jdvbt90502_reg_read(state, 0x0096, &res1, 1);
+                if (ret)
+                        goto error;
+                /* if (res1 != 0x00) goto error; */
+                ret = jdvbt90502_reg_read(state, 0x00B0, res2, sizeof(res2));
+                if (ret)
+                        goto error;
+                if (res2[0] >= 0xA7)
+                        break;
+                msleep(100);
+        }
+        if (retry >= RETRY_COUNT) {
+                deb_fe("%s: FE does not get ready after freq setting.\n",
+                       __func__);
+                return -EREMOTEIO;
+        }
+
+        return 0;
+error:
+        deb_fe("%s:ret == %d\n", __func__, ret);
+        return -EREMOTEIO;
+}
+
+static int jdvbt90502_read_status(struct dvb_frontend *fe, fe_status_t *state)
+{
+        u8 result;
+        int ret;
+
+        *state = FE_HAS_SIGNAL;
+
+        ret = jdvbt90502_pll_read(fe->demodulator_priv, &result);
+        if (ret) {
+                deb_fe("%s:ret == %d\n", __func__, ret);
+                return -EREMOTEIO;
+        }
+
+        *state = FE_HAS_SIGNAL
+                | FE_HAS_CARRIER
+                | FE_HAS_VITERBI
+                | FE_HAS_SYNC;
+
+        if (result & PLL_STATUS_LOCKED)
+                *state |= FE_HAS_LOCK;
+
+        return 0;
+}
+
+static int jdvbt90502_read_ber(struct dvb_frontend *fe, u32 *ber)
+{
+        *ber = 0;
+        return 0;
+}
+
+static int jdvbt90502_read_signal_strength(struct dvb_frontend *fe,
+                                           u16 *strength)
+{
+        int ret;
+        u8 rbuf[37];
+
+        *strength = 0;
+
+        /* status register (incl. signal strength) : 0x89  */
+        /* TODO: read just the necessary registers [0x8B..0x8D]? */
+        ret = jdvbt90502_reg_read(fe->demodulator_priv, 0x0089,
+                                  rbuf, sizeof(rbuf));
+
+        if (ret) {
+                deb_fe("%s:ret == %d\n", __func__, ret);
+                return -EREMOTEIO;
+        }
+
+        /* signal_strength: rbuf[2-4] (24bit BE), use lower 16bit for now. */
+        *strength = (rbuf[3] << 8) + rbuf[4];
+        if (rbuf[2])
+                *strength = 0xffff;
+
+        return 0;
+}
+
+static int jdvbt90502_read_snr(struct dvb_frontend *fe, u16 *snr)
+{
+        *snr = 0x0101;
+        return 0;
+}
+
+static int jdvbt90502_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
+{
+        *ucblocks = 0;
+        return 0;
+}
+
+static int jdvbt90502_get_tune_settings(struct dvb_frontend *fe,
+                                        struct dvb_frontend_tune_settings *fs)
+{
+        fs->min_delay_ms = 500;
+        fs->step_size = 0;
+        fs->max_drift = 0;
+
+        return 0;
+}
+
+static int jdvbt90502_get_frontend(struct dvb_frontend *fe,
+                                   struct dvb_frontend_parameters *p)
+{
+        p->inversion = INVERSION_AUTO;
+        p->u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
+        p->u.ofdm.code_rate_HP = FEC_AUTO;
+        p->u.ofdm.code_rate_LP = FEC_AUTO;
+        p->u.ofdm.constellation = QAM_64;
+        p->u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO;
+        p->u.ofdm.guard_interval = GUARD_INTERVAL_AUTO;
+        p->u.ofdm.hierarchy_information = HIERARCHY_AUTO;
+        return 0;
+}
+
+static int jdvbt90502_set_frontend(struct dvb_frontend *fe,
+                                   struct dvb_frontend_parameters *p)
+{
+        /**
+         * NOTE: ignore all the paramters except frequency.
+         *       others should be fixed to the proper value for ISDB-T,
+         *       but don't check here.
+         */
+
+        struct jdvbt90502_state *state = fe->demodulator_priv;
+        int ret;
+
+        deb_fe("%s: Freq:%d\n", __func__, p->frequency);
+
+        ret = jdvbt90502_pll_set_freq(state, p->frequency);
+        if (ret) {
+                deb_fe("%s:ret == %d\n", __func__, ret);
+                return -EREMOTEIO;
+        }
+
+        return 0;
+}
+
+static int jdvbt90502_sleep(struct dvb_frontend *fe)
+{
+        deb_fe("%s called.\n", __func__);
+        return 0;
+}
+
+
+/**
+ * (reg, val) commad list to initialize this module.
+ *  captured on a Windows box.
+ */
+static u8 init_code[][2] = {
+        {0x01, 0x40},
+        {0x04, 0x38},
+        {0x05, 0x40},
+        {0x07, 0x40},
+        {0x0F, 0x4F},
+        {0x11, 0x21},
+        {0x12, 0x0B},
+        {0x13, 0x2F},
+        {0x14, 0x31},
+        {0x16, 0x02},
+        {0x21, 0xC4},
+        {0x22, 0x20},
+        {0x2C, 0x79},
+        {0x2D, 0x34},
+        {0x2F, 0x00},
+        {0x30, 0x28},
+        {0x31, 0x31},
+        {0x32, 0xDF},
+        {0x38, 0x01},
+        {0x39, 0x78},
+        {0x3B, 0x33},
+        {0x3C, 0x33},
+        {0x48, 0x90},
+        {0x51, 0x68},
+        {0x5E, 0x38},
+        {0x71, 0x00},
+        {0x72, 0x08},
+        {0x77, 0x00},
+        {0xC0, 0x21},
+        {0xC1, 0x10},
+        {0xE4, 0x1A},
+        {0xEA, 0x1F},
+        {0x77, 0x00},
+        {0x71, 0x00},
+        {0x71, 0x00},
+        {0x76, 0x0C},
+};
+
+const static int init_code_len = sizeof(init_code) / sizeof(u8[2]);
+
+static int jdvbt90502_init(struct dvb_frontend *fe)
+{
+        int i = -1;
+        int ret;
+        struct i2c_msg msg;
+
+        struct jdvbt90502_state *state = fe->demodulator_priv;
+
+        deb_fe("%s called.\n", __func__);
+
+        msg.addr = state->config.demod_address;
+        msg.flags = 0;
+        msg.len = 2;
+        for (i = 0; i < init_code_len; i++) {
+                msg.buf = init_code[i];
+                ret = i2c_transfer(state->i2c, &msg, 1);
+                if (ret != 1)
+                        goto error;
+        }
+        msleep(100);
+
+        return 0;
+
+error:
+        deb_fe("%s: init_code[%d] failed. ret==%d\n", __func__, i, ret);
+        return -EREMOTEIO;
+}
+
+
+static void jdvbt90502_release(struct dvb_frontend *fe)
+{
+        struct jdvbt90502_state *state = fe->demodulator_priv;
+        kfree(state);
+}
+
+
+static struct dvb_frontend_ops jdvbt90502_ops;
+
+struct dvb_frontend *jdvbt90502_attach(struct dvb_usb_device *d)
+{
+        struct jdvbt90502_state *state = NULL;
+
+        deb_info("%s called.\n", __func__);
+
+        /* allocate memory for the internal state */
+        state = kzalloc(sizeof(struct jdvbt90502_state), GFP_KERNEL);
+        if (state == NULL)
+                goto error;
+
+        /* setup the state */
+        state->i2c = &d->i2c_adap;
+        memcpy(&state->config, &friio_fe_config, sizeof(friio_fe_config));
+
+        /* create dvb_frontend */
+        memcpy(&state->frontend.ops, &jdvbt90502_ops,
+               sizeof(jdvbt90502_ops));
+        state->frontend.demodulator_priv = state;
+
+        if (jdvbt90502_init(&state->frontend) < 0)
+                goto error;
+
+        return &state->frontend;
+
+error:
+        kfree(state);
+        return NULL;
+}
+
+static struct dvb_frontend_ops jdvbt90502_ops = {
+
+        .info = {
+                .name                   = "Comtech JDVBT90502 ISDB-T",
+                .type                   = FE_OFDM,
+                .frequency_min          = 473000000, /* UHF 13ch, center */
+                .frequency_max          = 767142857, /* UHF 62ch, center */
+                .frequency_stepsize     = JDVBT90502_PLL_CLK /
+                                                        JDVBT90502_PLL_DIVIDER,
+                .frequency_tolerance    = 0,
+
+                /* NOTE: this driver ignores all parameters but frequency. */
+                .caps = FE_CAN_INVERSION_AUTO |
+                        FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                        FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
+                        FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | FE_CAN_FEC_AUTO |
+                        FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
+                        FE_CAN_TRANSMISSION_MODE_AUTO |
+                        FE_CAN_GUARD_INTERVAL_AUTO |
+                        FE_CAN_HIERARCHY_AUTO,
+        },
+
+        .release = jdvbt90502_release,
+
+        .init = jdvbt90502_init,
+        .sleep = jdvbt90502_sleep,
+        .write = _jdvbt90502_write,
+
+        .set_frontend = jdvbt90502_set_frontend,
+        .get_frontend = jdvbt90502_get_frontend,
+        .get_tune_settings = jdvbt90502_get_tune_settings,
+
+        .read_status = jdvbt90502_read_status,
+        .read_ber = jdvbt90502_read_ber,
+        .read_signal_strength = jdvbt90502_read_signal_strength,
+        .read_snr = jdvbt90502_read_snr,
+        .read_ucblocks = jdvbt90502_read_ucblocks,
+};
diff --git a/drivers/media/dvb/dvb-usb/friio.c b/drivers/media/dvb/dvb-usb/friio.c
new file mode 100644
index 000000000000..14a65b4aec07
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/friio.c
@@ -0,0 +1,525 @@
+/* DVB USB compliant Linux driver for the Friio USB2.0 ISDB-T receiver.
+ *
+ * Copyright (C) 2009 Akihiro Tsukada <tskd2@yahoo.co.jp>
+ *
+ * This module is based off the the gl861 and vp702x modules.
+ *
+ * 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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#include "friio.h"
+
+/* debug */
+int dvb_usb_friio_debug;
+module_param_named(debug, dvb_usb_friio_debug, int, 0644);
+MODULE_PARM_DESC(debug,
+                 "set debugging level (1=info,2=xfer,4=rc,8=fe (or-able))."
+                 DVB_USB_DEBUG_STATUS);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+/**
+ * Indirect I2C access to the PLL via FE.
+ * whole I2C protocol data to the PLL is sent via the FE's I2C register.
+ * This is done by a control msg to the FE with the I2C data accompanied, and
+ * a specific USB request number is assigned for that purpose.
+ *
+ * this func sends wbuf[1..] to the I2C register wbuf[0] at addr (= at FE).
+ * TODO: refoctored, smarter i2c functions.
+ */
+static int gl861_i2c_ctrlmsg_data(struct dvb_usb_device *d, u8 addr,
+                                  u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
+{
+        u16 index = wbuf[0];    /* must be JDVBT90502_2ND_I2C_REG(=0xFE) */
+        u16 value = addr << (8 + 1);
+        int wo = (rbuf == NULL || rlen == 0);   /* write only */
+        u8 req, type;
+
+        deb_xfer("write to PLL:0x%02x via FE reg:0x%02x, len:%d\n",
+                 wbuf[1], wbuf[0], wlen - 1);
+
+        if (wo && wlen >= 2) {
+                req = GL861_REQ_I2C_DATA_CTRL_WRITE;
+                type = GL861_WRITE;
+                udelay(20);
+                return usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+                                       req, type, value, index,
+                                       &wbuf[1], wlen - 1, 2000);
+        }
+
+        deb_xfer("not supported ctrl-msg, aborting.");
+        return -EINVAL;
+}
+
+/* normal I2C access (without extra data arguments).
+ * write to the register wbuf[0] at I2C address addr with the value wbuf[1],
+ *  or read from the register wbuf[0].
+ * register address can be 16bit (wbuf[2]<<8 | wbuf[0]) if wlen==3
+ */
+static int gl861_i2c_msg(struct dvb_usb_device *d, u8 addr,
+                         u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
+{
+        u16 index;
+        u16 value = addr << (8 + 1);
+        int wo = (rbuf == NULL || rlen == 0);   /* write-only */
+        u8 req, type;
+        unsigned int pipe;
+
+        /* special case for the indirect I2C access to the PLL via FE, */
+        if (addr == friio_fe_config.demod_address &&
+            wbuf[0] == JDVBT90502_2ND_I2C_REG)
+                return gl861_i2c_ctrlmsg_data(d, addr, wbuf, wlen, rbuf, rlen);
+
+        if (wo) {
+                req = GL861_REQ_I2C_WRITE;
+                type = GL861_WRITE;
+                pipe = usb_sndctrlpipe(d->udev, 0);
+        } else {                /* rw */
+                req = GL861_REQ_I2C_READ;
+                type = GL861_READ;
+                pipe = usb_rcvctrlpipe(d->udev, 0);
+        }
+
+        switch (wlen) {
+        case 1:
+                index = wbuf[0];
+                break;
+        case 2:
+                index = wbuf[0];
+                value = value + wbuf[1];
+                break;
+        case 3:
+                /* special case for 16bit register-address */
+                index = (wbuf[2] << 8) | wbuf[0];
+                value = value + wbuf[1];
+                break;
+        default:
+                deb_xfer("wlen = %x, aborting.", wlen);
+                return -EINVAL;
+        }
+        msleep(1);
+        return usb_control_msg(d->udev, pipe, req, type,
+                               value, index, rbuf, rlen, 2000);
+}
+
+/* I2C */
+static int gl861_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
+                          int num)
+{
+        struct dvb_usb_device *d = i2c_get_adapdata(adap);
+        int i;
+
+
+        if (num > 2)
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
+                return -EAGAIN;
+
+        for (i = 0; i < num; i++) {
+                /* write/read request */
+                if (i + 1 < num && (msg[i + 1].flags & I2C_M_RD)) {
+                        if (gl861_i2c_msg(d, msg[i].addr,
+                                          msg[i].buf, msg[i].len,
+                                          msg[i + 1].buf, msg[i + 1].len) < 0)
+                                break;
+                        i++;
+                } else
+                        if (gl861_i2c_msg(d, msg[i].addr, msg[i].buf,
+                                          msg[i].len, NULL, 0) < 0)
+                                break;
+        }
+
+        mutex_unlock(&d->i2c_mutex);
+        return i;
+}
+
+static u32 gl861_i2c_func(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C;
+}
+
+
+static int friio_ext_ctl(struct dvb_usb_adapter *adap,
+                         u32 sat_color, int lnb_on)
+{
+        int i;
+        int ret;
+        struct i2c_msg msg;
+        u8 buf[2];
+        u32 mask;
+        u8 lnb = (lnb_on) ? FRIIO_CTL_LNB : 0;
+
+        msg.addr = 0x00;
+        msg.flags = 0;
+        msg.len = 2;
+        msg.buf = buf;
+
+        buf[0] = 0x00;
+
+        /* send 2bit header (&B10) */
+        buf[1] = lnb | FRIIO_CTL_LED | FRIIO_CTL_STROBE;
+        ret = gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+        buf[1] |= FRIIO_CTL_CLK;
+        ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+
+        buf[1] = lnb | FRIIO_CTL_STROBE;
+        ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+        buf[1] |= FRIIO_CTL_CLK;
+        ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+
+        /* send 32bit(satur, R, G, B) data in serial */
+        mask = 1 << 31;
+        for (i = 0; i < 32; i++) {
+                buf[1] = lnb | FRIIO_CTL_STROBE;
+                if (sat_color & mask)
+                        buf[1] |= FRIIO_CTL_LED;
+                ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+                buf[1] |= FRIIO_CTL_CLK;
+                ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+                mask >>= 1;
+        }
+
+        /* set the strobe off */
+        buf[1] = lnb;
+        ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+        buf[1] |= FRIIO_CTL_CLK;
+        ret += gl861_i2c_xfer(&adap->dev->i2c_adap, &msg, 1);
+
+        return (ret == 70);
+}
+
+
+static int friio_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff);
+
+/* TODO: move these init cmds to the FE's init routine? */
+static u8 streaming_init_cmds[][2] = {
+        {0x33, 0x08},
+        {0x37, 0x40},
+        {0x3A, 0x1F},
+        {0x3B, 0xFF},
+        {0x3C, 0x1F},
+        {0x3D, 0xFF},
+        {0x38, 0x00},
+        {0x35, 0x00},
+        {0x39, 0x00},
+        {0x36, 0x00},
+};
+static int cmdlen = sizeof(streaming_init_cmds) / 2;
+
+/*
+ * Command sequence in this init function is a replay
+ *  of the captured USB commands from the Windows proprietary driver.
+ */
+static int friio_initialize(struct dvb_usb_device *d)
+{
+        int ret;
+        int i;
+        int retry = 0;
+        u8 rbuf[2];
+        u8 wbuf[3];
+
+        deb_info("%s called.\n", __func__);
+
+        /* use gl861_i2c_msg instead of gl861_i2c_xfer(), */
+        /* because the i2c device is not set up yet. */
+        wbuf[0] = 0x11;
+        wbuf[1] = 0x02;
+        ret = gl861_i2c_msg(d, 0x00, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+        msleep(2);
+
+        wbuf[0] = 0x11;
+        wbuf[1] = 0x00;
+        ret = gl861_i2c_msg(d, 0x00, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+        msleep(1);
+
+        /* following msgs should be in the FE's init code? */
+        /* cmd sequence to identify the device type? (friio black/white) */
+        wbuf[0] = 0x03;
+        wbuf[1] = 0x80;
+        /* can't use gl861_i2c_cmd, as the register-addr is 16bit(0x0100) */
+        ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+                              GL861_REQ_I2C_DATA_CTRL_WRITE, GL861_WRITE,
+                              0x1200, 0x0100, wbuf, 2, 2000);
+        if (ret < 0)
+                goto error;
+
+        msleep(2);
+        wbuf[0] = 0x00;
+        wbuf[2] = 0x01;         /* reg.0x0100 */
+        wbuf[1] = 0x00;
+        ret = gl861_i2c_msg(d, 0x12 >> 1, wbuf, 3, rbuf, 2);
+        /* my Friio White returns 0xffff. */
+        if (ret < 0 || rbuf[0] != 0xff || rbuf[1] != 0xff)
+                goto error;
+
+        msleep(2);
+        wbuf[0] = 0x03;
+        wbuf[1] = 0x80;
+        ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+                              GL861_REQ_I2C_DATA_CTRL_WRITE, GL861_WRITE,
+                              0x9000, 0x0100, wbuf, 2, 2000);
+        if (ret < 0)
+                goto error;
+
+        msleep(2);
+        wbuf[0] = 0x00;
+        wbuf[2] = 0x01;         /* reg.0x0100 */
+        wbuf[1] = 0x00;
+        ret = gl861_i2c_msg(d, 0x90 >> 1, wbuf, 3, rbuf, 2);
+        /* my Friio White returns 0xffff again. */
+        if (ret < 0 || rbuf[0] != 0xff || rbuf[1] != 0xff)
+                goto error;
+
+        msleep(1);
+
+restart:
+        /* ============ start DEMOD init cmds ================== */
+        /* read PLL status to clear the POR bit */
+        wbuf[0] = JDVBT90502_2ND_I2C_REG;
+        wbuf[1] = (FRIIO_PLL_ADDR << 1) + 1;    /* +1 for reading */
+        ret = gl861_i2c_msg(d, FRIIO_DEMOD_ADDR, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+
+        msleep(5);
+        /* note: DEMODULATOR has 16bit register-address. */
+        wbuf[0] = 0x00;
+        wbuf[2] = 0x01;         /* reg addr: 0x0100 */
+        wbuf[1] = 0x00;         /* val: not used */
+        ret = gl861_i2c_msg(d, FRIIO_DEMOD_ADDR, wbuf, 3, rbuf, 1);
+        if (ret < 0)
+                goto error;
+/*
+        msleep(1);
+        wbuf[0] = 0x80;
+        wbuf[1] = 0x00;
+        ret = gl861_i2c_msg(d, FRIIO_DEMOD_ADDR, wbuf, 2, rbuf, 1);
+        if (ret < 0)
+                goto error;
+ */
+        if (rbuf[0] & 0x80) {   /* still in PowerOnReset state? */
+                if (++retry > 3) {
+                        deb_info("failed to get the correct"
+                                 " FE demod status:0x%02x\n", rbuf[0]);
+                        goto error;
+                }
+                msleep(100);
+                goto restart;
+        }
+
+        /* TODO: check return value in rbuf */
+        /* =========== end DEMOD init cmds ===================== */
+        msleep(1);
+
+        wbuf[0] = 0x30;
+        wbuf[1] = 0x04;
+        ret = gl861_i2c_msg(d, 0x00, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+
+        msleep(2);
+        /* following 2 cmds unnecessary? */
+        wbuf[0] = 0x00;
+        wbuf[1] = 0x01;
+        ret = gl861_i2c_msg(d, 0x00, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+
+        wbuf[0] = 0x06;
+        wbuf[1] = 0x0F;
+        ret = gl861_i2c_msg(d, 0x00, wbuf, 2, NULL, 0);
+        if (ret < 0)
+                goto error;
+
+        /* some streaming ctl cmds (maybe) */
+        msleep(10);
+        for (i = 0; i < cmdlen; i++) {
+                ret = gl861_i2c_msg(d, 0x00, streaming_init_cmds[i], 2,
+                                    NULL, 0);
+                if (ret < 0)
+                        goto error;
+                msleep(1);
+        }
+        msleep(20);
+
+        /* change the LED color etc. */
+        ret = friio_streaming_ctrl(&d->adapter[0], 0);
+        if (ret < 0)
+                goto error;
+
+        return 0;
+
+error:
+        deb_info("%s:ret == %d\n", __func__, ret);
+        return -EIO;
+}
+
+/* Callbacks for DVB USB */
+
+static int friio_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
+{
+        int ret;
+
+        deb_info("%s called.(%d)\n", __func__, onoff);
+
+        /* set the LED color and saturation (and LNB on) */
+        if (onoff)
+                ret = friio_ext_ctl(adap, 0x6400ff64, 1);
+        else
+                ret = friio_ext_ctl(adap, 0x96ff00ff, 1);
+
+        if (ret != 1) {
+                deb_info("%s failed to send cmdx. ret==%d\n", __func__, ret);
+                return -EREMOTEIO;
+        }
+        return 0;
+}
+
+static int friio_frontend_attach(struct dvb_usb_adapter *adap)
+{
+        if (friio_initialize(adap->dev) < 0)
+                return -EIO;
+
+        adap->fe = jdvbt90502_attach(adap->dev);
+        if (adap->fe == NULL)
+                return -EIO;
+
+        return 0;
+}
+
+/* DVB USB Driver stuff */
+static struct dvb_usb_device_properties friio_properties;
+
+static int friio_probe(struct usb_interface *intf,
+                       const struct usb_device_id *id)
+{
+        struct dvb_usb_device *d;
+        struct usb_host_interface *alt;
+        int ret;
+
+        if (intf->num_altsetting < GL861_ALTSETTING_COUNT)
+                return -ENODEV;
+
+        alt = usb_altnum_to_altsetting(intf, FRIIO_BULK_ALTSETTING);
+        if (alt == NULL) {
+                deb_rc("not alt found!\n");
+                return -ENODEV;
+        }
+        ret = usb_set_interface(interface_to_usbdev(intf),
+                                alt->desc.bInterfaceNumber,
+                                alt->desc.bAlternateSetting);
+        if (ret != 0) {
+                deb_rc("failed to set alt-setting!\n");
+                return ret;
+        }
+
+        ret = dvb_usb_device_init(intf, &friio_properties,
+                                  THIS_MODULE, &d, adapter_nr);
+        if (ret == 0)
+                friio_streaming_ctrl(&d->adapter[0], 1);
+
+        return ret;
+}
+
+
+struct jdvbt90502_config friio_fe_config = {
+        .demod_address = FRIIO_DEMOD_ADDR,
+        .pll_address = FRIIO_PLL_ADDR,
+};
+
+static struct i2c_algorithm gl861_i2c_algo = {
+        .master_xfer   = gl861_i2c_xfer,
+        .functionality = gl861_i2c_func,
+};
+
+static struct usb_device_id friio_table[] = {
+        { USB_DEVICE(USB_VID_774, USB_PID_FRIIO_WHITE) },
+        { }             /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, friio_table);
+
+
+static struct dvb_usb_device_properties friio_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+        .usb_ctrl = DEVICE_SPECIFIC,
+
+        .size_of_priv = 0,
+
+        .num_adapters = 1,
+        .adapter = {
+                /* caps:0 =>  no pid filter, 188B TS packet */
+                /* GL861 has a HW pid filter, but no info available. */
+                {
+                        .caps  = 0,
+
+                        .frontend_attach  = friio_frontend_attach,
+                        .streaming_ctrl = friio_streaming_ctrl,
+
+                        .stream = {
+                                .type = USB_BULK,
+                                /* count <= MAX_NO_URBS_FOR_DATA_STREAM(10) */
+                                .count = 8,
+                                .endpoint = 0x01,
+                                .u = {
+                                        /* GL861 has 6KB buf inside */
+                                        .bulk = {
+                                                .buffersize = 16384,
+                                        }
+                                }
+                        },
+                }
+        },
+        .i2c_algo = &gl861_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                {
+                        .name = "774 Friio ISDB-T USB2.0",
+                        .cold_ids = { NULL },
+                        .warm_ids = { &friio_table[0], NULL },
+                },
+        }
+};
+
+static struct usb_driver friio_driver = {
+        .name           = "dvb_usb_friio",
+        .probe          = friio_probe,
+        .disconnect     = dvb_usb_device_exit,
+        .id_table       = friio_table,
+};
+
+
+/* module stuff */
+static int __init friio_module_init(void)
+{
+        int ret;
+
+        ret = usb_register(&friio_driver);
+        if (ret)
+                err("usb_register failed. Error number %d", ret);
+
+        return ret;
+}
+
+
+static void __exit friio_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&friio_driver);
+}
+
+module_init(friio_module_init);
+module_exit(friio_module_exit);
+
+MODULE_AUTHOR("Akihiro Tsukada <tskd2@yahoo.co.jp>");
+MODULE_DESCRIPTION("Driver for Friio ISDB-T USB2.0 Receiver");
+MODULE_VERSION("0.2");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/friio.h b/drivers/media/dvb/dvb-usb/friio.h
new file mode 100644
index 000000000000..af8d55e390fb
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/friio.h
@@ -0,0 +1,99 @@
+/* DVB USB compliant Linux driver for the Friio USB2.0 ISDB-T receiver.
+ *
+ * Copyright (C) 2009 Akihiro Tsukada <tskd2@yahoo.co.jp>
+ *
+ * This module is based off the the gl861 and vp702x modules.
+ *
+ * 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, version 2.
+ *
+ * see Documentation/dvb/README.dvb-usb for more information
+ */
+#ifndef _DVB_USB_FRIIO_H_
+#define _DVB_USB_FRIIO_H_
+
+/**
+ *      Friio Components
+ *       USB hub:                                AU4254
+ *         USB controller(+ TS dmx & streaming): GL861
+ *         Frontend:                             comtech JDVBT-90502
+ *             (tuner PLL:                       tua6034, I2C addr:(0xC0 >> 1))
+ *             (OFDM demodulator:                TC90502, I2C addr:(0x30 >> 1))
+ *         LED x3 (+LNB) controll:               PIC 16F676
+ *         EEPROM:                               24C08
+ *
+ *        (USB smart card reader:                AU9522)
+ *
+ */
+
+#define DVB_USB_LOG_PREFIX "friio"
+#include "dvb-usb.h"
+
+extern int dvb_usb_friio_debug;
+#define deb_info(args...) dprintk(dvb_usb_friio_debug, 0x01, args)
+#define deb_xfer(args...) dprintk(dvb_usb_friio_debug, 0x02, args)
+#define deb_rc(args...)   dprintk(dvb_usb_friio_debug, 0x04, args)
+#define deb_fe(args...)   dprintk(dvb_usb_friio_debug, 0x08, args)
+
+/* Vendor requests */
+#define GL861_WRITE             0x40
+#define GL861_READ              0xc0
+
+/* command bytes */
+#define GL861_REQ_I2C_WRITE     0x01
+#define GL861_REQ_I2C_READ      0x02
+/* For control msg with data argument */
+/* Used for accessing the PLL on the secondary I2C bus of FE via GL861 */
+#define GL861_REQ_I2C_DATA_CTRL_WRITE   0x03
+
+#define GL861_ALTSETTING_COUNT  2
+#define FRIIO_BULK_ALTSETTING   0
+#define FRIIO_ISOC_ALTSETTING   1
+
+/* LED & LNB control via PIC. */
+/* basically, it's serial control with clock and strobe. */
+/* write the below 4bit control data to the reg 0x00 at the I2C addr 0x00 */
+/* when controlling the LEDs, 32bit(saturation, R, G, B) is sent on the bit3*/
+#define FRIIO_CTL_LNB (1 << 0)
+#define FRIIO_CTL_STROBE (1 << 1)
+#define FRIIO_CTL_CLK (1 << 2)
+#define FRIIO_CTL_LED (1 << 3)
+
+/* Front End related */
+
+#define FRIIO_DEMOD_ADDR  (0x30 >> 1)
+#define FRIIO_PLL_ADDR  (0xC0 >> 1)
+
+#define JDVBT90502_PLL_CLK      4000000
+#define JDVBT90502_PLL_DIVIDER  28
+
+#define JDVBT90502_2ND_I2C_REG 0xFE
+
+/* byte index for pll i2c command data structure*/
+/* see datasheet for tua6034 */
+#define DEMOD_REDIRECT_REG 0
+#define ADDRESS_BYTE       1
+#define DIVIDER_BYTE1      2
+#define DIVIDER_BYTE2      3
+#define CONTROL_BYTE       4
+#define BANDSWITCH_BYTE    5
+#define AGC_CTRL_BYTE      5
+#define PLL_CMD_LEN        6
+
+/* bit masks for PLL STATUS response */
+#define PLL_STATUS_POR_MODE   0x80 /* 1: Power on Reset (test) Mode */
+#define PLL_STATUS_LOCKED     0x40 /* 1: locked */
+#define PLL_STATUS_AGC_ACTIVE 0x08 /* 1:active */
+#define PLL_STATUS_TESTMODE   0x07 /* digital output level (5 level) */
+  /* 0.15Vcc step   0x00: < 0.15Vcc, ..., 0x04: >= 0.6Vcc (<= 1Vcc) */
+
+
+struct jdvbt90502_config {
+        u8 demod_address; /* i2c addr for demodulator IC */
+        u8 pll_address;   /* PLL addr on the secondary i2c*/
+};
+extern struct jdvbt90502_config friio_fe_config;
+
+extern struct dvb_frontend *jdvbt90502_attach(struct dvb_usb_device *d);
+#endif
diff --git a/drivers/media/dvb/dvb-usb/m920x.c b/drivers/media/dvb/dvb-usb/m920x.c
index aec7a1943b66..ef9b7bed13ff 100644
--- a/drivers/media/dvb/dvb-usb/m920x.c
+++ b/drivers/media/dvb/dvb-usb/m920x.c
@@ -337,6 +337,8 @@ static int m920x_firmware_download(struct usb_device *udev, const struct firmwar
         int i, pass, ret = 0;
 
         buff = kmalloc(65536, GFP_KERNEL);
+        if (buff == NULL)
+                return -ENOMEM;
 
         if ((ret = m920x_read(udev, M9206_FILTER, 0x0, 0x8000, read, 4)) != 0)
                 goto done;
diff --git a/drivers/media/dvb/frontends/Kconfig b/drivers/media/dvb/frontends/Kconfig
index b794e860b4e2..d7c4837fa71c 100644
--- a/drivers/media/dvb/frontends/Kconfig
+++ b/drivers/media/dvb/frontends/Kconfig
@@ -484,6 +484,14 @@ config DVB_S921
           AN ISDB-T DQPSK, QPSK, 16QAM and 64QAM 1seg tuner module.
           Say Y when you want to support this frontend.
 
+config DVB_DIB8000
+        tristate "DiBcom 8000MB/MC"
+        depends on DVB_CORE && I2C
+        default m if DVB_FE_CUSTOMISE
+        help
+          A driver for DiBcom's DiB8000 ISDB-T/ISDB-Tsb demodulator.
+          Say Y when you want to support this frontend.
+
 comment "Digital terrestrial only tuners/PLL"
         depends on DVB_CORE
 
diff --git a/drivers/media/dvb/frontends/Makefile b/drivers/media/dvb/frontends/Makefile
index 3b49d37ab5fa..3523767e7a76 100644
--- a/drivers/media/dvb/frontends/Makefile
+++ b/drivers/media/dvb/frontends/Makefile
@@ -23,6 +23,7 @@ obj-$(CONFIG_DVB_DIB3000MB) += dib3000mb.o
 obj-$(CONFIG_DVB_DIB3000MC) += dib3000mc.o dibx000_common.o
 obj-$(CONFIG_DVB_DIB7000M) += dib7000m.o dibx000_common.o
 obj-$(CONFIG_DVB_DIB7000P) += dib7000p.o dibx000_common.o
+obj-$(CONFIG_DVB_DIB8000) += dib8000.o dibx000_common.o
 obj-$(CONFIG_DVB_MT312) += mt312.o
 obj-$(CONFIG_DVB_VES1820) += ves1820.o
 obj-$(CONFIG_DVB_VES1X93) += ves1x93.o
diff --git a/drivers/media/dvb/frontends/au8522_decoder.c b/drivers/media/dvb/frontends/au8522_decoder.c
index 9e9a75576a1d..74981ee923c8 100644
--- a/drivers/media/dvb/frontends/au8522_decoder.c
+++ b/drivers/media/dvb/frontends/au8522_decoder.c
@@ -792,6 +792,11 @@ static int au8522_probe(struct i2c_client *client,
         }
 
         demod_config = kzalloc(sizeof(struct au8522_config), GFP_KERNEL);
+        if (demod_config == NULL) {
+                if (instance == 1)
+                        kfree(state);
+                return -ENOMEM;
+        }
         demod_config->demod_address = 0x8e >> 1;
 
         state->config = demod_config;
diff --git a/drivers/media/dvb/frontends/dib0070.c b/drivers/media/dvb/frontends/dib0070.c
index da92cbe1b8ea..2be17b93e0bd 100644
--- a/drivers/media/dvb/frontends/dib0070.c
+++ b/drivers/media/dvb/frontends/dib0070.c
@@ -1,12 +1,29 @@
 /*
  * Linux-DVB Driver for DiBcom's DiB0070 base-band RF Tuner.
  *
- * Copyright (C) 2005-7 DiBcom (http://www.dibcom.fr/)
+ * Copyright (C) 2005-9 DiBcom (http://www.dibcom.fr/)
  *
  * 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, version 2.
+ * 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.
+ *
+ *
+ * This code is more or less generated from another driver, please
+ * excuse some codingstyle oddities.
+ *
  */
+
 #include <linux/kernel.h>
 #include <linux/i2c.h>
 
@@ -19,27 +36,65 @@ static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
 
-#define dprintk(args...) do { if (debug) { printk(KERN_DEBUG "DiB0070: "); printk(args); printk("\n"); } } while (0)
+#define dprintk(args...) do { \
+        if (debug) { \
+                printk(KERN_DEBUG "DiB0070: "); \
+                printk(args); \
+                printk("\n"); \
+        } \
+} while (0)
 
 #define DIB0070_P1D  0x00
 #define DIB0070_P1F  0x01
 #define DIB0070_P1G  0x03
 #define DIB0070S_P1A 0x02
 
+enum frontend_tune_state {
+        CT_TUNER_START = 10,
+        CT_TUNER_STEP_0,
+        CT_TUNER_STEP_1,
+        CT_TUNER_STEP_2,
+        CT_TUNER_STEP_3,
+        CT_TUNER_STEP_4,
+        CT_TUNER_STEP_5,
+        CT_TUNER_STEP_6,
+        CT_TUNER_STEP_7,
+        CT_TUNER_STOP,
+};
+
+#define FE_CALLBACK_TIME_NEVER 0xffffffff
+
 struct dib0070_state {
         struct i2c_adapter *i2c;
         struct dvb_frontend *fe;
         const struct dib0070_config *cfg;
         u16 wbd_ff_offset;
         u8 revision;
+
+        enum frontend_tune_state tune_state;
+        u32 current_rf;
+
+        /* for the captrim binary search */
+        s8 step;
+        u16 adc_diff;
+
+        s8 captrim;
+        s8 fcaptrim;
+        u16 lo4;
+
+        const struct dib0070_tuning *current_tune_table_index;
+        const struct dib0070_lna_match *lna_match;
+
+        u8 wbd_gain_current;
+        u16 wbd_offset_3_3[2];
 };
 
 static uint16_t dib0070_read_reg(struct dib0070_state *state, u8 reg)
 {
         u8 b[2];
         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 = b,  .len = 2 },
+                {.addr = state->cfg->i2c_address,.flags = 0,.buf = &reg,.len = 1},
+                {.addr = state->cfg->i2c_address,.flags = I2C_M_RD,.buf = b,.len = 2},
         };
         if (i2c_transfer(state->i2c, msg, 2) != 2) {
                 printk(KERN_WARNING "DiB0070 I2C read failed\n");
@@ -51,7 +106,7 @@ static uint16_t dib0070_read_reg(struct dib0070_state *state, u8 reg)
 static int dib0070_write_reg(struct dib0070_state *state, u8 reg, u16 val)
 {
         u8 b[3] = { reg, val >> 8, val & 0xff };
-        struct i2c_msg msg = { .addr = state->cfg->i2c_address, .flags = 0, .buf = b, .len = 3 };
+        struct i2c_msg msg = {.addr = state->cfg->i2c_address,.flags = 0,.buf = b,.len = 3 };
         if (i2c_transfer(state->i2c, &msg, 1) != 1) {
                 printk(KERN_WARNING "DiB0070 I2C write failed\n");
                 return -EREMOTEIO;
@@ -59,55 +114,71 @@ static int dib0070_write_reg(struct dib0070_state *state, u8 reg, u16 val)
         return 0;
 }
 
-#define HARD_RESET(state) do { if (state->cfg->reset) { state->cfg->reset(state->fe,1); msleep(10); state->cfg->reset(state->fe,0); msleep(10); } } while (0)
+#define HARD_RESET(state) do { \
+    state->cfg->sleep(state->fe, 0); \
+    if (state->cfg->reset) { \
+        state->cfg->reset(state->fe,1); msleep(10); \
+        state->cfg->reset(state->fe,0); msleep(10); \
+    } \
+} while (0)
 
 static int dib0070_set_bandwidth(struct dvb_frontend *fe, struct dvb_frontend_parameters *ch)
 {
-        struct dib0070_state *st = fe->tuner_priv;
-        u16 tmp = 0;
-        tmp = dib0070_read_reg(st, 0x02) & 0x3fff;
+        struct dib0070_state *state = fe->tuner_priv;
+        u16 tmp = dib0070_read_reg(state, 0x02) & 0x3fff;
+
+        if (state->fe->dtv_property_cache.bandwidth_hz / 1000 > 7000)
+                tmp |= (0 << 14);
+        else if (state->fe->dtv_property_cache.bandwidth_hz / 1000 > 6000)
+                tmp |= (1 << 14);
+        else if (state->fe->dtv_property_cache.bandwidth_hz / 1000 > 5000)
+                tmp |= (2 << 14);
+        else
+                tmp |= (3 << 14);
 
-    switch(BANDWIDTH_TO_KHZ(ch->u.ofdm.bandwidth)) {
-                case  8000:
-                        tmp |= (0 << 14);
-                        break;
-                case  7000:
-                        tmp |= (1 << 14);
-                        break;
-        case  6000:
-                        tmp |= (2 << 14);
-                        break;
-        case 5000:
-                default:
-                        tmp |= (3 << 14);
-                        break;
+        dib0070_write_reg(state, 0x02, tmp);
+
+        /* sharpen the BB filter in ISDB-T to have higher immunity to adjacent channels */
+        if (state->fe->dtv_property_cache.delivery_system == SYS_ISDBT) {
+                u16 value = dib0070_read_reg(state, 0x17);
+
+                dib0070_write_reg(state, 0x17, value & 0xfffc);
+                tmp = dib0070_read_reg(state, 0x01) & 0x01ff;
+                dib0070_write_reg(state, 0x01, tmp | (60 << 9));
+
+                dib0070_write_reg(state, 0x17, value);
         }
-        dib0070_write_reg(st, 0x02, tmp);
         return 0;
 }
 
-static void dib0070_captrim(struct dib0070_state *st, u16 LO4)
+static int dib0070_captrim(struct dib0070_state *state, enum frontend_tune_state *tune_state)
 {
-        int8_t captrim, fcaptrim, step_sign, step;
-        u16 adc, adc_diff = 3000;
+        int8_t step_sign;
+        u16 adc;
+        int ret = 0;
 
+        if (*tune_state == CT_TUNER_STEP_0) {
 
+                dib0070_write_reg(state, 0x0f, 0xed10);
+                dib0070_write_reg(state, 0x17, 0x0034);
 
-        dib0070_write_reg(st, 0x0f, 0xed10);
-        dib0070_write_reg(st, 0x17,    0x0034);
+                dib0070_write_reg(state, 0x18, 0x0032);
+                state->step = state->captrim = state->fcaptrim = 64;
+                state->adc_diff = 3000;
+                ret = 20;
 
-        dib0070_write_reg(st, 0x18, 0x0032);
-        msleep(2);
+                *tune_state = CT_TUNER_STEP_1;
+        } else if (*tune_state == CT_TUNER_STEP_1) {
+                state->step /= 2;
+                dib0070_write_reg(state, 0x14, state->lo4 | state->captrim);
+                ret = 15;
 
-        step = captrim = fcaptrim = 64;
+                *tune_state = CT_TUNER_STEP_2;
+        } else if (*tune_state == CT_TUNER_STEP_2) {
 
-        do {
-                step /= 2;
-                dib0070_write_reg(st, 0x14, LO4 | captrim);
-                msleep(1);
-                adc = dib0070_read_reg(st, 0x19);
+                adc = dib0070_read_reg(state, 0x19);
 
-                dprintk( "CAPTRIM=%hd; ADC = %hd (ADC) & %dmV", captrim, adc, (u32) adc*(u32)1800/(u32)1024);
+                dprintk("CAPTRIM=%hd; ADC = %hd (ADC) & %dmV", state->captrim, adc, (u32) adc * (u32) 1800 / (u32) 1024);
 
                 if (adc >= 400) {
                         adc -= 400;
@@ -117,379 +188,430 @@ static void dib0070_captrim(struct dib0070_state *st, u16 LO4)
                         step_sign = 1;
                 }
 
-                if (adc < adc_diff) {
-                        dprintk( "CAPTRIM=%hd is closer to target (%hd/%hd)", captrim, adc, adc_diff);
-                        adc_diff = adc;
-                        fcaptrim = captrim;
+                if (adc < state->adc_diff) {
+                        dprintk("CAPTRIM=%hd is closer to target (%hd/%hd)", state->captrim, adc, state->adc_diff);
+                        state->adc_diff = adc;
+                        state->fcaptrim = state->captrim;
 
+                }
+                state->captrim += (step_sign * state->step);
 
+                if (state->step >= 1)
+                        *tune_state = CT_TUNER_STEP_1;
+                else
+                        *tune_state = CT_TUNER_STEP_3;
 
-                }
-                captrim += (step_sign * step);
-        } while (step >= 1);
+        } else if (*tune_state == CT_TUNER_STEP_3) {
+                dib0070_write_reg(state, 0x14, state->lo4 | state->fcaptrim);
+                dib0070_write_reg(state, 0x18, 0x07ff);
+                *tune_state = CT_TUNER_STEP_4;
+        }
 
-        dib0070_write_reg(st, 0x14, LO4 | fcaptrim);
-        dib0070_write_reg(st, 0x18, 0x07ff);
+        return ret;
 }
 
-#define LPF     100                       // define for the loop filter 100kHz by default 16-07-06
-#define LO4_SET_VCO_HFDIV(l, v, h)   l |= ((v) << 11) | ((h) << 7)
-#define LO4_SET_SD(l, s)             l |= ((s) << 14) | ((s) << 12)
-#define LO4_SET_CTRIM(l, c)          l |=  (c) << 10
-static int dib0070_tune_digital(struct dvb_frontend *fe, struct dvb_frontend_parameters *ch)
+static int dib0070_set_ctrl_lo5(struct dvb_frontend *fe, u8 vco_bias_trim, u8 hf_div_trim, u8 cp_current, u8 third_order_filt)
 {
-        struct dib0070_state *st = fe->tuner_priv;
-        u32 freq = ch->frequency/1000 + (BAND_OF_FREQUENCY(ch->frequency/1000) == BAND_VHF ? st->cfg->freq_offset_khz_vhf : st->cfg->freq_offset_khz_uhf);
-
-        u8 band = BAND_OF_FREQUENCY(freq), c;
+        struct dib0070_state *state = fe->tuner_priv;
+        u16 lo5 = (third_order_filt << 14) | (0 << 13) | (1 << 12) | (3 << 9) | (cp_current << 6) | (hf_div_trim << 3) | (vco_bias_trim << 0);
+        dprintk("CTRL_LO5: 0x%x", lo5);
+        return dib0070_write_reg(state, 0x15, lo5);
+}
 
-        /*******************VCO***********************************/
-        u16 lo4 = 0;
+void dib0070_ctrl_agc_filter(struct dvb_frontend *fe, u8 open)
+{
+        struct dib0070_state *state = fe->tuner_priv;
 
-        u8 REFDIV, PRESC = 2;
-        u32 FBDiv, Rest, FREF, VCOF_kHz;
-        u16 Num, Den;
-        /*******************FrontEnd******************************/
-        u16 value = 0;
+        if (open) {
+                dib0070_write_reg(state, 0x1b, 0xff00);
+                dib0070_write_reg(state, 0x1a, 0x0000);
+        } else {
+                dib0070_write_reg(state, 0x1b, 0x4112);
+                if (state->cfg->vga_filter != 0) {
+                        dib0070_write_reg(state, 0x1a, state->cfg->vga_filter);
+                        dprintk("vga filter register is set to %x", state->cfg->vga_filter);
+                } else
+                        dib0070_write_reg(state, 0x1a, 0x0009);
+        }
+}
 
-        dprintk( "Tuning for Band: %hd (%d kHz)", band, freq);
+EXPORT_SYMBOL(dib0070_ctrl_agc_filter);
+struct dib0070_tuning {
+        u32 max_freq;           /* for every frequency less than or equal to that field: this information is correct */
+        u8 switch_trim;
+        u8 vco_band;
+        u8 hfdiv;
+        u8 vco_multi;
+        u8 presc;
+        u8 wbdmux;
+        u16 tuner_enable;
+};
 
+struct dib0070_lna_match {
+        u32 max_freq;           /* for every frequency less than or equal to that field: this information is correct */
+        u8 lna_band;
+};
 
-        dib0070_write_reg(st, 0x17, 0x30);
+static const struct dib0070_tuning dib0070s_tuning_table[] = {
+        {570000, 2, 1, 3, 6, 6, 2, 0x4000 | 0x0800},    /* UHF */
+        {700000, 2, 0, 2, 4, 2, 2, 0x4000 | 0x0800},
+        {863999, 2, 1, 2, 4, 2, 2, 0x4000 | 0x0800},
+        {1500000, 0, 1, 1, 2, 2, 4, 0x2000 | 0x0400},   /* LBAND */
+        {1600000, 0, 1, 1, 2, 2, 4, 0x2000 | 0x0400},
+        {2000000, 0, 1, 1, 2, 2, 4, 0x2000 | 0x0400},
+        {0xffffffff, 0, 0, 8, 1, 2, 1, 0x8000 | 0x1000},        /* SBAND */
+};
 
-        dib0070_set_bandwidth(fe, ch);  /* c is used as HF */
-        switch (st->revision) {
-                case DIB0070S_P1A:
-                        switch (band) {
-                                case BAND_LBAND:
-                                        LO4_SET_VCO_HFDIV(lo4, 1, 1);
-                                        c = 2;
-                                        break;
-                                case BAND_SBAND:
-                                        LO4_SET_VCO_HFDIV(lo4, 0, 0);
-                                        LO4_SET_CTRIM(lo4, 1);
-                                        c = 1;
-                                        break;
-                                case BAND_UHF:
-                                default:
-                                        if (freq < 570000) {
-                                                LO4_SET_VCO_HFDIV(lo4, 1, 3);
-                                                PRESC = 6; c = 6;
-                                        } else if (freq < 680000) {
-                                                LO4_SET_VCO_HFDIV(lo4, 0, 2);
-                                                c = 4;
-                                        } else {
-                                                LO4_SET_VCO_HFDIV(lo4, 1, 2);
-                                                c = 4;
-                                        }
-                                        break;
-                        } break;
-
-                case DIB0070_P1G:
-                case DIB0070_P1F:
-                default:
-                        switch (band) {
-                                case BAND_FM:
-                                                LO4_SET_VCO_HFDIV(lo4, 0, 7);
-                                                c = 24;
-                                        break;
-                                case BAND_LBAND:
-                                                LO4_SET_VCO_HFDIV(lo4, 1, 0);
-                                                c = 2;
-                                        break;
-                                case BAND_VHF:
-                                        if (freq < 180000) {
-                                                LO4_SET_VCO_HFDIV(lo4, 0, 3);
-                                                c = 16;
-                                        } else if (freq < 190000) {
-                                                LO4_SET_VCO_HFDIV(lo4, 1, 3);
-                                                c = 16;
-                                        } else {
-                                                LO4_SET_VCO_HFDIV(lo4, 0, 6);
-                                                c = 12;
-                                        }
-                                        break;
-
-                                case BAND_UHF:
-                                default:
-                                        if (freq < 570000) {
-                                                LO4_SET_VCO_HFDIV(lo4, 1, 5);
-                                                c = 6;
-                                        } else if (freq < 700000) {
-                                                LO4_SET_VCO_HFDIV(lo4, 0, 1);
-                                                c = 4;
-                                        } else {
-                                                LO4_SET_VCO_HFDIV(lo4, 1, 1);
-                                                c = 4;
-                                        }
-                                        break;
-                        }
-                break;
-        }
+static const struct dib0070_tuning dib0070_tuning_table[] = {
+        {115000, 1, 0, 7, 24, 2, 1, 0x8000 | 0x1000},   /* FM below 92MHz cannot be tuned */
+        {179500, 1, 0, 3, 16, 2, 1, 0x8000 | 0x1000},   /* VHF */
+        {189999, 1, 1, 3, 16, 2, 1, 0x8000 | 0x1000},
+        {250000, 1, 0, 6, 12, 2, 1, 0x8000 | 0x1000},
+        {569999, 2, 1, 5, 6, 2, 2, 0x4000 | 0x0800},    /* UHF */
+        {699999, 2, 0, 1, 4, 2, 2, 0x4000 | 0x0800},
+        {863999, 2, 1, 1, 4, 2, 2, 0x4000 | 0x0800},
+        {0xffffffff, 0, 1, 0, 2, 2, 4, 0x2000 | 0x0400},        /* LBAND or everything higher than UHF */
+};
 
-        dprintk( "HFDIV code: %hd", (lo4 >> 7) & 0xf);
-        dprintk( "VCO = %hd", (lo4 >> 11) & 0x3);
+static const struct dib0070_lna_match dib0070_lna_flip_chip[] = {
+        {180000, 0},            /* VHF */
+        {188000, 1},
+        {196400, 2},
+        {250000, 3},
+        {550000, 0},            /* UHF */
+        {590000, 1},
+        {666000, 3},
+        {864000, 5},
+        {1500000, 0},           /* LBAND or everything higher than UHF */
+        {1600000, 1},
+        {2000000, 3},
+        {0xffffffff, 7},
+};
 
+static const struct dib0070_lna_match dib0070_lna[] = {
+        {180000, 0},            /* VHF */
+        {188000, 1},
+        {196400, 2},
+        {250000, 3},
+        {550000, 2},            /* UHF */
+        {650000, 3},
+        {750000, 5},
+        {850000, 6},
+        {864000, 7},
+        {1500000, 0},           /* LBAND or everything higher than UHF */
+        {1600000, 1},
+        {2000000, 3},
+        {0xffffffff, 7},
+};
 
-        VCOF_kHz = (c * freq) * 2;
-        dprintk( "VCOF in kHz: %d ((%hd*%d) << 1))",VCOF_kHz, c, freq);
+#define LPF     100             // define for the loop filter 100kHz by default 16-07-06
+static int dib0070_tune_digital(struct dvb_frontend *fe, struct dvb_frontend_parameters *ch)
+{
+        struct dib0070_state *state = fe->tuner_priv;
 
-        switch (band) {
-                case BAND_VHF:
-                        REFDIV = (u8) ((st->cfg->clock_khz + 9999) / 10000);
-                        break;
-                case BAND_FM:
-                        REFDIV = (u8) ((st->cfg->clock_khz) / 1000);
-                        break;
-                default:
-                        REFDIV = (u8) ( st->cfg->clock_khz  / 10000);
-                        break;
-        }
-        FREF = st->cfg->clock_khz / REFDIV;
+        const struct dib0070_tuning *tune;
+        const struct dib0070_lna_match *lna_match;
 
-        dprintk( "REFDIV: %hd, FREF: %d", REFDIV, FREF);
+        enum frontend_tune_state *tune_state = &state->tune_state;
+        int ret = 10;           /* 1ms is the default delay most of the time */
 
+        u8 band = (u8) BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000);
+        u32 freq = fe->dtv_property_cache.frequency / 1000 + (band == BAND_VHF ? state->cfg->freq_offset_khz_vhf : state->cfg->freq_offset_khz_uhf);
 
+#ifdef CONFIG_SYS_ISDBT
+        if (state->fe->dtv_property_cache.delivery_system == SYS_ISDBT && state->fe->dtv_property_cache.isdbt_sb_mode == 1)
+                if (((state->fe->dtv_property_cache.isdbt_sb_segment_count % 2)
+                     && (state->fe->dtv_property_cache.isdbt_sb_segment_idx == ((state->fe->dtv_property_cache.isdbt_sb_segment_count / 2) + 1)))
+                    || (((state->fe->dtv_property_cache.isdbt_sb_segment_count % 2) == 0)
+                        && (state->fe->dtv_property_cache.isdbt_sb_segment_idx == (state->fe->dtv_property_cache.isdbt_sb_segment_count / 2)))
+                    || (((state->fe->dtv_property_cache.isdbt_sb_segment_count % 2) == 0)
+                        && (state->fe->dtv_property_cache.isdbt_sb_segment_idx == ((state->fe->dtv_property_cache.isdbt_sb_segment_count / 2) + 1))))
+                        freq += 850;
+#endif
+        if (state->current_rf != freq) {
 
-        switch (st->revision) {
+                switch (state->revision) {
                 case DIB0070S_P1A:
-                        FBDiv = (VCOF_kHz / PRESC / FREF);
-                        Rest  = (VCOF_kHz / PRESC) - FBDiv * FREF;
+                        tune = dib0070s_tuning_table;
+                        lna_match = dib0070_lna;
                         break;
-
-                case DIB0070_P1G:
-                case DIB0070_P1F:
                 default:
-                        FBDiv = (freq / (FREF / 2));
-                        Rest  = 2 * freq - FBDiv * FREF;
+                        tune = dib0070_tuning_table;
+                        if (state->cfg->flip_chip)
+                                lna_match = dib0070_lna_flip_chip;
+                        else
+                                lna_match = dib0070_lna;
                         break;
-        }
-
-
-             if (Rest < LPF)              Rest = 0;
-        else if (Rest < 2 * LPF)          Rest = 2 * LPF;
-        else if (Rest > (FREF - LPF))   { Rest = 0 ; FBDiv += 1; }
-        else if (Rest > (FREF - 2 * LPF)) Rest = FREF - 2 * LPF;
-        Rest = (Rest * 6528) / (FREF / 10);
-        dprintk( "FBDIV: %d, Rest: %d", FBDiv, Rest);
-
-        Num = 0;
-        Den = 1;
+                }
+                while (freq > tune->max_freq)   /* find the right one */
+                        tune++;
+                while (freq > lna_match->max_freq)      /* find the right one */
+                        lna_match++;
 
-        if (Rest > 0) {
-                LO4_SET_SD(lo4, 1);
-                Den = 255;
-                Num = (u16)Rest;
+                state->current_tune_table_index = tune;
+                state->lna_match = lna_match;
         }
-        dprintk( "Num: %hd, Den: %hd, SD: %hd",Num, Den, (lo4 >> 12) & 0x1);
 
+        if (*tune_state == CT_TUNER_START) {
+                dprintk("Tuning for Band: %hd (%d kHz)", band, freq);
+                if (state->current_rf != freq) {
+                        u8 REFDIV;
+                        u32 FBDiv, Rest, FREF, VCOF_kHz;
+                        u8 Den;
 
+                        state->current_rf = freq;
+                        state->lo4 = (state->current_tune_table_index->vco_band << 11) | (state->current_tune_table_index->hfdiv << 7);
 
-        dib0070_write_reg(st, 0x11, (u16)FBDiv);
+                        dib0070_write_reg(state, 0x17, 0x30);
 
+                        VCOF_kHz = state->current_tune_table_index->vco_multi * freq * 2;
 
-        dib0070_write_reg(st, 0x12, (Den << 8) | REFDIV);
-
+                        switch (band) {
+                        case BAND_VHF:
+                                REFDIV = (u8) ((state->cfg->clock_khz + 9999) / 10000);
+                                break;
+                        case BAND_FM:
+                                REFDIV = (u8) ((state->cfg->clock_khz) / 1000);
+                                break;
+                        default:
+                                REFDIV = (u8) (state->cfg->clock_khz / 10000);
+                                break;
+                        }
+                        FREF = state->cfg->clock_khz / REFDIV;
+
+                        switch (state->revision) {
+                        case DIB0070S_P1A:
+                                FBDiv = (VCOF_kHz / state->current_tune_table_index->presc / FREF);
+                                Rest = (VCOF_kHz / state->current_tune_table_index->presc) - FBDiv * FREF;
+                                break;
+
+                        case DIB0070_P1G:
+                        case DIB0070_P1F:
+                        default:
+                                FBDiv = (freq / (FREF / 2));
+                                Rest = 2 * freq - FBDiv * FREF;
+                                break;
+                        }
 
-        dib0070_write_reg(st, 0x13, Num);
+                        if (Rest < LPF)
+                                Rest = 0;
+                        else if (Rest < 2 * LPF)
+                                Rest = 2 * LPF;
+                        else if (Rest > (FREF - LPF)) {
+                                Rest = 0;
+                                FBDiv += 1;
+                        } else if (Rest > (FREF - 2 * LPF))
+                                Rest = FREF - 2 * LPF;
+                        Rest = (Rest * 6528) / (FREF / 10);
+
+                        Den = 1;
+                        if (Rest > 0) {
+                                state->lo4 |= (1 << 14) | (1 << 12);
+                                Den = 255;
+                        }
 
+                        dib0070_write_reg(state, 0x11, (u16) FBDiv);
+                        dib0070_write_reg(state, 0x12, (Den << 8) | REFDIV);
+                        dib0070_write_reg(state, 0x13, (u16) Rest);
 
-        value = 0x0040 | 0x0020 | 0x0010 | 0x0008 | 0x0002 | 0x0001;
+                        if (state->revision == DIB0070S_P1A) {
 
-        switch (band) {
-                case BAND_UHF:   value |= 0x4000 | 0x0800; break;
-                case BAND_LBAND: value |= 0x2000 | 0x0400; break;
-                default:         value |= 0x8000 | 0x1000; break;
-        }
-        dib0070_write_reg(st, 0x20, value);
+                                if (band == BAND_SBAND) {
+                                        dib0070_set_ctrl_lo5(fe, 2, 4, 3, 0);
+                                        dib0070_write_reg(state, 0x1d, 0xFFFF);
+                                } else
+                                        dib0070_set_ctrl_lo5(fe, 5, 4, 3, 1);
+                        }
 
-        dib0070_captrim(st, lo4);
-        if (st->revision == DIB0070S_P1A) {
-                if (band == BAND_SBAND)
-                        dib0070_write_reg(st, 0x15, 0x16e2);
-                else
-                        dib0070_write_reg(st, 0x15, 0x56e5);
-        }
+                        dib0070_write_reg(state, 0x20,
+                                          0x0040 | 0x0020 | 0x0010 | 0x0008 | 0x0002 | 0x0001 | state->current_tune_table_index->tuner_enable);
 
+                        dprintk("REFDIV: %hd, FREF: %d", REFDIV, FREF);
+                        dprintk("FBDIV: %d, Rest: %d", FBDiv, Rest);
+                        dprintk("Num: %hd, Den: %hd, SD: %hd", (u16) Rest, Den, (state->lo4 >> 12) & 0x1);
+                        dprintk("HFDIV code: %hd", state->current_tune_table_index->hfdiv);
+                        dprintk("VCO = %hd", state->current_tune_table_index->vco_band);
+                        dprintk("VCOF: ((%hd*%d) << 1))", state->current_tune_table_index->vco_multi, freq);
 
+                        *tune_state = CT_TUNER_STEP_0;
+                } else {        /* we are already tuned to this frequency - the configuration is correct  */
+                        ret = 50;       /* wakeup time */
+                        *tune_state = CT_TUNER_STEP_5;
+                }
+        } else if ((*tune_state > CT_TUNER_START) && (*tune_state < CT_TUNER_STEP_4)) {
+
+                ret = dib0070_captrim(state, tune_state);
+
+        } else if (*tune_state == CT_TUNER_STEP_4) {
+                const struct dib0070_wbd_gain_cfg *tmp = state->cfg->wbd_gain;
+                if (tmp != NULL) {
+                        while (freq / 1000 > tmp->freq) /* find the right one */
+                                tmp++;
+                        dib0070_write_reg(state, 0x0f,
+                                          (0 << 15) | (1 << 14) | (3 << 12) | (tmp->wbd_gain_val << 9) | (0 << 8) | (1 << 7) | (state->
+                                                                                                                                current_tune_table_index->
+                                                                                                                                wbdmux << 0));
+                        state->wbd_gain_current = tmp->wbd_gain_val;
+                } else {
+                        dib0070_write_reg(state, 0x0f,
+                                          (0 << 15) | (1 << 14) | (3 << 12) | (6 << 9) | (0 << 8) | (1 << 7) | (state->current_tune_table_index->
+                                                                                                                wbdmux << 0));
+                        state->wbd_gain_current = 6;
+                }
 
-        switch (band) {
-                case BAND_UHF:   value = 0x7c82; break;
-                case BAND_LBAND: value = 0x7c84; break;
-                default:         value = 0x7c81; break;
-        }
-        dib0070_write_reg(st, 0x0f, value);
-        dib0070_write_reg(st, 0x06, 0x3fff);
-
-        /* Front End */
-        /* c == TUNE, value = SWITCH */
-        c = 0;
-        value = 0;
-        switch (band) {
-                case BAND_FM:
-                        c = 0; value = 1;
-                break;
-
-                case BAND_VHF:
-                        if (freq <= 180000) c = 0;
-                        else if (freq <= 188200) c = 1;
-                        else if (freq <= 196400) c = 2;
-                        else c = 3;
-                        value = 1;
-                break;
-
-                case BAND_LBAND:
-                        if (freq <= 1500000) c = 0;
-                        else if (freq <= 1600000) c = 1;
-                        else c = 3;
-                break;
-
-                case BAND_SBAND:
-                        c = 7;
-                        dib0070_write_reg(st, 0x1d,0xFFFF);
-                break;
-
-                case BAND_UHF:
-                default:
-                        if (st->cfg->flip_chip) {
-                                if (freq <= 550000) c = 0;
-                                else if (freq <= 590000) c = 1;
-                                else if (freq <= 666000) c = 3;
-                                else c = 5;
-                        } else {
-                                if (freq <= 550000) c = 2;
-                                else if (freq <= 650000) c = 3;
-                                else if (freq <= 750000) c = 5;
-                                else if (freq <= 850000) c = 6;
-                                else c = 7;
-                        }
-                        value = 2;
-                break;
+                dib0070_write_reg(state, 0x06, 0x3fff);
+                dib0070_write_reg(state, 0x07,
+                                  (state->current_tune_table_index->switch_trim << 11) | (7 << 8) | (state->lna_match->lna_band << 3) | (3 << 0));
+                dib0070_write_reg(state, 0x08, (state->lna_match->lna_band << 10) | (3 << 7) | (127));
+                dib0070_write_reg(state, 0x0d, 0x0d80);
+
+                dib0070_write_reg(state, 0x18, 0x07ff);
+                dib0070_write_reg(state, 0x17, 0x0033);
+
+                *tune_state = CT_TUNER_STEP_5;
+        } else if (*tune_state == CT_TUNER_STEP_5) {
+                dib0070_set_bandwidth(fe, ch);
+                *tune_state = CT_TUNER_STOP;
+        } else {
+                ret = FE_CALLBACK_TIME_NEVER;   /* tuner finished, time to call again infinite */
         }
+        return ret;
+}
 
-        /* default: LNA_MATCH=7, BIAS=3 */
-        dib0070_write_reg(st, 0x07, (value << 11) | (7 << 8) | (c << 3) | (3 << 0));
-        dib0070_write_reg(st, 0x08, (c << 10) | (3 << 7) | (127));
-        dib0070_write_reg(st, 0x0d, 0x0d80);
+static int dib0070_tune(struct dvb_frontend *fe, struct dvb_frontend_parameters *p)
+{
+        struct dib0070_state *state = fe->tuner_priv;
+        uint32_t ret;
 
+        state->tune_state = CT_TUNER_START;
 
-        dib0070_write_reg(st, 0x18,   0x07ff);
-        dib0070_write_reg(st, 0x17, 0x0033);
+        do {
+                ret = dib0070_tune_digital(fe, p);
+                if (ret != FE_CALLBACK_TIME_NEVER)
+                        msleep(ret / 10);
+                else
+                        break;
+        } while (state->tune_state != CT_TUNER_STOP);
 
         return 0;
 }
 
 static int dib0070_wakeup(struct dvb_frontend *fe)
 {
-        struct dib0070_state *st = fe->tuner_priv;
-        if (st->cfg->sleep)
-                st->cfg->sleep(fe, 0);
+        struct dib0070_state *state = fe->tuner_priv;
+        if (state->cfg->sleep)
+                state->cfg->sleep(fe, 0);
         return 0;
 }
 
 static int dib0070_sleep(struct dvb_frontend *fe)
 {
-        struct dib0070_state *st = fe->tuner_priv;
-        if (st->cfg->sleep)
-                st->cfg->sleep(fe, 1);
+        struct dib0070_state *state = fe->tuner_priv;
+        if (state->cfg->sleep)
+                state->cfg->sleep(fe, 1);
         return 0;
 }
 
-static u16 dib0070_p1f_defaults[] =
-
-{
+static const u16 dib0070_p1f_defaults[] = {
         7, 0x02,
-                0x0008,
-                0x0000,
-                0x0000,
-                0x0000,
-                0x0000,
-                0x0002,
-                0x0100,
+        0x0008,
+        0x0000,
+        0x0000,
+        0x0000,
+        0x0000,
+        0x0002,
+        0x0100,
 
         3, 0x0d,
-                0x0d80,
-                0x0001,
-                0x0000,
+        0x0d80,
+        0x0001,
+        0x0000,
 
         4, 0x11,
-                0x0000,
-                0x0103,
-                0x0000,
-                0x0000,
+        0x0000,
+        0x0103,
+        0x0000,
+        0x0000,
 
         3, 0x16,
-                0x0004 | 0x0040,
-                0x0030,
-                0x07ff,
+        0x0004 | 0x0040,
+        0x0030,
+        0x07ff,
 
         6, 0x1b,
-                0x4112,
-                0xff00,
-                0xc07f,
-                0x0000,
-                0x0180,
-                0x4000 | 0x0800 | 0x0040 | 0x0020 | 0x0010 | 0x0008 | 0x0002 | 0x0001,
+        0x4112,
+        0xff00,
+        0xc07f,
+        0x0000,
+        0x0180,
+        0x4000 | 0x0800 | 0x0040 | 0x0020 | 0x0010 | 0x0008 | 0x0002 | 0x0001,
 
         0,
 };
 
-static void dib0070_wbd_calibration(struct dvb_frontend *fe)
+static u16 dib0070_read_wbd_offset(struct dib0070_state *state, u8 gain)
 {
-        u16 wbd_offs;
-        struct dib0070_state *state = fe->tuner_priv;
-
-        if (state->cfg->sleep)
-                state->cfg->sleep(fe, 0);
+        u16 tuner_en = dib0070_read_reg(state, 0x20);
+        u16 offset;
 
-        dib0070_write_reg(state, 0x0f, 0x6d81);
-        dib0070_write_reg(state, 0x20, 0x0040 | 0x0020 | 0x0010 | 0x0008 | 0x0002 | 0x0001);
+        dib0070_write_reg(state, 0x18, 0x07ff);
+        dib0070_write_reg(state, 0x20, 0x0800 | 0x4000 | 0x0040 | 0x0020 | 0x0010 | 0x0008 | 0x0002 | 0x0001);
+        dib0070_write_reg(state, 0x0f, (1 << 14) | (2 << 12) | (gain << 9) | (1 << 8) | (1 << 7) | (0 << 0));
         msleep(9);
-        wbd_offs = dib0070_read_reg(state, 0x19);
-        dib0070_write_reg(state, 0x20, 0);
-        state->wbd_ff_offset = ((wbd_offs * 8 * 18 / 33 + 1) / 2);
-        dprintk( "WBDStart = %d (Vargen) - FF = %hd", (u32) wbd_offs * 1800/1024, state->wbd_ff_offset);
-
-        if (state->cfg->sleep)
-                state->cfg->sleep(fe, 1);
-
+        offset = dib0070_read_reg(state, 0x19);
+        dib0070_write_reg(state, 0x20, tuner_en);
+        return offset;
 }
 
-u16 dib0070_wbd_offset(struct dvb_frontend *fe)
+static void dib0070_wbd_offset_calibration(struct dib0070_state *state)
 {
-        struct dib0070_state *st = fe->tuner_priv;
-        return st->wbd_ff_offset;
+        u8 gain;
+        for (gain = 6; gain < 8; gain++) {
+                state->wbd_offset_3_3[gain - 6] = ((dib0070_read_wbd_offset(state, gain) * 8 * 18 / 33 + 1) / 2);
+                dprintk("Gain: %d, WBDOffset (3.3V) = %hd", gain, state->wbd_offset_3_3[gain - 6]);
+        }
 }
 
-EXPORT_SYMBOL(dib0070_wbd_offset);
-static int dib0070_set_ctrl_lo5(struct dvb_frontend *fe, u8 vco_bias_trim, u8 hf_div_trim, u8 cp_current, u8 third_order_filt)
+u16 dib0070_wbd_offset(struct dvb_frontend *fe)
 {
         struct dib0070_state *state = fe->tuner_priv;
-    u16 lo5 = (third_order_filt << 14) | (0 << 13) | (1 << 12) | (3 << 9) | (cp_current << 6) | (hf_div_trim << 3) | (vco_bias_trim << 0);
-        dprintk( "CTRL_LO5: 0x%x", lo5);
-        return dib0070_write_reg(state, 0x15, lo5);
+        const struct dib0070_wbd_gain_cfg *tmp = state->cfg->wbd_gain;
+        u32 freq = fe->dtv_property_cache.frequency / 1000;
+
+        if (tmp != NULL) {
+                while (freq / 1000 > tmp->freq) /* find the right one */
+                        tmp++;
+                state->wbd_gain_current = tmp->wbd_gain_val;
+        } else
+                state->wbd_gain_current = 6;
+
+        return state->wbd_offset_3_3[state->wbd_gain_current - 6];
 }
 
+EXPORT_SYMBOL(dib0070_wbd_offset);
+
 #define pgm_read_word(w) (*w)
-static int dib0070_reset(struct dib0070_state *state)
+static int dib0070_reset(struct dvb_frontend *fe)
 {
+        struct dib0070_state *state = fe->tuner_priv;
         u16 l, r, *n;
 
         HARD_RESET(state);
 
-
 #ifndef FORCE_SBAND_TUNER
         if ((dib0070_read_reg(state, 0x22) >> 9) & 0x1)
                 state->revision = (dib0070_read_reg(state, 0x1f) >> 8) & 0xff;
         else
+#else
+#warning forcing SBAND
 #endif
-                state->revision = DIB0070S_P1A;
+        state->revision = DIB0070S_P1A;
 
         /* P1F or not */
-        dprintk( "Revision: %x", state->revision);
+        dprintk("Revision: %x", state->revision);
 
         if (state->revision == DIB0070_P1D) {
-                dprintk( "Error: this driver is not to be used meant for P1D or earlier");
+                dprintk("Error: this driver is not to be used meant for P1D or earlier");
                 return -EINVAL;
         }
 
@@ -498,7 +620,7 @@ static int dib0070_reset(struct dib0070_state *state)
         while (l) {
                 r = pgm_read_word(n++);
                 do {
-                        dib0070_write_reg(state, (u8)r, pgm_read_word(n++));
+                        dib0070_write_reg(state, (u8) r, pgm_read_word(n++));
                         r++;
                 } while (--l);
                 l = pgm_read_word(n++);
@@ -514,24 +636,25 @@ static int dib0070_reset(struct dib0070_state *state)
         r |= state->cfg->osc_buffer_state << 3;
 
         dib0070_write_reg(state, 0x10, r);
-        dib0070_write_reg(state, 0x1f, (1 << 8) | ((state->cfg->clock_pad_drive & 0xf) << 4));
+        dib0070_write_reg(state, 0x1f, (1 << 8) | ((state->cfg->clock_pad_drive & 0xf) << 5));
 
         if (state->cfg->invert_iq) {
                 r = dib0070_read_reg(state, 0x02) & 0xffdf;
                 dib0070_write_reg(state, 0x02, r | (1 << 5));
         }
 
-
         if (state->revision == DIB0070S_P1A)
-                dib0070_set_ctrl_lo5(state->fe, 4, 7, 3, 1);
+                dib0070_set_ctrl_lo5(fe, 2, 4, 3, 0);
         else
-                dib0070_set_ctrl_lo5(state->fe, 4, 4, 2, 0);
+                dib0070_set_ctrl_lo5(fe, 5, 4, state->cfg->charge_pump, state->cfg->enable_third_order_filter);
 
         dib0070_write_reg(state, 0x01, (54 << 9) | 0xc8);
+
+        dib0070_wbd_offset_calibration(state);
+
         return 0;
 }
 
-
 static int dib0070_release(struct dvb_frontend *fe)
 {
         kfree(fe->tuner_priv);
@@ -539,23 +662,24 @@ static int dib0070_release(struct dvb_frontend *fe)
         return 0;
 }
 
-static struct dvb_tuner_ops dib0070_ops = {
+static const struct dvb_tuner_ops dib0070_ops = {
         .info = {
-                .name           = "DiBcom DiB0070",
-                .frequency_min  =  45000000,
-                .frequency_max  = 860000000,
-                .frequency_step =      1000,
-        },
-        .release       = dib0070_release,
-
-        .init          = dib0070_wakeup,
-        .sleep         = dib0070_sleep,
-        .set_params    = dib0070_tune_digital,
-//      .get_frequency = dib0070_get_frequency,
-//      .get_bandwidth = dib0070_get_bandwidth
+                 .name = "DiBcom DiB0070",
+                 .frequency_min = 45000000,
+                 .frequency_max = 860000000,
+                 .frequency_step = 1000,
+                 },
+        .release = dib0070_release,
+
+        .init = dib0070_wakeup,
+        .sleep = dib0070_sleep,
+        .set_params = dib0070_tune,
+
+//      .get_frequency = dib0070_get_frequency,
+//      .get_bandwidth = dib0070_get_bandwidth
 };
 
-struct dvb_frontend * dib0070_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct dib0070_config *cfg)
+struct dvb_frontend *dib0070_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct dib0070_config *cfg)
 {
         struct dib0070_state *state = kzalloc(sizeof(struct dib0070_state), GFP_KERNEL);
         if (state == NULL)
@@ -563,25 +687,24 @@ struct dvb_frontend * dib0070_attach(struct dvb_frontend *fe, struct i2c_adapter
 
         state->cfg = cfg;
         state->i2c = i2c;
-        state->fe  = fe;
+        state->fe = fe;
         fe->tuner_priv = state;
 
-        if (dib0070_reset(state) != 0)
+        if (dib0070_reset(fe) != 0)
                 goto free_mem;
 
-        dib0070_wbd_calibration(fe);
-
         printk(KERN_INFO "DiB0070: successfully identified\n");
         memcpy(&fe->ops.tuner_ops, &dib0070_ops, sizeof(struct dvb_tuner_ops));
 
         fe->tuner_priv = state;
         return fe;
 
-free_mem:
+ free_mem:
         kfree(state);
         fe->tuner_priv = NULL;
         return NULL;
 }
+
 EXPORT_SYMBOL(dib0070_attach);
 
 MODULE_AUTHOR("Patrick Boettcher <pboettcher@dibcom.fr>");
diff --git a/drivers/media/dvb/frontends/dib0070.h b/drivers/media/dvb/frontends/dib0070.h
index 9670f5d20cfb..8a2e1e710adb 100644
--- a/drivers/media/dvb/frontends/dib0070.h
+++ b/drivers/media/dvb/frontends/dib0070.h
@@ -15,6 +15,11 @@ struct i2c_adapter;
 
 #define DEFAULT_DIB0070_I2C_ADDRESS 0x60
 
+struct dib0070_wbd_gain_cfg {
+        u16 freq;
+        u16 wbd_gain_val;
+};
+
 struct dib0070_config {
         u8 i2c_address;
 
@@ -26,26 +31,28 @@ struct dib0070_config {
         int freq_offset_khz_uhf;
         int freq_offset_khz_vhf;
 
-        u8 osc_buffer_state; /* 0= normal, 1= tri-state */
-        u32  clock_khz;
-        u8 clock_pad_drive; /* (Drive + 1) * 2mA */
+        u8 osc_buffer_state;    /* 0= normal, 1= tri-state */
+        u32 clock_khz;
+        u8 clock_pad_drive;     /* (Drive + 1) * 2mA */
 
-        u8 invert_iq; /* invert Q - in case I or Q is inverted on the board */
+        u8 invert_iq;           /* invert Q - in case I or Q is inverted on the board */
 
-        u8 force_crystal_mode; /* if == 0 -> decision is made in the driver default: <24 -> 2, >=24 -> 1 */
+        u8 force_crystal_mode;  /* if == 0 -> decision is made in the driver default: <24 -> 2, >=24 -> 1 */
 
         u8 flip_chip;
+        u8 enable_third_order_filter;
+        u8 charge_pump;
+
+        const struct dib0070_wbd_gain_cfg *wbd_gain;
+
+        u8 vga_filter;
 };
 
 #if defined(CONFIG_DVB_TUNER_DIB0070) || (defined(CONFIG_DVB_TUNER_DIB0070_MODULE) && defined(MODULE))
-extern struct dvb_frontend *dib0070_attach(struct dvb_frontend *fe,
-                                           struct i2c_adapter *i2c,
-                                           struct dib0070_config *cfg);
+extern struct dvb_frontend *dib0070_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct dib0070_config *cfg);
 extern u16 dib0070_wbd_offset(struct dvb_frontend *);
 #else
-static inline struct dvb_frontend *dib0070_attach(struct dvb_frontend *fe,
-                                                  struct i2c_adapter *i2c,
-                                                  struct dib0070_config *cfg)
+static inline struct dvb_frontend *dib0070_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct dib0070_config *cfg)
 {
         printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
         return NULL;
@@ -57,5 +64,6 @@ static inline u16 dib0070_wbd_offset(struct dvb_frontend *fe)
         return -ENODEV;
 }
 #endif
+extern void dib0070_ctrl_agc_filter(struct dvb_frontend *, u8 open);
 
 #endif
diff --git a/drivers/media/dvb/frontends/dib7000p.c b/drivers/media/dvb/frontends/dib7000p.c
index fc96fbf03d6d..55ef6eeb0769 100644
--- a/drivers/media/dvb/frontends/dib7000p.c
+++ b/drivers/media/dvb/frontends/dib7000p.c
@@ -10,6 +10,7 @@
 #include <linux/kernel.h>
 #include <linux/i2c.h>
 
+#include "dvb_math.h"
 #include "dvb_frontend.h"
 
 #include "dib7000p.h"
@@ -1217,7 +1218,37 @@ static int dib7000p_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 
 static int dib7000p_read_snr(struct dvb_frontend* fe, u16 *snr)
 {
-        *snr = 0x0000;
+        struct dib7000p_state *state = fe->demodulator_priv;
+        u16 val;
+        s32 signal_mant, signal_exp, noise_mant, noise_exp;
+        u32 result = 0;
+
+        val = dib7000p_read_word(state, 479);
+        noise_mant = (val >> 4) & 0xff;
+        noise_exp = ((val & 0xf) << 2);
+        val = dib7000p_read_word(state, 480);
+        noise_exp += ((val >> 14) & 0x3);
+        if ((noise_exp & 0x20) != 0)
+                noise_exp -= 0x40;
+
+        signal_mant = (val >> 6) & 0xFF;
+        signal_exp  = (val & 0x3F);
+        if ((signal_exp & 0x20) != 0)
+                signal_exp -= 0x40;
+
+        if (signal_mant != 0)
+                result = intlog10(2) * 10 * signal_exp + 10 *
+                        intlog10(signal_mant);
+        else
+                result = intlog10(2) * 10 * signal_exp - 100;
+
+        if (noise_mant != 0)
+                result -= intlog10(2) * 10 * noise_exp + 10 *
+                        intlog10(noise_mant);
+        else
+                result -= intlog10(2) * 10 * noise_exp - 100;
+
+        *snr = result / ((1 << 24) / 10);
         return 0;
 }
 
diff --git a/drivers/media/dvb/frontends/dib8000.c b/drivers/media/dvb/frontends/dib8000.c
new file mode 100644
index 000000000000..852c790d09d9
--- /dev/null
+++ b/drivers/media/dvb/frontends/dib8000.c
@@ -0,0 +1,2277 @@
+/*
+ * Linux-DVB Driver for DiBcom's DiB8000 chip (ISDB-T).
+ *
+ * Copyright (C) 2009 DiBcom (http://www.dibcom.fr/)
+ *
+ * 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, version 2.
+ */
+#include <linux/kernel.h>
+#include <linux/i2c.h>
+#include "dvb_math.h"
+
+#include "dvb_frontend.h"
+
+#include "dib8000.h"
+
+#define LAYER_ALL -1
+#define LAYER_A   1
+#define LAYER_B   2
+#define LAYER_C   3
+
+#define FE_CALLBACK_TIME_NEVER 0xffffffff
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
+
+#define dprintk(args...) do { if (debug) { printk(KERN_DEBUG "DiB8000: "); printk(args); printk("\n"); } } while (0)
+
+enum frontend_tune_state {
+        CT_AGC_START = 20,
+        CT_AGC_STEP_0,
+        CT_AGC_STEP_1,
+        CT_AGC_STEP_2,
+        CT_AGC_STEP_3,
+        CT_AGC_STEP_4,
+        CT_AGC_STOP,
+
+        CT_DEMOD_START = 30,
+};
+
+#define FE_STATUS_TUNE_FAILED 0
+
+struct i2c_device {
+        struct i2c_adapter *adap;
+        u8 addr;
+};
+
+struct dib8000_state {
+        struct dvb_frontend fe;
+        struct dib8000_config cfg;
+
+        struct i2c_device i2c;
+
+        struct dibx000_i2c_master i2c_master;
+
+        u16 wbd_ref;
+
+        u8 current_band;
+        u32 current_bandwidth;
+        struct dibx000_agc_config *current_agc;
+        u32 timf;
+        u32 timf_default;
+
+        u8 div_force_off:1;
+        u8 div_state:1;
+        u16 div_sync_wait;
+
+        u8 agc_state;
+        u8 differential_constellation;
+        u8 diversity_onoff;
+
+        s16 ber_monitored_layer;
+        u16 gpio_dir;
+        u16 gpio_val;
+
+        u16 revision;
+        u8 isdbt_cfg_loaded;
+        enum frontend_tune_state tune_state;
+        u32 status;
+};
+
+enum dib8000_power_mode {
+        DIB8000M_POWER_ALL = 0,
+        DIB8000M_POWER_INTERFACE_ONLY,
+};
+
+static u16 dib8000_i2c_read16(struct i2c_device *i2c, u16 reg)
+{
+        u8 wb[2] = { reg >> 8, reg & 0xff };
+        u8 rb[2];
+        struct i2c_msg msg[2] = {
+                {.addr = i2c->addr >> 1,.flags = 0,.buf = wb,.len = 2},
+                {.addr = i2c->addr >> 1,.flags = I2C_M_RD,.buf = rb,.len = 2},
+        };
+
+        if (i2c_transfer(i2c->adap, msg, 2) != 2)
+                dprintk("i2c read error on %d", reg);
+
+        return (rb[0] << 8) | rb[1];
+}
+
+static u16 dib8000_read_word(struct dib8000_state *state, u16 reg)
+{
+        return dib8000_i2c_read16(&state->i2c, reg);
+}
+
+static u32 dib8000_read32(struct dib8000_state *state, u16 reg)
+{
+        u16 rw[2];
+
+        rw[0] = dib8000_read_word(state, reg + 0);
+        rw[1] = dib8000_read_word(state, reg + 1);
+
+        return ((rw[0] << 16) | (rw[1]));
+}
+
+static int dib8000_i2c_write16(struct i2c_device *i2c, u16 reg, u16 val)
+{
+        u8 b[4] = {
+                (reg >> 8) & 0xff, reg & 0xff,
+                (val >> 8) & 0xff, val & 0xff,
+        };
+        struct i2c_msg msg = {
+                .addr = i2c->addr >> 1,.flags = 0,.buf = b,.len = 4
+        };
+        return i2c_transfer(i2c->adap, &msg, 1) != 1 ? -EREMOTEIO : 0;
+}
+
+static int dib8000_write_word(struct dib8000_state *state, u16 reg, u16 val)
+{
+        return dib8000_i2c_write16(&state->i2c, reg, val);
+}
+
+const int16_t coeff_2k_sb_1seg_dqpsk[8] = {
+        (769 << 5) | 0x0a, (745 << 5) | 0x03, (595 << 5) | 0x0d, (769 << 5) | 0x0a, (920 << 5) | 0x09, (784 << 5) | 0x02, (519 << 5) | 0x0c,
+            (920 << 5) | 0x09
+};
+
+const int16_t coeff_2k_sb_1seg[8] = {
+        (692 << 5) | 0x0b, (683 << 5) | 0x01, (519 << 5) | 0x09, (692 << 5) | 0x0b, 0 | 0x1f, 0 | 0x1f, 0 | 0x1f, 0 | 0x1f
+};
+
+const int16_t coeff_2k_sb_3seg_0dqpsk_1dqpsk[8] = {
+        (832 << 5) | 0x10, (912 << 5) | 0x05, (900 << 5) | 0x12, (832 << 5) | 0x10, (-931 << 5) | 0x0f, (912 << 5) | 0x04, (807 << 5) | 0x11,
+            (-931 << 5) | 0x0f
+};
+
+const int16_t coeff_2k_sb_3seg_0dqpsk[8] = {
+        (622 << 5) | 0x0c, (941 << 5) | 0x04, (796 << 5) | 0x10, (622 << 5) | 0x0c, (982 << 5) | 0x0c, (519 << 5) | 0x02, (572 << 5) | 0x0e,
+            (982 << 5) | 0x0c
+};
+
+const int16_t coeff_2k_sb_3seg_1dqpsk[8] = {
+        (699 << 5) | 0x14, (607 << 5) | 0x04, (944 << 5) | 0x13, (699 << 5) | 0x14, (-720 << 5) | 0x0d, (640 << 5) | 0x03, (866 << 5) | 0x12,
+            (-720 << 5) | 0x0d
+};
+
+const int16_t coeff_2k_sb_3seg[8] = {
+        (664 << 5) | 0x0c, (925 << 5) | 0x03, (937 << 5) | 0x10, (664 << 5) | 0x0c, (-610 << 5) | 0x0a, (697 << 5) | 0x01, (836 << 5) | 0x0e,
+            (-610 << 5) | 0x0a
+};
+
+const int16_t coeff_4k_sb_1seg_dqpsk[8] = {
+        (-955 << 5) | 0x0e, (687 << 5) | 0x04, (818 << 5) | 0x10, (-955 << 5) | 0x0e, (-922 << 5) | 0x0d, (750 << 5) | 0x03, (665 << 5) | 0x0f,
+            (-922 << 5) | 0x0d
+};
+
+const int16_t coeff_4k_sb_1seg[8] = {
+        (638 << 5) | 0x0d, (683 << 5) | 0x02, (638 << 5) | 0x0d, (638 << 5) | 0x0d, (-655 << 5) | 0x0a, (517 << 5) | 0x00, (698 << 5) | 0x0d,
+            (-655 << 5) | 0x0a
+};
+
+const int16_t coeff_4k_sb_3seg_0dqpsk_1dqpsk[8] = {
+        (-707 << 5) | 0x14, (910 << 5) | 0x06, (889 << 5) | 0x16, (-707 << 5) | 0x14, (-958 << 5) | 0x13, (993 << 5) | 0x05, (523 << 5) | 0x14,
+            (-958 << 5) | 0x13
+};
+
+const int16_t coeff_4k_sb_3seg_0dqpsk[8] = {
+        (-723 << 5) | 0x13, (910 << 5) | 0x05, (777 << 5) | 0x14, (-723 << 5) | 0x13, (-568 << 5) | 0x0f, (547 << 5) | 0x03, (696 << 5) | 0x12,
+            (-568 << 5) | 0x0f
+};
+
+const int16_t coeff_4k_sb_3seg_1dqpsk[8] = {
+        (-940 << 5) | 0x15, (607 << 5) | 0x05, (915 << 5) | 0x16, (-940 << 5) | 0x15, (-848 << 5) | 0x13, (683 << 5) | 0x04, (543 << 5) | 0x14,
+            (-848 << 5) | 0x13
+};
+
+const int16_t coeff_4k_sb_3seg[8] = {
+        (612 << 5) | 0x12, (910 << 5) | 0x04, (864 << 5) | 0x14, (612 << 5) | 0x12, (-869 << 5) | 0x13, (683 << 5) | 0x02, (869 << 5) | 0x12,
+            (-869 << 5) | 0x13
+};
+
+const int16_t coeff_8k_sb_1seg_dqpsk[8] = {
+        (-835 << 5) | 0x12, (684 << 5) | 0x05, (735 << 5) | 0x14, (-835 << 5) | 0x12, (-598 << 5) | 0x10, (781 << 5) | 0x04, (739 << 5) | 0x13,
+            (-598 << 5) | 0x10
+};
+
+const int16_t coeff_8k_sb_1seg[8] = {
+        (673 << 5) | 0x0f, (683 << 5) | 0x03, (808 << 5) | 0x12, (673 << 5) | 0x0f, (585 << 5) | 0x0f, (512 << 5) | 0x01, (780 << 5) | 0x0f,
+            (585 << 5) | 0x0f
+};
+
+const int16_t coeff_8k_sb_3seg_0dqpsk_1dqpsk[8] = {
+        (863 << 5) | 0x17, (930 << 5) | 0x07, (878 << 5) | 0x19, (863 << 5) | 0x17, (0 << 5) | 0x14, (521 << 5) | 0x05, (980 << 5) | 0x18,
+            (0 << 5) | 0x14
+};
+
+const int16_t coeff_8k_sb_3seg_0dqpsk[8] = {
+        (-924 << 5) | 0x17, (910 << 5) | 0x06, (774 << 5) | 0x17, (-924 << 5) | 0x17, (-877 << 5) | 0x15, (565 << 5) | 0x04, (553 << 5) | 0x15,
+            (-877 << 5) | 0x15
+};
+
+const int16_t coeff_8k_sb_3seg_1dqpsk[8] = {
+        (-921 << 5) | 0x19, (607 << 5) | 0x06, (881 << 5) | 0x19, (-921 << 5) | 0x19, (-921 << 5) | 0x14, (713 << 5) | 0x05, (1018 << 5) | 0x18,
+            (-921 << 5) | 0x14
+};
+
+const int16_t coeff_8k_sb_3seg[8] = {
+        (514 << 5) | 0x14, (910 << 5) | 0x05, (861 << 5) | 0x17, (514 << 5) | 0x14, (690 << 5) | 0x14, (683 << 5) | 0x03, (662 << 5) | 0x15,
+            (690 << 5) | 0x14
+};
+
+const int16_t ana_fe_coeff_3seg[24] = {
+        81, 80, 78, 74, 68, 61, 54, 45, 37, 28, 19, 11, 4, 1022, 1017, 1013, 1010, 1008, 1008, 1008, 1008, 1010, 1014, 1017
+};
+
+const int16_t ana_fe_coeff_1seg[24] = {
+        249, 226, 164, 82, 5, 981, 970, 988, 1018, 20, 31, 26, 8, 1012, 1000, 1018, 1012, 8, 15, 14, 9, 3, 1017, 1003
+};
+
+const int16_t ana_fe_coeff_13seg[24] = {
+        396, 305, 105, -51, -77, -12, 41, 31, -11, -30, -11, 14, 15, -2, -13, -7, 5, 8, 1, -6, -7, -3, 0, 1
+};
+
+static u16 fft_to_mode(struct dib8000_state *state)
+{
+        u16 mode;
+        switch (state->fe.dtv_property_cache.transmission_mode) {
+        case TRANSMISSION_MODE_2K:
+                mode = 1;
+                break;
+        case TRANSMISSION_MODE_4K:
+                mode = 2;
+                break;
+        default:
+        case TRANSMISSION_MODE_AUTO:
+        case TRANSMISSION_MODE_8K:
+                mode = 3;
+                break;
+        }
+        return mode;
+}
+
+static void dib8000_set_acquisition_mode(struct dib8000_state *state)
+{
+        u16 nud = dib8000_read_word(state, 298);
+        nud |= (1 << 3) | (1 << 0);
+        dprintk("acquisition mode activated");
+        dib8000_write_word(state, 298, nud);
+}
+
+static int dib8000_set_output_mode(struct dib8000_state *state, int mode)
+{
+        u16 outreg, fifo_threshold, smo_mode, sram = 0x0205;    /* by default SDRAM deintlv is enabled */
+
+        outreg = 0;
+        fifo_threshold = 1792;
+        smo_mode = (dib8000_read_word(state, 299) & 0x0050) | (1 << 1);
+
+        dprintk("-I-  Setting output mode for demod %p to %d", &state->fe, mode);
+
+        switch (mode) {
+        case OUTMODE_MPEG2_PAR_GATED_CLK:       // STBs with parallel gated clock
+                outreg = (1 << 10);     /* 0x0400 */
+                break;
+        case OUTMODE_MPEG2_PAR_CONT_CLK:        // STBs with parallel continues clock
+                outreg = (1 << 10) | (1 << 6);  /* 0x0440 */
+                break;
+        case OUTMODE_MPEG2_SERIAL:      // STBs with serial input
+                outreg = (1 << 10) | (2 << 6) | (0 << 1);       /* 0x0482 */
+                break;
+        case OUTMODE_DIVERSITY:
+                if (state->cfg.hostbus_diversity) {
+                        outreg = (1 << 10) | (4 << 6);  /* 0x0500 */
+                        sram &= 0xfdff;
+                } else
+                        sram |= 0x0c00;
+                break;
+        case OUTMODE_MPEG2_FIFO:        // e.g. USB feeding
+                smo_mode |= (3 << 1);
+                fifo_threshold = 512;
+                outreg = (1 << 10) | (5 << 6);
+                break;
+        case OUTMODE_HIGH_Z:    // disable
+                outreg = 0;
+                break;
+
+        case OUTMODE_ANALOG_ADC:
+                outreg = (1 << 10) | (3 << 6);
+                dib8000_set_acquisition_mode(state);
+                break;
+
+        default:
+                dprintk("Unhandled output_mode passed to be set for demod %p", &state->fe);
+                return -EINVAL;
+        }
+
+        if (state->cfg.output_mpeg2_in_188_bytes)
+                smo_mode |= (1 << 5);
+
+        dib8000_write_word(state, 299, smo_mode);
+        dib8000_write_word(state, 300, fifo_threshold); /* synchronous fread */
+        dib8000_write_word(state, 1286, outreg);
+        dib8000_write_word(state, 1291, sram);
+
+        return 0;
+}
+
+static int dib8000_set_diversity_in(struct dvb_frontend *fe, int onoff)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        u16 sync_wait = dib8000_read_word(state, 273) & 0xfff0;
+
+        if (!state->differential_constellation) {
+                dib8000_write_word(state, 272, 1 << 9); //dvsy_off_lmod4 = 1
+                dib8000_write_word(state, 273, sync_wait | (1 << 2) | 2);       // sync_enable = 1; comb_mode = 2
+        } else {
+                dib8000_write_word(state, 272, 0);      //dvsy_off_lmod4 = 0
+                dib8000_write_word(state, 273, sync_wait);      // sync_enable = 0; comb_mode = 0
+        }
+        state->diversity_onoff = onoff;
+
+        switch (onoff) {
+        case 0:         /* only use the internal way - not the diversity input */
+                dib8000_write_word(state, 270, 1);
+                dib8000_write_word(state, 271, 0);
+                break;
+        case 1:         /* both ways */
+                dib8000_write_word(state, 270, 6);
+                dib8000_write_word(state, 271, 6);
+                break;
+        case 2:         /* only the diversity input */
+                dib8000_write_word(state, 270, 0);
+                dib8000_write_word(state, 271, 1);
+                break;
+        }
+        return 0;
+}
+
+static void dib8000_set_power_mode(struct dib8000_state *state, enum dib8000_power_mode mode)
+{
+        /* by default everything is going to be powered off */
+        u16 reg_774 = 0x3fff, reg_775 = 0xffff, reg_776 = 0xffff,
+            reg_900 = (dib8000_read_word(state, 900) & 0xfffc) | 0x3, reg_1280 = (dib8000_read_word(state, 1280) & 0x00ff) | 0xff00;
+
+        /* now, depending on the requested mode, we power on */
+        switch (mode) {
+                /* power up everything in the demod */
+        case DIB8000M_POWER_ALL:
+                reg_774 = 0x0000;
+                reg_775 = 0x0000;
+                reg_776 = 0x0000;
+                reg_900 &= 0xfffc;
+                reg_1280 &= 0x00ff;
+                break;
+        case DIB8000M_POWER_INTERFACE_ONLY:
+                reg_1280 &= 0x00ff;
+                break;
+        }
+
+        dprintk("powermode : 774 : %x ; 775 : %x; 776 : %x ; 900 : %x; 1280 : %x", reg_774, reg_775, reg_776, reg_900, reg_1280);
+        dib8000_write_word(state, 774, reg_774);
+        dib8000_write_word(state, 775, reg_775);
+        dib8000_write_word(state, 776, reg_776);
+        dib8000_write_word(state, 900, reg_900);
+        dib8000_write_word(state, 1280, reg_1280);
+}
+
+static int dib8000_set_adc_state(struct dib8000_state *state, enum dibx000_adc_states no)
+{
+        int ret = 0;
+        u16 reg_907 = dib8000_read_word(state, 907), reg_908 = dib8000_read_word(state, 908);
+
+        switch (no) {
+        case DIBX000_SLOW_ADC_ON:
+                reg_908 |= (1 << 1) | (1 << 0);
+                ret |= dib8000_write_word(state, 908, reg_908);
+                reg_908 &= ~(1 << 1);
+                break;
+
+        case DIBX000_SLOW_ADC_OFF:
+                reg_908 |= (1 << 1) | (1 << 0);
+                break;
+
+        case DIBX000_ADC_ON:
+                reg_907 &= 0x0fff;
+                reg_908 &= 0x0003;
+                break;
+
+        case DIBX000_ADC_OFF:   // leave the VBG voltage on
+                reg_907 |= (1 << 14) | (1 << 13) | (1 << 12);
+                reg_908 |= (1 << 5) | (1 << 4) | (1 << 3) | (1 << 2);
+                break;
+
+        case DIBX000_VBG_ENABLE:
+                reg_907 &= ~(1 << 15);
+                break;
+
+        case DIBX000_VBG_DISABLE:
+                reg_907 |= (1 << 15);
+                break;
+
+        default:
+                break;
+        }
+
+        ret |= dib8000_write_word(state, 907, reg_907);
+        ret |= dib8000_write_word(state, 908, reg_908);
+
+        return ret;
+}
+
+static int dib8000_set_bandwidth(struct dib8000_state *state, u32 bw)
+{
+        u32 timf;
+
+        if (bw == 0)
+                bw = 6000;
+
+        if (state->timf == 0) {
+                dprintk("using default timf");
+                timf = state->timf_default;
+        } else {
+                dprintk("using updated timf");
+                timf = state->timf;
+        }
+
+        dib8000_write_word(state, 29, (u16) ((timf >> 16) & 0xffff));
+        dib8000_write_word(state, 30, (u16) ((timf) & 0xffff));
+
+        return 0;
+}
+
+static int dib8000_sad_calib(struct dib8000_state *state)
+{
+/* internal */
+        dib8000_write_word(state, 923, (0 << 1) | (0 << 0));
+        dib8000_write_word(state, 924, 776);    // 0.625*3.3 / 4096
+
+        /* do the calibration */
+        dib8000_write_word(state, 923, (1 << 0));
+        dib8000_write_word(state, 923, (0 << 0));
+
+        msleep(1);
+        return 0;
+}
+
+int dib8000_set_wbd_ref(struct dvb_frontend *fe, u16 value)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        if (value > 4095)
+                value = 4095;
+        state->wbd_ref = value;
+        return dib8000_write_word(state, 106, value);
+}
+
+EXPORT_SYMBOL(dib8000_set_wbd_ref);
+static void dib8000_reset_pll_common(struct dib8000_state *state, const struct dibx000_bandwidth_config *bw)
+{
+        dprintk("ifreq: %d %x, inversion: %d", bw->ifreq, bw->ifreq, bw->ifreq >> 25);
+        dib8000_write_word(state, 23, (u16) (((bw->internal * 1000) >> 16) & 0xffff));  /* P_sec_len */
+        dib8000_write_word(state, 24, (u16) ((bw->internal * 1000) & 0xffff));
+        dib8000_write_word(state, 27, (u16) ((bw->ifreq >> 16) & 0x01ff));
+        dib8000_write_word(state, 28, (u16) (bw->ifreq & 0xffff));
+        dib8000_write_word(state, 26, (u16) ((bw->ifreq >> 25) & 0x0003));
+
+        dib8000_write_word(state, 922, bw->sad_cfg);
+}
+
+static void dib8000_reset_pll(struct dib8000_state *state)
+{
+        const struct dibx000_bandwidth_config *pll = state->cfg.pll;
+        u16 clk_cfg1;
+
+        // clk_cfg0
+        dib8000_write_word(state, 901, (pll->pll_prediv << 8) | (pll->pll_ratio << 0));
+
+        // clk_cfg1
+        clk_cfg1 = (1 << 10) | (0 << 9) | (pll->IO_CLK_en_core << 8) |
+            (pll->bypclk_div << 5) | (pll->enable_refdiv << 4) | (1 << 3) | (pll->pll_range << 1) | (pll->pll_reset << 0);
+
+        dib8000_write_word(state, 902, clk_cfg1);
+        clk_cfg1 = (clk_cfg1 & 0xfff7) | (pll->pll_bypass << 3);
+        dib8000_write_word(state, 902, clk_cfg1);
+
+        dprintk("clk_cfg1: 0x%04x", clk_cfg1);  /* 0x507 1 0 1 000 0 0 11 1 */
+
+        /* smpl_cfg: P_refclksel=2, P_ensmplsel=1 nodivsmpl=1 */
+        if (state->cfg.pll->ADClkSrc == 0)
+                dib8000_write_word(state, 904, (0 << 15) | (0 << 12) | (0 << 10) | (pll->modulo << 8) | (pll->ADClkSrc << 7) | (0 << 1));
+        else if (state->cfg.refclksel != 0)
+                dib8000_write_word(state, 904,
+                                   (0 << 15) | (1 << 12) | ((state->cfg.refclksel & 0x3) << 10) | (pll->modulo << 8) | (pll->
+                                                                                                                        ADClkSrc << 7) | (0 << 1));
+        else
+                dib8000_write_word(state, 904, (0 << 15) | (1 << 12) | (3 << 10) | (pll->modulo << 8) | (pll->ADClkSrc << 7) | (0 << 1));
+
+        dib8000_reset_pll_common(state, pll);
+}
+
+static int dib8000_reset_gpio(struct dib8000_state *st)
+{
+        /* reset the GPIOs */
+        dib8000_write_word(st, 1029, st->cfg.gpio_dir);
+        dib8000_write_word(st, 1030, st->cfg.gpio_val);
+
+        /* TODO 782 is P_gpio_od */
+
+        dib8000_write_word(st, 1032, st->cfg.gpio_pwm_pos);
+
+        dib8000_write_word(st, 1037, st->cfg.pwm_freq_div);
+        return 0;
+}
+
+static int dib8000_cfg_gpio(struct dib8000_state *st, u8 num, u8 dir, u8 val)
+{
+        st->cfg.gpio_dir = dib8000_read_word(st, 1029);
+        st->cfg.gpio_dir &= ~(1 << num);        /* reset the direction bit */
+        st->cfg.gpio_dir |= (dir & 0x1) << num; /* set the new direction */
+        dib8000_write_word(st, 1029, st->cfg.gpio_dir);
+
+        st->cfg.gpio_val = dib8000_read_word(st, 1030);
+        st->cfg.gpio_val &= ~(1 << num);        /* reset the direction bit */
+        st->cfg.gpio_val |= (val & 0x01) << num;        /* set the new value */
+        dib8000_write_word(st, 1030, st->cfg.gpio_val);
+
+        dprintk("gpio dir: %x: gpio val: %x", st->cfg.gpio_dir, st->cfg.gpio_val);
+
+        return 0;
+}
+
+int dib8000_set_gpio(struct dvb_frontend *fe, u8 num, u8 dir, u8 val)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        return dib8000_cfg_gpio(state, num, dir, val);
+}
+
+EXPORT_SYMBOL(dib8000_set_gpio);
+static const u16 dib8000_defaults[] = {
+        /* auto search configuration - lock0 by default waiting
+         * for cpil_lock; lock1 cpil_lock; lock2 tmcc_sync_lock */
+        3, 7,
+        0x0004,
+        0x0400,
+        0x0814,
+
+        12, 11,
+        0x001b,
+        0x7740,
+        0x005b,
+        0x8d80,
+        0x01c9,
+        0xc380,
+        0x0000,
+        0x0080,
+        0x0000,
+        0x0090,
+        0x0001,
+        0xd4c0,
+
+        /*1, 32,
+           0x6680 // P_corm_thres Lock algorithms configuration */
+
+        11, 80,                 /* set ADC level to -16 */
+        (1 << 13) - 825 - 117,
+        (1 << 13) - 837 - 117,
+        (1 << 13) - 811 - 117,
+        (1 << 13) - 766 - 117,
+        (1 << 13) - 737 - 117,
+        (1 << 13) - 693 - 117,
+        (1 << 13) - 648 - 117,
+        (1 << 13) - 619 - 117,
+        (1 << 13) - 575 - 117,
+        (1 << 13) - 531 - 117,
+        (1 << 13) - 501 - 117,
+
+        4, 108,
+        0,
+        0,
+        0,
+        0,
+
+        1, 175,
+        0x0410,
+        1, 179,
+        8192,                   // P_fft_nb_to_cut
+
+        6, 181,
+        0x2800,                 // P_coff_corthres_ ( 2k 4k 8k ) 0x2800
+        0x2800,
+        0x2800,
+        0x2800,                 // P_coff_cpilthres_ ( 2k 4k 8k ) 0x2800
+        0x2800,
+        0x2800,
+
+        2, 193,
+        0x0666,                 // P_pha3_thres
+        0x0000,                 // P_cti_use_cpe, P_cti_use_prog
+
+        2, 205,
+        0x200f,                 // P_cspu_regul, P_cspu_win_cut
+        0x000f,                 // P_des_shift_work
+
+        5, 215,
+        0x023d,                 // P_adp_regul_cnt
+        0x00a4,                 // P_adp_noise_cnt
+        0x00a4,                 // P_adp_regul_ext
+        0x7ff0,                 // P_adp_noise_ext
+        0x3ccc,                 // P_adp_fil
+
+        1, 230,
+        0x0000,                 // P_2d_byp_ti_num
+
+        1, 263,
+        0x800,                  //P_equal_thres_wgn
+
+        1, 268,
+        (2 << 9) | 39,          // P_equal_ctrl_synchro, P_equal_speedmode
+
+        1, 270,
+        0x0001,                 // P_div_lock0_wait
+        1, 285,
+        0x0020,                 //p_fec_
+        1, 299,
+        0x0062,                 // P_smo_mode, P_smo_rs_discard, P_smo_fifo_flush, P_smo_pid_parse, P_smo_error_discard
+
+        1, 338,
+        (1 << 12) |             // P_ctrl_corm_thres4pre_freq_inh=1
+            (1 << 10) |         // P_ctrl_pre_freq_mode_sat=1
+            (0 << 9) |          // P_ctrl_pre_freq_inh=0
+            (3 << 5) |          // P_ctrl_pre_freq_step=3
+            (1 << 0),           // P_pre_freq_win_len=1
+
+        1, 903,
+        (0 << 4) | 2,           // P_divclksel=0 P_divbitsel=2 (was clk=3,bit=1 for MPW)
+
+        0,
+};
+
+static u16 dib8000_identify(struct i2c_device *client)
+{
+        u16 value;
+
+        //because of glitches sometimes
+        value = dib8000_i2c_read16(client, 896);
+
+        if ((value = dib8000_i2c_read16(client, 896)) != 0x01b3) {
+                dprintk("wrong Vendor ID (read=0x%x)", value);
+                return 0;
+        }
+
+        value = dib8000_i2c_read16(client, 897);
+        if (value != 0x8000 && value != 0x8001 && value != 0x8002) {
+                dprintk("wrong Device ID (%x)", value);
+                return 0;
+        }
+
+        switch (value) {
+        case 0x8000:
+                dprintk("found DiB8000A");
+                break;
+        case 0x8001:
+                dprintk("found DiB8000B");
+                break;
+        case 0x8002:
+                dprintk("found DiB8000C");
+                break;
+        }
+        return value;
+}
+
+static int dib8000_reset(struct dvb_frontend *fe)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+
+        dib8000_write_word(state, 1287, 0x0003);        /* sram lead in, rdy */
+
+        if ((state->revision = dib8000_identify(&state->i2c)) == 0)
+                return -EINVAL;
+
+        if (state->revision == 0x8000)
+                dprintk("error : dib8000 MA not supported");
+
+        dibx000_reset_i2c_master(&state->i2c_master);
+
+        dib8000_set_power_mode(state, DIB8000M_POWER_ALL);
+
+        /* always leave the VBG voltage on - it consumes almost nothing but takes a long time to start */
+        dib8000_set_adc_state(state, DIBX000_VBG_ENABLE);
+
+        /* restart all parts */
+        dib8000_write_word(state, 770, 0xffff);
+        dib8000_write_word(state, 771, 0xffff);
+        dib8000_write_word(state, 772, 0xfffc);
+        dib8000_write_word(state, 898, 0x000c); // sad
+        dib8000_write_word(state, 1280, 0x004d);
+        dib8000_write_word(state, 1281, 0x000c);
+
+        dib8000_write_word(state, 770, 0x0000);
+        dib8000_write_word(state, 771, 0x0000);
+        dib8000_write_word(state, 772, 0x0000);
+        dib8000_write_word(state, 898, 0x0004); // sad
+        dib8000_write_word(state, 1280, 0x0000);
+        dib8000_write_word(state, 1281, 0x0000);
+
+        /* drives */
+        if (state->cfg.drives)
+                dib8000_write_word(state, 906, state->cfg.drives);
+        else {
+                dprintk("using standard PAD-drive-settings, please adjust settings in config-struct to be optimal.");
+                dib8000_write_word(state, 906, 0x2d98); // min drive SDRAM - not optimal - adjust
+        }
+
+        dib8000_reset_pll(state);
+
+        if (dib8000_reset_gpio(state) != 0)
+                dprintk("GPIO reset was not successful.");
+
+        if (dib8000_set_output_mode(state, OUTMODE_HIGH_Z) != 0)
+                dprintk("OUTPUT_MODE could not be resetted.");
+
+        state->current_agc = NULL;
+
+        // P_iqc_alpha_pha, P_iqc_alpha_amp, P_iqc_dcc_alpha, ...
+        /* P_iqc_ca2 = 0; P_iqc_impnc_on = 0; P_iqc_mode = 0; */
+        if (state->cfg.pll->ifreq == 0)
+                dib8000_write_word(state, 40, 0x0755);  /* P_iqc_corr_inh = 0 enable IQcorr block */
+        else
+                dib8000_write_word(state, 40, 0x1f55);  /* P_iqc_corr_inh = 1 disable IQcorr block */
+
+        {
+                u16 l = 0, r;
+                const u16 *n;
+                n = dib8000_defaults;
+                l = *n++;
+                while (l) {
+                        r = *n++;
+                        do {
+                                dib8000_write_word(state, r, *n++);
+                                r++;
+                        } while (--l);
+                        l = *n++;
+                }
+        }
+        state->isdbt_cfg_loaded = 0;
+
+        //div_cfg override for special configs
+        if (state->cfg.div_cfg != 0)
+                dib8000_write_word(state, 903, state->cfg.div_cfg);
+
+        /* unforce divstr regardless whether i2c enumeration was done or not */
+        dib8000_write_word(state, 1285, dib8000_read_word(state, 1285) & ~(1 << 1));
+
+        dib8000_set_bandwidth(state, 6000);
+
+        dib8000_set_adc_state(state, DIBX000_SLOW_ADC_ON);
+        dib8000_sad_calib(state);
+        dib8000_set_adc_state(state, DIBX000_SLOW_ADC_OFF);
+
+        dib8000_set_power_mode(state, DIB8000M_POWER_INTERFACE_ONLY);
+
+        return 0;
+}
+
+static void dib8000_restart_agc(struct dib8000_state *state)
+{
+        // P_restart_iqc & P_restart_agc
+        dib8000_write_word(state, 770, 0x0a00);
+        dib8000_write_word(state, 770, 0x0000);
+}
+
+static int dib8000_update_lna(struct dib8000_state *state)
+{
+        u16 dyn_gain;
+
+        if (state->cfg.update_lna) {
+                // read dyn_gain here (because it is demod-dependent and not tuner)
+                dyn_gain = dib8000_read_word(state, 390);
+
+                if (state->cfg.update_lna(&state->fe, dyn_gain)) {      // LNA has changed
+                        dib8000_restart_agc(state);
+                        return 1;
+                }
+        }
+        return 0;
+}
+
+static int dib8000_set_agc_config(struct dib8000_state *state, u8 band)
+{
+        struct dibx000_agc_config *agc = NULL;
+        int i;
+        if (state->current_band == band && state->current_agc != NULL)
+                return 0;
+        state->current_band = band;
+
+        for (i = 0; i < state->cfg.agc_config_count; i++)
+                if (state->cfg.agc[i].band_caps & band) {
+                        agc = &state->cfg.agc[i];
+                        break;
+                }
+
+        if (agc == NULL) {
+                dprintk("no valid AGC configuration found for band 0x%02x", band);
+                return -EINVAL;
+        }
+
+        state->current_agc = agc;
+
+        /* AGC */
+        dib8000_write_word(state, 76, agc->setup);
+        dib8000_write_word(state, 77, agc->inv_gain);
+        dib8000_write_word(state, 78, agc->time_stabiliz);
+        dib8000_write_word(state, 101, (agc->alpha_level << 12) | agc->thlock);
+
+        // Demod AGC loop configuration
+        dib8000_write_word(state, 102, (agc->alpha_mant << 5) | agc->alpha_exp);
+        dib8000_write_word(state, 103, (agc->beta_mant << 6) | agc->beta_exp);
+
+        dprintk("WBD: ref: %d, sel: %d, active: %d, alpha: %d",
+                state->wbd_ref != 0 ? state->wbd_ref : agc->wbd_ref, agc->wbd_sel, !agc->perform_agc_softsplit, agc->wbd_sel);
+
+        /* AGC continued */
+        if (state->wbd_ref != 0)
+                dib8000_write_word(state, 106, state->wbd_ref);
+        else                    // use default
+                dib8000_write_word(state, 106, agc->wbd_ref);
+        dib8000_write_word(state, 107, (agc->wbd_alpha << 9) | (agc->perform_agc_softsplit << 8));
+        dib8000_write_word(state, 108, agc->agc1_max);
+        dib8000_write_word(state, 109, agc->agc1_min);
+        dib8000_write_word(state, 110, agc->agc2_max);
+        dib8000_write_word(state, 111, agc->agc2_min);
+        dib8000_write_word(state, 112, (agc->agc1_pt1 << 8) | agc->agc1_pt2);
+        dib8000_write_word(state, 113, (agc->agc1_slope1 << 8) | agc->agc1_slope2);
+        dib8000_write_word(state, 114, (agc->agc2_pt1 << 8) | agc->agc2_pt2);
+        dib8000_write_word(state, 115, (agc->agc2_slope1 << 8) | agc->agc2_slope2);
+
+        dib8000_write_word(state, 75, agc->agc1_pt3);
+        dib8000_write_word(state, 923, (dib8000_read_word(state, 923) & 0xffe3) | (agc->wbd_inv << 4) | (agc->wbd_sel << 2));   /*LB : 929 -> 923 */
+
+        return 0;
+}
+
+static int dib8000_agc_soft_split(struct dib8000_state *state)
+{
+        u16 agc, split_offset;
+
+        if (!state->current_agc || !state->current_agc->perform_agc_softsplit || state->current_agc->split.max == 0)
+                return FE_CALLBACK_TIME_NEVER;
+
+        // n_agc_global
+        agc = dib8000_read_word(state, 390);
+
+        if (agc > state->current_agc->split.min_thres)
+                split_offset = state->current_agc->split.min;
+        else if (agc < state->current_agc->split.max_thres)
+                split_offset = state->current_agc->split.max;
+        else
+                split_offset = state->current_agc->split.max *
+                    (agc - state->current_agc->split.min_thres) / (state->current_agc->split.max_thres - state->current_agc->split.min_thres);
+
+        dprintk("AGC split_offset: %d", split_offset);
+
+        // P_agc_force_split and P_agc_split_offset
+        dib8000_write_word(state, 107, (dib8000_read_word(state, 107) & 0xff00) | split_offset);
+        return 5000;
+}
+
+static int dib8000_agc_startup(struct dvb_frontend *fe)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        enum frontend_tune_state *tune_state = &state->tune_state;
+
+        int ret = 0;
+
+        switch (*tune_state) {
+        case CT_AGC_START:
+                // set power-up level: interf+analog+AGC
+
+                dib8000_set_adc_state(state, DIBX000_ADC_ON);
+
+                if (dib8000_set_agc_config(state, (unsigned char)(BAND_OF_FREQUENCY(fe->dtv_property_cache.frequency / 1000))) != 0) {
+                        *tune_state = CT_AGC_STOP;
+                        state->status = FE_STATUS_TUNE_FAILED;
+                        break;
+                }
+
+                ret = 70;
+                *tune_state = CT_AGC_STEP_0;
+                break;
+
+        case CT_AGC_STEP_0:
+                //AGC initialization
+                if (state->cfg.agc_control)
+                        state->cfg.agc_control(&state->fe, 1);
+
+                dib8000_restart_agc(state);
+
+                // wait AGC rough lock time
+                ret = 50;
+                *tune_state = CT_AGC_STEP_1;
+                break;
+
+        case CT_AGC_STEP_1:
+                // wait AGC accurate lock time
+                ret = 70;
+
+                if (dib8000_update_lna(state))
+                        // wait only AGC rough lock time
+                        ret = 50;
+                else
+                        *tune_state = CT_AGC_STEP_2;
+                break;
+
+        case CT_AGC_STEP_2:
+                dib8000_agc_soft_split(state);
+
+                if (state->cfg.agc_control)
+                        state->cfg.agc_control(&state->fe, 0);
+
+                *tune_state = CT_AGC_STOP;
+                break;
+        default:
+                ret = dib8000_agc_soft_split(state);
+                break;
+        }
+        return ret;
+
+}
+
+static void dib8000_update_timf(struct dib8000_state *state)
+{
+        u32 timf = state->timf = dib8000_read32(state, 435);
+
+        dib8000_write_word(state, 29, (u16) (timf >> 16));
+        dib8000_write_word(state, 30, (u16) (timf & 0xffff));
+        dprintk("Updated timing frequency: %d (default: %d)", state->timf, state->timf_default);
+}
+
+static void dib8000_set_channel(struct dib8000_state *state, u8 seq, u8 autosearching)
+{
+        u16 mode, max_constellation, seg_diff_mask = 0, nbseg_diff = 0;
+        u8 guard, crate, constellation, timeI;
+        u8 permu_seg[] = { 6, 5, 7, 4, 8, 3, 9, 2, 10, 1, 11, 0, 12 };
+        u16 i, coeff[4], P_cfr_left_edge = 0, P_cfr_right_edge = 0, seg_mask13 = 0x1fff;        // All 13 segments enabled
+        const s16 *ncoeff, *ana_fe;
+        u16 tmcc_pow = 0;
+        u16 coff_pow = 0x2800;
+        u16 init_prbs = 0xfff;
+        u16 ana_gain = 0;
+        u16 adc_target_16dB[11] = {
+                (1 << 13) - 825 - 117,
+                (1 << 13) - 837 - 117,
+                (1 << 13) - 811 - 117,
+                (1 << 13) - 766 - 117,
+                (1 << 13) - 737 - 117,
+                (1 << 13) - 693 - 117,
+                (1 << 13) - 648 - 117,
+                (1 << 13) - 619 - 117,
+                (1 << 13) - 575 - 117,
+                (1 << 13) - 531 - 117,
+                (1 << 13) - 501 - 117
+        };
+
+        if (state->ber_monitored_layer != LAYER_ALL)
+                dib8000_write_word(state, 285, (dib8000_read_word(state, 285) & 0x60) | state->ber_monitored_layer);
+        else
+                dib8000_write_word(state, 285, dib8000_read_word(state, 285) & 0x60);
+
+        i = dib8000_read_word(state, 26) & 1;   // P_dds_invspec
+        dib8000_write_word(state, 26, state->fe.dtv_property_cache.inversion ^ i);
+
+        if (state->fe.dtv_property_cache.isdbt_sb_mode) {
+                //compute new dds_freq for the seg and adjust prbs
+                int seg_offset =
+                    state->fe.dtv_property_cache.isdbt_sb_segment_idx - (state->fe.dtv_property_cache.isdbt_sb_segment_count / 2) -
+                    (state->fe.dtv_property_cache.isdbt_sb_segment_count % 2);
+                int clk = state->cfg.pll->internal;
+                u32 segtodds = ((u32) (430 << 23) / clk) << 3;  // segtodds = SegBW / Fclk * pow(2,26)
+                int dds_offset = seg_offset * segtodds;
+                int new_dds, sub_channel;
+                if ((state->fe.dtv_property_cache.isdbt_sb_segment_count % 2) == 0)     // if even
+                        dds_offset -= (int)(segtodds / 2);
+
+                if (state->cfg.pll->ifreq == 0) {
+                        if ((state->fe.dtv_property_cache.inversion ^ i) == 0) {
+                                dib8000_write_word(state, 26, dib8000_read_word(state, 26) | 1);
+                                new_dds = dds_offset;
+                        } else
+                                new_dds = dds_offset;
+
+                        // We shift tuning frequency if the wanted segment is :
+                        //  - the segment of center frequency with an odd total number of segments
+                        //  - the segment to the left of center frequency with an even total number of segments
+                        //  - the segment to the right of center frequency with an even total number of segments
+                        if ((state->fe.dtv_property_cache.delivery_system == SYS_ISDBT) && (state->fe.dtv_property_cache.isdbt_sb_mode == 1)
+                            &&
+                            (((state->fe.dtv_property_cache.isdbt_sb_segment_count % 2)
+                              && (state->fe.dtv_property_cache.isdbt_sb_segment_idx ==
+                                  ((state->fe.dtv_property_cache.isdbt_sb_segment_count / 2) + 1)))
+                             || (((state->fe.dtv_property_cache.isdbt_sb_segment_count % 2) == 0)
+                                 && (state->fe.dtv_property_cache.isdbt_sb_segment_idx == (state->fe.dtv_property_cache.isdbt_sb_segment_count / 2)))
+                             || (((state->fe.dtv_property_cache.isdbt_sb_segment_count % 2) == 0)
+                                 && (state->fe.dtv_property_cache.isdbt_sb_segment_idx ==
+                                     ((state->fe.dtv_property_cache.isdbt_sb_segment_count / 2) + 1)))
+                            )) {
+                                new_dds -= ((u32) (850 << 22) / clk) << 4;      // new_dds = 850 (freq shift in KHz) / Fclk * pow(2,26)
+                        }
+                } else {
+                        if ((state->fe.dtv_property_cache.inversion ^ i) == 0)
+                                new_dds = state->cfg.pll->ifreq - dds_offset;
+                        else
+                                new_dds = state->cfg.pll->ifreq + dds_offset;
+                }
+                dib8000_write_word(state, 27, (u16) ((new_dds >> 16) & 0x01ff));
+                dib8000_write_word(state, 28, (u16) (new_dds & 0xffff));
+                if (state->fe.dtv_property_cache.isdbt_sb_segment_count % 2)    // if odd
+                        sub_channel = ((state->fe.dtv_property_cache.isdbt_sb_subchannel + (3 * seg_offset) + 1) % 41) / 3;
+                else            // if even
+                        sub_channel = ((state->fe.dtv_property_cache.isdbt_sb_subchannel + (3 * seg_offset)) % 41) / 3;
+                sub_channel -= 6;
+
+                if (state->fe.dtv_property_cache.transmission_mode == TRANSMISSION_MODE_2K
+                    || state->fe.dtv_property_cache.transmission_mode == TRANSMISSION_MODE_4K) {
+                        dib8000_write_word(state, 219, dib8000_read_word(state, 219) | 0x1);    //adp_pass =1
+                        dib8000_write_word(state, 190, dib8000_read_word(state, 190) | (0x1 << 14));    //pha3_force_pha_shift = 1
+                } else {
+                        dib8000_write_word(state, 219, dib8000_read_word(state, 219) & 0xfffe); //adp_pass =0
+                        dib8000_write_word(state, 190, dib8000_read_word(state, 190) & 0xbfff); //pha3_force_pha_shift = 0
+                }
+
+                switch (state->fe.dtv_property_cache.transmission_mode) {
+                case TRANSMISSION_MODE_2K:
+                        switch (sub_channel) {
+                        case -6:
+                                init_prbs = 0x0;
+                                break;  // 41, 0, 1
+                        case -5:
+                                init_prbs = 0x423;
+                                break;  // 02~04
+                        case -4:
+                                init_prbs = 0x9;
+                                break;  // 05~07
+                        case -3:
+                                init_prbs = 0x5C7;
+                                break;  // 08~10
+                        case -2:
+                                init_prbs = 0x7A6;
+                                break;  // 11~13
+                        case -1:
+                                init_prbs = 0x3D8;
+                                break;  // 14~16
+                        case 0:
+                                init_prbs = 0x527;
+                                break;  // 17~19
+                        case 1:
+                                init_prbs = 0x7FF;
+                                break;  // 20~22
+                        case 2:
+                                init_prbs = 0x79B;
+                                break;  // 23~25
+                        case 3:
+                                init_prbs = 0x3D6;
+                                break;  // 26~28
+                        case 4:
+                                init_prbs = 0x3A2;
+                                break;  // 29~31
+                        case 5:
+                                init_prbs = 0x53B;
+                                break;  // 32~34
+                        case 6:
+                                init_prbs = 0x2F4;
+                                break;  // 35~37
+                        default:
+                        case 7:
+                                init_prbs = 0x213;
+                                break;  // 38~40
+                        }
+                        break;
+
+                case TRANSMISSION_MODE_4K:
+                        switch (sub_channel) {
+                        case -6:
+                                init_prbs = 0x0;
+                                break;  // 41, 0, 1
+                        case -5:
+                                init_prbs = 0x208;
+                                break;  // 02~04
+                        case -4:
+                                init_prbs = 0xC3;
+                                break;  // 05~07
+                        case -3:
+                                init_prbs = 0x7B9;
+                                break;  // 08~10
+                        case -2:
+                                init_prbs = 0x423;
+                                break;  // 11~13
+                        case -1:
+                                init_prbs = 0x5C7;
+                                break;  // 14~16
+                        case 0:
+                                init_prbs = 0x3D8;
+                                break;  // 17~19
+                        case 1:
+                                init_prbs = 0x7FF;
+                                break;  // 20~22
+                        case 2:
+                                init_prbs = 0x3D6;
+                                break;  // 23~25
+                        case 3:
+                                init_prbs = 0x53B;
+                                break;  // 26~28
+                        case 4:
+                                init_prbs = 0x213;
+                                break;  // 29~31
+                        case 5:
+                                init_prbs = 0x29;
+                                break;  // 32~34
+                        case 6:
+                                init_prbs = 0xD0;
+                                break;  // 35~37
+                        default:
+                        case 7:
+                                init_prbs = 0x48E;
+                                break;  // 38~40
+                        }
+                        break;
+
+                default:
+                case TRANSMISSION_MODE_8K:
+                        switch (sub_channel) {
+                        case -6:
+                                init_prbs = 0x0;
+                                break;  // 41, 0, 1
+                        case -5:
+                                init_prbs = 0x740;
+                                break;  // 02~04
+                        case -4:
+                                init_prbs = 0x069;
+                                break;  // 05~07
+                        case -3:
+                                init_prbs = 0x7DD;
+                                break;  // 08~10
+                        case -2:
+                                init_prbs = 0x208;
+                                break;  // 11~13
+                        case -1:
+                                init_prbs = 0x7B9;
+                                break;  // 14~16
+                        case 0:
+                                init_prbs = 0x5C7;
+                                break;  // 17~19
+                        case 1:
+                                init_prbs = 0x7FF;
+                                break;  // 20~22
+                        case 2:
+                                init_prbs = 0x53B;
+                                break;  // 23~25
+                        case 3:
+                                init_prbs = 0x29;
+                                break;  // 26~28
+                        case 4:
+                                init_prbs = 0x48E;
+                                break;  // 29~31
+                        case 5:
+                                init_prbs = 0x4C4;
+                                break;  // 32~34
+                        case 6:
+                                init_prbs = 0x367;
+                                break;  // 33~37
+                        default:
+                        case 7:
+                                init_prbs = 0x684;
+                                break;  // 38~40
+                        }
+                        break;
+                }
+        } else {                // if not state->fe.dtv_property_cache.isdbt_sb_mode
+                dib8000_write_word(state, 27, (u16) ((state->cfg.pll->ifreq >> 16) & 0x01ff));
+                dib8000_write_word(state, 28, (u16) (state->cfg.pll->ifreq & 0xffff));
+                dib8000_write_word(state, 26, (u16) ((state->cfg.pll->ifreq >> 25) & 0x0003));
+        }
+        /*P_mode == ?? */
+        dib8000_write_word(state, 10, (seq << 4));
+        //  dib8000_write_word(state, 287, (dib8000_read_word(state, 287) & 0xe000) | 0x1000);
+
+        switch (state->fe.dtv_property_cache.guard_interval) {
+        case GUARD_INTERVAL_1_32:
+                guard = 0;
+                break;
+        case GUARD_INTERVAL_1_16:
+                guard = 1;
+                break;
+        case GUARD_INTERVAL_1_8:
+                guard = 2;
+                break;
+        case GUARD_INTERVAL_1_4:
+        default:
+                guard = 3;
+                break;
+        }
+
+        dib8000_write_word(state, 1, (init_prbs << 2) | (guard & 0x3)); // ADDR 1
+
+        max_constellation = DQPSK;
+        for (i = 0; i < 3; i++) {
+                switch (state->fe.dtv_property_cache.layer[i].modulation) {
+                case DQPSK:
+                        constellation = 0;
+                        break;
+                case QPSK:
+                        constellation = 1;
+                        break;
+                case QAM_16:
+                        constellation = 2;
+                        break;
+                case QAM_64:
+                default:
+                        constellation = 3;
+                        break;
+                }
+
+                switch (state->fe.dtv_property_cache.layer[i].fec) {
+                case FEC_1_2:
+                        crate = 1;
+                        break;
+                case FEC_2_3:
+                        crate = 2;
+                        break;
+                case FEC_3_4:
+                        crate = 3;
+                        break;
+                case FEC_5_6:
+                        crate = 5;
+                        break;
+                case FEC_7_8:
+                default:
+                        crate = 7;
+                        break;
+                }
+
+                if ((state->fe.dtv_property_cache.layer[i].interleaving > 0) &&
+                    ((state->fe.dtv_property_cache.layer[i].interleaving <= 3) ||
+                     (state->fe.dtv_property_cache.layer[i].interleaving == 4 && state->fe.dtv_property_cache.isdbt_sb_mode == 1))
+                    )
+                        timeI = state->fe.dtv_property_cache.layer[i].interleaving;
+                else
+                        timeI = 0;
+                dib8000_write_word(state, 2 + i, (constellation << 10) | ((state->fe.dtv_property_cache.layer[i].segment_count & 0xf) << 6) |
+                                   (crate << 3) | timeI);
+                if (state->fe.dtv_property_cache.layer[i].segment_count > 0) {
+                        switch (max_constellation) {
+                        case DQPSK:
+                        case QPSK:
+                                if (state->fe.dtv_property_cache.layer[i].modulation == QAM_16 ||
+                                    state->fe.dtv_property_cache.layer[i].modulation == QAM_64)
+                                        max_constellation = state->fe.dtv_property_cache.layer[i].modulation;
+                                break;
+                        case QAM_16:
+                                if (state->fe.dtv_property_cache.layer[i].modulation == QAM_64)
+                                        max_constellation = state->fe.dtv_property_cache.layer[i].modulation;
+                                break;
+                        }
+                }
+        }
+
+        mode = fft_to_mode(state);
+
+        //dib8000_write_word(state, 5, 13); /*p_last_seg = 13*/
+
+        dib8000_write_word(state, 274, (dib8000_read_word(state, 274) & 0xffcf) |
+                           ((state->fe.dtv_property_cache.isdbt_partial_reception & 1) << 5) | ((state->fe.dtv_property_cache.
+                                                                                                 isdbt_sb_mode & 1) << 4));
+
+        dprintk("mode = %d ; guard = %d", mode, state->fe.dtv_property_cache.guard_interval);
+
+        /* signal optimization parameter */
+
+        if (state->fe.dtv_property_cache.isdbt_partial_reception) {
+                seg_diff_mask = (state->fe.dtv_property_cache.layer[0].modulation == DQPSK) << permu_seg[0];
+                for (i = 1; i < 3; i++)
+                        nbseg_diff +=
+                            (state->fe.dtv_property_cache.layer[i].modulation == DQPSK) * state->fe.dtv_property_cache.layer[i].segment_count;
+                for (i = 0; i < nbseg_diff; i++)
+                        seg_diff_mask |= 1 << permu_seg[i + 1];
+        } else {
+                for (i = 0; i < 3; i++)
+                        nbseg_diff +=
+                            (state->fe.dtv_property_cache.layer[i].modulation == DQPSK) * state->fe.dtv_property_cache.layer[i].segment_count;
+                for (i = 0; i < nbseg_diff; i++)
+                        seg_diff_mask |= 1 << permu_seg[i];
+        }
+        dprintk("nbseg_diff = %X (%d)", seg_diff_mask, seg_diff_mask);
+
+        state->differential_constellation = (seg_diff_mask != 0);
+        dib8000_set_diversity_in(&state->fe, state->diversity_onoff);
+
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1) {  // ISDB-Tsb
+                if (state->fe.dtv_property_cache.isdbt_partial_reception == 1)  // 3-segments
+                        seg_mask13 = 0x00E0;
+                else            // 1-segment
+                        seg_mask13 = 0x0040;
+        } else
+                seg_mask13 = 0x1fff;
+
+        // WRITE: Mode & Diff mask
+        dib8000_write_word(state, 0, (mode << 13) | seg_diff_mask);
+
+        if ((seg_diff_mask) || (state->fe.dtv_property_cache.isdbt_sb_mode))
+                dib8000_write_word(state, 268, (dib8000_read_word(state, 268) & 0xF9FF) | 0x0200);
+        else
+                dib8000_write_word(state, 268, (2 << 9) | 39);  //init value
+
+        // ---- SMALL ----
+        // P_small_seg_diff
+        dib8000_write_word(state, 352, seg_diff_mask);  // ADDR 352
+
+        dib8000_write_word(state, 353, seg_mask13);     // ADDR 353
+
+/*     // P_small_narrow_band=0, P_small_last_seg=13, P_small_offset_num_car=5 */
+        // dib8000_write_word(state, 351, (state->fe.dtv_property_cache.isdbt_sb_mode << 8) | (13 << 4) | 5 );
+
+        // ---- SMALL ----
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1) {
+                switch (state->fe.dtv_property_cache.transmission_mode) {
+                case TRANSMISSION_MODE_2K:
+                        if (state->fe.dtv_property_cache.isdbt_partial_reception == 0) {        // 1-seg
+                                if (state->fe.dtv_property_cache.layer[0].modulation == DQPSK)  // DQPSK
+                                        ncoeff = coeff_2k_sb_1seg_dqpsk;
+                                else    // QPSK or QAM
+                                        ncoeff = coeff_2k_sb_1seg;
+                        } else {        // 3-segments
+                                if (state->fe.dtv_property_cache.layer[0].modulation == DQPSK) {        // DQPSK on central segment
+                                        if (state->fe.dtv_property_cache.layer[1].modulation == DQPSK)  // DQPSK on external segments
+                                                ncoeff = coeff_2k_sb_3seg_0dqpsk_1dqpsk;
+                                        else    // QPSK or QAM on external segments
+                                                ncoeff = coeff_2k_sb_3seg_0dqpsk;
+                                } else {        // QPSK or QAM on central segment
+                                        if (state->fe.dtv_property_cache.layer[1].modulation == DQPSK)  // DQPSK on external segments
+                                                ncoeff = coeff_2k_sb_3seg_1dqpsk;
+                                        else    // QPSK or QAM on external segments
+                                                ncoeff = coeff_2k_sb_3seg;
+                                }
+                        }
+                        break;
+
+                case TRANSMISSION_MODE_4K:
+                        if (state->fe.dtv_property_cache.isdbt_partial_reception == 0) {        // 1-seg
+                                if (state->fe.dtv_property_cache.layer[0].modulation == DQPSK)  // DQPSK
+                                        ncoeff = coeff_4k_sb_1seg_dqpsk;
+                                else    // QPSK or QAM
+                                        ncoeff = coeff_4k_sb_1seg;
+                        } else {        // 3-segments
+                                if (state->fe.dtv_property_cache.layer[0].modulation == DQPSK) {        // DQPSK on central segment
+                                        if (state->fe.dtv_property_cache.layer[1].modulation == DQPSK) {        // DQPSK on external segments
+                                                ncoeff = coeff_4k_sb_3seg_0dqpsk_1dqpsk;
+                                        } else {        // QPSK or QAM on external segments
+                                                ncoeff = coeff_4k_sb_3seg_0dqpsk;
+                                        }
+                                } else {        // QPSK or QAM on central segment
+                                        if (state->fe.dtv_property_cache.layer[1].modulation == DQPSK) {        // DQPSK on external segments
+                                                ncoeff = coeff_4k_sb_3seg_1dqpsk;
+                                        } else  // QPSK or QAM on external segments
+                                                ncoeff = coeff_4k_sb_3seg;
+                                }
+                        }
+                        break;
+
+                case TRANSMISSION_MODE_AUTO:
+                case TRANSMISSION_MODE_8K:
+                default:
+                        if (state->fe.dtv_property_cache.isdbt_partial_reception == 0) {        // 1-seg
+                                if (state->fe.dtv_property_cache.layer[0].modulation == DQPSK)  // DQPSK
+                                        ncoeff = coeff_8k_sb_1seg_dqpsk;
+                                else    // QPSK or QAM
+                                        ncoeff = coeff_8k_sb_1seg;
+                        } else {        // 3-segments
+                                if (state->fe.dtv_property_cache.layer[0].modulation == DQPSK) {        // DQPSK on central segment
+                                        if (state->fe.dtv_property_cache.layer[1].modulation == DQPSK) {        // DQPSK on external segments
+                                                ncoeff = coeff_8k_sb_3seg_0dqpsk_1dqpsk;
+                                        } else {        // QPSK or QAM on external segments
+                                                ncoeff = coeff_8k_sb_3seg_0dqpsk;
+                                        }
+                                } else {        // QPSK or QAM on central segment
+                                        if (state->fe.dtv_property_cache.layer[1].modulation == DQPSK) {        // DQPSK on external segments
+                                                ncoeff = coeff_8k_sb_3seg_1dqpsk;
+                                        } else  // QPSK or QAM on external segments
+                                                ncoeff = coeff_8k_sb_3seg;
+                                }
+                        }
+                        break;
+                }
+        }
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1)
+                for (i = 0; i < 8; i++)
+                        dib8000_write_word(state, 343 + i, ncoeff[i]);
+
+        // P_small_coef_ext_enable=ISDB-Tsb, P_small_narrow_band=ISDB-Tsb, P_small_last_seg=13, P_small_offset_num_car=5
+        dib8000_write_word(state, 351,
+                           (state->fe.dtv_property_cache.isdbt_sb_mode << 9) | (state->fe.dtv_property_cache.isdbt_sb_mode << 8) | (13 << 4) | 5);
+
+        // ---- COFF ----
+        // Carloff, the most robust
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1) {  // Sound Broadcasting mode - use both TMCC and AC pilots
+
+                // P_coff_cpil_alpha=4, P_coff_inh=0, P_coff_cpil_winlen=64
+                // P_coff_narrow_band=1, P_coff_square_val=1, P_coff_one_seg=~partial_rcpt, P_coff_use_tmcc=1, P_coff_use_ac=1
+                dib8000_write_word(state, 187,
+                                   (4 << 12) | (0 << 11) | (63 << 5) | (0x3 << 3) | ((~state->fe.dtv_property_cache.isdbt_partial_reception & 1) << 2)
+                                   | 0x3);
+
+/*             // P_small_coef_ext_enable = 1 */
+/*             dib8000_write_word(state, 351, dib8000_read_word(state, 351) | 0x200); */
+
+                if (state->fe.dtv_property_cache.isdbt_partial_reception == 0) {        // Sound Broadcasting mode 1 seg
+
+                        // P_coff_winlen=63, P_coff_thres_lock=15, P_coff_one_seg_width= (P_mode == 3) , P_coff_one_seg_sym= (P_mode-1)
+                        if (mode == 3)
+                                dib8000_write_word(state, 180, 0x1fcf | ((mode - 1) << 14));
+                        else
+                                dib8000_write_word(state, 180, 0x0fcf | ((mode - 1) << 14));
+                        // P_ctrl_corm_thres4pre_freq_inh=1,P_ctrl_pre_freq_mode_sat=1,
+                        // P_ctrl_pre_freq_inh=0, P_ctrl_pre_freq_step = 5, P_pre_freq_win_len=4
+                        dib8000_write_word(state, 338, (1 << 12) | (1 << 10) | (0 << 9) | (5 << 5) | 4);
+                        // P_ctrl_pre_freq_win_len=16, P_ctrl_pre_freq_thres_lockin=8
+                        dib8000_write_word(state, 340, (16 << 6) | (8 << 0));
+                        // P_ctrl_pre_freq_thres_lockout=6, P_small_use_tmcc/ac/cp=1
+                        dib8000_write_word(state, 341, (6 << 3) | (1 << 2) | (1 << 1) | (1 << 0));
+
+                        // P_coff_corthres_8k, 4k, 2k and P_coff_cpilthres_8k, 4k, 2k
+                        dib8000_write_word(state, 181, 300);
+                        dib8000_write_word(state, 182, 150);
+                        dib8000_write_word(state, 183, 80);
+                        dib8000_write_word(state, 184, 300);
+                        dib8000_write_word(state, 185, 150);
+                        dib8000_write_word(state, 186, 80);
+                } else {        // Sound Broadcasting mode 3 seg
+                        // P_coff_one_seg_sym= 1, P_coff_one_seg_width= 1, P_coff_winlen=63, P_coff_thres_lock=15
+                        /*                 if (mode == 3) */
+                        /*                     dib8000_write_word(state, 180, 0x2fca | ((0) << 14)); */
+                        /*                 else */
+                        /*                     dib8000_write_word(state, 180, 0x2fca | ((1) << 14)); */
+                        dib8000_write_word(state, 180, 0x1fcf | (1 << 14));
+
+                        // P_ctrl_corm_thres4pre_freq_inh = 1, P_ctrl_pre_freq_mode_sat=1,
+                        // P_ctrl_pre_freq_inh=0, P_ctrl_pre_freq_step = 4, P_pre_freq_win_len=4
+                        dib8000_write_word(state, 338, (1 << 12) | (1 << 10) | (0 << 9) | (4 << 5) | 4);
+                        // P_ctrl_pre_freq_win_len=16, P_ctrl_pre_freq_thres_lockin=8
+                        dib8000_write_word(state, 340, (16 << 6) | (8 << 0));
+                        //P_ctrl_pre_freq_thres_lockout=6, P_small_use_tmcc/ac/cp=1
+                        dib8000_write_word(state, 341, (6 << 3) | (1 << 2) | (1 << 1) | (1 << 0));
+
+                        // P_coff_corthres_8k, 4k, 2k and P_coff_cpilthres_8k, 4k, 2k
+                        dib8000_write_word(state, 181, 350);
+                        dib8000_write_word(state, 182, 300);
+                        dib8000_write_word(state, 183, 250);
+                        dib8000_write_word(state, 184, 350);
+                        dib8000_write_word(state, 185, 300);
+                        dib8000_write_word(state, 186, 250);
+                }
+
+        } else if (state->isdbt_cfg_loaded == 0) {      // if not Sound Broadcasting mode : put default values for 13 segments
+                dib8000_write_word(state, 180, (16 << 6) | 9);
+                dib8000_write_word(state, 187, (4 << 12) | (8 << 5) | 0x2);
+                coff_pow = 0x2800;
+                for (i = 0; i < 6; i++)
+                        dib8000_write_word(state, 181 + i, coff_pow);
+
+                // P_ctrl_corm_thres4pre_freq_inh=1, P_ctrl_pre_freq_mode_sat=1,
+                // P_ctrl_pre_freq_mode_sat=1, P_ctrl_pre_freq_inh=0, P_ctrl_pre_freq_step = 3, P_pre_freq_win_len=1
+                dib8000_write_word(state, 338, (1 << 12) | (1 << 10) | (0 << 9) | (3 << 5) | 1);
+
+                // P_ctrl_pre_freq_win_len=8, P_ctrl_pre_freq_thres_lockin=6
+                dib8000_write_word(state, 340, (8 << 6) | (6 << 0));
+                // P_ctrl_pre_freq_thres_lockout=4, P_small_use_tmcc/ac/cp=1
+                dib8000_write_word(state, 341, (4 << 3) | (1 << 2) | (1 << 1) | (1 << 0));
+        }
+        // ---- FFT ----
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1 && state->fe.dtv_property_cache.isdbt_partial_reception == 0)       // 1-seg
+                dib8000_write_word(state, 178, 64);     // P_fft_powrange=64
+        else
+                dib8000_write_word(state, 178, 32);     // P_fft_powrange=32
+
+        /* make the cpil_coff_lock more robust but slower p_coff_winlen
+         * 6bits; p_coff_thres_lock 6bits (for coff lock if needed)
+         */
+        /* if ( ( nbseg_diff>0)&&(nbseg_diff<13))
+           dib8000_write_word(state, 187, (dib8000_read_word(state, 187) & 0xfffb) | (1 << 3)); */
+
+        dib8000_write_word(state, 189, ~seg_mask13 | seg_diff_mask);    /* P_lmod4_seg_inh       */
+        dib8000_write_word(state, 192, ~seg_mask13 | seg_diff_mask);    /* P_pha3_seg_inh        */
+        dib8000_write_word(state, 225, ~seg_mask13 | seg_diff_mask);    /* P_tac_seg_inh         */
+        if ((!state->fe.dtv_property_cache.isdbt_sb_mode) && (state->cfg.pll->ifreq == 0))
+                dib8000_write_word(state, 266, ~seg_mask13 | seg_diff_mask | 0x40);     /* P_equal_noise_seg_inh */
+        else
+                dib8000_write_word(state, 266, ~seg_mask13 | seg_diff_mask);    /* P_equal_noise_seg_inh */
+        dib8000_write_word(state, 287, ~seg_mask13 | 0x1000);   /* P_tmcc_seg_inh        */
+        //dib8000_write_word(state, 288, ~seg_mask13 | seg_diff_mask); /* P_tmcc_seg_eq_inh */
+        if (!autosearching)
+                dib8000_write_word(state, 288, (~seg_mask13 | seg_diff_mask) & 0x1fff); /* P_tmcc_seg_eq_inh */
+        else
+                dib8000_write_word(state, 288, 0x1fff); //disable equalisation of the tmcc when autosearch to be able to find the DQPSK channels.
+        dprintk("287 = %X (%d)", ~seg_mask13 | 0x1000, ~seg_mask13 | 0x1000);
+
+        dib8000_write_word(state, 211, seg_mask13 & (~seg_diff_mask));  /* P_des_seg_enabled     */
+
+        /* offset loop parameters */
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1) {
+                if (state->fe.dtv_property_cache.isdbt_partial_reception == 0)  // Sound Broadcasting mode 1 seg
+                        /* P_timf_alpha = (11-P_mode), P_corm_alpha=6, P_corm_thres=0x80 */
+                        dib8000_write_word(state, 32, ((11 - mode) << 12) | (6 << 8) | 0x40);
+
+                else            // Sound Broadcasting mode 3 seg
+                        /* P_timf_alpha = (10-P_mode), P_corm_alpha=6, P_corm_thres=0x80 */
+                        dib8000_write_word(state, 32, ((10 - mode) << 12) | (6 << 8) | 0x60);
+        } else
+                // TODO in 13 seg, timf_alpha can always be the same or not ?
+                /* P_timf_alpha = (9-P_mode, P_corm_alpha=6, P_corm_thres=0x80 */
+                dib8000_write_word(state, 32, ((9 - mode) << 12) | (6 << 8) | 0x80);
+
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1) {
+                if (state->fe.dtv_property_cache.isdbt_partial_reception == 0)  // Sound Broadcasting mode 1 seg
+                        /* P_ctrl_pha_off_max=3   P_ctrl_sfreq_inh =0  P_ctrl_sfreq_step = (11-P_mode)  */
+                        dib8000_write_word(state, 37, (3 << 5) | (0 << 4) | (10 - mode));
+
+                else            // Sound Broadcasting mode 3 seg
+                        /* P_ctrl_pha_off_max=3   P_ctrl_sfreq_inh =0  P_ctrl_sfreq_step = (10-P_mode)  */
+                        dib8000_write_word(state, 37, (3 << 5) | (0 << 4) | (9 - mode));
+        } else
+                /* P_ctrl_pha_off_max=3   P_ctrl_sfreq_inh =0  P_ctrl_sfreq_step = 9  */
+                dib8000_write_word(state, 37, (3 << 5) | (0 << 4) | (8 - mode));
+
+        /* P_dvsy_sync_wait - reuse mode */
+        switch (state->fe.dtv_property_cache.transmission_mode) {
+        case TRANSMISSION_MODE_8K:
+                mode = 256;
+                break;
+        case TRANSMISSION_MODE_4K:
+                mode = 128;
+                break;
+        default:
+        case TRANSMISSION_MODE_2K:
+                mode = 64;
+                break;
+        }
+        if (state->cfg.diversity_delay == 0)
+                mode = (mode * (1 << (guard)) * 3) / 2 + 48;    // add 50% SFN margin + compensate for one DVSY-fifo
+        else
+                mode = (mode * (1 << (guard)) * 3) / 2 + state->cfg.diversity_delay;    // add 50% SFN margin + compensate for DVSY-fifo
+        mode <<= 4;
+        dib8000_write_word(state, 273, (dib8000_read_word(state, 273) & 0x000f) | mode);
+
+        /* channel estimation fine configuration */
+        switch (max_constellation) {
+        case QAM_64:
+                ana_gain = 0x7; // -1 : avoid def_est saturation when ADC target is -16dB
+                coeff[0] = 0x0148;      /* P_adp_regul_cnt 0.04 */
+                coeff[1] = 0xfff0;      /* P_adp_noise_cnt -0.002 */
+                coeff[2] = 0x00a4;      /* P_adp_regul_ext 0.02 */
+                coeff[3] = 0xfff8;      /* P_adp_noise_ext -0.001 */
+                //if (!state->cfg.hostbus_diversity) //if diversity, we should prehaps use the configuration of the max_constallation -1
+                break;
+        case QAM_16:
+                ana_gain = 0x7; // -1 : avoid def_est saturation when ADC target is -16dB
+                coeff[0] = 0x023d;      /* P_adp_regul_cnt 0.07 */
+                coeff[1] = 0xffdf;      /* P_adp_noise_cnt -0.004 */
+                coeff[2] = 0x00a4;      /* P_adp_regul_ext 0.02 */
+                coeff[3] = 0xfff0;      /* P_adp_noise_ext -0.002 */
+                //if (!((state->cfg.hostbus_diversity) && (max_constellation == QAM_16)))
+                break;
+        default:
+                ana_gain = 0;   // 0 : goes along with ADC target at -22dB to keep good mobile performance and lock at sensitivity level
+                coeff[0] = 0x099a;      /* P_adp_regul_cnt 0.3 */
+                coeff[1] = 0xffae;      /* P_adp_noise_cnt -0.01 */
+                coeff[2] = 0x0333;      /* P_adp_regul_ext 0.1 */
+                coeff[3] = 0xfff8;      /* P_adp_noise_ext -0.002 */
+                break;
+        }
+        for (mode = 0; mode < 4; mode++)
+                dib8000_write_word(state, 215 + mode, coeff[mode]);
+
+        // update ana_gain depending on max constellation
+        dib8000_write_word(state, 116, ana_gain);
+        // update ADC target depending on ana_gain
+        if (ana_gain) {         // set -16dB ADC target for ana_gain=-1
+                for (i = 0; i < 10; i++)
+                        dib8000_write_word(state, 80 + i, adc_target_16dB[i]);
+        } else {                // set -22dB ADC target for ana_gain=0
+                for (i = 0; i < 10; i++)
+                        dib8000_write_word(state, 80 + i, adc_target_16dB[i] - 355);
+        }
+
+        // ---- ANA_FE ----
+        if (state->fe.dtv_property_cache.isdbt_sb_mode) {
+                if (state->fe.dtv_property_cache.isdbt_partial_reception == 1)  // 3-segments
+                        ana_fe = ana_fe_coeff_3seg;
+                else            // 1-segment
+                        ana_fe = ana_fe_coeff_1seg;
+        } else
+                ana_fe = ana_fe_coeff_13seg;
+
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1 || state->isdbt_cfg_loaded == 0)
+                for (mode = 0; mode < 24; mode++)
+                        dib8000_write_word(state, 117 + mode, ana_fe[mode]);
+
+        // ---- CHAN_BLK ----
+        for (i = 0; i < 13; i++) {
+                if ((((~seg_diff_mask) >> i) & 1) == 1) {
+                        P_cfr_left_edge += (1 << i) * ((i == 0) || ((((seg_mask13 & (~seg_diff_mask)) >> (i - 1)) & 1) == 0));
+                        P_cfr_right_edge += (1 << i) * ((i == 12) || ((((seg_mask13 & (~seg_diff_mask)) >> (i + 1)) & 1) == 0));
+                }
+        }
+        dib8000_write_word(state, 222, P_cfr_left_edge);        // P_cfr_left_edge
+        dib8000_write_word(state, 223, P_cfr_right_edge);       // P_cfr_right_edge
+        // "P_cspu_left_edge"  not used => do not care
+        // "P_cspu_right_edge" not used => do not care
+
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1) {  // ISDB-Tsb
+                dib8000_write_word(state, 228, 1);      // P_2d_mode_byp=1
+                dib8000_write_word(state, 205, dib8000_read_word(state, 205) & 0xfff0); // P_cspu_win_cut = 0
+                if (state->fe.dtv_property_cache.isdbt_partial_reception == 0   // 1-segment
+                    && state->fe.dtv_property_cache.transmission_mode == TRANSMISSION_MODE_2K) {
+                        //dib8000_write_word(state, 219, dib8000_read_word(state, 219) & 0xfffe); // P_adp_pass = 0
+                        dib8000_write_word(state, 265, 15);     // P_equal_noise_sel = 15
+                }
+        } else if (state->isdbt_cfg_loaded == 0) {
+                dib8000_write_word(state, 228, 0);      // default value
+                dib8000_write_word(state, 265, 31);     // default value
+                dib8000_write_word(state, 205, 0x200f); // init value
+        }
+        // ---- TMCC ----
+        for (i = 0; i < 3; i++)
+                tmcc_pow +=
+                    (((state->fe.dtv_property_cache.layer[i].modulation == DQPSK) * 4 + 1) * state->fe.dtv_property_cache.layer[i].segment_count);
+        // Quantif of "P_tmcc_dec_thres_?k" is (0, 5+mode, 9);
+        // Threshold is set at 1/4 of max power.
+        tmcc_pow *= (1 << (9 - 2));
+
+        dib8000_write_word(state, 290, tmcc_pow);       // P_tmcc_dec_thres_2k
+        dib8000_write_word(state, 291, tmcc_pow);       // P_tmcc_dec_thres_4k
+        dib8000_write_word(state, 292, tmcc_pow);       // P_tmcc_dec_thres_8k
+        //dib8000_write_word(state, 287, (1 << 13) | 0x1000 );
+        // ---- PHA3 ----
+
+        if (state->isdbt_cfg_loaded == 0)
+                dib8000_write_word(state, 250, 3285);   /*p_2d_hspeed_thr0 */
+
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1)
+                state->isdbt_cfg_loaded = 0;
+        else
+                state->isdbt_cfg_loaded = 1;
+
+}
+
+static int dib8000_autosearch_start(struct dvb_frontend *fe)
+{
+        u8 factor;
+        u32 value;
+        struct dib8000_state *state = fe->demodulator_priv;
+
+        int slist = 0;
+
+        state->fe.dtv_property_cache.inversion = 0;
+        if (!state->fe.dtv_property_cache.isdbt_sb_mode)
+                state->fe.dtv_property_cache.layer[0].segment_count = 13;
+        state->fe.dtv_property_cache.layer[0].modulation = QAM_64;
+        state->fe.dtv_property_cache.layer[0].fec = FEC_2_3;
+        state->fe.dtv_property_cache.layer[0].interleaving = 0;
+
+        //choose the right list, in sb, always do everything
+        if (state->fe.dtv_property_cache.isdbt_sb_mode) {
+                state->fe.dtv_property_cache.transmission_mode = TRANSMISSION_MODE_8K;
+                state->fe.dtv_property_cache.guard_interval = GUARD_INTERVAL_1_8;
+                slist = 7;
+                dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x9fff) | (1 << 13));
+        } else {
+                if (state->fe.dtv_property_cache.guard_interval == GUARD_INTERVAL_AUTO) {
+                        if (state->fe.dtv_property_cache.transmission_mode == TRANSMISSION_MODE_AUTO) {
+                                slist = 7;
+                                dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x9fff) | (1 << 13));       // P_mode = 1 to have autosearch start ok with mode2
+                        } else
+                                slist = 3;
+                } else {
+                        if (state->fe.dtv_property_cache.transmission_mode == TRANSMISSION_MODE_AUTO) {
+                                slist = 2;
+                                dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x9fff) | (1 << 13));       // P_mode = 1
+                        } else
+                                slist = 0;
+                }
+
+                if (state->fe.dtv_property_cache.transmission_mode == TRANSMISSION_MODE_AUTO)
+                        state->fe.dtv_property_cache.transmission_mode = TRANSMISSION_MODE_8K;
+                if (state->fe.dtv_property_cache.guard_interval == GUARD_INTERVAL_AUTO)
+                        state->fe.dtv_property_cache.guard_interval = GUARD_INTERVAL_1_8;
+
+                dprintk("using list for autosearch : %d", slist);
+                dib8000_set_channel(state, (unsigned char)slist, 1);
+                //dib8000_write_word(state, 0, (dib8000_read_word(state, 0) & 0x9fff) | (1 << 13));  // P_mode = 1
+
+                factor = 1;
+
+                //set lock_mask values
+                dib8000_write_word(state, 6, 0x4);
+                dib8000_write_word(state, 7, 0x8);
+                dib8000_write_word(state, 8, 0x1000);
+
+                //set lock_mask wait time values
+                value = 50 * state->cfg.pll->internal * factor;
+                dib8000_write_word(state, 11, (u16) ((value >> 16) & 0xffff));  // lock0 wait time
+                dib8000_write_word(state, 12, (u16) (value & 0xffff));  // lock0 wait time
+                value = 100 * state->cfg.pll->internal * factor;
+                dib8000_write_word(state, 13, (u16) ((value >> 16) & 0xffff));  // lock1 wait time
+                dib8000_write_word(state, 14, (u16) (value & 0xffff));  // lock1 wait time
+                value = 1000 * state->cfg.pll->internal * factor;
+                dib8000_write_word(state, 15, (u16) ((value >> 16) & 0xffff));  // lock2 wait time
+                dib8000_write_word(state, 16, (u16) (value & 0xffff));  // lock2 wait time
+
+                value = dib8000_read_word(state, 0);
+                dib8000_write_word(state, 0, (u16) ((1 << 15) | value));
+                dib8000_read_word(state, 1284); // reset the INT. n_irq_pending
+                dib8000_write_word(state, 0, (u16) value);
+
+        }
+
+        return 0;
+}
+
+static int dib8000_autosearch_irq(struct dvb_frontend *fe)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        u16 irq_pending = dib8000_read_word(state, 1284);
+
+        if (irq_pending & 0x1) {        // failed
+                dprintk("dib8000_autosearch_irq failed");
+                return 1;
+        }
+
+        if (irq_pending & 0x2) {        // succeeded
+                dprintk("dib8000_autosearch_irq succeeded");
+                return 2;
+        }
+
+        return 0;               // still pending
+}
+
+static int dib8000_tune(struct dvb_frontend *fe)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        int ret = 0;
+        u16 value, mode = fft_to_mode(state);
+
+        // we are already tuned - just resuming from suspend
+        if (state == NULL)
+                return -EINVAL;
+
+        dib8000_set_bandwidth(state, state->fe.dtv_property_cache.bandwidth_hz / 1000);
+        dib8000_set_channel(state, 0, 0);
+
+        // restart demod
+        ret |= dib8000_write_word(state, 770, 0x4000);
+        ret |= dib8000_write_word(state, 770, 0x0000);
+        msleep(45);
+
+        /* P_ctrl_inh_cor=0, P_ctrl_alpha_cor=4, P_ctrl_inh_isi=0, P_ctrl_alpha_isi=3 */
+        /*  ret |= dib8000_write_word(state, 29, (0 << 9) | (4 << 5) | (0 << 4) | (3 << 0) );  workaround inh_isi stays at 1 */
+
+        // never achieved a lock before - wait for timfreq to update
+        if (state->timf == 0) {
+                if (state->fe.dtv_property_cache.isdbt_sb_mode == 1) {
+                        if (state->fe.dtv_property_cache.isdbt_partial_reception == 0)  // Sound Broadcasting mode 1 seg
+                                msleep(300);
+                        else    // Sound Broadcasting mode 3 seg
+                                msleep(500);
+                } else          // 13 seg
+                        msleep(200);
+        }
+        //dump_reg(state);
+        if (state->fe.dtv_property_cache.isdbt_sb_mode == 1) {
+                if (state->fe.dtv_property_cache.isdbt_partial_reception == 0) {        // Sound Broadcasting mode 1 seg
+
+                        /* P_timf_alpha = (13-P_mode) , P_corm_alpha=6, P_corm_thres=0x40  alpha to check on board */
+                        dib8000_write_word(state, 32, ((13 - mode) << 12) | (6 << 8) | 0x40);
+                        //dib8000_write_word(state, 32, (8 << 12) | (6 << 8) | 0x80);
+
+                        /*  P_ctrl_sfreq_step= (12-P_mode)   P_ctrl_sfreq_inh =0     P_ctrl_pha_off_max  */
+                        ret |= dib8000_write_word(state, 37, (12 - mode) | ((5 + mode) << 5));
+
+                } else {        // Sound Broadcasting mode 3 seg
+
+                        /* P_timf_alpha = (12-P_mode) , P_corm_alpha=6, P_corm_thres=0x60  alpha to check on board */
+                        dib8000_write_word(state, 32, ((12 - mode) << 12) | (6 << 8) | 0x60);
+
+                        ret |= dib8000_write_word(state, 37, (11 - mode) | ((5 + mode) << 5));
+                }
+
+        } else {                // 13 seg
+                /* P_timf_alpha = 8 , P_corm_alpha=6, P_corm_thres=0x80  alpha to check on board */
+                dib8000_write_word(state, 32, ((11 - mode) << 12) | (6 << 8) | 0x80);
+
+                ret |= dib8000_write_word(state, 37, (10 - mode) | ((5 + mode) << 5));
+
+        }
+
+        // we achieved a coff_cpil_lock - it's time to update the timf
+        if ((dib8000_read_word(state, 568) >> 11) & 0x1)
+                dib8000_update_timf(state);
+
+        //now that tune is finished, lock0 should lock on fec_mpeg to output this lock on MP_LOCK. It's changed in autosearch start
+        dib8000_write_word(state, 6, 0x200);
+
+        if (state->revision == 0x8002) {
+                value = dib8000_read_word(state, 903);
+                dib8000_write_word(state, 903, value & ~(1 << 3));
+                msleep(1);
+                dib8000_write_word(state, 903, value | (1 << 3));
+        }
+
+        return ret;
+}
+
+static int dib8000_wakeup(struct dvb_frontend *fe)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+
+        dib8000_set_power_mode(state, DIB8000M_POWER_ALL);
+        dib8000_set_adc_state(state, DIBX000_ADC_ON);
+        if (dib8000_set_adc_state(state, DIBX000_SLOW_ADC_ON) != 0)
+                dprintk("could not start Slow ADC");
+
+        return 0;
+}
+
+static int dib8000_sleep(struct dvb_frontend *fe)
+{
+        struct dib8000_state *st = fe->demodulator_priv;
+        if (1) {
+                dib8000_set_output_mode(st, OUTMODE_HIGH_Z);
+                dib8000_set_power_mode(st, DIB8000M_POWER_INTERFACE_ONLY);
+                return dib8000_set_adc_state(st, DIBX000_SLOW_ADC_OFF) | dib8000_set_adc_state(st, DIBX000_ADC_OFF);
+        } else {
+
+                return 0;
+        }
+}
+
+static int dib8000_get_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        u16 i, val = 0;
+
+        fe->dtv_property_cache.bandwidth_hz = 6000000;
+
+        fe->dtv_property_cache.isdbt_sb_mode = dib8000_read_word(state, 508) & 0x1;
+
+        val = dib8000_read_word(state, 570);
+        fe->dtv_property_cache.inversion = (val & 0x40) >> 6;
+        switch ((val & 0x30) >> 4) {
+        case 1:
+                fe->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_2K;
+                break;
+        case 3:
+        default:
+                fe->dtv_property_cache.transmission_mode = TRANSMISSION_MODE_8K;
+                break;
+        }
+
+        switch (val & 0x3) {
+        case 0:
+                fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_32;
+                dprintk("dib8000_get_frontend GI = 1/32 ");
+                break;
+        case 1:
+                fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_16;
+                dprintk("dib8000_get_frontend GI = 1/16 ");
+                break;
+        case 2:
+                dprintk("dib8000_get_frontend GI = 1/8 ");
+                fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_8;
+                break;
+        case 3:
+                dprintk("dib8000_get_frontend GI = 1/4 ");
+                fe->dtv_property_cache.guard_interval = GUARD_INTERVAL_1_4;
+                break;
+        }
+
+        val = dib8000_read_word(state, 505);
+        fe->dtv_property_cache.isdbt_partial_reception = val & 1;
+        dprintk("dib8000_get_frontend : partial_reception = %d ", fe->dtv_property_cache.isdbt_partial_reception);
+
+        for (i = 0; i < 3; i++) {
+                val = dib8000_read_word(state, 493 + i);
+                fe->dtv_property_cache.layer[i].segment_count = val & 0x0F;
+                dprintk("dib8000_get_frontend : Layer %d segments = %d ", i, fe->dtv_property_cache.layer[i].segment_count);
+
+                val = dib8000_read_word(state, 499 + i);
+                fe->dtv_property_cache.layer[i].interleaving = val & 0x3;
+                dprintk("dib8000_get_frontend : Layer %d time_intlv = %d ", i, fe->dtv_property_cache.layer[i].interleaving);
+
+                val = dib8000_read_word(state, 481 + i);
+                switch (val & 0x7) {
+                case 1:
+                        fe->dtv_property_cache.layer[i].fec = FEC_1_2;
+                        dprintk("dib8000_get_frontend : Layer %d Code Rate = 1/2 ", i);
+                        break;
+                case 2:
+                        fe->dtv_property_cache.layer[i].fec = FEC_2_3;
+                        dprintk("dib8000_get_frontend : Layer %d Code Rate = 2/3 ", i);
+                        break;
+                case 3:
+                        fe->dtv_property_cache.layer[i].fec = FEC_3_4;
+                        dprintk("dib8000_get_frontend : Layer %d Code Rate = 3/4 ", i);
+                        break;
+                case 5:
+                        fe->dtv_property_cache.layer[i].fec = FEC_5_6;
+                        dprintk("dib8000_get_frontend : Layer %d Code Rate = 5/6 ", i);
+                        break;
+                default:
+                        fe->dtv_property_cache.layer[i].fec = FEC_7_8;
+                        dprintk("dib8000_get_frontend : Layer %d Code Rate = 7/8 ", i);
+                        break;
+                }
+
+                val = dib8000_read_word(state, 487 + i);
+                switch (val & 0x3) {
+                case 0:
+                        dprintk("dib8000_get_frontend : Layer %d DQPSK ", i);
+                        fe->dtv_property_cache.layer[i].modulation = DQPSK;
+                        break;
+                case 1:
+                        fe->dtv_property_cache.layer[i].modulation = QPSK;
+                        dprintk("dib8000_get_frontend : Layer %d QPSK ", i);
+                        break;
+                case 2:
+                        fe->dtv_property_cache.layer[i].modulation = QAM_16;
+                        dprintk("dib8000_get_frontend : Layer %d QAM16 ", i);
+                        break;
+                case 3:
+                default:
+                        dprintk("dib8000_get_frontend : Layer %d QAM64 ", i);
+                        fe->dtv_property_cache.layer[i].modulation = QAM_64;
+                        break;
+                }
+        }
+        return 0;
+}
+
+static int dib8000_set_frontend(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        int time, ret;
+
+        dib8000_set_output_mode(state, OUTMODE_HIGH_Z);
+
+        if (fe->ops.tuner_ops.set_params)
+                fe->ops.tuner_ops.set_params(fe, fep);
+
+        /* start up the AGC */
+        state->tune_state = CT_AGC_START;
+        do {
+                time = dib8000_agc_startup(fe);
+                if (time != FE_CALLBACK_TIME_NEVER)
+                        msleep(time / 10);
+                else
+                        break;
+        } while (state->tune_state != CT_AGC_STOP);
+
+        if (state->fe.dtv_property_cache.frequency == 0) {
+                dprintk("dib8000: must at least specify frequency ");
+                return 0;
+        }
+
+        if (state->fe.dtv_property_cache.bandwidth_hz == 0) {
+                dprintk("dib8000: no bandwidth specified, set to default ");
+                state->fe.dtv_property_cache.bandwidth_hz = 6000000;
+        }
+
+        state->tune_state = CT_DEMOD_START;
+
+        if ((state->fe.dtv_property_cache.delivery_system != SYS_ISDBT) ||
+            (state->fe.dtv_property_cache.inversion == INVERSION_AUTO) ||
+            (state->fe.dtv_property_cache.transmission_mode == TRANSMISSION_MODE_AUTO) ||
+            (state->fe.dtv_property_cache.guard_interval == GUARD_INTERVAL_AUTO) ||
+            (((state->fe.dtv_property_cache.isdbt_layer_enabled & (1 << 0)) != 0) &&
+             (state->fe.dtv_property_cache.layer[0].segment_count != 0xff) &&
+             (state->fe.dtv_property_cache.layer[0].segment_count != 0) &&
+             ((state->fe.dtv_property_cache.layer[0].modulation == QAM_AUTO) ||
+              (state->fe.dtv_property_cache.layer[0].fec == FEC_AUTO))) ||
+            (((state->fe.dtv_property_cache.isdbt_layer_enabled & (1 << 1)) != 0) &&
+             (state->fe.dtv_property_cache.layer[1].segment_count != 0xff) &&
+             (state->fe.dtv_property_cache.layer[1].segment_count != 0) &&
+             ((state->fe.dtv_property_cache.layer[1].modulation == QAM_AUTO) ||
+              (state->fe.dtv_property_cache.layer[1].fec == FEC_AUTO))) ||
+            (((state->fe.dtv_property_cache.isdbt_layer_enabled & (1 << 2)) != 0) &&
+             (state->fe.dtv_property_cache.layer[2].segment_count != 0xff) &&
+             (state->fe.dtv_property_cache.layer[2].segment_count != 0) &&
+             ((state->fe.dtv_property_cache.layer[2].modulation == QAM_AUTO) ||
+              (state->fe.dtv_property_cache.layer[2].fec == FEC_AUTO))) ||
+            (((state->fe.dtv_property_cache.layer[0].segment_count == 0) ||
+              ((state->fe.dtv_property_cache.isdbt_layer_enabled & (1 << 0)) == 0)) &&
+             ((state->fe.dtv_property_cache.layer[1].segment_count == 0) ||
+              ((state->fe.dtv_property_cache.isdbt_layer_enabled & (2 << 0)) == 0)) &&
+             ((state->fe.dtv_property_cache.layer[2].segment_count == 0) || ((state->fe.dtv_property_cache.isdbt_layer_enabled & (3 << 0)) == 0)))) {
+                int i = 800, found;
+
+                dib8000_set_bandwidth(state, fe->dtv_property_cache.bandwidth_hz / 1000);
+                dib8000_autosearch_start(fe);
+                do {
+                        msleep(10);
+                        found = dib8000_autosearch_irq(fe);
+                } while (found == 0 && i--);
+
+                dprintk("Frequency %d Hz, autosearch returns: %d", fep->frequency, found);
+
+                if (found == 0 || found == 1)
+                        return 0;       // no channel found
+
+                dib8000_get_frontend(fe, fep);
+        }
+
+        ret = dib8000_tune(fe);
+
+        /* make this a config parameter */
+        dib8000_set_output_mode(state, state->cfg.output_mode);
+
+        return ret;
+}
+
+static int dib8000_read_status(struct dvb_frontend *fe, fe_status_t * stat)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        u16 lock = dib8000_read_word(state, 568);
+
+        *stat = 0;
+
+        if ((lock >> 14) & 1)   // AGC
+                *stat |= FE_HAS_SIGNAL;
+
+        if ((lock >> 8) & 1)    // Equal
+                *stat |= FE_HAS_CARRIER;
+
+        if ((lock >> 3) & 1)    // TMCC_SYNC
+                *stat |= FE_HAS_SYNC;
+
+        if ((lock >> 5) & 7)    // FEC MPEG
+                *stat |= FE_HAS_LOCK;
+
+        lock = dib8000_read_word(state, 554);   // Viterbi Layer A
+        if (lock & 0x01)
+                *stat |= FE_HAS_VITERBI;
+
+        lock = dib8000_read_word(state, 555);   // Viterbi Layer B
+        if (lock & 0x01)
+                *stat |= FE_HAS_VITERBI;
+
+        lock = dib8000_read_word(state, 556);   // Viterbi Layer C
+        if (lock & 0x01)
+                *stat |= FE_HAS_VITERBI;
+
+        return 0;
+}
+
+static int dib8000_read_ber(struct dvb_frontend *fe, u32 * ber)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        *ber = (dib8000_read_word(state, 560) << 16) | dib8000_read_word(state, 561);   // 13 segments
+        return 0;
+}
+
+static int dib8000_read_unc_blocks(struct dvb_frontend *fe, u32 * unc)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        *unc = dib8000_read_word(state, 565);   // packet error on 13 seg
+        return 0;
+}
+
+static int dib8000_read_signal_strength(struct dvb_frontend *fe, u16 * strength)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        u16 val = dib8000_read_word(state, 390);
+        *strength = 65535 - val;
+        return 0;
+}
+
+static int dib8000_read_snr(struct dvb_frontend *fe, u16 * snr)
+{
+        struct dib8000_state *state = fe->demodulator_priv;
+        u16 val;
+        s32 signal_mant, signal_exp, noise_mant, noise_exp;
+        u32 result = 0;
+
+        val = dib8000_read_word(state, 542);
+        noise_mant = (val >> 6) & 0xff;
+        noise_exp = (val & 0x3f);
+
+        val = dib8000_read_word(state, 543);
+        signal_mant = (val >> 6) & 0xff;
+        signal_exp = (val & 0x3f);
+
+        if ((noise_exp & 0x20) != 0)
+                noise_exp -= 0x40;
+        if ((signal_exp & 0x20) != 0)
+                signal_exp -= 0x40;
+
+        if (signal_mant != 0)
+                result = intlog10(2) * 10 * signal_exp + 10 * intlog10(signal_mant);
+        else
+                result = intlog10(2) * 10 * signal_exp - 100;
+        if (noise_mant != 0)
+                result -= intlog10(2) * 10 * noise_exp + 10 * intlog10(noise_mant);
+        else
+                result -= intlog10(2) * 10 * noise_exp - 100;
+
+        *snr = result / (1 << 24);
+        return 0;
+}
+
+int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods, u8 default_addr, u8 first_addr)
+{
+        int k = 0;
+        u8 new_addr = 0;
+        struct i2c_device client = {.adap = host };
+
+        for (k = no_of_demods - 1; k >= 0; k--) {
+                /* designated i2c address */
+                new_addr = first_addr + (k << 1);
+
+                client.addr = new_addr;
+                dib8000_i2c_write16(&client, 1287, 0x0003);     /* sram lead in, rdy */
+                if (dib8000_identify(&client) == 0) {
+                        dib8000_i2c_write16(&client, 1287, 0x0003);     /* sram lead in, rdy */
+                        client.addr = default_addr;
+                        if (dib8000_identify(&client) == 0) {
+                                dprintk("#%d: not identified", k);
+                                return -EINVAL;
+                        }
+                }
+
+                /* start diversity to pull_down div_str - just for i2c-enumeration */
+                dib8000_i2c_write16(&client, 1286, (1 << 10) | (4 << 6));
+
+                /* set new i2c address and force divstart */
+                dib8000_i2c_write16(&client, 1285, (new_addr << 2) | 0x2);
+                client.addr = new_addr;
+                dib8000_identify(&client);
+
+                dprintk("IC %d initialized (to i2c_address 0x%x)", k, new_addr);
+        }
+
+        for (k = 0; k < no_of_demods; k++) {
+                new_addr = first_addr | (k << 1);
+                client.addr = new_addr;
+
+                // unforce divstr
+                dib8000_i2c_write16(&client, 1285, new_addr << 2);
+
+                /* deactivate div - it was just for i2c-enumeration */
+                dib8000_i2c_write16(&client, 1286, 0);
+        }
+
+        return 0;
+}
+
+EXPORT_SYMBOL(dib8000_i2c_enumeration);
+static int dib8000_fe_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings *tune)
+{
+        tune->min_delay_ms = 1000;
+        tune->step_size = 0;
+        tune->max_drift = 0;
+        return 0;
+}
+
+static void dib8000_release(struct dvb_frontend *fe)
+{
+        struct dib8000_state *st = fe->demodulator_priv;
+        dibx000_exit_i2c_master(&st->i2c_master);
+        kfree(st);
+}
+
+struct i2c_adapter *dib8000_get_i2c_master(struct dvb_frontend *fe, enum dibx000_i2c_interface intf, int gating)
+{
+        struct dib8000_state *st = fe->demodulator_priv;
+        return dibx000_get_i2c_adapter(&st->i2c_master, intf, gating);
+}
+
+EXPORT_SYMBOL(dib8000_get_i2c_master);
+
+static const struct dvb_frontend_ops dib8000_ops = {
+        .info = {
+                 .name = "DiBcom 8000 ISDB-T",
+                 .type = FE_OFDM,
+                 .frequency_min = 44250000,
+                 .frequency_max = 867250000,
+                 .frequency_stepsize = 62500,
+                 .caps = FE_CAN_INVERSION_AUTO |
+                 FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
+                 FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
+                 FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_RECOVER | FE_CAN_HIERARCHY_AUTO,
+                 },
+
+        .release = dib8000_release,
+
+        .init = dib8000_wakeup,
+        .sleep = dib8000_sleep,
+
+        .set_frontend = dib8000_set_frontend,
+        .get_tune_settings = dib8000_fe_get_tune_settings,
+        .get_frontend = dib8000_get_frontend,
+
+        .read_status = dib8000_read_status,
+        .read_ber = dib8000_read_ber,
+        .read_signal_strength = dib8000_read_signal_strength,
+        .read_snr = dib8000_read_snr,
+        .read_ucblocks = dib8000_read_unc_blocks,
+};
+
+struct dvb_frontend *dib8000_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib8000_config *cfg)
+{
+        struct dvb_frontend *fe;
+        struct dib8000_state *state;
+
+        dprintk("dib8000_attach");
+
+        state = kzalloc(sizeof(struct dib8000_state), GFP_KERNEL);
+        if (state == NULL)
+                return NULL;
+
+        memcpy(&state->cfg, cfg, sizeof(struct dib8000_config));
+        state->i2c.adap = i2c_adap;
+        state->i2c.addr = i2c_addr;
+        state->gpio_val = cfg->gpio_val;
+        state->gpio_dir = cfg->gpio_dir;
+
+        /* Ensure the output mode remains at the previous default if it's
+         * not specifically set by the caller.
+         */
+        if ((state->cfg.output_mode != OUTMODE_MPEG2_SERIAL) && (state->cfg.output_mode != OUTMODE_MPEG2_PAR_GATED_CLK))
+                state->cfg.output_mode = OUTMODE_MPEG2_FIFO;
+
+        fe = &state->fe;
+        fe->demodulator_priv = state;
+        memcpy(&state->fe.ops, &dib8000_ops, sizeof(struct dvb_frontend_ops));
+
+        state->timf_default = cfg->pll->timf;
+
+        if (dib8000_identify(&state->i2c) == 0)
+                goto error;
+
+        dibx000_init_i2c_master(&state->i2c_master, DIB8000, state->i2c.adap, state->i2c.addr);
+
+        dib8000_reset(fe);
+
+        dib8000_write_word(state, 285, (dib8000_read_word(state, 285) & ~0x60) | (3 << 5));     /* ber_rs_len = 3 */
+
+        return fe;
+
+ error:
+        kfree(state);
+        return NULL;
+}
+
+EXPORT_SYMBOL(dib8000_attach);
+
+MODULE_AUTHOR("Olivier Grenie <Olivier.Grenie@dibcom.fr, " "Patrick Boettcher <pboettcher@dibcom.fr>");
+MODULE_DESCRIPTION("Driver for the DiBcom 8000 ISDB-T demodulator");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/frontends/dib8000.h b/drivers/media/dvb/frontends/dib8000.h
new file mode 100644
index 000000000000..a86de340dd54
--- /dev/null
+++ b/drivers/media/dvb/frontends/dib8000.h
@@ -0,0 +1,79 @@
+#ifndef DIB8000_H
+#define DIB8000_H
+
+#include "dibx000_common.h"
+
+struct dib8000_config {
+        u8 output_mpeg2_in_188_bytes;
+        u8 hostbus_diversity;
+        u8 tuner_is_baseband;
+        int (*update_lna) (struct dvb_frontend *, u16 agc_global);
+
+        u8 agc_config_count;
+        struct dibx000_agc_config *agc;
+        struct dibx000_bandwidth_config *pll;
+
+#define DIB8000_GPIO_DEFAULT_DIRECTIONS 0xffff
+        u16 gpio_dir;
+#define DIB8000_GPIO_DEFAULT_VALUES     0x0000
+        u16 gpio_val;
+#define DIB8000_GPIO_PWM_POS0(v)        ((v & 0xf) << 12)
+#define DIB8000_GPIO_PWM_POS1(v)        ((v & 0xf) << 8 )
+#define DIB8000_GPIO_PWM_POS2(v)        ((v & 0xf) << 4 )
+#define DIB8000_GPIO_PWM_POS3(v)         (v & 0xf)
+#define DIB8000_GPIO_DEFAULT_PWM_POS    0xffff
+        u16 gpio_pwm_pos;
+        u16 pwm_freq_div;
+
+        void (*agc_control) (struct dvb_frontend *, u8 before);
+
+        u16 drives;
+        u16 diversity_delay;
+        u8 div_cfg;
+        u8 output_mode;
+        u8 refclksel;
+};
+
+#define DEFAULT_DIB8000_I2C_ADDRESS 18
+
+#if defined(CONFIG_DVB_DIB8000) || (defined(CONFIG_DVB_DIB8000_MODULE) && defined(MODULE))
+extern struct dvb_frontend *dib8000_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib8000_config *cfg);
+extern struct i2c_adapter *dib8000_get_i2c_master(struct dvb_frontend *, enum dibx000_i2c_interface, int);
+
+extern int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods, u8 default_addr, u8 first_addr);
+
+extern int dib8000_set_gpio(struct dvb_frontend *, u8 num, u8 dir, u8 val);
+extern int dib8000_set_wbd_ref(struct dvb_frontend *, u16 value);
+#else
+static inline struct dvb_frontend *dib8000_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib8000_config *cfg)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+
+static inline struct i2c_adapter *dib8000_get_i2c_master(struct dvb_frontend *fe, enum dibx000_i2c_interface i, int x)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return NULL;
+}
+
+int dib8000_i2c_enumeration(struct i2c_adapter *host, int no_of_demods, u8 default_addr, u8 first_addr)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return -ENODEV;
+}
+
+int dib8000_set_gpio(struct dvb_frontend *fe, u8 num, u8 dir, u8 val)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return -ENODEV;
+}
+
+int dib8000_set_wbd_ref(struct dvb_frontend *fe, u16 value)
+{
+        printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+        return -ENODEV;
+}
+#endif
+
+#endif
diff --git a/drivers/media/dvb/frontends/dibx000_common.c b/drivers/media/dvb/frontends/dibx000_common.c
index 315e09e95b0c..4efca30d2127 100644
--- a/drivers/media/dvb/frontends/dibx000_common.c
+++ b/drivers/media/dvb/frontends/dibx000_common.c
@@ -15,29 +15,31 @@ static int dibx000_write_word(struct dibx000_i2c_master *mst, u16 reg, u16 val)
                 (val >> 8) & 0xff, val & 0xff,
         };
         struct i2c_msg msg = {
-                .addr = mst->i2c_addr, .flags = 0, .buf = b, .len = 4
+                .addr = mst->i2c_addr,.flags = 0,.buf = b,.len = 4
         };
         return i2c_transfer(mst->i2c_adap, &msg, 1) != 1 ? -EREMOTEIO : 0;
 }
 
 
-static int dibx000_i2c_select_interface(struct dibx000_i2c_master *mst, enum dibx000_i2c_interface intf)
+static int dibx000_i2c_select_interface(struct dibx000_i2c_master *mst,
+                                        enum dibx000_i2c_interface intf)
 {
         if (mst->device_rev > DIB3000MC && mst->selected_interface != intf) {
-                dprintk("selecting interface: %d\n",intf);
+                dprintk("selecting interface: %d\n", intf);
                 mst->selected_interface = intf;
                 return dibx000_write_word(mst, mst->base_reg + 4, intf);
         }
         return 0;
 }
 
-static int dibx000_i2c_gate_ctrl(struct dibx000_i2c_master *mst, u8 tx[4], u8 addr, int onoff)
+static int dibx000_i2c_gate_ctrl(struct dibx000_i2c_master *mst, u8 tx[4],
+                                 u8 addr, int onoff)
 {
         u16 val;
 
 
         if (onoff)
-                val = addr << 8; // bit 7 = use master or not, if 0, the gate is open
+                val = addr << 8;        // bit 7 = use master or not, if 0, the gate is open
         else
                 val = 1 << 7;
 
@@ -45,7 +47,7 @@ static int dibx000_i2c_gate_ctrl(struct dibx000_i2c_master *mst, u8 tx[4], u8 ad
                 val <<= 1;
 
         tx[0] = (((mst->base_reg + 1) >> 8) & 0xff);
-        tx[1] = ( (mst->base_reg + 1)       & 0xff);
+        tx[1] = ((mst->base_reg + 1) & 0xff);
         tx[2] = val >> 8;
         tx[3] = val & 0xff;
 
@@ -57,59 +59,78 @@ static u32 dibx000_i2c_func(struct i2c_adapter *adapter)
         return I2C_FUNC_I2C;
 }
 
-static int dibx000_i2c_gated_tuner_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msg[], int num)
+static int dibx000_i2c_gated_tuner_xfer(struct i2c_adapter *i2c_adap,
+                                        struct i2c_msg msg[], int num)
 {
         struct dibx000_i2c_master *mst = i2c_get_adapdata(i2c_adap);
         struct i2c_msg m[2 + num];
         u8 tx_open[4], tx_close[4];
 
-        memset(m,0, sizeof(struct i2c_msg) * (2 + num));
+        memset(m, 0, sizeof(struct i2c_msg) * (2 + num));
 
         dibx000_i2c_select_interface(mst, DIBX000_I2C_INTERFACE_TUNER);
 
-        dibx000_i2c_gate_ctrl(mst, tx_open,  msg[0].addr, 1);
+        dibx000_i2c_gate_ctrl(mst, tx_open, msg[0].addr, 1);
         m[0].addr = mst->i2c_addr;
-        m[0].buf  = tx_open;
-        m[0].len  = 4;
+        m[0].buf = tx_open;
+        m[0].len = 4;
 
         memcpy(&m[1], msg, sizeof(struct i2c_msg) * num);
 
         dibx000_i2c_gate_ctrl(mst, tx_close, 0, 0);
-        m[num+1].addr = mst->i2c_addr;
-        m[num+1].buf  = tx_close;
-        m[num+1].len  = 4;
+        m[num + 1].addr = mst->i2c_addr;
+        m[num + 1].buf = tx_close;
+        m[num + 1].len = 4;
 
-        return i2c_transfer(mst->i2c_adap, m, 2+num) == 2 + num ? num : -EIO;
+        return i2c_transfer(mst->i2c_adap, m, 2 + num) == 2 + num ? num : -EIO;
 }
 
 static struct i2c_algorithm dibx000_i2c_gated_tuner_algo = {
-        .master_xfer   = dibx000_i2c_gated_tuner_xfer,
+        .master_xfer = dibx000_i2c_gated_tuner_xfer,
         .functionality = dibx000_i2c_func,
 };
 
-struct i2c_adapter * dibx000_get_i2c_adapter(struct dibx000_i2c_master *mst, enum dibx000_i2c_interface intf, int gating)
+struct i2c_adapter *dibx000_get_i2c_adapter(struct dibx000_i2c_master *mst,
+                                            enum dibx000_i2c_interface intf,
+                                            int gating)
 {
         struct i2c_adapter *i2c = NULL;
 
         switch (intf) {
-                case DIBX000_I2C_INTERFACE_TUNER:
-                        if (gating)
-                                i2c = &mst->gated_tuner_i2c_adap;
-                        break;
-                default:
-                        printk(KERN_ERR "DiBX000: incorrect I2C interface selected\n");
-                        break;
+        case DIBX000_I2C_INTERFACE_TUNER:
+                if (gating)
+                        i2c = &mst->gated_tuner_i2c_adap;
+                break;
+        default:
+                printk(KERN_ERR "DiBX000: incorrect I2C interface selected\n");
+                break;
         }
 
         return i2c;
 }
+
 EXPORT_SYMBOL(dibx000_get_i2c_adapter);
 
-static int i2c_adapter_init(struct i2c_adapter *i2c_adap, struct i2c_algorithm *algo, const char *name, struct dibx000_i2c_master *mst)
+void dibx000_reset_i2c_master(struct dibx000_i2c_master *mst)
+{
+        /* initialize the i2c-master by closing the gate */
+        u8 tx[4];
+        struct i2c_msg m = {.addr = mst->i2c_addr,.buf = tx,.len = 4 };
+
+        dibx000_i2c_gate_ctrl(mst, tx, 0, 0);
+        i2c_transfer(mst->i2c_adap, &m, 1);
+        mst->selected_interface = 0xff; // the first time force a select of the I2C
+        dibx000_i2c_select_interface(mst, DIBX000_I2C_INTERFACE_TUNER);
+}
+
+EXPORT_SYMBOL(dibx000_reset_i2c_master);
+
+static int i2c_adapter_init(struct i2c_adapter *i2c_adap,
+                            struct i2c_algorithm *algo, const char *name,
+                            struct dibx000_i2c_master *mst)
 {
         strncpy(i2c_adap->name, name, sizeof(i2c_adap->name));
-        i2c_adap->class     = I2C_CLASS_TV_DIGITAL,
-        i2c_adap->algo      = algo;
+        i2c_adap->class = I2C_CLASS_TV_DIGITAL, i2c_adap->algo = algo;
         i2c_adap->algo_data = NULL;
         i2c_set_adapdata(i2c_adap, mst);
         if (i2c_add_adapter(i2c_adap) < 0)
@@ -117,34 +138,40 @@ static int i2c_adapter_init(struct i2c_adapter *i2c_adap, struct i2c_algorithm *
         return 0;
 }
 
-int dibx000_init_i2c_master(struct dibx000_i2c_master *mst, u16 device_rev, struct i2c_adapter *i2c_adap, u8 i2c_addr)
+int dibx000_init_i2c_master(struct dibx000_i2c_master *mst, u16 device_rev,
+                            struct i2c_adapter *i2c_adap, u8 i2c_addr)
 {
         u8 tx[4];
-        struct i2c_msg m = { .addr = i2c_addr >> 1, .buf = tx, .len = 4 };
+        struct i2c_msg m = {.addr = i2c_addr >> 1,.buf = tx,.len = 4 };
 
         mst->device_rev = device_rev;
-        mst->i2c_adap   = i2c_adap;
-        mst->i2c_addr   = i2c_addr >> 1;
+        mst->i2c_adap = i2c_adap;
+        mst->i2c_addr = i2c_addr >> 1;
 
-        if (device_rev == DIB7000P)
+        if (device_rev == DIB7000P || device_rev == DIB8000)
                 mst->base_reg = 1024;
         else
                 mst->base_reg = 768;
 
-    if (i2c_adapter_init(&mst->gated_tuner_i2c_adap, &dibx000_i2c_gated_tuner_algo, "DiBX000 tuner I2C bus", mst) != 0)
-                printk(KERN_ERR "DiBX000: could not initialize the tuner i2c_adapter\n");
+        if (i2c_adapter_init
+            (&mst->gated_tuner_i2c_adap, &dibx000_i2c_gated_tuner_algo,
+             "DiBX000 tuner I2C bus", mst) != 0)
+                printk(KERN_ERR
+                       "DiBX000: could not initialize the tuner i2c_adapter\n");
 
         /* initialize the i2c-master by closing the gate */
         dibx000_i2c_gate_ctrl(mst, tx, 0, 0);
 
         return i2c_transfer(i2c_adap, &m, 1) == 1;
 }
+
 EXPORT_SYMBOL(dibx000_init_i2c_master);
 
 void dibx000_exit_i2c_master(struct dibx000_i2c_master *mst)
 {
         i2c_del_adapter(&mst->gated_tuner_i2c_adap);
 }
+
 EXPORT_SYMBOL(dibx000_exit_i2c_master);
 
 MODULE_AUTHOR("Patrick Boettcher <pboettcher@dibcom.fr>");
diff --git a/drivers/media/dvb/frontends/dibx000_common.h b/drivers/media/dvb/frontends/dibx000_common.h
index 84e4d5362922..5be10eca07c0 100644
--- a/drivers/media/dvb/frontends/dibx000_common.h
+++ b/drivers/media/dvb/frontends/dibx000_common.h
@@ -2,7 +2,7 @@
 #define DIBX000_COMMON_H
 
 enum dibx000_i2c_interface {
-        DIBX000_I2C_INTERFACE_TUNER    = 0,
+        DIBX000_I2C_INTERFACE_TUNER = 0,
         DIBX000_I2C_INTERFACE_GPIO_1_2 = 1,
         DIBX000_I2C_INTERFACE_GPIO_3_4 = 2
 };
@@ -12,22 +12,29 @@ struct dibx000_i2c_master {
 #define DIB7000   2
 #define DIB7000P  11
 #define DIB7000MC 12
+#define DIB8000   13
         u16 device_rev;
 
         enum dibx000_i2c_interface selected_interface;
 
-//      struct i2c_adapter  tuner_i2c_adap;
-        struct i2c_adapter  gated_tuner_i2c_adap;
+//      struct i2c_adapter  tuner_i2c_adap;
+        struct i2c_adapter gated_tuner_i2c_adap;
 
         struct i2c_adapter *i2c_adap;
-        u8                  i2c_addr;
+        u8 i2c_addr;
 
         u16 base_reg;
 };
 
-extern int dibx000_init_i2c_master(struct dibx000_i2c_master *mst, u16 device_rev, struct i2c_adapter *i2c_adap, u8 i2c_addr);
-extern struct i2c_adapter * dibx000_get_i2c_adapter(struct dibx000_i2c_master *mst, enum dibx000_i2c_interface intf, int gating);
+extern int dibx000_init_i2c_master(struct dibx000_i2c_master *mst,
+                                   u16 device_rev, struct i2c_adapter *i2c_adap,
+                                   u8 i2c_addr);
+extern struct i2c_adapter *dibx000_get_i2c_adapter(struct dibx000_i2c_master
+                                                   *mst,
+                                                   enum dibx000_i2c_interface
+                                                   intf, int gating);
 extern void dibx000_exit_i2c_master(struct dibx000_i2c_master *mst);
+extern void dibx000_reset_i2c_master(struct dibx000_i2c_master *mst);
 
 #define BAND_LBAND 0x01
 #define BAND_UHF   0x02
@@ -41,18 +48,18 @@ extern void dibx000_exit_i2c_master(struct dibx000_i2c_master *mst);
                                                                         (freq_kHz) <= 2000000 ? BAND_LBAND : BAND_SBAND )
 
 struct dibx000_agc_config {
-        /* defines the capabilities of this AGC-setting - using the BAND_-defines*/
-        u8  band_caps;
+        /* defines the capabilities of this AGC-setting - using the BAND_-defines */
+        u8 band_caps;
 
         u16 setup;
 
         u16 inv_gain;
         u16 time_stabiliz;
 
-        u8  alpha_level;
+        u8 alpha_level;
         u16 thlock;
 
-        u8  wbd_inv;
+        u8 wbd_inv;
         u16 wbd_ref;
         u8 wbd_sel;
         u8 wbd_alpha;
@@ -92,8 +99,8 @@ struct dibx000_agc_config {
 };
 
 struct dibx000_bandwidth_config {
-        u32   internal;
-        u32   sampling;
+        u32 internal;
+        u32 sampling;
 
         u8 pll_prediv;
         u8 pll_ratio;
diff --git a/drivers/media/dvb/frontends/lgdt3304.c b/drivers/media/dvb/frontends/lgdt3304.c
index eb72a9866c93..e334b5d4e578 100644
--- a/drivers/media/dvb/frontends/lgdt3304.c
+++ b/drivers/media/dvb/frontends/lgdt3304.c
@@ -363,6 +363,8 @@ struct dvb_frontend* lgdt3304_attach(const struct lgdt3304_config *config,
 
         struct lgdt3304_state *state;
         state = kzalloc(sizeof(struct lgdt3304_state), GFP_KERNEL);
+        if (state == NULL)
+                return NULL;
         state->addr = config->i2c_address;
         state->i2c = i2c;
 
diff --git a/drivers/media/dvb/frontends/s921_module.c b/drivers/media/dvb/frontends/s921_module.c
index 3f5a0e1dfdf5..3156b64cfc96 100644
--- a/drivers/media/dvb/frontends/s921_module.c
+++ b/drivers/media/dvb/frontends/s921_module.c
@@ -169,6 +169,8 @@ struct dvb_frontend* s921_attach(const struct s921_config *config,
 
         struct s921_state *state;
         state = kzalloc(sizeof(struct s921_state), GFP_KERNEL);
+        if (state == NULL)
+                return NULL;
 
         state->addr = config->i2c_address;
         state->i2c = i2c;
diff --git a/drivers/media/dvb/pt1/Kconfig b/drivers/media/dvb/pt1/Kconfig
new file mode 100644
index 000000000000..24501d5bf70d
--- /dev/null
+++ b/drivers/media/dvb/pt1/Kconfig
@@ -0,0 +1,12 @@
+config DVB_PT1
+        tristate "PT1 cards"
+        depends on DVB_CORE && PCI && I2C
+        help
+          Support for Earthsoft PT1 PCI cards.
+
+          Since these cards have no MPEG decoder onboard, they transmit
+          only compressed MPEG data over the PCI bus, so you need
+          an external software decoder to watch TV on your computer.
+
+          Say Y or M if you own such a device and want to use it.
+
diff --git a/drivers/media/dvb/pt1/Makefile b/drivers/media/dvb/pt1/Makefile
new file mode 100644
index 000000000000..a66da17bbe31
--- /dev/null
+++ b/drivers/media/dvb/pt1/Makefile
@@ -0,0 +1,5 @@
+earth-pt1-objs := pt1.o va1j5jf8007s.o va1j5jf8007t.o
+
+obj-$(CONFIG_DVB_PT1) += earth-pt1.o
+
+EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core -Idrivers/media/dvb/frontends
diff --git a/drivers/media/dvb/pt1/pt1.c b/drivers/media/dvb/pt1/pt1.c
new file mode 100644
index 000000000000..8ffbcecad931
--- /dev/null
+++ b/drivers/media/dvb/pt1/pt1.c
@@ -0,0 +1,1056 @@
+/*
+ * driver for Earthsoft PT1
+ *
+ * Copyright (C) 2009 HIRANO Takahito <hiranotaka@zng.info>
+ *
+ * based on pt1dvr - http://pt1dvr.sourceforge.jp/
+ *      by Tomoaki Ishikawa <tomy@users.sourceforge.jp>
+ *
+ * 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>
+#include <linux/pci.h>
+#include <linux/kthread.h>
+#include <linux/freezer.h>
+
+#include "dvbdev.h"
+#include "dvb_demux.h"
+#include "dmxdev.h"
+#include "dvb_net.h"
+#include "dvb_frontend.h"
+
+#include "va1j5jf8007t.h"
+#include "va1j5jf8007s.h"
+
+#define DRIVER_NAME "earth-pt1"
+
+#define PT1_PAGE_SHIFT 12
+#define PT1_PAGE_SIZE (1 << PT1_PAGE_SHIFT)
+#define PT1_NR_UPACKETS 1024
+#define PT1_NR_BUFS 511
+
+struct pt1_buffer_page {
+        __le32 upackets[PT1_NR_UPACKETS];
+};
+
+struct pt1_table_page {
+        __le32 next_pfn;
+        __le32 buf_pfns[PT1_NR_BUFS];
+};
+
+struct pt1_buffer {
+        struct pt1_buffer_page *page;
+        dma_addr_t addr;
+};
+
+struct pt1_table {
+        struct pt1_table_page *page;
+        dma_addr_t addr;
+        struct pt1_buffer bufs[PT1_NR_BUFS];
+};
+
+#define PT1_NR_ADAPS 4
+
+struct pt1_adapter;
+
+struct pt1 {
+        struct pci_dev *pdev;
+        void __iomem *regs;
+        struct i2c_adapter i2c_adap;
+        int i2c_running;
+        struct pt1_adapter *adaps[PT1_NR_ADAPS];
+        struct pt1_table *tables;
+        struct task_struct *kthread;
+};
+
+struct pt1_adapter {
+        struct pt1 *pt1;
+        int index;
+
+        u8 *buf;
+        int upacket_count;
+        int packet_count;
+
+        struct dvb_adapter adap;
+        struct dvb_demux demux;
+        int users;
+        struct dmxdev dmxdev;
+        struct dvb_net net;
+        struct dvb_frontend *fe;
+        int (*orig_set_voltage)(struct dvb_frontend *fe,
+                                fe_sec_voltage_t voltage);
+};
+
+#define pt1_printk(level, pt1, format, arg...)  \
+        dev_printk(level, &(pt1)->pdev->dev, format, ##arg)
+
+static void pt1_write_reg(struct pt1 *pt1, int reg, u32 data)
+{
+        writel(data, pt1->regs + reg * 4);
+}
+
+static u32 pt1_read_reg(struct pt1 *pt1, int reg)
+{
+        return readl(pt1->regs + reg * 4);
+}
+
+static int pt1_nr_tables = 64;
+module_param_named(nr_tables, pt1_nr_tables, int, 0);
+
+static void pt1_increment_table_count(struct pt1 *pt1)
+{
+        pt1_write_reg(pt1, 0, 0x00000020);
+}
+
+static void pt1_init_table_count(struct pt1 *pt1)
+{
+        pt1_write_reg(pt1, 0, 0x00000010);
+}
+
+static void pt1_register_tables(struct pt1 *pt1, u32 first_pfn)
+{
+        pt1_write_reg(pt1, 5, first_pfn);
+        pt1_write_reg(pt1, 0, 0x0c000040);
+}
+
+static void pt1_unregister_tables(struct pt1 *pt1)
+{
+        pt1_write_reg(pt1, 0, 0x08080000);
+}
+
+static int pt1_sync(struct pt1 *pt1)
+{
+        int i;
+        for (i = 0; i < 57; i++) {
+                if (pt1_read_reg(pt1, 0) & 0x20000000)
+                        return 0;
+                pt1_write_reg(pt1, 0, 0x00000008);
+        }
+        pt1_printk(KERN_ERR, pt1, "could not sync\n");
+        return -EIO;
+}
+
+static u64 pt1_identify(struct pt1 *pt1)
+{
+        int i;
+        u64 id;
+        id = 0;
+        for (i = 0; i < 57; i++) {
+                id |= (u64)(pt1_read_reg(pt1, 0) >> 30 & 1) << i;
+                pt1_write_reg(pt1, 0, 0x00000008);
+        }
+        return id;
+}
+
+static int pt1_unlock(struct pt1 *pt1)
+{
+        int i;
+        pt1_write_reg(pt1, 0, 0x00000008);
+        for (i = 0; i < 3; i++) {
+                if (pt1_read_reg(pt1, 0) & 0x80000000)
+                        return 0;
+                schedule_timeout_uninterruptible((HZ + 999) / 1000);
+        }
+        pt1_printk(KERN_ERR, pt1, "could not unlock\n");
+        return -EIO;
+}
+
+static int pt1_reset_pci(struct pt1 *pt1)
+{
+        int i;
+        pt1_write_reg(pt1, 0, 0x01010000);
+        pt1_write_reg(pt1, 0, 0x01000000);
+        for (i = 0; i < 10; i++) {
+                if (pt1_read_reg(pt1, 0) & 0x00000001)
+                        return 0;
+                schedule_timeout_uninterruptible((HZ + 999) / 1000);
+        }
+        pt1_printk(KERN_ERR, pt1, "could not reset PCI\n");
+        return -EIO;
+}
+
+static int pt1_reset_ram(struct pt1 *pt1)
+{
+        int i;
+        pt1_write_reg(pt1, 0, 0x02020000);
+        pt1_write_reg(pt1, 0, 0x02000000);
+        for (i = 0; i < 10; i++) {
+                if (pt1_read_reg(pt1, 0) & 0x00000002)
+                        return 0;
+                schedule_timeout_uninterruptible((HZ + 999) / 1000);
+        }
+        pt1_printk(KERN_ERR, pt1, "could not reset RAM\n");
+        return -EIO;
+}
+
+static int pt1_do_enable_ram(struct pt1 *pt1)
+{
+        int i, j;
+        u32 status;
+        status = pt1_read_reg(pt1, 0) & 0x00000004;
+        pt1_write_reg(pt1, 0, 0x00000002);
+        for (i = 0; i < 10; i++) {
+                for (j = 0; j < 1024; j++) {
+                        if ((pt1_read_reg(pt1, 0) & 0x00000004) != status)
+                                return 0;
+                }
+                schedule_timeout_uninterruptible((HZ + 999) / 1000);
+        }
+        pt1_printk(KERN_ERR, pt1, "could not enable RAM\n");
+        return -EIO;
+}
+
+static int pt1_enable_ram(struct pt1 *pt1)
+{
+        int i, ret;
+        schedule_timeout_uninterruptible((HZ + 999) / 1000);
+        for (i = 0; i < 10; i++) {
+                ret = pt1_do_enable_ram(pt1);
+                if (ret < 0)
+                        return ret;
+        }
+        return 0;
+}
+
+static void pt1_disable_ram(struct pt1 *pt1)
+{
+        pt1_write_reg(pt1, 0, 0x0b0b0000);
+}
+
+static void pt1_set_stream(struct pt1 *pt1, int index, int enabled)
+{
+        pt1_write_reg(pt1, 2, 1 << (index + 8) | enabled << index);
+}
+
+static void pt1_init_streams(struct pt1 *pt1)
+{
+        int i;
+        for (i = 0; i < PT1_NR_ADAPS; i++)
+                pt1_set_stream(pt1, i, 0);
+}
+
+static int pt1_filter(struct pt1 *pt1, struct pt1_buffer_page *page)
+{
+        u32 upacket;
+        int i;
+        int index;
+        struct pt1_adapter *adap;
+        int offset;
+        u8 *buf;
+
+        if (!page->upackets[PT1_NR_UPACKETS - 1])
+                return 0;
+
+        for (i = 0; i < PT1_NR_UPACKETS; i++) {
+                upacket = le32_to_cpu(page->upackets[i]);
+                index = (upacket >> 29) - 1;
+                if (index < 0 || index >=  PT1_NR_ADAPS)
+                        continue;
+
+                adap = pt1->adaps[index];
+                if (upacket >> 25 & 1)
+                        adap->upacket_count = 0;
+                else if (!adap->upacket_count)
+                        continue;
+
+                buf = adap->buf;
+                offset = adap->packet_count * 188 + adap->upacket_count * 3;
+                buf[offset] = upacket >> 16;
+                buf[offset + 1] = upacket >> 8;
+                if (adap->upacket_count != 62)
+                        buf[offset + 2] = upacket;
+
+                if (++adap->upacket_count >= 63) {
+                        adap->upacket_count = 0;
+                        if (++adap->packet_count >= 21) {
+                                dvb_dmx_swfilter_packets(&adap->demux, buf, 21);
+                                adap->packet_count = 0;
+                        }
+                }
+        }
+
+        page->upackets[PT1_NR_UPACKETS - 1] = 0;
+        return 1;
+}
+
+static int pt1_thread(void *data)
+{
+        struct pt1 *pt1;
+        int table_index;
+        int buf_index;
+        struct pt1_buffer_page *page;
+
+        pt1 = data;
+        set_freezable();
+
+        table_index = 0;
+        buf_index = 0;
+
+        while (!kthread_should_stop()) {
+                try_to_freeze();
+
+                page = pt1->tables[table_index].bufs[buf_index].page;
+                if (!pt1_filter(pt1, page)) {
+                        schedule_timeout_interruptible((HZ + 999) / 1000);
+                        continue;
+                }
+
+                if (++buf_index >= PT1_NR_BUFS) {
+                        pt1_increment_table_count(pt1);
+                        buf_index = 0;
+                        if (++table_index >= pt1_nr_tables)
+                                table_index = 0;
+                }
+        }
+
+        return 0;
+}
+
+static void pt1_free_page(struct pt1 *pt1, void *page, dma_addr_t addr)
+{
+        dma_free_coherent(&pt1->pdev->dev, PT1_PAGE_SIZE, page, addr);
+}
+
+static void *pt1_alloc_page(struct pt1 *pt1, dma_addr_t *addrp, u32 *pfnp)
+{
+        void *page;
+        dma_addr_t addr;
+
+        page = dma_alloc_coherent(&pt1->pdev->dev, PT1_PAGE_SIZE, &addr,
+                                  GFP_KERNEL);
+        if (page == NULL)
+                return NULL;
+
+        BUG_ON(addr & (PT1_PAGE_SIZE - 1));
+        BUG_ON(addr >> PT1_PAGE_SHIFT >> 31 >> 1);
+
+        *addrp = addr;
+        *pfnp = addr >> PT1_PAGE_SHIFT;
+        return page;
+}
+
+static void pt1_cleanup_buffer(struct pt1 *pt1, struct pt1_buffer *buf)
+{
+        pt1_free_page(pt1, buf->page, buf->addr);
+}
+
+static int
+pt1_init_buffer(struct pt1 *pt1, struct pt1_buffer *buf,  u32 *pfnp)
+{
+        struct pt1_buffer_page *page;
+        dma_addr_t addr;
+
+        page = pt1_alloc_page(pt1, &addr, pfnp);
+        if (page == NULL)
+                return -ENOMEM;
+
+        page->upackets[PT1_NR_UPACKETS - 1] = 0;
+
+        buf->page = page;
+        buf->addr = addr;
+        return 0;
+}
+
+static void pt1_cleanup_table(struct pt1 *pt1, struct pt1_table *table)
+{
+        int i;
+
+        for (i = 0; i < PT1_NR_BUFS; i++)
+                pt1_cleanup_buffer(pt1, &table->bufs[i]);
+
+        pt1_free_page(pt1, table->page, table->addr);
+}
+
+static int
+pt1_init_table(struct pt1 *pt1, struct pt1_table *table, u32 *pfnp)
+{
+        struct pt1_table_page *page;
+        dma_addr_t addr;
+        int i, ret;
+        u32 buf_pfn;
+
+        page = pt1_alloc_page(pt1, &addr, pfnp);
+        if (page == NULL)
+                return -ENOMEM;
+
+        for (i = 0; i < PT1_NR_BUFS; i++) {
+                ret = pt1_init_buffer(pt1, &table->bufs[i], &buf_pfn);
+                if (ret < 0)
+                        goto err;
+
+                page->buf_pfns[i] = cpu_to_le32(buf_pfn);
+        }
+
+        pt1_increment_table_count(pt1);
+        table->page = page;
+        table->addr = addr;
+        return 0;
+
+err:
+        while (i--)
+                pt1_cleanup_buffer(pt1, &table->bufs[i]);
+
+        pt1_free_page(pt1, page, addr);
+        return ret;
+}
+
+static void pt1_cleanup_tables(struct pt1 *pt1)
+{
+        struct pt1_table *tables;
+        int i;
+
+        tables = pt1->tables;
+        pt1_unregister_tables(pt1);
+
+        for (i = 0; i < pt1_nr_tables; i++)
+                pt1_cleanup_table(pt1, &tables[i]);
+
+        vfree(tables);
+}
+
+static int pt1_init_tables(struct pt1 *pt1)
+{
+        struct pt1_table *tables;
+        int i, ret;
+        u32 first_pfn, pfn;
+
+        tables = vmalloc(sizeof(struct pt1_table) * pt1_nr_tables);
+        if (tables == NULL)
+                return -ENOMEM;
+
+        pt1_init_table_count(pt1);
+
+        i = 0;
+        if (pt1_nr_tables) {
+                ret = pt1_init_table(pt1, &tables[0], &first_pfn);
+                if (ret)
+                        goto err;
+                i++;
+        }
+
+        while (i < pt1_nr_tables) {
+                ret = pt1_init_table(pt1, &tables[i], &pfn);
+                if (ret)
+                        goto err;
+                tables[i - 1].page->next_pfn = cpu_to_le32(pfn);
+                i++;
+        }
+
+        tables[pt1_nr_tables - 1].page->next_pfn = cpu_to_le32(first_pfn);
+
+        pt1_register_tables(pt1, first_pfn);
+        pt1->tables = tables;
+        return 0;
+
+err:
+        while (i--)
+                pt1_cleanup_table(pt1, &tables[i]);
+
+        vfree(tables);
+        return ret;
+}
+
+static int pt1_start_feed(struct dvb_demux_feed *feed)
+{
+        struct pt1_adapter *adap;
+        adap = container_of(feed->demux, struct pt1_adapter, demux);
+        if (!adap->users++)
+                pt1_set_stream(adap->pt1, adap->index, 1);
+        return 0;
+}
+
+static int pt1_stop_feed(struct dvb_demux_feed *feed)
+{
+        struct pt1_adapter *adap;
+        adap = container_of(feed->demux, struct pt1_adapter, demux);
+        if (!--adap->users)
+                pt1_set_stream(adap->pt1, adap->index, 0);
+        return 0;
+}
+
+static void
+pt1_set_power(struct pt1 *pt1, int power, int lnb, int reset)
+{
+        pt1_write_reg(pt1, 1, power | lnb << 1 | !reset << 3);
+}
+
+static int pt1_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
+{
+        struct pt1_adapter *adap;
+        int lnb;
+
+        adap = container_of(fe->dvb, struct pt1_adapter, adap);
+
+        switch (voltage) {
+        case SEC_VOLTAGE_13: /* actually 11V */
+                lnb = 2;
+                break;
+        case SEC_VOLTAGE_18: /* actually 15V */
+                lnb = 3;
+                break;
+        case SEC_VOLTAGE_OFF:
+                lnb = 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        pt1_set_power(adap->pt1, 1, lnb, 0);
+
+        if (adap->orig_set_voltage)
+                return adap->orig_set_voltage(fe, voltage);
+        else
+                return 0;
+}
+
+static void pt1_free_adapter(struct pt1_adapter *adap)
+{
+        dvb_unregister_frontend(adap->fe);
+        dvb_net_release(&adap->net);
+        adap->demux.dmx.close(&adap->demux.dmx);
+        dvb_dmxdev_release(&adap->dmxdev);
+        dvb_dmx_release(&adap->demux);
+        dvb_unregister_adapter(&adap->adap);
+        free_page((unsigned long)adap->buf);
+        kfree(adap);
+}
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+static struct pt1_adapter *
+pt1_alloc_adapter(struct pt1 *pt1, struct dvb_frontend *fe)
+{
+        struct pt1_adapter *adap;
+        void *buf;
+        struct dvb_adapter *dvb_adap;
+        struct dvb_demux *demux;
+        struct dmxdev *dmxdev;
+        int ret;
+
+        adap = kzalloc(sizeof(struct pt1_adapter), GFP_KERNEL);
+        if (!adap) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        adap->pt1 = pt1;
+
+        adap->orig_set_voltage = fe->ops.set_voltage;
+        fe->ops.set_voltage = pt1_set_voltage;
+
+        buf = (u8 *)__get_free_page(GFP_KERNEL);
+        if (!buf) {
+                ret = -ENOMEM;
+                goto err_kfree;
+        }
+
+        adap->buf = buf;
+        adap->upacket_count = 0;
+        adap->packet_count = 0;
+
+        dvb_adap = &adap->adap;
+        dvb_adap->priv = adap;
+        ret = dvb_register_adapter(dvb_adap, DRIVER_NAME, THIS_MODULE,
+                                   &pt1->pdev->dev, adapter_nr);
+        if (ret < 0)
+                goto err_free_page;
+
+        demux = &adap->demux;
+        demux->dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
+        demux->priv = adap;
+        demux->feednum = 256;
+        demux->filternum = 256;
+        demux->start_feed = pt1_start_feed;
+        demux->stop_feed = pt1_stop_feed;
+        demux->write_to_decoder = NULL;
+        ret = dvb_dmx_init(demux);
+        if (ret < 0)
+                goto err_unregister_adapter;
+
+        dmxdev = &adap->dmxdev;
+        dmxdev->filternum = 256;
+        dmxdev->demux = &demux->dmx;
+        dmxdev->capabilities = 0;
+        ret = dvb_dmxdev_init(dmxdev, dvb_adap);
+        if (ret < 0)
+                goto err_dmx_release;
+
+        dvb_net_init(dvb_adap, &adap->net, &demux->dmx);
+
+        ret = dvb_register_frontend(dvb_adap, fe);
+        if (ret < 0)
+                goto err_net_release;
+        adap->fe = fe;
+
+        return adap;
+
+err_net_release:
+        dvb_net_release(&adap->net);
+        adap->demux.dmx.close(&adap->demux.dmx);
+        dvb_dmxdev_release(&adap->dmxdev);
+err_dmx_release:
+        dvb_dmx_release(demux);
+err_unregister_adapter:
+        dvb_unregister_adapter(dvb_adap);
+err_free_page:
+        free_page((unsigned long)buf);
+err_kfree:
+        kfree(adap);
+err:
+        return ERR_PTR(ret);
+}
+
+static void pt1_cleanup_adapters(struct pt1 *pt1)
+{
+        int i;
+        for (i = 0; i < PT1_NR_ADAPS; i++)
+                pt1_free_adapter(pt1->adaps[i]);
+}
+
+struct pt1_config {
+        struct va1j5jf8007s_config va1j5jf8007s_config;
+        struct va1j5jf8007t_config va1j5jf8007t_config;
+};
+
+static const struct pt1_config pt1_configs[2] = {
+        {
+                { .demod_address = 0x1b },
+                { .demod_address = 0x1a },
+        }, {
+                { .demod_address = 0x19 },
+                { .demod_address = 0x18 },
+        },
+};
+
+static int pt1_init_adapters(struct pt1 *pt1)
+{
+        int i, j;
+        struct i2c_adapter *i2c_adap;
+        const struct pt1_config *config;
+        struct dvb_frontend *fe[4];
+        struct pt1_adapter *adap;
+        int ret;
+
+        i = 0;
+        j = 0;
+
+        i2c_adap = &pt1->i2c_adap;
+        do {
+                config = &pt1_configs[i / 2];
+
+                fe[i] = va1j5jf8007s_attach(&config->va1j5jf8007s_config,
+                                            i2c_adap);
+                if (!fe[i]) {
+                        ret = -ENODEV; /* This does not sound nice... */
+                        goto err;
+                }
+                i++;
+
+                fe[i] = va1j5jf8007t_attach(&config->va1j5jf8007t_config,
+                                            i2c_adap);
+                if (!fe[i]) {
+                        ret = -ENODEV;
+                        goto err;
+                }
+                i++;
+
+                ret = va1j5jf8007s_prepare(fe[i - 2]);
+                if (ret < 0)
+                        goto err;
+
+                ret = va1j5jf8007t_prepare(fe[i - 1]);
+                if (ret < 0)
+                        goto err;
+
+        } while (i < 4);
+
+        do {
+                adap = pt1_alloc_adapter(pt1, fe[j]);
+                if (IS_ERR(adap))
+                        goto err;
+                adap->index = j;
+                pt1->adaps[j] = adap;
+        } while (++j < 4);
+
+        return 0;
+
+err:
+        while (i-- > j)
+                fe[i]->ops.release(fe[i]);
+
+        while (j--)
+                pt1_free_adapter(pt1->adaps[j]);
+
+        return ret;
+}
+
+static void pt1_i2c_emit(struct pt1 *pt1, int addr, int busy, int read_enable,
+                         int clock, int data, int next_addr)
+{
+        pt1_write_reg(pt1, 4, addr << 18 | busy << 13 | read_enable << 12 |
+                      !clock << 11 | !data << 10 | next_addr);
+}
+
+static void pt1_i2c_write_bit(struct pt1 *pt1, int addr, int *addrp, int data)
+{
+        pt1_i2c_emit(pt1, addr,     1, 0, 0, data, addr + 1);
+        pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, data, addr + 2);
+        pt1_i2c_emit(pt1, addr + 2, 1, 0, 0, data, addr + 3);
+        *addrp = addr + 3;
+}
+
+static void pt1_i2c_read_bit(struct pt1 *pt1, int addr, int *addrp)
+{
+        pt1_i2c_emit(pt1, addr,     1, 0, 0, 1, addr + 1);
+        pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 1, addr + 2);
+        pt1_i2c_emit(pt1, addr + 2, 1, 1, 1, 1, addr + 3);
+        pt1_i2c_emit(pt1, addr + 3, 1, 0, 0, 1, addr + 4);
+        *addrp = addr + 4;
+}
+
+static void pt1_i2c_write_byte(struct pt1 *pt1, int addr, int *addrp, int data)
+{
+        int i;
+        for (i = 0; i < 8; i++)
+                pt1_i2c_write_bit(pt1, addr, &addr, data >> (7 - i) & 1);
+        pt1_i2c_write_bit(pt1, addr, &addr, 1);
+        *addrp = addr;
+}
+
+static void pt1_i2c_read_byte(struct pt1 *pt1, int addr, int *addrp, int last)
+{
+        int i;
+        for (i = 0; i < 8; i++)
+                pt1_i2c_read_bit(pt1, addr, &addr);
+        pt1_i2c_write_bit(pt1, addr, &addr, last);
+        *addrp = addr;
+}
+
+static void pt1_i2c_prepare(struct pt1 *pt1, int addr, int *addrp)
+{
+        pt1_i2c_emit(pt1, addr,     1, 0, 1, 1, addr + 1);
+        pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
+        pt1_i2c_emit(pt1, addr + 2, 1, 0, 0, 0, addr + 3);
+        *addrp = addr + 3;
+}
+
+static void
+pt1_i2c_write_msg(struct pt1 *pt1, int addr, int *addrp, struct i2c_msg *msg)
+{
+        int i;
+        pt1_i2c_prepare(pt1, addr, &addr);
+        pt1_i2c_write_byte(pt1, addr, &addr, msg->addr << 1);
+        for (i = 0; i < msg->len; i++)
+                pt1_i2c_write_byte(pt1, addr, &addr, msg->buf[i]);
+        *addrp = addr;
+}
+
+static void
+pt1_i2c_read_msg(struct pt1 *pt1, int addr, int *addrp, struct i2c_msg *msg)
+{
+        int i;
+        pt1_i2c_prepare(pt1, addr, &addr);
+        pt1_i2c_write_byte(pt1, addr, &addr, msg->addr << 1 | 1);
+        for (i = 0; i < msg->len; i++)
+                pt1_i2c_read_byte(pt1, addr, &addr, i == msg->len - 1);
+        *addrp = addr;
+}
+
+static int pt1_i2c_end(struct pt1 *pt1, int addr)
+{
+        pt1_i2c_emit(pt1, addr,     1, 0, 0, 0, addr + 1);
+        pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
+        pt1_i2c_emit(pt1, addr + 2, 1, 0, 1, 1, 0);
+
+        pt1_write_reg(pt1, 0, 0x00000004);
+        do {
+                if (signal_pending(current))
+                        return -EINTR;
+                schedule_timeout_interruptible((HZ + 999) / 1000);
+        } while (pt1_read_reg(pt1, 0) & 0x00000080);
+        return 0;
+}
+
+static void pt1_i2c_begin(struct pt1 *pt1, int *addrp)
+{
+        int addr;
+        addr = 0;
+
+        pt1_i2c_emit(pt1, addr,     0, 0, 1, 1, addr /* itself */);
+        addr = addr + 1;
+
+        if (!pt1->i2c_running) {
+                pt1_i2c_emit(pt1, addr,     1, 0, 1, 1, addr + 1);
+                pt1_i2c_emit(pt1, addr + 1, 1, 0, 1, 0, addr + 2);
+                addr = addr + 2;
+                pt1->i2c_running = 1;
+        }
+        *addrp = addr;
+}
+
+static int pt1_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
+{
+        struct pt1 *pt1;
+        int i;
+        struct i2c_msg *msg, *next_msg;
+        int addr, ret;
+        u16 len;
+        u32 word;
+
+        pt1 = i2c_get_adapdata(adap);
+
+        for (i = 0; i < num; i++) {
+                msg = &msgs[i];
+                if (msg->flags & I2C_M_RD)
+                        return -ENOTSUPP;
+
+                if (i + 1 < num)
+                        next_msg = &msgs[i + 1];
+                else
+                        next_msg = NULL;
+
+                if (next_msg && next_msg->flags & I2C_M_RD) {
+                        i++;
+
+                        len = next_msg->len;
+                        if (len > 4)
+                                return -ENOTSUPP;
+
+                        pt1_i2c_begin(pt1, &addr);
+                        pt1_i2c_write_msg(pt1, addr, &addr, msg);
+                        pt1_i2c_read_msg(pt1, addr, &addr, next_msg);
+                        ret = pt1_i2c_end(pt1, addr);
+                        if (ret < 0)
+                                return ret;
+
+                        word = pt1_read_reg(pt1, 2);
+                        while (len--) {
+                                next_msg->buf[len] = word;
+                                word >>= 8;
+                        }
+                } else {
+                        pt1_i2c_begin(pt1, &addr);
+                        pt1_i2c_write_msg(pt1, addr, &addr, msg);
+                        ret = pt1_i2c_end(pt1, addr);
+                        if (ret < 0)
+                                return ret;
+                }
+        }
+
+        return num;
+}
+
+static u32 pt1_i2c_func(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C;
+}
+
+static const struct i2c_algorithm pt1_i2c_algo = {
+        .master_xfer = pt1_i2c_xfer,
+        .functionality = pt1_i2c_func,
+};
+
+static void pt1_i2c_wait(struct pt1 *pt1)
+{
+        int i;
+        for (i = 0; i < 128; i++)
+                pt1_i2c_emit(pt1, 0, 0, 0, 1, 1, 0);
+}
+
+static void pt1_i2c_init(struct pt1 *pt1)
+{
+        int i;
+        for (i = 0; i < 1024; i++)
+                pt1_i2c_emit(pt1, i, 0, 0, 1, 1, 0);
+}
+
+static void __devexit pt1_remove(struct pci_dev *pdev)
+{
+        struct pt1 *pt1;
+        void __iomem *regs;
+
+        pt1 = pci_get_drvdata(pdev);
+        regs = pt1->regs;
+
+        kthread_stop(pt1->kthread);
+        pt1_cleanup_tables(pt1);
+        pt1_cleanup_adapters(pt1);
+        pt1_disable_ram(pt1);
+        pt1_set_power(pt1, 0, 0, 1);
+        i2c_del_adapter(&pt1->i2c_adap);
+        pci_set_drvdata(pdev, NULL);
+        kfree(pt1);
+        pci_iounmap(pdev, regs);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+}
+
+static int __devinit
+pt1_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+        int ret;
+        void __iomem *regs;
+        struct pt1 *pt1;
+        struct i2c_adapter *i2c_adap;
+        struct task_struct *kthread;
+
+        ret = pci_enable_device(pdev);
+        if (ret < 0)
+                goto err;
+
+        ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+        if (ret < 0)
+                goto err_pci_disable_device;
+
+        pci_set_master(pdev);
+
+        ret = pci_request_regions(pdev, DRIVER_NAME);
+        if (ret < 0)
+                goto err_pci_disable_device;
+
+        regs = pci_iomap(pdev, 0, 0);
+        if (!regs) {
+                ret = -EIO;
+                goto err_pci_release_regions;
+        }
+
+        pt1 = kzalloc(sizeof(struct pt1), GFP_KERNEL);
+        if (!pt1) {
+                ret = -ENOMEM;
+                goto err_pci_iounmap;
+        }
+
+        pt1->pdev = pdev;
+        pt1->regs = regs;
+        pci_set_drvdata(pdev, pt1);
+
+        i2c_adap = &pt1->i2c_adap;
+        i2c_adap->class = I2C_CLASS_TV_DIGITAL;
+        i2c_adap->algo = &pt1_i2c_algo;
+        i2c_adap->algo_data = NULL;
+        i2c_adap->dev.parent = &pdev->dev;
+        i2c_set_adapdata(i2c_adap, pt1);
+        ret = i2c_add_adapter(i2c_adap);
+        if (ret < 0)
+                goto err_kfree;
+
+        pt1_set_power(pt1, 0, 0, 1);
+
+        pt1_i2c_init(pt1);
+        pt1_i2c_wait(pt1);
+
+        ret = pt1_sync(pt1);
+        if (ret < 0)
+                goto err_i2c_del_adapter;
+
+        pt1_identify(pt1);
+
+        ret = pt1_unlock(pt1);
+        if (ret < 0)
+                goto err_i2c_del_adapter;
+
+        ret = pt1_reset_pci(pt1);
+        if (ret < 0)
+                goto err_i2c_del_adapter;
+
+        ret = pt1_reset_ram(pt1);
+        if (ret < 0)
+                goto err_i2c_del_adapter;
+
+        ret = pt1_enable_ram(pt1);
+        if (ret < 0)
+                goto err_i2c_del_adapter;
+
+        pt1_init_streams(pt1);
+
+        pt1_set_power(pt1, 1, 0, 1);
+        schedule_timeout_uninterruptible((HZ + 49) / 50);
+
+        pt1_set_power(pt1, 1, 0, 0);
+        schedule_timeout_uninterruptible((HZ + 999) / 1000);
+
+        ret = pt1_init_adapters(pt1);
+        if (ret < 0)
+                goto err_pt1_disable_ram;
+
+        ret = pt1_init_tables(pt1);
+        if (ret < 0)
+                goto err_pt1_cleanup_adapters;
+
+        kthread = kthread_run(pt1_thread, pt1, "pt1");
+        if (IS_ERR(kthread)) {
+                ret = PTR_ERR(kthread);
+                goto err_pt1_cleanup_tables;
+        }
+
+        pt1->kthread = kthread;
+        return 0;
+
+err_pt1_cleanup_tables:
+        pt1_cleanup_tables(pt1);
+err_pt1_cleanup_adapters:
+        pt1_cleanup_adapters(pt1);
+err_pt1_disable_ram:
+        pt1_disable_ram(pt1);
+        pt1_set_power(pt1, 0, 0, 1);
+err_i2c_del_adapter:
+        i2c_del_adapter(i2c_adap);
+err_kfree:
+        pci_set_drvdata(pdev, NULL);
+        kfree(pt1);
+err_pci_iounmap:
+        pci_iounmap(pdev, regs);
+err_pci_release_regions:
+        pci_release_regions(pdev);
+err_pci_disable_device:
+        pci_disable_device(pdev);
+err:
+        return ret;
+
+}
+
+static struct pci_device_id pt1_id_table[] = {
+        { PCI_DEVICE(0x10ee, 0x211a) },
+        { },
+};
+MODULE_DEVICE_TABLE(pci, pt1_id_table);
+
+static struct pci_driver pt1_driver = {
+        .name           = DRIVER_NAME,
+        .probe          = pt1_probe,
+        .remove         = __devexit_p(pt1_remove),
+        .id_table       = pt1_id_table,
+};
+
+
+static int __init pt1_init(void)
+{
+        return pci_register_driver(&pt1_driver);
+}
+
+
+static void __exit pt1_cleanup(void)
+{
+        pci_unregister_driver(&pt1_driver);
+}
+
+module_init(pt1_init);
+module_exit(pt1_cleanup);
+
+MODULE_AUTHOR("Takahito HIRANO <hiranotaka@zng.info>");
+MODULE_DESCRIPTION("Earthsoft PT1 Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/pt1/va1j5jf8007s.c b/drivers/media/dvb/pt1/va1j5jf8007s.c
new file mode 100644
index 000000000000..2db940f8635f
--- /dev/null
+++ b/drivers/media/dvb/pt1/va1j5jf8007s.c
@@ -0,0 +1,658 @@
+/*
+ * ISDB-S driver for VA1J5JF8007
+ *
+ * Copyright (C) 2009 HIRANO Takahito <hiranotaka@zng.info>
+ *
+ * based on pt1dvr - http://pt1dvr.sourceforge.jp/
+ *      by Tomoaki Ishikawa <tomy@users.sourceforge.jp>
+ *
+ * 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>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include "dvb_frontend.h"
+#include "va1j5jf8007s.h"
+
+enum va1j5jf8007s_tune_state {
+        VA1J5JF8007S_IDLE,
+        VA1J5JF8007S_SET_FREQUENCY_1,
+        VA1J5JF8007S_SET_FREQUENCY_2,
+        VA1J5JF8007S_SET_FREQUENCY_3,
+        VA1J5JF8007S_CHECK_FREQUENCY,
+        VA1J5JF8007S_SET_MODULATION,
+        VA1J5JF8007S_CHECK_MODULATION,
+        VA1J5JF8007S_SET_TS_ID,
+        VA1J5JF8007S_CHECK_TS_ID,
+        VA1J5JF8007S_TRACK,
+};
+
+struct va1j5jf8007s_state {
+        const struct va1j5jf8007s_config *config;
+        struct i2c_adapter *adap;
+        struct dvb_frontend fe;
+        enum va1j5jf8007s_tune_state tune_state;
+};
+
+static int va1j5jf8007s_get_frontend_algo(struct dvb_frontend *fe)
+{
+        return DVBFE_ALGO_HW;
+}
+
+static int
+va1j5jf8007s_read_status(struct dvb_frontend *fe, fe_status_t *status)
+{
+        struct va1j5jf8007s_state *state;
+
+        state = fe->demodulator_priv;
+
+        switch (state->tune_state) {
+        case VA1J5JF8007S_IDLE:
+        case VA1J5JF8007S_SET_FREQUENCY_1:
+        case VA1J5JF8007S_SET_FREQUENCY_2:
+        case VA1J5JF8007S_SET_FREQUENCY_3:
+        case VA1J5JF8007S_CHECK_FREQUENCY:
+                *status = 0;
+                return 0;
+
+
+        case VA1J5JF8007S_SET_MODULATION:
+        case VA1J5JF8007S_CHECK_MODULATION:
+                *status |= FE_HAS_SIGNAL;
+                return 0;
+
+        case VA1J5JF8007S_SET_TS_ID:
+        case VA1J5JF8007S_CHECK_TS_ID:
+                *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER;
+                return 0;
+
+        case VA1J5JF8007S_TRACK:
+                *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_LOCK;
+                return 0;
+        }
+
+        BUG();
+}
+
+struct va1j5jf8007s_cb_map {
+        u32 frequency;
+        u8 cb;
+};
+
+static const struct va1j5jf8007s_cb_map va1j5jf8007s_cb_maps[] = {
+        {  986000, 0xb2 },
+        { 1072000, 0xd2 },
+        { 1154000, 0xe2 },
+        { 1291000, 0x20 },
+        { 1447000, 0x40 },
+        { 1615000, 0x60 },
+        { 1791000, 0x80 },
+        { 1972000, 0xa0 },
+};
+
+static u8 va1j5jf8007s_lookup_cb(u32 frequency)
+{
+        int i;
+        const struct va1j5jf8007s_cb_map *map;
+
+        for (i = 0; i < ARRAY_SIZE(va1j5jf8007s_cb_maps); i++) {
+                map = &va1j5jf8007s_cb_maps[i];
+                if (frequency < map->frequency)
+                        return map->cb;
+        }
+        return 0xc0;
+}
+
+static int va1j5jf8007s_set_frequency_1(struct va1j5jf8007s_state *state)
+{
+        u32 frequency;
+        u16 word;
+        u8 buf[6];
+        struct i2c_msg msg;
+
+        frequency = state->fe.dtv_property_cache.frequency;
+
+        word = (frequency + 500) / 1000;
+        if (frequency < 1072000)
+                word = (word << 1 & ~0x1f) | (word & 0x0f);
+
+        buf[0] = 0xfe;
+        buf[1] = 0xc0;
+        buf[2] = 0x40 | word >> 8;
+        buf[3] = word;
+        buf[4] = 0xe0;
+        buf[5] = va1j5jf8007s_lookup_cb(frequency);
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int va1j5jf8007s_set_frequency_2(struct va1j5jf8007s_state *state)
+{
+        u8 buf[3];
+        struct i2c_msg msg;
+
+        buf[0] = 0xfe;
+        buf[1] = 0xc0;
+        buf[2] = 0xe4;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int va1j5jf8007s_set_frequency_3(struct va1j5jf8007s_state *state)
+{
+        u32 frequency;
+        u8 buf[4];
+        struct i2c_msg msg;
+
+        frequency = state->fe.dtv_property_cache.frequency;
+
+        buf[0] = 0xfe;
+        buf[1] = 0xc0;
+        buf[2] = 0xf4;
+        buf[3] = va1j5jf8007s_lookup_cb(frequency) | 0x4;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int
+va1j5jf8007s_check_frequency(struct va1j5jf8007s_state *state, int *lock)
+{
+        u8 addr;
+        u8 write_buf[2], read_buf[1];
+        struct i2c_msg msgs[2];
+
+        addr = state->config->demod_address;
+
+        write_buf[0] = 0xfe;
+        write_buf[1] = 0xc1;
+
+        msgs[0].addr = addr;
+        msgs[0].flags = 0;
+        msgs[0].len = sizeof(write_buf);
+        msgs[0].buf = write_buf;
+
+        msgs[1].addr = addr;
+        msgs[1].flags = I2C_M_RD;
+        msgs[1].len = sizeof(read_buf);
+        msgs[1].buf = read_buf;
+
+        if (i2c_transfer(state->adap, msgs, 2) != 2)
+                return -EREMOTEIO;
+
+        *lock = read_buf[0] & 0x40;
+        return 0;
+}
+
+static int va1j5jf8007s_set_modulation(struct va1j5jf8007s_state *state)
+{
+        u8 buf[2];
+        struct i2c_msg msg;
+
+        buf[0] = 0x03;
+        buf[1] = 0x01;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int
+va1j5jf8007s_check_modulation(struct va1j5jf8007s_state *state, int *lock)
+{
+        u8 addr;
+        u8 write_buf[1], read_buf[1];
+        struct i2c_msg msgs[2];
+
+        addr = state->config->demod_address;
+
+        write_buf[0] = 0xc3;
+
+        msgs[0].addr = addr;
+        msgs[0].flags = 0;
+        msgs[0].len = sizeof(write_buf);
+        msgs[0].buf = write_buf;
+
+        msgs[1].addr = addr;
+        msgs[1].flags = I2C_M_RD;
+        msgs[1].len = sizeof(read_buf);
+        msgs[1].buf = read_buf;
+
+        if (i2c_transfer(state->adap, msgs, 2) != 2)
+                return -EREMOTEIO;
+
+        *lock = !(read_buf[0] & 0x10);
+        return 0;
+}
+
+static int
+va1j5jf8007s_set_ts_id(struct va1j5jf8007s_state *state)
+{
+        u32 ts_id;
+        u8 buf[3];
+        struct i2c_msg msg;
+
+        ts_id = state->fe.dtv_property_cache.isdbs_ts_id;
+        if (!ts_id)
+                return 0;
+
+        buf[0] = 0x8f;
+        buf[1] = ts_id >> 8;
+        buf[2] = ts_id;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int
+va1j5jf8007s_check_ts_id(struct va1j5jf8007s_state *state, int *lock)
+{
+        u8 addr;
+        u8 write_buf[1], read_buf[2];
+        struct i2c_msg msgs[2];
+        u32 ts_id;
+
+        ts_id = state->fe.dtv_property_cache.isdbs_ts_id;
+        if (!ts_id) {
+                *lock = 1;
+                return 0;
+        }
+
+        addr = state->config->demod_address;
+
+        write_buf[0] = 0xe6;
+
+        msgs[0].addr = addr;
+        msgs[0].flags = 0;
+        msgs[0].len = sizeof(write_buf);
+        msgs[0].buf = write_buf;
+
+        msgs[1].addr = addr;
+        msgs[1].flags = I2C_M_RD;
+        msgs[1].len = sizeof(read_buf);
+        msgs[1].buf = read_buf;
+
+        if (i2c_transfer(state->adap, msgs, 2) != 2)
+                return -EREMOTEIO;
+
+        *lock = (read_buf[0] << 8 | read_buf[1]) == ts_id;
+        return 0;
+}
+
+static int
+va1j5jf8007s_tune(struct dvb_frontend *fe,
+                  struct dvb_frontend_parameters *params,
+                  unsigned int mode_flags,  unsigned int *delay,
+                  fe_status_t *status)
+{
+        struct va1j5jf8007s_state *state;
+        int ret;
+        int lock;
+
+        state = fe->demodulator_priv;
+
+        if (params != NULL)
+                state->tune_state = VA1J5JF8007S_SET_FREQUENCY_1;
+
+        switch (state->tune_state) {
+        case VA1J5JF8007S_IDLE:
+                *delay = 3 * HZ;
+                *status = 0;
+                return 0;
+
+        case VA1J5JF8007S_SET_FREQUENCY_1:
+                ret = va1j5jf8007s_set_frequency_1(state);
+                if (ret < 0)
+                        return ret;
+
+                state->tune_state = VA1J5JF8007S_SET_FREQUENCY_2;
+                *delay = 0;
+                *status = 0;
+                return 0;
+
+        case VA1J5JF8007S_SET_FREQUENCY_2:
+                ret = va1j5jf8007s_set_frequency_2(state);
+                if (ret < 0)
+                        return ret;
+
+                state->tune_state = VA1J5JF8007S_SET_FREQUENCY_3;
+                *delay = (HZ + 99) / 100;
+                *status = 0;
+                return 0;
+
+        case VA1J5JF8007S_SET_FREQUENCY_3:
+                ret = va1j5jf8007s_set_frequency_3(state);
+                if (ret < 0)
+                        return ret;
+
+                state->tune_state = VA1J5JF8007S_CHECK_FREQUENCY;
+                *delay = 0;
+                *status = 0;
+                return 0;
+
+        case VA1J5JF8007S_CHECK_FREQUENCY:
+                ret = va1j5jf8007s_check_frequency(state, &lock);
+                if (ret < 0)
+                        return ret;
+
+                if (!lock)  {
+                        *delay = (HZ + 999) / 1000;
+                        *status = 0;
+                        return 0;
+                }
+
+                state->tune_state = VA1J5JF8007S_SET_MODULATION;
+                *delay = 0;
+                *status = FE_HAS_SIGNAL;
+                return 0;
+
+        case VA1J5JF8007S_SET_MODULATION:
+                ret = va1j5jf8007s_set_modulation(state);
+                if (ret < 0)
+                        return ret;
+
+                state->tune_state = VA1J5JF8007S_CHECK_MODULATION;
+                *delay = 0;
+                *status = FE_HAS_SIGNAL;
+                return 0;
+
+        case VA1J5JF8007S_CHECK_MODULATION:
+                ret = va1j5jf8007s_check_modulation(state, &lock);
+                if (ret < 0)
+                        return ret;
+
+                if (!lock)  {
+                        *delay = (HZ + 49) / 50;
+                        *status = FE_HAS_SIGNAL;
+                        return 0;
+                }
+
+                state->tune_state = VA1J5JF8007S_SET_TS_ID;
+                *delay = 0;
+                *status = FE_HAS_SIGNAL | FE_HAS_CARRIER;
+                return 0;
+
+        case VA1J5JF8007S_SET_TS_ID:
+                ret = va1j5jf8007s_set_ts_id(state);
+                if (ret < 0)
+                        return ret;
+
+                state->tune_state = VA1J5JF8007S_CHECK_TS_ID;
+                return 0;
+
+        case VA1J5JF8007S_CHECK_TS_ID:
+                ret = va1j5jf8007s_check_ts_id(state, &lock);
+                if (ret < 0)
+                        return ret;
+
+                if (!lock)  {
+                        *delay = (HZ + 99) / 100;
+                        *status = FE_HAS_SIGNAL | FE_HAS_CARRIER;
+                        return 0;
+                }
+
+                state->tune_state = VA1J5JF8007S_TRACK;
+                /* fall through */
+
+        case VA1J5JF8007S_TRACK:
+                *delay = 3 * HZ;
+                *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_LOCK;
+                return 0;
+        }
+
+        BUG();
+}
+
+static int va1j5jf8007s_init_frequency(struct va1j5jf8007s_state *state)
+{
+        u8 buf[4];
+        struct i2c_msg msg;
+
+        buf[0] = 0xfe;
+        buf[1] = 0xc0;
+        buf[2] = 0xf0;
+        buf[3] = 0x04;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int va1j5jf8007s_set_sleep(struct va1j5jf8007s_state *state, int sleep)
+{
+        u8 buf[2];
+        struct i2c_msg msg;
+
+        buf[0] = 0x17;
+        buf[1] = sleep ? 0x01 : 0x00;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int va1j5jf8007s_sleep(struct dvb_frontend *fe)
+{
+        struct va1j5jf8007s_state *state;
+        int ret;
+
+        state = fe->demodulator_priv;
+
+        ret = va1j5jf8007s_init_frequency(state);
+        if (ret < 0)
+                return ret;
+
+        return va1j5jf8007s_set_sleep(state, 1);
+}
+
+static int va1j5jf8007s_init(struct dvb_frontend *fe)
+{
+        struct va1j5jf8007s_state *state;
+
+        state = fe->demodulator_priv;
+        state->tune_state = VA1J5JF8007S_IDLE;
+
+        return va1j5jf8007s_set_sleep(state, 0);
+}
+
+static void va1j5jf8007s_release(struct dvb_frontend *fe)
+{
+        struct va1j5jf8007s_state *state;
+        state = fe->demodulator_priv;
+        kfree(state);
+}
+
+static struct dvb_frontend_ops va1j5jf8007s_ops = {
+        .info = {
+                .name = "VA1J5JF8007 ISDB-S",
+                .type = FE_QPSK,
+                .frequency_min = 950000,
+                .frequency_max = 2150000,
+                .frequency_stepsize = 1000,
+                .caps = FE_CAN_INVERSION_AUTO | FE_CAN_FEC_AUTO |
+                        FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO |
+                        FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_HIERARCHY_AUTO,
+        },
+
+        .get_frontend_algo = va1j5jf8007s_get_frontend_algo,
+        .read_status = va1j5jf8007s_read_status,
+        .tune = va1j5jf8007s_tune,
+        .sleep = va1j5jf8007s_sleep,
+        .init = va1j5jf8007s_init,
+        .release = va1j5jf8007s_release,
+};
+
+static int va1j5jf8007s_prepare_1(struct va1j5jf8007s_state *state)
+{
+        u8 addr;
+        u8 write_buf[1], read_buf[1];
+        struct i2c_msg msgs[2];
+
+        addr = state->config->demod_address;
+
+        write_buf[0] = 0x07;
+
+        msgs[0].addr = addr;
+        msgs[0].flags = 0;
+        msgs[0].len = sizeof(write_buf);
+        msgs[0].buf = write_buf;
+
+        msgs[1].addr = addr;
+        msgs[1].flags = I2C_M_RD;
+        msgs[1].len = sizeof(read_buf);
+        msgs[1].buf = read_buf;
+
+        if (i2c_transfer(state->adap, msgs, 2) != 2)
+                return -EREMOTEIO;
+
+        if (read_buf[0] != 0x41)
+                return -EIO;
+
+        return 0;
+}
+
+static const u8 va1j5jf8007s_prepare_bufs[][2] = {
+        {0x04, 0x02}, {0x0d, 0x55}, {0x11, 0x40}, {0x13, 0x80}, {0x17, 0x01},
+        {0x1c, 0x0a}, {0x1d, 0xaa}, {0x1e, 0x20}, {0x1f, 0x88}, {0x51, 0xb0},
+        {0x52, 0x89}, {0x53, 0xb3}, {0x5a, 0x2d}, {0x5b, 0xd3}, {0x85, 0x69},
+        {0x87, 0x04}, {0x8e, 0x02}, {0xa3, 0xf7}, {0xa5, 0xc0},
+};
+
+static int va1j5jf8007s_prepare_2(struct va1j5jf8007s_state *state)
+{
+        u8 addr;
+        u8 buf[2];
+        struct i2c_msg msg;
+        int i;
+
+        addr = state->config->demod_address;
+
+        msg.addr = addr;
+        msg.flags = 0;
+        msg.len = 2;
+        msg.buf = buf;
+        for (i = 0; i < ARRAY_SIZE(va1j5jf8007s_prepare_bufs); i++) {
+                memcpy(buf, va1j5jf8007s_prepare_bufs[i], sizeof(buf));
+                if (i2c_transfer(state->adap, &msg, 1) != 1)
+                        return -EREMOTEIO;
+        }
+
+        return 0;
+}
+
+/* must be called after va1j5jf8007t_attach */
+int va1j5jf8007s_prepare(struct dvb_frontend *fe)
+{
+        struct va1j5jf8007s_state *state;
+        int ret;
+
+        state = fe->demodulator_priv;
+
+        ret = va1j5jf8007s_prepare_1(state);
+        if (ret < 0)
+                return ret;
+
+        ret = va1j5jf8007s_prepare_2(state);
+        if (ret < 0)
+                return ret;
+
+        return va1j5jf8007s_init_frequency(state);
+}
+
+struct dvb_frontend *
+va1j5jf8007s_attach(const struct va1j5jf8007s_config *config,
+                    struct i2c_adapter *adap)
+{
+        struct va1j5jf8007s_state *state;
+        struct dvb_frontend *fe;
+        u8 buf[2];
+        struct i2c_msg msg;
+
+        state = kzalloc(sizeof(struct va1j5jf8007s_state), GFP_KERNEL);
+        if (!state)
+                return NULL;
+
+        state->config = config;
+        state->adap = adap;
+
+        fe = &state->fe;
+        memcpy(&fe->ops, &va1j5jf8007s_ops, sizeof(struct dvb_frontend_ops));
+        fe->demodulator_priv = state;
+
+        buf[0] = 0x01;
+        buf[1] = 0x80;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1) {
+                kfree(state);
+                return NULL;
+        }
+
+        return fe;
+}
diff --git a/drivers/media/dvb/pt1/va1j5jf8007s.h b/drivers/media/dvb/pt1/va1j5jf8007s.h
new file mode 100644
index 000000000000..aa228a816353
--- /dev/null
+++ b/drivers/media/dvb/pt1/va1j5jf8007s.h
@@ -0,0 +1,40 @@
+/*
+ * ISDB-S driver for VA1J5JF8007
+ *
+ * Copyright (C) 2009 HIRANO Takahito <hiranotaka@zng.info>
+ *
+ * based on pt1dvr - http://pt1dvr.sourceforge.jp/
+ *      by Tomoaki Ishikawa <tomy@users.sourceforge.jp>
+ *
+ * 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 VA1J5JF8007S_H
+#define VA1J5JF8007S_H
+
+struct va1j5jf8007s_config {
+        u8 demod_address;
+};
+
+struct i2c_adapter;
+
+struct dvb_frontend *
+va1j5jf8007s_attach(const struct va1j5jf8007s_config *config,
+                    struct i2c_adapter *adap);
+
+/* must be called after va1j5jf8007t_attach */
+int va1j5jf8007s_prepare(struct dvb_frontend *fe);
+
+#endif
diff --git a/drivers/media/dvb/pt1/va1j5jf8007t.c b/drivers/media/dvb/pt1/va1j5jf8007t.c
new file mode 100644
index 000000000000..71117f4ca7e6
--- /dev/null
+++ b/drivers/media/dvb/pt1/va1j5jf8007t.c
@@ -0,0 +1,468 @@
+/*
+ * ISDB-T driver for VA1J5JF8007
+ *
+ * Copyright (C) 2009 HIRANO Takahito <hiranotaka@zng.info>
+ *
+ * based on pt1dvr - http://pt1dvr.sourceforge.jp/
+ *      by Tomoaki Ishikawa <tomy@users.sourceforge.jp>
+ *
+ * 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>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include "dvb_frontend.h"
+#include "dvb_math.h"
+#include "va1j5jf8007t.h"
+
+enum va1j5jf8007t_tune_state {
+        VA1J5JF8007T_IDLE,
+        VA1J5JF8007T_SET_FREQUENCY,
+        VA1J5JF8007T_CHECK_FREQUENCY,
+        VA1J5JF8007T_SET_MODULATION,
+        VA1J5JF8007T_CHECK_MODULATION,
+        VA1J5JF8007T_TRACK,
+        VA1J5JF8007T_ABORT,
+};
+
+struct va1j5jf8007t_state {
+        const struct va1j5jf8007t_config *config;
+        struct i2c_adapter *adap;
+        struct dvb_frontend fe;
+        enum va1j5jf8007t_tune_state tune_state;
+};
+
+static int va1j5jf8007t_get_frontend_algo(struct dvb_frontend *fe)
+{
+        return DVBFE_ALGO_HW;
+}
+
+static int
+va1j5jf8007t_read_status(struct dvb_frontend *fe, fe_status_t *status)
+{
+        struct va1j5jf8007t_state *state;
+
+        state = fe->demodulator_priv;
+
+        switch (state->tune_state) {
+        case VA1J5JF8007T_IDLE:
+        case VA1J5JF8007T_SET_FREQUENCY:
+        case VA1J5JF8007T_CHECK_FREQUENCY:
+                *status = 0;
+                return 0;
+
+
+        case VA1J5JF8007T_SET_MODULATION:
+        case VA1J5JF8007T_CHECK_MODULATION:
+        case VA1J5JF8007T_ABORT:
+                *status |= FE_HAS_SIGNAL;
+                return 0;
+
+        case VA1J5JF8007T_TRACK:
+                *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_LOCK;
+                return 0;
+        }
+
+        BUG();
+}
+
+struct va1j5jf8007t_cb_map {
+        u32 frequency;
+        u8 cb;
+};
+
+static const struct va1j5jf8007t_cb_map va1j5jf8007t_cb_maps[] = {
+        {  90000000, 0x80 },
+        { 140000000, 0x81 },
+        { 170000000, 0xa1 },
+        { 220000000, 0x62 },
+        { 330000000, 0xa2 },
+        { 402000000, 0xe2 },
+        { 450000000, 0x64 },
+        { 550000000, 0x84 },
+        { 600000000, 0xa4 },
+        { 700000000, 0xc4 },
+};
+
+static u8 va1j5jf8007t_lookup_cb(u32 frequency)
+{
+        int i;
+        const struct va1j5jf8007t_cb_map *map;
+
+        for (i = 0; i < ARRAY_SIZE(va1j5jf8007t_cb_maps); i++) {
+                map = &va1j5jf8007t_cb_maps[i];
+                if (frequency < map->frequency)
+                        return map->cb;
+        }
+        return 0xe4;
+}
+
+static int va1j5jf8007t_set_frequency(struct va1j5jf8007t_state *state)
+{
+        u32 frequency;
+        u16 word;
+        u8 buf[6];
+        struct i2c_msg msg;
+
+        frequency = state->fe.dtv_property_cache.frequency;
+
+        word = (frequency + 71428) / 142857 + 399;
+        buf[0] = 0xfe;
+        buf[1] = 0xc2;
+        buf[2] = word >> 8;
+        buf[3] = word;
+        buf[4] = 0x80;
+        buf[5] = va1j5jf8007t_lookup_cb(frequency);
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int
+va1j5jf8007t_check_frequency(struct va1j5jf8007t_state *state, int *lock)
+{
+        u8 addr;
+        u8 write_buf[2], read_buf[1];
+        struct i2c_msg msgs[2];
+
+        addr = state->config->demod_address;
+
+        write_buf[0] = 0xfe;
+        write_buf[1] = 0xc3;
+
+        msgs[0].addr = addr;
+        msgs[0].flags = 0;
+        msgs[0].len = sizeof(write_buf);
+        msgs[0].buf = write_buf;
+
+        msgs[1].addr = addr;
+        msgs[1].flags = I2C_M_RD;
+        msgs[1].len = sizeof(read_buf);
+        msgs[1].buf = read_buf;
+
+        if (i2c_transfer(state->adap, msgs, 2) != 2)
+                return -EREMOTEIO;
+
+        *lock = read_buf[0] & 0x40;
+        return 0;
+}
+
+static int va1j5jf8007t_set_modulation(struct va1j5jf8007t_state *state)
+{
+        u8 buf[2];
+        struct i2c_msg msg;
+
+        buf[0] = 0x01;
+        buf[1] = 0x40;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int va1j5jf8007t_check_modulation(struct va1j5jf8007t_state *state,
+                                         int *lock, int *retry)
+{
+        u8 addr;
+        u8 write_buf[1], read_buf[1];
+        struct i2c_msg msgs[2];
+
+        addr = state->config->demod_address;
+
+        write_buf[0] = 0x80;
+
+        msgs[0].addr = addr;
+        msgs[0].flags = 0;
+        msgs[0].len = sizeof(write_buf);
+        msgs[0].buf = write_buf;
+
+        msgs[1].addr = addr;
+        msgs[1].flags = I2C_M_RD;
+        msgs[1].len = sizeof(read_buf);
+        msgs[1].buf = read_buf;
+
+        if (i2c_transfer(state->adap, msgs, 2) != 2)
+                return -EREMOTEIO;
+
+        *lock = !(read_buf[0] & 0x10);
+        *retry = read_buf[0] & 0x80;
+        return 0;
+}
+
+static int
+va1j5jf8007t_tune(struct dvb_frontend *fe,
+                  struct dvb_frontend_parameters *params,
+                  unsigned int mode_flags,  unsigned int *delay,
+                  fe_status_t *status)
+{
+        struct va1j5jf8007t_state *state;
+        int ret;
+        int lock, retry;
+
+        state = fe->demodulator_priv;
+
+        if (params != NULL)
+                state->tune_state = VA1J5JF8007T_SET_FREQUENCY;
+
+        switch (state->tune_state) {
+        case VA1J5JF8007T_IDLE:
+                *delay = 3 * HZ;
+                *status = 0;
+                return 0;
+
+        case VA1J5JF8007T_SET_FREQUENCY:
+                ret = va1j5jf8007t_set_frequency(state);
+                if (ret < 0)
+                        return ret;
+
+                state->tune_state = VA1J5JF8007T_CHECK_FREQUENCY;
+                *delay = 0;
+                *status = 0;
+                return 0;
+
+        case VA1J5JF8007T_CHECK_FREQUENCY:
+                ret = va1j5jf8007t_check_frequency(state, &lock);
+                if (ret < 0)
+                        return ret;
+
+                if (!lock)  {
+                        *delay = (HZ + 999) / 1000;
+                        *status = 0;
+                        return 0;
+                }
+
+                state->tune_state = VA1J5JF8007T_SET_MODULATION;
+                *delay = 0;
+                *status = FE_HAS_SIGNAL;
+                return 0;
+
+        case VA1J5JF8007T_SET_MODULATION:
+                ret = va1j5jf8007t_set_modulation(state);
+                if (ret < 0)
+                        return ret;
+
+                state->tune_state = VA1J5JF8007T_CHECK_MODULATION;
+                *delay = 0;
+                *status = FE_HAS_SIGNAL;
+                return 0;
+
+        case VA1J5JF8007T_CHECK_MODULATION:
+                ret = va1j5jf8007t_check_modulation(state, &lock, &retry);
+                if (ret < 0)
+                        return ret;
+
+                if (!lock)  {
+                        if (!retry)  {
+                                state->tune_state = VA1J5JF8007T_ABORT;
+                                *delay = 3 * HZ;
+                                *status = FE_HAS_SIGNAL;
+                                return 0;
+                        }
+                        *delay = (HZ + 999) / 1000;
+                        *status = FE_HAS_SIGNAL;
+                        return 0;
+                }
+
+                state->tune_state = VA1J5JF8007T_TRACK;
+                /* fall through */
+
+        case VA1J5JF8007T_TRACK:
+                *delay = 3 * HZ;
+                *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_LOCK;
+                return 0;
+
+        case VA1J5JF8007T_ABORT:
+                *delay = 3 * HZ;
+                *status = FE_HAS_SIGNAL;
+                return 0;
+        }
+
+        BUG();
+}
+
+static int va1j5jf8007t_init_frequency(struct va1j5jf8007t_state *state)
+{
+        u8 buf[7];
+        struct i2c_msg msg;
+
+        buf[0] = 0xfe;
+        buf[1] = 0xc2;
+        buf[2] = 0x01;
+        buf[3] = 0x8f;
+        buf[4] = 0xc1;
+        buf[5] = 0x80;
+        buf[6] = 0x80;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int va1j5jf8007t_set_sleep(struct va1j5jf8007t_state *state, int sleep)
+{
+        u8 buf[2];
+        struct i2c_msg msg;
+
+        buf[0] = 0x03;
+        buf[1] = sleep ? 0x90 : 0x80;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1)
+                return -EREMOTEIO;
+
+        return 0;
+}
+
+static int va1j5jf8007t_sleep(struct dvb_frontend *fe)
+{
+        struct va1j5jf8007t_state *state;
+        int ret;
+
+        state = fe->demodulator_priv;
+
+        ret = va1j5jf8007t_init_frequency(state);
+        if (ret < 0)
+                return ret;
+
+        return va1j5jf8007t_set_sleep(state, 1);
+}
+
+static int va1j5jf8007t_init(struct dvb_frontend *fe)
+{
+        struct va1j5jf8007t_state *state;
+
+        state = fe->demodulator_priv;
+        state->tune_state = VA1J5JF8007T_IDLE;
+
+        return va1j5jf8007t_set_sleep(state, 0);
+}
+
+static void va1j5jf8007t_release(struct dvb_frontend *fe)
+{
+        struct va1j5jf8007t_state *state;
+        state = fe->demodulator_priv;
+        kfree(state);
+}
+
+static struct dvb_frontend_ops va1j5jf8007t_ops = {
+        .info = {
+                .name = "VA1J5JF8007 ISDB-T",
+                .type = FE_OFDM,
+                .frequency_min = 90000000,
+                .frequency_max = 770000000,
+                .frequency_stepsize = 142857,
+                .caps = FE_CAN_INVERSION_AUTO | FE_CAN_FEC_AUTO |
+                        FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO |
+                        FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_HIERARCHY_AUTO,
+        },
+
+        .get_frontend_algo = va1j5jf8007t_get_frontend_algo,
+        .read_status = va1j5jf8007t_read_status,
+        .tune = va1j5jf8007t_tune,
+        .sleep = va1j5jf8007t_sleep,
+        .init = va1j5jf8007t_init,
+        .release = va1j5jf8007t_release,
+};
+
+static const u8 va1j5jf8007t_prepare_bufs[][2] = {
+        {0x03, 0x90}, {0x14, 0x8f}, {0x1c, 0x2a}, {0x1d, 0xa8}, {0x1e, 0xa2},
+        {0x22, 0x83}, {0x31, 0x0d}, {0x32, 0xe0}, {0x39, 0xd3}, {0x3a, 0x00},
+        {0x5c, 0x40}, {0x5f, 0x80}, {0x75, 0x02}, {0x76, 0x4e}, {0x77, 0x03},
+        {0xef, 0x01}
+};
+
+int va1j5jf8007t_prepare(struct dvb_frontend *fe)
+{
+        struct va1j5jf8007t_state *state;
+        u8 buf[2];
+        struct i2c_msg msg;
+        int i;
+
+        state = fe->demodulator_priv;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        for (i = 0; i < ARRAY_SIZE(va1j5jf8007t_prepare_bufs); i++) {
+                memcpy(buf, va1j5jf8007t_prepare_bufs[i], sizeof(buf));
+                if (i2c_transfer(state->adap, &msg, 1) != 1)
+                        return -EREMOTEIO;
+        }
+
+        return va1j5jf8007t_init_frequency(state);
+}
+
+struct dvb_frontend *
+va1j5jf8007t_attach(const struct va1j5jf8007t_config *config,
+                    struct i2c_adapter *adap)
+{
+        struct va1j5jf8007t_state *state;
+        struct dvb_frontend *fe;
+        u8 buf[2];
+        struct i2c_msg msg;
+
+        state = kzalloc(sizeof(struct va1j5jf8007t_state), GFP_KERNEL);
+        if (!state)
+                return NULL;
+
+        state->config = config;
+        state->adap = adap;
+
+        fe = &state->fe;
+        memcpy(&fe->ops, &va1j5jf8007t_ops, sizeof(struct dvb_frontend_ops));
+        fe->demodulator_priv = state;
+
+        buf[0] = 0x01;
+        buf[1] = 0x80;
+
+        msg.addr = state->config->demod_address;
+        msg.flags = 0;
+        msg.len = sizeof(buf);
+        msg.buf = buf;
+
+        if (i2c_transfer(state->adap, &msg, 1) != 1) {
+                kfree(state);
+                return NULL;
+        }
+
+        return fe;
+}
diff --git a/drivers/media/dvb/pt1/va1j5jf8007t.h b/drivers/media/dvb/pt1/va1j5jf8007t.h
new file mode 100644
index 000000000000..ed49906f7769
--- /dev/null
+++ b/drivers/media/dvb/pt1/va1j5jf8007t.h
@@ -0,0 +1,40 @@
+/*
+ * ISDB-T driver for VA1J5JF8007
+ *
+ * Copyright (C) 2009 HIRANO Takahito <hiranotaka@zng.info>
+ *
+ * based on pt1dvr - http://pt1dvr.sourceforge.jp/
+ *      by Tomoaki Ishikawa <tomy@users.sourceforge.jp>
+ *
+ * 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 VA1J5JF8007T_H
+#define VA1J5JF8007T_H
+
+struct va1j5jf8007t_config {
+        u8 demod_address;
+};
+
+struct i2c_adapter;
+
+struct dvb_frontend *
+va1j5jf8007t_attach(const struct va1j5jf8007t_config *config,
+                    struct i2c_adapter *adap);
+
+/* must be called after va1j5jf8007s_attach */
+int va1j5jf8007t_prepare(struct dvb_frontend *fe);
+
+#endif
diff --git a/drivers/media/radio/Kconfig b/drivers/media/radio/Kconfig
index 25a36ad60c5e..a87a477c87f2 100644
--- a/drivers/media/radio/Kconfig
+++ b/drivers/media/radio/Kconfig
@@ -346,7 +346,7 @@ config RADIO_SI4713
         ---help---
           Say Y here if you want support to Si4713 FM Radio Transmitter.
           This device can transmit audio through FM. It can transmit
-          EDS and EBDS signals as well. This module is the v4l2 radio
+          RDS and RBDS signals as well. This module is the v4l2 radio
           interface for the i2c driver of this device.
 
           To compile this driver as a module, choose M here: the
diff --git a/drivers/media/radio/radio-si4713.c b/drivers/media/radio/radio-si4713.c
index 65c14b704586..170bbe554787 100644
--- a/drivers/media/radio/radio-si4713.c
+++ b/drivers/media/radio/radio-si4713.c
@@ -24,7 +24,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
-#include <linux/version.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
 #include <linux/videodev2.h>
diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index 1d758525d236..e6186b338a12 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -265,6 +265,15 @@ config VIDEO_SAA6588
 
 comment "Video decoders"
 
+config VIDEO_ADV7180
+        tristate "Analog Devices ADV7180 decoder"
+        depends on VIDEO_V4L2 && I2C
+        ---help---
+          Support for the Analog Devices ADV7180 video decoder.
+
+          To compile this driver as a module, choose M here: the
+          module will be called adv7180.
+
 config VIDEO_BT819
         tristate "BT819A VideoStream decoder"
         depends on VIDEO_V4L2 && I2C
@@ -493,6 +502,39 @@ config VIDEO_UPD64083
 
 endmenu # encoder / decoder chips
 
+config DISPLAY_DAVINCI_DM646X_EVM
+        tristate "DM646x EVM Video Display"
+        depends on VIDEO_DEV && MACH_DAVINCI_DM6467_EVM
+        select VIDEOBUF_DMA_CONTIG
+        select VIDEO_DAVINCI_VPIF
+        select VIDEO_ADV7343
+        select VIDEO_THS7303
+        help
+          Support for DM6467 based display device.
+
+          To compile this driver as a module, choose M here: the
+          module will be called vpif_display.
+
+config CAPTURE_DAVINCI_DM646X_EVM
+        tristate "DM646x EVM Video Capture"
+        depends on VIDEO_DEV && MACH_DAVINCI_DM6467_EVM
+        select VIDEOBUF_DMA_CONTIG
+        select VIDEO_DAVINCI_VPIF
+        help
+          Support for DM6467 based capture device.
+
+          To compile this driver as a module, choose M here: the
+          module will be called vpif_capture.
+
+config VIDEO_DAVINCI_VPIF
+        tristate "DaVinci VPIF Driver"
+        depends on DISPLAY_DAVINCI_DM646X_EVM
+        help
+          Support for DaVinci VPIF Driver.
+
+          To compile this driver as a module, choose M here: the
+          module will be called vpif.
+
 config VIDEO_VIVI
         tristate "Virtual Video Driver"
         depends on VIDEO_DEV && VIDEO_V4L2 && !SPARC32 && !SPARC64
@@ -505,6 +547,55 @@ config VIDEO_VIVI
           Say Y here if you want to test video apps or debug V4L devices.
           In doubt, say N.
 
+config VIDEO_VPSS_SYSTEM
+        tristate "VPSS System module driver"
+        depends on ARCH_DAVINCI
+        help
+          Support for vpss system module for video driver
+        default y
+
+config VIDEO_VPFE_CAPTURE
+        tristate "VPFE Video Capture Driver"
+        depends on VIDEO_V4L2 && ARCH_DAVINCI
+        select VIDEOBUF_DMA_CONTIG
+        help
+          Support for DMXXXX VPFE based frame grabber. This is the
+          common V4L2 module for following DMXXX SoCs from Texas
+          Instruments:- DM6446 & DM355.
+
+          To compile this driver as a module, choose M here: the
+          module will be called vpfe-capture.
+
+config VIDEO_DM6446_CCDC
+        tristate "DM6446 CCDC HW module"
+        depends on ARCH_DAVINCI_DM644x && VIDEO_VPFE_CAPTURE
+        select VIDEO_VPSS_SYSTEM
+        default y
+        help
+           Enables DaVinci CCD hw module. DaVinci CCDC hw interfaces
+           with decoder modules such as TVP5146 over BT656 or
+           sensor module such as MT9T001 over a raw interface. This
+           module configures the interface and CCDC/ISIF to do
+           video frame capture from slave decoders.
+
+           To compile this driver as a module, choose M here: the
+           module will be called vpfe.
+
+config VIDEO_DM355_CCDC
+        tristate "DM355 CCDC HW module"
+        depends on ARCH_DAVINCI_DM355 && VIDEO_VPFE_CAPTURE
+        select VIDEO_VPSS_SYSTEM
+        default y
+        help
+           Enables DM355 CCD hw module. DM355 CCDC hw interfaces
+           with decoder modules such as TVP5146 over BT656 or
+           sensor module such as MT9T001 over a raw interface. This
+           module configures the interface and CCDC/ISIF to do
+           video frame capture from a slave decoders
+
+           To compile this driver as a module, choose M here: the
+           module will be called vpfe.
+
 source "drivers/media/video/bt8xx/Kconfig"
 
 config VIDEO_PMS
@@ -690,6 +781,8 @@ source "drivers/media/video/ivtv/Kconfig"
 
 source "drivers/media/video/cx18/Kconfig"
 
+source "drivers/media/video/saa7164/Kconfig"
+
 config VIDEO_M32R_AR
         tristate "AR devices"
         depends on M32R && VIDEO_V4L1
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index 9f2e3214a482..e541932a789b 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -45,6 +45,7 @@ obj-$(CONFIG_VIDEO_SAA7185) += saa7185.o
 obj-$(CONFIG_VIDEO_SAA7191) += saa7191.o
 obj-$(CONFIG_VIDEO_ADV7170) += adv7170.o
 obj-$(CONFIG_VIDEO_ADV7175) += adv7175.o
+obj-$(CONFIG_VIDEO_ADV7180) += adv7180.o
 obj-$(CONFIG_VIDEO_ADV7343) += adv7343.o
 obj-$(CONFIG_VIDEO_VPX3220) += vpx3220.o
 obj-$(CONFIG_VIDEO_BT819) += bt819.o
@@ -154,12 +155,17 @@ obj-$(CONFIG_VIDEO_MX3)			+= mx3_camera.o
 obj-$(CONFIG_VIDEO_PXA27x)              += pxa_camera.o
 obj-$(CONFIG_VIDEO_SH_MOBILE_CEU)       += sh_mobile_ceu_camera.o
 
+obj-$(CONFIG_ARCH_DAVINCI)              += davinci/
+
 obj-$(CONFIG_VIDEO_AU0828) += au0828/
 
 obj-$(CONFIG_USB_VIDEO_CLASS)   += uvc/
+obj-$(CONFIG_VIDEO_SAA7164)     += saa7164/
 
 obj-$(CONFIG_VIDEO_IR_I2C)  += ir-kbd-i2c.o
 
+obj-$(CONFIG_ARCH_DAVINCI)      += davinci/
+
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
 EXTRA_CFLAGS += -Idrivers/media/common/tuners
diff --git a/drivers/media/video/adv7180.c b/drivers/media/video/adv7180.c
new file mode 100644
index 000000000000..1b3cbd02a7fd
--- /dev/null
+++ b/drivers/media/video/adv7180.c
@@ -0,0 +1,202 @@
+/*
+ * adv7180.c Analog Devices ADV7180 video decoder driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/i2c-id.h>
+#include <media/v4l2-ioctl.h>
+#include <linux/videodev2.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-chip-ident.h>
+
+#define DRIVER_NAME "adv7180"
+
+#define ADV7180_INPUT_CONTROL_REG       0x00
+#define ADV7180_INPUT_CONTROL_PAL_BG_NTSC_J_SECAM       0x00
+#define ADV7180_AUTODETECT_ENABLE_REG   0x07
+#define ADV7180_AUTODETECT_DEFAULT      0x7f
+
+
+#define ADV7180_STATUS1_REG 0x10
+#define ADV7180_STATUS1_AUTOD_MASK 0x70
+#define ADV7180_STATUS1_AUTOD_NTSM_M_J  0x00
+#define ADV7180_STATUS1_AUTOD_NTSC_4_43 0x10
+#define ADV7180_STATUS1_AUTOD_PAL_M     0x20
+#define ADV7180_STATUS1_AUTOD_PAL_60    0x30
+#define ADV7180_STATUS1_AUTOD_PAL_B_G   0x40
+#define ADV7180_STATUS1_AUTOD_SECAM     0x50
+#define ADV7180_STATUS1_AUTOD_PAL_COMB  0x60
+#define ADV7180_STATUS1_AUTOD_SECAM_525 0x70
+
+#define ADV7180_IDENT_REG 0x11
+#define ADV7180_ID_7180 0x18
+
+
+struct adv7180_state {
+        struct v4l2_subdev sd;
+};
+
+static v4l2_std_id determine_norm(struct i2c_client *client)
+{
+        u8 status1 = i2c_smbus_read_byte_data(client, ADV7180_STATUS1_REG);
+
+        switch (status1 & ADV7180_STATUS1_AUTOD_MASK) {
+        case ADV7180_STATUS1_AUTOD_NTSM_M_J:
+                return V4L2_STD_NTSC_M_JP;
+        case ADV7180_STATUS1_AUTOD_NTSC_4_43:
+                return V4L2_STD_NTSC_443;
+        case ADV7180_STATUS1_AUTOD_PAL_M:
+                return V4L2_STD_PAL_M;
+        case ADV7180_STATUS1_AUTOD_PAL_60:
+                return V4L2_STD_PAL_60;
+        case ADV7180_STATUS1_AUTOD_PAL_B_G:
+                return V4L2_STD_PAL;
+        case ADV7180_STATUS1_AUTOD_SECAM:
+                return V4L2_STD_SECAM;
+        case ADV7180_STATUS1_AUTOD_PAL_COMB:
+                return V4L2_STD_PAL_Nc | V4L2_STD_PAL_N;
+        case ADV7180_STATUS1_AUTOD_SECAM_525:
+                return V4L2_STD_SECAM;
+        default:
+                return V4L2_STD_UNKNOWN;
+        }
+}
+
+static inline struct adv7180_state *to_state(struct v4l2_subdev *sd)
+{
+        return container_of(sd, struct adv7180_state, sd);
+}
+
+static int adv7180_querystd(struct v4l2_subdev *sd, v4l2_std_id *std)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        *std = determine_norm(client);
+        return 0;
+}
+
+static int adv7180_g_chip_ident(struct v4l2_subdev *sd,
+        struct v4l2_dbg_chip_ident *chip)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_ADV7180, 0);
+}
+
+static const struct v4l2_subdev_video_ops adv7180_video_ops = {
+        .querystd = adv7180_querystd,
+};
+
+static const struct v4l2_subdev_core_ops adv7180_core_ops = {
+        .g_chip_ident = adv7180_g_chip_ident,
+};
+
+static const struct v4l2_subdev_ops adv7180_ops = {
+        .core = &adv7180_core_ops,
+        .video = &adv7180_video_ops,
+};
+
+/*
+ * Generic i2c probe
+ * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
+ */
+
+static int adv7180_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        struct adv7180_state *state;
+        struct v4l2_subdev *sd;
+        int ret;
+
+        /* Check if the adapter supports the needed features */
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -EIO;
+
+        v4l_info(client, "chip found @ 0x%02x (%s)\n",
+                        client->addr << 1, client->adapter->name);
+
+        state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL);
+        if (state == NULL)
+                return -ENOMEM;
+        sd = &state->sd;
+        v4l2_i2c_subdev_init(sd, client, &adv7180_ops);
+
+        /* Initialize adv7180 */
+        /* enable autodetection */
+        ret = i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG,
+                ADV7180_INPUT_CONTROL_PAL_BG_NTSC_J_SECAM);
+        if (ret > 0)
+                ret = i2c_smbus_write_byte_data(client,
+                        ADV7180_AUTODETECT_ENABLE_REG,
+                        ADV7180_AUTODETECT_DEFAULT);
+        if (ret < 0) {
+                printk(KERN_ERR DRIVER_NAME
+                        ": Failed to communicate to chip: %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int adv7180_remove(struct i2c_client *client)
+{
+        struct v4l2_subdev *sd = i2c_get_clientdata(client);
+
+        v4l2_device_unregister_subdev(sd);
+        kfree(to_state(sd));
+        return 0;
+}
+
+static const struct i2c_device_id adv7180_id[] = {
+        {DRIVER_NAME, 0},
+        {},
+};
+
+MODULE_DEVICE_TABLE(i2c, adv7180_id);
+
+static struct i2c_driver adv7180_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = DRIVER_NAME,
+        },
+        .probe          = adv7180_probe,
+        .remove         = adv7180_remove,
+        .id_table       = adv7180_id,
+};
+
+static __init int adv7180_init(void)
+{
+        return i2c_add_driver(&adv7180_driver);
+}
+
+static __exit void adv7180_exit(void)
+{
+        i2c_del_driver(&adv7180_driver);
+}
+
+module_init(adv7180_init);
+module_exit(adv7180_exit);
+
+MODULE_DESCRIPTION("Analog Devices ADV7180 video decoder driver");
+MODULE_AUTHOR("Mocean Laboratories");
+MODULE_LICENSE("GPL v2");
+
diff --git a/drivers/media/video/adv7343.c b/drivers/media/video/adv7343.c
index 30f5caf5dda5..df26f2fe44eb 100644
--- a/drivers/media/video/adv7343.c
+++ b/drivers/media/video/adv7343.c
@@ -24,7 +24,6 @@
 #include <linux/module.h>
 #include <linux/videodev2.h>
 #include <linux/uaccess.h>
-#include <linux/version.h>
 
 #include <media/adv7343.h>
 #include <media/v4l2-device.h>
diff --git a/drivers/media/video/au0828/au0828-cards.c b/drivers/media/video/au0828/au0828-cards.c
index 830c4a933f63..57dd9195daf5 100644
--- a/drivers/media/video/au0828/au0828-cards.c
+++ b/drivers/media/video/au0828/au0828-cards.c
@@ -212,7 +212,7 @@ void au0828_card_setup(struct au0828_dev *dev)
                    be abstracted out if we ever need to support a different
                    demod) */
                 sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
-                                "au8522", "au8522", 0x8e >> 1);
+                                "au8522", "au8522", 0x8e >> 1, NULL);
                 if (sd == NULL)
                         printk(KERN_ERR "analog subdev registration failed\n");
         }
@@ -221,7 +221,7 @@ void au0828_card_setup(struct au0828_dev *dev)
         if (dev->board.tuner_type != TUNER_ABSENT) {
                 /* Load the tuner module, which does the attach */
                 sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
-                                "tuner", "tuner", dev->board.tuner_addr);
+                                "tuner", "tuner", dev->board.tuner_addr, NULL);
                 if (sd == NULL)
                         printk(KERN_ERR "tuner subdev registration fail\n");
 
diff --git a/drivers/media/video/bt8xx/bttv-cards.c b/drivers/media/video/bt8xx/bttv-cards.c
index b42251fa96ba..12279f6d9bc4 100644
--- a/drivers/media/video/bt8xx/bttv-cards.c
+++ b/drivers/media/video/bt8xx/bttv-cards.c
@@ -3524,8 +3524,8 @@ void __devinit bttv_init_card2(struct bttv *btv)
                 };
                 struct v4l2_subdev *sd;
 
-                sd = v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev,
-                        &btv->c.i2c_adap, "saa6588", "saa6588", addrs);
+                sd = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
+                        &btv->c.i2c_adap, "saa6588", "saa6588", 0, addrs);
                 btv->has_saa6588 = (sd != NULL);
         }
 
@@ -3549,8 +3549,8 @@ void __devinit bttv_init_card2(struct bttv *btv)
                         I2C_CLIENT_END
                 };
 
-                btv->sd_msp34xx = v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev,
-                        &btv->c.i2c_adap, "msp3400", "msp3400", addrs);
+                btv->sd_msp34xx = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
+                        &btv->c.i2c_adap, "msp3400", "msp3400", 0, addrs);
                 if (btv->sd_msp34xx)
                         return;
                 goto no_audio;
@@ -3563,16 +3563,16 @@ void __devinit bttv_init_card2(struct bttv *btv)
                         I2C_CLIENT_END
                 };
 
-                if (v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev,
-                                &btv->c.i2c_adap, "tda7432", "tda7432", addrs))
+                if (v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
+                                &btv->c.i2c_adap, "tda7432", "tda7432", 0, addrs))
                         return;
                 goto no_audio;
         }
 
         case 3: {
                 /* The user specified that we should probe for tvaudio */
-                btv->sd_tvaudio = v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev,
-                        &btv->c.i2c_adap, "tvaudio", "tvaudio", tvaudio_addrs());
+                btv->sd_tvaudio = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
+                        &btv->c.i2c_adap, "tvaudio", "tvaudio", 0, tvaudio_addrs());
                 if (btv->sd_tvaudio)
                         return;
                 goto no_audio;
@@ -3591,13 +3591,13 @@ void __devinit bttv_init_card2(struct bttv *btv)
            it really is a msp3400, so it will return NULL when the device
            found is really something else (e.g. a tea6300). */
         if (!bttv_tvcards[btv->c.type].no_msp34xx) {
-                btv->sd_msp34xx = v4l2_i2c_new_probed_subdev_addr(&btv->c.v4l2_dev,
+                btv->sd_msp34xx = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
                         &btv->c.i2c_adap, "msp3400", "msp3400",
-                        I2C_ADDR_MSP3400 >> 1);
+                        0, I2C_ADDRS(I2C_ADDR_MSP3400 >> 1));
         } else if (bttv_tvcards[btv->c.type].msp34xx_alt) {
-                btv->sd_msp34xx = v4l2_i2c_new_probed_subdev_addr(&btv->c.v4l2_dev,
+                btv->sd_msp34xx = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
                         &btv->c.i2c_adap, "msp3400", "msp3400",
-                        I2C_ADDR_MSP3400_ALT >> 1);
+                        0, I2C_ADDRS(I2C_ADDR_MSP3400_ALT >> 1));
         }
 
         /* If we found a msp34xx, then we're done. */
@@ -3611,14 +3611,14 @@ void __devinit bttv_init_card2(struct bttv *btv)
                         I2C_CLIENT_END
                 };
 
-                if (v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev,
-                                &btv->c.i2c_adap, "tda7432", "tda7432", addrs))
+                if (v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
+                                &btv->c.i2c_adap, "tda7432", "tda7432", 0, addrs))
                         return;
         }
 
         /* Now see if we can find one of the tvaudio devices. */
-        btv->sd_tvaudio = v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev,
-                &btv->c.i2c_adap, "tvaudio", "tvaudio", tvaudio_addrs());
+        btv->sd_tvaudio = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
+                &btv->c.i2c_adap, "tvaudio", "tvaudio", 0, tvaudio_addrs());
         if (btv->sd_tvaudio)
                 return;
 
@@ -3641,15 +3641,15 @@ void __devinit bttv_init_tuner(struct bttv *btv)
 
                 /* Load tuner module before issuing tuner config call! */
                 if (bttv_tvcards[btv->c.type].has_radio)
-                        v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev,
+                        v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
                                 &btv->c.i2c_adap, "tuner", "tuner",
-                                v4l2_i2c_tuner_addrs(ADDRS_RADIO));
-                v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev,
+                                0, v4l2_i2c_tuner_addrs(ADDRS_RADIO));
+                v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
                                 &btv->c.i2c_adap, "tuner", "tuner",
-                                v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
-                v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev,
+                                0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
+                v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
                                 &btv->c.i2c_adap, "tuner", "tuner",
-                                v4l2_i2c_tuner_addrs(ADDRS_TV_WITH_DEMOD));
+                                0, v4l2_i2c_tuner_addrs(ADDRS_TV_WITH_DEMOD));
 
                 tun_setup.mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
                 tun_setup.type = btv->tuner_type;
diff --git a/drivers/media/video/cafe_ccic.c b/drivers/media/video/cafe_ccic.c
index 9c149a781294..657c481d255c 100644
--- a/drivers/media/video/cafe_ccic.c
+++ b/drivers/media/video/cafe_ccic.c
@@ -1955,7 +1955,7 @@ static int cafe_pci_probe(struct pci_dev *pdev,
 
         cam->sensor_addr = 0x42;
         cam->sensor = v4l2_i2c_new_subdev(&cam->v4l2_dev, &cam->i2c_adapter,
-                        "ov7670", "ov7670", cam->sensor_addr);
+                        "ov7670", "ov7670", cam->sensor_addr, NULL);
         if (cam->sensor == NULL) {
                 ret = -ENODEV;
                 goto out_smbus;
diff --git a/drivers/media/video/cx18/cx18-driver.c b/drivers/media/video/cx18/cx18-driver.c
index dd0224f328ad..6dd51e27582c 100644
--- a/drivers/media/video/cx18/cx18-driver.c
+++ b/drivers/media/video/cx18/cx18-driver.c
@@ -231,7 +231,7 @@ MODULE_PARM_DESC(enc_pcm_bufs,
                  "Number of encoder PCM buffers\n"
                  "\t\t\tDefault is computed from other enc_pcm_* parameters");
 
-MODULE_PARM_DESC(cx18_first_minor, "Set kernel number assigned to first card");
+MODULE_PARM_DESC(cx18_first_minor, "Set device node number assigned to first card");
 
 MODULE_AUTHOR("Hans Verkuil");
 MODULE_DESCRIPTION("CX23418 driver");
diff --git a/drivers/media/video/cx18/cx18-i2c.c b/drivers/media/video/cx18/cx18-i2c.c
index da395fef50df..2477461e84d7 100644
--- a/drivers/media/video/cx18/cx18-i2c.c
+++ b/drivers/media/video/cx18/cx18-i2c.c
@@ -116,7 +116,7 @@ static int cx18_i2c_new_ir(struct i2c_adapter *adap, u32 hw, const char *type,
         /* Our default information for ir-kbd-i2c.c to use */
         switch (hw) {
         case CX18_HW_Z8F0811_IR_RX_HAUP:
-                info.platform_data = &z8f0811_ir_init_data;
+                info.platform_data = (void *) &z8f0811_ir_init_data;
                 break;
         default:
                 break;
@@ -139,16 +139,16 @@ int cx18_i2c_register(struct cx18 *cx, unsigned idx)
 
         if (hw == CX18_HW_TUNER) {
                 /* special tuner group handling */
-                sd = v4l2_i2c_new_probed_subdev(&cx->v4l2_dev,
-                                adap, mod, type, cx->card_i2c->radio);
+                sd = v4l2_i2c_new_subdev(&cx->v4l2_dev,
+                                adap, mod, type, 0, cx->card_i2c->radio);
                 if (sd != NULL)
                         sd->grp_id = hw;
-                sd = v4l2_i2c_new_probed_subdev(&cx->v4l2_dev,
-                                adap, mod, type, cx->card_i2c->demod);
+                sd = v4l2_i2c_new_subdev(&cx->v4l2_dev,
+                                adap, mod, type, 0, cx->card_i2c->demod);
                 if (sd != NULL)
                         sd->grp_id = hw;
-                sd = v4l2_i2c_new_probed_subdev(&cx->v4l2_dev,
-                                adap, mod, type, cx->card_i2c->tv);
+                sd = v4l2_i2c_new_subdev(&cx->v4l2_dev,
+                                adap, mod, type, 0, cx->card_i2c->tv);
                 if (sd != NULL)
                         sd->grp_id = hw;
                 return sd != NULL ? 0 : -1;
@@ -162,7 +162,7 @@ int cx18_i2c_register(struct cx18 *cx, unsigned idx)
                 return -1;
 
         /* It's an I2C device other than an analog tuner or IR chip */
-        sd = v4l2_i2c_new_subdev(&cx->v4l2_dev, adap, mod, type, hw_addrs[idx]);
+        sd = v4l2_i2c_new_subdev(&cx->v4l2_dev, adap, mod, type, hw_addrs[idx], NULL);
         if (sd != NULL)
                 sd->grp_id = hw;
         return sd != NULL ? 0 : -1;
diff --git a/drivers/media/video/cx18/cx18-streams.c b/drivers/media/video/cx18/cx18-streams.c
index 54d248e16d85..7df513a2dba8 100644
--- a/drivers/media/video/cx18/cx18-streams.c
+++ b/drivers/media/video/cx18/cx18-streams.c
@@ -245,9 +245,9 @@ static int cx18_reg_dev(struct cx18 *cx, int type)
         video_set_drvdata(s->video_dev, s);
 
         /* Register device. First try the desired minor, then any free one. */
-        ret = video_register_device(s->video_dev, vfl_type, num);
+        ret = video_register_device_no_warn(s->video_dev, vfl_type, num);
         if (ret < 0) {
-                CX18_ERR("Couldn't register v4l2 device for %s kernel number %d\n",
+                CX18_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
                         s->name, num);
                 video_device_release(s->video_dev);
                 s->video_dev = NULL;
diff --git a/drivers/media/video/cx231xx/cx231xx-cards.c b/drivers/media/video/cx231xx/cx231xx-cards.c
index 63d2239fd324..319c459459e0 100644
--- a/drivers/media/video/cx231xx/cx231xx-cards.c
+++ b/drivers/media/video/cx231xx/cx231xx-cards.c
@@ -313,7 +313,7 @@ void cx231xx_card_setup(struct cx231xx *dev)
         if (dev->board.decoder == CX231XX_AVDECODER) {
                 dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                         &dev->i2c_bus[0].i2c_adap,
-                                        "cx25840", "cx25840", 0x88 >> 1);
+                                        "cx25840", "cx25840", 0x88 >> 1, NULL);
                 if (dev->sd_cx25840 == NULL)
                         cx231xx_info("cx25840 subdev registration failure\n");
                 cx25840_call(dev, core, load_fw);
@@ -323,7 +323,7 @@ void cx231xx_card_setup(struct cx231xx *dev)
         if (dev->board.tuner_type != TUNER_ABSENT) {
                 dev->sd_tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_bus[1].i2c_adap,
-                                "tuner", "tuner", 0xc2 >> 1);
+                                "tuner", "tuner", 0xc2 >> 1, NULL);
                 if (dev->sd_tuner == NULL)
                         cx231xx_info("tuner subdev registration failure\n");
 
diff --git a/drivers/media/video/cx23885/cimax2.c b/drivers/media/video/cx23885/cimax2.c
index 0316257b7345..c04222ffb286 100644
--- a/drivers/media/video/cx23885/cimax2.c
+++ b/drivers/media/video/cx23885/cimax2.c
@@ -75,7 +75,6 @@ struct netup_ci_state {
         void *priv;
 };
 
-struct mutex gpio_mutex;/* Two CiMax's uses same GPIO lines */
 
 int netup_read_i2c(struct i2c_adapter *i2c_adap, u8 addr, u8 reg,
                                                 u8 *buf, int len)
@@ -183,10 +182,11 @@ int netup_ci_op_cam(struct dvb_ca_en50221 *en50221, int slot,
         if (ret != 0)
                 return ret;
 
-        mutex_lock(&gpio_mutex);
+        mutex_lock(&dev->gpio_lock);
 
         /* write addr */
         cx_write(MC417_OEN, NETUP_EN_ALL);
+        msleep(2);
         cx_write(MC417_RWD, NETUP_CTRL_OFF |
                                 NETUP_ADLO | (0xff & addr));
         cx_clear(MC417_RWD, NETUP_ADLO);
@@ -194,9 +194,10 @@ int netup_ci_op_cam(struct dvb_ca_en50221 *en50221, int slot,
                                 NETUP_ADHI | (0xff & (addr >> 8)));
         cx_clear(MC417_RWD, NETUP_ADHI);
 
-        if (read) /* data in */
+        if (read) { /* data in */
                 cx_write(MC417_OEN, NETUP_EN_ALL | NETUP_DATA);
-        else /* data out */
+                msleep(2);
+        } else /* data out */
                 cx_write(MC417_RWD, NETUP_CTRL_OFF | data);
 
         /* choose chip */
@@ -206,7 +207,7 @@ int netup_ci_op_cam(struct dvb_ca_en50221 *en50221, int slot,
         cx_clear(MC417_RWD, (read) ? NETUP_RD : NETUP_WR);
         mem = netup_ci_get_mem(dev);
 
-        mutex_unlock(&gpio_mutex);
+        mutex_unlock(&dev->gpio_lock);
 
         if (!read)
                 if (mem < 0)
@@ -403,7 +404,6 @@ int netup_ci_init(struct cx23885_tsport *port)
         switch (port->nr) {
         case 1:
                 state->ci_i2c_addr = 0x40;
-                mutex_init(&gpio_mutex);
                 break;
         case 2:
                 state->ci_i2c_addr = 0x41;
diff --git a/drivers/media/video/cx23885/cx23885-cards.c b/drivers/media/video/cx23885/cx23885-cards.c
index 3143d85ef31d..bfdf79f1033c 100644
--- a/drivers/media/video/cx23885/cx23885-cards.c
+++ b/drivers/media/video/cx23885/cx23885-cards.c
@@ -210,6 +210,10 @@ struct cx23885_board cx23885_boards[] = {
                 .portb          = CX23885_MPEG_ENCODER,
                 .portc          = CX23885_MPEG_DVB,
         },
+        [CX23885_BOARD_COMPRO_VIDEOMATE_E800] = {
+                .name           = "Compro VideoMate E800",
+                .portc          = CX23885_MPEG_DVB,
+        },
 };
 const unsigned int cx23885_bcount = ARRAY_SIZE(cx23885_boards);
 
@@ -341,6 +345,10 @@ struct cx23885_subid cx23885_subids[] = {
                 .subvendor = 0x0070,
                 .subdevice = 0x8541,
                 .card      = CX23885_BOARD_HAUPPAUGE_HVR1850,
+        }, {
+                .subvendor = 0x1858,
+                .subdevice = 0xe800,
+                .card      = CX23885_BOARD_COMPRO_VIDEOMATE_E800,
         },
 };
 const unsigned int cx23885_idcount = ARRAY_SIZE(cx23885_subids);
@@ -536,6 +544,7 @@ int cx23885_tuner_callback(void *priv, int component, int command, int arg)
         case CX23885_BOARD_HAUPPAUGE_HVR1500Q:
         case CX23885_BOARD_LEADTEK_WINFAST_PXDVR3200_H:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E650F:
+        case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
                 /* Tuner Reset Command */
                 bitmask = 0x04;
                 break;
@@ -687,6 +696,7 @@ void cx23885_gpio_setup(struct cx23885_dev *dev)
                 break;
         case CX23885_BOARD_LEADTEK_WINFAST_PXDVR3200_H:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E650F:
+        case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
                 /* GPIO-2  xc3028 tuner reset */
 
                 /* The following GPIO's are on the internal AVCore (cx25840) */
@@ -911,6 +921,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
         case CX23885_BOARD_HAUPPAUGE_HVR1850:
+        case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
         default:
                 ts2->gen_ctrl_val  = 0xc; /* Serial bus + punctured clock */
                 ts2->ts_clk_en_val = 0x1; /* Enable TS_CLK */
@@ -927,9 +938,10 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_LEADTEK_WINFAST_PXDVR3200_H:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E650F:
         case CX23885_BOARD_NETUP_DUAL_DVBS2_CI:
+        case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
                 dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_bus[2].i2c_adap,
-                                "cx25840", "cx25840", 0x88 >> 1);
+                                "cx25840", "cx25840", 0x88 >> 1, NULL);
                 v4l2_subdev_call(dev->sd_cx25840, core, load_fw);
                 break;
         }
diff --git a/drivers/media/video/cx23885/cx23885-core.c b/drivers/media/video/cx23885/cx23885-core.c
index 40d438d7234d..c31284ba19dd 100644
--- a/drivers/media/video/cx23885/cx23885-core.c
+++ b/drivers/media/video/cx23885/cx23885-core.c
@@ -758,6 +758,7 @@ static int cx23885_dev_setup(struct cx23885_dev *dev)
         int i;
 
         mutex_init(&dev->lock);
+        mutex_init(&dev->gpio_lock);
 
         atomic_inc(&dev->refcount);
 
diff --git a/drivers/media/video/cx23885/cx23885-dvb.c b/drivers/media/video/cx23885/cx23885-dvb.c
index 022fad798fc2..45e13ee66dc7 100644
--- a/drivers/media/video/cx23885/cx23885-dvb.c
+++ b/drivers/media/video/cx23885/cx23885-dvb.c
@@ -255,15 +255,18 @@ static struct tda18271_std_map hauppauge_hvr1200_tda18271_std_map = {
 static struct tda18271_config hauppauge_tda18271_config = {
         .std_map = &hauppauge_tda18271_std_map,
         .gate    = TDA18271_GATE_ANALOG,
+        .output_opt = TDA18271_OUTPUT_LT_OFF,
 };
 
 static struct tda18271_config hauppauge_hvr1200_tuner_config = {
         .std_map = &hauppauge_hvr1200_tda18271_std_map,
         .gate    = TDA18271_GATE_ANALOG,
+        .output_opt = TDA18271_OUTPUT_LT_OFF,
 };
 
 static struct tda18271_config hauppauge_hvr1210_tuner_config = {
         .gate    = TDA18271_GATE_DIGITAL,
+        .output_opt = TDA18271_OUTPUT_LT_OFF,
 };
 
 static struct tda18271_std_map hauppauge_hvr127x_std_map = {
@@ -275,6 +278,7 @@ static struct tda18271_std_map hauppauge_hvr127x_std_map = {
 
 static struct tda18271_config hauppauge_hvr127x_config = {
         .std_map = &hauppauge_hvr127x_std_map,
+        .output_opt = TDA18271_OUTPUT_LT_OFF,
 };
 
 static struct lgdt3305_config hauppauge_lgdt3305_config = {
@@ -743,6 +747,7 @@ static int dvb_register(struct cx23885_tsport *port)
         }
         case CX23885_BOARD_LEADTEK_WINFAST_PXDVR3200_H:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E650F:
+        case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
                 i2c_bus = &dev->i2c_bus[0];
 
                 fe0->dvb.frontend = dvb_attach(zl10353_attach,
diff --git a/drivers/media/video/cx23885/cx23885-video.c b/drivers/media/video/cx23885/cx23885-video.c
index 5d6093336300..654cc253cd50 100644
--- a/drivers/media/video/cx23885/cx23885-video.c
+++ b/drivers/media/video/cx23885/cx23885-video.c
@@ -1521,11 +1521,11 @@ int cx23885_video_register(struct cx23885_dev *dev)
                 if (dev->tuner_addr)
                         sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_bus[1].i2c_adap,
-                                "tuner", "tuner", dev->tuner_addr);
+                                "tuner", "tuner", dev->tuner_addr, NULL);
                 else
-                        sd = v4l2_i2c_new_probed_subdev(&dev->v4l2_dev,
+                        sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_bus[1].i2c_adap,
-                                "tuner", "tuner", v4l2_i2c_tuner_addrs(ADDRS_TV));
+                                "tuner", "tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_TV));
                 if (sd) {
                         struct tuner_setup tun_setup;
 
diff --git a/drivers/media/video/cx23885/cx23885.h b/drivers/media/video/cx23885/cx23885.h
index 86f26947bb78..cc7a165561ff 100644
--- a/drivers/media/video/cx23885/cx23885.h
+++ b/drivers/media/video/cx23885/cx23885.h
@@ -78,6 +78,7 @@
 #define CX23885_BOARD_MYGICA_X8506             22
 #define CX23885_BOARD_MAGICPRO_PROHDTVE2       23
 #define CX23885_BOARD_HAUPPAUGE_HVR1850        24
+#define CX23885_BOARD_COMPRO_VIDEOMATE_E800    25
 
 #define GPIO_0 0x00000001
 #define GPIO_1 0x00000002
@@ -325,6 +326,7 @@ struct cx23885_dev {
 
         int                        nr;
         struct mutex               lock;
+        struct mutex               gpio_lock;
 
         /* board details */
         unsigned int               board;
diff --git a/drivers/media/video/cx23885/netup-eeprom.c b/drivers/media/video/cx23885/netup-eeprom.c
index 042bbbbd48f8..98a48f500684 100644
--- a/drivers/media/video/cx23885/netup-eeprom.c
+++ b/drivers/media/video/cx23885/netup-eeprom.c
@@ -97,11 +97,11 @@ void netup_get_card_info(struct i2c_adapter *i2c_adap,
 {
         int i, j;
 
-        cinfo->rev =  netup_eeprom_read(i2c_adap, 13);
+        cinfo->rev =  netup_eeprom_read(i2c_adap, 63);
 
-        for (i = 0, j = 0; i < 6; i++, j++)
+        for (i = 64, j = 0; i < 70; i++, j++)
                 cinfo->port[0].mac[j] =  netup_eeprom_read(i2c_adap, i);
 
-        for (i = 6, j = 0; i < 12; i++, j++)
+        for (i = 70, j = 0; i < 76; i++, j++)
                 cinfo->port[1].mac[j] =  netup_eeprom_read(i2c_adap, i);
 };
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c
index e5f07fbd5a35..33be6369871a 100644
--- a/drivers/media/video/cx88/cx88-cards.c
+++ b/drivers/media/video/cx88/cx88-cards.c
@@ -3439,20 +3439,20 @@ struct cx88_core *cx88_core_create(struct pci_dev *pci, int nr)
                    The radio_type is sometimes missing, or set to UNSET but
                    later code configures a tea5767.
                  */
-                v4l2_i2c_new_probed_subdev(&core->v4l2_dev, &core->i2c_adap,
+                v4l2_i2c_new_subdev(&core->v4l2_dev, &core->i2c_adap,
                                 "tuner", "tuner",
-                                v4l2_i2c_tuner_addrs(ADDRS_RADIO));
+                                0, v4l2_i2c_tuner_addrs(ADDRS_RADIO));
                 if (has_demod)
-                        v4l2_i2c_new_probed_subdev(&core->v4l2_dev,
+                        v4l2_i2c_new_subdev(&core->v4l2_dev,
                                 &core->i2c_adap, "tuner", "tuner",
-                                v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
+                                0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
                 if (core->board.tuner_addr == ADDR_UNSET) {
-                        v4l2_i2c_new_probed_subdev(&core->v4l2_dev,
+                        v4l2_i2c_new_subdev(&core->v4l2_dev,
                                 &core->i2c_adap, "tuner", "tuner",
-                                has_demod ? tv_addrs + 4 : tv_addrs);
+                                0, has_demod ? tv_addrs + 4 : tv_addrs);
                 } else {
                         v4l2_i2c_new_subdev(&core->v4l2_dev, &core->i2c_adap,
-                                "tuner", "tuner", core->board.tuner_addr);
+                                "tuner", "tuner", core->board.tuner_addr, NULL);
                 }
         }
 
diff --git a/drivers/media/video/cx88/cx88-video.c b/drivers/media/video/cx88/cx88-video.c
index 2bb54c3ef5cd..81d2b5dea18e 100644
--- a/drivers/media/video/cx88/cx88-video.c
+++ b/drivers/media/video/cx88/cx88-video.c
@@ -1881,14 +1881,14 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
 
         if (core->board.audio_chip == V4L2_IDENT_WM8775)
                 v4l2_i2c_new_subdev(&core->v4l2_dev, &core->i2c_adap,
-                                "wm8775", "wm8775", 0x36 >> 1);
+                                "wm8775", "wm8775", 0x36 >> 1, NULL);
 
         if (core->board.audio_chip == V4L2_IDENT_TVAUDIO) {
                 /* This probes for a tda9874 as is used on some
                    Pixelview Ultra boards. */
-                v4l2_i2c_new_probed_subdev_addr(&core->v4l2_dev,
+                v4l2_i2c_new_subdev(&core->v4l2_dev,
                                 &core->i2c_adap,
-                                "tvaudio", "tvaudio", 0xb0 >> 1);
+                                "tvaudio", "tvaudio", 0, I2C_ADDRS(0xb0 >> 1));
         }
 
         switch (core->boardnr) {
diff --git a/drivers/media/video/davinci/Makefile b/drivers/media/video/davinci/Makefile
new file mode 100644
index 000000000000..1a8b8f3f182e
--- /dev/null
+++ b/drivers/media/video/davinci/Makefile
@@ -0,0 +1,17 @@
+#
+# Makefile for the davinci video device drivers.
+#
+
+# VPIF
+obj-$(CONFIG_VIDEO_DAVINCI_VPIF) += vpif.o
+
+#DM646x EVM Display driver
+obj-$(CONFIG_DISPLAY_DAVINCI_DM646X_EVM) += vpif_display.o
+#DM646x EVM Capture driver
+obj-$(CONFIG_CAPTURE_DAVINCI_DM646X_EVM) += vpif_capture.o
+
+# Capture: DM6446 and DM355
+obj-$(CONFIG_VIDEO_VPSS_SYSTEM) += vpss.o
+obj-$(CONFIG_VIDEO_VPFE_CAPTURE) += vpfe_capture.o
+obj-$(CONFIG_VIDEO_DM6446_CCDC) += dm644x_ccdc.o
+obj-$(CONFIG_VIDEO_DM355_CCDC) += dm355_ccdc.o
diff --git a/drivers/media/video/davinci/ccdc_hw_device.h b/drivers/media/video/davinci/ccdc_hw_device.h
new file mode 100644
index 000000000000..86b9b3518965
--- /dev/null
+++ b/drivers/media/video/davinci/ccdc_hw_device.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2008-2009 Texas Instruments Inc
+ *
+ * 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
+ *
+ * ccdc device API
+ */
+#ifndef _CCDC_HW_DEVICE_H
+#define _CCDC_HW_DEVICE_H
+
+#ifdef __KERNEL__
+#include <linux/videodev2.h>
+#include <linux/device.h>
+#include <media/davinci/vpfe_types.h>
+#include <media/davinci/ccdc_types.h>
+
+/*
+ * ccdc hw operations
+ */
+struct ccdc_hw_ops {
+        /* Pointer to initialize function to initialize ccdc device */
+        int (*open) (struct device *dev);
+        /* Pointer to deinitialize function */
+        int (*close) (struct device *dev);
+        /* set ccdc base address */
+        void (*set_ccdc_base)(void *base, int size);
+        /* Pointer to function to enable or disable ccdc */
+        void (*enable) (int en);
+        /* reset sbl. only for 6446 */
+        void (*reset) (void);
+        /* enable output to sdram */
+        void (*enable_out_to_sdram) (int en);
+        /* Pointer to function to set hw parameters */
+        int (*set_hw_if_params) (struct vpfe_hw_if_param *param);
+        /* get interface parameters */
+        int (*get_hw_if_params) (struct vpfe_hw_if_param *param);
+        /*
+         * Pointer to function to set parameters. Used
+         * for implementing VPFE_S_CCDC_PARAMS
+         */
+        int (*set_params) (void *params);
+        /*
+         * Pointer to function to get parameter. Used
+         * for implementing VPFE_G_CCDC_PARAMS
+         */
+        int (*get_params) (void *params);
+        /* Pointer to function to configure ccdc */
+        int (*configure) (void);
+
+        /* Pointer to function to set buffer type */
+        int (*set_buftype) (enum ccdc_buftype buf_type);
+        /* Pointer to function to get buffer type */
+        enum ccdc_buftype (*get_buftype) (void);
+        /* Pointer to function to set frame format */
+        int (*set_frame_format) (enum ccdc_frmfmt frm_fmt);
+        /* Pointer to function to get frame format */
+        enum ccdc_frmfmt (*get_frame_format) (void);
+        /* enumerate hw pix formats */
+        int (*enum_pix)(u32 *hw_pix, int i);
+        /* Pointer to function to set buffer type */
+        u32 (*get_pixel_format) (void);
+        /* Pointer to function to get pixel format. */
+        int (*set_pixel_format) (u32 pixfmt);
+        /* Pointer to function to set image window */
+        int (*set_image_window) (struct v4l2_rect *win);
+        /* Pointer to function to set image window */
+        void (*get_image_window) (struct v4l2_rect *win);
+        /* Pointer to function to get line length */
+        unsigned int (*get_line_length) (void);
+
+        /* Query CCDC control IDs */
+        int (*queryctrl)(struct v4l2_queryctrl *qctrl);
+        /* Set CCDC control */
+        int (*set_control)(struct v4l2_control *ctrl);
+        /* Get CCDC control */
+        int (*get_control)(struct v4l2_control *ctrl);
+
+        /* Pointer to function to set frame buffer address */
+        void (*setfbaddr) (unsigned long addr);
+        /* Pointer to function to get field id */
+        int (*getfid) (void);
+};
+
+struct ccdc_hw_device {
+        /* ccdc device name */
+        char name[32];
+        /* module owner */
+        struct module *owner;
+        /* hw ops */
+        struct ccdc_hw_ops hw_ops;
+};
+
+/* Used by CCDC module to register & unregister with vpfe capture driver */
+int vpfe_register_ccdc_device(struct ccdc_hw_device *dev);
+void vpfe_unregister_ccdc_device(struct ccdc_hw_device *dev);
+
+#endif
+#endif
diff --git a/drivers/media/video/davinci/dm355_ccdc.c b/drivers/media/video/davinci/dm355_ccdc.c
new file mode 100644
index 000000000000..4629cabe3f28
--- /dev/null
+++ b/drivers/media/video/davinci/dm355_ccdc.c
@@ -0,0 +1,978 @@
+/*
+ * Copyright (C) 2005-2009 Texas Instruments Inc
+ *
+ * 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
+ *
+ * CCDC hardware module for DM355
+ * ------------------------------
+ *
+ * This module is for configuring DM355 CCD controller of VPFE to capture
+ * Raw yuv or Bayer RGB data from a decoder. CCDC has several modules
+ * such as Defect Pixel Correction, Color Space Conversion etc to
+ * pre-process the Bayer RGB data, before writing it to SDRAM. This
+ * module also allows application to configure individual
+ * module parameters through VPFE_CMD_S_CCDC_RAW_PARAMS IOCTL.
+ * To do so, application include dm355_ccdc.h and vpfe_capture.h header
+ * files. The setparams() API is called by vpfe_capture driver
+ * to configure module parameters
+ *
+ * TODO: 1) Raw bayer parameter settings and bayer capture
+ *       2) Split module parameter structure to module specific ioctl structs
+ *       3) add support for lense shading correction
+ *       4) investigate if enum used for user space type definition
+ *          to be replaced by #defines or integer
+ */
+#include <linux/platform_device.h>
+#include <linux/uaccess.h>
+#include <linux/videodev2.h>
+#include <media/davinci/dm355_ccdc.h>
+#include <media/davinci/vpss.h>
+#include "dm355_ccdc_regs.h"
+#include "ccdc_hw_device.h"
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("CCDC Driver for DM355");
+MODULE_AUTHOR("Texas Instruments");
+
+static struct device *dev;
+
+/* Object for CCDC raw mode */
+static struct ccdc_params_raw ccdc_hw_params_raw = {
+        .pix_fmt = CCDC_PIXFMT_RAW,
+        .frm_fmt = CCDC_FRMFMT_PROGRESSIVE,
+        .win = CCDC_WIN_VGA,
+        .fid_pol = VPFE_PINPOL_POSITIVE,
+        .vd_pol = VPFE_PINPOL_POSITIVE,
+        .hd_pol = VPFE_PINPOL_POSITIVE,
+        .gain = {
+                .r_ye = 256,
+                .gb_g = 256,
+                .gr_cy = 256,
+                .b_mg = 256
+        },
+        .config_params = {
+                .datasft = 2,
+                .data_sz = CCDC_DATA_10BITS,
+                .mfilt1 = CCDC_NO_MEDIAN_FILTER1,
+                .mfilt2 = CCDC_NO_MEDIAN_FILTER2,
+                .alaw = {
+                        .gama_wd = 2,
+                },
+                .blk_clamp = {
+                        .sample_pixel = 1,
+                        .dc_sub = 25
+                },
+                .col_pat_field0 = {
+                        .olop = CCDC_GREEN_BLUE,
+                        .olep = CCDC_BLUE,
+                        .elop = CCDC_RED,
+                        .elep = CCDC_GREEN_RED
+                },
+                .col_pat_field1 = {
+                        .olop = CCDC_GREEN_BLUE,
+                        .olep = CCDC_BLUE,
+                        .elop = CCDC_RED,
+                        .elep = CCDC_GREEN_RED
+                },
+        },
+};
+
+
+/* Object for CCDC ycbcr mode */
+static struct ccdc_params_ycbcr ccdc_hw_params_ycbcr = {
+        .win = CCDC_WIN_PAL,
+        .pix_fmt = CCDC_PIXFMT_YCBCR_8BIT,
+        .frm_fmt = CCDC_FRMFMT_INTERLACED,
+        .fid_pol = VPFE_PINPOL_POSITIVE,
+        .vd_pol = VPFE_PINPOL_POSITIVE,
+        .hd_pol = VPFE_PINPOL_POSITIVE,
+        .bt656_enable = 1,
+        .pix_order = CCDC_PIXORDER_CBYCRY,
+        .buf_type = CCDC_BUFTYPE_FLD_INTERLEAVED
+};
+
+static enum vpfe_hw_if_type ccdc_if_type;
+static void *__iomem ccdc_base_addr;
+static int ccdc_addr_size;
+
+/* Raw Bayer formats */
+static u32 ccdc_raw_bayer_pix_formats[] =
+                {V4L2_PIX_FMT_SBGGR8, V4L2_PIX_FMT_SBGGR16};
+
+/* Raw YUV formats */
+static u32 ccdc_raw_yuv_pix_formats[] =
+                {V4L2_PIX_FMT_UYVY, V4L2_PIX_FMT_YUYV};
+
+/* register access routines */
+static inline u32 regr(u32 offset)
+{
+        return __raw_readl(ccdc_base_addr + offset);
+}
+
+static inline void regw(u32 val, u32 offset)
+{
+        __raw_writel(val, ccdc_base_addr + offset);
+}
+
+static void ccdc_set_ccdc_base(void *addr, int size)
+{
+        ccdc_base_addr = addr;
+        ccdc_addr_size = size;
+}
+
+static void ccdc_enable(int en)
+{
+        unsigned int temp;
+        temp = regr(SYNCEN);
+        temp &= (~CCDC_SYNCEN_VDHDEN_MASK);
+        temp |= (en & CCDC_SYNCEN_VDHDEN_MASK);
+        regw(temp, SYNCEN);
+}
+
+static void ccdc_enable_output_to_sdram(int en)
+{
+        unsigned int temp;
+        temp = regr(SYNCEN);
+        temp &= (~(CCDC_SYNCEN_WEN_MASK));
+        temp |= ((en << CCDC_SYNCEN_WEN_SHIFT) & CCDC_SYNCEN_WEN_MASK);
+        regw(temp, SYNCEN);
+}
+
+static void ccdc_config_gain_offset(void)
+{
+        /* configure gain */
+        regw(ccdc_hw_params_raw.gain.r_ye, RYEGAIN);
+        regw(ccdc_hw_params_raw.gain.gr_cy, GRCYGAIN);
+        regw(ccdc_hw_params_raw.gain.gb_g, GBGGAIN);
+        regw(ccdc_hw_params_raw.gain.b_mg, BMGGAIN);
+        /* configure offset */
+        regw(ccdc_hw_params_raw.ccdc_offset, OFFSET);
+}
+
+/*
+ * ccdc_restore_defaults()
+ * This function restore power on defaults in the ccdc registers
+ */
+static int ccdc_restore_defaults(void)
+{
+        int i;
+
+        dev_dbg(dev, "\nstarting ccdc_restore_defaults...");
+        /* set all registers to zero */
+        for (i = 0; i <= CCDC_REG_LAST; i += 4)
+                regw(0, i);
+
+        /* now override the values with power on defaults in registers */
+        regw(MODESET_DEFAULT, MODESET);
+        /* no culling support */
+        regw(CULH_DEFAULT, CULH);
+        regw(CULV_DEFAULT, CULV);
+        /* Set default Gain and Offset */
+        ccdc_hw_params_raw.gain.r_ye = GAIN_DEFAULT;
+        ccdc_hw_params_raw.gain.gb_g = GAIN_DEFAULT;
+        ccdc_hw_params_raw.gain.gr_cy = GAIN_DEFAULT;
+        ccdc_hw_params_raw.gain.b_mg = GAIN_DEFAULT;
+        ccdc_config_gain_offset();
+        regw(OUTCLIP_DEFAULT, OUTCLIP);
+        regw(LSCCFG2_DEFAULT, LSCCFG2);
+        /* select ccdc input */
+        if (vpss_select_ccdc_source(VPSS_CCDCIN)) {
+                dev_dbg(dev, "\ncouldn't select ccdc input source");
+                return -EFAULT;
+        }
+        /* select ccdc clock */
+        if (vpss_enable_clock(VPSS_CCDC_CLOCK, 1) < 0) {
+                dev_dbg(dev, "\ncouldn't enable ccdc clock");
+                return -EFAULT;
+        }
+        dev_dbg(dev, "\nEnd of ccdc_restore_defaults...");
+        return 0;
+}
+
+static int ccdc_open(struct device *device)
+{
+        dev = device;
+        return ccdc_restore_defaults();
+}
+
+static int ccdc_close(struct device *device)
+{
+        /* disable clock */
+        vpss_enable_clock(VPSS_CCDC_CLOCK, 0);
+        /* do nothing for now */
+        return 0;
+}
+/*
+ * ccdc_setwin()
+ * This function will configure the window size to
+ * be capture in CCDC reg.
+ */
+static void ccdc_setwin(struct v4l2_rect *image_win,
+                        enum ccdc_frmfmt frm_fmt, int ppc)
+{
+        int horz_start, horz_nr_pixels;
+        int vert_start, vert_nr_lines;
+        int mid_img = 0;
+
+        dev_dbg(dev, "\nStarting ccdc_setwin...");
+
+        /*
+         * ppc - per pixel count. indicates how many pixels per cell
+         * output to SDRAM. example, for ycbcr, it is one y and one c, so 2.
+         * raw capture this is 1
+         */
+        horz_start = image_win->left << (ppc - 1);
+        horz_nr_pixels = ((image_win->width) << (ppc - 1)) - 1;
+
+        /* Writing the horizontal info into the registers */
+        regw(horz_start, SPH);
+        regw(horz_nr_pixels, NPH);
+        vert_start = image_win->top;
+
+        if (frm_fmt == CCDC_FRMFMT_INTERLACED) {
+                vert_nr_lines = (image_win->height >> 1) - 1;
+                vert_start >>= 1;
+                /* Since first line doesn't have any data */
+                vert_start += 1;
+                /* configure VDINT0 and VDINT1 */
+                regw(vert_start, VDINT0);
+        } else {
+                /* Since first line doesn't have any data */
+                vert_start += 1;
+                vert_nr_lines = image_win->height - 1;
+                /* configure VDINT0 and VDINT1 */
+                mid_img = vert_start + (image_win->height / 2);
+                regw(vert_start, VDINT0);
+                regw(mid_img, VDINT1);
+        }
+        regw(vert_start & CCDC_START_VER_ONE_MASK, SLV0);
+        regw(vert_start & CCDC_START_VER_TWO_MASK, SLV1);
+        regw(vert_nr_lines & CCDC_NUM_LINES_VER, NLV);
+        dev_dbg(dev, "\nEnd of ccdc_setwin...");
+}
+
+static int validate_ccdc_param(struct ccdc_config_params_raw *ccdcparam)
+{
+        if (ccdcparam->datasft < CCDC_DATA_NO_SHIFT ||
+            ccdcparam->datasft > CCDC_DATA_SHIFT_6BIT) {
+                dev_dbg(dev, "Invalid value of data shift\n");
+                return -EINVAL;
+        }
+
+        if (ccdcparam->mfilt1 < CCDC_NO_MEDIAN_FILTER1 ||
+            ccdcparam->mfilt1 > CCDC_MEDIAN_FILTER1) {
+                dev_dbg(dev, "Invalid value of median filter1\n");
+                return -EINVAL;
+        }
+
+        if (ccdcparam->mfilt2 < CCDC_NO_MEDIAN_FILTER2 ||
+            ccdcparam->mfilt2 > CCDC_MEDIAN_FILTER2) {
+                dev_dbg(dev, "Invalid value of median filter2\n");
+                return -EINVAL;
+        }
+
+        if ((ccdcparam->med_filt_thres < 0) ||
+           (ccdcparam->med_filt_thres > CCDC_MED_FILT_THRESH)) {
+                dev_dbg(dev, "Invalid value of median filter thresold\n");
+                return -EINVAL;
+        }
+
+        if (ccdcparam->data_sz < CCDC_DATA_16BITS ||
+            ccdcparam->data_sz > CCDC_DATA_8BITS) {
+                dev_dbg(dev, "Invalid value of data size\n");
+                return -EINVAL;
+        }
+
+        if (ccdcparam->alaw.enable) {
+                if (ccdcparam->alaw.gama_wd < CCDC_GAMMA_BITS_13_4 ||
+                    ccdcparam->alaw.gama_wd > CCDC_GAMMA_BITS_09_0) {
+                        dev_dbg(dev, "Invalid value of ALAW\n");
+                        return -EINVAL;
+                }
+        }
+
+        if (ccdcparam->blk_clamp.b_clamp_enable) {
+                if (ccdcparam->blk_clamp.sample_pixel < CCDC_SAMPLE_1PIXELS ||
+                    ccdcparam->blk_clamp.sample_pixel > CCDC_SAMPLE_16PIXELS) {
+                        dev_dbg(dev, "Invalid value of sample pixel\n");
+                        return -EINVAL;
+                }
+                if (ccdcparam->blk_clamp.sample_ln < CCDC_SAMPLE_1LINES ||
+                    ccdcparam->blk_clamp.sample_ln > CCDC_SAMPLE_16LINES) {
+                        dev_dbg(dev, "Invalid value of sample lines\n");
+                        return -EINVAL;
+                }
+        }
+        return 0;
+}
+
+/* Parameter operations */
+static int ccdc_set_params(void __user *params)
+{
+        struct ccdc_config_params_raw ccdc_raw_params;
+        int x;
+
+        /* only raw module parameters can be set through the IOCTL */
+        if (ccdc_if_type != VPFE_RAW_BAYER)
+                return -EINVAL;
+
+        x = copy_from_user(&ccdc_raw_params, params, sizeof(ccdc_raw_params));
+        if (x) {
+                dev_dbg(dev, "ccdc_set_params: error in copying ccdc"
+                        "params, %d\n", x);
+                return -EFAULT;
+        }
+
+        if (!validate_ccdc_param(&ccdc_raw_params)) {
+                memcpy(&ccdc_hw_params_raw.config_params,
+                        &ccdc_raw_params,
+                        sizeof(ccdc_raw_params));
+                return 0;
+        }
+        return -EINVAL;
+}
+
+/* This function will configure CCDC for YCbCr video capture */
+static void ccdc_config_ycbcr(void)
+{
+        struct ccdc_params_ycbcr *params = &ccdc_hw_params_ycbcr;
+        u32 temp;
+
+        /* first set the CCDC power on defaults values in all registers */
+        dev_dbg(dev, "\nStarting ccdc_config_ycbcr...");
+        ccdc_restore_defaults();
+
+        /* configure pixel format & video frame format */
+        temp = (((params->pix_fmt & CCDC_INPUT_MODE_MASK) <<
+                CCDC_INPUT_MODE_SHIFT) |
+                ((params->frm_fmt & CCDC_FRM_FMT_MASK) <<
+                CCDC_FRM_FMT_SHIFT));
+
+        /* setup BT.656 sync mode */
+        if (params->bt656_enable) {
+                regw(CCDC_REC656IF_BT656_EN, REC656IF);
+                /*
+                 * configure the FID, VD, HD pin polarity fld,hd pol positive,
+                 * vd negative, 8-bit pack mode
+                 */
+                temp |= CCDC_VD_POL_NEGATIVE;
+        } else {                /* y/c external sync mode */
+                temp |= (((params->fid_pol & CCDC_FID_POL_MASK) <<
+                        CCDC_FID_POL_SHIFT) |
+                        ((params->hd_pol & CCDC_HD_POL_MASK) <<
+                        CCDC_HD_POL_SHIFT) |
+                        ((params->vd_pol & CCDC_VD_POL_MASK) <<
+                        CCDC_VD_POL_SHIFT));
+        }
+
+        /* pack the data to 8-bit */
+        temp |= CCDC_DATA_PACK_ENABLE;
+
+        regw(temp, MODESET);
+
+        /* configure video window */
+        ccdc_setwin(&params->win, params->frm_fmt, 2);
+
+        /* configure the order of y cb cr in SD-RAM */
+        temp = (params->pix_order << CCDC_Y8POS_SHIFT);
+        temp |= CCDC_LATCH_ON_VSYNC_DISABLE | CCDC_CCDCFG_FIDMD_NO_LATCH_VSYNC;
+        regw(temp, CCDCFG);
+
+        /*
+         * configure the horizontal line offset. This is done by rounding up
+         * width to a multiple of 16 pixels and multiply by two to account for
+         * y:cb:cr 4:2:2 data
+         */
+        regw(((params->win.width * 2 + 31) >> 5), HSIZE);
+
+        /* configure the memory line offset */
+        if (params->buf_type == CCDC_BUFTYPE_FLD_INTERLEAVED) {
+                /* two fields are interleaved in memory */
+                regw(CCDC_SDOFST_FIELD_INTERLEAVED, SDOFST);
+        }
+
+        dev_dbg(dev, "\nEnd of ccdc_config_ycbcr...\n");
+}
+
+/*
+ * ccdc_config_black_clamp()
+ * configure parameters for Optical Black Clamp
+ */
+static void ccdc_config_black_clamp(struct ccdc_black_clamp *bclamp)
+{
+        u32 val;
+
+        if (!bclamp->b_clamp_enable) {
+                /* configure DCSub */
+                regw(bclamp->dc_sub & CCDC_BLK_DC_SUB_MASK, DCSUB);
+                regw(0x0000, CLAMP);
+                return;
+        }
+        /* Enable the Black clamping, set sample lines and pixels */
+        val = (bclamp->start_pixel & CCDC_BLK_ST_PXL_MASK) |
+              ((bclamp->sample_pixel & CCDC_BLK_SAMPLE_LN_MASK) <<
+                CCDC_BLK_SAMPLE_LN_SHIFT) | CCDC_BLK_CLAMP_ENABLE;
+        regw(val, CLAMP);
+
+        /* If Black clamping is enable then make dcsub 0 */
+        val = (bclamp->sample_ln & CCDC_NUM_LINE_CALC_MASK)
+                        << CCDC_NUM_LINE_CALC_SHIFT;
+        regw(val, DCSUB);
+}
+
+/*
+ * ccdc_config_black_compense()
+ * configure parameters for Black Compensation
+ */
+static void ccdc_config_black_compense(struct ccdc_black_compensation *bcomp)
+{
+        u32 val;
+
+        val = (bcomp->b & CCDC_BLK_COMP_MASK) |
+                ((bcomp->gb & CCDC_BLK_COMP_MASK) <<
+                CCDC_BLK_COMP_GB_COMP_SHIFT);
+        regw(val, BLKCMP1);
+
+        val = ((bcomp->gr & CCDC_BLK_COMP_MASK) <<
+                CCDC_BLK_COMP_GR_COMP_SHIFT) |
+                ((bcomp->r & CCDC_BLK_COMP_MASK) <<
+                CCDC_BLK_COMP_R_COMP_SHIFT);
+        regw(val, BLKCMP0);
+}
+
+/*
+ * ccdc_write_dfc_entry()
+ * write an entry in the dfc table.
+ */
+int ccdc_write_dfc_entry(int index, struct ccdc_vertical_dft *dfc)
+{
+/* TODO This is to be re-visited and adjusted */
+#define DFC_WRITE_WAIT_COUNT    1000
+        u32 val, count = DFC_WRITE_WAIT_COUNT;
+
+        regw(dfc->dft_corr_vert[index], DFCMEM0);
+        regw(dfc->dft_corr_horz[index], DFCMEM1);
+        regw(dfc->dft_corr_sub1[index], DFCMEM2);
+        regw(dfc->dft_corr_sub2[index], DFCMEM3);
+        regw(dfc->dft_corr_sub3[index], DFCMEM4);
+        /* set WR bit to write */
+        val = regr(DFCMEMCTL) | CCDC_DFCMEMCTL_DFCMWR_MASK;
+        regw(val, DFCMEMCTL);
+
+        /*
+         * Assume, it is very short. If we get an error, we need to
+         * adjust this value
+         */
+        while (regr(DFCMEMCTL) & CCDC_DFCMEMCTL_DFCMWR_MASK)
+                count--;
+        /*
+         * TODO We expect the count to be non-zero to be successful. Adjust
+         * the count if write requires more time
+         */
+
+        if (count) {
+                dev_err(dev, "defect table write timeout !!!\n");
+                return -1;
+        }
+        return 0;
+}
+
+/*
+ * ccdc_config_vdfc()
+ * configure parameters for Vertical Defect Correction
+ */
+static int ccdc_config_vdfc(struct ccdc_vertical_dft *dfc)
+{
+        u32 val;
+        int i;
+
+        /* Configure General Defect Correction. The table used is from IPIPE */
+        val = dfc->gen_dft_en & CCDC_DFCCTL_GDFCEN_MASK;
+
+        /* Configure Vertical Defect Correction if needed */
+        if (!dfc->ver_dft_en) {
+                /* Enable only General Defect Correction */
+                regw(val, DFCCTL);
+                return 0;
+        }
+
+        if (dfc->table_size > CCDC_DFT_TABLE_SIZE)
+                return -EINVAL;
+
+        val |= CCDC_DFCCTL_VDFC_DISABLE;
+        val |= (dfc->dft_corr_ctl.vdfcsl & CCDC_DFCCTL_VDFCSL_MASK) <<
+                CCDC_DFCCTL_VDFCSL_SHIFT;
+        val |= (dfc->dft_corr_ctl.vdfcuda & CCDC_DFCCTL_VDFCUDA_MASK) <<
+                CCDC_DFCCTL_VDFCUDA_SHIFT;
+        val |= (dfc->dft_corr_ctl.vdflsft & CCDC_DFCCTL_VDFLSFT_MASK) <<
+                CCDC_DFCCTL_VDFLSFT_SHIFT;
+        regw(val , DFCCTL);
+
+        /* clear address ptr to offset 0 */
+        val = CCDC_DFCMEMCTL_DFCMARST_MASK << CCDC_DFCMEMCTL_DFCMARST_SHIFT;
+
+        /* write defect table entries */
+        for (i = 0; i < dfc->table_size; i++) {
+                /* increment address for non zero index */
+                if (i != 0)
+                        val = CCDC_DFCMEMCTL_INC_ADDR;
+                regw(val, DFCMEMCTL);
+                if (ccdc_write_dfc_entry(i, dfc) < 0)
+                        return -EFAULT;
+        }
+
+        /* update saturation level and enable dfc */
+        regw(dfc->saturation_ctl & CCDC_VDC_DFCVSAT_MASK, DFCVSAT);
+        val = regr(DFCCTL) | (CCDC_DFCCTL_VDFCEN_MASK <<
+                        CCDC_DFCCTL_VDFCEN_SHIFT);
+        regw(val, DFCCTL);
+        return 0;
+}
+
+/*
+ * ccdc_config_csc()
+ * configure parameters for color space conversion
+ * Each register CSCM0-7 has two values in S8Q5 format.
+ */
+static void ccdc_config_csc(struct ccdc_csc *csc)
+{
+        u32 val1, val2;
+        int i;
+
+        if (!csc->enable)
+                return;
+
+        /* Enable the CSC sub-module */
+        regw(CCDC_CSC_ENABLE, CSCCTL);
+
+        /* Converting the co-eff as per the format of the register */
+        for (i = 0; i < CCDC_CSC_COEFF_TABLE_SIZE; i++) {
+                if ((i % 2) == 0) {
+                        /* CSCM - LSB */
+                        val1 = (csc->coeff[i].integer &
+                                CCDC_CSC_COEF_INTEG_MASK)
+                                << CCDC_CSC_COEF_INTEG_SHIFT;
+                        /*
+                         * convert decimal part to binary. Use 2 decimal
+                         * precision, user values range from .00 - 0.99
+                         */
+                        val1 |= (((csc->coeff[i].decimal &
+                                CCDC_CSC_COEF_DECIMAL_MASK) *
+                                CCDC_CSC_DEC_MAX) / 100);
+                } else {
+
+                        /* CSCM - MSB */
+                        val2 = (csc->coeff[i].integer &
+                                CCDC_CSC_COEF_INTEG_MASK)
+                                << CCDC_CSC_COEF_INTEG_SHIFT;
+                        val2 |= (((csc->coeff[i].decimal &
+                                 CCDC_CSC_COEF_DECIMAL_MASK) *
+                                 CCDC_CSC_DEC_MAX) / 100);
+                        val2 <<= CCDC_CSCM_MSB_SHIFT;
+                        val2 |= val1;
+                        regw(val2, (CSCM0 + ((i - 1) << 1)));
+                }
+        }
+}
+
+/*
+ * ccdc_config_color_patterns()
+ * configure parameters for color patterns
+ */
+static void ccdc_config_color_patterns(struct ccdc_col_pat *pat0,
+                                       struct ccdc_col_pat *pat1)
+{
+        u32 val;
+
+        val = (pat0->olop | (pat0->olep << 2) | (pat0->elop << 4) |
+                (pat0->elep << 6) | (pat1->olop << 8) | (pat1->olep << 10) |
+                (pat1->elop << 12) | (pat1->elep << 14));
+        regw(val, COLPTN);
+}
+
+/* This function will configure CCDC for Raw mode image capture */
+static int ccdc_config_raw(void)
+{
+        struct ccdc_params_raw *params = &ccdc_hw_params_raw;
+        struct ccdc_config_params_raw *config_params =
+                &ccdc_hw_params_raw.config_params;
+        unsigned int val;
+
+        dev_dbg(dev, "\nStarting ccdc_config_raw...");
+
+        /* restore power on defaults to register */
+        ccdc_restore_defaults();
+
+        /* CCDCFG register:
+         * set CCD Not to swap input since input is RAW data
+         * set FID detection function to Latch at V-Sync
+         * set WENLOG - ccdc valid area to AND
+         * set TRGSEL to WENBIT
+         * set EXTRG to DISABLE
+         * disable latching function on VSYNC - shadowed registers
+         */
+        regw(CCDC_YCINSWP_RAW | CCDC_CCDCFG_FIDMD_LATCH_VSYNC |
+             CCDC_CCDCFG_WENLOG_AND | CCDC_CCDCFG_TRGSEL_WEN |
+             CCDC_CCDCFG_EXTRG_DISABLE | CCDC_LATCH_ON_VSYNC_DISABLE, CCDCFG);
+
+        /*
+         * Set VDHD direction to input,  input type to raw input
+         * normal data polarity, do not use external WEN
+         */
+        val = (CCDC_VDHDOUT_INPUT | CCDC_RAW_IP_MODE | CCDC_DATAPOL_NORMAL |
+                CCDC_EXWEN_DISABLE);
+
+        /*
+         * Configure the vertical sync polarity (MODESET.VDPOL), horizontal
+         * sync polarity (MODESET.HDPOL), field id polarity (MODESET.FLDPOL),
+         * frame format(progressive or interlace), & pixel format (Input mode)
+         */
+        val |= (((params->vd_pol & CCDC_VD_POL_MASK) << CCDC_VD_POL_SHIFT) |
+                ((params->hd_pol & CCDC_HD_POL_MASK) << CCDC_HD_POL_SHIFT) |
+                ((params->fid_pol & CCDC_FID_POL_MASK) << CCDC_FID_POL_SHIFT) |
+                ((params->frm_fmt & CCDC_FRM_FMT_MASK) << CCDC_FRM_FMT_SHIFT) |
+                ((params->pix_fmt & CCDC_PIX_FMT_MASK) << CCDC_PIX_FMT_SHIFT));
+
+        /* set pack for alaw compression */
+        if ((config_params->data_sz == CCDC_DATA_8BITS) ||
+             config_params->alaw.enable)
+                val |= CCDC_DATA_PACK_ENABLE;
+
+        /* Configure for LPF */
+        if (config_params->lpf_enable)
+                val |= (config_params->lpf_enable & CCDC_LPF_MASK) <<
+                        CCDC_LPF_SHIFT;
+
+        /* Configure the data shift */
+        val |= (config_params->datasft & CCDC_DATASFT_MASK) <<
+                CCDC_DATASFT_SHIFT;
+        regw(val , MODESET);
+        dev_dbg(dev, "\nWriting 0x%x to MODESET...\n", val);
+
+        /* Configure the Median Filter threshold */
+        regw((config_params->med_filt_thres) & CCDC_MED_FILT_THRESH, MEDFILT);
+
+        /* Configure GAMMAWD register. defaur 11-2, and Mosaic cfa pattern */
+        val = CCDC_GAMMA_BITS_11_2 << CCDC_GAMMAWD_INPUT_SHIFT |
+                CCDC_CFA_MOSAIC;
+
+        /* Enable and configure aLaw register if needed */
+        if (config_params->alaw.enable) {
+                val |= (CCDC_ALAW_ENABLE |
+                        ((config_params->alaw.gama_wd &
+                        CCDC_ALAW_GAMA_WD_MASK) <<
+                        CCDC_GAMMAWD_INPUT_SHIFT));
+        }
+
+        /* Configure Median filter1 & filter2 */
+        val |= ((config_params->mfilt1 << CCDC_MFILT1_SHIFT) |
+                (config_params->mfilt2 << CCDC_MFILT2_SHIFT));
+
+        regw(val, GAMMAWD);
+        dev_dbg(dev, "\nWriting 0x%x to GAMMAWD...\n", val);
+
+        /* configure video window */
+        ccdc_setwin(&params->win, params->frm_fmt, 1);
+
+        /* Optical Clamp Averaging */
+        ccdc_config_black_clamp(&config_params->blk_clamp);
+
+        /* Black level compensation */
+        ccdc_config_black_compense(&config_params->blk_comp);
+
+        /* Vertical Defect Correction if needed */
+        if (ccdc_config_vdfc(&config_params->vertical_dft) < 0)
+                return -EFAULT;
+
+        /* color space conversion */
+        ccdc_config_csc(&config_params->csc);
+
+        /* color pattern */
+        ccdc_config_color_patterns(&config_params->col_pat_field0,
+                                   &config_params->col_pat_field1);
+
+        /* Configure the Gain  & offset control */
+        ccdc_config_gain_offset();
+
+        dev_dbg(dev, "\nWriting %x to COLPTN...\n", val);
+
+        /* Configure DATAOFST  register */
+        val = (config_params->data_offset.horz_offset & CCDC_DATAOFST_MASK) <<
+                CCDC_DATAOFST_H_SHIFT;
+        val |= (config_params->data_offset.vert_offset & CCDC_DATAOFST_MASK) <<
+                CCDC_DATAOFST_V_SHIFT;
+        regw(val, DATAOFST);
+
+        /* configuring HSIZE register */
+        val = (params->horz_flip_enable & CCDC_HSIZE_FLIP_MASK) <<
+                CCDC_HSIZE_FLIP_SHIFT;
+
+        /* If pack 8 is enable then 1 pixel will take 1 byte */
+        if ((config_params->data_sz == CCDC_DATA_8BITS) ||
+             config_params->alaw.enable) {
+                val |= (((params->win.width) + 31) >> 5) &
+                        CCDC_HSIZE_VAL_MASK;
+
+                /* adjust to multiple of 32 */
+                dev_dbg(dev, "\nWriting 0x%x to HSIZE...\n",
+                       (((params->win.width) + 31) >> 5) &
+                        CCDC_HSIZE_VAL_MASK);
+        } else {
+                /* else one pixel will take 2 byte */
+                val |= (((params->win.width * 2) + 31) >> 5) &
+                        CCDC_HSIZE_VAL_MASK;
+
+                dev_dbg(dev, "\nWriting 0x%x to HSIZE...\n",
+                       (((params->win.width * 2) + 31) >> 5) &
+                        CCDC_HSIZE_VAL_MASK);
+        }
+        regw(val, HSIZE);
+
+        /* Configure SDOFST register */
+        if (params->frm_fmt == CCDC_FRMFMT_INTERLACED) {
+                if (params->image_invert_enable) {
+                        /* For interlace inverse mode */
+                        regw(CCDC_SDOFST_INTERLACE_INVERSE, SDOFST);
+                        dev_dbg(dev, "\nWriting %x to SDOFST...\n",
+                                CCDC_SDOFST_INTERLACE_INVERSE);
+                } else {
+                        /* For interlace non inverse mode */
+                        regw(CCDC_SDOFST_INTERLACE_NORMAL, SDOFST);
+                        dev_dbg(dev, "\nWriting %x to SDOFST...\n",
+                                CCDC_SDOFST_INTERLACE_NORMAL);
+                }
+        } else if (params->frm_fmt == CCDC_FRMFMT_PROGRESSIVE) {
+                if (params->image_invert_enable) {
+                        /* For progessive inverse mode */
+                        regw(CCDC_SDOFST_PROGRESSIVE_INVERSE, SDOFST);
+                        dev_dbg(dev, "\nWriting %x to SDOFST...\n",
+                                CCDC_SDOFST_PROGRESSIVE_INVERSE);
+                } else {
+                        /* For progessive non inverse mode */
+                        regw(CCDC_SDOFST_PROGRESSIVE_NORMAL, SDOFST);
+                        dev_dbg(dev, "\nWriting %x to SDOFST...\n",
+                                CCDC_SDOFST_PROGRESSIVE_NORMAL);
+                }
+        }
+        dev_dbg(dev, "\nend of ccdc_config_raw...");
+        return 0;
+}
+
+static int ccdc_configure(void)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                return ccdc_config_raw();
+        else
+                ccdc_config_ycbcr();
+        return 0;
+}
+
+static int ccdc_set_buftype(enum ccdc_buftype buf_type)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                ccdc_hw_params_raw.buf_type = buf_type;
+        else
+                ccdc_hw_params_ycbcr.buf_type = buf_type;
+        return 0;
+}
+static enum ccdc_buftype ccdc_get_buftype(void)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                return ccdc_hw_params_raw.buf_type;
+        return ccdc_hw_params_ycbcr.buf_type;
+}
+
+static int ccdc_enum_pix(u32 *pix, int i)
+{
+        int ret = -EINVAL;
+        if (ccdc_if_type == VPFE_RAW_BAYER) {
+                if (i < ARRAY_SIZE(ccdc_raw_bayer_pix_formats)) {
+                        *pix = ccdc_raw_bayer_pix_formats[i];
+                        ret = 0;
+                }
+        } else {
+                if (i < ARRAY_SIZE(ccdc_raw_yuv_pix_formats)) {
+                        *pix = ccdc_raw_yuv_pix_formats[i];
+                        ret = 0;
+                }
+        }
+        return ret;
+}
+
+static int ccdc_set_pixel_format(u32 pixfmt)
+{
+        struct ccdc_a_law *alaw =
+                &ccdc_hw_params_raw.config_params.alaw;
+
+        if (ccdc_if_type == VPFE_RAW_BAYER) {
+                ccdc_hw_params_raw.pix_fmt = CCDC_PIXFMT_RAW;
+                if (pixfmt == V4L2_PIX_FMT_SBGGR8)
+                        alaw->enable = 1;
+                else if (pixfmt != V4L2_PIX_FMT_SBGGR16)
+                        return -EINVAL;
+        } else {
+                if (pixfmt == V4L2_PIX_FMT_YUYV)
+                        ccdc_hw_params_ycbcr.pix_order = CCDC_PIXORDER_YCBYCR;
+                else if (pixfmt == V4L2_PIX_FMT_UYVY)
+                        ccdc_hw_params_ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
+                else
+                        return -EINVAL;
+        }
+        return 0;
+}
+static u32 ccdc_get_pixel_format(void)
+{
+        struct ccdc_a_law *alaw =
+                &ccdc_hw_params_raw.config_params.alaw;
+        u32 pixfmt;
+
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                if (alaw->enable)
+                        pixfmt = V4L2_PIX_FMT_SBGGR8;
+                else
+                        pixfmt = V4L2_PIX_FMT_SBGGR16;
+        else {
+                if (ccdc_hw_params_ycbcr.pix_order == CCDC_PIXORDER_YCBYCR)
+                        pixfmt = V4L2_PIX_FMT_YUYV;
+                else
+                        pixfmt = V4L2_PIX_FMT_UYVY;
+        }
+        return pixfmt;
+}
+static int ccdc_set_image_window(struct v4l2_rect *win)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                ccdc_hw_params_raw.win = *win;
+        else
+                ccdc_hw_params_ycbcr.win = *win;
+        return 0;
+}
+
+static void ccdc_get_image_window(struct v4l2_rect *win)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                *win = ccdc_hw_params_raw.win;
+        else
+                *win = ccdc_hw_params_ycbcr.win;
+}
+
+static unsigned int ccdc_get_line_length(void)
+{
+        struct ccdc_config_params_raw *config_params =
+                &ccdc_hw_params_raw.config_params;
+        unsigned int len;
+
+        if (ccdc_if_type == VPFE_RAW_BAYER) {
+                if ((config_params->alaw.enable) ||
+                    (config_params->data_sz == CCDC_DATA_8BITS))
+                        len = ccdc_hw_params_raw.win.width;
+                else
+                        len = ccdc_hw_params_raw.win.width * 2;
+        } else
+                len = ccdc_hw_params_ycbcr.win.width * 2;
+        return ALIGN(len, 32);
+}
+
+static int ccdc_set_frame_format(enum ccdc_frmfmt frm_fmt)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                ccdc_hw_params_raw.frm_fmt = frm_fmt;
+        else
+                ccdc_hw_params_ycbcr.frm_fmt = frm_fmt;
+        return 0;
+}
+
+static enum ccdc_frmfmt ccdc_get_frame_format(void)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                return ccdc_hw_params_raw.frm_fmt;
+        else
+                return ccdc_hw_params_ycbcr.frm_fmt;
+}
+
+static int ccdc_getfid(void)
+{
+        return  (regr(MODESET) >> 15) & 1;
+}
+
+/* misc operations */
+static inline void ccdc_setfbaddr(unsigned long addr)
+{
+        regw((addr >> 21) & 0x007f, STADRH);
+        regw((addr >> 5) & 0x0ffff, STADRL);
+}
+
+static int ccdc_set_hw_if_params(struct vpfe_hw_if_param *params)
+{
+        ccdc_if_type = params->if_type;
+
+        switch (params->if_type) {
+        case VPFE_BT656:
+        case VPFE_YCBCR_SYNC_16:
+        case VPFE_YCBCR_SYNC_8:
+                ccdc_hw_params_ycbcr.vd_pol = params->vdpol;
+                ccdc_hw_params_ycbcr.hd_pol = params->hdpol;
+                break;
+        default:
+                /* TODO add support for raw bayer here */
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static struct ccdc_hw_device ccdc_hw_dev = {
+        .name = "DM355 CCDC",
+        .owner = THIS_MODULE,
+        .hw_ops = {
+                .open = ccdc_open,
+                .close = ccdc_close,
+                .set_ccdc_base = ccdc_set_ccdc_base,
+                .enable = ccdc_enable,
+                .enable_out_to_sdram = ccdc_enable_output_to_sdram,
+                .set_hw_if_params = ccdc_set_hw_if_params,
+                .set_params = ccdc_set_params,
+                .configure = ccdc_configure,
+                .set_buftype = ccdc_set_buftype,
+                .get_buftype = ccdc_get_buftype,
+                .enum_pix = ccdc_enum_pix,
+                .set_pixel_format = ccdc_set_pixel_format,
+                .get_pixel_format = ccdc_get_pixel_format,
+                .set_frame_format = ccdc_set_frame_format,
+                .get_frame_format = ccdc_get_frame_format,
+                .set_image_window = ccdc_set_image_window,
+                .get_image_window = ccdc_get_image_window,
+                .get_line_length = ccdc_get_line_length,
+                .setfbaddr = ccdc_setfbaddr,
+                .getfid = ccdc_getfid,
+        },
+};
+
+static int dm355_ccdc_init(void)
+{
+        printk(KERN_NOTICE "dm355_ccdc_init\n");
+        if (vpfe_register_ccdc_device(&ccdc_hw_dev) < 0)
+                return -1;
+        printk(KERN_NOTICE "%s is registered with vpfe.\n",
+                ccdc_hw_dev.name);
+        return 0;
+}
+
+static void dm355_ccdc_exit(void)
+{
+        vpfe_unregister_ccdc_device(&ccdc_hw_dev);
+}
+
+module_init(dm355_ccdc_init);
+module_exit(dm355_ccdc_exit);
diff --git a/drivers/media/video/davinci/dm355_ccdc_regs.h b/drivers/media/video/davinci/dm355_ccdc_regs.h
new file mode 100644
index 000000000000..d6d2ef0533b5
--- /dev/null
+++ b/drivers/media/video/davinci/dm355_ccdc_regs.h
@@ -0,0 +1,310 @@
+/*
+ * Copyright (C) 2005-2009 Texas Instruments Inc
+ *
+ * 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
+ */
+#ifndef _DM355_CCDC_REGS_H
+#define _DM355_CCDC_REGS_H
+
+/**************************************************************************\
+* Register OFFSET Definitions
+\**************************************************************************/
+#define SYNCEN                          0x00
+#define MODESET                         0x04
+#define HDWIDTH                         0x08
+#define VDWIDTH                         0x0c
+#define PPLN                            0x10
+#define LPFR                            0x14
+#define SPH                             0x18
+#define NPH                             0x1c
+#define SLV0                            0x20
+#define SLV1                            0x24
+#define NLV                             0x28
+#define CULH                            0x2c
+#define CULV                            0x30
+#define HSIZE                           0x34
+#define SDOFST                          0x38
+#define STADRH                          0x3c
+#define STADRL                          0x40
+#define CLAMP                           0x44
+#define DCSUB                           0x48
+#define COLPTN                          0x4c
+#define BLKCMP0                         0x50
+#define BLKCMP1                         0x54
+#define MEDFILT                         0x58
+#define RYEGAIN                         0x5c
+#define GRCYGAIN                        0x60
+#define GBGGAIN                         0x64
+#define BMGGAIN                         0x68
+#define OFFSET                          0x6c
+#define OUTCLIP                         0x70
+#define VDINT0                          0x74
+#define VDINT1                          0x78
+#define RSV0                            0x7c
+#define GAMMAWD                         0x80
+#define REC656IF                        0x84
+#define CCDCFG                          0x88
+#define FMTCFG                          0x8c
+#define FMTPLEN                         0x90
+#define FMTSPH                          0x94
+#define FMTLNH                          0x98
+#define FMTSLV                          0x9c
+#define FMTLNV                          0xa0
+#define FMTRLEN                         0xa4
+#define FMTHCNT                         0xa8
+#define FMT_ADDR_PTR_B                  0xac
+#define FMT_ADDR_PTR(i)                 (FMT_ADDR_PTR_B + (i * 4))
+#define FMTPGM_VF0                      0xcc
+#define FMTPGM_VF1                      0xd0
+#define FMTPGM_AP0                      0xd4
+#define FMTPGM_AP1                      0xd8
+#define FMTPGM_AP2                      0xdc
+#define FMTPGM_AP3                      0xe0
+#define FMTPGM_AP4                      0xe4
+#define FMTPGM_AP5                      0xe8
+#define FMTPGM_AP6                      0xec
+#define FMTPGM_AP7                      0xf0
+#define LSCCFG1                         0xf4
+#define LSCCFG2                         0xf8
+#define LSCH0                           0xfc
+#define LSCV0                           0x100
+#define LSCKH                           0x104
+#define LSCKV                           0x108
+#define LSCMEMCTL                       0x10c
+#define LSCMEMD                         0x110
+#define LSCMEMQ                         0x114
+#define DFCCTL                          0x118
+#define DFCVSAT                         0x11c
+#define DFCMEMCTL                       0x120
+#define DFCMEM0                         0x124
+#define DFCMEM1                         0x128
+#define DFCMEM2                         0x12c
+#define DFCMEM3                         0x130
+#define DFCMEM4                         0x134
+#define CSCCTL                          0x138
+#define CSCM0                           0x13c
+#define CSCM1                           0x140
+#define CSCM2                           0x144
+#define CSCM3                           0x148
+#define CSCM4                           0x14c
+#define CSCM5                           0x150
+#define CSCM6                           0x154
+#define CSCM7                           0x158
+#define DATAOFST                        0x15c
+#define CCDC_REG_LAST                   DATAOFST
+/**************************************************************
+*       Define for various register bit mask and shifts for CCDC
+*
+**************************************************************/
+#define CCDC_RAW_IP_MODE                        0
+#define CCDC_VDHDOUT_INPUT                      0
+#define CCDC_YCINSWP_RAW                        (0 << 4)
+#define CCDC_EXWEN_DISABLE                      0
+#define CCDC_DATAPOL_NORMAL                     0
+#define CCDC_CCDCFG_FIDMD_LATCH_VSYNC           0
+#define CCDC_CCDCFG_FIDMD_NO_LATCH_VSYNC        (1 << 6)
+#define CCDC_CCDCFG_WENLOG_AND                  0
+#define CCDC_CCDCFG_TRGSEL_WEN                  0
+#define CCDC_CCDCFG_EXTRG_DISABLE               0
+#define CCDC_CFA_MOSAIC                         0
+#define CCDC_Y8POS_SHIFT                        11
+
+#define CCDC_VDC_DFCVSAT_MASK                   0x3fff
+#define CCDC_DATAOFST_MASK                      0x0ff
+#define CCDC_DATAOFST_H_SHIFT                   0
+#define CCDC_DATAOFST_V_SHIFT                   8
+#define CCDC_GAMMAWD_CFA_MASK                   1
+#define CCDC_GAMMAWD_CFA_SHIFT                  5
+#define CCDC_GAMMAWD_INPUT_SHIFT                2
+#define CCDC_FID_POL_MASK                       1
+#define CCDC_FID_POL_SHIFT                      4
+#define CCDC_HD_POL_MASK                        1
+#define CCDC_HD_POL_SHIFT                       3
+#define CCDC_VD_POL_MASK                        1
+#define CCDC_VD_POL_SHIFT                       2
+#define CCDC_VD_POL_NEGATIVE                    (1 << 2)
+#define CCDC_FRM_FMT_MASK                       1
+#define CCDC_FRM_FMT_SHIFT                      7
+#define CCDC_DATA_SZ_MASK                       7
+#define CCDC_DATA_SZ_SHIFT                      8
+#define CCDC_VDHDOUT_MASK                       1
+#define CCDC_VDHDOUT_SHIFT                      0
+#define CCDC_EXWEN_MASK                         1
+#define CCDC_EXWEN_SHIFT                        5
+#define CCDC_INPUT_MODE_MASK                    3
+#define CCDC_INPUT_MODE_SHIFT                   12
+#define CCDC_PIX_FMT_MASK                       3
+#define CCDC_PIX_FMT_SHIFT                      12
+#define CCDC_DATAPOL_MASK                       1
+#define CCDC_DATAPOL_SHIFT                      6
+#define CCDC_WEN_ENABLE                         (1 << 1)
+#define CCDC_VDHDEN_ENABLE                      (1 << 16)
+#define CCDC_LPF_ENABLE                         (1 << 14)
+#define CCDC_ALAW_ENABLE                        1
+#define CCDC_ALAW_GAMA_WD_MASK                  7
+#define CCDC_REC656IF_BT656_EN                  3
+
+#define CCDC_FMTCFG_FMTMODE_MASK                3
+#define CCDC_FMTCFG_FMTMODE_SHIFT               1
+#define CCDC_FMTCFG_LNUM_MASK                   3
+#define CCDC_FMTCFG_LNUM_SHIFT                  4
+#define CCDC_FMTCFG_ADDRINC_MASK                7
+#define CCDC_FMTCFG_ADDRINC_SHIFT               8
+
+#define CCDC_CCDCFG_FIDMD_SHIFT                 6
+#define CCDC_CCDCFG_WENLOG_SHIFT                8
+#define CCDC_CCDCFG_TRGSEL_SHIFT                9
+#define CCDC_CCDCFG_EXTRG_SHIFT                 10
+#define CCDC_CCDCFG_MSBINVI_SHIFT               13
+
+#define CCDC_HSIZE_FLIP_SHIFT                   12
+#define CCDC_HSIZE_FLIP_MASK                    1
+#define CCDC_HSIZE_VAL_MASK                     0xFFF
+#define CCDC_SDOFST_FIELD_INTERLEAVED           0x249
+#define CCDC_SDOFST_INTERLACE_INVERSE           0x4B6D
+#define CCDC_SDOFST_INTERLACE_NORMAL            0x0B6D
+#define CCDC_SDOFST_PROGRESSIVE_INVERSE         0x4000
+#define CCDC_SDOFST_PROGRESSIVE_NORMAL          0
+#define CCDC_START_PX_HOR_MASK                  0x7FFF
+#define CCDC_NUM_PX_HOR_MASK                    0x7FFF
+#define CCDC_START_VER_ONE_MASK                 0x7FFF
+#define CCDC_START_VER_TWO_MASK                 0x7FFF
+#define CCDC_NUM_LINES_VER                      0x7FFF
+
+#define CCDC_BLK_CLAMP_ENABLE                   (1 << 15)
+#define CCDC_BLK_SGAIN_MASK                     0x1F
+#define CCDC_BLK_ST_PXL_MASK                    0x1FFF
+#define CCDC_BLK_SAMPLE_LN_MASK                 3
+#define CCDC_BLK_SAMPLE_LN_SHIFT                13
+
+#define CCDC_NUM_LINE_CALC_MASK                 3
+#define CCDC_NUM_LINE_CALC_SHIFT                14
+
+#define CCDC_BLK_DC_SUB_MASK                    0x3FFF
+#define CCDC_BLK_COMP_MASK                      0xFF
+#define CCDC_BLK_COMP_GB_COMP_SHIFT             8
+#define CCDC_BLK_COMP_GR_COMP_SHIFT             0
+#define CCDC_BLK_COMP_R_COMP_SHIFT              8
+#define CCDC_LATCH_ON_VSYNC_DISABLE             (1 << 15)
+#define CCDC_LATCH_ON_VSYNC_ENABLE              (0 << 15)
+#define CCDC_FPC_ENABLE                         (1 << 15)
+#define CCDC_FPC_FPC_NUM_MASK                   0x7FFF
+#define CCDC_DATA_PACK_ENABLE                   (1 << 11)
+#define CCDC_FMT_HORZ_FMTLNH_MASK               0x1FFF
+#define CCDC_FMT_HORZ_FMTSPH_MASK               0x1FFF
+#define CCDC_FMT_HORZ_FMTSPH_SHIFT              16
+#define CCDC_FMT_VERT_FMTLNV_MASK               0x1FFF
+#define CCDC_FMT_VERT_FMTSLV_MASK               0x1FFF
+#define CCDC_FMT_VERT_FMTSLV_SHIFT              16
+#define CCDC_VP_OUT_VERT_NUM_MASK               0x3FFF
+#define CCDC_VP_OUT_VERT_NUM_SHIFT              17
+#define CCDC_VP_OUT_HORZ_NUM_MASK               0x1FFF
+#define CCDC_VP_OUT_HORZ_NUM_SHIFT              4
+#define CCDC_VP_OUT_HORZ_ST_MASK                0xF
+
+#define CCDC_CSC_COEF_INTEG_MASK                7
+#define CCDC_CSC_COEF_DECIMAL_MASK              0x1f
+#define CCDC_CSC_COEF_INTEG_SHIFT               5
+#define CCDC_CSCM_MSB_SHIFT                     8
+#define CCDC_CSC_ENABLE                         1
+#define CCDC_CSC_DEC_MAX                        32
+
+#define CCDC_MFILT1_SHIFT                       10
+#define CCDC_MFILT2_SHIFT                       8
+#define CCDC_MED_FILT_THRESH                    0x3FFF
+#define CCDC_LPF_MASK                           1
+#define CCDC_LPF_SHIFT                          14
+#define CCDC_OFFSET_MASK                        0x3FF
+#define CCDC_DATASFT_MASK                       7
+#define CCDC_DATASFT_SHIFT                      8
+
+#define CCDC_DF_ENABLE                          1
+
+#define CCDC_FMTPLEN_P0_MASK                    0xF
+#define CCDC_FMTPLEN_P1_MASK                    0xF
+#define CCDC_FMTPLEN_P2_MASK                    7
+#define CCDC_FMTPLEN_P3_MASK                    7
+#define CCDC_FMTPLEN_P0_SHIFT                   0
+#define CCDC_FMTPLEN_P1_SHIFT                   4
+#define CCDC_FMTPLEN_P2_SHIFT                   8
+#define CCDC_FMTPLEN_P3_SHIFT                   12
+
+#define CCDC_FMTSPH_MASK                        0x1FFF
+#define CCDC_FMTLNH_MASK                        0x1FFF
+#define CCDC_FMTSLV_MASK                        0x1FFF
+#define CCDC_FMTLNV_MASK                        0x7FFF
+#define CCDC_FMTRLEN_MASK                       0x1FFF
+#define CCDC_FMTHCNT_MASK                       0x1FFF
+
+#define CCDC_ADP_INIT_MASK                      0x1FFF
+#define CCDC_ADP_LINE_SHIFT                     13
+#define CCDC_ADP_LINE_MASK                      3
+#define CCDC_FMTPGN_APTR_MASK                   7
+
+#define CCDC_DFCCTL_GDFCEN_MASK                 1
+#define CCDC_DFCCTL_VDFCEN_MASK                 1
+#define CCDC_DFCCTL_VDFC_DISABLE                (0 << 4)
+#define CCDC_DFCCTL_VDFCEN_SHIFT                4
+#define CCDC_DFCCTL_VDFCSL_MASK                 3
+#define CCDC_DFCCTL_VDFCSL_SHIFT                5
+#define CCDC_DFCCTL_VDFCUDA_MASK                1
+#define CCDC_DFCCTL_VDFCUDA_SHIFT               7
+#define CCDC_DFCCTL_VDFLSFT_MASK                3
+#define CCDC_DFCCTL_VDFLSFT_SHIFT               8
+#define CCDC_DFCMEMCTL_DFCMARST_MASK            1
+#define CCDC_DFCMEMCTL_DFCMARST_SHIFT           2
+#define CCDC_DFCMEMCTL_DFCMWR_MASK              1
+#define CCDC_DFCMEMCTL_DFCMWR_SHIFT             0
+#define CCDC_DFCMEMCTL_INC_ADDR                 (0 << 2)
+
+#define CCDC_LSCCFG_GFTSF_MASK                  7
+#define CCDC_LSCCFG_GFTSF_SHIFT                 1
+#define CCDC_LSCCFG_GFTINV_MASK                 0xf
+#define CCDC_LSCCFG_GFTINV_SHIFT                4
+#define CCDC_LSC_GFTABLE_SEL_MASK               3
+#define CCDC_LSC_GFTABLE_EPEL_SHIFT             8
+#define CCDC_LSC_GFTABLE_OPEL_SHIFT             10
+#define CCDC_LSC_GFTABLE_EPOL_SHIFT             12
+#define CCDC_LSC_GFTABLE_OPOL_SHIFT             14
+#define CCDC_LSC_GFMODE_MASK                    3
+#define CCDC_LSC_GFMODE_SHIFT                   4
+#define CCDC_LSC_DISABLE                        0
+#define CCDC_LSC_ENABLE                         1
+#define CCDC_LSC_TABLE1_SLC                     0
+#define CCDC_LSC_TABLE2_SLC                     1
+#define CCDC_LSC_TABLE3_SLC                     2
+#define CCDC_LSC_MEMADDR_RESET                  (1 << 2)
+#define CCDC_LSC_MEMADDR_INCR                   (0 << 2)
+#define CCDC_LSC_FRAC_MASK_T1                   0xFF
+#define CCDC_LSC_INT_MASK                       3
+#define CCDC_LSC_FRAC_MASK                      0x3FFF
+#define CCDC_LSC_CENTRE_MASK                    0x3FFF
+#define CCDC_LSC_COEF_MASK                      0xff
+#define CCDC_LSC_COEFL_SHIFT                    0
+#define CCDC_LSC_COEFU_SHIFT                    8
+#define CCDC_GAIN_MASK                          0x7FF
+#define CCDC_SYNCEN_VDHDEN_MASK                 (1 << 0)
+#define CCDC_SYNCEN_WEN_MASK                    (1 << 1)
+#define CCDC_SYNCEN_WEN_SHIFT                   1
+
+/* Power on Defaults in hardware */
+#define MODESET_DEFAULT                         0x200
+#define CULH_DEFAULT                            0xFFFF
+#define CULV_DEFAULT                            0xFF
+#define GAIN_DEFAULT                            256
+#define OUTCLIP_DEFAULT                         0x3FFF
+#define LSCCFG2_DEFAULT                         0xE
+
+#endif
diff --git a/drivers/media/video/davinci/dm644x_ccdc.c b/drivers/media/video/davinci/dm644x_ccdc.c
new file mode 100644
index 000000000000..2f19a919f477
--- /dev/null
+++ b/drivers/media/video/davinci/dm644x_ccdc.c
@@ -0,0 +1,878 @@
+/*
+ * Copyright (C) 2006-2009 Texas Instruments Inc
+ *
+ * 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
+ *
+ * CCDC hardware module for DM6446
+ * ------------------------------
+ *
+ * This module is for configuring CCD controller of DM6446 VPFE to capture
+ * Raw yuv or Bayer RGB data from a decoder. CCDC has several modules
+ * such as Defect Pixel Correction, Color Space Conversion etc to
+ * pre-process the Raw Bayer RGB data, before writing it to SDRAM. This
+ * module also allows application to configure individual
+ * module parameters through VPFE_CMD_S_CCDC_RAW_PARAMS IOCTL.
+ * To do so, application includes dm644x_ccdc.h and vpfe_capture.h header
+ * files.  The setparams() API is called by vpfe_capture driver
+ * to configure module parameters. This file is named DM644x so that other
+ * variants such DM6443 may be supported using the same module.
+ *
+ * TODO: Test Raw bayer parameter settings and bayer capture
+ *       Split module parameter structure to module specific ioctl structs
+ *       investigate if enum used for user space type definition
+ *       to be replaced by #defines or integer
+ */
+#include <linux/platform_device.h>
+#include <linux/uaccess.h>
+#include <linux/videodev2.h>
+#include <media/davinci/dm644x_ccdc.h>
+#include <media/davinci/vpss.h>
+#include "dm644x_ccdc_regs.h"
+#include "ccdc_hw_device.h"
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("CCDC Driver for DM6446");
+MODULE_AUTHOR("Texas Instruments");
+
+static struct device *dev;
+
+/* Object for CCDC raw mode */
+static struct ccdc_params_raw ccdc_hw_params_raw = {
+        .pix_fmt = CCDC_PIXFMT_RAW,
+        .frm_fmt = CCDC_FRMFMT_PROGRESSIVE,
+        .win = CCDC_WIN_VGA,
+        .fid_pol = VPFE_PINPOL_POSITIVE,
+        .vd_pol = VPFE_PINPOL_POSITIVE,
+        .hd_pol = VPFE_PINPOL_POSITIVE,
+        .config_params = {
+                .data_sz = CCDC_DATA_10BITS,
+        },
+};
+
+/* Object for CCDC ycbcr mode */
+static struct ccdc_params_ycbcr ccdc_hw_params_ycbcr = {
+        .pix_fmt = CCDC_PIXFMT_YCBCR_8BIT,
+        .frm_fmt = CCDC_FRMFMT_INTERLACED,
+        .win = CCDC_WIN_PAL,
+        .fid_pol = VPFE_PINPOL_POSITIVE,
+        .vd_pol = VPFE_PINPOL_POSITIVE,
+        .hd_pol = VPFE_PINPOL_POSITIVE,
+        .bt656_enable = 1,
+        .pix_order = CCDC_PIXORDER_CBYCRY,
+        .buf_type = CCDC_BUFTYPE_FLD_INTERLEAVED
+};
+
+#define CCDC_MAX_RAW_YUV_FORMATS        2
+
+/* Raw Bayer formats */
+static u32 ccdc_raw_bayer_pix_formats[] =
+        {V4L2_PIX_FMT_SBGGR8, V4L2_PIX_FMT_SBGGR16};
+
+/* Raw YUV formats */
+static u32 ccdc_raw_yuv_pix_formats[] =
+        {V4L2_PIX_FMT_UYVY, V4L2_PIX_FMT_YUYV};
+
+static void *__iomem ccdc_base_addr;
+static int ccdc_addr_size;
+static enum vpfe_hw_if_type ccdc_if_type;
+
+/* register access routines */
+static inline u32 regr(u32 offset)
+{
+        return __raw_readl(ccdc_base_addr + offset);
+}
+
+static inline void regw(u32 val, u32 offset)
+{
+        __raw_writel(val, ccdc_base_addr + offset);
+}
+
+static void ccdc_set_ccdc_base(void *addr, int size)
+{
+        ccdc_base_addr = addr;
+        ccdc_addr_size = size;
+}
+
+static void ccdc_enable(int flag)
+{
+        regw(flag, CCDC_PCR);
+}
+
+static void ccdc_enable_vport(int flag)
+{
+        if (flag)
+                /* enable video port */
+                regw(CCDC_ENABLE_VIDEO_PORT, CCDC_FMTCFG);
+        else
+                regw(CCDC_DISABLE_VIDEO_PORT, CCDC_FMTCFG);
+}
+
+/*
+ * ccdc_setwin()
+ * This function will configure the window size
+ * to be capture in CCDC reg
+ */
+void ccdc_setwin(struct v4l2_rect *image_win,
+                enum ccdc_frmfmt frm_fmt,
+                int ppc)
+{
+        int horz_start, horz_nr_pixels;
+        int vert_start, vert_nr_lines;
+        int val = 0, mid_img = 0;
+
+        dev_dbg(dev, "\nStarting ccdc_setwin...");
+        /*
+         * ppc - per pixel count. indicates how many pixels per cell
+         * output to SDRAM. example, for ycbcr, it is one y and one c, so 2.
+         * raw capture this is 1
+         */
+        horz_start = image_win->left << (ppc - 1);
+        horz_nr_pixels = (image_win->width << (ppc - 1)) - 1;
+        regw((horz_start << CCDC_HORZ_INFO_SPH_SHIFT) | horz_nr_pixels,
+             CCDC_HORZ_INFO);
+
+        vert_start = image_win->top;
+
+        if (frm_fmt == CCDC_FRMFMT_INTERLACED) {
+                vert_nr_lines = (image_win->height >> 1) - 1;
+                vert_start >>= 1;
+                /* Since first line doesn't have any data */
+                vert_start += 1;
+                /* configure VDINT0 */
+                val = (vert_start << CCDC_VDINT_VDINT0_SHIFT);
+                regw(val, CCDC_VDINT);
+
+        } else {
+                /* Since first line doesn't have any data */
+                vert_start += 1;
+                vert_nr_lines = image_win->height - 1;
+                /*
+                 * configure VDINT0 and VDINT1. VDINT1 will be at half
+                 * of image height
+                 */
+                mid_img = vert_start + (image_win->height / 2);
+                val = (vert_start << CCDC_VDINT_VDINT0_SHIFT) |
+                    (mid_img & CCDC_VDINT_VDINT1_MASK);
+                regw(val, CCDC_VDINT);
+
+        }
+        regw((vert_start << CCDC_VERT_START_SLV0_SHIFT) | vert_start,
+             CCDC_VERT_START);
+        regw(vert_nr_lines, CCDC_VERT_LINES);
+        dev_dbg(dev, "\nEnd of ccdc_setwin...");
+}
+
+static void ccdc_readregs(void)
+{
+        unsigned int val = 0;
+
+        val = regr(CCDC_ALAW);
+        dev_notice(dev, "\nReading 0x%x to ALAW...\n", val);
+        val = regr(CCDC_CLAMP);
+        dev_notice(dev, "\nReading 0x%x to CLAMP...\n", val);
+        val = regr(CCDC_DCSUB);
+        dev_notice(dev, "\nReading 0x%x to DCSUB...\n", val);
+        val = regr(CCDC_BLKCMP);
+        dev_notice(dev, "\nReading 0x%x to BLKCMP...\n", val);
+        val = regr(CCDC_FPC_ADDR);
+        dev_notice(dev, "\nReading 0x%x to FPC_ADDR...\n", val);
+        val = regr(CCDC_FPC);
+        dev_notice(dev, "\nReading 0x%x to FPC...\n", val);
+        val = regr(CCDC_FMTCFG);
+        dev_notice(dev, "\nReading 0x%x to FMTCFG...\n", val);
+        val = regr(CCDC_COLPTN);
+        dev_notice(dev, "\nReading 0x%x to COLPTN...\n", val);
+        val = regr(CCDC_FMT_HORZ);
+        dev_notice(dev, "\nReading 0x%x to FMT_HORZ...\n", val);
+        val = regr(CCDC_FMT_VERT);
+        dev_notice(dev, "\nReading 0x%x to FMT_VERT...\n", val);
+        val = regr(CCDC_HSIZE_OFF);
+        dev_notice(dev, "\nReading 0x%x to HSIZE_OFF...\n", val);
+        val = regr(CCDC_SDOFST);
+        dev_notice(dev, "\nReading 0x%x to SDOFST...\n", val);
+        val = regr(CCDC_VP_OUT);
+        dev_notice(dev, "\nReading 0x%x to VP_OUT...\n", val);
+        val = regr(CCDC_SYN_MODE);
+        dev_notice(dev, "\nReading 0x%x to SYN_MODE...\n", val);
+        val = regr(CCDC_HORZ_INFO);
+        dev_notice(dev, "\nReading 0x%x to HORZ_INFO...\n", val);
+        val = regr(CCDC_VERT_START);
+        dev_notice(dev, "\nReading 0x%x to VERT_START...\n", val);
+        val = regr(CCDC_VERT_LINES);
+        dev_notice(dev, "\nReading 0x%x to VERT_LINES...\n", val);
+}
+
+static int validate_ccdc_param(struct ccdc_config_params_raw *ccdcparam)
+{
+        if (ccdcparam->alaw.enable) {
+                if ((ccdcparam->alaw.gama_wd > CCDC_GAMMA_BITS_09_0) ||
+                    (ccdcparam->alaw.gama_wd < CCDC_GAMMA_BITS_15_6) ||
+                    (ccdcparam->alaw.gama_wd < ccdcparam->data_sz)) {
+                        dev_dbg(dev, "\nInvalid data line select");
+                        return -1;
+                }
+        }
+        return 0;
+}
+
+static int ccdc_update_raw_params(struct ccdc_config_params_raw *raw_params)
+{
+        struct ccdc_config_params_raw *config_params =
+                &ccdc_hw_params_raw.config_params;
+        unsigned int *fpc_virtaddr = NULL;
+        unsigned int *fpc_physaddr = NULL;
+
+        memcpy(config_params, raw_params, sizeof(*raw_params));
+        /*
+         * allocate memory for fault pixel table and copy the user
+         * values to the table
+         */
+        if (!config_params->fault_pxl.enable)
+                return 0;
+
+        fpc_physaddr = (unsigned int *)config_params->fault_pxl.fpc_table_addr;
+        fpc_virtaddr = (unsigned int *)phys_to_virt(
+                                (unsigned long)fpc_physaddr);
+        /*
+         * Allocate memory for FPC table if current
+         * FPC table buffer is not big enough to
+         * accomodate FPC Number requested
+         */
+        if (raw_params->fault_pxl.fp_num != config_params->fault_pxl.fp_num) {
+                if (fpc_physaddr != NULL) {
+                        free_pages((unsigned long)fpc_physaddr,
+                                   get_order
+                                   (config_params->fault_pxl.fp_num *
+                                   FP_NUM_BYTES));
+                }
+
+                /* Allocate memory for FPC table */
+                fpc_virtaddr =
+                        (unsigned int *)__get_free_pages(GFP_KERNEL | GFP_DMA,
+                                                         get_order(raw_params->
+                                                         fault_pxl.fp_num *
+                                                         FP_NUM_BYTES));
+
+                if (fpc_virtaddr == NULL) {
+                        dev_dbg(dev,
+                                "\nUnable to allocate memory for FPC");
+                        return -EFAULT;
+                }
+                fpc_physaddr =
+                    (unsigned int *)virt_to_phys((void *)fpc_virtaddr);
+        }
+
+        /* Copy number of fault pixels and FPC table */
+        config_params->fault_pxl.fp_num = raw_params->fault_pxl.fp_num;
+        if (copy_from_user(fpc_virtaddr,
+                        (void __user *)raw_params->fault_pxl.fpc_table_addr,
+                        config_params->fault_pxl.fp_num * FP_NUM_BYTES)) {
+                dev_dbg(dev, "\n copy_from_user failed");
+                return -EFAULT;
+        }
+        config_params->fault_pxl.fpc_table_addr = (unsigned int)fpc_physaddr;
+        return 0;
+}
+
+static int ccdc_close(struct device *dev)
+{
+        struct ccdc_config_params_raw *config_params =
+                &ccdc_hw_params_raw.config_params;
+        unsigned int *fpc_physaddr = NULL, *fpc_virtaddr = NULL;
+
+        fpc_physaddr = (unsigned int *)config_params->fault_pxl.fpc_table_addr;
+
+        if (fpc_physaddr != NULL) {
+                fpc_virtaddr = (unsigned int *)
+                    phys_to_virt((unsigned long)fpc_physaddr);
+                free_pages((unsigned long)fpc_virtaddr,
+                           get_order(config_params->fault_pxl.fp_num *
+                           FP_NUM_BYTES));
+        }
+        return 0;
+}
+
+/*
+ * ccdc_restore_defaults()
+ * This function will write defaults to all CCDC registers
+ */
+static void ccdc_restore_defaults(void)
+{
+        int i;
+
+        /* disable CCDC */
+        ccdc_enable(0);
+        /* set all registers to default value */
+        for (i = 4; i <= 0x94; i += 4)
+                regw(0,  i);
+        regw(CCDC_NO_CULLING, CCDC_CULLING);
+        regw(CCDC_GAMMA_BITS_11_2, CCDC_ALAW);
+}
+
+static int ccdc_open(struct device *device)
+{
+        dev = device;
+        ccdc_restore_defaults();
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                ccdc_enable_vport(1);
+        return 0;
+}
+
+static void ccdc_sbl_reset(void)
+{
+        vpss_clear_wbl_overflow(VPSS_PCR_CCDC_WBL_O);
+}
+
+/* Parameter operations */
+static int ccdc_set_params(void __user *params)
+{
+        struct ccdc_config_params_raw ccdc_raw_params;
+        int x;
+
+        if (ccdc_if_type != VPFE_RAW_BAYER)
+                return -EINVAL;
+
+        x = copy_from_user(&ccdc_raw_params, params, sizeof(ccdc_raw_params));
+        if (x) {
+                dev_dbg(dev, "ccdc_set_params: error in copying"
+                           "ccdc params, %d\n", x);
+                return -EFAULT;
+        }
+
+        if (!validate_ccdc_param(&ccdc_raw_params)) {
+                if (!ccdc_update_raw_params(&ccdc_raw_params))
+                        return 0;
+        }
+        return -EINVAL;
+}
+
+/*
+ * ccdc_config_ycbcr()
+ * This function will configure CCDC for YCbCr video capture
+ */
+void ccdc_config_ycbcr(void)
+{
+        struct ccdc_params_ycbcr *params = &ccdc_hw_params_ycbcr;
+        u32 syn_mode;
+
+        dev_dbg(dev, "\nStarting ccdc_config_ycbcr...");
+        /*
+         * first restore the CCDC registers to default values
+         * This is important since we assume default values to be set in
+         * a lot of registers that we didn't touch
+         */
+        ccdc_restore_defaults();
+
+        /*
+         * configure pixel format, frame format, configure video frame
+         * format, enable output to SDRAM, enable internal timing generator
+         * and 8bit pack mode
+         */
+        syn_mode = (((params->pix_fmt & CCDC_SYN_MODE_INPMOD_MASK) <<
+                    CCDC_SYN_MODE_INPMOD_SHIFT) |
+                    ((params->frm_fmt & CCDC_SYN_FLDMODE_MASK) <<
+                    CCDC_SYN_FLDMODE_SHIFT) | CCDC_VDHDEN_ENABLE |
+                    CCDC_WEN_ENABLE | CCDC_DATA_PACK_ENABLE);
+
+        /* setup BT.656 sync mode */
+        if (params->bt656_enable) {
+                regw(CCDC_REC656IF_BT656_EN, CCDC_REC656IF);
+
+                /*
+                 * configure the FID, VD, HD pin polarity,
+                 * fld,hd pol positive, vd negative, 8-bit data
+                 */
+                syn_mode |= CCDC_SYN_MODE_VD_POL_NEGATIVE | CCDC_SYN_MODE_8BITS;
+        } else {
+                /* y/c external sync mode */
+                syn_mode |= (((params->fid_pol & CCDC_FID_POL_MASK) <<
+                             CCDC_FID_POL_SHIFT) |
+                             ((params->hd_pol & CCDC_HD_POL_MASK) <<
+                             CCDC_HD_POL_SHIFT) |
+                             ((params->vd_pol & CCDC_VD_POL_MASK) <<
+                             CCDC_VD_POL_SHIFT));
+        }
+        regw(syn_mode, CCDC_SYN_MODE);
+
+        /* configure video window */
+        ccdc_setwin(&params->win, params->frm_fmt, 2);
+
+        /*
+         * configure the order of y cb cr in SDRAM, and disable latch
+         * internal register on vsync
+         */
+        regw((params->pix_order << CCDC_CCDCFG_Y8POS_SHIFT) |
+                 CCDC_LATCH_ON_VSYNC_DISABLE, CCDC_CCDCFG);
+
+        /*
+         * configure the horizontal line offset. This should be a
+         * on 32 byte bondary. So clear LSB 5 bits
+         */
+        regw(((params->win.width * 2  + 31) & ~0x1f), CCDC_HSIZE_OFF);
+
+        /* configure the memory line offset */
+        if (params->buf_type == CCDC_BUFTYPE_FLD_INTERLEAVED)
+                /* two fields are interleaved in memory */
+                regw(CCDC_SDOFST_FIELD_INTERLEAVED, CCDC_SDOFST);
+
+        ccdc_sbl_reset();
+        dev_dbg(dev, "\nEnd of ccdc_config_ycbcr...\n");
+        ccdc_readregs();
+}
+
+static void ccdc_config_black_clamp(struct ccdc_black_clamp *bclamp)
+{
+        u32 val;
+
+        if (!bclamp->enable) {
+                /* configure DCSub */
+                val = (bclamp->dc_sub) & CCDC_BLK_DC_SUB_MASK;
+                regw(val, CCDC_DCSUB);
+                dev_dbg(dev, "\nWriting 0x%x to DCSUB...\n", val);
+                regw(CCDC_CLAMP_DEFAULT_VAL, CCDC_CLAMP);
+                dev_dbg(dev, "\nWriting 0x0000 to CLAMP...\n");
+                return;
+        }
+        /*
+         * Configure gain,  Start pixel, No of line to be avg,
+         * No of pixel/line to be avg, & Enable the Black clamping
+         */
+        val = ((bclamp->sgain & CCDC_BLK_SGAIN_MASK) |
+               ((bclamp->start_pixel & CCDC_BLK_ST_PXL_MASK) <<
+                CCDC_BLK_ST_PXL_SHIFT) |
+               ((bclamp->sample_ln & CCDC_BLK_SAMPLE_LINE_MASK) <<
+                CCDC_BLK_SAMPLE_LINE_SHIFT) |
+               ((bclamp->sample_pixel & CCDC_BLK_SAMPLE_LN_MASK) <<
+                CCDC_BLK_SAMPLE_LN_SHIFT) | CCDC_BLK_CLAMP_ENABLE);
+        regw(val, CCDC_CLAMP);
+        dev_dbg(dev, "\nWriting 0x%x to CLAMP...\n", val);
+        /* If Black clamping is enable then make dcsub 0 */
+        regw(CCDC_DCSUB_DEFAULT_VAL, CCDC_DCSUB);
+        dev_dbg(dev, "\nWriting 0x00000000 to DCSUB...\n");
+}
+
+static void ccdc_config_black_compense(struct ccdc_black_compensation *bcomp)
+{
+        u32 val;
+
+        val = ((bcomp->b & CCDC_BLK_COMP_MASK) |
+              ((bcomp->gb & CCDC_BLK_COMP_MASK) <<
+               CCDC_BLK_COMP_GB_COMP_SHIFT) |
+              ((bcomp->gr & CCDC_BLK_COMP_MASK) <<
+               CCDC_BLK_COMP_GR_COMP_SHIFT) |
+              ((bcomp->r & CCDC_BLK_COMP_MASK) <<
+               CCDC_BLK_COMP_R_COMP_SHIFT));
+        regw(val, CCDC_BLKCMP);
+}
+
+static void ccdc_config_fpc(struct ccdc_fault_pixel *fpc)
+{
+        u32 val;
+
+        /* Initially disable FPC */
+        val = CCDC_FPC_DISABLE;
+        regw(val, CCDC_FPC);
+
+        if (!fpc->enable)
+                return;
+
+        /* Configure Fault pixel if needed */
+        regw(fpc->fpc_table_addr, CCDC_FPC_ADDR);
+        dev_dbg(dev, "\nWriting 0x%x to FPC_ADDR...\n",
+                       (fpc->fpc_table_addr));
+        /* Write the FPC params with FPC disable */
+        val = fpc->fp_num & CCDC_FPC_FPC_NUM_MASK;
+        regw(val, CCDC_FPC);
+
+        dev_dbg(dev, "\nWriting 0x%x to FPC...\n", val);
+        /* read the FPC register */
+        val = regr(CCDC_FPC) | CCDC_FPC_ENABLE;
+        regw(val, CCDC_FPC);
+        dev_dbg(dev, "\nWriting 0x%x to FPC...\n", val);
+}
+
+/*
+ * ccdc_config_raw()
+ * This function will configure CCDC for Raw capture mode
+ */
+void ccdc_config_raw(void)
+{
+        struct ccdc_params_raw *params = &ccdc_hw_params_raw;
+        struct ccdc_config_params_raw *config_params =
+                &ccdc_hw_params_raw.config_params;
+        unsigned int syn_mode = 0;
+        unsigned int val;
+
+        dev_dbg(dev, "\nStarting ccdc_config_raw...");
+
+        /*      Reset CCDC */
+        ccdc_restore_defaults();
+
+        /* Disable latching function registers on VSYNC  */
+        regw(CCDC_LATCH_ON_VSYNC_DISABLE, CCDC_CCDCFG);
+
+        /*
+         * Configure the vertical sync polarity(SYN_MODE.VDPOL),
+         * horizontal sync polarity (SYN_MODE.HDPOL), frame id polarity
+         * (SYN_MODE.FLDPOL), frame format(progressive or interlace),
+         * data size(SYNMODE.DATSIZ), &pixel format (Input mode), output
+         * SDRAM, enable internal timing generator
+         */
+        syn_mode =
+                (((params->vd_pol & CCDC_VD_POL_MASK) << CCDC_VD_POL_SHIFT) |
+                ((params->hd_pol & CCDC_HD_POL_MASK) << CCDC_HD_POL_SHIFT) |
+                ((params->fid_pol & CCDC_FID_POL_MASK) << CCDC_FID_POL_SHIFT) |
+                ((params->frm_fmt & CCDC_FRM_FMT_MASK) << CCDC_FRM_FMT_SHIFT) |
+                ((config_params->data_sz & CCDC_DATA_SZ_MASK) <<
+                CCDC_DATA_SZ_SHIFT) |
+                ((params->pix_fmt & CCDC_PIX_FMT_MASK) << CCDC_PIX_FMT_SHIFT) |
+                CCDC_WEN_ENABLE | CCDC_VDHDEN_ENABLE);
+
+        /* Enable and configure aLaw register if needed */
+        if (config_params->alaw.enable) {
+                val = ((config_params->alaw.gama_wd &
+                      CCDC_ALAW_GAMA_WD_MASK) | CCDC_ALAW_ENABLE);
+                regw(val, CCDC_ALAW);
+                dev_dbg(dev, "\nWriting 0x%x to ALAW...\n", val);
+        }
+
+        /* Configure video window */
+        ccdc_setwin(&params->win, params->frm_fmt, CCDC_PPC_RAW);
+
+        /* Configure Black Clamp */
+        ccdc_config_black_clamp(&config_params->blk_clamp);
+
+        /* Configure Black level compensation */
+        ccdc_config_black_compense(&config_params->blk_comp);
+
+        /* Configure Fault Pixel Correction */
+        ccdc_config_fpc(&config_params->fault_pxl);
+
+        /* If data size is 8 bit then pack the data */
+        if ((config_params->data_sz == CCDC_DATA_8BITS) ||
+             config_params->alaw.enable)
+                syn_mode |= CCDC_DATA_PACK_ENABLE;
+
+#ifdef CONFIG_DM644X_VIDEO_PORT_ENABLE
+        /* enable video port */
+        val = CCDC_ENABLE_VIDEO_PORT;
+#else
+        /* disable video port */
+        val = CCDC_DISABLE_VIDEO_PORT;
+#endif
+
+        if (config_params->data_sz == CCDC_DATA_8BITS)
+                val |= (CCDC_DATA_10BITS & CCDC_FMTCFG_VPIN_MASK)
+                    << CCDC_FMTCFG_VPIN_SHIFT;
+        else
+                val |= (config_params->data_sz & CCDC_FMTCFG_VPIN_MASK)
+                    << CCDC_FMTCFG_VPIN_SHIFT;
+        /* Write value in FMTCFG */
+        regw(val, CCDC_FMTCFG);
+
+        dev_dbg(dev, "\nWriting 0x%x to FMTCFG...\n", val);
+        /* Configure the color pattern according to mt9t001 sensor */
+        regw(CCDC_COLPTN_VAL, CCDC_COLPTN);
+
+        dev_dbg(dev, "\nWriting 0xBB11BB11 to COLPTN...\n");
+        /*
+         * Configure Data formatter(Video port) pixel selection
+         * (FMT_HORZ, FMT_VERT)
+         */
+        val = ((params->win.left & CCDC_FMT_HORZ_FMTSPH_MASK) <<
+              CCDC_FMT_HORZ_FMTSPH_SHIFT) |
+              (params->win.width & CCDC_FMT_HORZ_FMTLNH_MASK);
+        regw(val, CCDC_FMT_HORZ);
+
+        dev_dbg(dev, "\nWriting 0x%x to FMT_HORZ...\n", val);
+        val = (params->win.top & CCDC_FMT_VERT_FMTSLV_MASK)
+            << CCDC_FMT_VERT_FMTSLV_SHIFT;
+        if (params->frm_fmt == CCDC_FRMFMT_PROGRESSIVE)
+                val |= (params->win.height) & CCDC_FMT_VERT_FMTLNV_MASK;
+        else
+                val |= (params->win.height >> 1) & CCDC_FMT_VERT_FMTLNV_MASK;
+
+        dev_dbg(dev, "\nparams->win.height  0x%x ...\n",
+               params->win.height);
+        regw(val, CCDC_FMT_VERT);
+
+        dev_dbg(dev, "\nWriting 0x%x to FMT_VERT...\n", val);
+
+        dev_dbg(dev, "\nbelow regw(val, FMT_VERT)...");
+
+        /*
+         * Configure Horizontal offset register. If pack 8 is enabled then
+         * 1 pixel will take 1 byte
+         */
+        if ((config_params->data_sz == CCDC_DATA_8BITS) ||
+            config_params->alaw.enable)
+                regw((params->win.width + CCDC_32BYTE_ALIGN_VAL) &
+                    CCDC_HSIZE_OFF_MASK, CCDC_HSIZE_OFF);
+        else
+                /* else one pixel will take 2 byte */
+                regw(((params->win.width * CCDC_TWO_BYTES_PER_PIXEL) +
+                    CCDC_32BYTE_ALIGN_VAL) & CCDC_HSIZE_OFF_MASK,
+                    CCDC_HSIZE_OFF);
+
+        /* Set value for SDOFST */
+        if (params->frm_fmt == CCDC_FRMFMT_INTERLACED) {
+                if (params->image_invert_enable) {
+                        /* For intelace inverse mode */
+                        regw(CCDC_INTERLACED_IMAGE_INVERT, CCDC_SDOFST);
+                        dev_dbg(dev, "\nWriting 0x4B6D to SDOFST...\n");
+                }
+
+                else {
+                        /* For intelace non inverse mode */
+                        regw(CCDC_INTERLACED_NO_IMAGE_INVERT, CCDC_SDOFST);
+                        dev_dbg(dev, "\nWriting 0x0249 to SDOFST...\n");
+                }
+        } else if (params->frm_fmt == CCDC_FRMFMT_PROGRESSIVE) {
+                regw(CCDC_PROGRESSIVE_NO_IMAGE_INVERT, CCDC_SDOFST);
+                dev_dbg(dev, "\nWriting 0x0000 to SDOFST...\n");
+        }
+
+        /*
+         * Configure video port pixel selection (VPOUT)
+         * Here -1 is to make the height value less than FMT_VERT.FMTLNV
+         */
+        if (params->frm_fmt == CCDC_FRMFMT_PROGRESSIVE)
+                val = (((params->win.height - 1) & CCDC_VP_OUT_VERT_NUM_MASK))
+                    << CCDC_VP_OUT_VERT_NUM_SHIFT;
+        else
+                val =
+                    ((((params->win.height >> CCDC_INTERLACED_HEIGHT_SHIFT) -
+                     1) & CCDC_VP_OUT_VERT_NUM_MASK)) <<
+                    CCDC_VP_OUT_VERT_NUM_SHIFT;
+
+        val |= ((((params->win.width))) & CCDC_VP_OUT_HORZ_NUM_MASK)
+            << CCDC_VP_OUT_HORZ_NUM_SHIFT;
+        val |= (params->win.left) & CCDC_VP_OUT_HORZ_ST_MASK;
+        regw(val, CCDC_VP_OUT);
+
+        dev_dbg(dev, "\nWriting 0x%x to VP_OUT...\n", val);
+        regw(syn_mode, CCDC_SYN_MODE);
+        dev_dbg(dev, "\nWriting 0x%x to SYN_MODE...\n", syn_mode);
+
+        ccdc_sbl_reset();
+        dev_dbg(dev, "\nend of ccdc_config_raw...");
+        ccdc_readregs();
+}
+
+static int ccdc_configure(void)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                ccdc_config_raw();
+        else
+                ccdc_config_ycbcr();
+        return 0;
+}
+
+static int ccdc_set_buftype(enum ccdc_buftype buf_type)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                ccdc_hw_params_raw.buf_type = buf_type;
+        else
+                ccdc_hw_params_ycbcr.buf_type = buf_type;
+        return 0;
+}
+
+static enum ccdc_buftype ccdc_get_buftype(void)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                return ccdc_hw_params_raw.buf_type;
+        return ccdc_hw_params_ycbcr.buf_type;
+}
+
+static int ccdc_enum_pix(u32 *pix, int i)
+{
+        int ret = -EINVAL;
+        if (ccdc_if_type == VPFE_RAW_BAYER) {
+                if (i < ARRAY_SIZE(ccdc_raw_bayer_pix_formats)) {
+                        *pix = ccdc_raw_bayer_pix_formats[i];
+                        ret = 0;
+                }
+        } else {
+                if (i < ARRAY_SIZE(ccdc_raw_yuv_pix_formats)) {
+                        *pix = ccdc_raw_yuv_pix_formats[i];
+                        ret = 0;
+                }
+        }
+        return ret;
+}
+
+static int ccdc_set_pixel_format(u32 pixfmt)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER) {
+                ccdc_hw_params_raw.pix_fmt = CCDC_PIXFMT_RAW;
+                if (pixfmt == V4L2_PIX_FMT_SBGGR8)
+                        ccdc_hw_params_raw.config_params.alaw.enable = 1;
+                else if (pixfmt != V4L2_PIX_FMT_SBGGR16)
+                        return -EINVAL;
+        } else {
+                if (pixfmt == V4L2_PIX_FMT_YUYV)
+                        ccdc_hw_params_ycbcr.pix_order = CCDC_PIXORDER_YCBYCR;
+                else if (pixfmt == V4L2_PIX_FMT_UYVY)
+                        ccdc_hw_params_ycbcr.pix_order = CCDC_PIXORDER_CBYCRY;
+                else
+                        return -EINVAL;
+        }
+        return 0;
+}
+
+static u32 ccdc_get_pixel_format(void)
+{
+        struct ccdc_a_law *alaw =
+                &ccdc_hw_params_raw.config_params.alaw;
+        u32 pixfmt;
+
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                if (alaw->enable)
+                        pixfmt = V4L2_PIX_FMT_SBGGR8;
+                else
+                        pixfmt = V4L2_PIX_FMT_SBGGR16;
+        else {
+                if (ccdc_hw_params_ycbcr.pix_order == CCDC_PIXORDER_YCBYCR)
+                        pixfmt = V4L2_PIX_FMT_YUYV;
+                else
+                        pixfmt = V4L2_PIX_FMT_UYVY;
+        }
+        return pixfmt;
+}
+
+static int ccdc_set_image_window(struct v4l2_rect *win)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                ccdc_hw_params_raw.win = *win;
+        else
+                ccdc_hw_params_ycbcr.win = *win;
+        return 0;
+}
+
+static void ccdc_get_image_window(struct v4l2_rect *win)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                *win = ccdc_hw_params_raw.win;
+        else
+                *win = ccdc_hw_params_ycbcr.win;
+}
+
+static unsigned int ccdc_get_line_length(void)
+{
+        struct ccdc_config_params_raw *config_params =
+                &ccdc_hw_params_raw.config_params;
+        unsigned int len;
+
+        if (ccdc_if_type == VPFE_RAW_BAYER) {
+                if ((config_params->alaw.enable) ||
+                    (config_params->data_sz == CCDC_DATA_8BITS))
+                        len = ccdc_hw_params_raw.win.width;
+                else
+                        len = ccdc_hw_params_raw.win.width * 2;
+        } else
+                len = ccdc_hw_params_ycbcr.win.width * 2;
+        return ALIGN(len, 32);
+}
+
+static int ccdc_set_frame_format(enum ccdc_frmfmt frm_fmt)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                ccdc_hw_params_raw.frm_fmt = frm_fmt;
+        else
+                ccdc_hw_params_ycbcr.frm_fmt = frm_fmt;
+        return 0;
+}
+
+static enum ccdc_frmfmt ccdc_get_frame_format(void)
+{
+        if (ccdc_if_type == VPFE_RAW_BAYER)
+                return ccdc_hw_params_raw.frm_fmt;
+        else
+                return ccdc_hw_params_ycbcr.frm_fmt;
+}
+
+static int ccdc_getfid(void)
+{
+        return (regr(CCDC_SYN_MODE) >> 15) & 1;
+}
+
+/* misc operations */
+static inline void ccdc_setfbaddr(unsigned long addr)
+{
+        regw(addr & 0xffffffe0, CCDC_SDR_ADDR);
+}
+
+static int ccdc_set_hw_if_params(struct vpfe_hw_if_param *params)
+{
+        ccdc_if_type = params->if_type;
+
+        switch (params->if_type) {
+        case VPFE_BT656:
+        case VPFE_YCBCR_SYNC_16:
+        case VPFE_YCBCR_SYNC_8:
+                ccdc_hw_params_ycbcr.vd_pol = params->vdpol;
+                ccdc_hw_params_ycbcr.hd_pol = params->hdpol;
+                break;
+        default:
+                /* TODO add support for raw bayer here */
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static struct ccdc_hw_device ccdc_hw_dev = {
+        .name = "DM6446 CCDC",
+        .owner = THIS_MODULE,
+        .hw_ops = {
+                .open = ccdc_open,
+                .close = ccdc_close,
+                .set_ccdc_base = ccdc_set_ccdc_base,
+                .reset = ccdc_sbl_reset,
+                .enable = ccdc_enable,
+                .set_hw_if_params = ccdc_set_hw_if_params,
+                .set_params = ccdc_set_params,
+                .configure = ccdc_configure,
+                .set_buftype = ccdc_set_buftype,
+                .get_buftype = ccdc_get_buftype,
+                .enum_pix = ccdc_enum_pix,
+                .set_pixel_format = ccdc_set_pixel_format,
+                .get_pixel_format = ccdc_get_pixel_format,
+                .set_frame_format = ccdc_set_frame_format,
+                .get_frame_format = ccdc_get_frame_format,
+                .set_image_window = ccdc_set_image_window,
+                .get_image_window = ccdc_get_image_window,
+                .get_line_length = ccdc_get_line_length,
+                .setfbaddr = ccdc_setfbaddr,
+                .getfid = ccdc_getfid,
+        },
+};
+
+static int dm644x_ccdc_init(void)
+{
+        printk(KERN_NOTICE "dm644x_ccdc_init\n");
+        if (vpfe_register_ccdc_device(&ccdc_hw_dev) < 0)
+                return -1;
+        printk(KERN_NOTICE "%s is registered with vpfe.\n",
+                ccdc_hw_dev.name);
+        return 0;
+}
+
+static void dm644x_ccdc_exit(void)
+{
+        vpfe_unregister_ccdc_device(&ccdc_hw_dev);
+}
+
+module_init(dm644x_ccdc_init);
+module_exit(dm644x_ccdc_exit);
diff --git a/drivers/media/video/davinci/dm644x_ccdc_regs.h b/drivers/media/video/davinci/dm644x_ccdc_regs.h
new file mode 100644
index 000000000000..6e5d05324466
--- /dev/null
+++ b/drivers/media/video/davinci/dm644x_ccdc_regs.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2006-2009 Texas Instruments Inc
+ *
+ * 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
+ */
+#ifndef _DM644X_CCDC_REGS_H
+#define _DM644X_CCDC_REGS_H
+
+/**************************************************************************\
+* Register OFFSET Definitions
+\**************************************************************************/
+#define CCDC_PID                                0x0
+#define CCDC_PCR                                0x4
+#define CCDC_SYN_MODE                           0x8
+#define CCDC_HD_VD_WID                          0xc
+#define CCDC_PIX_LINES                          0x10
+#define CCDC_HORZ_INFO                          0x14
+#define CCDC_VERT_START                         0x18
+#define CCDC_VERT_LINES                         0x1c
+#define CCDC_CULLING                            0x20
+#define CCDC_HSIZE_OFF                          0x24
+#define CCDC_SDOFST                             0x28
+#define CCDC_SDR_ADDR                           0x2c
+#define CCDC_CLAMP                              0x30
+#define CCDC_DCSUB                              0x34
+#define CCDC_COLPTN                             0x38
+#define CCDC_BLKCMP                             0x3c
+#define CCDC_FPC                                0x40
+#define CCDC_FPC_ADDR                           0x44
+#define CCDC_VDINT                              0x48
+#define CCDC_ALAW                               0x4c
+#define CCDC_REC656IF                           0x50
+#define CCDC_CCDCFG                             0x54
+#define CCDC_FMTCFG                             0x58
+#define CCDC_FMT_HORZ                           0x5c
+#define CCDC_FMT_VERT                           0x60
+#define CCDC_FMT_ADDR0                          0x64
+#define CCDC_FMT_ADDR1                          0x68
+#define CCDC_FMT_ADDR2                          0x6c
+#define CCDC_FMT_ADDR3                          0x70
+#define CCDC_FMT_ADDR4                          0x74
+#define CCDC_FMT_ADDR5                          0x78
+#define CCDC_FMT_ADDR6                          0x7c
+#define CCDC_FMT_ADDR7                          0x80
+#define CCDC_PRGEVEN_0                          0x84
+#define CCDC_PRGEVEN_1                          0x88
+#define CCDC_PRGODD_0                           0x8c
+#define CCDC_PRGODD_1                           0x90
+#define CCDC_VP_OUT                             0x94
+
+
+/***************************************************************
+*       Define for various register bit mask and shifts for CCDC
+****************************************************************/
+#define CCDC_FID_POL_MASK                       1
+#define CCDC_FID_POL_SHIFT                      4
+#define CCDC_HD_POL_MASK                        1
+#define CCDC_HD_POL_SHIFT                       3
+#define CCDC_VD_POL_MASK                        1
+#define CCDC_VD_POL_SHIFT                       2
+#define CCDC_HSIZE_OFF_MASK                     0xffffffe0
+#define CCDC_32BYTE_ALIGN_VAL                   31
+#define CCDC_FRM_FMT_MASK                       0x1
+#define CCDC_FRM_FMT_SHIFT                      7
+#define CCDC_DATA_SZ_MASK                       7
+#define CCDC_DATA_SZ_SHIFT                      8
+#define CCDC_PIX_FMT_MASK                       3
+#define CCDC_PIX_FMT_SHIFT                      12
+#define CCDC_VP2SDR_DISABLE                     0xFFFBFFFF
+#define CCDC_WEN_ENABLE                         (1 << 17)
+#define CCDC_SDR2RSZ_DISABLE                    0xFFF7FFFF
+#define CCDC_VDHDEN_ENABLE                      (1 << 16)
+#define CCDC_LPF_ENABLE                         (1 << 14)
+#define CCDC_ALAW_ENABLE                        (1 << 3)
+#define CCDC_ALAW_GAMA_WD_MASK                  7
+#define CCDC_BLK_CLAMP_ENABLE                   (1 << 31)
+#define CCDC_BLK_SGAIN_MASK                     0x1F
+#define CCDC_BLK_ST_PXL_MASK                    0x7FFF
+#define CCDC_BLK_ST_PXL_SHIFT                   10
+#define CCDC_BLK_SAMPLE_LN_MASK                 7
+#define CCDC_BLK_SAMPLE_LN_SHIFT                28
+#define CCDC_BLK_SAMPLE_LINE_MASK               7
+#define CCDC_BLK_SAMPLE_LINE_SHIFT              25
+#define CCDC_BLK_DC_SUB_MASK                    0x03FFF
+#define CCDC_BLK_COMP_MASK                      0xFF
+#define CCDC_BLK_COMP_GB_COMP_SHIFT             8
+#define CCDC_BLK_COMP_GR_COMP_SHIFT             16
+#define CCDC_BLK_COMP_R_COMP_SHIFT              24
+#define CCDC_LATCH_ON_VSYNC_DISABLE             (1 << 15)
+#define CCDC_FPC_ENABLE                         (1 << 15)
+#define CCDC_FPC_DISABLE                        0
+#define CCDC_FPC_FPC_NUM_MASK                   0x7FFF
+#define CCDC_DATA_PACK_ENABLE                   (1 << 11)
+#define CCDC_FMTCFG_VPIN_MASK                   7
+#define CCDC_FMTCFG_VPIN_SHIFT                  12
+#define CCDC_FMT_HORZ_FMTLNH_MASK               0x1FFF
+#define CCDC_FMT_HORZ_FMTSPH_MASK               0x1FFF
+#define CCDC_FMT_HORZ_FMTSPH_SHIFT              16
+#define CCDC_FMT_VERT_FMTLNV_MASK               0x1FFF
+#define CCDC_FMT_VERT_FMTSLV_MASK               0x1FFF
+#define CCDC_FMT_VERT_FMTSLV_SHIFT              16
+#define CCDC_VP_OUT_VERT_NUM_MASK               0x3FFF
+#define CCDC_VP_OUT_VERT_NUM_SHIFT              17
+#define CCDC_VP_OUT_HORZ_NUM_MASK               0x1FFF
+#define CCDC_VP_OUT_HORZ_NUM_SHIFT              4
+#define CCDC_VP_OUT_HORZ_ST_MASK                0xF
+#define CCDC_HORZ_INFO_SPH_SHIFT                16
+#define CCDC_VERT_START_SLV0_SHIFT              16
+#define CCDC_VDINT_VDINT0_SHIFT                 16
+#define CCDC_VDINT_VDINT1_MASK                  0xFFFF
+#define CCDC_PPC_RAW                            1
+#define CCDC_DCSUB_DEFAULT_VAL                  0
+#define CCDC_CLAMP_DEFAULT_VAL                  0
+#define CCDC_ENABLE_VIDEO_PORT                  0x8000
+#define CCDC_DISABLE_VIDEO_PORT                 0
+#define CCDC_COLPTN_VAL                         0xBB11BB11
+#define CCDC_TWO_BYTES_PER_PIXEL                2
+#define CCDC_INTERLACED_IMAGE_INVERT            0x4B6D
+#define CCDC_INTERLACED_NO_IMAGE_INVERT         0x0249
+#define CCDC_PROGRESSIVE_IMAGE_INVERT           0x4000
+#define CCDC_PROGRESSIVE_NO_IMAGE_INVERT        0
+#define CCDC_INTERLACED_HEIGHT_SHIFT            1
+#define CCDC_SYN_MODE_INPMOD_SHIFT              12
+#define CCDC_SYN_MODE_INPMOD_MASK               3
+#define CCDC_SYN_MODE_8BITS                     (7 << 8)
+#define CCDC_SYN_FLDMODE_MASK                   1
+#define CCDC_SYN_FLDMODE_SHIFT                  7
+#define CCDC_REC656IF_BT656_EN                  3
+#define CCDC_SYN_MODE_VD_POL_NEGATIVE           (1 << 2)
+#define CCDC_CCDCFG_Y8POS_SHIFT                 11
+#define CCDC_SDOFST_FIELD_INTERLEAVED           0x249
+#define CCDC_NO_CULLING                         0xffff00ff
+#endif
diff --git a/drivers/media/video/davinci/vpfe_capture.c b/drivers/media/video/davinci/vpfe_capture.c
new file mode 100644
index 000000000000..402ce43ef38e
--- /dev/null
+++ b/drivers/media/video/davinci/vpfe_capture.c
@@ -0,0 +1,2124 @@
+/*
+ * Copyright (C) 2008-2009 Texas Instruments Inc
+ *
+ * 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
+ *
+ * Driver name : VPFE Capture driver
+ *    VPFE Capture driver allows applications to capture and stream video
+ *    frames on DaVinci SoCs (DM6446, DM355 etc) from a YUV source such as
+ *    TVP5146 or  Raw Bayer RGB image data from an image sensor
+ *    such as Microns' MT9T001, MT9T031 etc.
+ *
+ *    These SoCs have, in common, a Video Processing Subsystem (VPSS) that
+ *    consists of a Video Processing Front End (VPFE) for capturing
+ *    video/raw image data and Video Processing Back End (VPBE) for displaying
+ *    YUV data through an in-built analog encoder or Digital LCD port. This
+ *    driver is for capture through VPFE. A typical EVM using these SoCs have
+ *    following high level configuration.
+ *
+ *
+ *    decoder(TVP5146/          YUV/
+ *           MT9T001)   -->  Raw Bayer RGB ---> MUX -> VPFE (CCDC/ISIF)
+ *                              data input              |      |
+ *                                                      V      |
+ *                                                    SDRAM    |
+ *                                                             V
+ *                                                         Image Processor
+ *                                                             |
+ *                                                             V
+ *                                                           SDRAM
+ *    The data flow happens from a decoder connected to the VPFE over a
+ *    YUV embedded (BT.656/BT.1120) or separate sync or raw bayer rgb interface
+ *    and to the input of VPFE through an optional MUX (if more inputs are
+ *    to be interfaced on the EVM). The input data is first passed through
+ *    CCDC (CCD Controller, a.k.a Image Sensor Interface, ISIF). The CCDC
+ *    does very little or no processing on YUV data and does pre-process Raw
+ *    Bayer RGB data through modules such as Defect Pixel Correction (DFC)
+ *    Color Space Conversion (CSC), data gain/offset etc. After this, data
+ *    can be written to SDRAM or can be connected to the image processing
+ *    block such as IPIPE (on DM355 only).
+ *
+ *    Features supported
+ *              - MMAP IO
+ *              - Capture using TVP5146 over BT.656
+ *              - support for interfacing decoders using sub device model
+ *              - Work with DM355 or DM6446 CCDC to do Raw Bayer RGB/YUV
+ *                data capture to SDRAM.
+ *    TODO list
+ *              - Support multiple REQBUF after open
+ *              - Support for de-allocating buffers through REQBUF
+ *              - Support for Raw Bayer RGB capture
+ *              - Support for chaining Image Processor
+ *              - Support for static allocation of buffers
+ *              - Support for USERPTR IO
+ *              - Support for STREAMON before QBUF
+ *              - Support for control ioctls
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/version.h>
+#include <media/v4l2-common.h>
+#include <linux/io.h>
+#include <media/davinci/vpfe_capture.h>
+#include "ccdc_hw_device.h"
+
+static int debug;
+static u32 numbuffers = 3;
+static u32 bufsize = (720 * 576 * 2);
+
+module_param(numbuffers, uint, S_IRUGO);
+module_param(bufsize, uint, S_IRUGO);
+module_param(debug, int, 0644);
+
+MODULE_PARM_DESC(numbuffers, "buffer count (default:3)");
+MODULE_PARM_DESC(bufsize, "buffer size in bytes (default:720 x 576 x 2)");
+MODULE_PARM_DESC(debug, "Debug level 0-1");
+
+MODULE_DESCRIPTION("VPFE Video for Linux Capture Driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Texas Instruments");
+
+/* standard information */
+struct vpfe_standard {
+        v4l2_std_id std_id;
+        unsigned int width;
+        unsigned int height;
+        struct v4l2_fract pixelaspect;
+        /* 0 - progressive, 1 - interlaced */
+        int frame_format;
+};
+
+/* ccdc configuration */
+struct ccdc_config {
+        /* This make sure vpfe is probed and ready to go */
+        int vpfe_probed;
+        /* name of ccdc device */
+        char name[32];
+        /* for storing mem maps for CCDC */
+        int ccdc_addr_size;
+        void *__iomem ccdc_addr;
+};
+
+/* data structures */
+static struct vpfe_config_params config_params = {
+        .min_numbuffers = 3,
+        .numbuffers = 3,
+        .min_bufsize = 720 * 480 * 2,
+        .device_bufsize = 720 * 576 * 2,
+};
+
+/* ccdc device registered */
+static struct ccdc_hw_device *ccdc_dev;
+/* lock for accessing ccdc information */
+static DEFINE_MUTEX(ccdc_lock);
+/* ccdc configuration */
+static struct ccdc_config *ccdc_cfg;
+
+const struct vpfe_standard vpfe_standards[] = {
+        {V4L2_STD_525_60, 720, 480, {11, 10}, 1},
+        {V4L2_STD_625_50, 720, 576, {54, 59}, 1},
+};
+
+/* Used when raw Bayer image from ccdc is directly captured to SDRAM */
+static const struct vpfe_pixel_format vpfe_pix_fmts[] = {
+        {
+                .fmtdesc = {
+                        .index = 0,
+                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+                        .description = "Bayer GrRBGb 8bit A-Law compr.",
+                        .pixelformat = V4L2_PIX_FMT_SBGGR8,
+                },
+                .bpp = 1,
+        },
+        {
+                .fmtdesc = {
+                        .index = 1,
+                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+                        .description = "Bayer GrRBGb - 16bit",
+                        .pixelformat = V4L2_PIX_FMT_SBGGR16,
+                },
+                .bpp = 2,
+        },
+        {
+                .fmtdesc = {
+                        .index = 2,
+                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+                        .description = "Bayer GrRBGb 8bit DPCM compr.",
+                        .pixelformat = V4L2_PIX_FMT_SGRBG10DPCM8,
+                },
+                .bpp = 1,
+        },
+        {
+                .fmtdesc = {
+                        .index = 3,
+                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+                        .description = "YCbCr 4:2:2 Interleaved UYVY",
+                        .pixelformat = V4L2_PIX_FMT_UYVY,
+                },
+                .bpp = 2,
+        },
+        {
+                .fmtdesc = {
+                        .index = 4,
+                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+                        .description = "YCbCr 4:2:2 Interleaved YUYV",
+                        .pixelformat = V4L2_PIX_FMT_YUYV,
+                },
+                .bpp = 2,
+        },
+        {
+                .fmtdesc = {
+                        .index = 5,
+                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
+                        .description = "Y/CbCr 4:2:0 - Semi planar",
+                        .pixelformat = V4L2_PIX_FMT_NV12,
+                },
+                .bpp = 1,
+        },
+};
+
+/*
+ * vpfe_lookup_pix_format()
+ * lookup an entry in the vpfe pix format table based on pix_format
+ */
+static const struct vpfe_pixel_format *vpfe_lookup_pix_format(u32 pix_format)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(vpfe_pix_fmts); i++) {
+                if (pix_format == vpfe_pix_fmts[i].fmtdesc.pixelformat)
+                        return &vpfe_pix_fmts[i];
+        }
+        return NULL;
+}
+
+/*
+ * vpfe_register_ccdc_device. CCDC module calls this to
+ * register with vpfe capture
+ */
+int vpfe_register_ccdc_device(struct ccdc_hw_device *dev)
+{
+        int ret = 0;
+        printk(KERN_NOTICE "vpfe_register_ccdc_device: %s\n", dev->name);
+
+        BUG_ON(!dev->hw_ops.open);
+        BUG_ON(!dev->hw_ops.enable);
+        BUG_ON(!dev->hw_ops.set_hw_if_params);
+        BUG_ON(!dev->hw_ops.configure);
+        BUG_ON(!dev->hw_ops.set_buftype);
+        BUG_ON(!dev->hw_ops.get_buftype);
+        BUG_ON(!dev->hw_ops.enum_pix);
+        BUG_ON(!dev->hw_ops.set_frame_format);
+        BUG_ON(!dev->hw_ops.get_frame_format);
+        BUG_ON(!dev->hw_ops.get_pixel_format);
+        BUG_ON(!dev->hw_ops.set_pixel_format);
+        BUG_ON(!dev->hw_ops.set_params);
+        BUG_ON(!dev->hw_ops.set_image_window);
+        BUG_ON(!dev->hw_ops.get_image_window);
+        BUG_ON(!dev->hw_ops.get_line_length);
+        BUG_ON(!dev->hw_ops.setfbaddr);
+        BUG_ON(!dev->hw_ops.getfid);
+
+        mutex_lock(&ccdc_lock);
+        if (NULL == ccdc_cfg) {
+                /*
+                 * TODO. Will this ever happen? if so, we need to fix it.
+                 * Proabably we need to add the request to a linked list and
+                 * walk through it during vpfe probe
+                 */
+                printk(KERN_ERR "vpfe capture not initialized\n");
+                ret = -1;
+                goto unlock;
+        }
+
+        if (strcmp(dev->name, ccdc_cfg->name)) {
+                /* ignore this ccdc */
+                ret = -1;
+                goto unlock;
+        }
+
+        if (ccdc_dev) {
+                printk(KERN_ERR "ccdc already registered\n");
+                ret = -1;
+                goto unlock;
+        }
+
+        ccdc_dev = dev;
+        dev->hw_ops.set_ccdc_base(ccdc_cfg->ccdc_addr,
+                                  ccdc_cfg->ccdc_addr_size);
+unlock:
+        mutex_unlock(&ccdc_lock);
+        return ret;
+}
+EXPORT_SYMBOL(vpfe_register_ccdc_device);
+
+/*
+ * vpfe_unregister_ccdc_device. CCDC module calls this to
+ * unregister with vpfe capture
+ */
+void vpfe_unregister_ccdc_device(struct ccdc_hw_device *dev)
+{
+        if (NULL == dev) {
+                printk(KERN_ERR "invalid ccdc device ptr\n");
+                return;
+        }
+
+        printk(KERN_NOTICE "vpfe_unregister_ccdc_device, dev->name = %s\n",
+                dev->name);
+
+        if (strcmp(dev->name, ccdc_cfg->name)) {
+                /* ignore this ccdc */
+                return;
+        }
+
+        mutex_lock(&ccdc_lock);
+        ccdc_dev = NULL;
+        mutex_unlock(&ccdc_lock);
+        return;
+}
+EXPORT_SYMBOL(vpfe_unregister_ccdc_device);
+
+/*
+ * vpfe_get_ccdc_image_format - Get image parameters based on CCDC settings
+ */
+static int vpfe_get_ccdc_image_format(struct vpfe_device *vpfe_dev,
+                                 struct v4l2_format *f)
+{
+        struct v4l2_rect image_win;
+        enum ccdc_buftype buf_type;
+        enum ccdc_frmfmt frm_fmt;
+
+        memset(f, 0, sizeof(*f));
+        f->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+        ccdc_dev->hw_ops.get_image_window(&image_win);
+        f->fmt.pix.width = image_win.width;
+        f->fmt.pix.height = image_win.height;
+        f->fmt.pix.bytesperline = ccdc_dev->hw_ops.get_line_length();
+        f->fmt.pix.sizeimage = f->fmt.pix.bytesperline *
+                                f->fmt.pix.height;
+        buf_type = ccdc_dev->hw_ops.get_buftype();
+        f->fmt.pix.pixelformat = ccdc_dev->hw_ops.get_pixel_format();
+        frm_fmt = ccdc_dev->hw_ops.get_frame_format();
+        if (frm_fmt == CCDC_FRMFMT_PROGRESSIVE)
+                f->fmt.pix.field = V4L2_FIELD_NONE;
+        else if (frm_fmt == CCDC_FRMFMT_INTERLACED) {
+                if (buf_type == CCDC_BUFTYPE_FLD_INTERLEAVED)
+                        f->fmt.pix.field = V4L2_FIELD_INTERLACED;
+                else if (buf_type == CCDC_BUFTYPE_FLD_SEPARATED)
+                        f->fmt.pix.field = V4L2_FIELD_SEQ_TB;
+                else {
+                        v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf_type\n");
+                        return -EINVAL;
+                }
+        } else {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid frm_fmt\n");
+                return -EINVAL;
+        }
+        return 0;
+}
+
+/*
+ * vpfe_config_ccdc_image_format()
+ * For a pix format, configure ccdc to setup the capture
+ */
+static int vpfe_config_ccdc_image_format(struct vpfe_device *vpfe_dev)
+{
+        enum ccdc_frmfmt frm_fmt = CCDC_FRMFMT_INTERLACED;
+        int ret = 0;
+
+        if (ccdc_dev->hw_ops.set_pixel_format(
+                        vpfe_dev->fmt.fmt.pix.pixelformat) < 0) {
+                v4l2_err(&vpfe_dev->v4l2_dev,
+                        "couldn't set pix format in ccdc\n");
+                return -EINVAL;
+        }
+        /* configure the image window */
+        ccdc_dev->hw_ops.set_image_window(&vpfe_dev->crop);
+
+        switch (vpfe_dev->fmt.fmt.pix.field) {
+        case V4L2_FIELD_INTERLACED:
+                /* do nothing, since it is default */
+                ret = ccdc_dev->hw_ops.set_buftype(
+                                CCDC_BUFTYPE_FLD_INTERLEAVED);
+                break;
+        case V4L2_FIELD_NONE:
+                frm_fmt = CCDC_FRMFMT_PROGRESSIVE;
+                /* buffer type only applicable for interlaced scan */
+                break;
+        case V4L2_FIELD_SEQ_TB:
+                ret = ccdc_dev->hw_ops.set_buftype(
+                                CCDC_BUFTYPE_FLD_SEPARATED);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* set the frame format */
+        if (!ret)
+                ret = ccdc_dev->hw_ops.set_frame_format(frm_fmt);
+        return ret;
+}
+/*
+ * vpfe_config_image_format()
+ * For a given standard, this functions sets up the default
+ * pix format & crop values in the vpfe device and ccdc.  It first
+ * starts with defaults based values from the standard table.
+ * It then checks if sub device support g_fmt and then override the
+ * values based on that.Sets crop values to match with scan resolution
+ * starting at 0,0. It calls vpfe_config_ccdc_image_format() set the
+ * values in ccdc
+ */
+static int vpfe_config_image_format(struct vpfe_device *vpfe_dev,
+                                    const v4l2_std_id *std_id)
+{
+        struct vpfe_subdev_info *sdinfo = vpfe_dev->current_subdev;
+        int i, ret = 0;
+
+        for (i = 0; i < ARRAY_SIZE(vpfe_standards); i++) {
+                if (vpfe_standards[i].std_id & *std_id) {
+                        vpfe_dev->std_info.active_pixels =
+                                        vpfe_standards[i].width;
+                        vpfe_dev->std_info.active_lines =
+                                        vpfe_standards[i].height;
+                        vpfe_dev->std_info.frame_format =
+                                        vpfe_standards[i].frame_format;
+                        vpfe_dev->std_index = i;
+                        break;
+                }
+        }
+
+        if (i ==  ARRAY_SIZE(vpfe_standards)) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "standard not supported\n");
+                return -EINVAL;
+        }
+
+        vpfe_dev->crop.top = 0;
+        vpfe_dev->crop.left = 0;
+        vpfe_dev->crop.width = vpfe_dev->std_info.active_pixels;
+        vpfe_dev->crop.height = vpfe_dev->std_info.active_lines;
+        vpfe_dev->fmt.fmt.pix.width = vpfe_dev->crop.width;
+        vpfe_dev->fmt.fmt.pix.height = vpfe_dev->crop.height;
+
+        /* first field and frame format based on standard frame format */
+        if (vpfe_dev->std_info.frame_format) {
+                vpfe_dev->fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
+                /* assume V4L2_PIX_FMT_UYVY as default */
+                vpfe_dev->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
+        } else {
+                vpfe_dev->fmt.fmt.pix.field = V4L2_FIELD_NONE;
+                /* assume V4L2_PIX_FMT_SBGGR8 */
+                vpfe_dev->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_SBGGR8;
+        }
+
+        /* if sub device supports g_fmt, override the defaults */
+        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev,
+                        sdinfo->grp_id, video, g_fmt, &vpfe_dev->fmt);
+
+        if (ret && ret != -ENOIOCTLCMD) {
+                v4l2_err(&vpfe_dev->v4l2_dev,
+                        "error in getting g_fmt from sub device\n");
+                return ret;
+        }
+
+        /* Sets the values in CCDC */
+        ret = vpfe_config_ccdc_image_format(vpfe_dev);
+        if (ret)
+                return ret;
+
+        /* Update the values of sizeimage and bytesperline */
+        if (!ret) {
+                vpfe_dev->fmt.fmt.pix.bytesperline =
+                        ccdc_dev->hw_ops.get_line_length();
+                vpfe_dev->fmt.fmt.pix.sizeimage =
+                        vpfe_dev->fmt.fmt.pix.bytesperline *
+                        vpfe_dev->fmt.fmt.pix.height;
+        }
+        return ret;
+}
+
+static int vpfe_initialize_device(struct vpfe_device *vpfe_dev)
+{
+        int ret = 0;
+
+        /* set first input of current subdevice as the current input */
+        vpfe_dev->current_input = 0;
+
+        /* set default standard */
+        vpfe_dev->std_index = 0;
+
+        /* Configure the default format information */
+        ret = vpfe_config_image_format(vpfe_dev,
+                                &vpfe_standards[vpfe_dev->std_index].std_id);
+        if (ret)
+                return ret;
+
+        /* now open the ccdc device to initialize it */
+        mutex_lock(&ccdc_lock);
+        if (NULL == ccdc_dev) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "ccdc device not registered\n");
+                ret = -ENODEV;
+                goto unlock;
+        }
+
+        if (!try_module_get(ccdc_dev->owner)) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Couldn't lock ccdc module\n");
+                ret = -ENODEV;
+                goto unlock;
+        }
+        ret = ccdc_dev->hw_ops.open(vpfe_dev->pdev);
+        if (!ret)
+                vpfe_dev->initialized = 1;
+unlock:
+        mutex_unlock(&ccdc_lock);
+        return ret;
+}
+
+/*
+ * vpfe_open : It creates object of file handle structure and
+ * stores it in private_data  member of filepointer
+ */
+static int vpfe_open(struct file *file)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        struct vpfe_fh *fh;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_open\n");
+
+        if (!vpfe_dev->cfg->num_subdevs) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "No decoder registered\n");
+                return -ENODEV;
+        }
+
+        /* Allocate memory for the file handle object */
+        fh = kmalloc(sizeof(struct vpfe_fh), GFP_KERNEL);
+        if (NULL == fh) {
+                v4l2_err(&vpfe_dev->v4l2_dev,
+                        "unable to allocate memory for file handle object\n");
+                return -ENOMEM;
+        }
+        /* store pointer to fh in private_data member of file */
+        file->private_data = fh;
+        fh->vpfe_dev = vpfe_dev;
+        mutex_lock(&vpfe_dev->lock);
+        /* If decoder is not initialized. initialize it */
+        if (!vpfe_dev->initialized) {
+                if (vpfe_initialize_device(vpfe_dev)) {
+                        mutex_unlock(&vpfe_dev->lock);
+                        return -ENODEV;
+                }
+        }
+        /* Increment device usrs counter */
+        vpfe_dev->usrs++;
+        /* Set io_allowed member to false */
+        fh->io_allowed = 0;
+        /* Initialize priority of this instance to default priority */
+        fh->prio = V4L2_PRIORITY_UNSET;
+        v4l2_prio_open(&vpfe_dev->prio, &fh->prio);
+        mutex_unlock(&vpfe_dev->lock);
+        return 0;
+}
+
+static void vpfe_schedule_next_buffer(struct vpfe_device *vpfe_dev)
+{
+        unsigned long addr;
+
+        vpfe_dev->next_frm = list_entry(vpfe_dev->dma_queue.next,
+                                        struct videobuf_buffer, queue);
+        list_del(&vpfe_dev->next_frm->queue);
+        vpfe_dev->next_frm->state = VIDEOBUF_ACTIVE;
+        addr = videobuf_to_dma_contig(vpfe_dev->next_frm);
+        ccdc_dev->hw_ops.setfbaddr(addr);
+}
+
+static void vpfe_process_buffer_complete(struct vpfe_device *vpfe_dev)
+{
+        struct timeval timevalue;
+
+        do_gettimeofday(&timevalue);
+        vpfe_dev->cur_frm->ts = timevalue;
+        vpfe_dev->cur_frm->state = VIDEOBUF_DONE;
+        vpfe_dev->cur_frm->size = vpfe_dev->fmt.fmt.pix.sizeimage;
+        wake_up_interruptible(&vpfe_dev->cur_frm->done);
+        vpfe_dev->cur_frm = vpfe_dev->next_frm;
+}
+
+/* ISR for VINT0*/
+static irqreturn_t vpfe_isr(int irq, void *dev_id)
+{
+        struct vpfe_device *vpfe_dev = dev_id;
+        enum v4l2_field field;
+        unsigned long addr;
+        int fid;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "\nStarting vpfe_isr...\n");
+        field = vpfe_dev->fmt.fmt.pix.field;
+
+        /* if streaming not started, don't do anything */
+        if (!vpfe_dev->started)
+                return IRQ_HANDLED;
+
+        /* only for 6446 this will be applicable */
+        if (NULL != ccdc_dev->hw_ops.reset)
+                ccdc_dev->hw_ops.reset();
+
+        if (field == V4L2_FIELD_NONE) {
+                /* handle progressive frame capture */
+                v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
+                        "frame format is progressive...\n");
+                if (vpfe_dev->cur_frm != vpfe_dev->next_frm)
+                        vpfe_process_buffer_complete(vpfe_dev);
+                return IRQ_HANDLED;
+        }
+
+        /* interlaced or TB capture check which field we are in hardware */
+        fid = ccdc_dev->hw_ops.getfid();
+
+        /* switch the software maintained field id */
+        vpfe_dev->field_id ^= 1;
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "field id = %x:%x.\n",
+                fid, vpfe_dev->field_id);
+        if (fid == vpfe_dev->field_id) {
+                /* we are in-sync here,continue */
+                if (fid == 0) {
+                        /*
+                         * One frame is just being captured. If the next frame
+                         * is available, release the current frame and move on
+                         */
+                        if (vpfe_dev->cur_frm != vpfe_dev->next_frm)
+                                vpfe_process_buffer_complete(vpfe_dev);
+                        /*
+                         * based on whether the two fields are stored
+                         * interleavely or separately in memory, reconfigure
+                         * the CCDC memory address
+                         */
+                        if (field == V4L2_FIELD_SEQ_TB) {
+                                addr =
+                                  videobuf_to_dma_contig(vpfe_dev->cur_frm);
+                                addr += vpfe_dev->field_off;
+                                ccdc_dev->hw_ops.setfbaddr(addr);
+                        }
+                        return IRQ_HANDLED;
+                }
+                /*
+                 * if one field is just being captured configure
+                 * the next frame get the next frame from the empty
+                 * queue if no frame is available hold on to the
+                 * current buffer
+                 */
+                spin_lock(&vpfe_dev->dma_queue_lock);
+                if (!list_empty(&vpfe_dev->dma_queue) &&
+                    vpfe_dev->cur_frm == vpfe_dev->next_frm)
+                        vpfe_schedule_next_buffer(vpfe_dev);
+                spin_unlock(&vpfe_dev->dma_queue_lock);
+        } else if (fid == 0) {
+                /*
+                 * out of sync. Recover from any hardware out-of-sync.
+                 * May loose one frame
+                 */
+                vpfe_dev->field_id = fid;
+        }
+        return IRQ_HANDLED;
+}
+
+/* vdint1_isr - isr handler for VINT1 interrupt */
+static irqreturn_t vdint1_isr(int irq, void *dev_id)
+{
+        struct vpfe_device *vpfe_dev = dev_id;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "\nInside vdint1_isr...\n");
+
+        /* if streaming not started, don't do anything */
+        if (!vpfe_dev->started)
+                return IRQ_HANDLED;
+
+        spin_lock(&vpfe_dev->dma_queue_lock);
+        if ((vpfe_dev->fmt.fmt.pix.field == V4L2_FIELD_NONE) &&
+            !list_empty(&vpfe_dev->dma_queue) &&
+            vpfe_dev->cur_frm == vpfe_dev->next_frm)
+                vpfe_schedule_next_buffer(vpfe_dev);
+        spin_unlock(&vpfe_dev->dma_queue_lock);
+        return IRQ_HANDLED;
+}
+
+static void vpfe_detach_irq(struct vpfe_device *vpfe_dev)
+{
+        enum ccdc_frmfmt frame_format;
+
+        frame_format = ccdc_dev->hw_ops.get_frame_format();
+        if (frame_format == CCDC_FRMFMT_PROGRESSIVE)
+                free_irq(IRQ_VDINT1, vpfe_dev);
+}
+
+static int vpfe_attach_irq(struct vpfe_device *vpfe_dev)
+{
+        enum ccdc_frmfmt frame_format;
+
+        frame_format = ccdc_dev->hw_ops.get_frame_format();
+        if (frame_format == CCDC_FRMFMT_PROGRESSIVE) {
+                return request_irq(vpfe_dev->ccdc_irq1, vdint1_isr,
+                                    IRQF_DISABLED, "vpfe_capture1",
+                                    vpfe_dev);
+        }
+        return 0;
+}
+
+/* vpfe_stop_ccdc_capture: stop streaming in ccdc/isif */
+static void vpfe_stop_ccdc_capture(struct vpfe_device *vpfe_dev)
+{
+        vpfe_dev->started = 0;
+        ccdc_dev->hw_ops.enable(0);
+        if (ccdc_dev->hw_ops.enable_out_to_sdram)
+                ccdc_dev->hw_ops.enable_out_to_sdram(0);
+}
+
+/*
+ * vpfe_release : This function deletes buffer queue, frees the
+ * buffers and the vpfe file  handle
+ */
+static int vpfe_release(struct file *file)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        struct vpfe_fh *fh = file->private_data;
+        struct vpfe_subdev_info *sdinfo;
+        int ret;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_release\n");
+
+        /* Get the device lock */
+        mutex_lock(&vpfe_dev->lock);
+        /* if this instance is doing IO */
+        if (fh->io_allowed) {
+                if (vpfe_dev->started) {
+                        sdinfo = vpfe_dev->current_subdev;
+                        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev,
+                                                         sdinfo->grp_id,
+                                                         video, s_stream, 0);
+                        if (ret && (ret != -ENOIOCTLCMD))
+                                v4l2_err(&vpfe_dev->v4l2_dev,
+                                "stream off failed in subdev\n");
+                        vpfe_stop_ccdc_capture(vpfe_dev);
+                        vpfe_detach_irq(vpfe_dev);
+                        videobuf_streamoff(&vpfe_dev->buffer_queue);
+                }
+                vpfe_dev->io_usrs = 0;
+                vpfe_dev->numbuffers = config_params.numbuffers;
+        }
+
+        /* Decrement device usrs counter */
+        vpfe_dev->usrs--;
+        /* Close the priority */
+        v4l2_prio_close(&vpfe_dev->prio, &fh->prio);
+        /* If this is the last file handle */
+        if (!vpfe_dev->usrs) {
+                vpfe_dev->initialized = 0;
+                if (ccdc_dev->hw_ops.close)
+                        ccdc_dev->hw_ops.close(vpfe_dev->pdev);
+                module_put(ccdc_dev->owner);
+        }
+        mutex_unlock(&vpfe_dev->lock);
+        file->private_data = NULL;
+        /* Free memory allocated to file handle object */
+        kfree(fh);
+        return 0;
+}
+
+/*
+ * vpfe_mmap : It is used to map kernel space buffers
+ * into user spaces
+ */
+static int vpfe_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        /* Get the device object and file handle object */
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_mmap\n");
+
+        return videobuf_mmap_mapper(&vpfe_dev->buffer_queue, vma);
+}
+
+/*
+ * vpfe_poll: It is used for select/poll system call
+ */
+static unsigned int vpfe_poll(struct file *file, poll_table *wait)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_poll\n");
+
+        if (vpfe_dev->started)
+                return videobuf_poll_stream(file,
+                                            &vpfe_dev->buffer_queue, wait);
+        return 0;
+}
+
+/* vpfe capture driver file operations */
+static const struct v4l2_file_operations vpfe_fops = {
+        .owner = THIS_MODULE,
+        .open = vpfe_open,
+        .release = vpfe_release,
+        .unlocked_ioctl = video_ioctl2,
+        .mmap = vpfe_mmap,
+        .poll = vpfe_poll
+};
+
+/*
+ * vpfe_check_format()
+ * This function adjust the input pixel format as per hardware
+ * capabilities and update the same in pixfmt.
+ * Following algorithm used :-
+ *
+ *      If given pixformat is not in the vpfe list of pix formats or not
+ *      supported by the hardware, current value of pixformat in the device
+ *      is used
+ *      If given field is not supported, then current field is used. If field
+ *      is different from current, then it is matched with that from sub device.
+ *      Minimum height is 2 lines for interlaced or tb field and 1 line for
+ *      progressive. Maximum height is clamped to active active lines of scan
+ *      Minimum width is 32 bytes in memory and width is clamped to active
+ *      pixels of scan.
+ *      bytesperline is a multiple of 32.
+ */
+static const struct vpfe_pixel_format *
+        vpfe_check_format(struct vpfe_device *vpfe_dev,
+                          struct v4l2_pix_format *pixfmt)
+{
+        u32 min_height = 1, min_width = 32, max_width, max_height;
+        const struct vpfe_pixel_format *vpfe_pix_fmt;
+        u32 pix;
+        int temp, found;
+
+        vpfe_pix_fmt = vpfe_lookup_pix_format(pixfmt->pixelformat);
+        if (NULL == vpfe_pix_fmt) {
+                /*
+                 * use current pixel format in the vpfe device. We
+                 * will find this pix format in the table
+                 */
+                pixfmt->pixelformat = vpfe_dev->fmt.fmt.pix.pixelformat;
+                vpfe_pix_fmt = vpfe_lookup_pix_format(pixfmt->pixelformat);
+        }
+
+        /* check if hw supports it */
+        temp = 0;
+        found = 0;
+        while (ccdc_dev->hw_ops.enum_pix(&pix, temp) >= 0) {
+                if (vpfe_pix_fmt->fmtdesc.pixelformat == pix) {
+                        found = 1;
+                        break;
+                }
+                temp++;
+        }
+
+        if (!found) {
+                /* use current pixel format */
+                pixfmt->pixelformat = vpfe_dev->fmt.fmt.pix.pixelformat;
+                /*
+                 * Since this is currently used in the vpfe device, we
+                 * will find this pix format in the table
+                 */
+                vpfe_pix_fmt = vpfe_lookup_pix_format(pixfmt->pixelformat);
+        }
+
+        /* check what field format is supported */
+        if (pixfmt->field == V4L2_FIELD_ANY) {
+                /* if field is any, use current value as default */
+                pixfmt->field = vpfe_dev->fmt.fmt.pix.field;
+        }
+
+        /*
+         * if field is not same as current field in the vpfe device
+         * try matching the field with the sub device field
+         */
+        if (vpfe_dev->fmt.fmt.pix.field != pixfmt->field) {
+                /*
+                 * If field value is not in the supported fields, use current
+                 * field used in the device as default
+                 */
+                switch (pixfmt->field) {
+                case V4L2_FIELD_INTERLACED:
+                case V4L2_FIELD_SEQ_TB:
+                        /* if sub device is supporting progressive, use that */
+                        if (!vpfe_dev->std_info.frame_format)
+                                pixfmt->field = V4L2_FIELD_NONE;
+                        break;
+                case V4L2_FIELD_NONE:
+                        if (vpfe_dev->std_info.frame_format)
+                                pixfmt->field = V4L2_FIELD_INTERLACED;
+                        break;
+
+                default:
+                        /* use current field as default */
+                        pixfmt->field = vpfe_dev->fmt.fmt.pix.field;
+                        break;
+                }
+        }
+
+        /* Now adjust image resolutions supported */
+        if (pixfmt->field == V4L2_FIELD_INTERLACED ||
+            pixfmt->field == V4L2_FIELD_SEQ_TB)
+                min_height = 2;
+
+        max_width = vpfe_dev->std_info.active_pixels;
+        max_height = vpfe_dev->std_info.active_lines;
+        min_width /= vpfe_pix_fmt->bpp;
+
+        v4l2_info(&vpfe_dev->v4l2_dev, "width = %d, height = %d, bpp = %d\n",
+                  pixfmt->width, pixfmt->height, vpfe_pix_fmt->bpp);
+
+        pixfmt->width = clamp((pixfmt->width), min_width, max_width);
+        pixfmt->height = clamp((pixfmt->height), min_height, max_height);
+
+        /* If interlaced, adjust height to be a multiple of 2 */
+        if (pixfmt->field == V4L2_FIELD_INTERLACED)
+                pixfmt->height &= (~1);
+        /*
+         * recalculate bytesperline and sizeimage since width
+         * and height might have changed
+         */
+        pixfmt->bytesperline = (((pixfmt->width * vpfe_pix_fmt->bpp) + 31)
+                                & ~31);
+        if (pixfmt->pixelformat == V4L2_PIX_FMT_NV12)
+                pixfmt->sizeimage =
+                        pixfmt->bytesperline * pixfmt->height +
+                        ((pixfmt->bytesperline * pixfmt->height) >> 1);
+        else
+                pixfmt->sizeimage = pixfmt->bytesperline * pixfmt->height;
+
+        v4l2_info(&vpfe_dev->v4l2_dev, "adjusted width = %d, height ="
+                 " %d, bpp = %d, bytesperline = %d, sizeimage = %d\n",
+                 pixfmt->width, pixfmt->height, vpfe_pix_fmt->bpp,
+                 pixfmt->bytesperline, pixfmt->sizeimage);
+        return vpfe_pix_fmt;
+}
+
+static int vpfe_querycap(struct file *file, void  *priv,
+                               struct v4l2_capability *cap)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querycap\n");
+
+        cap->version = VPFE_CAPTURE_VERSION_CODE;
+        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+        strlcpy(cap->driver, CAPTURE_DRV_NAME, sizeof(cap->driver));
+        strlcpy(cap->bus_info, "VPFE", sizeof(cap->bus_info));
+        strlcpy(cap->card, vpfe_dev->cfg->card_name, sizeof(cap->card));
+        return 0;
+}
+
+static int vpfe_g_fmt_vid_cap(struct file *file, void *priv,
+                                struct v4l2_format *fmt)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        int ret = 0;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_fmt_vid_cap\n");
+        /* Fill in the information about format */
+        *fmt = vpfe_dev->fmt;
+        return ret;
+}
+
+static int vpfe_enum_fmt_vid_cap(struct file *file, void  *priv,
+                                   struct v4l2_fmtdesc *fmt)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        const struct vpfe_pixel_format *pix_fmt;
+        int temp_index;
+        u32 pix;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_fmt_vid_cap\n");
+
+        if (ccdc_dev->hw_ops.enum_pix(&pix, fmt->index) < 0)
+                return -EINVAL;
+
+        /* Fill in the information about format */
+        pix_fmt = vpfe_lookup_pix_format(pix);
+        if (NULL != pix_fmt) {
+                temp_index = fmt->index;
+                *fmt = pix_fmt->fmtdesc;
+                fmt->index = temp_index;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+static int vpfe_s_fmt_vid_cap(struct file *file, void *priv,
+                                struct v4l2_format *fmt)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        const struct vpfe_pixel_format *pix_fmts;
+        int ret = 0;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_fmt_vid_cap\n");
+
+        /* If streaming is started, return error */
+        if (vpfe_dev->started) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Streaming is started\n");
+                return -EBUSY;
+        }
+
+        /* Check for valid frame format */
+        pix_fmts = vpfe_check_format(vpfe_dev, &fmt->fmt.pix);
+
+        if (NULL == pix_fmts)
+                return -EINVAL;
+
+        /* store the pixel format in the device  object */
+        ret = mutex_lock_interruptible(&vpfe_dev->lock);
+        if (ret)
+                return ret;
+
+        /* First detach any IRQ if currently attached */
+        vpfe_detach_irq(vpfe_dev);
+        vpfe_dev->fmt = *fmt;
+        /* set image capture parameters in the ccdc */
+        ret = vpfe_config_ccdc_image_format(vpfe_dev);
+        mutex_unlock(&vpfe_dev->lock);
+        return ret;
+}
+
+static int vpfe_try_fmt_vid_cap(struct file *file, void *priv,
+                                  struct v4l2_format *f)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        const struct vpfe_pixel_format *pix_fmts;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_try_fmt_vid_cap\n");
+
+        pix_fmts = vpfe_check_format(vpfe_dev, &f->fmt.pix);
+        if (NULL == pix_fmts)
+                return -EINVAL;
+        return 0;
+}
+
+/*
+ * vpfe_get_subdev_input_index - Get subdev index and subdev input index for a
+ * given app input index
+ */
+static int vpfe_get_subdev_input_index(struct vpfe_device *vpfe_dev,
+                                        int *subdev_index,
+                                        int *subdev_input_index,
+                                        int app_input_index)
+{
+        struct vpfe_config *cfg = vpfe_dev->cfg;
+        struct vpfe_subdev_info *sdinfo;
+        int i, j = 0;
+
+        for (i = 0; i < cfg->num_subdevs; i++) {
+                sdinfo = &cfg->sub_devs[i];
+                if (app_input_index < (j + sdinfo->num_inputs)) {
+                        *subdev_index = i;
+                        *subdev_input_index = app_input_index - j;
+                        return 0;
+                }
+                j += sdinfo->num_inputs;
+        }
+        return -EINVAL;
+}
+
+/*
+ * vpfe_get_app_input - Get app input index for a given subdev input index
+ * driver stores the input index of the current sub device and translate it
+ * when application request the current input
+ */
+static int vpfe_get_app_input_index(struct vpfe_device *vpfe_dev,
+                                    int *app_input_index)
+{
+        struct vpfe_config *cfg = vpfe_dev->cfg;
+        struct vpfe_subdev_info *sdinfo;
+        int i, j = 0;
+
+        for (i = 0; i < cfg->num_subdevs; i++) {
+                sdinfo = &cfg->sub_devs[i];
+                if (!strcmp(sdinfo->name, vpfe_dev->current_subdev->name)) {
+                        if (vpfe_dev->current_input >= sdinfo->num_inputs)
+                                return -1;
+                        *app_input_index = j + vpfe_dev->current_input;
+                        return 0;
+                }
+                j += sdinfo->num_inputs;
+        }
+        return -EINVAL;
+}
+
+static int vpfe_enum_input(struct file *file, void *priv,
+                                 struct v4l2_input *inp)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        struct vpfe_subdev_info *sdinfo;
+        int subdev, index ;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_input\n");
+
+        if (vpfe_get_subdev_input_index(vpfe_dev,
+                                        &subdev,
+                                        &index,
+                                        inp->index) < 0) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "input information not found"
+                         " for the subdev\n");
+                return -EINVAL;
+        }
+        sdinfo = &vpfe_dev->cfg->sub_devs[subdev];
+        memcpy(inp, &sdinfo->inputs[index], sizeof(struct v4l2_input));
+        return 0;
+}
+
+static int vpfe_g_input(struct file *file, void *priv, unsigned int *index)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_input\n");
+
+        return vpfe_get_app_input_index(vpfe_dev, index);
+}
+
+
+static int vpfe_s_input(struct file *file, void *priv, unsigned int index)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        struct vpfe_subdev_info *sdinfo;
+        int subdev_index, inp_index;
+        struct vpfe_route *route;
+        u32 input = 0, output = 0;
+        int ret = -EINVAL;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_input\n");
+
+        ret = mutex_lock_interruptible(&vpfe_dev->lock);
+        if (ret)
+                return ret;
+
+        /*
+         * If streaming is started return device busy
+         * error
+         */
+        if (vpfe_dev->started) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Streaming is on\n");
+                ret = -EBUSY;
+                goto unlock_out;
+        }
+
+        if (vpfe_get_subdev_input_index(vpfe_dev,
+                                        &subdev_index,
+                                        &inp_index,
+                                        index) < 0) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "invalid input index\n");
+                goto unlock_out;
+        }
+
+        sdinfo = &vpfe_dev->cfg->sub_devs[subdev_index];
+        route = &sdinfo->routes[inp_index];
+        if (route && sdinfo->can_route) {
+                input = route->input;
+                output = route->output;
+        }
+
+        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
+                                         video, s_routing, input, output, 0);
+
+        if (ret) {
+                v4l2_err(&vpfe_dev->v4l2_dev,
+                        "vpfe_doioctl:error in setting input in decoder\n");
+                ret = -EINVAL;
+                goto unlock_out;
+        }
+        vpfe_dev->current_subdev = sdinfo;
+        vpfe_dev->current_input = index;
+        vpfe_dev->std_index = 0;
+
+        /* set the bus/interface parameter for the sub device in ccdc */
+        ret = ccdc_dev->hw_ops.set_hw_if_params(&sdinfo->ccdc_if_params);
+        if (ret)
+                goto unlock_out;
+
+        /* set the default image parameters in the device */
+        ret = vpfe_config_image_format(vpfe_dev,
+                                &vpfe_standards[vpfe_dev->std_index].std_id);
+unlock_out:
+        mutex_unlock(&vpfe_dev->lock);
+        return ret;
+}
+
+static int vpfe_querystd(struct file *file, void *priv, v4l2_std_id *std_id)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        struct vpfe_subdev_info *sdinfo;
+        int ret = 0;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querystd\n");
+
+        ret = mutex_lock_interruptible(&vpfe_dev->lock);
+        sdinfo = vpfe_dev->current_subdev;
+        if (ret)
+                return ret;
+        /* Call querystd function of decoder device */
+        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
+                                         video, querystd, std_id);
+        mutex_unlock(&vpfe_dev->lock);
+        return ret;
+}
+
+static int vpfe_s_std(struct file *file, void *priv, v4l2_std_id *std_id)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        struct vpfe_subdev_info *sdinfo;
+        int ret = 0;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_std\n");
+
+        /* Call decoder driver function to set the standard */
+        ret = mutex_lock_interruptible(&vpfe_dev->lock);
+        if (ret)
+                return ret;
+
+        sdinfo = vpfe_dev->current_subdev;
+        /* If streaming is started, return device busy error */
+        if (vpfe_dev->started) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "streaming is started\n");
+                ret = -EBUSY;
+                goto unlock_out;
+        }
+
+        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
+                                         core, s_std, *std_id);
+        if (ret < 0) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Failed to set standard\n");
+                goto unlock_out;
+        }
+        ret = vpfe_config_image_format(vpfe_dev, std_id);
+
+unlock_out:
+        mutex_unlock(&vpfe_dev->lock);
+        return ret;
+}
+
+static int vpfe_g_std(struct file *file, void *priv, v4l2_std_id *std_id)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_std\n");
+
+        *std_id = vpfe_standards[vpfe_dev->std_index].std_id;
+        return 0;
+}
+/*
+ *  Videobuf operations
+ */
+static int vpfe_videobuf_setup(struct videobuf_queue *vq,
+                                unsigned int *count,
+                                unsigned int *size)
+{
+        struct vpfe_fh *fh = vq->priv_data;
+        struct vpfe_device *vpfe_dev = fh->vpfe_dev;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_buffer_setup\n");
+        *size = config_params.device_bufsize;
+
+        if (*count < config_params.min_numbuffers)
+                *count = config_params.min_numbuffers;
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
+                "count=%d, size=%d\n", *count, *size);
+        return 0;
+}
+
+static int vpfe_videobuf_prepare(struct videobuf_queue *vq,
+                                struct videobuf_buffer *vb,
+                                enum v4l2_field field)
+{
+        struct vpfe_fh *fh = vq->priv_data;
+        struct vpfe_device *vpfe_dev = fh->vpfe_dev;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_buffer_prepare\n");
+
+        /* If buffer is not initialized, initialize it */
+        if (VIDEOBUF_NEEDS_INIT == vb->state) {
+                vb->width = vpfe_dev->fmt.fmt.pix.width;
+                vb->height = vpfe_dev->fmt.fmt.pix.height;
+                vb->size = vpfe_dev->fmt.fmt.pix.sizeimage;
+                vb->field = field;
+        }
+        vb->state = VIDEOBUF_PREPARED;
+        return 0;
+}
+
+static void vpfe_videobuf_queue(struct videobuf_queue *vq,
+                                struct videobuf_buffer *vb)
+{
+        /* Get the file handle object and device object */
+        struct vpfe_fh *fh = vq->priv_data;
+        struct vpfe_device *vpfe_dev = fh->vpfe_dev;
+        unsigned long flags;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_buffer_queue\n");
+
+        /* add the buffer to the DMA queue */
+        spin_lock_irqsave(&vpfe_dev->dma_queue_lock, flags);
+        list_add_tail(&vb->queue, &vpfe_dev->dma_queue);
+        spin_unlock_irqrestore(&vpfe_dev->dma_queue_lock, flags);
+
+        /* Change state of the buffer */
+        vb->state = VIDEOBUF_QUEUED;
+}
+
+static void vpfe_videobuf_release(struct videobuf_queue *vq,
+                                  struct videobuf_buffer *vb)
+{
+        struct vpfe_fh *fh = vq->priv_data;
+        struct vpfe_device *vpfe_dev = fh->vpfe_dev;
+        unsigned long flags;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_videobuf_release\n");
+
+        /*
+         * We need to flush the buffer from the dma queue since
+         * they are de-allocated
+         */
+        spin_lock_irqsave(&vpfe_dev->dma_queue_lock, flags);
+        INIT_LIST_HEAD(&vpfe_dev->dma_queue);
+        spin_unlock_irqrestore(&vpfe_dev->dma_queue_lock, flags);
+        videobuf_dma_contig_free(vq, vb);
+        vb->state = VIDEOBUF_NEEDS_INIT;
+}
+
+static struct videobuf_queue_ops vpfe_videobuf_qops = {
+        .buf_setup      = vpfe_videobuf_setup,
+        .buf_prepare    = vpfe_videobuf_prepare,
+        .buf_queue      = vpfe_videobuf_queue,
+        .buf_release    = vpfe_videobuf_release,
+};
+
+/*
+ * vpfe_reqbufs. currently support REQBUF only once opening
+ * the device.
+ */
+static int vpfe_reqbufs(struct file *file, void *priv,
+                        struct v4l2_requestbuffers *req_buf)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        struct vpfe_fh *fh = file->private_data;
+        int ret = 0;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_reqbufs\n");
+
+        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != req_buf->type) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buffer type\n");
+                return -EINVAL;
+        }
+
+        if (V4L2_MEMORY_USERPTR == req_buf->memory) {
+                /* we don't support user ptr IO */
+                v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_reqbufs:"
+                         " USERPTR IO not supported\n");
+                return  -EINVAL;
+        }
+
+        ret = mutex_lock_interruptible(&vpfe_dev->lock);
+        if (ret)
+                return ret;
+
+        if (vpfe_dev->io_usrs != 0) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Only one IO user allowed\n");
+                ret = -EBUSY;
+                goto unlock_out;
+        }
+
+        vpfe_dev->memory = req_buf->memory;
+        videobuf_queue_dma_contig_init(&vpfe_dev->buffer_queue,
+                                &vpfe_videobuf_qops,
+                                NULL,
+                                &vpfe_dev->irqlock,
+                                req_buf->type,
+                                vpfe_dev->fmt.fmt.pix.field,
+                                sizeof(struct videobuf_buffer),
+                                fh);
+
+        fh->io_allowed = 1;
+        vpfe_dev->io_usrs = 1;
+        INIT_LIST_HEAD(&vpfe_dev->dma_queue);
+        ret = videobuf_reqbufs(&vpfe_dev->buffer_queue, req_buf);
+unlock_out:
+        mutex_unlock(&vpfe_dev->lock);
+        return ret;
+}
+
+static int vpfe_querybuf(struct file *file, void *priv,
+                         struct v4l2_buffer *buf)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querybuf\n");
+
+        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf->type) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
+                return  -EINVAL;
+        }
+
+        if (vpfe_dev->memory != V4L2_MEMORY_MMAP) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid memory\n");
+                return -EINVAL;
+        }
+        /* Call videobuf_querybuf to get information */
+        return videobuf_querybuf(&vpfe_dev->buffer_queue, buf);
+}
+
+static int vpfe_qbuf(struct file *file, void *priv,
+                     struct v4l2_buffer *p)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        struct vpfe_fh *fh = file->private_data;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_qbuf\n");
+
+        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != p->type) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
+                return -EINVAL;
+        }
+
+        /*
+         * If this file handle is not allowed to do IO,
+         * return error
+         */
+        if (!fh->io_allowed) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "fh->io_allowed\n");
+                return -EACCES;
+        }
+        return videobuf_qbuf(&vpfe_dev->buffer_queue, p);
+}
+
+static int vpfe_dqbuf(struct file *file, void *priv,
+                      struct v4l2_buffer *buf)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_dqbuf\n");
+
+        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf->type) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
+                return -EINVAL;
+        }
+        return videobuf_dqbuf(&vpfe_dev->buffer_queue,
+                                      buf, file->f_flags & O_NONBLOCK);
+}
+
+/*
+ * vpfe_calculate_offsets : This function calculates buffers offset
+ * for top and bottom field
+ */
+static void vpfe_calculate_offsets(struct vpfe_device *vpfe_dev)
+{
+        struct v4l2_rect image_win;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_calculate_offsets\n");
+
+        ccdc_dev->hw_ops.get_image_window(&image_win);
+        vpfe_dev->field_off = image_win.height * image_win.width;
+}
+
+/* vpfe_start_ccdc_capture: start streaming in ccdc/isif */
+static void vpfe_start_ccdc_capture(struct vpfe_device *vpfe_dev)
+{
+        ccdc_dev->hw_ops.enable(1);
+        if (ccdc_dev->hw_ops.enable_out_to_sdram)
+                ccdc_dev->hw_ops.enable_out_to_sdram(1);
+        vpfe_dev->started = 1;
+}
+
+/*
+ * vpfe_streamon. Assume the DMA queue is not empty.
+ * application is expected to call QBUF before calling
+ * this ioctl. If not, driver returns error
+ */
+static int vpfe_streamon(struct file *file, void *priv,
+                         enum v4l2_buf_type buf_type)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        struct vpfe_fh *fh = file->private_data;
+        struct vpfe_subdev_info *sdinfo;
+        unsigned long addr;
+        int ret = 0;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_streamon\n");
+
+        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf_type) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
+                return -EINVAL;
+        }
+
+        /* If file handle is not allowed IO, return error */
+        if (!fh->io_allowed) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "fh->io_allowed\n");
+                return -EACCES;
+        }
+
+        sdinfo = vpfe_dev->current_subdev;
+        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
+                                        video, s_stream, 1);
+
+        if (ret && (ret != -ENOIOCTLCMD)) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "stream on failed in subdev\n");
+                return -EINVAL;
+        }
+
+        /* If buffer queue is empty, return error */
+        if (list_empty(&vpfe_dev->buffer_queue.stream)) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "buffer queue is empty\n");
+                return -EIO;
+        }
+
+        /* Call videobuf_streamon to start streaming * in videobuf */
+        ret = videobuf_streamon(&vpfe_dev->buffer_queue);
+        if (ret)
+                return ret;
+
+
+        ret = mutex_lock_interruptible(&vpfe_dev->lock);
+        if (ret)
+                goto streamoff;
+        /* Get the next frame from the buffer queue */
+        vpfe_dev->next_frm = list_entry(vpfe_dev->dma_queue.next,
+                                        struct videobuf_buffer, queue);
+        vpfe_dev->cur_frm = vpfe_dev->next_frm;
+        /* Remove buffer from the buffer queue */
+        list_del(&vpfe_dev->cur_frm->queue);
+        /* Mark state of the current frame to active */
+        vpfe_dev->cur_frm->state = VIDEOBUF_ACTIVE;
+        /* Initialize field_id and started member */
+        vpfe_dev->field_id = 0;
+        addr = videobuf_to_dma_contig(vpfe_dev->cur_frm);
+
+        /* Calculate field offset */
+        vpfe_calculate_offsets(vpfe_dev);
+
+        if (vpfe_attach_irq(vpfe_dev) < 0) {
+                v4l2_err(&vpfe_dev->v4l2_dev,
+                         "Error in attaching interrupt handle\n");
+                ret = -EFAULT;
+                goto unlock_out;
+        }
+        if (ccdc_dev->hw_ops.configure() < 0) {
+                v4l2_err(&vpfe_dev->v4l2_dev,
+                         "Error in configuring ccdc\n");
+                ret = -EINVAL;
+                goto unlock_out;
+        }
+        ccdc_dev->hw_ops.setfbaddr((unsigned long)(addr));
+        vpfe_start_ccdc_capture(vpfe_dev);
+        mutex_unlock(&vpfe_dev->lock);
+        return ret;
+unlock_out:
+        mutex_unlock(&vpfe_dev->lock);
+streamoff:
+        ret = videobuf_streamoff(&vpfe_dev->buffer_queue);
+        return ret;
+}
+
+static int vpfe_streamoff(struct file *file, void *priv,
+                          enum v4l2_buf_type buf_type)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        struct vpfe_fh *fh = file->private_data;
+        struct vpfe_subdev_info *sdinfo;
+        int ret = 0;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_streamoff\n");
+
+        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf_type) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
+                return -EINVAL;
+        }
+
+        /* If io is allowed for this file handle, return error */
+        if (!fh->io_allowed) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "fh->io_allowed\n");
+                return -EACCES;
+        }
+
+        /* If streaming is not started, return error */
+        if (!vpfe_dev->started) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "device started\n");
+                return -EINVAL;
+        }
+
+        ret = mutex_lock_interruptible(&vpfe_dev->lock);
+        if (ret)
+                return ret;
+
+        vpfe_stop_ccdc_capture(vpfe_dev);
+        vpfe_detach_irq(vpfe_dev);
+
+        sdinfo = vpfe_dev->current_subdev;
+        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
+                                        video, s_stream, 0);
+
+        if (ret && (ret != -ENOIOCTLCMD))
+                v4l2_err(&vpfe_dev->v4l2_dev, "stream off failed in subdev\n");
+        ret = videobuf_streamoff(&vpfe_dev->buffer_queue);
+        mutex_unlock(&vpfe_dev->lock);
+        return ret;
+}
+
+static int vpfe_cropcap(struct file *file, void *priv,
+                              struct v4l2_cropcap *crop)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_cropcap\n");
+
+        if (vpfe_dev->std_index > ARRAY_SIZE(vpfe_standards))
+                return -EINVAL;
+
+        memset(crop, 0, sizeof(struct v4l2_cropcap));
+        crop->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        crop->bounds.width = crop->defrect.width =
+                vpfe_standards[vpfe_dev->std_index].width;
+        crop->bounds.height = crop->defrect.height =
+                vpfe_standards[vpfe_dev->std_index].height;
+        crop->pixelaspect = vpfe_standards[vpfe_dev->std_index].pixelaspect;
+        return 0;
+}
+
+static int vpfe_g_crop(struct file *file, void *priv,
+                             struct v4l2_crop *crop)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_crop\n");
+
+        crop->c = vpfe_dev->crop;
+        return 0;
+}
+
+static int vpfe_s_crop(struct file *file, void *priv,
+                             struct v4l2_crop *crop)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        int ret = 0;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_crop\n");
+
+        if (vpfe_dev->started) {
+                /* make sure streaming is not started */
+                v4l2_err(&vpfe_dev->v4l2_dev,
+                        "Cannot change crop when streaming is ON\n");
+                return -EBUSY;
+        }
+
+        ret = mutex_lock_interruptible(&vpfe_dev->lock);
+        if (ret)
+                return ret;
+
+        if (crop->c.top < 0 || crop->c.left < 0) {
+                v4l2_err(&vpfe_dev->v4l2_dev,
+                        "doesn't support negative values for top & left\n");
+                ret = -EINVAL;
+                goto unlock_out;
+        }
+
+        /* adjust the width to 16 pixel boundry */
+        crop->c.width = ((crop->c.width + 15) & ~0xf);
+
+        /* make sure parameters are valid */
+        if ((crop->c.left + crop->c.width >
+                vpfe_dev->std_info.active_pixels) ||
+            (crop->c.top + crop->c.height >
+                vpfe_dev->std_info.active_lines)) {
+                v4l2_err(&vpfe_dev->v4l2_dev, "Error in S_CROP params\n");
+                ret = -EINVAL;
+                goto unlock_out;
+        }
+        ccdc_dev->hw_ops.set_image_window(&crop->c);
+        vpfe_dev->fmt.fmt.pix.width = crop->c.width;
+        vpfe_dev->fmt.fmt.pix.height = crop->c.height;
+        vpfe_dev->fmt.fmt.pix.bytesperline =
+                ccdc_dev->hw_ops.get_line_length();
+        vpfe_dev->fmt.fmt.pix.sizeimage =
+                vpfe_dev->fmt.fmt.pix.bytesperline *
+                vpfe_dev->fmt.fmt.pix.height;
+        vpfe_dev->crop = crop->c;
+unlock_out:
+        mutex_unlock(&vpfe_dev->lock);
+        return ret;
+}
+
+
+static long vpfe_param_handler(struct file *file, void *priv,
+                int cmd, void *param)
+{
+        struct vpfe_device *vpfe_dev = video_drvdata(file);
+        int ret = 0;
+
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_param_handler\n");
+
+        if (vpfe_dev->started) {
+                /* only allowed if streaming is not started */
+                v4l2_err(&vpfe_dev->v4l2_dev, "device already started\n");
+                return -EBUSY;
+        }
+
+        ret = mutex_lock_interruptible(&vpfe_dev->lock);
+        if (ret)
+                return ret;
+
+        switch (cmd) {
+        case VPFE_CMD_S_CCDC_RAW_PARAMS:
+                v4l2_warn(&vpfe_dev->v4l2_dev,
+                          "VPFE_CMD_S_CCDC_RAW_PARAMS: experimental ioctl\n");
+                ret = ccdc_dev->hw_ops.set_params(param);
+                if (ret) {
+                        v4l2_err(&vpfe_dev->v4l2_dev,
+                                "Error in setting parameters in CCDC\n");
+                        goto unlock_out;
+                }
+                if (vpfe_get_ccdc_image_format(vpfe_dev, &vpfe_dev->fmt) < 0) {
+                        v4l2_err(&vpfe_dev->v4l2_dev,
+                                "Invalid image format at CCDC\n");
+                        goto unlock_out;
+                }
+                break;
+        default:
+                ret = -EINVAL;
+        }
+unlock_out:
+        mutex_unlock(&vpfe_dev->lock);
+        return ret;
+}
+
+
+/* vpfe capture ioctl operations */
+static const struct v4l2_ioctl_ops vpfe_ioctl_ops = {
+        .vidioc_querycap         = vpfe_querycap,
+        .vidioc_g_fmt_vid_cap    = vpfe_g_fmt_vid_cap,
+        .vidioc_enum_fmt_vid_cap = vpfe_enum_fmt_vid_cap,
+        .vidioc_s_fmt_vid_cap    = vpfe_s_fmt_vid_cap,
+        .vidioc_try_fmt_vid_cap  = vpfe_try_fmt_vid_cap,
+        .vidioc_enum_input       = vpfe_enum_input,
+        .vidioc_g_input          = vpfe_g_input,
+        .vidioc_s_input          = vpfe_s_input,
+        .vidioc_querystd         = vpfe_querystd,
+        .vidioc_s_std            = vpfe_s_std,
+        .vidioc_g_std            = vpfe_g_std,
+        .vidioc_reqbufs          = vpfe_reqbufs,
+        .vidioc_querybuf         = vpfe_querybuf,
+        .vidioc_qbuf             = vpfe_qbuf,
+        .vidioc_dqbuf            = vpfe_dqbuf,
+        .vidioc_streamon         = vpfe_streamon,
+        .vidioc_streamoff        = vpfe_streamoff,
+        .vidioc_cropcap          = vpfe_cropcap,
+        .vidioc_g_crop           = vpfe_g_crop,
+        .vidioc_s_crop           = vpfe_s_crop,
+        .vidioc_default          = vpfe_param_handler,
+};
+
+static struct vpfe_device *vpfe_initialize(void)
+{
+        struct vpfe_device *vpfe_dev;
+
+        /* Default number of buffers should be 3 */
+        if ((numbuffers > 0) &&
+            (numbuffers < config_params.min_numbuffers))
+                numbuffers = config_params.min_numbuffers;
+
+        /*
+         * Set buffer size to min buffers size if invalid buffer size is
+         * given
+         */
+        if (bufsize < config_params.min_bufsize)
+                bufsize = config_params.min_bufsize;
+
+        config_params.numbuffers = numbuffers;
+
+        if (numbuffers)
+                config_params.device_bufsize = bufsize;
+
+        /* Allocate memory for device objects */
+        vpfe_dev = kzalloc(sizeof(*vpfe_dev), GFP_KERNEL);
+
+        return vpfe_dev;
+}
+
+static void vpfe_disable_clock(struct vpfe_device *vpfe_dev)
+{
+        struct vpfe_config *vpfe_cfg = vpfe_dev->cfg;
+
+        clk_disable(vpfe_cfg->vpssclk);
+        clk_put(vpfe_cfg->vpssclk);
+        clk_disable(vpfe_cfg->slaveclk);
+        clk_put(vpfe_cfg->slaveclk);
+        v4l2_info(vpfe_dev->pdev->driver,
+                 "vpfe vpss master & slave clocks disabled\n");
+}
+
+static int vpfe_enable_clock(struct vpfe_device *vpfe_dev)
+{
+        struct vpfe_config *vpfe_cfg = vpfe_dev->cfg;
+        int ret = -ENOENT;
+
+        vpfe_cfg->vpssclk = clk_get(vpfe_dev->pdev, "vpss_master");
+        if (NULL == vpfe_cfg->vpssclk) {
+                v4l2_err(vpfe_dev->pdev->driver, "No clock defined for"
+                         "vpss_master\n");
+                return ret;
+        }
+
+        if (clk_enable(vpfe_cfg->vpssclk)) {
+                v4l2_err(vpfe_dev->pdev->driver,
+                        "vpfe vpss master clock not enabled\n");
+                goto out;
+        }
+        v4l2_info(vpfe_dev->pdev->driver,
+                 "vpfe vpss master clock enabled\n");
+
+        vpfe_cfg->slaveclk = clk_get(vpfe_dev->pdev, "vpss_slave");
+        if (NULL == vpfe_cfg->slaveclk) {
+                v4l2_err(vpfe_dev->pdev->driver,
+                        "No clock defined for vpss slave\n");
+                goto out;
+        }
+
+        if (clk_enable(vpfe_cfg->slaveclk)) {
+                v4l2_err(vpfe_dev->pdev->driver,
+                         "vpfe vpss slave clock not enabled\n");
+                goto out;
+        }
+        v4l2_info(vpfe_dev->pdev->driver, "vpfe vpss slave clock enabled\n");
+        return 0;
+out:
+        if (vpfe_cfg->vpssclk)
+                clk_put(vpfe_cfg->vpssclk);
+        if (vpfe_cfg->slaveclk)
+                clk_put(vpfe_cfg->slaveclk);
+
+        return -1;
+}
+
+/*
+ * vpfe_probe : This function creates device entries by register
+ * itself to the V4L2 driver and initializes fields of each
+ * device objects
+ */
+static __init int vpfe_probe(struct platform_device *pdev)
+{
+        struct vpfe_subdev_info *sdinfo;
+        struct vpfe_config *vpfe_cfg;
+        struct resource *res1;
+        struct vpfe_device *vpfe_dev;
+        struct i2c_adapter *i2c_adap;
+        struct video_device *vfd;
+        int ret = -ENOMEM, i, j;
+        int num_subdevs = 0;
+
+        /* Get the pointer to the device object */
+        vpfe_dev = vpfe_initialize();
+
+        if (!vpfe_dev) {
+                v4l2_err(pdev->dev.driver,
+                        "Failed to allocate memory for vpfe_dev\n");
+                return ret;
+        }
+
+        vpfe_dev->pdev = &pdev->dev;
+
+        if (NULL == pdev->dev.platform_data) {
+                v4l2_err(pdev->dev.driver, "Unable to get vpfe config\n");
+                ret = -ENOENT;
+                goto probe_free_dev_mem;
+        }
+
+        vpfe_cfg = pdev->dev.platform_data;
+        vpfe_dev->cfg = vpfe_cfg;
+        if (NULL == vpfe_cfg->ccdc ||
+            NULL == vpfe_cfg->card_name ||
+            NULL == vpfe_cfg->sub_devs) {
+                v4l2_err(pdev->dev.driver, "null ptr in vpfe_cfg\n");
+                ret = -ENOENT;
+                goto probe_free_dev_mem;
+        }
+
+        /* enable vpss clocks */
+        ret = vpfe_enable_clock(vpfe_dev);
+        if (ret)
+                goto probe_free_dev_mem;
+
+        mutex_lock(&ccdc_lock);
+        /* Allocate memory for ccdc configuration */
+        ccdc_cfg = kmalloc(sizeof(struct ccdc_config), GFP_KERNEL);
+        if (NULL == ccdc_cfg) {
+                v4l2_err(pdev->dev.driver,
+                         "Memory allocation failed for ccdc_cfg\n");
+                goto probe_disable_clock;
+        }
+
+        strncpy(ccdc_cfg->name, vpfe_cfg->ccdc, 32);
+        /* Get VINT0 irq resource */
+        res1 = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res1) {
+                v4l2_err(pdev->dev.driver,
+                         "Unable to get interrupt for VINT0\n");
+                ret = -ENOENT;
+                goto probe_disable_clock;
+        }
+        vpfe_dev->ccdc_irq0 = res1->start;
+
+        /* Get VINT1 irq resource */
+        res1 = platform_get_resource(pdev,
+                                IORESOURCE_IRQ, 1);
+        if (!res1) {
+                v4l2_err(pdev->dev.driver,
+                         "Unable to get interrupt for VINT1\n");
+                ret = -ENOENT;
+                goto probe_disable_clock;
+        }
+        vpfe_dev->ccdc_irq1 = res1->start;
+
+        /* Get address base of CCDC */
+        res1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res1) {
+                v4l2_err(pdev->dev.driver,
+                        "Unable to get register address map\n");
+                ret = -ENOENT;
+                goto probe_disable_clock;
+        }
+
+        ccdc_cfg->ccdc_addr_size = res1->end - res1->start + 1;
+        if (!request_mem_region(res1->start, ccdc_cfg->ccdc_addr_size,
+                                pdev->dev.driver->name)) {
+                v4l2_err(pdev->dev.driver,
+                        "Failed request_mem_region for ccdc base\n");
+                ret = -ENXIO;
+                goto probe_disable_clock;
+        }
+        ccdc_cfg->ccdc_addr = ioremap_nocache(res1->start,
+                                             ccdc_cfg->ccdc_addr_size);
+        if (!ccdc_cfg->ccdc_addr) {
+                v4l2_err(pdev->dev.driver, "Unable to ioremap ccdc addr\n");
+                ret = -ENXIO;
+                goto probe_out_release_mem1;
+        }
+
+        ret = request_irq(vpfe_dev->ccdc_irq0, vpfe_isr, IRQF_DISABLED,
+                          "vpfe_capture0", vpfe_dev);
+
+        if (0 != ret) {
+                v4l2_err(pdev->dev.driver, "Unable to request interrupt\n");
+                goto probe_out_unmap1;
+        }
+
+        /* Allocate memory for video device */
+        vfd = video_device_alloc();
+        if (NULL == vfd) {
+                ret = -ENOMEM;
+                v4l2_err(pdev->dev.driver,
+                        "Unable to alloc video device\n");
+                goto probe_out_release_irq;
+        }
+
+        /* Initialize field of video device */
+        vfd->release            = video_device_release;
+        vfd->fops               = &vpfe_fops;
+        vfd->ioctl_ops          = &vpfe_ioctl_ops;
+        vfd->minor              = -1;
+        vfd->tvnorms            = 0;
+        vfd->current_norm       = V4L2_STD_PAL;
+        vfd->v4l2_dev           = &vpfe_dev->v4l2_dev;
+        snprintf(vfd->name, sizeof(vfd->name),
+                 "%s_V%d.%d.%d",
+                 CAPTURE_DRV_NAME,
+                 (VPFE_CAPTURE_VERSION_CODE >> 16) & 0xff,
+                 (VPFE_CAPTURE_VERSION_CODE >> 8) & 0xff,
+                 (VPFE_CAPTURE_VERSION_CODE) & 0xff);
+        /* Set video_dev to the video device */
+        vpfe_dev->video_dev     = vfd;
+
+        ret = v4l2_device_register(&pdev->dev, &vpfe_dev->v4l2_dev);
+        if (ret) {
+                v4l2_err(pdev->dev.driver,
+                        "Unable to register v4l2 device.\n");
+                goto probe_out_video_release;
+        }
+        v4l2_info(&vpfe_dev->v4l2_dev, "v4l2 device registered\n");
+        spin_lock_init(&vpfe_dev->irqlock);
+        spin_lock_init(&vpfe_dev->dma_queue_lock);
+        mutex_init(&vpfe_dev->lock);
+
+        /* Initialize field of the device objects */
+        vpfe_dev->numbuffers = config_params.numbuffers;
+
+        /* Initialize prio member of device object */
+        v4l2_prio_init(&vpfe_dev->prio);
+        /* register video device */
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
+                "trying to register vpfe device.\n");
+        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
+                "video_dev=%x\n", (int)&vpfe_dev->video_dev);
+        vpfe_dev->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        ret = video_register_device(vpfe_dev->video_dev,
+                                    VFL_TYPE_GRABBER, -1);
+
+        if (ret) {
+                v4l2_err(pdev->dev.driver,
+                        "Unable to register video device.\n");
+                goto probe_out_v4l2_unregister;
+        }
+
+        v4l2_info(&vpfe_dev->v4l2_dev, "video device registered\n");
+        /* set the driver data in platform device */
+        platform_set_drvdata(pdev, vpfe_dev);
+        /* set driver private data */
+        video_set_drvdata(vpfe_dev->video_dev, vpfe_dev);
+        i2c_adap = i2c_get_adapter(1);
+        vpfe_cfg = pdev->dev.platform_data;
+        num_subdevs = vpfe_cfg->num_subdevs;
+        vpfe_dev->sd = kmalloc(sizeof(struct v4l2_subdev *) * num_subdevs,
+                                GFP_KERNEL);
+        if (NULL == vpfe_dev->sd) {
+                v4l2_err(&vpfe_dev->v4l2_dev,
+                        "unable to allocate memory for subdevice pointers\n");
+                ret = -ENOMEM;
+                goto probe_out_video_unregister;
+        }
+
+        for (i = 0; i < num_subdevs; i++) {
+                struct v4l2_input *inps;
+
+                sdinfo = &vpfe_cfg->sub_devs[i];
+
+                /* Load up the subdevice */
+                vpfe_dev->sd[i] =
+                        v4l2_i2c_new_subdev_board(&vpfe_dev->v4l2_dev,
+                                                  i2c_adap,
+                                                  sdinfo->name,
+                                                  &sdinfo->board_info,
+                                                  NULL);
+                if (vpfe_dev->sd[i]) {
+                        v4l2_info(&vpfe_dev->v4l2_dev,
+                                  "v4l2 sub device %s registered\n",
+                                  sdinfo->name);
+                        vpfe_dev->sd[i]->grp_id = sdinfo->grp_id;
+                        /* update tvnorms from the sub devices */
+                        for (j = 0; j < sdinfo->num_inputs; j++) {
+                                inps = &sdinfo->inputs[j];
+                                vfd->tvnorms |= inps->std;
+                        }
+                } else {
+                        v4l2_info(&vpfe_dev->v4l2_dev,
+                                  "v4l2 sub device %s register fails\n",
+                                  sdinfo->name);
+                        goto probe_sd_out;
+                }
+        }
+
+        /* set first sub device as current one */
+        vpfe_dev->current_subdev = &vpfe_cfg->sub_devs[0];
+
+        /* We have at least one sub device to work with */
+        mutex_unlock(&ccdc_lock);
+        return 0;
+
+probe_sd_out:
+        kfree(vpfe_dev->sd);
+probe_out_video_unregister:
+        video_unregister_device(vpfe_dev->video_dev);
+probe_out_v4l2_unregister:
+        v4l2_device_unregister(&vpfe_dev->v4l2_dev);
+probe_out_video_release:
+        if (vpfe_dev->video_dev->minor == -1)
+                video_device_release(vpfe_dev->video_dev);
+probe_out_release_irq:
+        free_irq(vpfe_dev->ccdc_irq0, vpfe_dev);
+probe_out_unmap1:
+        iounmap(ccdc_cfg->ccdc_addr);
+probe_out_release_mem1:
+        release_mem_region(res1->start, res1->end - res1->start + 1);
+probe_disable_clock:
+        vpfe_disable_clock(vpfe_dev);
+        mutex_unlock(&ccdc_lock);
+        kfree(ccdc_cfg);
+probe_free_dev_mem:
+        kfree(vpfe_dev);
+        return ret;
+}
+
+/*
+ * vpfe_remove : It un-register device from V4L2 driver
+ */
+static int vpfe_remove(struct platform_device *pdev)
+{
+        struct vpfe_device *vpfe_dev = platform_get_drvdata(pdev);
+        struct resource *res;
+
+        v4l2_info(pdev->dev.driver, "vpfe_remove\n");
+
+        free_irq(vpfe_dev->ccdc_irq0, vpfe_dev);
+        kfree(vpfe_dev->sd);
+        v4l2_device_unregister(&vpfe_dev->v4l2_dev);
+        video_unregister_device(vpfe_dev->video_dev);
+        mutex_lock(&ccdc_lock);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, res->end - res->start + 1);
+        iounmap(ccdc_cfg->ccdc_addr);
+        mutex_unlock(&ccdc_lock);
+        vpfe_disable_clock(vpfe_dev);
+        kfree(vpfe_dev);
+        kfree(ccdc_cfg);
+        return 0;
+}
+
+static int
+vpfe_suspend(struct device *dev)
+{
+        /* add suspend code here later */
+        return -1;
+}
+
+static int
+vpfe_resume(struct device *dev)
+{
+        /* add resume code here later */
+        return -1;
+}
+
+static struct dev_pm_ops vpfe_dev_pm_ops = {
+        .suspend = vpfe_suspend,
+        .resume = vpfe_resume,
+};
+
+static struct platform_driver vpfe_driver = {
+        .driver = {
+                .name = CAPTURE_DRV_NAME,
+                .owner = THIS_MODULE,
+                .pm = &vpfe_dev_pm_ops,
+        },
+        .probe = vpfe_probe,
+        .remove = __devexit_p(vpfe_remove),
+};
+
+static __init int vpfe_init(void)
+{
+        printk(KERN_NOTICE "vpfe_init\n");
+        /* Register driver to the kernel */
+        return platform_driver_register(&vpfe_driver);
+}
+
+/*
+ * vpfe_cleanup : This function un-registers device driver
+ */
+static void vpfe_cleanup(void)
+{
+        platform_driver_unregister(&vpfe_driver);
+}
+
+module_init(vpfe_init);
+module_exit(vpfe_cleanup);
diff --git a/drivers/media/video/davinci/vpif.c b/drivers/media/video/davinci/vpif.c
new file mode 100644
index 000000000000..3b8eac31ecae
--- /dev/null
+++ b/drivers/media/video/davinci/vpif.c
@@ -0,0 +1,296 @@
+/*
+ * vpif - DM646x Video Port Interface driver
+ * VPIF is a receiver and transmitter for video data. It has two channels(0, 1)
+ * that receiveing video byte stream and two channels(2, 3) for video output.
+ * The hardware supports SDTV, HDTV formats, raw data capture.
+ * Currently, the driver supports NTSC and PAL standards.
+ *
+ * Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.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 version 2.
+ *
+ * This program is distributed .as is. WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/kernel.h>
+#include <linux/io.h>
+#include <mach/hardware.h>
+
+#include "vpif.h"
+
+MODULE_DESCRIPTION("TI DaVinci Video Port Interface driver");
+MODULE_LICENSE("GPL");
+
+#define VPIF_CH0_MAX_MODES      (22)
+#define VPIF_CH1_MAX_MODES      (02)
+#define VPIF_CH2_MAX_MODES      (15)
+#define VPIF_CH3_MAX_MODES      (02)
+
+static resource_size_t  res_len;
+static struct resource  *res;
+spinlock_t vpif_lock;
+
+void __iomem *vpif_base;
+
+static inline void vpif_wr_bit(u32 reg, u32 bit, u32 val)
+{
+        if (val)
+                vpif_set_bit(reg, bit);
+        else
+                vpif_clr_bit(reg, bit);
+}
+
+/* This structure is used to keep track of VPIF size register's offsets */
+struct vpif_registers {
+        u32 h_cfg, v_cfg_00, v_cfg_01, v_cfg_02, v_cfg, ch_ctrl;
+        u32 line_offset, vanc0_strt, vanc0_size, vanc1_strt;
+        u32 vanc1_size, width_mask, len_mask;
+        u8 max_modes;
+};
+
+static const struct vpif_registers vpifregs[VPIF_NUM_CHANNELS] = {
+        /* Channel0 */
+        {
+                VPIF_CH0_H_CFG, VPIF_CH0_V_CFG_00, VPIF_CH0_V_CFG_01,
+                VPIF_CH0_V_CFG_02, VPIF_CH0_V_CFG_03, VPIF_CH0_CTRL,
+                VPIF_CH0_IMG_ADD_OFST, 0, 0, 0, 0, 0x1FFF, 0xFFF,
+                VPIF_CH0_MAX_MODES,
+        },
+        /* Channel1 */
+        {
+                VPIF_CH1_H_CFG, VPIF_CH1_V_CFG_00, VPIF_CH1_V_CFG_01,
+                VPIF_CH1_V_CFG_02, VPIF_CH1_V_CFG_03, VPIF_CH1_CTRL,
+                VPIF_CH1_IMG_ADD_OFST, 0, 0, 0, 0, 0x1FFF, 0xFFF,
+                VPIF_CH1_MAX_MODES,
+        },
+        /* Channel2 */
+        {
+                VPIF_CH2_H_CFG, VPIF_CH2_V_CFG_00, VPIF_CH2_V_CFG_01,
+                VPIF_CH2_V_CFG_02, VPIF_CH2_V_CFG_03, VPIF_CH2_CTRL,
+                VPIF_CH2_IMG_ADD_OFST, VPIF_CH2_VANC0_STRT, VPIF_CH2_VANC0_SIZE,
+                VPIF_CH2_VANC1_STRT, VPIF_CH2_VANC1_SIZE, 0x7FF, 0x7FF,
+                VPIF_CH2_MAX_MODES
+        },
+        /* Channel3 */
+        {
+                VPIF_CH3_H_CFG, VPIF_CH3_V_CFG_00, VPIF_CH3_V_CFG_01,
+                VPIF_CH3_V_CFG_02, VPIF_CH3_V_CFG_03, VPIF_CH3_CTRL,
+                VPIF_CH3_IMG_ADD_OFST, VPIF_CH3_VANC0_STRT, VPIF_CH3_VANC0_SIZE,
+                VPIF_CH3_VANC1_STRT, VPIF_CH3_VANC1_SIZE, 0x7FF, 0x7FF,
+                VPIF_CH3_MAX_MODES
+        },
+};
+
+/* vpif_set_mode_info:
+ * This function is used to set horizontal and vertical config parameters
+ * As per the standard in the channel, configure the values of L1, L3,
+ * L5, L7  L9, L11 in VPIF Register , also write width and height
+ */
+static void vpif_set_mode_info(const struct vpif_channel_config_params *config,
+                                u8 channel_id, u8 config_channel_id)
+{
+        u32 value;
+
+        value = (config->eav2sav & vpifregs[config_channel_id].width_mask);
+        value <<= VPIF_CH_LEN_SHIFT;
+        value |= (config->sav2eav & vpifregs[config_channel_id].width_mask);
+        regw(value, vpifregs[channel_id].h_cfg);
+
+        value = (config->l1 & vpifregs[config_channel_id].len_mask);
+        value <<= VPIF_CH_LEN_SHIFT;
+        value |= (config->l3 & vpifregs[config_channel_id].len_mask);
+        regw(value, vpifregs[channel_id].v_cfg_00);
+
+        value = (config->l5 & vpifregs[config_channel_id].len_mask);
+        value <<= VPIF_CH_LEN_SHIFT;
+        value |= (config->l7 & vpifregs[config_channel_id].len_mask);
+        regw(value, vpifregs[channel_id].v_cfg_01);
+
+        value = (config->l9 & vpifregs[config_channel_id].len_mask);
+        value <<= VPIF_CH_LEN_SHIFT;
+        value |= (config->l11 & vpifregs[config_channel_id].len_mask);
+        regw(value, vpifregs[channel_id].v_cfg_02);
+
+        value = (config->vsize & vpifregs[config_channel_id].len_mask);
+        regw(value, vpifregs[channel_id].v_cfg);
+}
+
+/* config_vpif_params
+ * Function to set the parameters of a channel
+ * Mainly modifies the channel ciontrol register
+ * It sets frame format, yc mux mode
+ */
+static void config_vpif_params(struct vpif_params *vpifparams,
+                                u8 channel_id, u8 found)
+{
+        const struct vpif_channel_config_params *config = &vpifparams->std_info;
+        u32 value, ch_nip, reg;
+        u8 start, end;
+        int i;
+
+        start = channel_id;
+        end = channel_id + found;
+
+        for (i = start; i < end; i++) {
+                reg = vpifregs[i].ch_ctrl;
+                if (channel_id < 2)
+                        ch_nip = VPIF_CAPTURE_CH_NIP;
+                else
+                        ch_nip = VPIF_DISPLAY_CH_NIP;
+
+                vpif_wr_bit(reg, ch_nip, config->frm_fmt);
+                vpif_wr_bit(reg, VPIF_CH_YC_MUX_BIT, config->ycmux_mode);
+                vpif_wr_bit(reg, VPIF_CH_INPUT_FIELD_FRAME_BIT,
+                                        vpifparams->video_params.storage_mode);
+
+                /* Set raster scanning SDR Format */
+                vpif_clr_bit(reg, VPIF_CH_SDR_FMT_BIT);
+                vpif_wr_bit(reg, VPIF_CH_DATA_MODE_BIT, config->capture_format);
+
+                if (channel_id > 1)     /* Set the Pixel enable bit */
+                        vpif_set_bit(reg, VPIF_DISPLAY_PIX_EN_BIT);
+                else if (config->capture_format) {
+                        /* Set the polarity of various pins */
+                        vpif_wr_bit(reg, VPIF_CH_FID_POLARITY_BIT,
+                                        vpifparams->iface.fid_pol);
+                        vpif_wr_bit(reg, VPIF_CH_V_VALID_POLARITY_BIT,
+                                        vpifparams->iface.vd_pol);
+                        vpif_wr_bit(reg, VPIF_CH_H_VALID_POLARITY_BIT,
+                                        vpifparams->iface.hd_pol);
+
+                        value = regr(reg);
+                        /* Set data width */
+                        value &= ((~(unsigned int)(0x3)) <<
+                                        VPIF_CH_DATA_WIDTH_BIT);
+                        value |= ((vpifparams->params.data_sz) <<
+                                                     VPIF_CH_DATA_WIDTH_BIT);
+                        regw(value, reg);
+                }
+
+                /* Write the pitch in the driver */
+                regw((vpifparams->video_params.hpitch),
+                                                vpifregs[i].line_offset);
+        }
+}
+
+/* vpif_set_video_params
+ * This function is used to set video parameters in VPIF register
+ */
+int vpif_set_video_params(struct vpif_params *vpifparams, u8 channel_id)
+{
+        const struct vpif_channel_config_params *config = &vpifparams->std_info;
+        int found = 1;
+
+        vpif_set_mode_info(config, channel_id, channel_id);
+        if (!config->ycmux_mode) {
+                /* YC are on separate channels (HDTV formats) */
+                vpif_set_mode_info(config, channel_id + 1, channel_id);
+                found = 2;
+        }
+
+        config_vpif_params(vpifparams, channel_id, found);
+
+        regw(0x80, VPIF_REQ_SIZE);
+        regw(0x01, VPIF_EMULATION_CTRL);
+
+        return found;
+}
+EXPORT_SYMBOL(vpif_set_video_params);
+
+void vpif_set_vbi_display_params(struct vpif_vbi_params *vbiparams,
+                                u8 channel_id)
+{
+        u32 value;
+
+        value = 0x3F8 & (vbiparams->hstart0);
+        value |= 0x3FFFFFF & ((vbiparams->vstart0) << 16);
+        regw(value, vpifregs[channel_id].vanc0_strt);
+
+        value = 0x3F8 & (vbiparams->hstart1);
+        value |= 0x3FFFFFF & ((vbiparams->vstart1) << 16);
+        regw(value, vpifregs[channel_id].vanc1_strt);
+
+        value = 0x3F8 & (vbiparams->hsize0);
+        value |= 0x3FFFFFF & ((vbiparams->vsize0) << 16);
+        regw(value, vpifregs[channel_id].vanc0_size);
+
+        value = 0x3F8 & (vbiparams->hsize1);
+        value |= 0x3FFFFFF & ((vbiparams->vsize1) << 16);
+        regw(value, vpifregs[channel_id].vanc1_size);
+
+}
+EXPORT_SYMBOL(vpif_set_vbi_display_params);
+
+int vpif_channel_getfid(u8 channel_id)
+{
+        return (regr(vpifregs[channel_id].ch_ctrl) & VPIF_CH_FID_MASK)
+                                        >> VPIF_CH_FID_SHIFT;
+}
+EXPORT_SYMBOL(vpif_channel_getfid);
+
+static int __init vpif_probe(struct platform_device *pdev)
+{
+        int status = 0;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENOENT;
+
+        res_len = res->end - res->start + 1;
+
+        res = request_mem_region(res->start, res_len, res->name);
+        if (!res)
+                return -EBUSY;
+
+        vpif_base = ioremap(res->start, res_len);
+        if (!vpif_base) {
+                status = -EBUSY;
+                goto fail;
+        }
+
+        spin_lock_init(&vpif_lock);
+        dev_info(&pdev->dev, "vpif probe success\n");
+        return 0;
+
+fail:
+        release_mem_region(res->start, res_len);
+        return status;
+}
+
+static int vpif_remove(struct platform_device *pdev)
+{
+        iounmap(vpif_base);
+        release_mem_region(res->start, res_len);
+        return 0;
+}
+
+static struct platform_driver vpif_driver = {
+        .driver = {
+                .name   = "vpif",
+                .owner = THIS_MODULE,
+        },
+        .remove = __devexit_p(vpif_remove),
+        .probe = vpif_probe,
+};
+
+static void vpif_exit(void)
+{
+        platform_driver_unregister(&vpif_driver);
+}
+
+static int __init vpif_init(void)
+{
+        return platform_driver_register(&vpif_driver);
+}
+subsys_initcall(vpif_init);
+module_exit(vpif_exit);
+
diff --git a/drivers/media/video/davinci/vpif.h b/drivers/media/video/davinci/vpif.h
new file mode 100644
index 000000000000..188841b476e0
--- /dev/null
+++ b/drivers/media/video/davinci/vpif.h
@@ -0,0 +1,642 @@
+/*
+ * VPIF header file
+ *
+ * Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.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 version 2.
+ *
+ * This program is distributed .as is. WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef VPIF_H
+#define VPIF_H
+
+#include <linux/io.h>
+#include <linux/videodev2.h>
+#include <mach/hardware.h>
+#include <mach/dm646x.h>
+
+/* Maximum channel allowed */
+#define VPIF_NUM_CHANNELS               (4)
+#define VPIF_CAPTURE_NUM_CHANNELS       (2)
+#define VPIF_DISPLAY_NUM_CHANNELS       (2)
+
+/* Macros to read/write registers */
+extern void __iomem *vpif_base;
+extern spinlock_t vpif_lock;
+
+#define regr(reg)               readl((reg) + vpif_base)
+#define regw(value, reg)        writel(value, (reg + vpif_base))
+
+/* Register Addresss Offsets */
+#define VPIF_PID                        (0x0000)
+#define VPIF_CH0_CTRL                   (0x0004)
+#define VPIF_CH1_CTRL                   (0x0008)
+#define VPIF_CH2_CTRL                   (0x000C)
+#define VPIF_CH3_CTRL                   (0x0010)
+
+#define VPIF_INTEN                      (0x0020)
+#define VPIF_INTEN_SET                  (0x0024)
+#define VPIF_INTEN_CLR                  (0x0028)
+#define VPIF_STATUS                     (0x002C)
+#define VPIF_STATUS_CLR                 (0x0030)
+#define VPIF_EMULATION_CTRL             (0x0034)
+#define VPIF_REQ_SIZE                   (0x0038)
+
+#define VPIF_CH0_TOP_STRT_ADD_LUMA      (0x0040)
+#define VPIF_CH0_BTM_STRT_ADD_LUMA      (0x0044)
+#define VPIF_CH0_TOP_STRT_ADD_CHROMA    (0x0048)
+#define VPIF_CH0_BTM_STRT_ADD_CHROMA    (0x004c)
+#define VPIF_CH0_TOP_STRT_ADD_HANC      (0x0050)
+#define VPIF_CH0_BTM_STRT_ADD_HANC      (0x0054)
+#define VPIF_CH0_TOP_STRT_ADD_VANC      (0x0058)
+#define VPIF_CH0_BTM_STRT_ADD_VANC      (0x005c)
+#define VPIF_CH0_SP_CFG                 (0x0060)
+#define VPIF_CH0_IMG_ADD_OFST           (0x0064)
+#define VPIF_CH0_HANC_ADD_OFST          (0x0068)
+#define VPIF_CH0_H_CFG                  (0x006c)
+#define VPIF_CH0_V_CFG_00               (0x0070)
+#define VPIF_CH0_V_CFG_01               (0x0074)
+#define VPIF_CH0_V_CFG_02               (0x0078)
+#define VPIF_CH0_V_CFG_03               (0x007c)
+
+#define VPIF_CH1_TOP_STRT_ADD_LUMA      (0x0080)
+#define VPIF_CH1_BTM_STRT_ADD_LUMA      (0x0084)
+#define VPIF_CH1_TOP_STRT_ADD_CHROMA    (0x0088)
+#define VPIF_CH1_BTM_STRT_ADD_CHROMA    (0x008c)
+#define VPIF_CH1_TOP_STRT_ADD_HANC      (0x0090)
+#define VPIF_CH1_BTM_STRT_ADD_HANC      (0x0094)
+#define VPIF_CH1_TOP_STRT_ADD_VANC      (0x0098)
+#define VPIF_CH1_BTM_STRT_ADD_VANC      (0x009c)
+#define VPIF_CH1_SP_CFG                 (0x00a0)
+#define VPIF_CH1_IMG_ADD_OFST           (0x00a4)
+#define VPIF_CH1_HANC_ADD_OFST          (0x00a8)
+#define VPIF_CH1_H_CFG                  (0x00ac)
+#define VPIF_CH1_V_CFG_00               (0x00b0)
+#define VPIF_CH1_V_CFG_01               (0x00b4)
+#define VPIF_CH1_V_CFG_02               (0x00b8)
+#define VPIF_CH1_V_CFG_03               (0x00bc)
+
+#define VPIF_CH2_TOP_STRT_ADD_LUMA      (0x00c0)
+#define VPIF_CH2_BTM_STRT_ADD_LUMA      (0x00c4)
+#define VPIF_CH2_TOP_STRT_ADD_CHROMA    (0x00c8)
+#define VPIF_CH2_BTM_STRT_ADD_CHROMA    (0x00cc)
+#define VPIF_CH2_TOP_STRT_ADD_HANC      (0x00d0)
+#define VPIF_CH2_BTM_STRT_ADD_HANC      (0x00d4)
+#define VPIF_CH2_TOP_STRT_ADD_VANC      (0x00d8)
+#define VPIF_CH2_BTM_STRT_ADD_VANC      (0x00dc)
+#define VPIF_CH2_SP_CFG                 (0x00e0)
+#define VPIF_CH2_IMG_ADD_OFST           (0x00e4)
+#define VPIF_CH2_HANC_ADD_OFST          (0x00e8)
+#define VPIF_CH2_H_CFG                  (0x00ec)
+#define VPIF_CH2_V_CFG_00               (0x00f0)
+#define VPIF_CH2_V_CFG_01               (0x00f4)
+#define VPIF_CH2_V_CFG_02               (0x00f8)
+#define VPIF_CH2_V_CFG_03               (0x00fc)
+#define VPIF_CH2_HANC0_STRT             (0x0100)
+#define VPIF_CH2_HANC0_SIZE             (0x0104)
+#define VPIF_CH2_HANC1_STRT             (0x0108)
+#define VPIF_CH2_HANC1_SIZE             (0x010c)
+#define VPIF_CH2_VANC0_STRT             (0x0110)
+#define VPIF_CH2_VANC0_SIZE             (0x0114)
+#define VPIF_CH2_VANC1_STRT             (0x0118)
+#define VPIF_CH2_VANC1_SIZE             (0x011c)
+
+#define VPIF_CH3_TOP_STRT_ADD_LUMA      (0x0140)
+#define VPIF_CH3_BTM_STRT_ADD_LUMA      (0x0144)
+#define VPIF_CH3_TOP_STRT_ADD_CHROMA    (0x0148)
+#define VPIF_CH3_BTM_STRT_ADD_CHROMA    (0x014c)
+#define VPIF_CH3_TOP_STRT_ADD_HANC      (0x0150)
+#define VPIF_CH3_BTM_STRT_ADD_HANC      (0x0154)
+#define VPIF_CH3_TOP_STRT_ADD_VANC      (0x0158)
+#define VPIF_CH3_BTM_STRT_ADD_VANC      (0x015c)
+#define VPIF_CH3_SP_CFG                 (0x0160)
+#define VPIF_CH3_IMG_ADD_OFST           (0x0164)
+#define VPIF_CH3_HANC_ADD_OFST          (0x0168)
+#define VPIF_CH3_H_CFG                  (0x016c)
+#define VPIF_CH3_V_CFG_00               (0x0170)
+#define VPIF_CH3_V_CFG_01               (0x0174)
+#define VPIF_CH3_V_CFG_02               (0x0178)
+#define VPIF_CH3_V_CFG_03               (0x017c)
+#define VPIF_CH3_HANC0_STRT             (0x0180)
+#define VPIF_CH3_HANC0_SIZE             (0x0184)
+#define VPIF_CH3_HANC1_STRT             (0x0188)
+#define VPIF_CH3_HANC1_SIZE             (0x018c)
+#define VPIF_CH3_VANC0_STRT             (0x0190)
+#define VPIF_CH3_VANC0_SIZE             (0x0194)
+#define VPIF_CH3_VANC1_STRT             (0x0198)
+#define VPIF_CH3_VANC1_SIZE             (0x019c)
+
+#define VPIF_IODFT_CTRL                 (0x01c0)
+
+/* Functions for bit Manipulation */
+static inline void vpif_set_bit(u32 reg, u32 bit)
+{
+        regw((regr(reg)) | (0x01 << bit), reg);
+}
+
+static inline void vpif_clr_bit(u32 reg, u32 bit)
+{
+        regw(((regr(reg)) & ~(0x01 << bit)), reg);
+}
+
+/* Macro for Generating mask */
+#ifdef GENERATE_MASK
+#undef GENERATE_MASK
+#endif
+
+#define GENERATE_MASK(bits, pos) \
+                ((((0xFFFFFFFF) << (32 - bits)) >> (32 - bits)) << pos)
+
+/* Bit positions in the channel control registers */
+#define VPIF_CH_DATA_MODE_BIT   (2)
+#define VPIF_CH_YC_MUX_BIT      (3)
+#define VPIF_CH_SDR_FMT_BIT     (4)
+#define VPIF_CH_HANC_EN_BIT     (8)
+#define VPIF_CH_VANC_EN_BIT     (9)
+
+#define VPIF_CAPTURE_CH_NIP     (10)
+#define VPIF_DISPLAY_CH_NIP     (11)
+
+#define VPIF_DISPLAY_PIX_EN_BIT (10)
+
+#define VPIF_CH_INPUT_FIELD_FRAME_BIT   (12)
+
+#define VPIF_CH_FID_POLARITY_BIT        (15)
+#define VPIF_CH_V_VALID_POLARITY_BIT    (14)
+#define VPIF_CH_H_VALID_POLARITY_BIT    (13)
+#define VPIF_CH_DATA_WIDTH_BIT          (28)
+
+#define VPIF_CH_CLK_EDGE_CTRL_BIT       (31)
+
+/* Mask various length */
+#define VPIF_CH_EAVSAV_MASK     GENERATE_MASK(13, 0)
+#define VPIF_CH_LEN_MASK        GENERATE_MASK(12, 0)
+#define VPIF_CH_WIDTH_MASK      GENERATE_MASK(13, 0)
+#define VPIF_CH_LEN_SHIFT       (16)
+
+/* VPIF masks for registers */
+#define VPIF_REQ_SIZE_MASK      (0x1ff)
+
+/* bit posotion of interrupt vpif_ch_intr register */
+#define VPIF_INTEN_FRAME_CH0    (0x00000001)
+#define VPIF_INTEN_FRAME_CH1    (0x00000002)
+#define VPIF_INTEN_FRAME_CH2    (0x00000004)
+#define VPIF_INTEN_FRAME_CH3    (0x00000008)
+
+/* bit position of clock and channel enable in vpif_chn_ctrl register */
+
+#define VPIF_CH0_CLK_EN         (0x00000002)
+#define VPIF_CH0_EN             (0x00000001)
+#define VPIF_CH1_CLK_EN         (0x00000002)
+#define VPIF_CH1_EN             (0x00000001)
+#define VPIF_CH2_CLK_EN         (0x00000002)
+#define VPIF_CH2_EN             (0x00000001)
+#define VPIF_CH3_CLK_EN         (0x00000002)
+#define VPIF_CH3_EN             (0x00000001)
+#define VPIF_CH_CLK_EN          (0x00000002)
+#define VPIF_CH_EN              (0x00000001)
+
+#define VPIF_INT_TOP    (0x00)
+#define VPIF_INT_BOTTOM (0x01)
+#define VPIF_INT_BOTH   (0x02)
+
+#define VPIF_CH0_INT_CTRL_SHIFT (6)
+#define VPIF_CH1_INT_CTRL_SHIFT (6)
+#define VPIF_CH2_INT_CTRL_SHIFT (6)
+#define VPIF_CH3_INT_CTRL_SHIFT (6)
+#define VPIF_CH_INT_CTRL_SHIFT  (6)
+
+/* enabled interrupt on both the fields on vpid_ch0_ctrl register */
+#define channel0_intr_assert()  (regw((regr(VPIF_CH0_CTRL)|\
+        (VPIF_INT_BOTH << VPIF_CH0_INT_CTRL_SHIFT)), VPIF_CH0_CTRL))
+
+/* enabled interrupt on both the fields on vpid_ch1_ctrl register */
+#define channel1_intr_assert()  (regw((regr(VPIF_CH1_CTRL)|\
+        (VPIF_INT_BOTH << VPIF_CH1_INT_CTRL_SHIFT)), VPIF_CH1_CTRL))
+
+/* enabled interrupt on both the fields on vpid_ch0_ctrl register */
+#define channel2_intr_assert()  (regw((regr(VPIF_CH2_CTRL)|\
+        (VPIF_INT_BOTH << VPIF_CH2_INT_CTRL_SHIFT)), VPIF_CH2_CTRL))
+
+/* enabled interrupt on both the fields on vpid_ch1_ctrl register */
+#define channel3_intr_assert()  (regw((regr(VPIF_CH3_CTRL)|\
+        (VPIF_INT_BOTH << VPIF_CH3_INT_CTRL_SHIFT)), VPIF_CH3_CTRL))
+
+#define VPIF_CH_FID_MASK        (0x20)
+#define VPIF_CH_FID_SHIFT       (5)
+
+#define VPIF_NTSC_VBI_START_FIELD0      (1)
+#define VPIF_NTSC_VBI_START_FIELD1      (263)
+#define VPIF_PAL_VBI_START_FIELD0       (624)
+#define VPIF_PAL_VBI_START_FIELD1       (311)
+
+#define VPIF_NTSC_HBI_START_FIELD0      (1)
+#define VPIF_NTSC_HBI_START_FIELD1      (263)
+#define VPIF_PAL_HBI_START_FIELD0       (624)
+#define VPIF_PAL_HBI_START_FIELD1       (311)
+
+#define VPIF_NTSC_VBI_COUNT_FIELD0      (20)
+#define VPIF_NTSC_VBI_COUNT_FIELD1      (19)
+#define VPIF_PAL_VBI_COUNT_FIELD0       (24)
+#define VPIF_PAL_VBI_COUNT_FIELD1       (25)
+
+#define VPIF_NTSC_HBI_COUNT_FIELD0      (263)
+#define VPIF_NTSC_HBI_COUNT_FIELD1      (262)
+#define VPIF_PAL_HBI_COUNT_FIELD0       (312)
+#define VPIF_PAL_HBI_COUNT_FIELD1       (313)
+
+#define VPIF_NTSC_VBI_SAMPLES_PER_LINE  (720)
+#define VPIF_PAL_VBI_SAMPLES_PER_LINE   (720)
+#define VPIF_NTSC_HBI_SAMPLES_PER_LINE  (268)
+#define VPIF_PAL_HBI_SAMPLES_PER_LINE   (280)
+
+#define VPIF_CH_VANC_EN                 (0x20)
+#define VPIF_DMA_REQ_SIZE               (0x080)
+#define VPIF_EMULATION_DISABLE          (0x01)
+
+extern u8 irq_vpif_capture_channel[VPIF_NUM_CHANNELS];
+
+/* inline function to enable/disable channel0 */
+static inline void enable_channel0(int enable)
+{
+        if (enable)
+                regw((regr(VPIF_CH0_CTRL) | (VPIF_CH0_EN)), VPIF_CH0_CTRL);
+        else
+                regw((regr(VPIF_CH0_CTRL) & (~VPIF_CH0_EN)), VPIF_CH0_CTRL);
+}
+
+/* inline function to enable/disable channel1 */
+static inline void enable_channel1(int enable)
+{
+        if (enable)
+                regw((regr(VPIF_CH1_CTRL) | (VPIF_CH1_EN)), VPIF_CH1_CTRL);
+        else
+                regw((regr(VPIF_CH1_CTRL) & (~VPIF_CH1_EN)), VPIF_CH1_CTRL);
+}
+
+/* inline function to enable interrupt for channel0 */
+static inline void channel0_intr_enable(int enable)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&vpif_lock, flags);
+
+        if (enable) {
+                regw((regr(VPIF_INTEN) | 0x10), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | 0x10), VPIF_INTEN_SET);
+
+                regw((regr(VPIF_INTEN) | VPIF_INTEN_FRAME_CH0), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | VPIF_INTEN_FRAME_CH0),
+                                                        VPIF_INTEN_SET);
+        } else {
+                regw((regr(VPIF_INTEN) & (~VPIF_INTEN_FRAME_CH0)), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | VPIF_INTEN_FRAME_CH0),
+                                                        VPIF_INTEN_SET);
+        }
+        spin_unlock_irqrestore(&vpif_lock, flags);
+}
+
+/* inline function to enable interrupt for channel1 */
+static inline void channel1_intr_enable(int enable)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&vpif_lock, flags);
+
+        if (enable) {
+                regw((regr(VPIF_INTEN) | 0x10), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | 0x10), VPIF_INTEN_SET);
+
+                regw((regr(VPIF_INTEN) | VPIF_INTEN_FRAME_CH1), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | VPIF_INTEN_FRAME_CH1),
+                                                        VPIF_INTEN_SET);
+        } else {
+                regw((regr(VPIF_INTEN) & (~VPIF_INTEN_FRAME_CH1)), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | VPIF_INTEN_FRAME_CH1),
+                                                        VPIF_INTEN_SET);
+        }
+        spin_unlock_irqrestore(&vpif_lock, flags);
+}
+
+/* inline function to set buffer addresses in case of Y/C non mux mode */
+static inline void ch0_set_videobuf_addr_yc_nmux(unsigned long top_strt_luma,
+                                                 unsigned long btm_strt_luma,
+                                                 unsigned long top_strt_chroma,
+                                                 unsigned long btm_strt_chroma)
+{
+        regw(top_strt_luma, VPIF_CH0_TOP_STRT_ADD_LUMA);
+        regw(btm_strt_luma, VPIF_CH0_BTM_STRT_ADD_LUMA);
+        regw(top_strt_chroma, VPIF_CH1_TOP_STRT_ADD_CHROMA);
+        regw(btm_strt_chroma, VPIF_CH1_BTM_STRT_ADD_CHROMA);
+}
+
+/* inline function to set buffer addresses in VPIF registers for video data */
+static inline void ch0_set_videobuf_addr(unsigned long top_strt_luma,
+                                         unsigned long btm_strt_luma,
+                                         unsigned long top_strt_chroma,
+                                         unsigned long btm_strt_chroma)
+{
+        regw(top_strt_luma, VPIF_CH0_TOP_STRT_ADD_LUMA);
+        regw(btm_strt_luma, VPIF_CH0_BTM_STRT_ADD_LUMA);
+        regw(top_strt_chroma, VPIF_CH0_TOP_STRT_ADD_CHROMA);
+        regw(btm_strt_chroma, VPIF_CH0_BTM_STRT_ADD_CHROMA);
+}
+
+static inline void ch1_set_videobuf_addr(unsigned long top_strt_luma,
+                                         unsigned long btm_strt_luma,
+                                         unsigned long top_strt_chroma,
+                                         unsigned long btm_strt_chroma)
+{
+
+        regw(top_strt_luma, VPIF_CH1_TOP_STRT_ADD_LUMA);
+        regw(btm_strt_luma, VPIF_CH1_BTM_STRT_ADD_LUMA);
+        regw(top_strt_chroma, VPIF_CH1_TOP_STRT_ADD_CHROMA);
+        regw(btm_strt_chroma, VPIF_CH1_BTM_STRT_ADD_CHROMA);
+}
+
+static inline void ch0_set_vbi_addr(unsigned long top_vbi,
+        unsigned long btm_vbi, unsigned long a, unsigned long b)
+{
+        regw(top_vbi, VPIF_CH0_TOP_STRT_ADD_VANC);
+        regw(btm_vbi, VPIF_CH0_BTM_STRT_ADD_VANC);
+}
+
+static inline void ch0_set_hbi_addr(unsigned long top_vbi,
+        unsigned long btm_vbi, unsigned long a, unsigned long b)
+{
+        regw(top_vbi, VPIF_CH0_TOP_STRT_ADD_HANC);
+        regw(btm_vbi, VPIF_CH0_BTM_STRT_ADD_HANC);
+}
+
+static inline void ch1_set_vbi_addr(unsigned long top_vbi,
+        unsigned long btm_vbi, unsigned long a, unsigned long b)
+{
+        regw(top_vbi, VPIF_CH1_TOP_STRT_ADD_VANC);
+        regw(btm_vbi, VPIF_CH1_BTM_STRT_ADD_VANC);
+}
+
+static inline void ch1_set_hbi_addr(unsigned long top_vbi,
+        unsigned long btm_vbi, unsigned long a, unsigned long b)
+{
+        regw(top_vbi, VPIF_CH1_TOP_STRT_ADD_HANC);
+        regw(btm_vbi, VPIF_CH1_BTM_STRT_ADD_HANC);
+}
+
+/* Inline function to enable raw vbi in the given channel */
+static inline void disable_raw_feature(u8 channel_id, u8 index)
+{
+        u32 ctrl_reg;
+        if (0 == channel_id)
+                ctrl_reg = VPIF_CH0_CTRL;
+        else
+                ctrl_reg = VPIF_CH1_CTRL;
+
+        if (1 == index)
+                vpif_clr_bit(ctrl_reg, VPIF_CH_VANC_EN_BIT);
+        else
+                vpif_clr_bit(ctrl_reg, VPIF_CH_HANC_EN_BIT);
+}
+
+static inline void enable_raw_feature(u8 channel_id, u8 index)
+{
+        u32 ctrl_reg;
+        if (0 == channel_id)
+                ctrl_reg = VPIF_CH0_CTRL;
+        else
+                ctrl_reg = VPIF_CH1_CTRL;
+
+        if (1 == index)
+                vpif_set_bit(ctrl_reg, VPIF_CH_VANC_EN_BIT);
+        else
+                vpif_set_bit(ctrl_reg, VPIF_CH_HANC_EN_BIT);
+}
+
+/* inline function to enable/disable channel2 */
+static inline void enable_channel2(int enable)
+{
+        if (enable) {
+                regw((regr(VPIF_CH2_CTRL) | (VPIF_CH2_CLK_EN)), VPIF_CH2_CTRL);
+                regw((regr(VPIF_CH2_CTRL) | (VPIF_CH2_EN)), VPIF_CH2_CTRL);
+        } else {
+                regw((regr(VPIF_CH2_CTRL) & (~VPIF_CH2_CLK_EN)), VPIF_CH2_CTRL);
+                regw((regr(VPIF_CH2_CTRL) & (~VPIF_CH2_EN)), VPIF_CH2_CTRL);
+        }
+}
+
+/* inline function to enable/disable channel3 */
+static inline void enable_channel3(int enable)
+{
+        if (enable) {
+                regw((regr(VPIF_CH3_CTRL) | (VPIF_CH3_CLK_EN)), VPIF_CH3_CTRL);
+                regw((regr(VPIF_CH3_CTRL) | (VPIF_CH3_EN)), VPIF_CH3_CTRL);
+        } else {
+                regw((regr(VPIF_CH3_CTRL) & (~VPIF_CH3_CLK_EN)), VPIF_CH3_CTRL);
+                regw((regr(VPIF_CH3_CTRL) & (~VPIF_CH3_EN)), VPIF_CH3_CTRL);
+        }
+}
+
+/* inline function to enable interrupt for channel2 */
+static inline void channel2_intr_enable(int enable)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&vpif_lock, flags);
+
+        if (enable) {
+                regw((regr(VPIF_INTEN) | 0x10), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | 0x10), VPIF_INTEN_SET);
+                regw((regr(VPIF_INTEN) | VPIF_INTEN_FRAME_CH2), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | VPIF_INTEN_FRAME_CH2),
+                                                        VPIF_INTEN_SET);
+        } else {
+                regw((regr(VPIF_INTEN) & (~VPIF_INTEN_FRAME_CH2)), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | VPIF_INTEN_FRAME_CH2),
+                                                        VPIF_INTEN_SET);
+        }
+        spin_unlock_irqrestore(&vpif_lock, flags);
+}
+
+/* inline function to enable interrupt for channel3 */
+static inline void channel3_intr_enable(int enable)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&vpif_lock, flags);
+
+        if (enable) {
+                regw((regr(VPIF_INTEN) | 0x10), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | 0x10), VPIF_INTEN_SET);
+
+                regw((regr(VPIF_INTEN) | VPIF_INTEN_FRAME_CH3), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | VPIF_INTEN_FRAME_CH3),
+                                                        VPIF_INTEN_SET);
+        } else {
+                regw((regr(VPIF_INTEN) & (~VPIF_INTEN_FRAME_CH3)), VPIF_INTEN);
+                regw((regr(VPIF_INTEN_SET) | VPIF_INTEN_FRAME_CH3),
+                                                        VPIF_INTEN_SET);
+        }
+        spin_unlock_irqrestore(&vpif_lock, flags);
+}
+
+/* inline function to enable raw vbi data for channel2 */
+static inline void channel2_raw_enable(int enable, u8 index)
+{
+        u32 mask;
+
+        if (1 == index)
+                mask = VPIF_CH_VANC_EN_BIT;
+        else
+                mask = VPIF_CH_HANC_EN_BIT;
+
+        if (enable)
+                vpif_set_bit(VPIF_CH2_CTRL, mask);
+        else
+                vpif_clr_bit(VPIF_CH2_CTRL, mask);
+}
+
+/* inline function to enable raw vbi data for channel3*/
+static inline void channel3_raw_enable(int enable, u8 index)
+{
+        u32 mask;
+
+        if (1 == index)
+                mask = VPIF_CH_VANC_EN_BIT;
+        else
+                mask = VPIF_CH_HANC_EN_BIT;
+
+        if (enable)
+                vpif_set_bit(VPIF_CH3_CTRL, mask);
+        else
+                vpif_clr_bit(VPIF_CH3_CTRL, mask);
+}
+
+/* inline function to set buffer addresses in case of Y/C non mux mode */
+static inline void ch2_set_videobuf_addr_yc_nmux(unsigned long top_strt_luma,
+                                                 unsigned long btm_strt_luma,
+                                                 unsigned long top_strt_chroma,
+                                                 unsigned long btm_strt_chroma)
+{
+        regw(top_strt_luma, VPIF_CH2_TOP_STRT_ADD_LUMA);
+        regw(btm_strt_luma, VPIF_CH2_BTM_STRT_ADD_LUMA);
+        regw(top_strt_chroma, VPIF_CH3_TOP_STRT_ADD_CHROMA);
+        regw(btm_strt_chroma, VPIF_CH3_BTM_STRT_ADD_CHROMA);
+}
+
+/* inline function to set buffer addresses in VPIF registers for video data */
+static inline void ch2_set_videobuf_addr(unsigned long top_strt_luma,
+                                         unsigned long btm_strt_luma,
+                                         unsigned long top_strt_chroma,
+                                         unsigned long btm_strt_chroma)
+{
+        regw(top_strt_luma, VPIF_CH2_TOP_STRT_ADD_LUMA);
+        regw(btm_strt_luma, VPIF_CH2_BTM_STRT_ADD_LUMA);
+        regw(top_strt_chroma, VPIF_CH2_TOP_STRT_ADD_CHROMA);
+        regw(btm_strt_chroma, VPIF_CH2_BTM_STRT_ADD_CHROMA);
+}
+
+static inline void ch3_set_videobuf_addr(unsigned long top_strt_luma,
+                                         unsigned long btm_strt_luma,
+                                         unsigned long top_strt_chroma,
+                                         unsigned long btm_strt_chroma)
+{
+        regw(top_strt_luma, VPIF_CH3_TOP_STRT_ADD_LUMA);
+        regw(btm_strt_luma, VPIF_CH3_BTM_STRT_ADD_LUMA);
+        regw(top_strt_chroma, VPIF_CH3_TOP_STRT_ADD_CHROMA);
+        regw(btm_strt_chroma, VPIF_CH3_BTM_STRT_ADD_CHROMA);
+}
+
+/* inline function to set buffer addresses in VPIF registers for vbi data */
+static inline void ch2_set_vbi_addr(unsigned long top_strt_luma,
+                                         unsigned long btm_strt_luma,
+                                         unsigned long top_strt_chroma,
+                                         unsigned long btm_strt_chroma)
+{
+        regw(top_strt_luma, VPIF_CH2_TOP_STRT_ADD_VANC);
+        regw(btm_strt_luma, VPIF_CH2_BTM_STRT_ADD_VANC);
+}
+
+static inline void ch3_set_vbi_addr(unsigned long top_strt_luma,
+                                         unsigned long btm_strt_luma,
+                                         unsigned long top_strt_chroma,
+                                         unsigned long btm_strt_chroma)
+{
+        regw(top_strt_luma, VPIF_CH3_TOP_STRT_ADD_VANC);
+        regw(btm_strt_luma, VPIF_CH3_BTM_STRT_ADD_VANC);
+}
+
+#define VPIF_MAX_NAME   (30)
+
+/* This structure will store size parameters as per the mode selected by user */
+struct vpif_channel_config_params {
+        char name[VPIF_MAX_NAME];       /* Name of the mode */
+        u16 width;                      /* Indicates width of the image */
+        u16 height;                     /* Indicates height of the image */
+        u8 fps;
+        u8 frm_fmt;                     /* Indicates whether this is interlaced
+                                         * or progressive format */
+        u8 ycmux_mode;                  /* Indicates whether this mode requires
+                                         * single or two channels */
+        u16 eav2sav;                    /* length of sav 2 eav */
+        u16 sav2eav;                    /* length of sav 2 eav */
+        u16 l1, l3, l5, l7, l9, l11;    /* Other parameter configurations */
+        u16 vsize;                      /* Vertical size of the image */
+        u8 capture_format;              /* Indicates whether capture format
+                                         * is in BT or in CCD/CMOS */
+        u8  vbi_supported;              /* Indicates whether this mode
+                                         * supports capturing vbi or not */
+        u8 hd_sd;
+        v4l2_std_id stdid;
+};
+
+struct vpif_video_params;
+struct vpif_params;
+struct vpif_vbi_params;
+
+int vpif_set_video_params(struct vpif_params *vpifparams, u8 channel_id);
+void vpif_set_vbi_display_params(struct vpif_vbi_params *vbiparams,
+                                                        u8 channel_id);
+int vpif_channel_getfid(u8 channel_id);
+
+enum data_size {
+        _8BITS = 0,
+        _10BITS,
+        _12BITS,
+};
+
+/* Structure for vpif parameters for raw vbi data */
+struct vpif_vbi_params {
+        __u32 hstart0;  /* Horizontal start of raw vbi data for first field */
+        __u32 vstart0;  /* Vertical start of raw vbi data for first field */
+        __u32 hsize0;   /* Horizontal size of raw vbi data for first field */
+        __u32 vsize0;   /* Vertical size of raw vbi data for first field */
+        __u32 hstart1;  /* Horizontal start of raw vbi data for second field */
+        __u32 vstart1;  /* Vertical start of raw vbi data for second field */
+        __u32 hsize1;   /* Horizontal size of raw vbi data for second field */
+        __u32 vsize1;   /* Vertical size of raw vbi data for second field */
+};
+
+/* structure for vpif parameters */
+struct vpif_video_params {
+        __u8 storage_mode;      /* Indicates field or frame mode */
+        unsigned long hpitch;
+        v4l2_std_id stdid;
+};
+
+struct vpif_params {
+        struct vpif_interface iface;
+        struct vpif_video_params video_params;
+        struct vpif_channel_config_params std_info;
+        union param {
+                struct vpif_vbi_params  vbi_params;
+                enum data_size data_sz;
+        } params;
+};
+
+#endif                          /* End of #ifndef VPIF_H */
+
diff --git a/drivers/media/video/davinci/vpif_capture.c b/drivers/media/video/davinci/vpif_capture.c
new file mode 100644
index 000000000000..d947ee5e4eb4
--- /dev/null
+++ b/drivers/media/video/davinci/vpif_capture.c
@@ -0,0 +1,2168 @@
+/*
+ * Copyright (C) 2009 Texas Instruments Inc
+ *
+ * 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
+ *
+ * TODO : add support for VBI & HBI data service
+ *        add static buffer allocation
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/workqueue.h>
+#include <linux/string.h>
+#include <linux/videodev2.h>
+#include <linux/wait.h>
+#include <linux/time.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/version.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-ioctl.h>
+
+#include "vpif_capture.h"
+#include "vpif.h"
+
+MODULE_DESCRIPTION("TI DaVinci VPIF Capture driver");
+MODULE_LICENSE("GPL");
+
+#define vpif_err(fmt, arg...)   v4l2_err(&vpif_obj.v4l2_dev, fmt, ## arg)
+#define vpif_dbg(level, debug, fmt, arg...)     \
+                v4l2_dbg(level, debug, &vpif_obj.v4l2_dev, fmt, ## arg)
+
+static int debug = 1;
+static u32 ch0_numbuffers = 3;
+static u32 ch1_numbuffers = 3;
+static u32 ch0_bufsize = 1920 * 1080 * 2;
+static u32 ch1_bufsize = 720 * 576 * 2;
+
+module_param(debug, int, 0644);
+module_param(ch0_numbuffers, uint, S_IRUGO);
+module_param(ch1_numbuffers, uint, S_IRUGO);
+module_param(ch0_bufsize, uint, S_IRUGO);
+module_param(ch1_bufsize, uint, S_IRUGO);
+
+MODULE_PARM_DESC(debug, "Debug level 0-1");
+MODULE_PARM_DESC(ch2_numbuffers, "Channel0 buffer count (default:3)");
+MODULE_PARM_DESC(ch3_numbuffers, "Channel1 buffer count (default:3)");
+MODULE_PARM_DESC(ch2_bufsize, "Channel0 buffer size (default:1920 x 1080 x 2)");
+MODULE_PARM_DESC(ch3_bufsize, "Channel1 buffer size (default:720 x 576 x 2)");
+
+static struct vpif_config_params config_params = {
+        .min_numbuffers = 3,
+        .numbuffers[0] = 3,
+        .numbuffers[1] = 3,
+        .min_bufsize[0] = 720 * 480 * 2,
+        .min_bufsize[1] = 720 * 480 * 2,
+        .channel_bufsize[0] = 1920 * 1080 * 2,
+        .channel_bufsize[1] = 720 * 576 * 2,
+};
+
+/* global variables */
+static struct vpif_device vpif_obj = { {NULL} };
+static struct device *vpif_dev;
+
+/**
+ * ch_params: video standard configuration parameters for vpif
+ */
+static const struct vpif_channel_config_params ch_params[] = {
+        {
+                "NTSC_M", 720, 480, 30, 0, 1, 268, 1440, 1, 23, 263, 266,
+                286, 525, 525, 0, 1, 0, V4L2_STD_525_60,
+        },
+        {
+                "PAL_BDGHIK", 720, 576, 25, 0, 1, 280, 1440, 1, 23, 311, 313,
+                336, 624, 625, 0, 1, 0, V4L2_STD_625_50,
+        },
+};
+
+/**
+ * vpif_uservirt_to_phys : translate user/virtual address to phy address
+ * @virtp: user/virtual address
+ *
+ * This inline function is used to convert user space virtual address to
+ * physical address.
+ */
+static inline u32 vpif_uservirt_to_phys(u32 virtp)
+{
+        unsigned long physp = 0;
+        struct mm_struct *mm = current->mm;
+        struct vm_area_struct *vma;
+
+        vma = find_vma(mm, virtp);
+
+        /* For kernel direct-mapped memory, take the easy way */
+        if (virtp >= PAGE_OFFSET)
+                physp = virt_to_phys((void *)virtp);
+        else if (vma && (vma->vm_flags & VM_IO) && (vma->vm_pgoff))
+                /**
+                 * this will catch, kernel-allocated, mmaped-to-usermode
+                 * addresses
+                 */
+                physp = (vma->vm_pgoff << PAGE_SHIFT) + (virtp - vma->vm_start);
+        else {
+                /* otherwise, use get_user_pages() for general userland pages */
+                int res, nr_pages = 1;
+                        struct page *pages;
+
+                down_read(&current->mm->mmap_sem);
+
+                res = get_user_pages(current, current->mm,
+                                     virtp, nr_pages, 1, 0, &pages, NULL);
+                up_read(&current->mm->mmap_sem);
+
+                if (res == nr_pages)
+                        physp = __pa(page_address(&pages[0]) +
+                                     (virtp & ~PAGE_MASK));
+                else {
+                        vpif_err("get_user_pages failed\n");
+                        return 0;
+                }
+        }
+        return physp;
+}
+
+/**
+ * buffer_prepare :  callback function for buffer prepare
+ * @q : buffer queue ptr
+ * @vb: ptr to video buffer
+ * @field: field info
+ *
+ * This is the callback function for buffer prepare when videobuf_qbuf()
+ * function is called. The buffer is prepared and user space virtual address
+ * or user address is converted into  physical address
+ */
+static int vpif_buffer_prepare(struct videobuf_queue *q,
+                               struct videobuf_buffer *vb,
+                               enum v4l2_field field)
+{
+        /* Get the file handle object and channel object */
+        struct vpif_fh *fh = q->priv_data;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common;
+        unsigned long addr;
+
+
+        vpif_dbg(2, debug, "vpif_buffer_prepare\n");
+
+        common = &ch->common[VPIF_VIDEO_INDEX];
+
+        /* If buffer is not initialized, initialize it */
+        if (VIDEOBUF_NEEDS_INIT == vb->state) {
+                vb->width = common->width;
+                vb->height = common->height;
+                vb->size = vb->width * vb->height;
+                vb->field = field;
+        }
+        vb->state = VIDEOBUF_PREPARED;
+        /**
+         * if user pointer memory mechanism is used, get the physical
+         * address of the buffer
+         */
+        if (V4L2_MEMORY_USERPTR == common->memory) {
+                if (0 == vb->baddr) {
+                        vpif_dbg(1, debug, "buffer address is 0\n");
+                        return -EINVAL;
+
+                }
+                vb->boff = vpif_uservirt_to_phys(vb->baddr);
+                if (!IS_ALIGNED(vb->boff, 8))
+                        goto exit;
+        }
+
+        addr = vb->boff;
+        if (q->streaming) {
+                if (!IS_ALIGNED((addr + common->ytop_off), 8) ||
+                    !IS_ALIGNED((addr + common->ybtm_off), 8) ||
+                    !IS_ALIGNED((addr + common->ctop_off), 8) ||
+                    !IS_ALIGNED((addr + common->cbtm_off), 8))
+                        goto exit;
+        }
+        return 0;
+exit:
+        vpif_dbg(1, debug, "buffer_prepare:offset is not aligned to 8 bytes\n");
+        return -EINVAL;
+}
+
+/**
+ * vpif_buffer_setup : Callback function for buffer setup.
+ * @q: buffer queue ptr
+ * @count: number of buffers
+ * @size: size of the buffer
+ *
+ * This callback function is called when reqbuf() is called to adjust
+ * the buffer count and buffer size
+ */
+static int vpif_buffer_setup(struct videobuf_queue *q, unsigned int *count,
+                             unsigned int *size)
+{
+        /* Get the file handle object and channel object */
+        struct vpif_fh *fh = q->priv_data;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common;
+
+        common = &ch->common[VPIF_VIDEO_INDEX];
+
+        vpif_dbg(2, debug, "vpif_buffer_setup\n");
+
+        /* If memory type is not mmap, return */
+        if (V4L2_MEMORY_MMAP != common->memory)
+                return 0;
+
+        /* Calculate the size of the buffer */
+        *size = config_params.channel_bufsize[ch->channel_id];
+
+        if (*count < config_params.min_numbuffers)
+                *count = config_params.min_numbuffers;
+        return 0;
+}
+
+/**
+ * vpif_buffer_queue : Callback function to add buffer to DMA queue
+ * @q: ptr to videobuf_queue
+ * @vb: ptr to videobuf_buffer
+ */
+static void vpif_buffer_queue(struct videobuf_queue *q,
+                              struct videobuf_buffer *vb)
+{
+        /* Get the file handle object and channel object */
+        struct vpif_fh *fh = q->priv_data;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common;
+
+        common = &ch->common[VPIF_VIDEO_INDEX];
+
+        vpif_dbg(2, debug, "vpif_buffer_queue\n");
+
+        /* add the buffer to the DMA queue */
+        list_add_tail(&vb->queue, &common->dma_queue);
+        /* Change state of the buffer */
+        vb->state = VIDEOBUF_QUEUED;
+}
+
+/**
+ * vpif_buffer_release : Callback function to free buffer
+ * @q: buffer queue ptr
+ * @vb: ptr to video buffer
+ *
+ * This function is called from the videobuf layer to free memory
+ * allocated to  the buffers
+ */
+static void vpif_buffer_release(struct videobuf_queue *q,
+                                struct videobuf_buffer *vb)
+{
+        /* Get the file handle object and channel object */
+        struct vpif_fh *fh = q->priv_data;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common;
+
+        common = &ch->common[VPIF_VIDEO_INDEX];
+
+        videobuf_dma_contig_free(q, vb);
+        vb->state = VIDEOBUF_NEEDS_INIT;
+}
+
+static struct videobuf_queue_ops video_qops = {
+        .buf_setup = vpif_buffer_setup,
+        .buf_prepare = vpif_buffer_prepare,
+        .buf_queue = vpif_buffer_queue,
+        .buf_release = vpif_buffer_release,
+};
+
+static u8 channel_first_int[VPIF_NUMBER_OF_OBJECTS][2] =
+        { {1, 1} };
+
+/**
+ * vpif_process_buffer_complete: process a completed buffer
+ * @common: ptr to common channel object
+ *
+ * This function time stamp the buffer and mark it as DONE. It also
+ * wake up any process waiting on the QUEUE and set the next buffer
+ * as current
+ */
+static void vpif_process_buffer_complete(struct common_obj *common)
+{
+        do_gettimeofday(&common->cur_frm->ts);
+        common->cur_frm->state = VIDEOBUF_DONE;
+        wake_up_interruptible(&common->cur_frm->done);
+        /* Make curFrm pointing to nextFrm */
+        common->cur_frm = common->next_frm;
+}
+
+/**
+ * vpif_schedule_next_buffer: set next buffer address for capture
+ * @common : ptr to common channel object
+ *
+ * This function will get next buffer from the dma queue and
+ * set the buffer address in the vpif register for capture.
+ * the buffer is marked active
+ */
+static void vpif_schedule_next_buffer(struct common_obj *common)
+{
+        unsigned long addr = 0;
+
+        common->next_frm = list_entry(common->dma_queue.next,
+                                     struct videobuf_buffer, queue);
+        /* Remove that buffer from the buffer queue */
+        list_del(&common->next_frm->queue);
+        common->next_frm->state = VIDEOBUF_ACTIVE;
+        if (V4L2_MEMORY_USERPTR == common->memory)
+                addr = common->next_frm->boff;
+        else
+                addr = videobuf_to_dma_contig(common->next_frm);
+
+        /* Set top and bottom field addresses in VPIF registers */
+        common->set_addr(addr + common->ytop_off,
+                         addr + common->ybtm_off,
+                         addr + common->ctop_off,
+                         addr + common->cbtm_off);
+}
+
+/**
+ * vpif_channel_isr : ISR handler for vpif capture
+ * @irq: irq number
+ * @dev_id: dev_id ptr
+ *
+ * It changes status of the captured buffer, takes next buffer from the queue
+ * and sets its address in VPIF  registers
+ */
+static irqreturn_t vpif_channel_isr(int irq, void *dev_id)
+{
+        struct vpif_device *dev = &vpif_obj;
+        struct common_obj *common;
+        struct channel_obj *ch;
+        enum v4l2_field field;
+        int channel_id = 0;
+        int fid = -1, i;
+
+        channel_id = *(int *)(dev_id);
+        ch = dev->dev[channel_id];
+
+        field = ch->common[VPIF_VIDEO_INDEX].fmt.fmt.pix.field;
+
+        for (i = 0; i < VPIF_NUMBER_OF_OBJECTS; i++) {
+                common = &ch->common[i];
+                /* skip If streaming is not started in this channel */
+                if (0 == common->started)
+                        continue;
+
+                /* Check the field format */
+                if (1 == ch->vpifparams.std_info.frm_fmt) {
+                        /* Progressive mode */
+                        if (list_empty(&common->dma_queue))
+                                continue;
+
+                        if (!channel_first_int[i][channel_id])
+                                vpif_process_buffer_complete(common);
+
+                        channel_first_int[i][channel_id] = 0;
+
+                        vpif_schedule_next_buffer(common);
+
+
+                        channel_first_int[i][channel_id] = 0;
+                } else {
+                        /**
+                         * Interlaced mode. If it is first interrupt, ignore
+                         * it
+                         */
+                        if (channel_first_int[i][channel_id]) {
+                                channel_first_int[i][channel_id] = 0;
+                                continue;
+                        }
+                        if (0 == i) {
+                                ch->field_id ^= 1;
+                                /* Get field id from VPIF registers */
+                                fid = vpif_channel_getfid(ch->channel_id);
+                                if (fid != ch->field_id) {
+                                        /**
+                                         * If field id does not match stored
+                                         * field id, make them in sync
+                                         */
+                                        if (0 == fid)
+                                                ch->field_id = fid;
+                                        return IRQ_HANDLED;
+                                }
+                        }
+                        /* device field id and local field id are in sync */
+                        if (0 == fid) {
+                                /* this is even field */
+                                if (common->cur_frm == common->next_frm)
+                                        continue;
+
+                                /* mark the current buffer as done */
+                                vpif_process_buffer_complete(common);
+                        } else if (1 == fid) {
+                                /* odd field */
+                                if (list_empty(&common->dma_queue) ||
+                                    (common->cur_frm != common->next_frm))
+                                        continue;
+
+                                vpif_schedule_next_buffer(common);
+                        }
+                }
+        }
+        return IRQ_HANDLED;
+}
+
+/**
+ * vpif_update_std_info() - update standard related info
+ * @ch: ptr to channel object
+ *
+ * For a given standard selected by application, update values
+ * in the device data structures
+ */
+static int vpif_update_std_info(struct channel_obj *ch)
+{
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        struct vpif_params *vpifparams = &ch->vpifparams;
+        const struct vpif_channel_config_params *config;
+        struct vpif_channel_config_params *std_info;
+        struct video_obj *vid_ch = &ch->video;
+        int index;
+
+        vpif_dbg(2, debug, "vpif_update_std_info\n");
+
+        std_info = &vpifparams->std_info;
+
+        for (index = 0; index < ARRAY_SIZE(ch_params); index++) {
+                config = &ch_params[index];
+                if (config->stdid & vid_ch->stdid) {
+                        memcpy(std_info, config, sizeof(*config));
+                        break;
+                }
+        }
+
+        /* standard not found */
+        if (index == ARRAY_SIZE(ch_params))
+                return -EINVAL;
+
+        common->fmt.fmt.pix.width = std_info->width;
+        common->width = std_info->width;
+        common->fmt.fmt.pix.height = std_info->height;
+        common->height = std_info->height;
+        common->fmt.fmt.pix.bytesperline = std_info->width;
+        vpifparams->video_params.hpitch = std_info->width;
+        vpifparams->video_params.storage_mode = std_info->frm_fmt;
+        return 0;
+}
+
+/**
+ * vpif_calculate_offsets : This function calculates buffers offsets
+ * @ch : ptr to channel object
+ *
+ * This function calculates buffer offsets for Y and C in the top and
+ * bottom field
+ */
+static void vpif_calculate_offsets(struct channel_obj *ch)
+{
+        unsigned int hpitch, vpitch, sizeimage;
+        struct video_obj *vid_ch = &(ch->video);
+        struct vpif_params *vpifparams = &ch->vpifparams;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        enum v4l2_field field = common->fmt.fmt.pix.field;
+
+        vpif_dbg(2, debug, "vpif_calculate_offsets\n");
+
+        if (V4L2_FIELD_ANY == field) {
+                if (vpifparams->std_info.frm_fmt)
+                        vid_ch->buf_field = V4L2_FIELD_NONE;
+                else
+                        vid_ch->buf_field = V4L2_FIELD_INTERLACED;
+        } else
+                vid_ch->buf_field = common->fmt.fmt.pix.field;
+
+        if (V4L2_MEMORY_USERPTR == common->memory)
+                sizeimage = common->fmt.fmt.pix.sizeimage;
+        else
+                sizeimage = config_params.channel_bufsize[ch->channel_id];
+
+        hpitch = common->fmt.fmt.pix.bytesperline;
+        vpitch = sizeimage / (hpitch * 2);
+
+        if ((V4L2_FIELD_NONE == vid_ch->buf_field) ||
+            (V4L2_FIELD_INTERLACED == vid_ch->buf_field)) {
+                /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
+                common->ytop_off = 0;
+                common->ybtm_off = hpitch;
+                common->ctop_off = sizeimage / 2;
+                common->cbtm_off = sizeimage / 2 + hpitch;
+        } else if (V4L2_FIELD_SEQ_TB == vid_ch->buf_field) {
+                /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
+                common->ytop_off = 0;
+                common->ybtm_off = sizeimage / 4;
+                common->ctop_off = sizeimage / 2;
+                common->cbtm_off = common->ctop_off + sizeimage / 4;
+        } else if (V4L2_FIELD_SEQ_BT == vid_ch->buf_field) {
+                /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
+                common->ybtm_off = 0;
+                common->ytop_off = sizeimage / 4;
+                common->cbtm_off = sizeimage / 2;
+                common->ctop_off = common->cbtm_off + sizeimage / 4;
+        }
+        if ((V4L2_FIELD_NONE == vid_ch->buf_field) ||
+            (V4L2_FIELD_INTERLACED == vid_ch->buf_field))
+                vpifparams->video_params.storage_mode = 1;
+        else
+                vpifparams->video_params.storage_mode = 0;
+
+        if (1 == vpifparams->std_info.frm_fmt)
+                vpifparams->video_params.hpitch =
+                    common->fmt.fmt.pix.bytesperline;
+        else {
+                if ((field == V4L2_FIELD_ANY)
+                    || (field == V4L2_FIELD_INTERLACED))
+                        vpifparams->video_params.hpitch =
+                            common->fmt.fmt.pix.bytesperline * 2;
+                else
+                        vpifparams->video_params.hpitch =
+                            common->fmt.fmt.pix.bytesperline;
+        }
+
+        ch->vpifparams.video_params.stdid = vpifparams->std_info.stdid;
+}
+
+/**
+ * vpif_config_format: configure default frame format in the device
+ * ch : ptr to channel object
+ */
+static void vpif_config_format(struct channel_obj *ch)
+{
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        vpif_dbg(2, debug, "vpif_config_format\n");
+
+        common->fmt.fmt.pix.field = V4L2_FIELD_ANY;
+        if (config_params.numbuffers[ch->channel_id] == 0)
+                common->memory = V4L2_MEMORY_USERPTR;
+        else
+                common->memory = V4L2_MEMORY_MMAP;
+
+        common->fmt.fmt.pix.sizeimage
+            = config_params.channel_bufsize[ch->channel_id];
+
+        if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER)
+                common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_SBGGR8;
+        else
+                common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P;
+        common->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+}
+
+/**
+ * vpif_get_default_field() - Get default field type based on interface
+ * @vpif_params - ptr to vpif params
+ */
+static inline enum v4l2_field vpif_get_default_field(
+                                struct vpif_interface *iface)
+{
+        return (iface->if_type == VPIF_IF_RAW_BAYER) ? V4L2_FIELD_NONE :
+                                                V4L2_FIELD_INTERLACED;
+}
+
+/**
+ * vpif_check_format()  - check given pixel format for compatibility
+ * @ch - channel  ptr
+ * @pixfmt - Given pixel format
+ * @update - update the values as per hardware requirement
+ *
+ * Check the application pixel format for S_FMT and update the input
+ * values as per hardware limits for TRY_FMT. The default pixel and
+ * field format is selected based on interface type.
+ */
+static int vpif_check_format(struct channel_obj *ch,
+                             struct v4l2_pix_format *pixfmt,
+                             int update)
+{
+        struct common_obj *common = &(ch->common[VPIF_VIDEO_INDEX]);
+        struct vpif_params *vpif_params = &ch->vpifparams;
+        enum v4l2_field field = pixfmt->field;
+        u32 sizeimage, hpitch, vpitch;
+        int ret = -EINVAL;
+
+        vpif_dbg(2, debug, "vpif_check_format\n");
+        /**
+         * first check for the pixel format. If if_type is Raw bayer,
+         * only V4L2_PIX_FMT_SBGGR8 format is supported. Otherwise only
+         * V4L2_PIX_FMT_YUV422P is supported
+         */
+        if (vpif_params->iface.if_type == VPIF_IF_RAW_BAYER) {
+                if (pixfmt->pixelformat != V4L2_PIX_FMT_SBGGR8) {
+                        if (!update) {
+                                vpif_dbg(2, debug, "invalid pix format\n");
+                                goto exit;
+                        }
+                        pixfmt->pixelformat = V4L2_PIX_FMT_SBGGR8;
+                }
+        } else {
+                if (pixfmt->pixelformat != V4L2_PIX_FMT_YUV422P) {
+                        if (!update) {
+                                vpif_dbg(2, debug, "invalid pixel format\n");
+                                goto exit;
+                        }
+                        pixfmt->pixelformat = V4L2_PIX_FMT_YUV422P;
+                }
+        }
+
+        if (!(VPIF_VALID_FIELD(field))) {
+                if (!update) {
+                        vpif_dbg(2, debug, "invalid field format\n");
+                        goto exit;
+                }
+                /**
+                 * By default use FIELD_NONE for RAW Bayer capture
+                 * and FIELD_INTERLACED for other interfaces
+                 */
+                field = vpif_get_default_field(&vpif_params->iface);
+        } else if (field == V4L2_FIELD_ANY)
+                /* unsupported field. Use default */
+                field = vpif_get_default_field(&vpif_params->iface);
+
+        /* validate the hpitch */
+        hpitch = pixfmt->bytesperline;
+        if (hpitch < vpif_params->std_info.width) {
+                if (!update) {
+                        vpif_dbg(2, debug, "invalid hpitch\n");
+                        goto exit;
+                }
+                hpitch = vpif_params->std_info.width;
+        }
+
+        if (V4L2_MEMORY_USERPTR == common->memory)
+                sizeimage = pixfmt->sizeimage;
+        else
+                sizeimage = config_params.channel_bufsize[ch->channel_id];
+
+        vpitch = sizeimage / (hpitch * 2);
+
+        /* validate the vpitch */
+        if (vpitch < vpif_params->std_info.height) {
+                if (!update) {
+                        vpif_dbg(2, debug, "Invalid vpitch\n");
+                        goto exit;
+                }
+                vpitch = vpif_params->std_info.height;
+        }
+
+        /* Check for 8 byte alignment */
+        if (!ALIGN(hpitch, 8)) {
+                if (!update) {
+                        vpif_dbg(2, debug, "invalid pitch alignment\n");
+                        goto exit;
+                }
+                /* adjust to next 8 byte boundary */
+                hpitch = (((hpitch + 7) / 8) * 8);
+        }
+        /* if update is set, modify the bytesperline and sizeimage */
+        if (update) {
+                pixfmt->bytesperline = hpitch;
+                pixfmt->sizeimage = hpitch * vpitch * 2;
+        }
+        /**
+         * Image width and height is always based on current standard width and
+         * height
+         */
+        pixfmt->width = common->fmt.fmt.pix.width;
+        pixfmt->height = common->fmt.fmt.pix.height;
+        return 0;
+exit:
+        return ret;
+}
+
+/**
+ * vpif_config_addr() - function to configure buffer address in vpif
+ * @ch - channel ptr
+ * @muxmode - channel mux mode
+ */
+static void vpif_config_addr(struct channel_obj *ch, int muxmode)
+{
+        struct common_obj *common;
+
+        vpif_dbg(2, debug, "vpif_config_addr\n");
+
+        common = &(ch->common[VPIF_VIDEO_INDEX]);
+
+        if (VPIF_CHANNEL1_VIDEO == ch->channel_id)
+                common->set_addr = ch1_set_videobuf_addr;
+        else if (2 == muxmode)
+                common->set_addr = ch0_set_videobuf_addr_yc_nmux;
+        else
+                common->set_addr = ch0_set_videobuf_addr;
+}
+
+/**
+ * vpfe_mmap : It is used to map kernel space buffers into user spaces
+ * @filep: file pointer
+ * @vma: ptr to vm_area_struct
+ */
+static int vpif_mmap(struct file *filep, struct vm_area_struct *vma)
+{
+        /* Get the channel object and file handle object */
+        struct vpif_fh *fh = filep->private_data;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &(ch->common[VPIF_VIDEO_INDEX]);
+
+        vpif_dbg(2, debug, "vpif_mmap\n");
+
+        return videobuf_mmap_mapper(&common->buffer_queue, vma);
+}
+
+/**
+ * vpif_poll: It is used for select/poll system call
+ * @filep: file pointer
+ * @wait: poll table to wait
+ */
+static unsigned int vpif_poll(struct file *filep, poll_table * wait)
+{
+        int err = 0;
+        struct vpif_fh *fh = filep->private_data;
+        struct channel_obj *channel = fh->channel;
+        struct common_obj *common = &(channel->common[VPIF_VIDEO_INDEX]);
+
+        vpif_dbg(2, debug, "vpif_poll\n");
+
+        if (common->started)
+                err = videobuf_poll_stream(filep, &common->buffer_queue, wait);
+
+        return 0;
+}
+
+/**
+ * vpif_open : vpif open handler
+ * @filep: file ptr
+ *
+ * It creates object of file handle structure and stores it in private_data
+ * member of filepointer
+ */
+static int vpif_open(struct file *filep)
+{
+        struct vpif_capture_config *config = vpif_dev->platform_data;
+        struct video_device *vdev = video_devdata(filep);
+        struct common_obj *common;
+        struct video_obj *vid_ch;
+        struct channel_obj *ch;
+        struct vpif_fh *fh;
+        int i, ret = 0;
+
+        vpif_dbg(2, debug, "vpif_open\n");
+
+        ch = video_get_drvdata(vdev);
+
+        vid_ch = &ch->video;
+        common = &ch->common[VPIF_VIDEO_INDEX];
+
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        if (NULL == ch->curr_subdev_info) {
+                /**
+                 * search through the sub device to see a registered
+                 * sub device and make it as current sub device
+                 */
+                for (i = 0; i < config->subdev_count; i++) {
+                        if (vpif_obj.sd[i]) {
+                                /* the sub device is registered */
+                                ch->curr_subdev_info = &config->subdev_info[i];
+                                /* make first input as the current input */
+                                vid_ch->input_idx = 0;
+                                break;
+                        }
+                }
+                if (i == config->subdev_count) {
+                        vpif_err("No sub device registered\n");
+                        ret = -ENOENT;
+                        goto exit;
+                }
+        }
+
+        /* Allocate memory for the file handle object */
+        fh = kmalloc(sizeof(struct vpif_fh), GFP_KERNEL);
+        if (NULL == fh) {
+                vpif_err("unable to allocate memory for file handle object\n");
+                ret = -ENOMEM;
+                goto exit;
+        }
+
+        /* store pointer to fh in private_data member of filep */
+        filep->private_data = fh;
+        fh->channel = ch;
+        fh->initialized = 0;
+        /* If decoder is not initialized. initialize it */
+        if (!ch->initialized) {
+                fh->initialized = 1;
+                ch->initialized = 1;
+                memset(&(ch->vpifparams), 0, sizeof(struct vpif_params));
+        }
+        /* Increment channel usrs counter */
+        ch->usrs++;
+        /* Set io_allowed member to false */
+        fh->io_allowed[VPIF_VIDEO_INDEX] = 0;
+        /* Initialize priority of this instance to default priority */
+        fh->prio = V4L2_PRIORITY_UNSET;
+        v4l2_prio_open(&ch->prio, &fh->prio);
+exit:
+        mutex_unlock(&common->lock);
+        return ret;
+}
+
+/**
+ * vpif_release : function to clean up file close
+ * @filep: file pointer
+ *
+ * This function deletes buffer queue, frees the buffers and the vpfe file
+ * handle
+ */
+static int vpif_release(struct file *filep)
+{
+        struct vpif_fh *fh = filep->private_data;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common;
+
+        vpif_dbg(2, debug, "vpif_release\n");
+
+        common = &ch->common[VPIF_VIDEO_INDEX];
+
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        /* if this instance is doing IO */
+        if (fh->io_allowed[VPIF_VIDEO_INDEX]) {
+                /* Reset io_usrs member of channel object */
+                common->io_usrs = 0;
+                /* Disable channel as per its device type and channel id */
+                if (VPIF_CHANNEL0_VIDEO == ch->channel_id) {
+                        enable_channel0(0);
+                        channel0_intr_enable(0);
+                }
+                if ((VPIF_CHANNEL1_VIDEO == ch->channel_id) ||
+                    (2 == common->started)) {
+                        enable_channel1(0);
+                        channel1_intr_enable(0);
+                }
+                common->started = 0;
+                /* Free buffers allocated */
+                videobuf_queue_cancel(&common->buffer_queue);
+                videobuf_mmap_free(&common->buffer_queue);
+        }
+
+        /* Decrement channel usrs counter */
+        ch->usrs--;
+
+        /* unlock mutex on channel object */
+        mutex_unlock(&common->lock);
+
+        /* Close the priority */
+        v4l2_prio_close(&ch->prio, &fh->prio);
+
+        if (fh->initialized)
+                ch->initialized = 0;
+
+        filep->private_data = NULL;
+        kfree(fh);
+        return 0;
+}
+
+/**
+ * vpif_reqbufs() - request buffer handler
+ * @file: file ptr
+ * @priv: file handle
+ * @reqbuf: request buffer structure ptr
+ */
+static int vpif_reqbufs(struct file *file, void *priv,
+                        struct v4l2_requestbuffers *reqbuf)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common;
+        u8 index = 0;
+        int ret = 0;
+
+        vpif_dbg(2, debug, "vpif_reqbufs\n");
+
+        /**
+         * This file handle has not initialized the channel,
+         * It is not allowed to do settings
+         */
+        if ((VPIF_CHANNEL0_VIDEO == ch->channel_id)
+            || (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
+                if (!fh->initialized) {
+                        vpif_dbg(1, debug, "Channel Busy\n");
+                        return -EBUSY;
+                }
+        }
+
+        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != reqbuf->type)
+                return -EINVAL;
+
+        index = VPIF_VIDEO_INDEX;
+
+        common = &ch->common[index];
+
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        if (0 != common->io_usrs) {
+                ret = -EBUSY;
+                goto reqbuf_exit;
+        }
+
+        /* Initialize videobuf queue as per the buffer type */
+        videobuf_queue_dma_contig_init(&common->buffer_queue,
+                                            &video_qops, NULL,
+                                            &common->irqlock,
+                                            reqbuf->type,
+                                            common->fmt.fmt.pix.field,
+                                            sizeof(struct videobuf_buffer), fh);
+
+        /* Set io allowed member of file handle to TRUE */
+        fh->io_allowed[index] = 1;
+        /* Increment io usrs member of channel object to 1 */
+        common->io_usrs = 1;
+        /* Store type of memory requested in channel object */
+        common->memory = reqbuf->memory;
+        INIT_LIST_HEAD(&common->dma_queue);
+
+        /* Allocate buffers */
+        ret = videobuf_reqbufs(&common->buffer_queue, reqbuf);
+
+reqbuf_exit:
+        mutex_unlock(&common->lock);
+        return ret;
+}
+
+/**
+ * vpif_querybuf() - query buffer handler
+ * @file: file ptr
+ * @priv: file handle
+ * @buf: v4l2 buffer structure ptr
+ */
+static int vpif_querybuf(struct file *file, void *priv,
+                                struct v4l2_buffer *buf)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        vpif_dbg(2, debug, "vpif_querybuf\n");
+
+        if (common->fmt.type != buf->type)
+                return -EINVAL;
+
+        if (common->memory != V4L2_MEMORY_MMAP) {
+                vpif_dbg(1, debug, "Invalid memory\n");
+                return -EINVAL;
+        }
+
+        return videobuf_querybuf(&common->buffer_queue, buf);
+}
+
+/**
+ * vpif_qbuf() - query buffer handler
+ * @file: file ptr
+ * @priv: file handle
+ * @buf: v4l2 buffer structure ptr
+ */
+static int vpif_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
+{
+
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        struct v4l2_buffer tbuf = *buf;
+        struct videobuf_buffer *buf1;
+        unsigned long addr = 0;
+        unsigned long flags;
+        int ret = 0;
+
+        vpif_dbg(2, debug, "vpif_qbuf\n");
+
+        if (common->fmt.type != tbuf.type) {
+                vpif_err("invalid buffer type\n");
+                return -EINVAL;
+        }
+
+        if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
+                vpif_err("fh io not allowed \n");
+                return -EACCES;
+        }
+
+        if (!(list_empty(&common->dma_queue)) ||
+            (common->cur_frm != common->next_frm) ||
+            !common->started ||
+            (common->started && (0 == ch->field_id)))
+                return videobuf_qbuf(&common->buffer_queue, buf);
+
+        /* bufferqueue is empty store buffer address in VPIF registers */
+        mutex_lock(&common->buffer_queue.vb_lock);
+        buf1 = common->buffer_queue.bufs[tbuf.index];
+
+        if ((buf1->state == VIDEOBUF_QUEUED) ||
+            (buf1->state == VIDEOBUF_ACTIVE)) {
+                vpif_err("invalid state\n");
+                goto qbuf_exit;
+        }
+
+        switch (buf1->memory) {
+        case V4L2_MEMORY_MMAP:
+                if (buf1->baddr == 0)
+                        goto qbuf_exit;
+                break;
+
+        case V4L2_MEMORY_USERPTR:
+                if (tbuf.length < buf1->bsize)
+                        goto qbuf_exit;
+
+                if ((VIDEOBUF_NEEDS_INIT != buf1->state)
+                            && (buf1->baddr != tbuf.m.userptr))
+                        vpif_buffer_release(&common->buffer_queue, buf1);
+                        buf1->baddr = tbuf.m.userptr;
+                break;
+
+        default:
+                goto qbuf_exit;
+        }
+
+        local_irq_save(flags);
+        ret = vpif_buffer_prepare(&common->buffer_queue, buf1,
+                                        common->buffer_queue.field);
+        if (ret < 0) {
+                local_irq_restore(flags);
+                goto qbuf_exit;
+        }
+
+        buf1->state = VIDEOBUF_ACTIVE;
+
+        if (V4L2_MEMORY_USERPTR == common->memory)
+                addr = buf1->boff;
+        else
+                addr = videobuf_to_dma_contig(buf1);
+
+        common->next_frm = buf1;
+        common->set_addr(addr + common->ytop_off,
+                         addr + common->ybtm_off,
+                         addr + common->ctop_off,
+                         addr + common->cbtm_off);
+
+        local_irq_restore(flags);
+        list_add_tail(&buf1->stream, &common->buffer_queue.stream);
+        mutex_unlock(&common->buffer_queue.vb_lock);
+        return 0;
+
+qbuf_exit:
+        mutex_unlock(&common->buffer_queue.vb_lock);
+        return -EINVAL;
+}
+
+/**
+ * vpif_dqbuf() - query buffer handler
+ * @file: file ptr
+ * @priv: file handle
+ * @buf: v4l2 buffer structure ptr
+ */
+static int vpif_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        vpif_dbg(2, debug, "vpif_dqbuf\n");
+
+        return videobuf_dqbuf(&common->buffer_queue, buf,
+                                        file->f_flags & O_NONBLOCK);
+}
+
+/**
+ * vpif_streamon() - streamon handler
+ * @file: file ptr
+ * @priv: file handle
+ * @buftype: v4l2 buffer type
+ */
+static int vpif_streamon(struct file *file, void *priv,
+                                enum v4l2_buf_type buftype)
+{
+
+        struct vpif_capture_config *config = vpif_dev->platform_data;
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        struct channel_obj *oth_ch = vpif_obj.dev[!ch->channel_id];
+        struct vpif_params *vpif;
+        unsigned long addr = 0;
+        int ret = 0;
+
+        vpif_dbg(2, debug, "vpif_streamon\n");
+
+        vpif = &ch->vpifparams;
+
+        if (buftype != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                vpif_dbg(1, debug, "buffer type not supported\n");
+                return -EINVAL;
+        }
+
+        /* If file handle is not allowed IO, return error */
+        if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
+                vpif_dbg(1, debug, "io not allowed\n");
+                return -EACCES;
+        }
+
+        /* If Streaming is already started, return error */
+        if (common->started) {
+                vpif_dbg(1, debug, "channel->started\n");
+                return -EBUSY;
+        }
+
+        if ((ch->channel_id == VPIF_CHANNEL0_VIDEO &&
+            oth_ch->common[VPIF_VIDEO_INDEX].started &&
+            vpif->std_info.ycmux_mode == 0) ||
+           ((ch->channel_id == VPIF_CHANNEL1_VIDEO) &&
+            (2 == oth_ch->common[VPIF_VIDEO_INDEX].started))) {
+                vpif_dbg(1, debug, "other channel is being used\n");
+                return -EBUSY;
+        }
+
+        ret = vpif_check_format(ch, &common->fmt.fmt.pix, 0);
+        if (ret)
+                return ret;
+
+        /* Enable streamon on the sub device */
+        ret = v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index], video,
+                                s_stream, 1);
+
+        if (ret && (ret != -ENOIOCTLCMD)) {
+                vpif_dbg(1, debug, "stream on failed in subdev\n");
+                return ret;
+        }
+
+        /* Call videobuf_streamon to start streaming in videobuf */
+        ret = videobuf_streamon(&common->buffer_queue);
+        if (ret) {
+                vpif_dbg(1, debug, "videobuf_streamon\n");
+                return ret;
+        }
+
+        if (mutex_lock_interruptible(&common->lock)) {
+                ret = -ERESTARTSYS;
+                goto streamoff_exit;
+        }
+
+        /* If buffer queue is empty, return error */
+        if (list_empty(&common->dma_queue)) {
+                vpif_dbg(1, debug, "buffer queue is empty\n");
+                ret = -EIO;
+                goto exit;
+        }
+
+        /* Get the next frame from the buffer queue */
+        common->cur_frm = list_entry(common->dma_queue.next,
+                                    struct videobuf_buffer, queue);
+        common->next_frm = common->cur_frm;
+
+        /* Remove buffer from the buffer queue */
+        list_del(&common->cur_frm->queue);
+        /* Mark state of the current frame to active */
+        common->cur_frm->state = VIDEOBUF_ACTIVE;
+        /* Initialize field_id and started member */
+        ch->field_id = 0;
+        common->started = 1;
+
+        if (V4L2_MEMORY_USERPTR == common->memory)
+                addr = common->cur_frm->boff;
+        else
+                addr = videobuf_to_dma_contig(common->cur_frm);
+
+        /* Calculate the offset for Y and C data in the buffer */
+        vpif_calculate_offsets(ch);
+
+        if ((vpif->std_info.frm_fmt &&
+            ((common->fmt.fmt.pix.field != V4L2_FIELD_NONE) &&
+             (common->fmt.fmt.pix.field != V4L2_FIELD_ANY))) ||
+            (!vpif->std_info.frm_fmt &&
+             (common->fmt.fmt.pix.field == V4L2_FIELD_NONE))) {
+                vpif_dbg(1, debug, "conflict in field format and std format\n");
+                ret = -EINVAL;
+                goto exit;
+        }
+
+        /* configure 1 or 2 channel mode */
+        ret = config->setup_input_channel_mode(vpif->std_info.ycmux_mode);
+
+        if (ret < 0) {
+                vpif_dbg(1, debug, "can't set vpif channel mode\n");
+                goto exit;
+        }
+
+        /* Call vpif_set_params function to set the parameters and addresses */
+        ret = vpif_set_video_params(vpif, ch->channel_id);
+
+        if (ret < 0) {
+                vpif_dbg(1, debug, "can't set video params\n");
+                goto exit;
+        }
+
+        common->started = ret;
+        vpif_config_addr(ch, ret);
+
+        common->set_addr(addr + common->ytop_off,
+                         addr + common->ybtm_off,
+                         addr + common->ctop_off,
+                         addr + common->cbtm_off);
+
+        /**
+         * Set interrupt for both the fields in VPIF Register enable channel in
+         * VPIF register
+         */
+        if ((VPIF_CHANNEL0_VIDEO == ch->channel_id)) {
+                channel0_intr_assert();
+                channel0_intr_enable(1);
+                enable_channel0(1);
+        }
+        if ((VPIF_CHANNEL1_VIDEO == ch->channel_id) ||
+            (common->started == 2)) {
+                channel1_intr_assert();
+                channel1_intr_enable(1);
+                enable_channel1(1);
+        }
+        channel_first_int[VPIF_VIDEO_INDEX][ch->channel_id] = 1;
+        mutex_unlock(&common->lock);
+        return ret;
+
+exit:
+        mutex_unlock(&common->lock);
+streamoff_exit:
+        ret = videobuf_streamoff(&common->buffer_queue);
+        return ret;
+}
+
+/**
+ * vpif_streamoff() - streamoff handler
+ * @file: file ptr
+ * @priv: file handle
+ * @buftype: v4l2 buffer type
+ */
+static int vpif_streamoff(struct file *file, void *priv,
+                                enum v4l2_buf_type buftype)
+{
+
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        int ret;
+
+        vpif_dbg(2, debug, "vpif_streamoff\n");
+
+        if (buftype != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                vpif_dbg(1, debug, "buffer type not supported\n");
+                return -EINVAL;
+        }
+
+        /* If io is allowed for this file handle, return error */
+        if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
+                vpif_dbg(1, debug, "io not allowed\n");
+                return -EACCES;
+        }
+
+        /* If streaming is not started, return error */
+        if (!common->started) {
+                vpif_dbg(1, debug, "channel->started\n");
+                return -EINVAL;
+        }
+
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        /* disable channel */
+        if (VPIF_CHANNEL0_VIDEO == ch->channel_id) {
+                enable_channel0(0);
+                channel0_intr_enable(0);
+        } else {
+                enable_channel1(0);
+                channel1_intr_enable(0);
+        }
+
+        common->started = 0;
+
+        ret = v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index], video,
+                                s_stream, 0);
+
+        if (ret && (ret != -ENOIOCTLCMD))
+                vpif_dbg(1, debug, "stream off failed in subdev\n");
+
+        mutex_unlock(&common->lock);
+
+        return videobuf_streamoff(&common->buffer_queue);
+}
+
+/**
+ * vpif_map_sub_device_to_input() - Maps sub device to input
+ * @ch - ptr to channel
+ * @config - ptr to capture configuration
+ * @input_index - Given input index from application
+ * @sub_device_index - index into sd table
+ *
+ * lookup the sub device information for a given input index.
+ * we report all the inputs to application. inputs table also
+ * has sub device name for the each input
+ */
+static struct vpif_subdev_info *vpif_map_sub_device_to_input(
+                                struct channel_obj *ch,
+                                struct vpif_capture_config *vpif_cfg,
+                                int input_index,
+                                int *sub_device_index)
+{
+        struct vpif_capture_chan_config *chan_cfg;
+        struct vpif_subdev_info *subdev_info = NULL;
+        const char *subdev_name = NULL;
+        int i;
+
+        vpif_dbg(2, debug, "vpif_map_sub_device_to_input\n");
+
+        chan_cfg = &vpif_cfg->chan_config[ch->channel_id];
+
+        /**
+         * search through the inputs to find the sub device supporting
+         * the input
+         */
+        for (i = 0; i < chan_cfg->input_count; i++) {
+                /* For each sub device, loop through input */
+                if (i == input_index) {
+                        subdev_name = chan_cfg->inputs[i].subdev_name;
+                        break;
+                }
+        }
+
+        /* if reached maximum. return null */
+        if (i == chan_cfg->input_count || (NULL == subdev_name))
+                return subdev_info;
+
+        /* loop through the sub device list to get the sub device info */
+        for (i = 0; i < vpif_cfg->subdev_count; i++) {
+                subdev_info = &vpif_cfg->subdev_info[i];
+                if (!strcmp(subdev_info->name, subdev_name))
+                        break;
+        }
+
+        if (i == vpif_cfg->subdev_count)
+                return subdev_info;
+
+        /* check if the sub device is registered */
+        if (NULL == vpif_obj.sd[i])
+                return NULL;
+
+        *sub_device_index = i;
+        return subdev_info;
+}
+
+/**
+ * vpif_querystd() - querystd handler
+ * @file: file ptr
+ * @priv: file handle
+ * @std_id: ptr to std id
+ *
+ * This function is called to detect standard at the selected input
+ */
+static int vpif_querystd(struct file *file, void *priv, v4l2_std_id *std_id)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        int ret = 0;
+
+        vpif_dbg(2, debug, "vpif_querystd\n");
+
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        /* Call querystd function of decoder device */
+        ret = v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index], video,
+                                querystd, std_id);
+        if (ret < 0)
+                vpif_dbg(1, debug, "Failed to set standard for sub devices\n");
+
+        mutex_unlock(&common->lock);
+        return ret;
+}
+
+/**
+ * vpif_g_std() - get STD handler
+ * @file: file ptr
+ * @priv: file handle
+ * @std_id: ptr to std id
+ */
+static int vpif_g_std(struct file *file, void *priv, v4l2_std_id *std)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+
+        vpif_dbg(2, debug, "vpif_g_std\n");
+
+        *std = ch->video.stdid;
+        return 0;
+}
+
+/**
+ * vpif_s_std() - set STD handler
+ * @file: file ptr
+ * @priv: file handle
+ * @std_id: ptr to std id
+ */
+static int vpif_s_std(struct file *file, void *priv, v4l2_std_id *std_id)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        int ret = 0;
+
+        vpif_dbg(2, debug, "vpif_s_std\n");
+
+        if (common->started) {
+                vpif_err("streaming in progress\n");
+                return -EBUSY;
+        }
+
+        if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) ||
+            (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
+                if (!fh->initialized) {
+                        vpif_dbg(1, debug, "Channel Busy\n");
+                        return -EBUSY;
+                }
+        }
+
+        ret = v4l2_prio_check(&ch->prio, &fh->prio);
+        if (0 != ret)
+                return ret;
+
+        fh->initialized = 1;
+
+        /* Call encoder subdevice function to set the standard */
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        ch->video.stdid = *std_id;
+
+        /* Get the information about the standard */
+        if (vpif_update_std_info(ch)) {
+                ret = -EINVAL;
+                vpif_err("Error getting the standard info\n");
+                goto s_std_exit;
+        }
+
+        /* Configure the default format information */
+        vpif_config_format(ch);
+
+        /* set standard in the sub device */
+        ret = v4l2_subdev_call(vpif_obj.sd[ch->curr_sd_index], core,
+                                s_std, *std_id);
+        if (ret < 0)
+                vpif_dbg(1, debug, "Failed to set standard for sub devices\n");
+
+s_std_exit:
+        mutex_unlock(&common->lock);
+        return ret;
+}
+
+/**
+ * vpif_enum_input() - ENUMINPUT handler
+ * @file: file ptr
+ * @priv: file handle
+ * @input: ptr to input structure
+ */
+static int vpif_enum_input(struct file *file, void *priv,
+                                struct v4l2_input *input)
+{
+
+        struct vpif_capture_config *config = vpif_dev->platform_data;
+        struct vpif_capture_chan_config *chan_cfg;
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+
+        chan_cfg = &config->chan_config[ch->channel_id];
+
+        if (input->index >= chan_cfg->input_count) {
+                vpif_dbg(1, debug, "Invalid input index\n");
+                return -EINVAL;
+        }
+
+        memcpy(input, &chan_cfg->inputs[input->index].input,
+                sizeof(*input));
+        return 0;
+}
+
+/**
+ * vpif_g_input() - Get INPUT handler
+ * @file: file ptr
+ * @priv: file handle
+ * @index: ptr to input index
+ */
+static int vpif_g_input(struct file *file, void *priv, unsigned int *index)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct video_obj *vid_ch = &ch->video;
+
+        *index = vid_ch->input_idx;
+
+        return 0;
+}
+
+/**
+ * vpif_s_input() - Set INPUT handler
+ * @file: file ptr
+ * @priv: file handle
+ * @index: input index
+ */
+static int vpif_s_input(struct file *file, void *priv, unsigned int index)
+{
+        struct vpif_capture_config *config = vpif_dev->platform_data;
+        struct vpif_capture_chan_config *chan_cfg;
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        struct video_obj *vid_ch = &ch->video;
+        struct vpif_subdev_info *subdev_info;
+        int ret = 0, sd_index = 0;
+        u32 input = 0, output = 0;
+
+        chan_cfg = &config->chan_config[ch->channel_id];
+
+        if (common->started) {
+                vpif_err("Streaming in progress\n");
+                return -EBUSY;
+        }
+
+        if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) ||
+            (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
+                if (!fh->initialized) {
+                        vpif_dbg(1, debug, "Channel Busy\n");
+                        return -EBUSY;
+                }
+        }
+
+        ret = v4l2_prio_check(&ch->prio, &fh->prio);
+        if (0 != ret)
+                return ret;
+
+        fh->initialized = 1;
+        subdev_info = vpif_map_sub_device_to_input(ch, config, index,
+                                                   &sd_index);
+        if (NULL == subdev_info) {
+                vpif_dbg(1, debug,
+                        "couldn't lookup sub device for the input index\n");
+                return -EINVAL;
+        }
+
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        /* first setup input path from sub device to vpif */
+        if (config->setup_input_path) {
+                ret = config->setup_input_path(ch->channel_id,
+                                               subdev_info->name);
+                if (ret < 0) {
+                        vpif_dbg(1, debug, "couldn't setup input path for the"
+                                " sub device %s, for input index %d\n",
+                                subdev_info->name, index);
+                        goto exit;
+                }
+        }
+
+        if (subdev_info->can_route) {
+                input = subdev_info->input;
+                output = subdev_info->output;
+                ret = v4l2_subdev_call(vpif_obj.sd[sd_index], video, s_routing,
+                                        input, output, 0);
+                if (ret < 0) {
+                        vpif_dbg(1, debug, "Failed to set input\n");
+                        goto exit;
+                }
+        }
+        vid_ch->input_idx = index;
+        ch->curr_subdev_info = subdev_info;
+        ch->curr_sd_index = sd_index;
+        /* copy interface parameters to vpif */
+        ch->vpifparams.iface = subdev_info->vpif_if;
+
+        /* update tvnorms from the sub device input info */
+        ch->video_dev->tvnorms = chan_cfg->inputs[index].input.std;
+
+exit:
+        mutex_unlock(&common->lock);
+        return ret;
+}
+
+/**
+ * vpif_enum_fmt_vid_cap() - ENUM_FMT handler
+ * @file: file ptr
+ * @priv: file handle
+ * @index: input index
+ */
+static int vpif_enum_fmt_vid_cap(struct file *file, void  *priv,
+                                        struct v4l2_fmtdesc *fmt)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+
+        if (fmt->index != 0) {
+                vpif_dbg(1, debug, "Invalid format index\n");
+                return -EINVAL;
+        }
+
+        /* Fill in the information about format */
+        if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER) {
+                fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                strcpy(fmt->description, "Raw Mode -Bayer Pattern GrRBGb");
+                fmt->pixelformat = V4L2_PIX_FMT_SBGGR8;
+        } else {
+                fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                strcpy(fmt->description, "YCbCr4:2:2 YC Planar");
+                fmt->pixelformat = V4L2_PIX_FMT_YUV422P;
+        }
+        return 0;
+}
+
+/**
+ * vpif_try_fmt_vid_cap() - TRY_FMT handler
+ * @file: file ptr
+ * @priv: file handle
+ * @fmt: ptr to v4l2 format structure
+ */
+static int vpif_try_fmt_vid_cap(struct file *file, void *priv,
+                                struct v4l2_format *fmt)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
+
+        return vpif_check_format(ch, pixfmt, 1);
+}
+
+
+/**
+ * vpif_g_fmt_vid_cap() - Set INPUT handler
+ * @file: file ptr
+ * @priv: file handle
+ * @fmt: ptr to v4l2 format structure
+ */
+static int vpif_g_fmt_vid_cap(struct file *file, void *priv,
+                                struct v4l2_format *fmt)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        /* Check the validity of the buffer type */
+        if (common->fmt.type != fmt->type)
+                return -EINVAL;
+
+        /* Fill in the information about format */
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        *fmt = common->fmt;
+        mutex_unlock(&common->lock);
+        return 0;
+}
+
+/**
+ * vpif_s_fmt_vid_cap() - Set FMT handler
+ * @file: file ptr
+ * @priv: file handle
+ * @fmt: ptr to v4l2 format structure
+ */
+static int vpif_s_fmt_vid_cap(struct file *file, void *priv,
+                                struct v4l2_format *fmt)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        struct v4l2_pix_format *pixfmt;
+        int ret = 0;
+
+        vpif_dbg(2, debug, "VIDIOC_S_FMT\n");
+
+        /* If streaming is started, return error */
+        if (common->started) {
+                vpif_dbg(1, debug, "Streaming is started\n");
+                return -EBUSY;
+        }
+
+        if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) ||
+            (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
+                if (!fh->initialized) {
+                        vpif_dbg(1, debug, "Channel Busy\n");
+                        return -EBUSY;
+                }
+        }
+
+        ret = v4l2_prio_check(&ch->prio, &fh->prio);
+        if (0 != ret)
+                return ret;
+
+        fh->initialized = 1;
+
+        pixfmt = &fmt->fmt.pix;
+        /* Check for valid field format */
+        ret = vpif_check_format(ch, pixfmt, 0);
+
+        if (ret)
+                return ret;
+        /* store the format in the channel object */
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        common->fmt = *fmt;
+        mutex_unlock(&common->lock);
+
+        return 0;
+}
+
+/**
+ * vpif_querycap() - QUERYCAP handler
+ * @file: file ptr
+ * @priv: file handle
+ * @cap: ptr to v4l2_capability structure
+ */
+static int vpif_querycap(struct file *file, void  *priv,
+                                struct v4l2_capability *cap)
+{
+        struct vpif_capture_config *config = vpif_dev->platform_data;
+
+        cap->version = VPIF_CAPTURE_VERSION_CODE;
+        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+        strlcpy(cap->driver, "vpif capture", sizeof(cap->driver));
+        strlcpy(cap->bus_info, "DM646x Platform", sizeof(cap->bus_info));
+        strlcpy(cap->card, config->card_name, sizeof(cap->card));
+
+        return 0;
+}
+
+/**
+ * vpif_g_priority() - get priority handler
+ * @file: file ptr
+ * @priv: file handle
+ * @prio: ptr to v4l2_priority structure
+ */
+static int vpif_g_priority(struct file *file, void *priv,
+                           enum v4l2_priority *prio)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+
+        *prio = v4l2_prio_max(&ch->prio);
+
+        return 0;
+}
+
+/**
+ * vpif_s_priority() - set priority handler
+ * @file: file ptr
+ * @priv: file handle
+ * @prio: ptr to v4l2_priority structure
+ */
+static int vpif_s_priority(struct file *file, void *priv, enum v4l2_priority p)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+
+        return v4l2_prio_change(&ch->prio, &fh->prio, p);
+}
+
+/**
+ * vpif_cropcap() - cropcap handler
+ * @file: file ptr
+ * @priv: file handle
+ * @crop: ptr to v4l2_cropcap structure
+ */
+static int vpif_cropcap(struct file *file, void *priv,
+                        struct v4l2_cropcap *crop)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != crop->type)
+                return -EINVAL;
+
+        crop->bounds.left = 0;
+        crop->bounds.top = 0;
+        crop->bounds.height = common->height;
+        crop->bounds.width = common->width;
+        crop->defrect = crop->bounds;
+        return 0;
+}
+
+/* vpif capture ioctl operations */
+static const struct v4l2_ioctl_ops vpif_ioctl_ops = {
+        .vidioc_querycap                = vpif_querycap,
+        .vidioc_g_priority              = vpif_g_priority,
+        .vidioc_s_priority              = vpif_s_priority,
+        .vidioc_enum_fmt_vid_cap        = vpif_enum_fmt_vid_cap,
+        .vidioc_g_fmt_vid_cap           = vpif_g_fmt_vid_cap,
+        .vidioc_s_fmt_vid_cap           = vpif_s_fmt_vid_cap,
+        .vidioc_try_fmt_vid_cap         = vpif_try_fmt_vid_cap,
+        .vidioc_enum_input              = vpif_enum_input,
+        .vidioc_s_input                 = vpif_s_input,
+        .vidioc_g_input                 = vpif_g_input,
+        .vidioc_reqbufs                 = vpif_reqbufs,
+        .vidioc_querybuf                = vpif_querybuf,
+        .vidioc_querystd                = vpif_querystd,
+        .vidioc_s_std                   = vpif_s_std,
+        .vidioc_g_std                   = vpif_g_std,
+        .vidioc_qbuf                    = vpif_qbuf,
+        .vidioc_dqbuf                   = vpif_dqbuf,
+        .vidioc_streamon                = vpif_streamon,
+        .vidioc_streamoff               = vpif_streamoff,
+        .vidioc_cropcap                 = vpif_cropcap,
+};
+
+/* vpif file operations */
+static struct v4l2_file_operations vpif_fops = {
+        .owner = THIS_MODULE,
+        .open = vpif_open,
+        .release = vpif_release,
+        .ioctl = video_ioctl2,
+        .mmap = vpif_mmap,
+        .poll = vpif_poll
+};
+
+/* vpif video template */
+static struct video_device vpif_video_template = {
+        .name           = "vpif",
+        .fops           = &vpif_fops,
+        .minor          = -1,
+        .ioctl_ops      = &vpif_ioctl_ops,
+};
+
+/**
+ * initialize_vpif() - Initialize vpif data structures
+ *
+ * Allocate memory for data structures and initialize them
+ */
+static int initialize_vpif(void)
+{
+        int err = 0, i, j;
+        int free_channel_objects_index;
+
+        /* Default number of buffers should be 3 */
+        if ((ch0_numbuffers > 0) &&
+            (ch0_numbuffers < config_params.min_numbuffers))
+                ch0_numbuffers = config_params.min_numbuffers;
+        if ((ch1_numbuffers > 0) &&
+            (ch1_numbuffers < config_params.min_numbuffers))
+                ch1_numbuffers = config_params.min_numbuffers;
+
+        /* Set buffer size to min buffers size if it is invalid */
+        if (ch0_bufsize < config_params.min_bufsize[VPIF_CHANNEL0_VIDEO])
+                ch0_bufsize =
+                    config_params.min_bufsize[VPIF_CHANNEL0_VIDEO];
+        if (ch1_bufsize < config_params.min_bufsize[VPIF_CHANNEL1_VIDEO])
+                ch1_bufsize =
+                    config_params.min_bufsize[VPIF_CHANNEL1_VIDEO];
+
+        config_params.numbuffers[VPIF_CHANNEL0_VIDEO] = ch0_numbuffers;
+        config_params.numbuffers[VPIF_CHANNEL1_VIDEO] = ch1_numbuffers;
+        if (ch0_numbuffers) {
+                config_params.channel_bufsize[VPIF_CHANNEL0_VIDEO]
+                    = ch0_bufsize;
+        }
+        if (ch1_numbuffers) {
+                config_params.channel_bufsize[VPIF_CHANNEL1_VIDEO]
+                    = ch1_bufsize;
+        }
+
+        /* Allocate memory for six channel objects */
+        for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
+                vpif_obj.dev[i] =
+                    kzalloc(sizeof(*vpif_obj.dev[i]), GFP_KERNEL);
+                /* If memory allocation fails, return error */
+                if (!vpif_obj.dev[i]) {
+                        free_channel_objects_index = i;
+                        err = -ENOMEM;
+                        goto vpif_init_free_channel_objects;
+                }
+        }
+        return 0;
+
+vpif_init_free_channel_objects:
+        for (j = 0; j < free_channel_objects_index; j++)
+                kfree(vpif_obj.dev[j]);
+        return err;
+}
+
+/**
+ * vpif_probe : This function probes the vpif capture driver
+ * @pdev: platform device pointer
+ *
+ * This creates device entries by register itself to the V4L2 driver and
+ * initializes fields of each channel objects
+ */
+static __init int vpif_probe(struct platform_device *pdev)
+{
+        struct vpif_subdev_info *subdevdata;
+        struct vpif_capture_config *config;
+        int i, j, k, m, q, err;
+        struct i2c_adapter *i2c_adap;
+        struct channel_obj *ch;
+        struct common_obj *common;
+        struct video_device *vfd;
+        struct resource *res;
+        int subdev_count;
+
+        vpif_dev = &pdev->dev;
+
+        err = initialize_vpif();
+        if (err) {
+                v4l2_err(vpif_dev->driver, "Error initializing vpif\n");
+                return err;
+        }
+
+        k = 0;
+        while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, k))) {
+                for (i = res->start; i <= res->end; i++) {
+                        if (request_irq(i, vpif_channel_isr, IRQF_DISABLED,
+                                        "DM646x_Capture",
+                                (void *)(&vpif_obj.dev[k]->channel_id))) {
+                                err = -EBUSY;
+                                i--;
+                                goto vpif_int_err;
+                        }
+                }
+                k++;
+        }
+
+        for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
+                /* Get the pointer to the channel object */
+                ch = vpif_obj.dev[i];
+                /* Allocate memory for video device */
+                vfd = video_device_alloc();
+                if (NULL == vfd) {
+                        for (j = 0; j < i; j++) {
+                                ch = vpif_obj.dev[j];
+                                video_device_release(ch->video_dev);
+                        }
+                        err = -ENOMEM;
+                        goto vpif_dev_alloc_err;
+                }
+
+                /* Initialize field of video device */
+                *vfd = vpif_video_template;
+                vfd->v4l2_dev = &vpif_obj.v4l2_dev;
+                vfd->release = video_device_release;
+                snprintf(vfd->name, sizeof(vfd->name),
+                         "DM646x_VPIFCapture_DRIVER_V%d.%d.%d",
+                         (VPIF_CAPTURE_VERSION_CODE >> 16) & 0xff,
+                         (VPIF_CAPTURE_VERSION_CODE >> 8) & 0xff,
+                         (VPIF_CAPTURE_VERSION_CODE) & 0xff);
+                /* Set video_dev to the video device */
+                ch->video_dev = vfd;
+        }
+
+        for (j = 0; j < VPIF_CAPTURE_MAX_DEVICES; j++) {
+                ch = vpif_obj.dev[j];
+                ch->channel_id = j;
+                common = &(ch->common[VPIF_VIDEO_INDEX]);
+                spin_lock_init(&common->irqlock);
+                mutex_init(&common->lock);
+                /* Initialize prio member of channel object */
+                v4l2_prio_init(&ch->prio);
+                err = video_register_device(ch->video_dev,
+                                            VFL_TYPE_GRABBER, (j ? 1 : 0));
+                if (err)
+                        goto probe_out;
+
+                video_set_drvdata(ch->video_dev, ch);
+
+        }
+
+        i2c_adap = i2c_get_adapter(1);
+        config = pdev->dev.platform_data;
+
+        subdev_count = config->subdev_count;
+        vpif_obj.sd = kmalloc(sizeof(struct v4l2_subdev *) * subdev_count,
+                                GFP_KERNEL);
+        if (vpif_obj.sd == NULL) {
+                vpif_err("unable to allocate memory for subdevice pointers\n");
+                err = -ENOMEM;
+                goto probe_out;
+        }
+
+        err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev);
+        if (err) {
+                v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n");
+                goto probe_subdev_out;
+        }
+
+        for (i = 0; i < subdev_count; i++) {
+                subdevdata = &config->subdev_info[i];
+                vpif_obj.sd[i] =
+                        v4l2_i2c_new_subdev_board(&vpif_obj.v4l2_dev,
+                                                  i2c_adap,
+                                                  subdevdata->name,
+                                                  &subdevdata->board_info,
+                                                  NULL);
+
+                if (!vpif_obj.sd[i]) {
+                        vpif_err("Error registering v4l2 subdevice\n");
+                        goto probe_subdev_out;
+                }
+                v4l2_info(&vpif_obj.v4l2_dev, "registered sub device %s\n",
+                          subdevdata->name);
+
+                if (vpif_obj.sd[i])
+                        vpif_obj.sd[i]->grp_id = 1 << i;
+        }
+        v4l2_info(&vpif_obj.v4l2_dev, "DM646x VPIF Capture driver"
+                  " initialized\n");
+
+        return 0;
+
+probe_subdev_out:
+        /* free sub devices memory */
+        kfree(vpif_obj.sd);
+
+        j = VPIF_CAPTURE_MAX_DEVICES;
+probe_out:
+        v4l2_device_unregister(&vpif_obj.v4l2_dev);
+        for (k = 0; k < j; k++) {
+                /* Get the pointer to the channel object */
+                ch = vpif_obj.dev[k];
+                /* Unregister video device */
+                video_unregister_device(ch->video_dev);
+        }
+
+vpif_dev_alloc_err:
+        k = VPIF_CAPTURE_MAX_DEVICES-1;
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, k);
+        i = res->end;
+
+vpif_int_err:
+        for (q = k; q >= 0; q--) {
+                for (m = i; m >= (int)res->start; m--)
+                        free_irq(m, (void *)(&vpif_obj.dev[q]->channel_id));
+
+                res = platform_get_resource(pdev, IORESOURCE_IRQ, q-1);
+                if (res)
+                        i = res->end;
+        }
+        return err;
+}
+
+/**
+ * vpif_remove() - driver remove handler
+ * @device: ptr to platform device structure
+ *
+ * The vidoe device is unregistered
+ */
+static int vpif_remove(struct platform_device *device)
+{
+        int i;
+        struct channel_obj *ch;
+
+        v4l2_device_unregister(&vpif_obj.v4l2_dev);
+
+        /* un-register device */
+        for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
+                /* Get the pointer to the channel object */
+                ch = vpif_obj.dev[i];
+                /* Unregister video device */
+                video_unregister_device(ch->video_dev);
+        }
+        return 0;
+}
+
+/**
+ * vpif_suspend: vpif device suspend
+ *
+ * TODO: Add suspend code here
+ */
+static int
+vpif_suspend(struct device *dev)
+{
+        return -1;
+}
+
+/**
+ * vpif_resume: vpif device suspend
+ *
+ * TODO: Add resume code here
+ */
+static int
+vpif_resume(struct device *dev)
+{
+        return -1;
+}
+
+static struct dev_pm_ops vpif_dev_pm_ops = {
+        .suspend = vpif_suspend,
+        .resume = vpif_resume,
+};
+
+static struct platform_driver vpif_driver = {
+        .driver = {
+                .name   = "vpif_capture",
+                .owner  = THIS_MODULE,
+                .pm = &vpif_dev_pm_ops,
+        },
+        .probe = vpif_probe,
+        .remove = vpif_remove,
+};
+
+/**
+ * vpif_init: initialize the vpif driver
+ *
+ * This function registers device and driver to the kernel, requests irq
+ * handler and allocates memory
+ * for channel objects
+ */
+static __init int vpif_init(void)
+{
+        return platform_driver_register(&vpif_driver);
+}
+
+/**
+ * vpif_cleanup : This function clean up the vpif capture resources
+ *
+ * This will un-registers device and driver to the kernel, frees
+ * requested irq handler and de-allocates memory allocated for channel
+ * objects.
+ */
+static void vpif_cleanup(void)
+{
+        struct platform_device *pdev;
+        struct resource *res;
+        int irq_num;
+        int i = 0;
+
+        pdev = container_of(vpif_dev, struct platform_device, dev);
+        while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, i))) {
+                for (irq_num = res->start; irq_num <= res->end; irq_num++)
+                        free_irq(irq_num,
+                                 (void *)(&vpif_obj.dev[i]->channel_id));
+                i++;
+        }
+
+        platform_driver_unregister(&vpif_driver);
+
+        kfree(vpif_obj.sd);
+        for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++)
+                kfree(vpif_obj.dev[i]);
+}
+
+/* Function for module initialization and cleanup */
+module_init(vpif_init);
+module_exit(vpif_cleanup);
diff --git a/drivers/media/video/davinci/vpif_capture.h b/drivers/media/video/davinci/vpif_capture.h
new file mode 100644
index 000000000000..4e12ec8cac6f
--- /dev/null
+++ b/drivers/media/video/davinci/vpif_capture.h
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2009 Texas Instruments Inc
+ *
+ * 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
+ */
+
+#ifndef VPIF_CAPTURE_H
+#define VPIF_CAPTURE_H
+
+#ifdef __KERNEL__
+
+/* Header files */
+#include <linux/videodev2.h>
+#include <linux/version.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-device.h>
+#include <media/videobuf-core.h>
+#include <media/videobuf-dma-contig.h>
+#include <mach/dm646x.h>
+
+#include "vpif.h"
+
+/* Macros */
+#define VPIF_MAJOR_RELEASE              0
+#define VPIF_MINOR_RELEASE              0
+#define VPIF_BUILD                      1
+#define VPIF_CAPTURE_VERSION_CODE       ((VPIF_MAJOR_RELEASE << 16) | \
+        (VPIF_MINOR_RELEASE << 8) | VPIF_BUILD)
+
+#define VPIF_VALID_FIELD(field)         (((V4L2_FIELD_ANY == field) || \
+        (V4L2_FIELD_NONE == field)) || \
+        (((V4L2_FIELD_INTERLACED == field) || \
+        (V4L2_FIELD_SEQ_TB == field)) || \
+        (V4L2_FIELD_SEQ_BT == field)))
+
+#define VPIF_CAPTURE_MAX_DEVICES        2
+#define VPIF_VIDEO_INDEX                0
+#define VPIF_NUMBER_OF_OBJECTS          1
+
+/* Enumerated data type to give id to each device per channel */
+enum vpif_channel_id {
+        VPIF_CHANNEL0_VIDEO = 0,
+        VPIF_CHANNEL1_VIDEO,
+};
+
+struct video_obj {
+        enum v4l2_field buf_field;
+        /* Currently selected or default standard */
+        v4l2_std_id stdid;
+        /* This is to track the last input that is passed to application */
+        u32 input_idx;
+};
+
+struct common_obj {
+        /* Pointer pointing to current v4l2_buffer */
+        struct videobuf_buffer *cur_frm;
+        /* Pointer pointing to current v4l2_buffer */
+        struct videobuf_buffer *next_frm;
+        /*
+         * This field keeps track of type of buffer exchange mechanism
+         * user has selected
+         */
+        enum v4l2_memory memory;
+        /* Used to store pixel format */
+        struct v4l2_format fmt;
+        /* Buffer queue used in video-buf */
+        struct videobuf_queue buffer_queue;
+        /* Queue of filled frames */
+        struct list_head dma_queue;
+        /* Used in video-buf */
+        spinlock_t irqlock;
+        /* lock used to access this structure */
+        struct mutex lock;
+        /* number of users performing IO */
+        u32 io_usrs;
+        /* Indicates whether streaming started */
+        u8 started;
+        /* Function pointer to set the addresses */
+        void (*set_addr) (unsigned long, unsigned long, unsigned long,
+                          unsigned long);
+        /* offset where Y top starts from the starting of the buffer */
+        u32 ytop_off;
+        /* offset where Y bottom starts from the starting of the buffer */
+        u32 ybtm_off;
+        /* offset where C top starts from the starting of the buffer */
+        u32 ctop_off;
+        /* offset where C bottom starts from the starting of the buffer */
+        u32 cbtm_off;
+        /* Indicates width of the image data */
+        u32 width;
+        /* Indicates height of the image data */
+        u32 height;
+};
+
+struct channel_obj {
+        /* Identifies video device for this channel */
+        struct video_device *video_dev;
+        /* Used to keep track of state of the priority */
+        struct v4l2_prio_state prio;
+        /* number of open instances of the channel */
+        int usrs;
+        /* Indicates id of the field which is being displayed */
+        u32 field_id;
+        /* flag to indicate whether decoder is initialized */
+        u8 initialized;
+        /* Identifies channel */
+        enum vpif_channel_id channel_id;
+        /* index into sd table */
+        int curr_sd_index;
+        /* ptr to current sub device information */
+        struct vpif_subdev_info *curr_subdev_info;
+        /* vpif configuration params */
+        struct vpif_params vpifparams;
+        /* common object array */
+        struct common_obj common[VPIF_NUMBER_OF_OBJECTS];
+        /* video object */
+        struct video_obj video;
+};
+
+/* File handle structure */
+struct vpif_fh {
+        /* pointer to channel object for opened device */
+        struct channel_obj *channel;
+        /* Indicates whether this file handle is doing IO */
+        u8 io_allowed[VPIF_NUMBER_OF_OBJECTS];
+        /* Used to keep track priority of this instance */
+        enum v4l2_priority prio;
+        /* Used to indicate channel is initialize or not */
+        u8 initialized;
+};
+
+struct vpif_device {
+        struct v4l2_device v4l2_dev;
+        struct channel_obj *dev[VPIF_CAPTURE_NUM_CHANNELS];
+        struct v4l2_subdev **sd;
+};
+
+struct vpif_config_params {
+        u8 min_numbuffers;
+        u8 numbuffers[VPIF_CAPTURE_NUM_CHANNELS];
+        s8 device_type;
+        u32 min_bufsize[VPIF_CAPTURE_NUM_CHANNELS];
+        u32 channel_bufsize[VPIF_CAPTURE_NUM_CHANNELS];
+        u8 default_device[VPIF_CAPTURE_NUM_CHANNELS];
+        u8 max_device_type;
+};
+/* Struct which keeps track of the line numbers for the sliced vbi service */
+struct vpif_service_line {
+        u16 service_id;
+        u16 service_line[2];
+};
+#endif                          /* End of __KERNEL__ */
+#endif                          /* VPIF_CAPTURE_H */
diff --git a/drivers/media/video/davinci/vpif_display.c b/drivers/media/video/davinci/vpif_display.c
new file mode 100644
index 000000000000..c015da813dda
--- /dev/null
+++ b/drivers/media/video/davinci/vpif_display.c
@@ -0,0 +1,1656 @@
+/*
+ * vpif-display - VPIF display driver
+ * Display driver for TI DaVinci VPIF
+ *
+ * Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.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 version 2.
+ *
+ * This program is distributed .as is. WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/workqueue.h>
+#include <linux/string.h>
+#include <linux/videodev2.h>
+#include <linux/wait.h>
+#include <linux/time.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/version.h>
+
+#include <asm/irq.h>
+#include <asm/page.h>
+
+#include <media/adv7343.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-ioctl.h>
+
+#include <mach/dm646x.h>
+
+#include "vpif_display.h"
+#include "vpif.h"
+
+MODULE_DESCRIPTION("TI DaVinci VPIF Display driver");
+MODULE_LICENSE("GPL");
+
+#define DM646X_V4L2_STD (V4L2_STD_525_60 | V4L2_STD_625_50)
+
+#define vpif_err(fmt, arg...)   v4l2_err(&vpif_obj.v4l2_dev, fmt, ## arg)
+#define vpif_dbg(level, debug, fmt, arg...)     \
+                v4l2_dbg(level, debug, &vpif_obj.v4l2_dev, fmt, ## arg)
+
+static int debug = 1;
+static u32 ch2_numbuffers = 3;
+static u32 ch3_numbuffers = 3;
+static u32 ch2_bufsize = 1920 * 1080 * 2;
+static u32 ch3_bufsize = 720 * 576 * 2;
+
+module_param(debug, int, 0644);
+module_param(ch2_numbuffers, uint, S_IRUGO);
+module_param(ch3_numbuffers, uint, S_IRUGO);
+module_param(ch2_bufsize, uint, S_IRUGO);
+module_param(ch3_bufsize, uint, S_IRUGO);
+
+MODULE_PARM_DESC(debug, "Debug level 0-1");
+MODULE_PARM_DESC(ch2_numbuffers, "Channel2 buffer count (default:3)");
+MODULE_PARM_DESC(ch3_numbuffers, "Channel3 buffer count (default:3)");
+MODULE_PARM_DESC(ch2_bufsize, "Channel2 buffer size (default:1920 x 1080 x 2)");
+MODULE_PARM_DESC(ch3_bufsize, "Channel3 buffer size (default:720 x 576 x 2)");
+
+static struct vpif_config_params config_params = {
+        .min_numbuffers         = 3,
+        .numbuffers[0]          = 3,
+        .numbuffers[1]          = 3,
+        .min_bufsize[0]         = 720 * 480 * 2,
+        .min_bufsize[1]         = 720 * 480 * 2,
+        .channel_bufsize[0]     = 1920 * 1080 * 2,
+        .channel_bufsize[1]     = 720 * 576 * 2,
+};
+
+static struct vpif_device vpif_obj = { {NULL} };
+static struct device *vpif_dev;
+
+static const struct vpif_channel_config_params ch_params[] = {
+        {
+                "NTSC", 720, 480, 30, 0, 1, 268, 1440, 1, 23, 263, 266,
+                286, 525, 525, 0, 1, 0, V4L2_STD_525_60,
+        },
+        {
+                "PAL", 720, 576, 25, 0, 1, 280, 1440, 1, 23, 311, 313,
+                336, 624, 625, 0, 1, 0, V4L2_STD_625_50,
+        },
+};
+
+/*
+ * vpif_uservirt_to_phys: This function is used to convert user
+ * space virtual address to physical address.
+ */
+static u32 vpif_uservirt_to_phys(u32 virtp)
+{
+        struct mm_struct *mm = current->mm;
+        unsigned long physp = 0;
+        struct vm_area_struct *vma;
+
+        vma = find_vma(mm, virtp);
+
+        /* For kernel direct-mapped memory, take the easy way */
+        if (virtp >= PAGE_OFFSET) {
+                physp = virt_to_phys((void *)virtp);
+        } else if (vma && (vma->vm_flags & VM_IO) && (vma->vm_pgoff)) {
+                /* this will catch, kernel-allocated, mmaped-to-usermode addr */
+                physp = (vma->vm_pgoff << PAGE_SHIFT) + (virtp - vma->vm_start);
+        } else {
+                /* otherwise, use get_user_pages() for general userland pages */
+                int res, nr_pages = 1;
+                struct page *pages;
+                down_read(&current->mm->mmap_sem);
+
+                res = get_user_pages(current, current->mm,
+                                     virtp, nr_pages, 1, 0, &pages, NULL);
+                up_read(&current->mm->mmap_sem);
+
+                if (res == nr_pages) {
+                        physp = __pa(page_address(&pages[0]) +
+                                                        (virtp & ~PAGE_MASK));
+                } else {
+                        vpif_err("get_user_pages failed\n");
+                        return 0;
+                }
+        }
+
+        return physp;
+}
+
+/*
+ * buffer_prepare: This is the callback function called from videobuf_qbuf()
+ * function the buffer is prepared and user space virtual address is converted
+ * into physical address
+ */
+static int vpif_buffer_prepare(struct videobuf_queue *q,
+                               struct videobuf_buffer *vb,
+                               enum v4l2_field field)
+{
+        struct vpif_fh *fh = q->priv_data;
+        struct common_obj *common;
+        unsigned long addr;
+
+        common = &fh->channel->common[VPIF_VIDEO_INDEX];
+        if (VIDEOBUF_NEEDS_INIT == vb->state) {
+                vb->width       = common->width;
+                vb->height      = common->height;
+                vb->size        = vb->width * vb->height;
+                vb->field       = field;
+        }
+        vb->state = VIDEOBUF_PREPARED;
+
+        /* if user pointer memory mechanism is used, get the physical
+         * address of the buffer */
+        if (V4L2_MEMORY_USERPTR == common->memory) {
+                if (!vb->baddr) {
+                        vpif_err("buffer_address is 0\n");
+                        return -EINVAL;
+                }
+
+                vb->boff = vpif_uservirt_to_phys(vb->baddr);
+                if (!ISALIGNED(vb->boff))
+                        goto buf_align_exit;
+        }
+
+        addr = vb->boff;
+        if (q->streaming && (V4L2_BUF_TYPE_SLICED_VBI_OUTPUT != q->type)) {
+                if (!ISALIGNED(addr + common->ytop_off) ||
+                    !ISALIGNED(addr + common->ybtm_off) ||
+                    !ISALIGNED(addr + common->ctop_off) ||
+                    !ISALIGNED(addr + common->cbtm_off))
+                        goto buf_align_exit;
+        }
+        return 0;
+
+buf_align_exit:
+        vpif_err("buffer offset not aligned to 8 bytes\n");
+        return -EINVAL;
+}
+
+/*
+ * vpif_buffer_setup: This function allocates memory for the buffers
+ */
+static int vpif_buffer_setup(struct videobuf_queue *q, unsigned int *count,
+                                unsigned int *size)
+{
+        struct vpif_fh *fh = q->priv_data;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        if (V4L2_MEMORY_MMAP != common->memory)
+                return 0;
+
+        *size = config_params.channel_bufsize[ch->channel_id];
+        if (*count < config_params.min_numbuffers)
+                *count = config_params.min_numbuffers;
+
+        return 0;
+}
+
+/*
+ * vpif_buffer_queue: This function adds the buffer to DMA queue
+ */
+static void vpif_buffer_queue(struct videobuf_queue *q,
+                              struct videobuf_buffer *vb)
+{
+        struct vpif_fh *fh = q->priv_data;
+        struct common_obj *common;
+
+        common = &fh->channel->common[VPIF_VIDEO_INDEX];
+
+        /* add the buffer to the DMA queue */
+        list_add_tail(&vb->queue, &common->dma_queue);
+        vb->state = VIDEOBUF_QUEUED;
+}
+
+/*
+ * vpif_buffer_release: This function is called from the videobuf layer to
+ * free memory allocated to the buffers
+ */
+static void vpif_buffer_release(struct videobuf_queue *q,
+                                struct videobuf_buffer *vb)
+{
+        struct vpif_fh *fh = q->priv_data;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common;
+        unsigned int buf_size = 0;
+
+        common = &ch->common[VPIF_VIDEO_INDEX];
+
+        videobuf_dma_contig_free(q, vb);
+        vb->state = VIDEOBUF_NEEDS_INIT;
+
+        if (V4L2_MEMORY_MMAP != common->memory)
+                return;
+
+        buf_size = config_params.channel_bufsize[ch->channel_id];
+}
+
+static struct videobuf_queue_ops video_qops = {
+        .buf_setup      = vpif_buffer_setup,
+        .buf_prepare    = vpif_buffer_prepare,
+        .buf_queue      = vpif_buffer_queue,
+        .buf_release    = vpif_buffer_release,
+};
+static u8 channel_first_int[VPIF_NUMOBJECTS][2] = { {1, 1} };
+
+static void process_progressive_mode(struct common_obj *common)
+{
+        unsigned long addr = 0;
+
+        /* Get the next buffer from buffer queue */
+        common->next_frm = list_entry(common->dma_queue.next,
+                                struct videobuf_buffer, queue);
+        /* Remove that buffer from the buffer queue */
+        list_del(&common->next_frm->queue);
+        /* Mark status of the buffer as active */
+        common->next_frm->state = VIDEOBUF_ACTIVE;
+
+        /* Set top and bottom field addrs in VPIF registers */
+        addr = videobuf_to_dma_contig(common->next_frm);
+        common->set_addr(addr + common->ytop_off,
+                                 addr + common->ybtm_off,
+                                 addr + common->ctop_off,
+                                 addr + common->cbtm_off);
+}
+
+static void process_interlaced_mode(int fid, struct common_obj *common)
+{
+        /* device field id and local field id are in sync */
+        /* If this is even field */
+        if (0 == fid) {
+                if (common->cur_frm == common->next_frm)
+                        return;
+
+                /* one frame is displayed If next frame is
+                 *  available, release cur_frm and move on */
+                /* Copy frame display time */
+                do_gettimeofday(&common->cur_frm->ts);
+                /* Change status of the cur_frm */
+                common->cur_frm->state = VIDEOBUF_DONE;
+                /* unlock semaphore on cur_frm */
+                wake_up_interruptible(&common->cur_frm->done);
+                /* Make cur_frm pointing to next_frm */
+                common->cur_frm = common->next_frm;
+
+        } else if (1 == fid) {  /* odd field */
+                if (list_empty(&common->dma_queue)
+                    || (common->cur_frm != common->next_frm)) {
+                        return;
+                }
+                /* one field is displayed configure the next
+                 * frame if it is available else hold on current
+                 * frame */
+                /* Get next from the buffer queue */
+                process_progressive_mode(common);
+
+        }
+}
+
+/*
+ * vpif_channel_isr: It changes status of the displayed buffer, takes next
+ * buffer from the queue and sets its address in VPIF registers
+ */
+static irqreturn_t vpif_channel_isr(int irq, void *dev_id)
+{
+        struct vpif_device *dev = &vpif_obj;
+        struct channel_obj *ch;
+        struct common_obj *common;
+        enum v4l2_field field;
+        int fid = -1, i;
+        int channel_id = 0;
+
+        channel_id = *(int *)(dev_id);
+        ch = dev->dev[channel_id];
+        field = ch->common[VPIF_VIDEO_INDEX].fmt.fmt.pix.field;
+        for (i = 0; i < VPIF_NUMOBJECTS; i++) {
+                common = &ch->common[i];
+                /* If streaming is started in this channel */
+                if (0 == common->started)
+                        continue;
+
+                if (1 == ch->vpifparams.std_info.frm_fmt) {
+                        if (list_empty(&common->dma_queue))
+                                continue;
+
+                        /* Progressive mode */
+                        if (!channel_first_int[i][channel_id]) {
+                                /* Mark status of the cur_frm to
+                                 * done and unlock semaphore on it */
+                                do_gettimeofday(&common->cur_frm->ts);
+                                common->cur_frm->state = VIDEOBUF_DONE;
+                                wake_up_interruptible(&common->cur_frm->done);
+                                /* Make cur_frm pointing to next_frm */
+                                common->cur_frm = common->next_frm;
+                        }
+
+                        channel_first_int[i][channel_id] = 0;
+                        process_progressive_mode(common);
+                } else {
+                        /* Interlaced mode */
+                        /* If it is first interrupt, ignore it */
+
+                        if (channel_first_int[i][channel_id]) {
+                                channel_first_int[i][channel_id] = 0;
+                                continue;
+                        }
+
+                        if (0 == i) {
+                                ch->field_id ^= 1;
+                                /* Get field id from VPIF registers */
+                                fid = vpif_channel_getfid(ch->channel_id + 2);
+                                /* If fid does not match with stored field id */
+                                if (fid != ch->field_id) {
+                                        /* Make them in sync */
+                                        if (0 == fid)
+                                                ch->field_id = fid;
+
+                                        return IRQ_HANDLED;
+                                }
+                        }
+                        process_interlaced_mode(fid, common);
+                }
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int vpif_get_std_info(struct channel_obj *ch)
+{
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        struct video_obj *vid_ch = &ch->video;
+        struct vpif_params *vpifparams = &ch->vpifparams;
+        struct vpif_channel_config_params *std_info = &vpifparams->std_info;
+        const struct vpif_channel_config_params *config;
+
+        int index;
+
+        std_info->stdid = vid_ch->stdid;
+        if (!std_info)
+                return -1;
+
+        for (index = 0; index < ARRAY_SIZE(ch_params); index++) {
+                config = &ch_params[index];
+                if (config->stdid & std_info->stdid) {
+                        memcpy(std_info, config, sizeof(*config));
+                        break;
+                }
+        }
+
+        if (index == ARRAY_SIZE(ch_params))
+                return -1;
+
+        common->fmt.fmt.pix.width = std_info->width;
+        common->fmt.fmt.pix.height = std_info->height;
+        vpif_dbg(1, debug, "Pixel details: Width = %d,Height = %d\n",
+                        common->fmt.fmt.pix.width, common->fmt.fmt.pix.height);
+
+        /* Set height and width paramateres */
+        ch->common[VPIF_VIDEO_INDEX].height = std_info->height;
+        ch->common[VPIF_VIDEO_INDEX].width = std_info->width;
+
+        return 0;
+}
+
+/*
+ * vpif_calculate_offsets: This function calculates buffers offset for Y and C
+ * in the top and bottom field
+ */
+static void vpif_calculate_offsets(struct channel_obj *ch)
+{
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        struct vpif_params *vpifparams = &ch->vpifparams;
+        enum v4l2_field field = common->fmt.fmt.pix.field;
+        struct video_obj *vid_ch = &ch->video;
+        unsigned int hpitch, vpitch, sizeimage;
+
+        if (V4L2_FIELD_ANY == common->fmt.fmt.pix.field) {
+                if (ch->vpifparams.std_info.frm_fmt)
+                        vid_ch->buf_field = V4L2_FIELD_NONE;
+                else
+                        vid_ch->buf_field = V4L2_FIELD_INTERLACED;
+        } else {
+                vid_ch->buf_field = common->fmt.fmt.pix.field;
+        }
+
+        if (V4L2_MEMORY_USERPTR == common->memory)
+                sizeimage = common->fmt.fmt.pix.sizeimage;
+        else
+                sizeimage = config_params.channel_bufsize[ch->channel_id];
+
+        hpitch = common->fmt.fmt.pix.bytesperline;
+        vpitch = sizeimage / (hpitch * 2);
+        if ((V4L2_FIELD_NONE == vid_ch->buf_field) ||
+            (V4L2_FIELD_INTERLACED == vid_ch->buf_field)) {
+                common->ytop_off = 0;
+                common->ybtm_off = hpitch;
+                common->ctop_off = sizeimage / 2;
+                common->cbtm_off = sizeimage / 2 + hpitch;
+        } else if (V4L2_FIELD_SEQ_TB == vid_ch->buf_field) {
+                common->ytop_off = 0;
+                common->ybtm_off = sizeimage / 4;
+                common->ctop_off = sizeimage / 2;
+                common->cbtm_off = common->ctop_off + sizeimage / 4;
+        } else if (V4L2_FIELD_SEQ_BT == vid_ch->buf_field) {
+                common->ybtm_off = 0;
+                common->ytop_off = sizeimage / 4;
+                common->cbtm_off = sizeimage / 2;
+                common->ctop_off = common->cbtm_off + sizeimage / 4;
+        }
+
+        if ((V4L2_FIELD_NONE == vid_ch->buf_field) ||
+            (V4L2_FIELD_INTERLACED == vid_ch->buf_field)) {
+                vpifparams->video_params.storage_mode = 1;
+        } else {
+                vpifparams->video_params.storage_mode = 0;
+        }
+
+        if (ch->vpifparams.std_info.frm_fmt == 1) {
+                vpifparams->video_params.hpitch =
+                    common->fmt.fmt.pix.bytesperline;
+        } else {
+                if ((field == V4L2_FIELD_ANY) ||
+                        (field == V4L2_FIELD_INTERLACED))
+                        vpifparams->video_params.hpitch =
+                            common->fmt.fmt.pix.bytesperline * 2;
+                else
+                        vpifparams->video_params.hpitch =
+                            common->fmt.fmt.pix.bytesperline;
+        }
+
+        ch->vpifparams.video_params.stdid = ch->vpifparams.std_info.stdid;
+}
+
+static void vpif_config_format(struct channel_obj *ch)
+{
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        common->fmt.fmt.pix.field = V4L2_FIELD_ANY;
+        if (config_params.numbuffers[ch->channel_id] == 0)
+                common->memory = V4L2_MEMORY_USERPTR;
+        else
+                common->memory = V4L2_MEMORY_MMAP;
+
+        common->fmt.fmt.pix.sizeimage =
+                        config_params.channel_bufsize[ch->channel_id];
+        common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P;
+        common->fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+}
+
+static int vpif_check_format(struct channel_obj *ch,
+                             struct v4l2_pix_format *pixfmt)
+{
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        enum v4l2_field field = pixfmt->field;
+        u32 sizeimage, hpitch, vpitch;
+
+        if (pixfmt->pixelformat != V4L2_PIX_FMT_YUV422P)
+                goto invalid_fmt_exit;
+
+        if (!(VPIF_VALID_FIELD(field)))
+                goto invalid_fmt_exit;
+
+        if (pixfmt->bytesperline <= 0)
+                goto invalid_pitch_exit;
+
+        if (V4L2_MEMORY_USERPTR == common->memory)
+                sizeimage = pixfmt->sizeimage;
+        else
+                sizeimage = config_params.channel_bufsize[ch->channel_id];
+
+        if (vpif_get_std_info(ch)) {
+                vpif_err("Error getting the standard info\n");
+                return -EINVAL;
+        }
+
+        hpitch = pixfmt->bytesperline;
+        vpitch = sizeimage / (hpitch * 2);
+
+        /* Check for valid value of pitch */
+        if ((hpitch < ch->vpifparams.std_info.width) ||
+            (vpitch < ch->vpifparams.std_info.height))
+                goto invalid_pitch_exit;
+
+        /* Check for 8 byte alignment */
+        if (!ISALIGNED(hpitch)) {
+                vpif_err("invalid pitch alignment\n");
+                return -EINVAL;
+        }
+        pixfmt->width = common->fmt.fmt.pix.width;
+        pixfmt->height = common->fmt.fmt.pix.height;
+
+        return 0;
+
+invalid_fmt_exit:
+        vpif_err("invalid field format\n");
+        return -EINVAL;
+
+invalid_pitch_exit:
+        vpif_err("invalid pitch\n");
+        return -EINVAL;
+}
+
+static void vpif_config_addr(struct channel_obj *ch, int muxmode)
+{
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        if (VPIF_CHANNEL3_VIDEO == ch->channel_id) {
+                common->set_addr = ch3_set_videobuf_addr;
+        } else {
+                if (2 == muxmode)
+                        common->set_addr = ch2_set_videobuf_addr_yc_nmux;
+                else
+                        common->set_addr = ch2_set_videobuf_addr;
+        }
+}
+
+/*
+ * vpif_mmap: It is used to map kernel space buffers into user spaces
+ */
+static int vpif_mmap(struct file *filep, struct vm_area_struct *vma)
+{
+        struct vpif_fh *fh = filep->private_data;
+        struct common_obj *common = &fh->channel->common[VPIF_VIDEO_INDEX];
+
+        return videobuf_mmap_mapper(&common->buffer_queue, vma);
+}
+
+/*
+ * vpif_poll: It is used for select/poll system call
+ */
+static unsigned int vpif_poll(struct file *filep, poll_table *wait)
+{
+        struct vpif_fh *fh = filep->private_data;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        if (common->started)
+                return videobuf_poll_stream(filep, &common->buffer_queue, wait);
+
+        return 0;
+}
+
+/*
+ * vpif_open: It creates object of file handle structure and stores it in
+ * private_data member of filepointer
+ */
+static int vpif_open(struct file *filep)
+{
+        struct video_device *vdev = video_devdata(filep);
+        struct channel_obj *ch = NULL;
+        struct vpif_fh *fh = NULL;
+
+        ch = video_get_drvdata(vdev);
+        /* Allocate memory for the file handle object */
+        fh = kmalloc(sizeof(struct vpif_fh), GFP_KERNEL);
+        if (fh == NULL) {
+                vpif_err("unable to allocate memory for file handle object\n");
+                return -ENOMEM;
+        }
+
+        /* store pointer to fh in private_data member of filep */
+        filep->private_data = fh;
+        fh->channel = ch;
+        fh->initialized = 0;
+        if (!ch->initialized) {
+                fh->initialized = 1;
+                ch->initialized = 1;
+                memset(&ch->vpifparams, 0, sizeof(ch->vpifparams));
+        }
+
+        /* Increment channel usrs counter */
+        atomic_inc(&ch->usrs);
+        /* Set io_allowed[VPIF_VIDEO_INDEX] member to false */
+        fh->io_allowed[VPIF_VIDEO_INDEX] = 0;
+        /* Initialize priority of this instance to default priority */
+        fh->prio = V4L2_PRIORITY_UNSET;
+        v4l2_prio_open(&ch->prio, &fh->prio);
+
+        return 0;
+}
+
+/*
+ * vpif_release: This function deletes buffer queue, frees the buffers and
+ * the vpif file handle
+ */
+static int vpif_release(struct file *filep)
+{
+        struct vpif_fh *fh = filep->private_data;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        /* if this instance is doing IO */
+        if (fh->io_allowed[VPIF_VIDEO_INDEX]) {
+                /* Reset io_usrs member of channel object */
+                common->io_usrs = 0;
+                /* Disable channel */
+                if (VPIF_CHANNEL2_VIDEO == ch->channel_id) {
+                        enable_channel2(0);
+                        channel2_intr_enable(0);
+                }
+                if ((VPIF_CHANNEL3_VIDEO == ch->channel_id) ||
+                    (2 == common->started)) {
+                        enable_channel3(0);
+                        channel3_intr_enable(0);
+                }
+                common->started = 0;
+                /* Free buffers allocated */
+                videobuf_queue_cancel(&common->buffer_queue);
+                videobuf_mmap_free(&common->buffer_queue);
+                common->numbuffers =
+                    config_params.numbuffers[ch->channel_id];
+        }
+
+        mutex_unlock(&common->lock);
+
+        /* Decrement channel usrs counter */
+        atomic_dec(&ch->usrs);
+        /* If this file handle has initialize encoder device, reset it */
+        if (fh->initialized)
+                ch->initialized = 0;
+
+        /* Close the priority */
+        v4l2_prio_close(&ch->prio, &fh->prio);
+        filep->private_data = NULL;
+        fh->initialized = 0;
+        kfree(fh);
+
+        return 0;
+}
+
+/* functions implementing ioctls */
+
+static int vpif_querycap(struct file *file, void  *priv,
+                                struct v4l2_capability *cap)
+{
+        struct vpif_display_config *config = vpif_dev->platform_data;
+
+        cap->version = VPIF_DISPLAY_VERSION_CODE;
+        cap->capabilities = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
+        strlcpy(cap->driver, "vpif display", sizeof(cap->driver));
+        strlcpy(cap->bus_info, "Platform", sizeof(cap->bus_info));
+        strlcpy(cap->card, config->card_name, sizeof(cap->card));
+
+        return 0;
+}
+
+static int vpif_enum_fmt_vid_out(struct file *file, void  *priv,
+                                        struct v4l2_fmtdesc *fmt)
+{
+        if (fmt->index != 0) {
+                vpif_err("Invalid format index\n");
+                return -EINVAL;
+        }
+
+        /* Fill in the information about format */
+        fmt->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+        strcpy(fmt->description, "YCbCr4:2:2 YC Planar");
+        fmt->pixelformat = V4L2_PIX_FMT_YUV422P;
+
+        return 0;
+}
+
+static int vpif_g_fmt_vid_out(struct file *file, void *priv,
+                                struct v4l2_format *fmt)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        /* Check the validity of the buffer type */
+        if (common->fmt.type != fmt->type)
+                return -EINVAL;
+
+        /* Fill in the information about format */
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        if (vpif_get_std_info(ch)) {
+                vpif_err("Error getting the standard info\n");
+                return -EINVAL;
+        }
+
+        *fmt = common->fmt;
+        mutex_unlock(&common->lock);
+        return 0;
+}
+
+static int vpif_s_fmt_vid_out(struct file *file, void *priv,
+                                struct v4l2_format *fmt)
+{
+        struct vpif_fh *fh = priv;
+        struct v4l2_pix_format *pixfmt;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        int ret = 0;
+
+        if ((VPIF_CHANNEL2_VIDEO == ch->channel_id)
+            || (VPIF_CHANNEL3_VIDEO == ch->channel_id)) {
+                if (!fh->initialized) {
+                        vpif_dbg(1, debug, "Channel Busy\n");
+                        return -EBUSY;
+                }
+
+                /* Check for the priority */
+                ret = v4l2_prio_check(&ch->prio, &fh->prio);
+                if (0 != ret)
+                        return ret;
+                fh->initialized = 1;
+        }
+
+        if (common->started) {
+                vpif_dbg(1, debug, "Streaming in progress\n");
+                return -EBUSY;
+        }
+
+        pixfmt = &fmt->fmt.pix;
+        /* Check for valid field format */
+        ret = vpif_check_format(ch, pixfmt);
+        if (ret)
+                return ret;
+
+        /* store the pix format in the channel object */
+        common->fmt.fmt.pix = *pixfmt;
+        /* store the format in the channel object */
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        common->fmt = *fmt;
+        mutex_unlock(&common->lock);
+
+        return 0;
+}
+
+static int vpif_try_fmt_vid_out(struct file *file, void *priv,
+                                struct v4l2_format *fmt)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
+        int ret = 0;
+
+        ret = vpif_check_format(ch, pixfmt);
+        if (ret) {
+                *pixfmt = common->fmt.fmt.pix;
+                pixfmt->sizeimage = pixfmt->width * pixfmt->height * 2;
+        }
+
+        return ret;
+}
+
+static int vpif_reqbufs(struct file *file, void *priv,
+                        struct v4l2_requestbuffers *reqbuf)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common;
+        enum v4l2_field field;
+        u8 index = 0;
+        int ret = 0;
+
+        /* This file handle has not initialized the channel,
+           It is not allowed to do settings */
+        if ((VPIF_CHANNEL2_VIDEO == ch->channel_id)
+            || (VPIF_CHANNEL3_VIDEO == ch->channel_id)) {
+                if (!fh->initialized) {
+                        vpif_err("Channel Busy\n");
+                        return -EBUSY;
+                }
+        }
+
+        if (V4L2_BUF_TYPE_VIDEO_OUTPUT != reqbuf->type)
+                return -EINVAL;
+
+        index = VPIF_VIDEO_INDEX;
+
+        common = &ch->common[index];
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        if (common->fmt.type != reqbuf->type) {
+                ret = -EINVAL;
+                goto reqbuf_exit;
+        }
+
+        if (0 != common->io_usrs) {
+                ret = -EBUSY;
+                goto reqbuf_exit;
+        }
+
+        if (reqbuf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
+                if (common->fmt.fmt.pix.field == V4L2_FIELD_ANY)
+                        field = V4L2_FIELD_INTERLACED;
+                else
+                        field = common->fmt.fmt.pix.field;
+        } else {
+                field = V4L2_VBI_INTERLACED;
+        }
+
+        /* Initialize videobuf queue as per the buffer type */
+        videobuf_queue_dma_contig_init(&common->buffer_queue,
+                                            &video_qops, NULL,
+                                            &common->irqlock,
+                                            reqbuf->type, field,
+                                            sizeof(struct videobuf_buffer), fh);
+
+        /* Set io allowed member of file handle to TRUE */
+        fh->io_allowed[index] = 1;
+        /* Increment io usrs member of channel object to 1 */
+        common->io_usrs = 1;
+        /* Store type of memory requested in channel object */
+        common->memory = reqbuf->memory;
+        INIT_LIST_HEAD(&common->dma_queue);
+
+        /* Allocate buffers */
+        ret = videobuf_reqbufs(&common->buffer_queue, reqbuf);
+
+reqbuf_exit:
+        mutex_unlock(&common->lock);
+        return ret;
+}
+
+static int vpif_querybuf(struct file *file, void *priv,
+                                struct v4l2_buffer *tbuf)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        if (common->fmt.type != tbuf->type)
+                return -EINVAL;
+
+        return videobuf_querybuf(&common->buffer_queue, tbuf);
+}
+
+static int vpif_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
+{
+
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        struct v4l2_buffer tbuf = *buf;
+        struct videobuf_buffer *buf1;
+        unsigned long addr = 0;
+        unsigned long flags;
+        int ret = 0;
+
+        if (common->fmt.type != tbuf.type)
+                return -EINVAL;
+
+        if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
+                vpif_err("fh->io_allowed\n");
+                return -EACCES;
+        }
+
+        if (!(list_empty(&common->dma_queue)) ||
+            (common->cur_frm != common->next_frm) ||
+            !(common->started) ||
+            (common->started && (0 == ch->field_id)))
+                return videobuf_qbuf(&common->buffer_queue, buf);
+
+        /* bufferqueue is empty store buffer address in VPIF registers */
+        mutex_lock(&common->buffer_queue.vb_lock);
+        buf1 = common->buffer_queue.bufs[tbuf.index];
+        if (buf1->memory != tbuf.memory) {
+                vpif_err("invalid buffer type\n");
+                goto qbuf_exit;
+        }
+
+        if ((buf1->state == VIDEOBUF_QUEUED) ||
+            (buf1->state == VIDEOBUF_ACTIVE)) {
+                vpif_err("invalid state\n");
+                goto qbuf_exit;
+        }
+
+        switch (buf1->memory) {
+        case V4L2_MEMORY_MMAP:
+                if (buf1->baddr == 0)
+                        goto qbuf_exit;
+                break;
+
+        case V4L2_MEMORY_USERPTR:
+                if (tbuf.length < buf1->bsize)
+                        goto qbuf_exit;
+
+                if ((VIDEOBUF_NEEDS_INIT != buf1->state)
+                            && (buf1->baddr != tbuf.m.userptr))
+                        vpif_buffer_release(&common->buffer_queue, buf1);
+                        buf1->baddr = tbuf.m.userptr;
+                break;
+
+        default:
+                goto qbuf_exit;
+        }
+
+        local_irq_save(flags);
+        ret = vpif_buffer_prepare(&common->buffer_queue, buf1,
+                                        common->buffer_queue.field);
+        if (ret < 0) {
+                local_irq_restore(flags);
+                goto qbuf_exit;
+        }
+
+        buf1->state = VIDEOBUF_ACTIVE;
+        addr = buf1->boff;
+        common->next_frm = buf1;
+        if (tbuf.type != V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
+                common->set_addr((addr + common->ytop_off),
+                                 (addr + common->ybtm_off),
+                                 (addr + common->ctop_off),
+                                 (addr + common->cbtm_off));
+        }
+
+        local_irq_restore(flags);
+        list_add_tail(&buf1->stream, &common->buffer_queue.stream);
+        mutex_unlock(&common->buffer_queue.vb_lock);
+        return 0;
+
+qbuf_exit:
+        mutex_unlock(&common->buffer_queue.vb_lock);
+        return -EINVAL;
+}
+
+static int vpif_s_std(struct file *file, void *priv, v4l2_std_id *std_id)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        int ret = 0;
+
+        if (!(*std_id & DM646X_V4L2_STD))
+                return -EINVAL;
+
+        if (common->started) {
+                vpif_err("streaming in progress\n");
+                return -EBUSY;
+        }
+
+        /* Call encoder subdevice function to set the standard */
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        ch->video.stdid = *std_id;
+        /* Get the information about the standard */
+        if (vpif_get_std_info(ch)) {
+                vpif_err("Error getting the standard info\n");
+                return -EINVAL;
+        }
+
+        if ((ch->vpifparams.std_info.width *
+                ch->vpifparams.std_info.height * 2) >
+                config_params.channel_bufsize[ch->channel_id]) {
+                vpif_err("invalid std for this size\n");
+                ret = -EINVAL;
+                goto s_std_exit;
+        }
+
+        common->fmt.fmt.pix.bytesperline = common->fmt.fmt.pix.width;
+        /* Configure the default format information */
+        vpif_config_format(ch);
+
+        ret = v4l2_device_call_until_err(&vpif_obj.v4l2_dev, 1, video,
+                                                s_std_output, *std_id);
+        if (ret < 0) {
+                vpif_err("Failed to set output standard\n");
+                goto s_std_exit;
+        }
+
+        ret = v4l2_device_call_until_err(&vpif_obj.v4l2_dev, 1, core,
+                                                        s_std, *std_id);
+        if (ret < 0)
+                vpif_err("Failed to set standard for sub devices\n");
+
+s_std_exit:
+        mutex_unlock(&common->lock);
+        return ret;
+}
+
+static int vpif_g_std(struct file *file, void *priv, v4l2_std_id *std)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+
+        *std = ch->video.stdid;
+        return 0;
+}
+
+static int vpif_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        return videobuf_dqbuf(&common->buffer_queue, p,
+                                        (file->f_flags & O_NONBLOCK));
+}
+
+static int vpif_streamon(struct file *file, void *priv,
+                                enum v4l2_buf_type buftype)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        struct channel_obj *oth_ch = vpif_obj.dev[!ch->channel_id];
+        struct vpif_params *vpif = &ch->vpifparams;
+        struct vpif_display_config *vpif_config_data =
+                                        vpif_dev->platform_data;
+        unsigned long addr = 0;
+        int ret = 0;
+
+        if (buftype != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
+                vpif_err("buffer type not supported\n");
+                return -EINVAL;
+        }
+
+        if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
+                vpif_err("fh->io_allowed\n");
+                return -EACCES;
+        }
+
+        /* If Streaming is already started, return error */
+        if (common->started) {
+                vpif_err("channel->started\n");
+                return -EBUSY;
+        }
+
+        if ((ch->channel_id == VPIF_CHANNEL2_VIDEO
+                && oth_ch->common[VPIF_VIDEO_INDEX].started &&
+                ch->vpifparams.std_info.ycmux_mode == 0)
+                || ((ch->channel_id == VPIF_CHANNEL3_VIDEO)
+                && (2 == oth_ch->common[VPIF_VIDEO_INDEX].started))) {
+                vpif_err("other channel is using\n");
+                return -EBUSY;
+        }
+
+        ret = vpif_check_format(ch, &common->fmt.fmt.pix);
+        if (ret < 0)
+                return ret;
+
+        /* Call videobuf_streamon to start streaming  in videobuf */
+        ret = videobuf_streamon(&common->buffer_queue);
+        if (ret < 0) {
+                vpif_err("videobuf_streamon\n");
+                return ret;
+        }
+
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        /* If buffer queue is empty, return error */
+        if (list_empty(&common->dma_queue)) {
+                vpif_err("buffer queue is empty\n");
+                ret = -EIO;
+                goto streamon_exit;
+        }
+
+        /* Get the next frame from the buffer queue */
+        common->next_frm = common->cur_frm =
+                            list_entry(common->dma_queue.next,
+                                       struct videobuf_buffer, queue);
+
+        list_del(&common->cur_frm->queue);
+        /* Mark state of the current frame to active */
+        common->cur_frm->state = VIDEOBUF_ACTIVE;
+
+        /* Initialize field_id and started member */
+        ch->field_id = 0;
+        common->started = 1;
+        if (buftype == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
+                addr = common->cur_frm->boff;
+                /* Calculate the offset for Y and C data  in the buffer */
+                vpif_calculate_offsets(ch);
+
+                if ((ch->vpifparams.std_info.frm_fmt &&
+                        ((common->fmt.fmt.pix.field != V4L2_FIELD_NONE)
+                        && (common->fmt.fmt.pix.field != V4L2_FIELD_ANY)))
+                        || (!ch->vpifparams.std_info.frm_fmt
+                        && (common->fmt.fmt.pix.field == V4L2_FIELD_NONE))) {
+                        vpif_err("conflict in field format and std format\n");
+                        ret = -EINVAL;
+                        goto streamon_exit;
+                }
+
+                /* clock settings */
+                ret =
+                 vpif_config_data->set_clock(ch->vpifparams.std_info.ycmux_mode,
+                                                ch->vpifparams.std_info.hd_sd);
+                if (ret < 0) {
+                        vpif_err("can't set clock\n");
+                        goto streamon_exit;
+                }
+
+                /* set the parameters and addresses */
+                ret = vpif_set_video_params(vpif, ch->channel_id + 2);
+                if (ret < 0)
+                        goto streamon_exit;
+
+                common->started = ret;
+                vpif_config_addr(ch, ret);
+                common->set_addr((addr + common->ytop_off),
+                                 (addr + common->ybtm_off),
+                                 (addr + common->ctop_off),
+                                 (addr + common->cbtm_off));
+
+                /* Set interrupt for both the fields in VPIF
+                   Register enable channel in VPIF register */
+                if (VPIF_CHANNEL2_VIDEO == ch->channel_id) {
+                        channel2_intr_assert();
+                        channel2_intr_enable(1);
+                        enable_channel2(1);
+                }
+
+                if ((VPIF_CHANNEL3_VIDEO == ch->channel_id)
+                        || (common->started == 2)) {
+                        channel3_intr_assert();
+                        channel3_intr_enable(1);
+                        enable_channel3(1);
+                }
+                channel_first_int[VPIF_VIDEO_INDEX][ch->channel_id] = 1;
+        }
+
+streamon_exit:
+        mutex_unlock(&common->lock);
+        return ret;
+}
+
+static int vpif_streamoff(struct file *file, void *priv,
+                                enum v4l2_buf_type buftype)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+
+        if (buftype != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
+                vpif_err("buffer type not supported\n");
+                return -EINVAL;
+        }
+
+        if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
+                vpif_err("fh->io_allowed\n");
+                return -EACCES;
+        }
+
+        if (!common->started) {
+                vpif_err("channel->started\n");
+                return -EINVAL;
+        }
+
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        if (buftype == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
+                /* disable channel */
+                if (VPIF_CHANNEL2_VIDEO == ch->channel_id) {
+                        enable_channel2(0);
+                        channel2_intr_enable(0);
+                }
+                if ((VPIF_CHANNEL3_VIDEO == ch->channel_id) ||
+                                        (2 == common->started)) {
+                        enable_channel3(0);
+                        channel3_intr_enable(0);
+                }
+        }
+
+        common->started = 0;
+        mutex_unlock(&common->lock);
+
+        return videobuf_streamoff(&common->buffer_queue);
+}
+
+static int vpif_cropcap(struct file *file, void *priv,
+                        struct v4l2_cropcap *crop)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        if (V4L2_BUF_TYPE_VIDEO_OUTPUT != crop->type)
+                return -EINVAL;
+
+        crop->bounds.left = crop->bounds.top = 0;
+        crop->defrect.left = crop->defrect.top = 0;
+        crop->defrect.height = crop->bounds.height = common->height;
+        crop->defrect.width = crop->bounds.width = common->width;
+
+        return 0;
+}
+
+static int vpif_enum_output(struct file *file, void *fh,
+                                struct v4l2_output *output)
+{
+
+        struct vpif_display_config *config = vpif_dev->platform_data;
+
+        if (output->index >= config->output_count) {
+                vpif_dbg(1, debug, "Invalid output index\n");
+                return -EINVAL;
+        }
+
+        strcpy(output->name, config->output[output->index]);
+        output->type = V4L2_OUTPUT_TYPE_ANALOG;
+        output->std = DM646X_V4L2_STD;
+
+        return 0;
+}
+
+static int vpif_s_output(struct file *file, void *priv, unsigned int i)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct video_obj *vid_ch = &ch->video;
+        struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
+        int ret = 0;
+
+        if (mutex_lock_interruptible(&common->lock))
+                return -ERESTARTSYS;
+
+        if (common->started) {
+                vpif_err("Streaming in progress\n");
+                ret = -EBUSY;
+                goto s_output_exit;
+        }
+
+        ret = v4l2_device_call_until_err(&vpif_obj.v4l2_dev, 1, video,
+                                                        s_routing, 0, i, 0);
+
+        if (ret < 0)
+                vpif_err("Failed to set output standard\n");
+
+        vid_ch->output_id = i;
+
+s_output_exit:
+        mutex_unlock(&common->lock);
+        return ret;
+}
+
+static int vpif_g_output(struct file *file, void *priv, unsigned int *i)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+        struct video_obj *vid_ch = &ch->video;
+
+        *i = vid_ch->output_id;
+
+        return 0;
+}
+
+static int vpif_g_priority(struct file *file, void *priv, enum v4l2_priority *p)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+
+        *p = v4l2_prio_max(&ch->prio);
+
+        return 0;
+}
+
+static int vpif_s_priority(struct file *file, void *priv, enum v4l2_priority p)
+{
+        struct vpif_fh *fh = priv;
+        struct channel_obj *ch = fh->channel;
+
+        return v4l2_prio_change(&ch->prio, &fh->prio, p);
+}
+
+/* vpif display ioctl operations */
+static const struct v4l2_ioctl_ops vpif_ioctl_ops = {
+        .vidioc_querycap                = vpif_querycap,
+        .vidioc_g_priority              = vpif_g_priority,
+        .vidioc_s_priority              = vpif_s_priority,
+        .vidioc_enum_fmt_vid_out        = vpif_enum_fmt_vid_out,
+        .vidioc_g_fmt_vid_out           = vpif_g_fmt_vid_out,
+        .vidioc_s_fmt_vid_out           = vpif_s_fmt_vid_out,
+        .vidioc_try_fmt_vid_out         = vpif_try_fmt_vid_out,
+        .vidioc_reqbufs                 = vpif_reqbufs,
+        .vidioc_querybuf                = vpif_querybuf,
+        .vidioc_qbuf                    = vpif_qbuf,
+        .vidioc_dqbuf                   = vpif_dqbuf,
+        .vidioc_streamon                = vpif_streamon,
+        .vidioc_streamoff               = vpif_streamoff,
+        .vidioc_s_std                   = vpif_s_std,
+        .vidioc_g_std                   = vpif_g_std,
+        .vidioc_enum_output             = vpif_enum_output,
+        .vidioc_s_output                = vpif_s_output,
+        .vidioc_g_output                = vpif_g_output,
+        .vidioc_cropcap                 = vpif_cropcap,
+};
+
+static const struct v4l2_file_operations vpif_fops = {
+        .owner          = THIS_MODULE,
+        .open           = vpif_open,
+        .release        = vpif_release,
+        .ioctl          = video_ioctl2,
+        .mmap           = vpif_mmap,
+        .poll           = vpif_poll
+};
+
+static struct video_device vpif_video_template = {
+        .name           = "vpif",
+        .fops           = &vpif_fops,
+        .minor          = -1,
+        .ioctl_ops      = &vpif_ioctl_ops,
+        .tvnorms        = DM646X_V4L2_STD,
+        .current_norm   = V4L2_STD_625_50,
+
+};
+
+/*Configure the channels, buffer sizei, request irq */
+static int initialize_vpif(void)
+{
+        int free_channel_objects_index;
+        int free_buffer_channel_index;
+        int free_buffer_index;
+        int err = 0, i, j;
+
+        /* Default number of buffers should be 3 */
+        if ((ch2_numbuffers > 0) &&
+            (ch2_numbuffers < config_params.min_numbuffers))
+                ch2_numbuffers = config_params.min_numbuffers;
+        if ((ch3_numbuffers > 0) &&
+            (ch3_numbuffers < config_params.min_numbuffers))
+                ch3_numbuffers = config_params.min_numbuffers;
+
+        /* Set buffer size to min buffers size if invalid buffer size is
+         * given */
+        if (ch2_bufsize < config_params.min_bufsize[VPIF_CHANNEL2_VIDEO])
+                ch2_bufsize =
+                    config_params.min_bufsize[VPIF_CHANNEL2_VIDEO];
+        if (ch3_bufsize < config_params.min_bufsize[VPIF_CHANNEL3_VIDEO])
+                ch3_bufsize =
+                    config_params.min_bufsize[VPIF_CHANNEL3_VIDEO];
+
+        config_params.numbuffers[VPIF_CHANNEL2_VIDEO] = ch2_numbuffers;
+
+        if (ch2_numbuffers) {
+                config_params.channel_bufsize[VPIF_CHANNEL2_VIDEO] =
+                                                        ch2_bufsize;
+        }
+        config_params.numbuffers[VPIF_CHANNEL3_VIDEO] = ch3_numbuffers;
+
+        if (ch3_numbuffers) {
+                config_params.channel_bufsize[VPIF_CHANNEL3_VIDEO] =
+                                                        ch3_bufsize;
+        }
+
+        /* Allocate memory for six channel objects */
+        for (i = 0; i < VPIF_DISPLAY_MAX_DEVICES; i++) {
+                vpif_obj.dev[i] =
+                    kmalloc(sizeof(struct channel_obj), GFP_KERNEL);
+                /* If memory allocation fails, return error */
+                if (!vpif_obj.dev[i]) {
+                        free_channel_objects_index = i;
+                        err = -ENOMEM;
+                        goto vpif_init_free_channel_objects;
+                }
+        }
+
+        free_channel_objects_index = VPIF_DISPLAY_MAX_DEVICES;
+        free_buffer_channel_index = VPIF_DISPLAY_NUM_CHANNELS;
+        free_buffer_index = config_params.numbuffers[i - 1];
+
+        return 0;
+
+vpif_init_free_channel_objects:
+        for (j = 0; j < free_channel_objects_index; j++)
+                kfree(vpif_obj.dev[j]);
+        return err;
+}
+
+/*
+ * vpif_probe: This function creates device entries by register itself to the
+ * V4L2 driver and initializes fields of each channel objects
+ */
+static __init int vpif_probe(struct platform_device *pdev)
+{
+        struct vpif_subdev_info *subdevdata;
+        struct vpif_display_config *config;
+        int i, j = 0, k, q, m, err = 0;
+        struct i2c_adapter *i2c_adap;
+        struct vpif_config *config;
+        struct common_obj *common;
+        struct channel_obj *ch;
+        struct video_device *vfd;
+        struct resource *res;
+        int subdev_count;
+
+        vpif_dev = &pdev->dev;
+
+        err = initialize_vpif();
+
+        if (err) {
+                v4l2_err(vpif_dev->driver, "Error initializing vpif\n");
+                return err;
+        }
+
+        err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev);
+        if (err) {
+                v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n");
+                return err;
+        }
+
+        k = 0;
+        while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, k))) {
+                for (i = res->start; i <= res->end; i++) {
+                        if (request_irq(i, vpif_channel_isr, IRQF_DISABLED,
+                                        "DM646x_Display",
+                                (void *)(&vpif_obj.dev[k]->channel_id))) {
+                                err = -EBUSY;
+                                goto vpif_int_err;
+                        }
+                }
+                k++;
+        }
+
+        for (i = 0; i < VPIF_DISPLAY_MAX_DEVICES; i++) {
+
+                /* Get the pointer to the channel object */
+                ch = vpif_obj.dev[i];
+
+                /* Allocate memory for video device */
+                vfd = video_device_alloc();
+                if (vfd == NULL) {
+                        for (j = 0; j < i; j++) {
+                                ch = vpif_obj.dev[j];
+                                video_device_release(ch->video_dev);
+                        }
+                        err = -ENOMEM;
+                        goto vpif_int_err;
+                }
+
+                /* Initialize field of video device */
+                *vfd = vpif_video_template;
+                vfd->v4l2_dev = &vpif_obj.v4l2_dev;
+                vfd->release = video_device_release;
+                snprintf(vfd->name, sizeof(vfd->name),
+                         "DM646x_VPIFDisplay_DRIVER_V%d.%d.%d",
+                         (VPIF_DISPLAY_VERSION_CODE >> 16) & 0xff,
+                         (VPIF_DISPLAY_VERSION_CODE >> 8) & 0xff,
+                         (VPIF_DISPLAY_VERSION_CODE) & 0xff);
+
+                /* Set video_dev to the video device */
+                ch->video_dev = vfd;
+        }
+
+        for (j = 0; j < VPIF_DISPLAY_MAX_DEVICES; j++) {
+                ch = vpif_obj.dev[j];
+                /* Initialize field of the channel objects */
+                atomic_set(&ch->usrs, 0);
+                for (k = 0; k < VPIF_NUMOBJECTS; k++) {
+                        ch->common[k].numbuffers = 0;
+                        common = &ch->common[k];
+                        common->io_usrs = 0;
+                        common->started = 0;
+                        spin_lock_init(&common->irqlock);
+                        mutex_init(&common->lock);
+                        common->numbuffers = 0;
+                        common->set_addr = NULL;
+                        common->ytop_off = common->ybtm_off = 0;
+                        common->ctop_off = common->cbtm_off = 0;
+                        common->cur_frm = common->next_frm = NULL;
+                        memset(&common->fmt, 0, sizeof(common->fmt));
+                        common->numbuffers = config_params.numbuffers[k];
+
+                }
+                ch->initialized = 0;
+                ch->channel_id = j;
+                if (j < 2)
+                        ch->common[VPIF_VIDEO_INDEX].numbuffers =
+                            config_params.numbuffers[ch->channel_id];
+                else
+                        ch->common[VPIF_VIDEO_INDEX].numbuffers = 0;
+
+                memset(&ch->vpifparams, 0, sizeof(ch->vpifparams));
+
+                /* Initialize prio member of channel object */
+                v4l2_prio_init(&ch->prio);
+                ch->common[VPIF_VIDEO_INDEX].fmt.type =
+                                                V4L2_BUF_TYPE_VIDEO_OUTPUT;
+
+                /* register video device */
+                vpif_dbg(1, debug, "channel=%x,channel->video_dev=%x\n",
+                                (int)ch, (int)&ch->video_dev);
+
+                err = video_register_device(ch->video_dev,
+                                          VFL_TYPE_GRABBER, (j ? 3 : 2));
+                if (err < 0)
+                        goto probe_out;
+
+                video_set_drvdata(ch->video_dev, ch);
+        }
+
+        i2c_adap = i2c_get_adapter(1);
+        config = pdev->dev.platform_data;
+        subdev_count = config->subdev_count;
+        subdevdata = config->subdevinfo;
+        vpif_obj.sd = kmalloc(sizeof(struct v4l2_subdev *) * subdev_count,
+                                                                GFP_KERNEL);
+        if (vpif_obj.sd == NULL) {
+                vpif_err("unable to allocate memory for subdevice pointers\n");
+                err = -ENOMEM;
+                goto probe_out;
+        }
+
+        for (i = 0; i < subdev_count; i++) {
+                vpif_obj.sd[i] = v4l2_i2c_new_subdev_board(&vpif_obj.v4l2_dev,
+                                                i2c_adap, subdevdata[i].name,
+                                                &subdevdata[i].board_info,
+                                                NULL);
+                if (!vpif_obj.sd[i]) {
+                        vpif_err("Error registering v4l2 subdevice\n");
+                        goto probe_subdev_out;
+                }
+
+                if (vpif_obj.sd[i])
+                        vpif_obj.sd[i]->grp_id = 1 << i;
+        }
+
+        return 0;
+
+probe_subdev_out:
+        kfree(vpif_obj.sd);
+probe_out:
+        for (k = 0; k < j; k++) {
+                ch = vpif_obj.dev[k];
+                video_unregister_device(ch->video_dev);
+                video_device_release(ch->video_dev);
+                ch->video_dev = NULL;
+        }
+vpif_int_err:
+        v4l2_device_unregister(&vpif_obj.v4l2_dev);
+        vpif_err("VPIF IRQ request failed\n");
+        for (q = k; k >= 0; k--) {
+                for (m = i; m >= res->start; m--)
+                        free_irq(m, (void *)(&vpif_obj.dev[k]->channel_id));
+                res = platform_get_resource(pdev, IORESOURCE_IRQ, k-1);
+                m = res->end;
+        }
+
+        return err;
+}
+
+/*
+ * vpif_remove: It un-register channels from V4L2 driver
+ */
+static int vpif_remove(struct platform_device *device)
+{
+        struct channel_obj *ch;
+        int i;
+
+        v4l2_device_unregister(&vpif_obj.v4l2_dev);
+
+        /* un-register device */
+        for (i = 0; i < VPIF_DISPLAY_MAX_DEVICES; i++) {
+                /* Get the pointer to the channel object */
+                ch = vpif_obj.dev[i];
+                /* Unregister video device */
+                video_unregister_device(ch->video_dev);
+
+                ch->video_dev = NULL;
+        }
+
+        return 0;
+}
+
+static struct platform_driver vpif_driver = {
+        .driver = {
+                        .name   = "vpif_display",
+                        .owner  = THIS_MODULE,
+        },
+        .probe  = vpif_probe,
+        .remove = vpif_remove,
+};
+
+static __init int vpif_init(void)
+{
+        return platform_driver_register(&vpif_driver);
+}
+
+/*
+ * vpif_cleanup: This function un-registers device and driver to the kernel,
+ * frees requested irq handler and de-allocates memory allocated for channel
+ * objects.
+ */
+static void vpif_cleanup(void)
+{
+        struct platform_device *pdev;
+        struct resource *res;
+        int irq_num;
+        int i = 0;
+
+        pdev = container_of(vpif_dev, struct platform_device, dev);
+
+        while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, i))) {
+                for (irq_num = res->start; irq_num <= res->end; irq_num++)
+                        free_irq(irq_num,
+                                 (void *)(&vpif_obj.dev[i]->channel_id));
+                i++;
+        }
+
+        platform_driver_unregister(&vpif_driver);
+        kfree(vpif_obj.sd);
+        for (i = 0; i < VPIF_DISPLAY_MAX_DEVICES; i++)
+                kfree(vpif_obj.dev[i]);
+}
+
+module_init(vpif_init);
+module_exit(vpif_cleanup);
diff --git a/drivers/media/video/davinci/vpif_display.h b/drivers/media/video/davinci/vpif_display.h
new file mode 100644
index 000000000000..a2a7cd166bbf
--- /dev/null
+++ b/drivers/media/video/davinci/vpif_display.h
@@ -0,0 +1,175 @@
+/*
+ * DM646x display header file
+ *
+ * Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.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 version 2.
+ *
+ * This program is distributed .as is. WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef DAVINCIHD_DISPLAY_H
+#define DAVINCIHD_DISPLAY_H
+
+/* Header files */
+#include <linux/videodev2.h>
+#include <linux/version.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-device.h>
+#include <media/videobuf-core.h>
+#include <media/videobuf-dma-contig.h>
+
+#include "vpif.h"
+
+/* Macros */
+#define VPIF_MAJOR_RELEASE      (0)
+#define VPIF_MINOR_RELEASE      (0)
+#define VPIF_BUILD              (1)
+
+#define VPIF_DISPLAY_VERSION_CODE \
+        ((VPIF_MAJOR_RELEASE << 16) | (VPIF_MINOR_RELEASE << 8) | VPIF_BUILD)
+
+#define VPIF_VALID_FIELD(field) \
+        (((V4L2_FIELD_ANY == field) || (V4L2_FIELD_NONE == field)) || \
+        (((V4L2_FIELD_INTERLACED == field) || (V4L2_FIELD_SEQ_TB == field)) || \
+        (V4L2_FIELD_SEQ_BT == field)))
+
+#define VPIF_DISPLAY_MAX_DEVICES        (2)
+#define VPIF_SLICED_BUF_SIZE            (256)
+#define VPIF_SLICED_MAX_SERVICES        (3)
+#define VPIF_VIDEO_INDEX                (0)
+#define VPIF_VBI_INDEX                  (1)
+#define VPIF_HBI_INDEX                  (2)
+
+/* Setting it to 1 as HBI/VBI support yet to be added , else 3*/
+#define VPIF_NUMOBJECTS (1)
+
+/* Macros */
+#define ISALIGNED(a)    (0 == ((a) & 7))
+
+/* enumerated data types */
+/* Enumerated data type to give id to each device per channel */
+enum vpif_channel_id {
+        VPIF_CHANNEL2_VIDEO = 0,        /* Channel2 Video */
+        VPIF_CHANNEL3_VIDEO,            /* Channel3 Video */
+};
+
+/* structures */
+
+struct video_obj {
+        enum v4l2_field buf_field;
+        u32 latest_only;                /* indicate whether to return
+                                         * most recent displayed frame only */
+        v4l2_std_id stdid;              /* Currently selected or default
+                                         * standard */
+        u32 output_id;                  /* Current output id */
+};
+
+struct vbi_obj {
+        int num_services;
+        struct vpif_vbi_params vbiparams;       /* vpif parameters for the raw
+                                                 * vbi data */
+};
+
+struct common_obj {
+        /* Buffer specific parameters */
+        u8 *fbuffers[VIDEO_MAX_FRAME];          /* List of buffer pointers for
+                                                 * storing frames */
+        u32 numbuffers;                         /* number of buffers */
+        struct videobuf_buffer *cur_frm;        /* Pointer pointing to current
+                                                 * videobuf_buffer */
+        struct videobuf_buffer *next_frm;       /* Pointer pointing to next
+                                                 * videobuf_buffer */
+        enum v4l2_memory memory;                /* This field keeps track of
+                                                 * type of buffer exchange
+                                                 * method user has selected */
+        struct v4l2_format fmt;                 /* Used to store the format */
+        struct videobuf_queue buffer_queue;     /* Buffer queue used in
+                                                 * video-buf */
+        struct list_head dma_queue;             /* Queue of filled frames */
+        spinlock_t irqlock;                     /* Used in video-buf */
+
+        /* channel specific parameters */
+        struct mutex lock;                      /* lock used to access this
+                                                 * structure */
+        u32 io_usrs;                            /* number of users performing
+                                                 * IO */
+        u8 started;                             /* Indicates whether streaming
+                                                 * started */
+        u32 ytop_off;                           /* offset of Y top from the
+                                                 * starting of the buffer */
+        u32 ybtm_off;                           /* offset of Y bottom from the
+                                                 * starting of the buffer */
+        u32 ctop_off;                           /* offset of C top from the
+                                                 * starting of the buffer */
+        u32 cbtm_off;                           /* offset of C bottom from the
+                                                 * starting of the buffer */
+        /* Function pointer to set the addresses */
+        void (*set_addr) (unsigned long, unsigned long,
+                                unsigned long, unsigned long);
+        u32 height;
+        u32 width;
+};
+
+struct channel_obj {
+        /* V4l2 specific parameters */
+        struct video_device *video_dev; /* Identifies video device for
+                                         * this channel */
+        struct v4l2_prio_state prio;    /* Used to keep track of state of
+                                         * the priority */
+        atomic_t usrs;                  /* number of open instances of
+                                         * the channel */
+        u32 field_id;                   /* Indicates id of the field
+                                         * which is being displayed */
+        u8 initialized;                 /* flag to indicate whether
+                                         * encoder is initialized */
+
+        enum vpif_channel_id channel_id;/* Identifies channel */
+        struct vpif_params vpifparams;
+        struct common_obj common[VPIF_NUMOBJECTS];
+        struct video_obj video;
+        struct vbi_obj vbi;
+};
+
+/* File handle structure */
+struct vpif_fh {
+        struct channel_obj *channel;    /* pointer to channel object for
+                                         * opened device */
+        u8 io_allowed[VPIF_NUMOBJECTS]; /* Indicates whether this file handle
+                                         * is doing IO */
+        enum v4l2_priority prio;        /* Used to keep track priority of
+                                         * this instance */
+        u8 initialized;                 /* Used to keep track of whether this
+                                         * file handle has initialized
+                                         * channel or not */
+};
+
+/* vpif device structure */
+struct vpif_device {
+        struct v4l2_device v4l2_dev;
+        struct channel_obj *dev[VPIF_DISPLAY_NUM_CHANNELS];
+        struct v4l2_subdev **sd;
+
+};
+
+struct vpif_config_params {
+        u32 min_bufsize[VPIF_DISPLAY_NUM_CHANNELS];
+        u32 channel_bufsize[VPIF_DISPLAY_NUM_CHANNELS];
+        u8 numbuffers[VPIF_DISPLAY_NUM_CHANNELS];
+        u8 min_numbuffers;
+};
+
+/* Struct which keeps track of the line numbers for the sliced vbi service */
+struct vpif_service_line {
+        u16 service_id;
+        u16 service_line[2];
+        u16 enc_service_id;
+        u8 bytestowrite;
+};
+
+#endif                          /* DAVINCIHD_DISPLAY_H */
diff --git a/drivers/media/video/davinci/vpss.c b/drivers/media/video/davinci/vpss.c
new file mode 100644
index 000000000000..6d709ca8cfb0
--- /dev/null
+++ b/drivers/media/video/davinci/vpss.c
@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2009 Texas Instruments.
+ *
+ * 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.
+ *
+ * common vpss driver for all video drivers.
+ */
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/compiler.h>
+#include <linux/io.h>
+#include <mach/hardware.h>
+#include <media/davinci/vpss.h>
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("VPSS Driver");
+MODULE_AUTHOR("Texas Instruments");
+
+/* DM644x defines */
+#define DM644X_SBL_PCR_VPSS             (4)
+
+/* vpss BL register offsets */
+#define DM355_VPSSBL_CCDCMUX            0x1c
+/* vpss CLK register offsets */
+#define DM355_VPSSCLK_CLKCTRL           0x04
+/* masks and shifts */
+#define VPSS_HSSISEL_SHIFT              4
+
+/*
+ * vpss operations. Depends on platform. Not all functions are available
+ * on all platforms. The api, first check if a functio is available before
+ * invoking it. In the probe, the function ptrs are intialized based on
+ * vpss name. vpss name can be "dm355_vpss", "dm644x_vpss" etc.
+ */
+struct vpss_hw_ops {
+        /* enable clock */
+        int (*enable_clock)(enum vpss_clock_sel clock_sel, int en);
+        /* select input to ccdc */
+        void (*select_ccdc_source)(enum vpss_ccdc_source_sel src_sel);
+        /* clear wbl overlflow bit */
+        int (*clear_wbl_overflow)(enum vpss_wbl_sel wbl_sel);
+};
+
+/* vpss configuration */
+struct vpss_oper_config {
+        __iomem void *vpss_bl_regs_base;
+        __iomem void *vpss_regs_base;
+        struct resource         *r1;
+        resource_size_t         len1;
+        struct resource         *r2;
+        resource_size_t         len2;
+        char vpss_name[32];
+        spinlock_t vpss_lock;
+        struct vpss_hw_ops hw_ops;
+};
+
+static struct vpss_oper_config oper_cfg;
+
+/* register access routines */
+static inline u32 bl_regr(u32 offset)
+{
+        return __raw_readl(oper_cfg.vpss_bl_regs_base + offset);
+}
+
+static inline void bl_regw(u32 val, u32 offset)
+{
+        __raw_writel(val, oper_cfg.vpss_bl_regs_base + offset);
+}
+
+static inline u32 vpss_regr(u32 offset)
+{
+        return __raw_readl(oper_cfg.vpss_regs_base + offset);
+}
+
+static inline void vpss_regw(u32 val, u32 offset)
+{
+        __raw_writel(val, oper_cfg.vpss_regs_base + offset);
+}
+
+static void dm355_select_ccdc_source(enum vpss_ccdc_source_sel src_sel)
+{
+        bl_regw(src_sel << VPSS_HSSISEL_SHIFT, DM355_VPSSBL_CCDCMUX);
+}
+
+int vpss_select_ccdc_source(enum vpss_ccdc_source_sel src_sel)
+{
+        if (!oper_cfg.hw_ops.select_ccdc_source)
+                return -1;
+
+        dm355_select_ccdc_source(src_sel);
+        return 0;
+}
+EXPORT_SYMBOL(vpss_select_ccdc_source);
+
+static int dm644x_clear_wbl_overflow(enum vpss_wbl_sel wbl_sel)
+{
+        u32 mask = 1, val;
+
+        if (wbl_sel < VPSS_PCR_AEW_WBL_0 ||
+            wbl_sel > VPSS_PCR_CCDC_WBL_O)
+                return -1;
+
+        /* writing a 0 clear the overflow */
+        mask = ~(mask << wbl_sel);
+        val = bl_regr(DM644X_SBL_PCR_VPSS) & mask;
+        bl_regw(val, DM644X_SBL_PCR_VPSS);
+        return 0;
+}
+
+int vpss_clear_wbl_overflow(enum vpss_wbl_sel wbl_sel)
+{
+        if (!oper_cfg.hw_ops.clear_wbl_overflow)
+                return -1;
+
+        return oper_cfg.hw_ops.clear_wbl_overflow(wbl_sel);
+}
+EXPORT_SYMBOL(vpss_clear_wbl_overflow);
+
+/*
+ *  dm355_enable_clock - Enable VPSS Clock
+ *  @clock_sel: CLock to be enabled/disabled
+ *  @en: enable/disable flag
+ *
+ *  This is called to enable or disable a vpss clock
+ */
+static int dm355_enable_clock(enum vpss_clock_sel clock_sel, int en)
+{
+        unsigned long flags;
+        u32 utemp, mask = 0x1, shift = 0;
+
+        switch (clock_sel) {
+        case VPSS_VPBE_CLOCK:
+                /* nothing since lsb */
+                break;
+        case VPSS_VENC_CLOCK_SEL:
+                shift = 2;
+                break;
+        case VPSS_CFALD_CLOCK:
+                shift = 3;
+                break;
+        case VPSS_H3A_CLOCK:
+                shift = 4;
+                break;
+        case VPSS_IPIPE_CLOCK:
+                shift = 5;
+                break;
+        case VPSS_CCDC_CLOCK:
+                shift = 6;
+                break;
+        default:
+                printk(KERN_ERR "dm355_enable_clock:"
+                                " Invalid selector: %d\n", clock_sel);
+                return -1;
+        }
+
+        spin_lock_irqsave(&oper_cfg.vpss_lock, flags);
+        utemp = vpss_regr(DM355_VPSSCLK_CLKCTRL);
+        if (!en)
+                utemp &= ~(mask << shift);
+        else
+                utemp |= (mask << shift);
+
+        vpss_regw(utemp, DM355_VPSSCLK_CLKCTRL);
+        spin_unlock_irqrestore(&oper_cfg.vpss_lock, flags);
+        return 0;
+}
+
+int vpss_enable_clock(enum vpss_clock_sel clock_sel, int en)
+{
+        if (!oper_cfg.hw_ops.enable_clock)
+                return -1;
+
+        return oper_cfg.hw_ops.enable_clock(clock_sel, en);
+}
+EXPORT_SYMBOL(vpss_enable_clock);
+
+static int __init vpss_probe(struct platform_device *pdev)
+{
+        int status, dm355 = 0;
+
+        if (!pdev->dev.platform_data) {
+                dev_err(&pdev->dev, "no platform data\n");
+                return -ENOENT;
+        }
+        strcpy(oper_cfg.vpss_name, pdev->dev.platform_data);
+
+        if (!strcmp(oper_cfg.vpss_name, "dm355_vpss"))
+                dm355 = 1;
+        else if (strcmp(oper_cfg.vpss_name, "dm644x_vpss")) {
+                dev_err(&pdev->dev, "vpss driver not supported on"
+                        " this platform\n");
+                return -ENODEV;
+        }
+
+        dev_info(&pdev->dev, "%s vpss probed\n", oper_cfg.vpss_name);
+        oper_cfg.r1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!oper_cfg.r1)
+                return -ENOENT;
+
+        oper_cfg.len1 = oper_cfg.r1->end - oper_cfg.r1->start + 1;
+
+        oper_cfg.r1 = request_mem_region(oper_cfg.r1->start, oper_cfg.len1,
+                                         oper_cfg.r1->name);
+        if (!oper_cfg.r1)
+                return -EBUSY;
+
+        oper_cfg.vpss_bl_regs_base = ioremap(oper_cfg.r1->start, oper_cfg.len1);
+        if (!oper_cfg.vpss_bl_regs_base) {
+                status = -EBUSY;
+                goto fail1;
+        }
+
+        if (dm355) {
+                oper_cfg.r2 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+                if (!oper_cfg.r2) {
+                        status = -ENOENT;
+                        goto fail2;
+                }
+                oper_cfg.len2 = oper_cfg.r2->end - oper_cfg.r2->start + 1;
+                oper_cfg.r2 = request_mem_region(oper_cfg.r2->start,
+                                                 oper_cfg.len2,
+                                                 oper_cfg.r2->name);
+                if (!oper_cfg.r2) {
+                        status = -EBUSY;
+                        goto fail2;
+                }
+
+                oper_cfg.vpss_regs_base = ioremap(oper_cfg.r2->start,
+                                                  oper_cfg.len2);
+                if (!oper_cfg.vpss_regs_base) {
+                        status = -EBUSY;
+                        goto fail3;
+                }
+        }
+
+        if (dm355) {
+                oper_cfg.hw_ops.enable_clock = dm355_enable_clock;
+                oper_cfg.hw_ops.select_ccdc_source = dm355_select_ccdc_source;
+        } else
+                oper_cfg.hw_ops.clear_wbl_overflow = dm644x_clear_wbl_overflow;
+
+        spin_lock_init(&oper_cfg.vpss_lock);
+        dev_info(&pdev->dev, "%s vpss probe success\n", oper_cfg.vpss_name);
+        return 0;
+
+fail3:
+        release_mem_region(oper_cfg.r2->start, oper_cfg.len2);
+fail2:
+        iounmap(oper_cfg.vpss_bl_regs_base);
+fail1:
+        release_mem_region(oper_cfg.r1->start, oper_cfg.len1);
+        return status;
+}
+
+static int vpss_remove(struct platform_device *pdev)
+{
+        iounmap(oper_cfg.vpss_bl_regs_base);
+        release_mem_region(oper_cfg.r1->start, oper_cfg.len1);
+        if (!strcmp(oper_cfg.vpss_name, "dm355_vpss")) {
+                iounmap(oper_cfg.vpss_regs_base);
+                release_mem_region(oper_cfg.r2->start, oper_cfg.len2);
+        }
+        return 0;
+}
+
+static struct platform_driver vpss_driver = {
+        .driver = {
+                .name   = "vpss",
+                .owner = THIS_MODULE,
+        },
+        .remove = __devexit_p(vpss_remove),
+        .probe = vpss_probe,
+};
+
+static void vpss_exit(void)
+{
+        platform_driver_unregister(&vpss_driver);
+}
+
+static int __init vpss_init(void)
+{
+        return platform_driver_register(&vpss_driver);
+}
+subsys_initcall(vpss_init);
+module_exit(vpss_exit);
diff --git a/drivers/media/video/em28xx/Kconfig b/drivers/media/video/em28xx/Kconfig
index 6524b493e033..c7be0e097828 100644
--- a/drivers/media/video/em28xx/Kconfig
+++ b/drivers/media/video/em28xx/Kconfig
@@ -36,6 +36,7 @@ config VIDEO_EM28XX_DVB
         depends on VIDEO_EM28XX && DVB_CORE
         select DVB_LGDT330X if !DVB_FE_CUSTOMISE
         select DVB_ZL10353 if !DVB_FE_CUSTOMISE
+        select DVB_TDA10023 if !DVB_FE_CUSTOMISE
         select VIDEOBUF_DVB
         ---help---
           This adds support for DVB cards based on the
diff --git a/drivers/media/video/em28xx/Makefile b/drivers/media/video/em28xx/Makefile
index 8137a8c94bfc..d0f093d1d0df 100644
--- a/drivers/media/video/em28xx/Makefile
+++ b/drivers/media/video/em28xx/Makefile
@@ -1,5 +1,5 @@
 em28xx-objs     := em28xx-video.o em28xx-i2c.o em28xx-cards.o em28xx-core.o \
-                   em28xx-input.o
+                   em28xx-input.o em28xx-vbi.o
 
 em28xx-alsa-objs := em28xx-audio.o
 
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index 7e3c78239fa9..bdb249bd9d5d 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -170,6 +170,19 @@ static struct em28xx_reg_seq pinnacle_hybrid_pro_digital[] = {
         {       -1,             -1,     -1,             -1},
 };
 
+/* eb1a:2868 Reddo DVB-C USB TV Box
+   GPIO4 - CU1216L NIM
+   Other GPIOs seems to be don't care. */
+static struct em28xx_reg_seq reddo_dvb_c_usb_box[] = {
+        {EM28XX_R08_GPIO,       0xfe,   0xff,           10},
+        {EM28XX_R08_GPIO,       0xde,   0xff,           10},
+        {EM28XX_R08_GPIO,       0xfe,   0xff,           10},
+        {EM28XX_R08_GPIO,       0xff,   0xff,           10},
+        {EM28XX_R08_GPIO,       0x7f,   0xff,           10},
+        {EM28XX_R08_GPIO,       0x6f,   0xff,           10},
+        {EM28XX_R08_GPIO,       0xff,   0xff,           10},
+        {-1,                    -1,     -1,             -1},
+};
 
 /* Callback for the most boards */
 static struct em28xx_reg_seq default_tuner_gpio[] = {
@@ -1566,6 +1579,14 @@ struct em28xx_board em28xx_boards[] = {
                         .gpio     = evga_indtube_analog,
                 } },
         },
+        /* eb1a:2868 Empia EM2870 + Philips CU1216L NIM (Philips TDA10023 +
+           Infineon TUA6034) */
+        [EM2870_BOARD_REDDO_DVB_C_USB_BOX] = {
+                .name          = "Reddo DVB-C USB TV Box",
+                .tuner_type    = TUNER_ABSENT,
+                .has_dvb       = 1,
+                .dvb_gpio      = reddo_dvb_c_usb_box,
+        },
 };
 const unsigned int em28xx_bcount = ARRAY_SIZE(em28xx_boards);
 
@@ -1593,6 +1614,8 @@ struct usb_device_id em28xx_id_table[] = {
                         .driver_info = EM2820_BOARD_UNKNOWN },
         { USB_DEVICE(0xeb1a, 0x2883),
                         .driver_info = EM2820_BOARD_UNKNOWN },
+        { USB_DEVICE(0xeb1a, 0x2868),
+                        .driver_info = EM2820_BOARD_UNKNOWN },
         { USB_DEVICE(0xeb1a, 0xe300),
                         .driver_info = EM2861_BOARD_KWORLD_PVRTV_300U },
         { USB_DEVICE(0xeb1a, 0xe303),
@@ -1696,6 +1719,7 @@ static struct em28xx_hash_table em28xx_eeprom_hash[] = {
         {0x166a0441, EM2880_BOARD_EMPIRE_DUAL_TV, TUNER_XC2028},
         {0xcee44a99, EM2882_BOARD_EVGA_INDTUBE, TUNER_XC2028},
         {0xb8846b20, EM2881_BOARD_PINNACLE_HYBRID_PRO, TUNER_XC2028},
+        {0x63f653bd, EM2870_BOARD_REDDO_DVB_C_USB_BOX, TUNER_ABSENT},
 };
 
 /* I2C devicelist hash table for devices with generic USB IDs */
@@ -2348,55 +2372,55 @@ void em28xx_card_setup(struct em28xx *dev)
 
         /* request some modules */
         if (dev->board.has_msp34xx)
-                v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, &dev->i2c_adap,
-                        "msp3400", "msp3400", msp3400_addrs);
+                v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
+                        "msp3400", "msp3400", 0, msp3400_addrs);
 
         if (dev->board.decoder == EM28XX_SAA711X)
-                v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, &dev->i2c_adap,
-                        "saa7115", "saa7115_auto", saa711x_addrs);
+                v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
+                        "saa7115", "saa7115_auto", 0, saa711x_addrs);
 
         if (dev->board.decoder == EM28XX_TVP5150)
-                v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, &dev->i2c_adap,
-                        "tvp5150", "tvp5150", tvp5150_addrs);
+                v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
+                        "tvp5150", "tvp5150", 0, tvp5150_addrs);
 
         if (dev->em28xx_sensor == EM28XX_MT9V011) {
                 struct v4l2_subdev *sd;
 
-                sd = v4l2_i2c_new_probed_subdev(&dev->v4l2_dev,
-                         &dev->i2c_adap, "mt9v011", "mt9v011", mt9v011_addrs);
+                sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
+                         &dev->i2c_adap, "mt9v011", "mt9v011", 0, mt9v011_addrs);
                 v4l2_subdev_call(sd, core, s_config, 0, &dev->sensor_xtal);
         }
 
 
         if (dev->board.adecoder == EM28XX_TVAUDIO)
                 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
-                        "tvaudio", "tvaudio", dev->board.tvaudio_addr);
+                        "tvaudio", "tvaudio", dev->board.tvaudio_addr, NULL);
 
         if (dev->board.tuner_type != TUNER_ABSENT) {
                 int has_demod = (dev->tda9887_conf & TDA9887_PRESENT);
 
                 if (dev->board.radio.type)
                         v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
-                                "tuner", "tuner", dev->board.radio_addr);
+                                "tuner", "tuner", dev->board.radio_addr, NULL);
 
                 if (has_demod)
-                        v4l2_i2c_new_probed_subdev(&dev->v4l2_dev,
+                        v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_adap, "tuner", "tuner",
-                                v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
+                                0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
                 if (dev->tuner_addr == 0) {
                         enum v4l2_i2c_tuner_type type =
                                 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
                         struct v4l2_subdev *sd;
 
-                        sd = v4l2_i2c_new_probed_subdev(&dev->v4l2_dev,
+                        sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_adap, "tuner", "tuner",
-                                v4l2_i2c_tuner_addrs(type));
+                                0, v4l2_i2c_tuner_addrs(type));
 
                         if (sd)
                                 dev->tuner_addr = v4l2_i2c_subdev_addr(sd);
                 } else {
                         v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
-                                "tuner", "tuner", dev->tuner_addr);
+                                "tuner", "tuner", dev->tuner_addr, NULL);
                 }
         }
 
@@ -2570,7 +2594,8 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
          * Default format, used for tvp5150 or saa711x output formats
          */
         dev->vinmode = 0x10;
-        dev->vinctl  = 0x11;
+        dev->vinctl  = EM28XX_VINCTRL_INTERLACED |
+                       EM28XX_VINCTRL_CCIR656_ENABLE;
 
         /* Do board specific init and eeprom reading */
         em28xx_card_setup(dev);
@@ -2589,6 +2614,8 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
         /* init video dma queues */
         INIT_LIST_HEAD(&dev->vidq.active);
         INIT_LIST_HEAD(&dev->vidq.queued);
+        INIT_LIST_HEAD(&dev->vbiq.active);
+        INIT_LIST_HEAD(&dev->vbiq.queued);
 
 
         if (dev->board.has_msp34xx) {
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c
index 98e140b5d95e..a88257a7d94f 100644
--- a/drivers/media/video/em28xx/em28xx-core.c
+++ b/drivers/media/video/em28xx/em28xx-core.c
@@ -54,6 +54,10 @@ static int alt = EM28XX_PINOUT;
 module_param(alt, int, 0644);
 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
 
+static unsigned int disable_vbi;
+module_param(disable_vbi, int, 0644);
+MODULE_PARM_DESC(disable_vbi, "disable vbi support");
+
 /* FIXME */
 #define em28xx_isocdbg(fmt, arg...) do {\
         if (core_debug) \
@@ -648,9 +652,24 @@ int em28xx_capture_start(struct em28xx *dev, int start)
         return rc;
 }
 
+int em28xx_vbi_supported(struct em28xx *dev)
+{
+        /* Modprobe option to manually disable */
+        if (disable_vbi == 1)
+                return 0;
+
+        if (dev->chip_id == CHIP_ID_EM2860 ||
+            dev->chip_id == CHIP_ID_EM2883)
+                return 1;
+
+        /* Version of em28xx that does not support VBI */
+        return 0;
+}
+
 int em28xx_set_outfmt(struct em28xx *dev)
 {
         int ret;
+        u8 vinctrl;
 
         ret = em28xx_write_reg_bits(dev, EM28XX_R27_OUTFMT,
                                 dev->format->reg | 0x20, 0xff);
@@ -661,7 +680,16 @@ int em28xx_set_outfmt(struct em28xx *dev)
         if (ret < 0)
                 return ret;
 
-        return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, dev->vinctl);
+        vinctrl = dev->vinctl;
+        if (em28xx_vbi_supported(dev) == 1) {
+                vinctrl |= EM28XX_VINCTRL_VBI_RAW;
+                em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
+                em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
+                em28xx_write_reg(dev, EM28XX_R36_VBI_WIDTH, 0xb4);
+                em28xx_write_reg(dev, EM28XX_R37_VBI_HEIGHT, 0x0c);
+        }
+
+        return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctrl);
 }
 
 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
@@ -732,7 +760,14 @@ int em28xx_resolution_set(struct em28xx *dev)
 
 
         em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
-        em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
+
+        /* If we don't set the start position to 4 in VBI mode, we end up
+           with line 21 being YUYV encoded instead of being in 8-bit
+           greyscale */
+        if (em28xx_vbi_supported(dev) == 1)
+                em28xx_capture_area_set(dev, 0, 4, width >> 2, height >> 2);
+        else
+                em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
 
         return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
 }
@@ -844,8 +879,7 @@ EXPORT_SYMBOL_GPL(em28xx_set_mode);
  */
 static void em28xx_irq_callback(struct urb *urb)
 {
-        struct em28xx_dmaqueue  *dma_q = urb->context;
-        struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
+        struct em28xx *dev = urb->context;
         int rc, i;
 
         switch (urb->status) {
@@ -930,6 +964,7 @@ int em28xx_init_isoc(struct em28xx *dev, int max_packets,
                      int (*isoc_copy) (struct em28xx *dev, struct urb *urb))
 {
         struct em28xx_dmaqueue *dma_q = &dev->vidq;
+        struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
         int i;
         int sb_size, pipe;
         struct urb *urb;
@@ -959,7 +994,8 @@ int em28xx_init_isoc(struct em28xx *dev, int max_packets,
         }
 
         dev->isoc_ctl.max_pkt_size = max_pkt_size;
-        dev->isoc_ctl.buf = NULL;
+        dev->isoc_ctl.vid_buf = NULL;
+        dev->isoc_ctl.vbi_buf = NULL;
 
         sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
 
@@ -994,7 +1030,7 @@ int em28xx_init_isoc(struct em28xx *dev, int max_packets,
 
                 usb_fill_int_urb(urb, dev->udev, pipe,
                                  dev->isoc_ctl.transfer_buffer[i], sb_size,
-                                 em28xx_irq_callback, dma_q, 1);
+                                 em28xx_irq_callback, dev, 1);
 
                 urb->number_of_packets = max_packets;
                 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
@@ -1009,6 +1045,7 @@ int em28xx_init_isoc(struct em28xx *dev, int max_packets,
         }
 
         init_waitqueue_head(&dma_q->wq);
+        init_waitqueue_head(&vbi_dma_q->wq);
 
         em28xx_capture_start(dev, 1);
 
@@ -1094,7 +1131,7 @@ struct em28xx *em28xx_get_device(int minor,
         list_for_each_entry(h, &em28xx_devlist, devlist) {
                 if (h->vdev->minor == minor)
                         dev = h;
-                if (h->vbi_dev->minor == minor) {
+                if (h->vbi_dev && h->vbi_dev->minor == minor) {
                         dev = h;
                         *fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
                 }
diff --git a/drivers/media/video/em28xx/em28xx-dvb.c b/drivers/media/video/em28xx/em28xx-dvb.c
index d603575431b4..db749461e5c6 100644
--- a/drivers/media/video/em28xx/em28xx-dvb.c
+++ b/drivers/media/video/em28xx/em28xx-dvb.c
@@ -33,6 +33,7 @@
 #include "s5h1409.h"
 #include "mt352.h"
 #include "mt352_priv.h" /* FIXME */
+#include "tda1002x.h"
 
 MODULE_DESCRIPTION("driver for em28xx based DVB cards");
 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
@@ -295,6 +296,11 @@ static struct mt352_config terratec_xs_mt352_cfg = {
         .demod_init = mt352_terratec_xs_init,
 };
 
+static struct tda10023_config em28xx_tda10023_config = {
+        .demod_address = 0x0c,
+        .invert = 1,
+};
+
 /* ------------------------------------------------------------------ */
 
 static int attach_xc3028(u8 addr, struct em28xx *dev)
@@ -549,6 +555,19 @@ static int dvb_init(struct em28xx *dev)
                 }
                 break;
 #endif
+        case EM2870_BOARD_REDDO_DVB_C_USB_BOX:
+                /* Philips CU1216L NIM (Philips TDA10023 + Infineon TUA6034) */
+                dvb->frontend = dvb_attach(tda10023_attach,
+                        &em28xx_tda10023_config,
+                        &dev->i2c_adap, 0x48);
+                if (dvb->frontend) {
+                        if (!dvb_attach(simple_tuner_attach, dvb->frontend,
+                                &dev->i2c_adap, 0x60, TUNER_PHILIPS_CU1216L)) {
+                                result = -EINVAL;
+                                goto out_free;
+                        }
+                }
+                break;
         default:
                 printk(KERN_ERR "%s/2: The frontend of your DVB/ATSC card"
                                 " isn't supported yet\n",
diff --git a/drivers/media/video/em28xx/em28xx-reg.h b/drivers/media/video/em28xx/em28xx-reg.h
index 6bf84bd787df..ed12e7ffcbd0 100644
--- a/drivers/media/video/em28xx/em28xx-reg.h
+++ b/drivers/media/video/em28xx/em28xx-reg.h
@@ -86,7 +86,19 @@
 #define EM28XX_XCLK_FREQUENCY_24MHZ     0x0b
 
 #define EM28XX_R10_VINMODE      0x10
+
 #define EM28XX_R11_VINCTRL      0x11
+
+/* em28xx Video Input Control Register 0x11 */
+#define EM28XX_VINCTRL_VBI_SLICED       0x80
+#define EM28XX_VINCTRL_VBI_RAW          0x40
+#define EM28XX_VINCTRL_VOUT_MODE_IN     0x20 /* HREF,VREF,VACT in output */
+#define EM28XX_VINCTRL_CCIR656_ENABLE   0x10
+#define EM28XX_VINCTRL_VBI_16BIT_RAW    0x08 /* otherwise 8-bit raw */
+#define EM28XX_VINCTRL_FID_ON_HREF      0x04
+#define EM28XX_VINCTRL_DUAL_EDGE_STROBE 0x02
+#define EM28XX_VINCTRL_INTERLACED       0x01
+
 #define EM28XX_R12_VINENABLE    0x12    /* */
 
 #define EM28XX_R14_GAMMA        0x14
@@ -135,6 +147,10 @@
 #define EM28XX_R31_HSCALEHIGH   0x31
 #define EM28XX_R32_VSCALELOW    0x32
 #define EM28XX_R33_VSCALEHIGH   0x33
+#define EM28XX_R34_VBI_START_H  0x34
+#define EM28XX_R35_VBI_START_V  0x35
+#define EM28XX_R36_VBI_WIDTH    0x36
+#define EM28XX_R37_VBI_HEIGHT   0x37
 
 #define EM28XX_R40_AC97LSB      0x40
 #define EM28XX_R41_AC97MSB      0x41
diff --git a/drivers/media/video/em28xx/em28xx-vbi.c b/drivers/media/video/em28xx/em28xx-vbi.c
new file mode 100644
index 000000000000..94943e5a1529
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-vbi.c
@@ -0,0 +1,142 @@
+/*
+   em28xx-vbi.c - VBI driver for em28xx
+
+   Copyright (C) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
+
+   This work was sponsored by EyeMagnet Limited.
+
+   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., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+
+#include "em28xx.h"
+
+static unsigned int vbibufs = 5;
+module_param(vbibufs, int, 0644);
+MODULE_PARM_DESC(vbibufs, "number of vbi buffers, range 2-32");
+
+static unsigned int vbi_debug;
+module_param(vbi_debug, int, 0644);
+MODULE_PARM_DESC(vbi_debug, "enable debug messages [vbi]");
+
+#define dprintk(level, fmt, arg...)     if (vbi_debug >= level) \
+        printk(KERN_DEBUG "%s: " fmt, dev->core->name , ## arg)
+
+/* ------------------------------------------------------------------ */
+
+static void
+free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf)
+{
+        struct em28xx_fh     *fh  = vq->priv_data;
+        struct em28xx        *dev = fh->dev;
+        unsigned long flags = 0;
+        if (in_interrupt())
+                BUG();
+
+        /* We used to wait for the buffer to finish here, but this didn't work
+           because, as we were keeping the state as VIDEOBUF_QUEUED,
+           videobuf_queue_cancel marked it as finished for us.
+           (Also, it could wedge forever if the hardware was misconfigured.)
+
+           This should be safe; by the time we get here, the buffer isn't
+           queued anymore. If we ever start marking the buffers as
+           VIDEOBUF_ACTIVE, it won't be, though.
+        */
+        spin_lock_irqsave(&dev->slock, flags);
+        if (dev->isoc_ctl.vbi_buf == buf)
+                dev->isoc_ctl.vbi_buf = NULL;
+        spin_unlock_irqrestore(&dev->slock, flags);
+
+        videobuf_vmalloc_free(&buf->vb);
+        buf->vb.state = VIDEOBUF_NEEDS_INIT;
+}
+
+static int
+vbi_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
+{
+        *size = 720 * 12 * 2;
+        if (0 == *count)
+                *count = vbibufs;
+        if (*count < 2)
+                *count = 2;
+        if (*count > 32)
+                *count = 32;
+        return 0;
+}
+
+static int
+vbi_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
+            enum v4l2_field field)
+{
+        struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
+        int                  rc = 0;
+        unsigned int size;
+
+        size = 720 * 12 * 2;
+
+        buf->vb.size = size;
+
+        if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
+                return -EINVAL;
+
+        buf->vb.width  = 720;
+        buf->vb.height = 12;
+        buf->vb.field  = field;
+
+        if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
+                rc = videobuf_iolock(q, &buf->vb, NULL);
+                if (rc < 0)
+                        goto fail;
+        }
+
+        buf->vb.state = VIDEOBUF_PREPARED;
+        return 0;
+
+fail:
+        free_buffer(q, buf);
+        return rc;
+}
+
+static void
+vbi_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
+{
+        struct em28xx_buffer    *buf     = container_of(vb,
+                                                        struct em28xx_buffer,
+                                                        vb);
+        struct em28xx_fh        *fh      = vq->priv_data;
+        struct em28xx           *dev     = fh->dev;
+        struct em28xx_dmaqueue  *vbiq    = &dev->vbiq;
+
+        buf->vb.state = VIDEOBUF_QUEUED;
+        list_add_tail(&buf->vb.queue, &vbiq->active);
+}
+
+static void vbi_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
+{
+        struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
+        free_buffer(q, buf);
+}
+
+struct videobuf_queue_ops em28xx_vbi_qops = {
+        .buf_setup    = vbi_setup,
+        .buf_prepare  = vbi_prepare,
+        .buf_queue    = vbi_queue,
+        .buf_release  = vbi_release,
+};
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index a6bdbc21410e..3a1dfb7726f8 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -163,7 +163,24 @@ static inline void buffer_filled(struct em28xx *dev,
         buf->vb.field_count++;
         do_gettimeofday(&buf->vb.ts);
 
-        dev->isoc_ctl.buf = NULL;
+        dev->isoc_ctl.vid_buf = NULL;
+
+        list_del(&buf->vb.queue);
+        wake_up(&buf->vb.done);
+}
+
+static inline void vbi_buffer_filled(struct em28xx *dev,
+                                     struct em28xx_dmaqueue *dma_q,
+                                     struct em28xx_buffer *buf)
+{
+        /* Advice that buffer was filled */
+        em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
+
+        buf->vb.state = VIDEOBUF_DONE;
+        buf->vb.field_count++;
+        do_gettimeofday(&buf->vb.ts);
+
+        dev->isoc_ctl.vbi_buf = NULL;
 
         list_del(&buf->vb.queue);
         wake_up(&buf->vb.done);
@@ -239,7 +256,8 @@ static void em28xx_copy_video(struct em28xx *dev,
 
                 if ((char *)startwrite + lencopy > (char *)outp +
                     buf->vb.size) {
-                        em28xx_isocdbg("Overflow of %zi bytes past buffer end (2)\n",
+                        em28xx_isocdbg("Overflow of %zi bytes past buffer end"
+                                       "(2)\n",
                                        ((char *)startwrite + lencopy) -
                                        ((char *)outp + buf->vb.size));
                         lencopy = remain = (char *)outp + buf->vb.size -
@@ -256,6 +274,63 @@ static void em28xx_copy_video(struct em28xx *dev,
         dma_q->pos += len;
 }
 
+static void em28xx_copy_vbi(struct em28xx *dev,
+                              struct em28xx_dmaqueue  *dma_q,
+                              struct em28xx_buffer *buf,
+                              unsigned char *p,
+                              unsigned char *outp, unsigned long len)
+{
+        void *startwrite, *startread;
+        int  offset;
+        int bytesperline = 720;
+
+        if (dev == NULL) {
+                em28xx_isocdbg("dev is null\n");
+                return;
+        }
+
+        if (dma_q == NULL) {
+                em28xx_isocdbg("dma_q is null\n");
+                return;
+        }
+        if (buf == NULL) {
+                return;
+        }
+        if (p == NULL) {
+                em28xx_isocdbg("p is null\n");
+                return;
+        }
+        if (outp == NULL) {
+                em28xx_isocdbg("outp is null\n");
+                return;
+        }
+
+        if (dma_q->pos + len > buf->vb.size)
+                len = buf->vb.size - dma_q->pos;
+
+        if ((p[0] == 0x33 && p[1] == 0x95) ||
+            (p[0] == 0x88 && p[1] == 0x88)) {
+                /* Header field, advance past it */
+                p += 4;
+        } else {
+                len += 4;
+        }
+
+        startread = p;
+
+        startwrite = outp + dma_q->pos;
+        offset = dma_q->pos;
+
+        /* Make sure the bottom field populates the second half of the frame */
+        if (buf->top_field == 0) {
+                startwrite += bytesperline * 0x0c;
+                offset += bytesperline * 0x0c;
+        }
+
+        memcpy(startwrite, startread, len);
+        dma_q->pos += len;
+}
+
 static inline void print_err_status(struct em28xx *dev,
                                      int packet, int status)
 {
@@ -306,7 +381,7 @@ static inline void get_next_buf(struct em28xx_dmaqueue *dma_q,
 
         if (list_empty(&dma_q->active)) {
                 em28xx_isocdbg("No active queue to serve\n");
-                dev->isoc_ctl.buf = NULL;
+                dev->isoc_ctl.vid_buf = NULL;
                 *buf = NULL;
                 return;
         }
@@ -318,7 +393,34 @@ static inline void get_next_buf(struct em28xx_dmaqueue *dma_q,
         outp = videobuf_to_vmalloc(&(*buf)->vb);
         memset(outp, 0, (*buf)->vb.size);
 
-        dev->isoc_ctl.buf = *buf;
+        dev->isoc_ctl.vid_buf = *buf;
+
+        return;
+}
+
+/*
+ * video-buf generic routine to get the next available VBI buffer
+ */
+static inline void vbi_get_next_buf(struct em28xx_dmaqueue *dma_q,
+                                    struct em28xx_buffer **buf)
+{
+        struct em28xx *dev = container_of(dma_q, struct em28xx, vbiq);
+        char *outp;
+
+        if (list_empty(&dma_q->active)) {
+                em28xx_isocdbg("No active queue to serve\n");
+                dev->isoc_ctl.vbi_buf = NULL;
+                *buf = NULL;
+                return;
+        }
+
+        /* Get the next buffer */
+        *buf = list_entry(dma_q->active.next, struct em28xx_buffer, vb.queue);
+        /* Cleans up buffer - Usefull for testing for frame/URB loss */
+        outp = videobuf_to_vmalloc(&(*buf)->vb);
+        memset(outp, 0x00, (*buf)->vb.size);
+
+        dev->isoc_ctl.vbi_buf = *buf;
 
         return;
 }
@@ -329,7 +431,7 @@ static inline void get_next_buf(struct em28xx_dmaqueue *dma_q,
 static inline int em28xx_isoc_copy(struct em28xx *dev, struct urb *urb)
 {
         struct em28xx_buffer    *buf;
-        struct em28xx_dmaqueue  *dma_q = urb->context;
+        struct em28xx_dmaqueue  *dma_q = &dev->vidq;
         unsigned char *outp = NULL;
         int i, len = 0, rc = 1;
         unsigned char *p;
@@ -346,7 +448,7 @@ static inline int em28xx_isoc_copy(struct em28xx *dev, struct urb *urb)
                         return 0;
         }
 
-        buf = dev->isoc_ctl.buf;
+        buf = dev->isoc_ctl.vid_buf;
         if (buf != NULL)
                 outp = videobuf_to_vmalloc(&buf->vb);
 
@@ -410,6 +512,153 @@ static inline int em28xx_isoc_copy(struct em28xx *dev, struct urb *urb)
         return rc;
 }
 
+/* Version of isoc handler that takes into account a mixture of video and
+   VBI data */
+static inline int em28xx_isoc_copy_vbi(struct em28xx *dev, struct urb *urb)
+{
+        struct em28xx_buffer    *buf, *vbi_buf;
+        struct em28xx_dmaqueue  *dma_q = &dev->vidq;
+        struct em28xx_dmaqueue  *vbi_dma_q = &dev->vbiq;
+        unsigned char *outp = NULL;
+        unsigned char *vbioutp = NULL;
+        int i, len = 0, rc = 1;
+        unsigned char *p;
+        int vbi_size;
+
+        if (!dev)
+                return 0;
+
+        if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
+                return 0;
+
+        if (urb->status < 0) {
+                print_err_status(dev, -1, urb->status);
+                if (urb->status == -ENOENT)
+                        return 0;
+        }
+
+        buf = dev->isoc_ctl.vid_buf;
+        if (buf != NULL)
+                outp = videobuf_to_vmalloc(&buf->vb);
+
+        vbi_buf = dev->isoc_ctl.vbi_buf;
+        if (vbi_buf != NULL)
+                vbioutp = videobuf_to_vmalloc(&vbi_buf->vb);
+
+        for (i = 0; i < urb->number_of_packets; i++) {
+                int status = urb->iso_frame_desc[i].status;
+
+                if (status < 0) {
+                        print_err_status(dev, i, status);
+                        if (urb->iso_frame_desc[i].status != -EPROTO)
+                                continue;
+                }
+
+                len = urb->iso_frame_desc[i].actual_length - 4;
+
+                if (urb->iso_frame_desc[i].actual_length <= 0) {
+                        /* em28xx_isocdbg("packet %d is empty",i); - spammy */
+                        continue;
+                }
+                if (urb->iso_frame_desc[i].actual_length >
+                                                dev->max_pkt_size) {
+                        em28xx_isocdbg("packet bigger than packet size");
+                        continue;
+                }
+
+                p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
+
+                /* capture type 0 = vbi start
+                   capture type 1 = video start
+                   capture type 2 = video in progress */
+                if (p[0] == 0x33 && p[1] == 0x95) {
+                        dev->capture_type = 0;
+                        dev->vbi_read = 0;
+                        em28xx_isocdbg("VBI START HEADER!!!\n");
+                        dev->cur_field = p[2];
+                }
+
+                /* FIXME: get rid of hard-coded value */
+                vbi_size = 720 * 0x0c;
+
+                if (dev->capture_type == 0) {
+                        if (dev->vbi_read >= vbi_size) {
+                                /* We've already read all the VBI data, so
+                                   treat the rest as video */
+                                em28xx_isocdbg("dev->vbi_read > vbi_size\n");
+                        } else if ((dev->vbi_read + len) < vbi_size) {
+                                /* This entire frame is VBI data */
+                                if (dev->vbi_read == 0 &&
+                                    (!(dev->cur_field & 1))) {
+                                        /* Brand new frame */
+                                        if (vbi_buf != NULL)
+                                                vbi_buffer_filled(dev,
+                                                                  vbi_dma_q,
+                                                                  vbi_buf);
+                                        vbi_get_next_buf(vbi_dma_q, &vbi_buf);
+                                        if (vbi_buf == NULL)
+                                                vbioutp = NULL;
+                                        else
+                                                vbioutp = videobuf_to_vmalloc(
+                                                        &vbi_buf->vb);
+                                }
+
+                                if (dev->vbi_read == 0) {
+                                        vbi_dma_q->pos = 0;
+                                        if (vbi_buf != NULL) {
+                                                if (dev->cur_field & 1)
+                                                        vbi_buf->top_field = 0;
+                                                else
+                                                        vbi_buf->top_field = 1;
+                                        }
+                                }
+
+                                dev->vbi_read += len;
+                                em28xx_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
+                                                vbioutp, len);
+                        } else {
+                                /* Some of this frame is VBI data and some is
+                                   video data */
+                                int vbi_data_len = vbi_size - dev->vbi_read;
+                                dev->vbi_read += vbi_data_len;
+                                em28xx_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
+                                                vbioutp, vbi_data_len);
+                                dev->capture_type = 1;
+                                p += vbi_data_len;
+                                len -= vbi_data_len;
+                        }
+                }
+
+                if (dev->capture_type == 1) {
+                        dev->capture_type = 2;
+                        em28xx_isocdbg("Video frame %d, length=%i, %s\n", p[2],
+                                       len, (p[2] & 1) ? "odd" : "even");
+
+                        if (dev->progressive || !(dev->cur_field & 1)) {
+                                if (buf != NULL)
+                                        buffer_filled(dev, dma_q, buf);
+                                get_next_buf(dma_q, &buf);
+                                if (buf == NULL)
+                                        outp = NULL;
+                                else
+                                        outp = videobuf_to_vmalloc(&buf->vb);
+                        }
+                        if (buf != NULL) {
+                                if (dev->cur_field & 1)
+                                        buf->top_field = 0;
+                                else
+                                        buf->top_field = 1;
+                        }
+
+                        dma_q->pos = 0;
+                }
+                if (buf != NULL && dev->capture_type == 2)
+                        em28xx_copy_video(dev, dma_q, buf, p, outp, len);
+        }
+        return rc;
+}
+
+
 /* ------------------------------------------------------------------
         Videobuf operations
    ------------------------------------------------------------------*/
@@ -421,7 +670,8 @@ buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
         struct em28xx        *dev = fh->dev;
         struct v4l2_frequency f;
 
-        *size = (fh->dev->width * fh->dev->height * dev->format->depth + 7) >> 3;
+        *size = (fh->dev->width * fh->dev->height * dev->format->depth + 7)
+                >> 3;
 
         if (0 == *count)
                 *count = EM28XX_DEF_BUF;
@@ -458,8 +708,8 @@ static void free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf)
            VIDEOBUF_ACTIVE, it won't be, though.
         */
         spin_lock_irqsave(&dev->slock, flags);
-        if (dev->isoc_ctl.buf == buf)
-                dev->isoc_ctl.buf = NULL;
+        if (dev->isoc_ctl.vid_buf == buf)
+                dev->isoc_ctl.vid_buf = NULL;
         spin_unlock_irqrestore(&dev->slock, flags);
 
         videobuf_vmalloc_free(&buf->vb);
@@ -475,7 +725,8 @@ buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
         struct em28xx        *dev = fh->dev;
         int                  rc = 0, urb_init = 0;
 
-        buf->vb.size = (fh->dev->width * fh->dev->height * dev->format->depth + 7) >> 3;
+        buf->vb.size = (fh->dev->width * fh->dev->height * dev->format->depth
+                        + 7) >> 3;
 
         if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
                 return -EINVAL;
@@ -494,9 +745,16 @@ buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
                 urb_init = 1;
 
         if (urb_init) {
-                rc = em28xx_init_isoc(dev, EM28XX_NUM_PACKETS,
-                                      EM28XX_NUM_BUFS, dev->max_pkt_size,
-                                      em28xx_isoc_copy);
+                if (em28xx_vbi_supported(dev) == 1)
+                        rc = em28xx_init_isoc(dev, EM28XX_NUM_PACKETS,
+                                              EM28XX_NUM_BUFS,
+                                              dev->max_pkt_size,
+                                              em28xx_isoc_copy_vbi);
+                else
+                        rc = em28xx_init_isoc(dev, EM28XX_NUM_PACKETS,
+                                              EM28XX_NUM_BUFS,
+                                              dev->max_pkt_size,
+                                              em28xx_isoc_copy);
                 if (rc < 0)
                         goto fail;
         }
@@ -578,34 +836,63 @@ static void video_mux(struct em28xx *dev, int index)
 }
 
 /* Usage lock check functions */
-static int res_get(struct em28xx_fh *fh)
+static int res_get(struct em28xx_fh *fh, unsigned int bit)
 {
         struct em28xx    *dev = fh->dev;
-        int              rc   = 0;
 
-        /* This instance already has stream_on */
-        if (fh->stream_on)
-                return rc;
+        if (fh->resources & bit)
+                /* have it already allocated */
+                return 1;
 
-        if (dev->stream_on)
-                return -EBUSY;
+        /* is it free? */
+        mutex_lock(&dev->lock);
+        if (dev->resources & bit) {
+                /* no, someone else uses it */
+                mutex_unlock(&dev->lock);
+                return 0;
+        }
+        /* it's free, grab it */
+        fh->resources  |= bit;
+        dev->resources |= bit;
+        em28xx_videodbg("res: get %d\n", bit);
+        mutex_unlock(&dev->lock);
+        return 1;
+}
 
-        dev->stream_on = 1;
-        fh->stream_on  = 1;
-        return rc;
+static int res_check(struct em28xx_fh *fh, unsigned int bit)
+{
+        return fh->resources & bit;
 }
 
-static int res_check(struct em28xx_fh *fh)
+static int res_locked(struct em28xx *dev, unsigned int bit)
 {
-        return fh->stream_on;
+        return dev->resources & bit;
 }
 
-static void res_free(struct em28xx_fh *fh)
+static void res_free(struct em28xx_fh *fh, unsigned int bits)
 {
         struct em28xx    *dev = fh->dev;
 
-        fh->stream_on = 0;
-        dev->stream_on = 0;
+        BUG_ON((fh->resources & bits) != bits);
+
+        mutex_lock(&dev->lock);
+        fh->resources  &= ~bits;
+        dev->resources &= ~bits;
+        em28xx_videodbg("res: put %d\n", bits);
+        mutex_unlock(&dev->lock);
+}
+
+static int get_ressource(struct em28xx_fh *fh)
+{
+        switch (fh->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                return EM28XX_RESOURCE_VIDEO;
+        case V4L2_BUF_TYPE_VBI_CAPTURE:
+                return EM28XX_RESOURCE_VBI;
+        default:
+                BUG();
+                return 0;
+        }
 }
 
 /*
@@ -782,7 +1069,8 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         } else {
                 /* width must even because of the YUYV format
                    height must be even because of interlacing */
-                v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh, 1, 0);
+                v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh,
+                                      1, 0);
         }
 
         get_scale(dev, width, height, &hscale, &vscale);
@@ -848,12 +1136,6 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                 goto out;
         }
 
-        if (dev->stream_on && !fh->stream_on) {
-                em28xx_errdev("%s device in use by another fh\n", __func__);
-                rc = -EBUSY;
-                goto out;
-        }
-
         rc = em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
                                 f->fmt.pix.width, f->fmt.pix.height);
 
@@ -862,6 +1144,21 @@ out:
         return rc;
 }
 
+static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
+{
+        struct em28xx_fh   *fh  = priv;
+        struct em28xx      *dev = fh->dev;
+        int                rc;
+
+        rc = check_dev(dev);
+        if (rc < 0)
+                return rc;
+
+        *norm = dev->norm;
+
+        return 0;
+}
+
 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *norm)
 {
         struct em28xx_fh   *fh  = priv;
@@ -1413,20 +1710,25 @@ static int vidioc_streamon(struct file *file, void *priv,
 {
         struct em28xx_fh      *fh  = priv;
         struct em28xx         *dev = fh->dev;
-        int                   rc;
+        int                   rc = -EINVAL;
 
         rc = check_dev(dev);
         if (rc < 0)
                 return rc;
 
+        if (unlikely(type != fh->type))
+                return -EINVAL;
 
-        mutex_lock(&dev->lock);
-        rc = res_get(fh);
+        em28xx_videodbg("vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n",
+                        fh, type, fh->resources, dev->resources);
 
-        if (likely(rc >= 0))
-                rc = videobuf_streamon(&fh->vb_vidq);
+        if (unlikely(!res_get(fh, get_ressource(fh))))
+                return -EBUSY;
 
-        mutex_unlock(&dev->lock);
+        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                rc = videobuf_streamon(&fh->vb_vidq);
+        else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
+                rc = videobuf_streamon(&fh->vb_vbiq);
 
         return rc;
 }
@@ -1442,17 +1744,22 @@ static int vidioc_streamoff(struct file *file, void *priv,
         if (rc < 0)
                 return rc;
 
-        if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+        if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
+            fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)
                 return -EINVAL;
         if (type != fh->type)
                 return -EINVAL;
 
-        mutex_lock(&dev->lock);
+        em28xx_videodbg("vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n",
+                        fh, type, fh->resources, dev->resources);
 
-        videobuf_streamoff(&fh->vb_vidq);
-        res_free(fh);
-
-        mutex_unlock(&dev->lock);
+        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                videobuf_streamoff(&fh->vb_vidq);
+                res_free(fh, EM28XX_RESOURCE_VIDEO);
+        } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
+                videobuf_streamoff(&fh->vb_vbiq);
+                res_free(fh, EM28XX_RESOURCE_VBI);
+        }
 
         return 0;
 }
@@ -1474,6 +1781,9 @@ static int vidioc_querycap(struct file *file, void  *priv,
                         V4L2_CAP_VIDEO_CAPTURE |
                         V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
 
+        if (dev->vbi_dev)
+                cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
+
         if (dev->audio_mode.has_audio)
                 cap->capabilities |= V4L2_CAP_AUDIO;
 
@@ -1541,6 +1851,45 @@ static int vidioc_try_set_sliced_vbi_cap(struct file *file, void *priv,
         return 0;
 }
 
+/* RAW VBI ioctls */
+
+static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
+                                struct v4l2_format *format)
+{
+        format->fmt.vbi.samples_per_line = 720;
+        format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
+        format->fmt.vbi.offset = 0;
+        format->fmt.vbi.flags = 0;
+
+        /* Varies by video standard (NTSC, PAL, etc.) */
+        /* FIXME: hard-coded for NTSC support */
+        format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; /* FIXME: ??? */
+        format->fmt.vbi.count[0] = 12;
+        format->fmt.vbi.count[1] = 12;
+        format->fmt.vbi.start[0] = 10;
+        format->fmt.vbi.start[1] = 273;
+
+        return 0;
+}
+
+static int vidioc_s_fmt_vbi_cap(struct file *file, void *priv,
+                                struct v4l2_format *format)
+{
+        format->fmt.vbi.samples_per_line = 720;
+        format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
+        format->fmt.vbi.offset = 0;
+        format->fmt.vbi.flags = 0;
+
+        /* Varies by video standard (NTSC, PAL, etc.) */
+        /* FIXME: hard-coded for NTSC support */
+        format->fmt.vbi.sampling_rate = 6750000 * 4 / 2; /* FIXME: ??? */
+        format->fmt.vbi.count[0] = 12;
+        format->fmt.vbi.count[1] = 12;
+        format->fmt.vbi.start[0] = 10;
+        format->fmt.vbi.start[1] = 273;
+
+        return 0;
+}
 
 static int vidioc_reqbufs(struct file *file, void *priv,
                           struct v4l2_requestbuffers *rb)
@@ -1553,7 +1902,10 @@ static int vidioc_reqbufs(struct file *file, void *priv,
         if (rc < 0)
                 return rc;
 
-        return videobuf_reqbufs(&fh->vb_vidq, rb);
+        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return videobuf_reqbufs(&fh->vb_vidq, rb);
+        else
+                return videobuf_reqbufs(&fh->vb_vbiq, rb);
 }
 
 static int vidioc_querybuf(struct file *file, void *priv,
@@ -1567,7 +1919,18 @@ static int vidioc_querybuf(struct file *file, void *priv,
         if (rc < 0)
                 return rc;
 
-        return videobuf_querybuf(&fh->vb_vidq, b);
+        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return videobuf_querybuf(&fh->vb_vidq, b);
+        else {
+                /* FIXME: I'm not sure yet whether this is a bug in zvbi or
+                   the videobuf framework, but we probably shouldn't be
+                   returning a buffer larger than that which was asked for.
+                   At a minimum, it causes a crash in zvbi since it does
+                   a memcpy based on the source buffer length */
+                int result = videobuf_querybuf(&fh->vb_vbiq, b);
+                b->length = 17280;
+                return result;
+        }
 }
 
 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
@@ -1580,7 +1943,10 @@ static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
         if (rc < 0)
                 return rc;
 
-        return videobuf_qbuf(&fh->vb_vidq, b);
+        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return videobuf_qbuf(&fh->vb_vidq, b);
+        else
+                return videobuf_qbuf(&fh->vb_vbiq, b);
 }
 
 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
@@ -1593,7 +1959,12 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
         if (rc < 0)
                 return rc;
 
-        return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
+        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags &
+                                      O_NONBLOCK);
+        else
+                return videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags &
+                                      O_NONBLOCK);
 }
 
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
@@ -1601,7 +1972,10 @@ static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
 {
         struct em28xx_fh  *fh = priv;
 
-        return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
+        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
+        else
+                return videobuf_cgmbuf(&fh->vb_vbiq, mbuf, 8);
 }
 #endif
 
@@ -1766,8 +2140,15 @@ static int em28xx_v4l2_open(struct file *filp)
                 field = V4L2_FIELD_INTERLACED;
 
         videobuf_queue_vmalloc_init(&fh->vb_vidq, &em28xx_video_qops,
-                        NULL, &dev->slock, fh->type, field,
-                        sizeof(struct em28xx_buffer), fh);
+                                    NULL, &dev->slock,
+                                    V4L2_BUF_TYPE_VIDEO_CAPTURE, field,
+                                    sizeof(struct em28xx_buffer), fh);
+
+        videobuf_queue_vmalloc_init(&fh->vb_vbiq, &em28xx_vbi_qops,
+                                    NULL, &dev->slock,
+                                    V4L2_BUF_TYPE_VBI_CAPTURE,
+                                    V4L2_FIELD_SEQ_TB,
+                                    sizeof(struct em28xx_buffer), fh);
 
         mutex_unlock(&dev->lock);
 
@@ -1824,20 +2205,21 @@ static int em28xx_v4l2_close(struct file *filp)
 
         em28xx_videodbg("users=%d\n", dev->users);
 
+        if (res_check(fh, EM28XX_RESOURCE_VIDEO)) {
+                videobuf_stop(&fh->vb_vidq);
+                res_free(fh, EM28XX_RESOURCE_VIDEO);
+        }
 
-        mutex_lock(&dev->lock);
-        if (res_check(fh))
-                res_free(fh);
+        if (res_check(fh, EM28XX_RESOURCE_VBI)) {
+                videobuf_stop(&fh->vb_vbiq);
+                res_free(fh, EM28XX_RESOURCE_VBI);
+        }
 
         if (dev->users == 1) {
-                videobuf_stop(&fh->vb_vidq);
-                videobuf_mmap_free(&fh->vb_vidq);
-
                 /* the device is already disconnect,
                    free the remaining resources */
                 if (dev->state & DEV_DISCONNECTED) {
                         em28xx_release_resources(dev);
-                        mutex_unlock(&dev->lock);
                         kfree(dev);
                         return 0;
                 }
@@ -1858,10 +2240,12 @@ static int em28xx_v4l2_close(struct file *filp)
                                         "0 (error=%i)\n", errCode);
                 }
         }
+
+        videobuf_mmap_free(&fh->vb_vidq);
+        videobuf_mmap_free(&fh->vb_vbiq);
         kfree(fh);
         dev->users--;
         wake_up_interruptible_nr(&dev->open, 1);
-        mutex_unlock(&dev->lock);
         return 0;
 }
 
@@ -1886,16 +2270,22 @@ em28xx_v4l2_read(struct file *filp, char __user *buf, size_t count,
          */
 
         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                mutex_lock(&dev->lock);
-                rc = res_get(fh);
-                mutex_unlock(&dev->lock);
-
-                if (unlikely(rc < 0))
-                        return rc;
+                if (res_locked(dev, EM28XX_RESOURCE_VIDEO))
+                        return -EBUSY;
 
                 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
                                         filp->f_flags & O_NONBLOCK);
         }
+
+
+        if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
+                if (!res_get(fh, EM28XX_RESOURCE_VBI))
+                        return -EBUSY;
+
+                return videobuf_read_stream(&fh->vb_vbiq, buf, count, pos, 0,
+                                        filp->f_flags & O_NONBLOCK);
+        }
+
         return 0;
 }
 
@@ -1913,17 +2303,17 @@ static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table *wait)
         if (rc < 0)
                 return rc;
 
-        mutex_lock(&dev->lock);
-        rc = res_get(fh);
-        mutex_unlock(&dev->lock);
-
-        if (unlikely(rc < 0))
-                return POLLERR;
-
-        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
+        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                if (!res_get(fh, EM28XX_RESOURCE_VIDEO))
+                        return POLLERR;
+                return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
+        } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
+                if (!res_get(fh, EM28XX_RESOURCE_VBI))
+                        return POLLERR;
+                return videobuf_poll_stream(filp, &fh->vb_vbiq, wait);
+        } else {
                 return POLLERR;
-
-        return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
+        }
 }
 
 /*
@@ -1939,14 +2329,10 @@ static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
         if (rc < 0)
                 return rc;
 
-        mutex_lock(&dev->lock);
-        rc = res_get(fh);
-        mutex_unlock(&dev->lock);
-
-        if (unlikely(rc < 0))
-                return rc;
-
-        rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
+        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
+        else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
+                rc = videobuf_mmap_mapper(&fh->vb_vbiq, vma);
 
         em28xx_videodbg("vma start=0x%08lx, size=%ld, ret=%d\n",
                 (unsigned long)vma->vm_start,
@@ -1972,6 +2358,8 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
         .vidioc_g_fmt_vid_cap       = vidioc_g_fmt_vid_cap,
         .vidioc_try_fmt_vid_cap     = vidioc_try_fmt_vid_cap,
         .vidioc_s_fmt_vid_cap       = vidioc_s_fmt_vid_cap,
+        .vidioc_g_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
+        .vidioc_s_fmt_vbi_cap       = vidioc_s_fmt_vbi_cap,
         .vidioc_g_audio             = vidioc_g_audio,
         .vidioc_s_audio             = vidioc_s_audio,
         .vidioc_cropcap             = vidioc_cropcap,
@@ -1984,6 +2372,7 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
         .vidioc_querybuf            = vidioc_querybuf,
         .vidioc_qbuf                = vidioc_qbuf,
         .vidioc_dqbuf               = vidioc_dqbuf,
+        .vidioc_g_std               = vidioc_g_std,
         .vidioc_s_std               = vidioc_s_std,
         .vidioc_g_parm              = vidioc_g_parm,
         .vidioc_s_parm              = vidioc_s_parm,
@@ -2105,13 +2494,10 @@ int em28xx_register_analog_devices(struct em28xx *dev)
         dev->mute = 1;
         dev->volume = 0x1f;
 
-        /* enable vbi capturing */
-
 /*      em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */
         val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK);
         em28xx_write_reg(dev, EM28XX_R0F_XCLK,
                          (EM28XX_XCLK_AUDIO_UNMUTE | val));
-        em28xx_write_reg(dev, EM28XX_R11_VINCTRL, 0x51);
 
         em28xx_set_outfmt(dev);
         em28xx_colorlevels_set_default(dev);
@@ -2134,14 +2520,17 @@ int em28xx_register_analog_devices(struct em28xx *dev)
         }
 
         /* Allocate and fill vbi video_device struct */
-        dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template, "vbi");
+        if (em28xx_vbi_supported(dev) == 1) {
+                dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template,
+                                                "vbi");
 
-        /* register v4l2 vbi video_device */
-        ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
-                                        vbi_nr[dev->devno]);
-        if (ret < 0) {
-                em28xx_errdev("unable to register vbi device\n");
-                return ret;
+                /* register v4l2 vbi video_device */
+                ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
+                                            vbi_nr[dev->devno]);
+                if (ret < 0) {
+                        em28xx_errdev("unable to register vbi device\n");
+                        return ret;
+                }
         }
 
         if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
@@ -2161,8 +2550,12 @@ int em28xx_register_analog_devices(struct em28xx *dev)
                             dev->radio_dev->num);
         }
 
-        em28xx_info("V4L2 device registered as /dev/video%d and /dev/vbi%d\n",
-                                dev->vdev->num, dev->vbi_dev->num);
+        em28xx_info("V4L2 video device registered as /dev/video%d\n",
+                                dev->vdev->num);
+
+        if (dev->vbi_dev)
+                em28xx_info("V4L2 VBI device registered as /dev/vbi%d\n",
+                            dev->vbi_dev->num);
 
         return 0;
 }
diff --git a/drivers/media/video/em28xx/em28xx.h b/drivers/media/video/em28xx/em28xx.h
index 0f2ba9a40d17..0a73e8bf0d6e 100644
--- a/drivers/media/video/em28xx/em28xx.h
+++ b/drivers/media/video/em28xx/em28xx.h
@@ -109,6 +109,7 @@
 #define EM2882_BOARD_EVGA_INDTUBE                 70
 #define EM2820_BOARD_SILVERCREST_WEBCAM           71
 #define EM2861_BOARD_GADMEI_UTV330PLUS           72
+#define EM2870_BOARD_REDDO_DVB_C_USB_BOX          73
 
 /* Limits minimum and default number of buffers */
 #define EM28XX_MIN_BUF 4
@@ -214,7 +215,8 @@ struct em28xx_usb_isoc_ctl {
         int                             tmp_buf_len;
 
                 /* Stores already requested buffers */
-        struct em28xx_buffer            *buf;
+        struct em28xx_buffer            *vid_buf;
+        struct em28xx_buffer            *vbi_buf;
 
                 /* Stores the number of received fields */
         int                             nfields;
@@ -443,6 +445,10 @@ enum em28xx_dev_state {
 #define EM28XX_AUDIO   0x10
 #define EM28XX_DVB     0x20
 
+/* em28xx resource types (used for res_get/res_lock etc */
+#define EM28XX_RESOURCE_VIDEO 0x01
+#define EM28XX_RESOURCE_VBI   0x02
+
 struct em28xx_audio {
         char name[50];
         char *transfer_buffer[EM28XX_AUDIO_BUFS];
@@ -463,10 +469,11 @@ struct em28xx;
 
 struct em28xx_fh {
         struct em28xx *dev;
-        unsigned int  stream_on:1;      /* Locks streams */
         int           radio;
+        unsigned int  resources;
 
         struct videobuf_queue        vb_vidq;
+        struct videobuf_queue        vb_vbiq;
 
         enum v4l2_buf_type           type;
 };
@@ -493,7 +500,6 @@ struct em28xx {
         /* Vinmode/Vinctl used at the driver */
         int vinmode, vinctl;
 
-        unsigned int stream_on:1;       /* Locks streams */
         unsigned int has_audio_class:1;
         unsigned int has_alsa_audio:1;
 
@@ -544,6 +550,12 @@ struct em28xx {
         enum em28xx_dev_state state;
         enum em28xx_io_method io;
 
+        /* vbi related state tracking */
+        int capture_type;
+        int vbi_read;
+        unsigned char cur_field;
+
+
         struct work_struct         request_module_wk;
 
         /* locks */
@@ -555,10 +567,14 @@ struct em28xx {
         struct video_device *vbi_dev;
         struct video_device *radio_dev;
 
+        /* resources in use */
+        unsigned int resources;
+
         unsigned char eedata[256];
 
         /* Isoc control struct */
         struct em28xx_dmaqueue vidq;
+        struct em28xx_dmaqueue vbiq;
         struct em28xx_usb_isoc_ctl isoc_ctl;
         spinlock_t slock;
 
@@ -639,6 +655,7 @@ int em28xx_audio_setup(struct em28xx *dev);
 
 int em28xx_colorlevels_set_default(struct em28xx *dev);
 int em28xx_capture_start(struct em28xx *dev, int start);
+int em28xx_vbi_supported(struct em28xx *dev);
 int em28xx_set_outfmt(struct em28xx *dev);
 int em28xx_resolution_set(struct em28xx *dev);
 int em28xx_set_alternate(struct em28xx *dev);
@@ -686,6 +703,9 @@ void em28xx_deregister_snapshot_button(struct em28xx *dev);
 int em28xx_ir_init(struct em28xx *dev);
 int em28xx_ir_fini(struct em28xx *dev);
 
+/* Provided by em28xx-vbi.c */
+extern struct videobuf_queue_ops em28xx_vbi_qops;
+
 /* printk macros */
 
 #define em28xx_err(fmt, arg...) do {\
diff --git a/drivers/media/video/et61x251/et61x251_core.c b/drivers/media/video/et61x251/et61x251_core.c
index d1c1e457f0b9..74092f436be6 100644
--- a/drivers/media/video/et61x251/et61x251_core.c
+++ b/drivers/media/video/et61x251/et61x251_core.c
@@ -1379,8 +1379,10 @@ et61x251_read(struct file* filp, char __user * buf,
                             (!list_empty(&cam->outqueue)) ||
                             (cam->state & DEV_DISCONNECTED) ||
                             (cam->state & DEV_MISCONFIGURED),
-                            cam->module_param.frame_timeout *
-                            1000 * msecs_to_jiffies(1) );
+                            msecs_to_jiffies(
+                                cam->module_param.frame_timeout * 1000
+                            )
+                          );
                 if (timeout < 0) {
                         mutex_unlock(&cam->fileop_mutex);
                         return timeout;
diff --git a/drivers/media/video/gspca/Kconfig b/drivers/media/video/gspca/Kconfig
index 8897283b0bb4..fe2e490ebc52 100644
--- a/drivers/media/video/gspca/Kconfig
+++ b/drivers/media/video/gspca/Kconfig
@@ -19,6 +19,7 @@ if USB_GSPCA && VIDEO_V4L2
 
 source "drivers/media/video/gspca/m5602/Kconfig"
 source "drivers/media/video/gspca/stv06xx/Kconfig"
+source "drivers/media/video/gspca/gl860/Kconfig"
 
 config USB_GSPCA_CONEX
         tristate "Conexant Camera Driver"
diff --git a/drivers/media/video/gspca/Makefile b/drivers/media/video/gspca/Makefile
index 035616b5e867..b7420818037e 100644
--- a/drivers/media/video/gspca/Makefile
+++ b/drivers/media/video/gspca/Makefile
@@ -58,3 +58,4 @@ gspca_zc3xx-objs    := zc3xx.o
 
 obj-$(CONFIG_USB_M5602)   += m5602/
 obj-$(CONFIG_USB_STV06XX) += stv06xx/
+obj-$(CONFIG_USB_GL860)   += gl860/
diff --git a/drivers/media/video/gspca/gl860/Kconfig b/drivers/media/video/gspca/gl860/Kconfig
new file mode 100644
index 000000000000..22772f53ec7b
--- /dev/null
+++ b/drivers/media/video/gspca/gl860/Kconfig
@@ -0,0 +1,8 @@
+config USB_GL860
+        tristate "GL860 USB Camera Driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for cameras based on the GL860 chip.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_gl860.
diff --git a/drivers/media/video/gspca/gl860/Makefile b/drivers/media/video/gspca/gl860/Makefile
new file mode 100644
index 000000000000..13c9403cc87d
--- /dev/null
+++ b/drivers/media/video/gspca/gl860/Makefile
@@ -0,0 +1,10 @@
+obj-$(CONFIG_USB_GL860) += gspca_gl860.o
+
+gspca_gl860-objs := gl860.o \
+                    gl860-mi1320.o \
+                    gl860-ov2640.o \
+                    gl860-ov9655.o \
+                    gl860-mi2020.o
+
+EXTRA_CFLAGS += -Idrivers/media/video/gspca
+
diff --git a/drivers/media/video/gspca/gl860/gl860-mi1320.c b/drivers/media/video/gspca/gl860/gl860-mi1320.c
new file mode 100644
index 000000000000..39f6261c1a0c
--- /dev/null
+++ b/drivers/media/video/gspca/gl860/gl860-mi1320.c
@@ -0,0 +1,537 @@
+/* @file gl860-mi1320.c
+ * @author Olivier LORIN from my logs
+ * @date 2009-08-27
+ *
+ * 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
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Sensor : MI1320 */
+
+#include "gl860.h"
+
+static struct validx tbl_common[] = {
+        {0xba00, 0x00f0}, {0xba00, 0x00f1}, {0xba51, 0x0066}, {0xba02, 0x00f1},
+        {0xba05, 0x0067}, {0xba05, 0x00f1}, {0xbaa0, 0x0065}, {0xba00, 0x00f1},
+        {0xffff, 0xffff},
+        {0xba00, 0x00f0}, {0xba02, 0x00f1}, {0xbafa, 0x0028}, {0xba02, 0x00f1},
+        {0xba00, 0x00f0}, {0xba01, 0x00f1}, {0xbaf0, 0x0006}, {0xba0e, 0x00f1},
+        {0xba70, 0x0006}, {0xba0e, 0x00f1},
+        {0xffff, 0xffff},
+        {0xba74, 0x0006}, {0xba0e, 0x00f1},
+        {0xffff, 0xffff},
+        {0x0061, 0x0000}, {0x0068, 0x000d},
+};
+
+static struct validx tbl_init_at_startup[] = {
+        {0x0000, 0x0000}, {0x0010, 0x0010},
+        {35, 0xffff},
+        {0x0008, 0x00c0}, {0x0001, 0x00c1}, {0x0001, 0x00c2}, {0x0020, 0x0006},
+        {0x006a, 0x000d},
+};
+
+static struct validx tbl_sensor_settings_common[] = {
+        {0x0010, 0x0010}, {0x0003, 0x00c1}, {0x0042, 0x00c2}, {0x0040, 0x0000},
+        {0x006a, 0x0007}, {0x006a, 0x000d}, {0x0063, 0x0006},
+};
+static struct validx tbl_sensor_settings_1280[] = {
+        {0xba00, 0x00f0}, {0xba00, 0x00f1}, {0xba5a, 0x0066}, {0xba02, 0x00f1},
+        {0xba05, 0x0067}, {0xba05, 0x00f1}, {0xba20, 0x0065}, {0xba00, 0x00f1},
+};
+static struct validx tbl_sensor_settings_800[] = {
+        {0xba00, 0x00f0}, {0xba00, 0x00f1}, {0xba5a, 0x0066}, {0xba02, 0x00f1},
+        {0xba05, 0x0067}, {0xba05, 0x00f1}, {0xba20, 0x0065}, {0xba00, 0x00f1},
+};
+static struct validx tbl_sensor_settings_640[] = {
+        {0xba00, 0x00f0}, {0xba00, 0x00f1}, {0xbaa0, 0x0065}, {0xba00, 0x00f1},
+        {0xba51, 0x0066}, {0xba02, 0x00f1}, {0xba05, 0x0067}, {0xba05, 0x00f1},
+        {0xba20, 0x0065}, {0xba00, 0x00f1},
+};
+static struct validx tbl_post_unset_alt[] = {
+        {0xba00, 0x00f0}, {0xba00, 0x00f1}, {0xbaa0, 0x0065}, {0xba00, 0x00f1},
+        {0x0061, 0x0000}, {0x0068, 0x000d},
+};
+
+static u8 *tbl_1280[] = {
+        "\x0d\x80\xf1\x08\x03\x04\xf1\x00" "\x04\x05\xf1\x02\x05\x00\xf1\xf1"
+        "\x06\x00\xf1\x0d\x20\x01\xf1\x00" "\x21\x84\xf1\x00\x0d\x00\xf1\x08"
+        "\xf0\x00\xf1\x01\x34\x00\xf1\x00" "\x9b\x43\xf1\x00\xa6\x05\xf1\x00"
+        "\xa9\x04\xf1\x00\xa1\x05\xf1\x00" "\xa4\x04\xf1\x00\xae\x0a\xf1\x08"
+        ,
+        "\xf0\x00\xf1\x02\x3a\x05\xf1\xf1" "\x3c\x05\xf1\xf1\x59\x01\xf1\x47"
+        "\x5a\x01\xf1\x88\x5c\x0a\xf1\x06" "\x5d\x0e\xf1\x0a\x64\x5e\xf1\x1c"
+        "\xd2\x00\xf1\xcf\xcb\x00\xf1\x01"
+        ,
+        "\xd3\x02\xd4\x28\xd5\x01\xd0\x02" "\xd1\x18\xd2\xc1"
+};
+
+static u8 *tbl_800[] = {
+        "\x0d\x80\xf1\x08\x03\x03\xf1\xc0" "\x04\x05\xf1\x02\x05\x00\xf1\xf1"
+        "\x06\x00\xf1\x0d\x20\x01\xf1\x00" "\x21\x84\xf1\x00\x0d\x00\xf1\x08"
+        "\xf0\x00\xf1\x01\x34\x00\xf1\x00" "\x9b\x43\xf1\x00\xa6\x05\xf1\x00"
+        "\xa9\x03\xf1\xc0\xa1\x03\xf1\x20" "\xa4\x02\xf1\x5a\xae\x0a\xf1\x08"
+        ,
+        "\xf0\x00\xf1\x02\x3a\x05\xf1\xf1" "\x3c\x05\xf1\xf1\x59\x01\xf1\x47"
+        "\x5a\x01\xf1\x88\x5c\x0a\xf1\x06" "\x5d\x0e\xf1\x0a\x64\x5e\xf1\x1c"
+        "\xd2\x00\xf1\xcf\xcb\x00\xf1\x01"
+        ,
+        "\xd3\x02\xd4\x18\xd5\x21\xd0\x02" "\xd1\x10\xd2\x59"
+};
+
+static u8 *tbl_640[] = {
+        "\x0d\x80\xf1\x08\x03\x04\xf1\x04" "\x04\x05\xf1\x02\x07\x01\xf1\x7c"
+        "\x08\x00\xf1\x0e\x21\x80\xf1\x00" "\x0d\x00\xf1\x08\xf0\x00\xf1\x01"
+        "\x34\x10\xf1\x10\x3a\x43\xf1\x00" "\xa6\x05\xf1\x02\xa9\x04\xf1\x04"
+        "\xa7\x02\xf1\x81\xaa\x01\xf1\xe2" "\xae\x0c\xf1\x09"
+        ,
+        "\xf0\x00\xf1\x02\x39\x03\xf1\xfc" "\x3b\x04\xf1\x04\x57\x01\xf1\xb6"
+        "\x58\x02\xf1\x0d\x5c\x1f\xf1\x19" "\x5d\x24\xf1\x1e\x64\x5e\xf1\x1c"
+        "\xd2\x00\xf1\x00\xcb\x00\xf1\x01"
+        ,
+        "\xd3\x02\xd4\x10\xd5\x81\xd0\x02" "\xd1\x08\xd2\xe1"
+};
+
+static s32 tbl_sat[] = {0x25, 0x1d, 0x15, 0x0d, 0x05, 0x4d, 0x55, 0x5d, 0x2d};
+static s32 tbl_bright[] = {0, 8, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70};
+static s32 tbl_backlight[] = {0x0e, 0x06, 0x02};
+
+static s32 tbl_cntr1[] = {
+        0x90, 0x98, 0xa0, 0xa8, 0xb0, 0xb8, 0xc0, 0xc8, 0xd0, 0xe0, 0xf0};
+static s32 tbl_cntr2[] = {
+        0x70, 0x68, 0x60, 0x58, 0x50, 0x48, 0x40, 0x38, 0x30, 0x20, 0x10};
+
+static u8 dat_wbalNL[] =
+        "\xf0\x00\xf1\x01\x05\x00\xf1\x06" "\x3b\x04\xf1\x2a\x47\x10\xf1\x10"
+        "\x9d\x3c\xf1\xae\xaf\x10\xf1\x00" "\xf0\x00\xf1\x02\x2f\x91\xf1\x20"
+        "\x9c\x91\xf1\x20\x37\x03\xf1\x00" "\x9d\xc5\xf1\x0f\xf0\x00\xf1\x00";
+
+static u8 dat_wbalLL[] =
+        "\xf0\x00\xf1\x01\x05\x00\xf1\x0c" "\x3b\x04\xf1\x2a\x47\x40\xf1\x40"
+        "\x9d\x20\xf1\xae\xaf\x10\xf1\x00" "\xf0\x00\xf1\x02\x2f\xd1\xf1\x00"
+        "\x9c\xd1\xf1\x00\x37\x03\xf1\x00" "\x9d\xc5\xf1\x3f\xf0\x00\xf1\x00";
+
+static u8 dat_wbalBL[] =
+        "\xf0\x00\xf1\x01\x05\x00\xf1\x06" "\x47\x10\xf1\x30\x9d\x3c\xf1\xae"
+        "\xaf\x10\xf1\x00\xf0\x00\xf1\x02" "\x2f\x91\xf1\x20\x9c\x91\xf1\x20"
+        "\x37\x03\xf1\x00\x9d\xc5\xf1\x2f" "\xf0\x00\xf1\x00";
+
+static u8 dat_hvflip1[] = {0xf0, 0x00, 0xf1, 0x00};
+
+static u8 s000[] =
+        "\x00\x01\x07\x6a\x06\x63\x0d\x6a" "\xc0\x00\x10\x10\xc1\x03\xc2\x42"
+        "\xd8\x04\x58\x00\x04\x02";
+static u8 s001[] =
+        "\x0d\x00\xf1\x0b\x0d\x00\xf1\x08" "\x35\x00\xf1\x22\x68\x00\xf1\x5d"
+        "\xf0\x00\xf1\x01\x06\x70\xf1\x0e" "\xf0\x00\xf1\x02\xdd\x18\xf1\xe0";
+static u8 s002[] =
+        "\x05\x01\xf1\x84\x06\x00\xf1\x44" "\x07\x00\xf1\xbe\x08\x00\xf1\x1e"
+        "\x20\x01\xf1\x03\x21\x84\xf1\x00" "\x22\x0d\xf1\x0f\x24\x80\xf1\x00"
+        "\x34\x18\xf1\x2d\x35\x00\xf1\x22" "\x43\x83\xf1\x83\x59\x00\xf1\xff";
+static u8 s003[] =
+        "\xf0\x00\xf1\x02\x39\x06\xf1\x8c" "\x3a\x06\xf1\x8c\x3b\x03\xf1\xda"
+        "\x3c\x05\xf1\x30\x57\x01\xf1\x0c" "\x58\x01\xf1\x42\x59\x01\xf1\x0c"
+        "\x5a\x01\xf1\x42\x5c\x13\xf1\x0e" "\x5d\x17\xf1\x12\x64\x1e\xf1\x1c";
+static u8 s004[] =
+        "\xf0\x00\xf1\x02\x24\x5f\xf1\x20" "\x28\xea\xf1\x02\x5f\x41\xf1\x43";
+static u8 s005[] =
+        "\x02\x00\xf1\xee\x03\x29\xf1\x1a" "\x04\x02\xf1\xa4\x09\x00\xf1\x68"
+        "\x0a\x00\xf1\x2a\x0b\x00\xf1\x04" "\x0c\x00\xf1\x93\x0d\x00\xf1\x82"
+        "\x0e\x00\xf1\x40\x0f\x00\xf1\x5f" "\x10\x00\xf1\x4e\x11\x00\xf1\x5b";
+static u8 s006[] =
+        "\x15\x00\xf1\xc9\x16\x00\xf1\x5e" "\x17\x00\xf1\x9d\x18\x00\xf1\x06"
+        "\x19\x00\xf1\x89\x1a\x00\xf1\x12" "\x1b\x00\xf1\xa1\x1c\x00\xf1\xe4"
+        "\x1d\x00\xf1\x7a\x1e\x00\xf1\x64" "\xf6\x00\xf1\x5f";
+static u8 s007[] =
+        "\xf0\x00\xf1\x01\x53\x09\xf1\x03" "\x54\x3d\xf1\x1c\x55\x99\xf1\x72"
+        "\x56\xc1\xf1\xb1\x57\xd8\xf1\xce" "\x58\xe0\xf1\x00\xdc\x0a\xf1\x03"
+        "\xdd\x45\xf1\x20\xde\xae\xf1\x82" "\xdf\xdc\xf1\xc9\xe0\xf6\xf1\xea"
+        "\xe1\xff\xf1\x00";
+static u8 s008[] =
+        "\xf0\x00\xf1\x01\x80\x00\xf1\x06" "\x81\xf6\xf1\x08\x82\xfb\xf1\xf7"
+        "\x83\x00\xf1\xfe\xb6\x07\xf1\x03" "\xb7\x18\xf1\x0c\x84\xfb\xf1\x06"
+        "\x85\xfb\xf1\xf9\x86\x00\xf1\xff" "\xb8\x07\xf1\x04\xb9\x16\xf1\x0a";
+static u8 s009[] =
+        "\x87\xfa\xf1\x05\x88\xfc\xf1\xf9" "\x89\x00\xf1\xff\xba\x06\xf1\x03"
+        "\xbb\x17\xf1\x09\x8a\xe8\xf1\x14" "\x8b\xf7\xf1\xf0\x8c\xfd\xf1\xfa"
+        "\x8d\x00\xf1\x00\xbc\x05\xf1\x01" "\xbd\x0c\xf1\x08\xbe\x00\xf1\x14";
+static u8 s010[] =
+        "\x8e\xea\xf1\x13\x8f\xf7\xf1\xf2" "\x90\xfd\xf1\xfa\x91\x00\xf1\x00"
+        "\xbf\x05\xf1\x01\xc0\x0a\xf1\x08" "\xc1\x00\xf1\x0c\x92\xed\xf1\x0f"
+        "\x93\xf9\xf1\xf4\x94\xfe\xf1\xfb" "\x95\x00\xf1\x00\xc2\x04\xf1\x01"
+        "\xc3\x0a\xf1\x07\xc4\x00\xf1\x10";
+static u8 s011[] =
+        "\xf0\x00\xf1\x01\x05\x00\xf1\x06" "\x25\x00\xf1\x55\x34\x10\xf1\x10"
+        "\x35\xf0\xf1\x10\x3a\x02\xf1\x03" "\x3b\x04\xf1\x2a\x9b\x43\xf1\x00"
+        "\xa4\x03\xf1\xc0\xa7\x02\xf1\x81";
+
+static int  mi1320_init_at_startup(struct gspca_dev *gspca_dev);
+static int  mi1320_configure_alt(struct gspca_dev *gspca_dev);
+static int  mi1320_init_pre_alt(struct gspca_dev *gspca_dev);
+static int  mi1320_init_post_alt(struct gspca_dev *gspca_dev);
+static void mi1320_post_unset_alt(struct gspca_dev *gspca_dev);
+static int  mi1320_sensor_settings(struct gspca_dev *gspca_dev);
+static int  mi1320_camera_settings(struct gspca_dev *gspca_dev);
+/*==========================================================================*/
+
+void mi1320_init_settings(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->vcur.backlight  =  0;
+        sd->vcur.brightness =  0;
+        sd->vcur.sharpness  =  6;
+        sd->vcur.contrast   = 10;
+        sd->vcur.gamma      = 20;
+        sd->vcur.hue        =  0;
+        sd->vcur.saturation =  6;
+        sd->vcur.whitebal   =  0;
+        sd->vcur.mirror     = 0;
+        sd->vcur.flip       = 0;
+        sd->vcur.AC50Hz     = 1;
+
+        sd->vmax.backlight  =  2;
+        sd->vmax.brightness =  8;
+        sd->vmax.sharpness  =  7;
+        sd->vmax.contrast   =  0; /* 10 but not working with tihs driver */
+        sd->vmax.gamma      = 40;
+        sd->vmax.hue        =  5 + 1;
+        sd->vmax.saturation =  8;
+        sd->vmax.whitebal   =  2;
+        sd->vmax.mirror     = 1;
+        sd->vmax.flip       = 1;
+        sd->vmax.AC50Hz     = 1;
+
+        sd->dev_camera_settings = mi1320_camera_settings;
+        sd->dev_init_at_startup = mi1320_init_at_startup;
+        sd->dev_configure_alt   = mi1320_configure_alt;
+        sd->dev_init_pre_alt    = mi1320_init_pre_alt;
+        sd->dev_post_unset_alt  = mi1320_post_unset_alt;
+}
+
+/*==========================================================================*/
+
+static void common(struct gspca_dev *gspca_dev)
+{
+        s32 n; /* reserved for FETCH macros */
+
+        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 22, s000);
+        ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x0000, 0, NULL);
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 32, s001);
+        n = fetch_validx(gspca_dev, tbl_common, ARRAY_SIZE(tbl_common));
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 48, s002);
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 48, s003);
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 16, s004);
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 48, s005);
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 44, s006);
+        keep_on_fetching_validx(gspca_dev, tbl_common,
+                                        ARRAY_SIZE(tbl_common), n);
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 52, s007);
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 48, s008);
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 48, s009);
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 56, s010);
+        keep_on_fetching_validx(gspca_dev, tbl_common,
+                                        ARRAY_SIZE(tbl_common), n);
+        ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 40, s011);
+        keep_on_fetching_validx(gspca_dev, tbl_common,
+                                        ARRAY_SIZE(tbl_common), n);
+}
+
+static int mi1320_init_at_startup(struct gspca_dev *gspca_dev)
+{
+        fetch_validx(gspca_dev, tbl_init_at_startup,
+                                ARRAY_SIZE(tbl_init_at_startup));
+
+        common(gspca_dev);
+
+/*      ctrl_out(gspca_dev, 0x40, 11, 0x0000, 0x0000, 0, NULL); */
+
+        return 0;
+}
+
+static int mi1320_init_pre_alt(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->mirrorMask = 0;
+
+        sd->vold.backlight  = -1;
+        sd->vold.brightness = -1;
+        sd->vold.sharpness  = -1;
+        sd->vold.contrast   = -1;
+        sd->vold.saturation = -1;
+        sd->vold.gamma    = -1;
+        sd->vold.hue      = -1;
+        sd->vold.whitebal = -1;
+        sd->vold.mirror   = -1;
+        sd->vold.flip     = -1;
+        sd->vold.AC50Hz   = -1;
+
+        common(gspca_dev);
+
+        mi1320_sensor_settings(gspca_dev);
+
+        mi1320_init_post_alt(gspca_dev);
+
+        return 0;
+}
+
+static int mi1320_init_post_alt(struct gspca_dev *gspca_dev)
+{
+        mi1320_camera_settings(gspca_dev);
+
+        return 0;
+}
+
+static int mi1320_sensor_settings(struct gspca_dev *gspca_dev)
+{
+        s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
+
+        ctrl_out(gspca_dev, 0x40, 5, 0x0001, 0x0000, 0, NULL);
+
+        fetch_validx(gspca_dev, tbl_sensor_settings_common,
+                                ARRAY_SIZE(tbl_sensor_settings_common));
+
+        switch (reso) {
+        case IMAGE_1280:
+                fetch_validx(gspca_dev, tbl_sensor_settings_1280,
+                                        ARRAY_SIZE(tbl_sensor_settings_1280));
+                ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 64, tbl_1280[0]);
+                ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 40, tbl_1280[1]);
+                ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, tbl_1280[2]);
+                break;
+
+        case IMAGE_800:
+                fetch_validx(gspca_dev, tbl_sensor_settings_800,
+                                        ARRAY_SIZE(tbl_sensor_settings_800));
+                ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 64, tbl_800[0]);
+                ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 40, tbl_800[1]);
+                ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, tbl_800[2]);
+                break;
+
+        default:
+                fetch_validx(gspca_dev, tbl_sensor_settings_640,
+                                        ARRAY_SIZE(tbl_sensor_settings_640));
+                ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 60, tbl_640[0]);
+                ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 40, tbl_640[1]);
+                ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, tbl_640[2]);
+                break;
+        }
+        return 0;
+}
+
+static int mi1320_configure_alt(struct gspca_dev *gspca_dev)
+{
+        s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
+
+        switch (reso) {
+        case IMAGE_640:
+                gspca_dev->alt = 3 + 1;
+                break;
+
+        case IMAGE_800:
+        case IMAGE_1280:
+                gspca_dev->alt = 1 + 1;
+                break;
+        }
+        return 0;
+}
+
+int mi1320_camera_settings(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        s32 backlight = sd->vcur.backlight;
+        s32 bright = sd->vcur.brightness;
+        s32 sharp  = sd->vcur.sharpness;
+        s32 cntr   = sd->vcur.contrast;
+        s32 gam    = sd->vcur.gamma;
+        s32 hue    = sd->vcur.hue;
+        s32 sat    = sd->vcur.saturation;
+        s32 wbal   = sd->vcur.whitebal;
+        s32 mirror = (((sd->vcur.mirror > 0) ^ sd->mirrorMask) > 0);
+        s32 flip   = (((sd->vcur.flip   > 0) ^ sd->mirrorMask) > 0);
+        s32 freq   = (sd->vcur.AC50Hz > 0);
+        s32 i;
+
+        if (freq != sd->vold.AC50Hz) {
+                sd->vold.AC50Hz = freq;
+
+                freq = 2 * (freq == 0);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba02, 0x00f1, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00       , 0x005b, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba01 + freq, 0x00f1, 0, NULL);
+        }
+
+        if (wbal != sd->vold.whitebal) {
+                sd->vold.whitebal = wbal;
+                if (wbal < 0 || wbal > sd->vmax.whitebal)
+                        wbal = 0;
+
+                for (i = 0; i < 2; i++) {
+                        if (wbal == 0) { /* Normal light */
+                                ctrl_out(gspca_dev, 0x40, 1,
+                                                0x0010, 0x0010, 0, NULL);
+                                ctrl_out(gspca_dev, 0x40, 1,
+                                                0x0003, 0x00c1, 0, NULL);
+                                ctrl_out(gspca_dev, 0x40, 1,
+                                                0x0042, 0x00c2, 0, NULL);
+                                ctrl_out(gspca_dev, 0x40, 3,
+                                                0xba00, 0x0200, 48, dat_wbalNL);
+                        }
+
+                        if (wbal == 1) { /* Low light */
+                                ctrl_out(gspca_dev, 0x40, 1,
+                                                0x0010, 0x0010, 0, NULL);
+                                ctrl_out(gspca_dev, 0x40, 1,
+                                                0x0004, 0x00c1, 0, NULL);
+                                ctrl_out(gspca_dev, 0x40, 1,
+                                                0x0043, 0x00c2, 0, NULL);
+                                ctrl_out(gspca_dev, 0x40, 3,
+                                                0xba00, 0x0200, 48, dat_wbalLL);
+                        }
+
+                        if (wbal == 2) { /* Back light */
+                                ctrl_out(gspca_dev, 0x40, 1,
+                                                0x0010, 0x0010, 0, NULL);
+                                ctrl_out(gspca_dev, 0x40, 1,
+                                                0x0003, 0x00c1, 0, NULL);
+                                ctrl_out(gspca_dev, 0x40, 1,
+                                                0x0042, 0x00c2, 0, NULL);
+                                ctrl_out(gspca_dev, 0x40, 3,
+                                                0xba00, 0x0200, 44, dat_wbalBL);
+                        }
+                }
+        }
+
+        if (bright != sd->vold.brightness) {
+                sd->vold.brightness = bright;
+                if (bright < 0 || bright > sd->vmax.brightness)
+                        bright = 0;
+
+                bright = tbl_bright[bright];
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00 + bright, 0x0034, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00 + bright, 0x00f1, 0, NULL);
+        }
+
+        if (sat != sd->vold.saturation) {
+                sd->vold.saturation = sat;
+                if (sat < 0 || sat > sd->vmax.saturation)
+                        sat = 0;
+
+                sat = tbl_sat[sat];
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00      , 0x0025, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00 + sat, 0x00f1, 0, NULL);
+        }
+
+        if (sharp != sd->vold.sharpness) {
+                sd->vold.sharpness = sharp;
+                if (sharp < 0 || sharp > sd->vmax.sharpness)
+                        sharp = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00        , 0x0005, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00 + sharp, 0x00f1, 0, NULL);
+        }
+
+        if (hue != sd->vold.hue) {
+                /* 0=normal  1=NB  2="sepia"  3=negative  4=other  5=other2 */
+                if (hue < 0 || hue > sd->vmax.hue)
+                        hue = 0;
+                if (hue == sd->vmax.hue)
+                        sd->swapRB = 1;
+                else
+                        sd->swapRB = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba70, 0x00e2, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00 + hue * (hue < 6), 0x00f1,
+                                                        0, NULL);
+        }
+
+        if (backlight != sd->vold.backlight) {
+                sd->vold.backlight = backlight;
+                if (backlight < 0 || backlight > sd->vmax.backlight)
+                        backlight = 0;
+
+                backlight = tbl_backlight[backlight];
+                for (i = 0; i < 2; i++) {
+                        ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0xba74, 0x0006, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0xba80 + backlight, 0x00f1,
+                                                                0, NULL);
+                }
+        }
+
+        if (hue != sd->vold.hue) {
+                sd->vold.hue = hue;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba70, 0x00e2, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00 + hue * (hue < 6), 0x00f1,
+                                                        0, NULL);
+        }
+
+        if (mirror != sd->vold.mirror || flip != sd->vold.flip) {
+                u8 dat_hvflip2[4] = {0x20, 0x01, 0xf1, 0x00};
+                sd->vold.mirror = mirror;
+                sd->vold.flip = flip;
+
+                dat_hvflip2[3] = flip + 2 * mirror;
+                ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 4, dat_hvflip1);
+                ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 4, dat_hvflip2);
+        }
+
+        if (gam != sd->vold.gamma) {
+                sd->vold.gamma = gam;
+                if (gam < 0 || gam > sd->vmax.gamma)
+                        gam = 0;
+
+                gam = 2 * gam;
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba04      , 0x003b, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba02 + gam, 0x00f1, 0, NULL);
+        }
+
+        if (cntr != sd->vold.contrast) {
+                sd->vold.contrast = cntr;
+                if (cntr < 0 || cntr > sd->vmax.contrast)
+                        cntr = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00 + tbl_cntr1[cntr], 0x0035,
+                                                        0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0xba00 + tbl_cntr2[cntr], 0x00f1,
+                                                        0, NULL);
+        }
+
+        return 0;
+}
+
+static void mi1320_post_unset_alt(struct gspca_dev *gspca_dev)
+{
+        ctrl_out(gspca_dev, 0x40, 5, 0x0000, 0x0000, 0, NULL);
+
+        fetch_validx(gspca_dev, tbl_post_unset_alt,
+                                ARRAY_SIZE(tbl_post_unset_alt));
+}
diff --git a/drivers/media/video/gspca/gl860/gl860-mi2020.c b/drivers/media/video/gspca/gl860/gl860-mi2020.c
new file mode 100644
index 000000000000..ffb09fed3e8c
--- /dev/null
+++ b/drivers/media/video/gspca/gl860/gl860-mi2020.c
@@ -0,0 +1,937 @@
+/* @file gl860-mi2020.c
+ * @author Olivier LORIN, from Ice/Soro2005's logs(A), Fret_saw/Hulkie's
+ * logs(B) and Tricid"s logs(C). With the help of Kytrix/BUGabundo/Blazercist.
+ * @date 2009-08-27
+ *
+ * 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
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Sensor : MI2020 */
+
+#include "gl860.h"
+
+static u8 dat_bright1[] = {0x8c, 0xa2, 0x06};
+static u8 dat_bright3[] = {0x8c, 0xa1, 0x02};
+static u8 dat_bright4[] = {0x90, 0x00, 0x0f};
+static u8 dat_bright5[] = {0x8c, 0xa1, 0x03};
+static u8 dat_bright6[] = {0x90, 0x00, 0x05};
+
+static u8 dat_dummy1[] = {0x90, 0x00, 0x06};
+/*static u8 dummy2[] = {0x8c, 0xa1, 0x02};*/
+/*static u8 dummy3[] = {0x90, 0x00, 0x1f};*/
+
+static u8 dat_hvflip1[] = {0x8c, 0x27, 0x19};
+static u8 dat_hvflip3[] = {0x8c, 0x27, 0x3b};
+static u8 dat_hvflip5[] = {0x8c, 0xa1, 0x03};
+static u8 dat_hvflip6[] = {0x90, 0x00, 0x06};
+
+static u8 dat_freq1[] = { 0x8c, 0xa4, 0x04 };
+
+static u8 dat_multi5[] = { 0x8c, 0xa1, 0x03 };
+static u8 dat_multi6[] = { 0x90, 0x00, 0x05 };
+
+static struct validx tbl_common_a[] = {
+        {0x0000, 0x0000},
+        {1, 0xffff}, /* msleep(35); */
+        {0x006a, 0x0007}, {0x0063, 0x0006}, {0x006a, 0x000d}, {0x0000, 0x00c0},
+        {0x0010, 0x0010}, {0x0003, 0x00c1}, {0x0042, 0x00c2}, {0x0004, 0x00d8},
+        {0x0000, 0x0058}, {0x0002, 0x0004}, {0x0041, 0x0000},
+};
+
+static struct validx tbl_common_b[] = {
+        {0x006a, 0x0007},
+        {35, 0xffff},
+        {0x00ef, 0x0006},
+        {35, 0xffff},
+        {0x006a, 0x000d},
+        {35, 0xffff},
+        {0x0000, 0x00c0}, {0x0010, 0x0010}, {0x0003, 0x00c1}, {0x0042, 0x00c2},
+        {0x0004, 0x00d8}, {0x0000, 0x0058}, {0x0041, 0x0000},
+};
+
+static struct idxdata tbl_common_c[] = {
+        {0x32, "\x02\x00\x08"}, {0x33, "\xf4\x03\x1d"},
+        {6, "\xff\xff\xff"}, /* 12 */
+        {0x34, "\x1e\x8f\x09"}, {0x34, "\x1c\x01\x28"}, {0x34, "\x1e\x8f\x09"},
+        {2, "\xff\xff\xff"}, /* - */
+        {0x34, "\x1e\x8f\x09"}, {0x32, "\x14\x06\xe6"}, {0x33, "\x8c\x22\x23"},
+        {0x33, "\x90\x00\x00"}, {0x33, "\x8c\xa2\x0f"}, {0x33, "\x90\x00\x0d"},
+        {0x33, "\x8c\xa2\x10"}, {0x33, "\x90\x00\x0b"}, {0x33, "\x8c\xa2\x11"},
+        {0x33, "\x90\x00\x07"}, {0x33, "\xf4\x03\x1d"}, {0x35, "\xa2\x00\xe2"},
+        {0x33, "\x8c\xab\x05"}, {0x33, "\x90\x00\x01"}, {0x32, "\x6e\x00\x86"},
+        {0x32, "\x70\x0f\xaa"}, {0x32, "\x72\x0f\xe4"}, {0x33, "\x8c\xa3\x4a"},
+        {0x33, "\x90\x00\x5a"}, {0x33, "\x8c\xa3\x4b"}, {0x33, "\x90\x00\xa6"},
+        {0x33, "\x8c\xa3\x61"}, {0x33, "\x90\x00\xc8"}, {0x33, "\x8c\xa3\x62"},
+        {0x33, "\x90\x00\xe1"}, {0x34, "\xce\x01\xa8"}, {0x34, "\xd0\x66\x33"},
+        {0x34, "\xd2\x31\x9a"}, {0x34, "\xd4\x94\x63"}, {0x34, "\xd6\x4b\x25"},
+        {0x34, "\xd8\x26\x70"}, {0x34, "\xda\x72\x4c"}, {0x34, "\xdc\xff\x04"},
+        {0x34, "\xde\x01\x5b"}, {0x34, "\xe6\x01\x13"}, {0x34, "\xee\x0b\xf0"},
+        {0x34, "\xf6\x0b\xa4"}, {0x35, "\x00\xf6\xe7"}, {0x35, "\x08\x0d\xfd"},
+        {0x35, "\x10\x25\x63"}, {0x35, "\x18\x35\x6c"}, {0x35, "\x20\x42\x7e"},
+        {0x35, "\x28\x19\x44"}, {0x35, "\x30\x39\xd4"}, {0x35, "\x38\xf5\xa8"},
+        {0x35, "\x4c\x07\x90"}, {0x35, "\x44\x07\xb8"}, {0x35, "\x5c\x06\x88"},
+        {0x35, "\x54\x07\xff"}, {0x34, "\xe0\x01\x52"}, {0x34, "\xe8\x00\xcc"},
+        {0x34, "\xf0\x0d\x83"}, {0x34, "\xf8\x0c\xb3"}, {0x35, "\x02\xfe\xba"},
+        {0x35, "\x0a\x04\xe0"}, {0x35, "\x12\x1c\x63"}, {0x35, "\x1a\x2b\x5a"},
+        {0x35, "\x22\x32\x5e"}, {0x35, "\x2a\x0d\x28"}, {0x35, "\x32\x2c\x02"},
+        {0x35, "\x3a\xf4\xfa"}, {0x35, "\x4e\x07\xef"}, {0x35, "\x46\x07\x88"},
+        {0x35, "\x5e\x07\xc1"}, {0x35, "\x56\x04\x64"}, {0x34, "\xe4\x01\x15"},
+        {0x34, "\xec\x00\x82"}, {0x34, "\xf4\x0c\xce"}, {0x34, "\xfc\x0c\xba"},
+        {0x35, "\x06\x1f\x02"}, {0x35, "\x0e\x02\xe3"}, {0x35, "\x16\x1a\x50"},
+        {0x35, "\x1e\x24\x39"}, {0x35, "\x26\x23\x4c"}, {0x35, "\x2e\xf9\x1b"},
+        {0x35, "\x36\x23\x19"}, {0x35, "\x3e\x12\x08"}, {0x35, "\x52\x07\x22"},
+        {0x35, "\x4a\x03\xd3"}, {0x35, "\x62\x06\x54"}, {0x35, "\x5a\x04\x5d"},
+        {0x34, "\xe2\x01\x04"}, {0x34, "\xea\x00\xa0"}, {0x34, "\xf2\x0c\xbc"},
+        {0x34, "\xfa\x0c\x5b"}, {0x35, "\x04\x17\xf2"}, {0x35, "\x0c\x02\x08"},
+        {0x35, "\x14\x28\x43"}, {0x35, "\x1c\x28\x62"}, {0x35, "\x24\x2b\x60"},
+        {0x35, "\x2c\x07\x33"}, {0x35, "\x34\x1f\xb0"}, {0x35, "\x3c\xed\xcd"},
+        {0x35, "\x50\x00\x06"}, {0x35, "\x48\x07\xff"}, {0x35, "\x60\x05\x89"},
+        {0x35, "\x58\x07\xff"}, {0x35, "\x40\x00\xa0"}, {0x35, "\x42\x00\x00"},
+        {0x32, "\x10\x01\xfc"}, {0x33, "\x8c\xa1\x18"}, {0x33, "\x90\x00\x3c"},
+        {1, "\xff\xff\xff"},
+        {0x33, "\x78\x00\x00"},
+        {1, "\xff\xff\xff"},
+        {0x35, "\xb8\x1f\x20"}, {0x33, "\x8c\xa2\x06"}, {0x33, "\x90\x00\x10"},
+        {0x33, "\x8c\xa2\x07"}, {0x33, "\x90\x00\x08"}, {0x33, "\x8c\xa2\x42"},
+        {0x33, "\x90\x00\x0b"}, {0x33, "\x8c\xa2\x4a"}, {0x33, "\x90\x00\x8c"},
+        {0x35, "\xba\xfa\x08"}, {0x33, "\x8c\xa2\x02"}, {0x33, "\x90\x00\x22"},
+        {0x33, "\x8c\xa2\x03"}, {0x33, "\x90\x00\xbb"},
+};
+
+static struct idxdata tbl_common_d[] = {
+        {0x33, "\x8c\x22\x2e"}, {0x33, "\x90\x00\xa0"}, {0x33, "\x8c\xa4\x08"},
+        {0x33, "\x90\x00\x1f"}, {0x33, "\x8c\xa4\x09"}, {0x33, "\x90\x00\x21"},
+        {0x33, "\x8c\xa4\x0a"}, {0x33, "\x90\x00\x25"}, {0x33, "\x8c\xa4\x0b"},
+        {0x33, "\x90\x00\x27"}, {0x33, "\x8c\x24\x11"}, {0x33, "\x90\x00\xa0"},
+        {0x33, "\x8c\x24\x13"}, {0x33, "\x90\x00\xc0"}, {0x33, "\x8c\x24\x15"},
+        {0x33, "\x90\x00\xa0"}, {0x33, "\x8c\x24\x17"}, {0x33, "\x90\x00\xc0"},
+};
+
+static struct idxdata tbl_common_e[] = {
+        {0x33, "\x8c\xa4\x04"}, {0x33, "\x90\x00\x80"}, {0x33, "\x8c\xa7\x9d"},
+        {0x33, "\x90\x00\x00"}, {0x33, "\x8c\xa7\x9e"}, {0x33, "\x90\x00\x00"},
+        {0x33, "\x8c\xa2\x0c"}, {0x33, "\x90\x00\x17"}, {0x33, "\x8c\xa2\x15"},
+        {0x33, "\x90\x00\x04"}, {0x33, "\x8c\xa2\x14"}, {0x33, "\x90\x00\x20"},
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x17"},
+        /* msleep(53); */
+        {0x33, "\x90\x21\x11"}, {0x33, "\x8c\x27\x1b"}, {0x33, "\x90\x02\x4f"},
+        {0x33, "\x8c\x27\x25"}, {0x33, "\x90\x06\x0f"}, {0x33, "\x8c\x27\x39"},
+        {0x33, "\x90\x21\x11"}, {0x33, "\x8c\x27\x3d"}, {0x33, "\x90\x01\x20"},
+        {0x33, "\x8c\x27\x47"}, {0x33, "\x90\x09\x4c"}, {0x33, "\x8c\x27\x03"},
+        {0x33, "\x90\x02\x84"}, {0x33, "\x8c\x27\x05"}, {0x33, "\x90\x01\xe2"},
+        {0x33, "\x8c\x27\x07"}, {0x33, "\x90\x06\x40"}, {0x33, "\x8c\x27\x09"},
+        {0x33, "\x90\x04\xb0"}, {0x33, "\x8c\x27\x0d"}, {0x33, "\x90\x00\x00"},
+        {0x33, "\x8c\x27\x0f"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x11"},
+        {0x33, "\x90\x04\xbd"}, {0x33, "\x8c\x27\x13"}, {0x33, "\x90\x06\x4d"},
+        {0x33, "\x8c\x27\x15"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x17"},
+        {0x33, "\x90\x21\x11"}, {0x33, "\x8c\x27\x19"}, {0x33, "\x90\x04\x6c"},
+        {0x33, "\x8c\x27\x1b"}, {0x33, "\x90\x02\x4f"}, {0x33, "\x8c\x27\x1d"},
+        {0x33, "\x90\x01\x02"}, {0x33, "\x8c\x27\x1f"}, {0x33, "\x90\x02\x79"},
+        {0x33, "\x8c\x27\x21"}, {0x33, "\x90\x01\x55"}, {0x33, "\x8c\x27\x23"},
+        {0x33, "\x90\x02\x85"}, {0x33, "\x8c\x27\x25"}, {0x33, "\x90\x06\x0f"},
+        {0x33, "\x8c\x27\x27"}, {0x33, "\x90\x20\x20"}, {0x33, "\x8c\x27\x29"},
+        {0x33, "\x90\x20\x20"}, {0x33, "\x8c\x27\x2b"}, {0x33, "\x90\x10\x20"},
+        {0x33, "\x8c\x27\x2d"}, {0x33, "\x90\x20\x07"}, {0x33, "\x8c\x27\x2f"},
+        {0x33, "\x90\x00\x04"}, {0x33, "\x8c\x27\x31"}, {0x33, "\x90\x00\x04"},
+        {0x33, "\x8c\x27\x33"}, {0x33, "\x90\x04\xbb"}, {0x33, "\x8c\x27\x35"},
+        {0x33, "\x90\x06\x4b"}, {0x33, "\x8c\x27\x37"}, {0x33, "\x90\x00\x00"},
+        {0x33, "\x8c\x27\x39"}, {0x33, "\x90\x21\x11"}, {0x33, "\x8c\x27\x3b"},
+        {0x33, "\x90\x00\x24"}, {0x33, "\x8c\x27\x3d"}, {0x33, "\x90\x01\x20"},
+        {0x33, "\x8c\x27\x41"}, {0x33, "\x90\x01\x69"}, {0x33, "\x8c\x27\x45"},
+        {0x33, "\x90\x04\xed"}, {0x33, "\x8c\x27\x47"}, {0x33, "\x90\x09\x4c"},
+        {0x33, "\x8c\x27\x51"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x53"},
+        {0x33, "\x90\x03\x20"}, {0x33, "\x8c\x27\x55"}, {0x33, "\x90\x00\x00"},
+        {0x33, "\x8c\x27\x57"}, {0x33, "\x90\x02\x58"}, {0x33, "\x8c\x27\x5f"},
+        {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x61"}, {0x33, "\x90\x06\x40"},
+        {0x33, "\x8c\x27\x63"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x65"},
+        {0x33, "\x90\x04\xb0"}, {0x33, "\x8c\x22\x2e"}, {0x33, "\x90\x00\xa1"},
+        {0x33, "\x8c\xa4\x08"}, {0x33, "\x90\x00\x1f"}, {0x33, "\x8c\xa4\x09"},
+        {0x33, "\x90\x00\x21"}, {0x33, "\x8c\xa4\x0a"}, {0x33, "\x90\x00\x25"},
+        {0x33, "\x8c\xa4\x0b"}, {0x33, "\x90\x00\x27"}, {0x33, "\x8c\x24\x11"},
+        {0x33, "\x90\x00\xa1"}, {0x33, "\x8c\x24\x13"}, {0x33, "\x90\x00\xc1"},
+        {0x33, "\x8c\x24\x15"},
+};
+
+static struct validx tbl_init_at_startup[] = {
+        {0x0000, 0x0000},
+        {53, 0xffff},
+        {0x0010, 0x0010},
+        {53, 0xffff},
+        {0x0008, 0x00c0},
+        {53, 0xffff},
+        {0x0001, 0x00c1},
+        {53, 0xffff},
+        {0x0001, 0x00c2},
+        {53, 0xffff},
+        {0x0020, 0x0006},
+        {53, 0xffff},
+        {0x006a, 0x000d},
+        {53, 0xffff},
+};
+
+static struct idxdata tbl_init_post_alt_low_a[] = {
+        {0x33, "\x8c\x27\x15"}, {0x33, "\x90\x00\x25"}, {0x33, "\x8c\x22\x2e"},
+        {0x33, "\x90\x00\x81"}, {0x33, "\x8c\xa4\x08"}, {0x33, "\x90\x00\x17"},
+        {0x33, "\x8c\xa4\x09"}, {0x33, "\x90\x00\x1a"}, {0x33, "\x8c\xa4\x0a"},
+        {0x33, "\x90\x00\x1d"}, {0x33, "\x8c\xa4\x0b"}, {0x33, "\x90\x00\x20"},
+        {0x33, "\x8c\x24\x11"}, {0x33, "\x90\x00\x81"}, {0x33, "\x8c\x24\x13"},
+        {0x33, "\x90\x00\x9b"},
+};
+
+static struct idxdata tbl_init_post_alt_low_b[] = {
+        {0x33, "\x8c\x27\x03"}, {0x33, "\x90\x03\x24"}, {0x33, "\x8c\x27\x05"},
+        {0x33, "\x90\x02\x58"}, {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
+        {2, "\xff\xff\xff"},
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"},
+        {2, "\xff\xff\xff"},
+};
+
+static struct idxdata tbl_init_post_alt_low_c[] = {
+        {0x34, "\x1e\x8f\x09"}, {0x34, "\x1c\x01\x28"}, {0x34, "\x1e\x8f\x09"},
+        {2, "\xff\xff\xff"},
+        {0x34, "\x1e\x8f\x09"}, {0x32, "\x14\x06\xe6"}, {0x33, "\x8c\xa1\x20"},
+        {0x33, "\x90\x00\x00"}, {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x01"},
+        {0x33, "\x2e\x01\x00"}, {0x34, "\x04\x00\x2a"}, {0x33, "\x8c\xa7\x02"},
+        {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x95"}, {0x33, "\x90\x01\x00"},
+        {2, "\xff\xff\xff"},
+        {0x33, "\x8c\xa1\x20"}, {0x33, "\x90\x00\x72"}, {0x33, "\x8c\xa1\x03"},
+        {0x33, "\x90\x00\x02"}, {0x33, "\x8c\xa7\x02"}, {0x33, "\x90\x00\x01"},
+        {2, "\xff\xff\xff"},
+        {0x33, "\x8c\xa1\x20"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\xa1\x03"},
+        {0x33, "\x90\x00\x01"}, {0x33, "\x8c\xa7\x02"}, {0x33, "\x90\x00\x00"},
+        {2, "\xff\xff\xff"}, /* - * */
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
+        {2, "\xff\xff\xff"},
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"},
+        {2, "\xff\xff\xff"},
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
+        {2, "\xff\xff\xff"},
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"},
+        {1, "\xff\xff\xff"},
+};
+
+static struct idxdata tbl_init_post_alt_low_d[] = {
+        {0x32, "\x10\x01\xf8"}, {0x34, "\xce\x01\xa8"}, {0x34, "\xd0\x66\x33"},
+        {0x34, "\xd2\x31\x9a"}, {0x34, "\xd4\x94\x63"}, {0x34, "\xd6\x4b\x25"},
+        {0x34, "\xd8\x26\x70"}, {0x34, "\xda\x72\x4c"}, {0x34, "\xdc\xff\x04"},
+        {0x34, "\xde\x01\x5b"}, {0x34, "\xe6\x01\x13"}, {0x34, "\xee\x0b\xf0"},
+        {0x34, "\xf6\x0b\xa4"}, {0x35, "\x00\xf6\xe7"}, {0x35, "\x08\x0d\xfd"},
+        {0x35, "\x10\x25\x63"}, {0x35, "\x18\x35\x6c"}, {0x35, "\x20\x42\x7e"},
+        {0x35, "\x28\x19\x44"}, {0x35, "\x30\x39\xd4"}, {0x35, "\x38\xf5\xa8"},
+        {0x35, "\x4c\x07\x90"}, {0x35, "\x44\x07\xb8"}, {0x35, "\x5c\x06\x88"},
+        {0x35, "\x54\x07\xff"}, {0x34, "\xe0\x01\x52"}, {0x34, "\xe8\x00\xcc"},
+        {0x34, "\xf0\x0d\x83"}, {0x34, "\xf8\x0c\xb3"}, {0x35, "\x02\xfe\xba"},
+        {0x35, "\x0a\x04\xe0"}, {0x35, "\x12\x1c\x63"}, {0x35, "\x1a\x2b\x5a"},
+        {0x35, "\x22\x32\x5e"}, {0x35, "\x2a\x0d\x28"}, {0x35, "\x32\x2c\x02"},
+        {0x35, "\x3a\xf4\xfa"}, {0x35, "\x4e\x07\xef"}, {0x35, "\x46\x07\x88"},
+        {0x35, "\x5e\x07\xc1"}, {0x35, "\x56\x04\x64"}, {0x34, "\xe4\x01\x15"},
+        {0x34, "\xec\x00\x82"}, {0x34, "\xf4\x0c\xce"}, {0x34, "\xfc\x0c\xba"},
+        {0x35, "\x06\x1f\x02"}, {0x35, "\x0e\x02\xe3"}, {0x35, "\x16\x1a\x50"},
+        {0x35, "\x1e\x24\x39"}, {0x35, "\x26\x23\x4c"}, {0x35, "\x2e\xf9\x1b"},
+        {0x35, "\x36\x23\x19"}, {0x35, "\x3e\x12\x08"}, {0x35, "\x52\x07\x22"},
+        {0x35, "\x4a\x03\xd3"}, {0x35, "\x62\x06\x54"}, {0x35, "\x5a\x04\x5d"},
+        {0x34, "\xe2\x01\x04"}, {0x34, "\xea\x00\xa0"}, {0x34, "\xf2\x0c\xbc"},
+        {0x34, "\xfa\x0c\x5b"}, {0x35, "\x04\x17\xf2"}, {0x35, "\x0c\x02\x08"},
+        {0x35, "\x14\x28\x43"}, {0x35, "\x1c\x28\x62"}, {0x35, "\x24\x2b\x60"},
+        {0x35, "\x2c\x07\x33"}, {0x35, "\x34\x1f\xb0"}, {0x35, "\x3c\xed\xcd"},
+        {0x35, "\x50\x00\x06"}, {0x35, "\x48\x07\xff"}, {0x35, "\x60\x05\x89"},
+        {0x35, "\x58\x07\xff"}, {0x35, "\x40\x00\xa0"}, {0x35, "\x42\x00\x00"},
+        {0x32, "\x10\x01\xfc"}, {0x33, "\x8c\xa1\x18"},
+        /* Flip/Mirror h/v=1 */
+        {0x33, "\x90\x00\x3c"}, {0x33, "\x8c\x27\x19"}, {0x33, "\x90\x04\x6c"},
+        {0x33, "\x8c\x27\x3b"}, {0x33, "\x90\x00\x24"}, {0x33, "\x8c\xa1\x03"},
+        {0x33, "\x90\x00\x06"},
+        {130, "\xff\xff\xff"},
+        {0x33, "\x90\x00\x06"}, {0x33, "\x90\x00\x06"}, {0x33, "\x90\x00\x06"},
+        {0x33, "\x90\x00\x06"}, {0x33, "\x90\x00\x06"}, {0x33, "\x90\x00\x06"},
+        {100, "\xff\xff\xff"},
+        /* ?? */
+        {0x33, "\x8c\xa1\x02"}, {0x33, "\x90\x00\x1f"}, {0x33, "\x8c\xa1\x02"},
+        {0x33, "\x90\x00\x1f"}, {0x33, "\x8c\xa1\x02"}, {0x33, "\x90\x00\x1f"},
+        {0x33, "\x8c\xa1\x02"}, {0x33, "\x90\x00\x1f"},
+        /* Brigthness=70 */
+        {0x33, "\x8c\xa2\x06"}, {0x33, "\x90\x00\x46"}, {0x33, "\x8c\xa1\x02"},
+        {0x33, "\x90\x00\x0f"}, {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
+        /* Sharpness=20 */
+        {0x32, "\x6c\x14\x08"},
+};
+
+static struct idxdata tbl_init_post_alt_big_a[] = {
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
+        {2, "\xff\xff\xff"},
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"},
+        {2, "\xff\xff\xff"},
+        {0x34, "\x1e\x8f\x09"}, {0x34, "\x1c\x01\x28"}, {0x34, "\x1e\x8f\x09"},
+        {0x34, "\x1e\x8f\x09"}, {0x32, "\x14\x06\xe6"}, {0x33, "\x8c\xa1\x03"},
+        {0x33, "\x90\x00\x05"},
+        {2, "\xff\xff\xff"},
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"},
+        {2, "\xff\xff\xff"},
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
+        {2, "\xff\xff\xff"},
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"}, {0x33, "\x8c\xa1\x20"},
+        {0x33, "\x90\x00\x72"}, {0x33, "\x8c\xa1\x30"}, {0x33, "\x90\x00\x03"},
+        {0x33, "\x8c\xa1\x31"}, {0x33, "\x90\x00\x02"}, {0x33, "\x8c\xa1\x32"},
+        {0x33, "\x90\x00\x03"}, {0x33, "\x8c\xa1\x34"}, {0x33, "\x90\x00\x03"},
+        {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x02"}, {0x33, "\x2e\x01\x00"},
+        {0x34, "\x04\x00\x2a"}, {0x33, "\x8c\xa7\x02"}, {0x33, "\x90\x00\x01"},
+};
+
+static struct idxdata tbl_init_post_alt_big_b[] = {
+        {0x32, "\x10\x01\xf8"}, {0x34, "\xce\x01\xa8"}, {0x34, "\xd0\x66\x33"},
+        {0x34, "\xd2\x31\x9a"}, {0x34, "\xd4\x94\x63"}, {0x34, "\xd6\x4b\x25"},
+        {0x34, "\xd8\x26\x70"}, {0x34, "\xda\x72\x4c"}, {0x34, "\xdc\xff\x04"},
+        {0x34, "\xde\x01\x5b"}, {0x34, "\xe6\x01\x13"}, {0x34, "\xee\x0b\xf0"},
+        {0x34, "\xf6\x0b\xa4"}, {0x35, "\x00\xf6\xe7"}, {0x35, "\x08\x0d\xfd"},
+        {0x35, "\x10\x25\x63"}, {0x35, "\x18\x35\x6c"}, {0x35, "\x20\x42\x7e"},
+        {0x35, "\x28\x19\x44"}, {0x35, "\x30\x39\xd4"}, {0x35, "\x38\xf5\xa8"},
+        {0x35, "\x4c\x07\x90"}, {0x35, "\x44\x07\xb8"}, {0x35, "\x5c\x06\x88"},
+        {0x35, "\x54\x07\xff"}, {0x34, "\xe0\x01\x52"}, {0x34, "\xe8\x00\xcc"},
+        {0x34, "\xf0\x0d\x83"}, {0x34, "\xf8\x0c\xb3"}, {0x35, "\x02\xfe\xba"},
+        {0x35, "\x0a\x04\xe0"}, {0x35, "\x12\x1c\x63"}, {0x35, "\x1a\x2b\x5a"},
+        {0x35, "\x22\x32\x5e"}, {0x35, "\x2a\x0d\x28"}, {0x35, "\x32\x2c\x02"},
+        {0x35, "\x3a\xf4\xfa"}, {0x35, "\x4e\x07\xef"}, {0x35, "\x46\x07\x88"},
+        {0x35, "\x5e\x07\xc1"}, {0x35, "\x56\x04\x64"}, {0x34, "\xe4\x01\x15"},
+        {0x34, "\xec\x00\x82"}, {0x34, "\xf4\x0c\xce"}, {0x34, "\xfc\x0c\xba"},
+        {0x35, "\x06\x1f\x02"}, {0x35, "\x0e\x02\xe3"}, {0x35, "\x16\x1a\x50"},
+        {0x35, "\x1e\x24\x39"}, {0x35, "\x26\x23\x4c"}, {0x35, "\x2e\xf9\x1b"},
+        {0x35, "\x36\x23\x19"}, {0x35, "\x3e\x12\x08"}, {0x35, "\x52\x07\x22"},
+        {0x35, "\x4a\x03\xd3"}, {0x35, "\x62\x06\x54"}, {0x35, "\x5a\x04\x5d"},
+        {0x34, "\xe2\x01\x04"}, {0x34, "\xea\x00\xa0"}, {0x34, "\xf2\x0c\xbc"},
+        {0x34, "\xfa\x0c\x5b"}, {0x35, "\x04\x17\xf2"}, {0x35, "\x0c\x02\x08"},
+        {0x35, "\x14\x28\x43"}, {0x35, "\x1c\x28\x62"}, {0x35, "\x24\x2b\x60"},
+        {0x35, "\x2c\x07\x33"}, {0x35, "\x34\x1f\xb0"}, {0x35, "\x3c\xed\xcd"},
+        {0x35, "\x50\x00\x06"}, {0x35, "\x48\x07\xff"}, {0x35, "\x60\x05\x89"},
+        {0x35, "\x58\x07\xff"}, {0x35, "\x40\x00\xa0"}, {0x35, "\x42\x00\x00"},
+        {0x32, "\x10\x01\xfc"}, {0x33, "\x8c\xa1\x18"}, {0x33, "\x90\x00\x3c"},
+};
+
+static struct idxdata tbl_init_post_alt_big_c[] = {
+        {0x33, "\x8c\xa1\x02"},
+        {0x33, "\x90\x00\x1f"},
+        {0x33, "\x8c\xa1\x02"},
+        {0x33, "\x90\x00\x1f"},
+        {0x33, "\x8c\xa1\x02"},
+        {0x33, "\x90\x00\x1f"},
+        {0x33, "\x8c\xa1\x02"},
+        {0x33, "\x90\x00\x1f"},
+};
+
+static u8 *dat_640  = "\xd0\x02\xd1\x08\xd2\xe1\xd3\x02\xd4\x10\xd5\x81";
+static u8 *dat_800  = "\xd0\x02\xd1\x10\xd2\x57\xd3\x02\xd4\x18\xd5\x21";
+static u8 *dat_1280 = "\xd0\x02\xd1\x20\xd2\x01\xd3\x02\xd4\x28\xd5\x01";
+static u8 *dat_1600 = "\xd0\x02\xd1\x20\xd2\xaf\xd3\x02\xd4\x30\xd5\x41";
+
+static int  mi2020_init_at_startup(struct gspca_dev *gspca_dev);
+static int  mi2020_configure_alt(struct gspca_dev *gspca_dev);
+static int  mi2020_init_pre_alt(struct gspca_dev *gspca_dev);
+static int  mi2020_init_post_alt(struct gspca_dev *gspca_dev);
+static void mi2020_post_unset_alt(struct gspca_dev *gspca_dev);
+static int  mi2020_camera_settings(struct gspca_dev *gspca_dev);
+/*==========================================================================*/
+
+void mi2020_init_settings(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->vcur.backlight  =  0;
+        sd->vcur.brightness = 70;
+        sd->vcur.sharpness  = 20;
+        sd->vcur.contrast   =  0;
+        sd->vcur.gamma      =  0;
+        sd->vcur.hue        =  0;
+        sd->vcur.saturation = 60;
+        sd->vcur.whitebal   = 50;
+        sd->vcur.mirror = 0;
+        sd->vcur.flip   = 0;
+        sd->vcur.AC50Hz = 1;
+
+        sd->vmax.backlight  =  64;
+        sd->vmax.brightness = 128;
+        sd->vmax.sharpness  =  40;
+        sd->vmax.contrast   =   3;
+        sd->vmax.gamma      =   2;
+        sd->vmax.hue        =   0 + 1; /* 200 */
+        sd->vmax.saturation =   0;     /* 100 */
+        sd->vmax.whitebal   =   0;     /* 100 */
+        sd->vmax.mirror = 1;
+        sd->vmax.flip   = 1;
+        sd->vmax.AC50Hz = 1;
+        if (_MI2020b_) {
+                sd->vmax.contrast  = 0;
+                sd->vmax.gamma     = 0;
+                sd->vmax.backlight = 0;
+        }
+
+        sd->dev_camera_settings = mi2020_camera_settings;
+        sd->dev_init_at_startup = mi2020_init_at_startup;
+        sd->dev_configure_alt   = mi2020_configure_alt;
+        sd->dev_init_pre_alt    = mi2020_init_pre_alt;
+        sd->dev_post_unset_alt  = mi2020_post_unset_alt;
+}
+
+/*==========================================================================*/
+
+static void common(struct gspca_dev *gspca_dev)
+{
+        s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
+
+        if (_MI2020b_) {
+                fetch_validx(gspca_dev, tbl_common_a, ARRAY_SIZE(tbl_common_a));
+        } else {
+                if (_MI2020_)
+                        ctrl_out(gspca_dev, 0x40,  1, 0x0008, 0x0004,  0, NULL);
+                else
+                        ctrl_out(gspca_dev, 0x40,  1, 0x0002, 0x0004,  0, NULL);
+                msleep(35);
+                fetch_validx(gspca_dev, tbl_common_b, ARRAY_SIZE(tbl_common_b));
+        }
+        ctrl_out(gspca_dev, 0x40,  3, 0x7a00, 0x0033,  3, "\x86\x25\x01");
+        ctrl_out(gspca_dev, 0x40,  3, 0x7a00, 0x0033,  3, "\x86\x25\x00");
+        msleep(2); /* - * */
+        ctrl_out(gspca_dev, 0x40,  3, 0x7a00, 0x0030,  3, "\x1a\x0a\xcc");
+        if (reso == IMAGE_1600)
+                msleep(2); /* 1600 */
+        fetch_idxdata(gspca_dev, tbl_common_c, ARRAY_SIZE(tbl_common_c));
+
+        if (_MI2020b_ || _MI2020_)
+                fetch_idxdata(gspca_dev, tbl_common_d,
+                                ARRAY_SIZE(tbl_common_d));
+
+        fetch_idxdata(gspca_dev, tbl_common_e, ARRAY_SIZE(tbl_common_e));
+        if (_MI2020b_ || _MI2020_) {
+                /* Different from fret */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x78");
+                /* Same as fret */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\x24\x17");
+                /* Different from fret */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x90");
+        } else {
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x6a");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\x24\x17");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x80");
+        }
+        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
+        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x05");
+        msleep(2);
+        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
+        if (reso == IMAGE_1600)
+                msleep(14); /* 1600 */
+        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x06");
+        msleep(2);
+}
+
+static int mi2020_init_at_startup(struct gspca_dev *gspca_dev)
+{
+        u8 c;
+
+        ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0004, 1, &c);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0004, 1, &c);
+
+        fetch_validx(gspca_dev, tbl_init_at_startup,
+                        ARRAY_SIZE(tbl_init_at_startup));
+
+        common(gspca_dev);
+
+        return 0;
+}
+
+static int mi2020_init_pre_alt(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->mirrorMask = 0;
+
+        sd->vold.backlight  = -1;
+        sd->vold.brightness = -1;
+        sd->vold.sharpness  = -1;
+        sd->vold.contrast   = -1;
+        sd->vold.gamma  = -1;
+        sd->vold.hue    = -1;
+        sd->vold.mirror = -1;
+        sd->vold.flip   = -1;
+        sd->vold.AC50Hz = -1;
+
+        mi2020_init_post_alt(gspca_dev);
+
+        return 0;
+}
+
+static int mi2020_init_post_alt(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
+
+        s32 backlight = sd->vcur.backlight;
+        s32 mirror = (((sd->vcur.mirror > 0) ^ sd->mirrorMask) > 0);
+        s32 flip   = (((sd->vcur.flip   > 0) ^ sd->mirrorMask) > 0);
+        s32 freq   = (sd->vcur.AC50Hz  > 0);
+
+        u8 dat_freq2[] = {0x90, 0x00, 0x80};
+        u8 dat_multi1[] = {0x8c, 0xa7, 0x00};
+        u8 dat_multi2[] = {0x90, 0x00, 0x00};
+        u8 dat_multi3[] = {0x8c, 0xa7, 0x00};
+        u8 dat_multi4[] = {0x90, 0x00, 0x00};
+        u8 dat_hvflip2[] = {0x90, 0x04, 0x6c};
+        u8 dat_hvflip4[] = {0x90, 0x00, 0x24};
+        u8 c;
+
+        sd->nbIm = -1;
+
+        dat_freq2[2] = freq ? 0xc0 : 0x80;
+        dat_multi1[2] = 0x9d;
+        dat_multi3[2] = dat_multi1[2] + 1;
+        dat_multi4[2] = dat_multi2[2] = backlight;
+        dat_hvflip2[2] = 0x6c + 2 * (1 - flip) + (1 - mirror);
+        dat_hvflip4[2] = 0x24 + 2 * (1 - flip) + (1 - mirror);
+
+        msleep(200);
+
+        ctrl_out(gspca_dev, 0x40, 5, 0x0001, 0x0000, 0, NULL);
+        msleep(3); /* 35 * */
+
+        common(gspca_dev);
+
+        ctrl_out(gspca_dev, 0x40,  1, 0x0041, 0x0000,  0, NULL);
+        msleep(70);
+
+        if (_MI2020b_)
+                ctrl_out(gspca_dev, 0x40,  1, 0x0040, 0x0000,  0, NULL);
+
+        ctrl_out(gspca_dev, 0x40,  1, 0x0010, 0x0010,  0, NULL);
+        ctrl_out(gspca_dev, 0x40,  1, 0x0003, 0x00c1,  0, NULL);
+        ctrl_out(gspca_dev, 0x40,  1, 0x0042, 0x00c2,  0, NULL);
+        ctrl_out(gspca_dev, 0x40,  1, 0x006a, 0x000d,  0, NULL);
+
+        switch (reso) {
+        case IMAGE_640:
+        case IMAGE_800:
+                if (reso != IMAGE_800)
+                        ctrl_out(gspca_dev, 0x40,  3, 0x0000, 0x0200,
+                                12, dat_640);
+                else
+                        ctrl_out(gspca_dev, 0x40,  3, 0x0000, 0x0200,
+                                12, dat_800);
+
+                if (_MI2020c_)
+                        fetch_idxdata(gspca_dev, tbl_init_post_alt_low_a,
+                                        ARRAY_SIZE(tbl_init_post_alt_low_a));
+
+                if (reso == IMAGE_800)
+                        fetch_idxdata(gspca_dev, tbl_init_post_alt_low_b,
+                                        ARRAY_SIZE(tbl_init_post_alt_low_b));
+
+                fetch_idxdata(gspca_dev, tbl_init_post_alt_low_c,
+                                ARRAY_SIZE(tbl_init_post_alt_low_c));
+
+                if (_MI2020b_) {
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x0010, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x00c1, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x00c2, 0, NULL);
+                        msleep(150);
+                } else if (_MI2020c_) {
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0010, 0x0010, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x00c1, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x00c2, 0, NULL);
+                        msleep(120);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000, 0, NULL);
+                        msleep(30);
+                } else if (_MI2020_) {
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x0010, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x00c1, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x00c2, 0, NULL);
+                        msleep(120);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000, 0, NULL);
+                        msleep(30);
+                }
+
+                /* AC power frequency */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq2);
+                msleep(20);
+                /* backlight */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi2);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi3);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi4);
+                /* at init time but not after */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa2\x0c");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x17");
+                /* finish the backlight */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi5);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi6);
+                msleep(5);/* " */
+
+                if (_MI2020c_) {
+                        fetch_idxdata(gspca_dev, tbl_init_post_alt_low_d,
+                                        ARRAY_SIZE(tbl_init_post_alt_low_d));
+                } else {
+                        ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, &c);
+                        msleep(14); /* 0xd8 */
+
+                        /* flip/mirror */
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_hvflip1);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_hvflip2);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_hvflip3);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_hvflip4);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_hvflip5);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_hvflip6);
+                        msleep(21);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_dummy1);
+                        msleep(5);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_dummy1);
+                        msleep(5);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_dummy1);
+                        msleep(5);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_dummy1);
+                        msleep(5);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_dummy1);
+                        msleep(5);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, dat_dummy1);
+                        /* end of flip/mirror main part */
+                        msleep(246); /* 146 */
+
+                        sd->nbIm = 0;
+                }
+                break;
+
+        case IMAGE_1280:
+        case IMAGE_1600:
+                if (reso == IMAGE_1280) {
+                        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
+                                        12, dat_1280);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, "\x8c\x27\x07");
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, "\x90\x05\x04");
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, "\x8c\x27\x09");
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, "\x90\x04\x02");
+                } else {
+                        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
+                                        12, dat_1600);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, "\x8c\x27\x07");
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, "\x90\x06\x40");
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, "\x8c\x27\x09");
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
+                                        3, "\x90\x04\xb0");
+                }
+
+                fetch_idxdata(gspca_dev, tbl_init_post_alt_big_a,
+                                ARRAY_SIZE(tbl_init_post_alt_big_a));
+
+                if (reso == IMAGE_1600)
+                        msleep(13); /* 1600 */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\x27\x97");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x01\x00");
+                msleep(53);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x20");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x00");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x01");
+                if (reso == IMAGE_1600)
+                        msleep(13); /* 1600 */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa7\x02");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x00");
+                msleep(53);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x20");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x72");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x02");
+                if (reso == IMAGE_1600)
+                        msleep(13); /* 1600 */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa7\x02");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x01");
+                msleep(53);
+
+                if (_MI2020b_) {
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x0010, 0, NULL);
+                        if (reso == IMAGE_1600)
+                                msleep(500); /* 1600 */
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x00c1, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x00c2, 0, NULL);
+                        msleep(1850);
+                } else if (_MI2020c_ || _MI2020_) {
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x0010, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x00c1, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x00c2, 0, NULL);
+                        msleep(1850);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000, 0, NULL);
+                        msleep(30);
+                }
+
+                /* AC power frequency */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq2);
+                msleep(20);
+                /* backlight */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi2);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi3);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi4);
+                /* at init time but not after */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa2\x0c");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x17");
+                /* finish the backlight */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi5);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi6);
+                msleep(6); /* " */
+
+                ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, &c);
+                msleep(14);
+
+                if (_MI2020c_)
+                        fetch_idxdata(gspca_dev, tbl_init_post_alt_big_b,
+                                        ARRAY_SIZE(tbl_init_post_alt_big_b));
+
+                /* flip/mirror */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip2);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip3);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip4);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip5);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip6);
+                /* end of flip/mirror main part */
+                msleep(16);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x01");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x20");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x00");
+                if (reso == IMAGE_1600)
+                        msleep(25); /* 1600 */
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa7\x02");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x00");
+                msleep(103);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x02");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x20");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x72");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa7\x02");
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x01");
+                sd->nbIm = 0;
+
+                if (_MI2020c_)
+                        fetch_idxdata(gspca_dev, tbl_init_post_alt_big_c,
+                                        ARRAY_SIZE(tbl_init_post_alt_big_c));
+        }
+
+        sd->vold.mirror    = mirror;
+        sd->vold.flip      = flip;
+        sd->vold.AC50Hz    = freq;
+        sd->vold.backlight = backlight;
+
+        mi2020_camera_settings(gspca_dev);
+
+        return 0;
+}
+
+static int mi2020_configure_alt(struct gspca_dev *gspca_dev)
+{
+        s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
+
+        switch (reso) {
+        case IMAGE_640:
+                gspca_dev->alt = 3 + 1;
+                break;
+
+        case IMAGE_800:
+        case IMAGE_1280:
+        case IMAGE_1600:
+                gspca_dev->alt = 1 + 1;
+                break;
+        }
+        return 0;
+}
+
+int mi2020_camera_settings(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        s32 backlight = sd->vcur.backlight;
+        s32 bright =  sd->vcur.brightness;
+        s32 sharp  =  sd->vcur.sharpness;
+        s32 cntr   =  sd->vcur.contrast;
+        s32 gam    =  sd->vcur.gamma;
+        s32 hue    = (sd->vcur.hue > 0);
+        s32 mirror = (((sd->vcur.mirror > 0) ^ sd->mirrorMask) > 0);
+        s32 flip   = (((sd->vcur.flip   > 0) ^ sd->mirrorMask) > 0);
+        s32 freq   = (sd->vcur.AC50Hz > 0);
+
+        u8 dat_sharp[] = {0x6c, 0x00, 0x08};
+        u8 dat_bright2[] = {0x90, 0x00, 0x00};
+        u8 dat_freq2[] = {0x90, 0x00, 0x80};
+        u8 dat_multi1[] = {0x8c, 0xa7, 0x00};
+        u8 dat_multi2[] = {0x90, 0x00, 0x00};
+        u8 dat_multi3[] = {0x8c, 0xa7, 0x00};
+        u8 dat_multi4[] = {0x90, 0x00, 0x00};
+        u8 dat_hvflip2[] = {0x90, 0x04, 0x6c};
+        u8 dat_hvflip4[] = {0x90, 0x00, 0x24};
+
+        /* Less than 4 images received -> too early to set the settings */
+        if (sd->nbIm < 4) {
+                sd->waitSet = 1;
+                return 0;
+        }
+        sd->waitSet = 0;
+
+        if (freq != sd->vold.AC50Hz) {
+                sd->vold.AC50Hz = freq;
+
+                dat_freq2[2] = freq ? 0xc0 : 0x80;
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq2);
+                msleep(20);
+        }
+
+        if (mirror != sd->vold.mirror || flip != sd->vold.flip) {
+                sd->vold.mirror = mirror;
+                sd->vold.flip   = flip;
+
+                dat_hvflip2[2] = 0x6c + 2 * (1 - flip) + (1 - mirror);
+                dat_hvflip4[2] = 0x24 + 2 * (1 - flip) + (1 - mirror);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip2);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip3);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip4);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip5);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip6);
+                msleep(130);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
+                msleep(6);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
+                msleep(6);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
+                msleep(6);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
+                msleep(6);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
+                msleep(6);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
+                msleep(6);
+
+                /* Sometimes present, sometimes not, useful? */
+                /* ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy2);
+                 * ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy3);
+                 * ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy2);
+                 * ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy3);
+                 * ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy2);
+                 * ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy3);
+                 * ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy2);
+                 * ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy3);*/
+        }
+
+        if (backlight != sd->vold.backlight) {
+                sd->vold.backlight = backlight;
+                if (backlight < 0 || backlight > sd->vmax.backlight)
+                        backlight = 0;
+
+                dat_multi1[2] = 0x9d;
+                dat_multi3[2] = dat_multi1[2] + 1;
+                dat_multi4[2] = dat_multi2[2] = backlight;
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi2);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi3);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi4);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi5);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi6);
+        }
+
+        if (gam != sd->vold.gamma) {
+                sd->vold.gamma = gam;
+                if (gam < 0 || gam > sd->vmax.gamma)
+                        gam = 0;
+
+                dat_multi1[2] = 0x6d;
+                dat_multi3[2] = dat_multi1[2] + 1;
+                dat_multi4[2] = dat_multi2[2] = 0x40 + gam;
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi2);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi3);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi4);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi5);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi6);
+        }
+
+        if (cntr != sd->vold.contrast) {
+                sd->vold.contrast = cntr;
+                if (cntr < 0 || cntr > sd->vmax.contrast)
+                        cntr = 0;
+
+                dat_multi1[2] = 0x6d;
+                dat_multi3[2] = dat_multi1[2] + 1;
+                dat_multi4[2] = dat_multi2[2] = 0x12 + 16 * cntr;
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi2);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi3);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi4);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi5);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi6);
+        }
+
+        if (bright != sd->vold.brightness) {
+                sd->vold.brightness = bright;
+                if (bright < 0 || bright > sd->vmax.brightness)
+                        bright = 0;
+
+                dat_bright2[2] = bright;
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright1);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright2);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright3);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright4);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright5);
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright6);
+        }
+
+        if (sharp != sd->vold.sharpness) {
+                sd->vold.sharpness = sharp;
+                if (sharp < 0 || sharp > sd->vmax.sharpness)
+                        sharp = 0;
+
+                dat_sharp[1] = sharp;
+                ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0032, 3, dat_sharp);
+        }
+
+        if (hue != sd->vold.hue) {
+                sd->swapRB = hue;
+                sd->vold.hue = hue;
+        }
+
+        return 0;
+}
+
+static void mi2020_post_unset_alt(struct gspca_dev *gspca_dev)
+{
+        ctrl_out(gspca_dev, 0x40, 5, 0x0000, 0x0000, 0, NULL);
+        msleep(20);
+        if (_MI2020c_ || _MI2020_)
+                ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x0000, 0, NULL);
+        else
+                ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x0000, 0, NULL);
+}
diff --git a/drivers/media/video/gspca/gl860/gl860-ov2640.c b/drivers/media/video/gspca/gl860/gl860-ov2640.c
new file mode 100644
index 000000000000..14b9c373f9f7
--- /dev/null
+++ b/drivers/media/video/gspca/gl860/gl860-ov2640.c
@@ -0,0 +1,505 @@
+/* @file gl860-ov2640.c
+ * @author Olivier LORIN, from Malmostoso's logs
+ * @date 2009-08-27
+ *
+ * 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
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Sensor : OV2640 */
+
+#include "gl860.h"
+
+static u8 dat_init1[] = "\x00\x41\x07\x6a\x06\x61\x0d\x6a" "\x10\x10\xc1\x01";
+static u8 dat_init2[] = {0x61}; /* expected */
+static u8 dat_init3[] = {0x51}; /* expected */
+
+static u8 dat_post[] =
+        "\x00\x41\x07\x6a\x06\xef\x0d\x6a" "\x10\x10\xc1\x01";
+
+static u8 dat_640[]  = "\xd0\x01\xd1\x08\xd2\xe0\xd3\x02\xd4\x10\xd5\x81";
+static u8 dat_800[]  = "\xd0\x01\xd1\x10\xd2\x58\xd3\x02\xd4\x18\xd5\x21";
+static u8 dat_1280[] = "\xd0\x01\xd1\x18\xd2\xc0\xd3\x02\xd4\x28\xd5\x01";
+static u8 dat_1600[] = "\xd0\x01\xd1\x20\xd2\xb0\xd3\x02\xd4\x30\xd5\x41";
+
+static u8 c50[] = {0x50}; /* expected */
+static u8 c28[] = {0x28}; /* expected */
+static u8 ca8[] = {0xa8}; /* expected */
+
+static struct validx tbl_init_at_startup[] = {
+        {0x0000, 0x0000}, {0x0010, 0x0010}, {0x0008, 0x00c0}, {0x0001, 0x00c1},
+        {0x0001, 0x00c2}, {0x0020, 0x0006}, {0x006a, 0x000d},
+        {0x0050, 0x0000}, {0x0041, 0x0000}, {0x006a, 0x0007}, {0x0061, 0x0006},
+        {0x006a, 0x000d}, {0x0000, 0x00c0}, {0x0010, 0x0010}, {0x0001, 0x00c1},
+        {0x0041, 0x00c2}, {0x0004, 0x00d8}, {0x0012, 0x0004}, {0x0000, 0x0058},
+        {0x0041, 0x0000}, {0x0061, 0x0000},
+};
+
+static struct validx tbl_common[] = {
+        {0x6000, 0x00ff}, {0x60ff, 0x002c}, {0x60df, 0x002e}, {0x6001, 0x00ff},
+        {0x6080, 0x0012}, {0x6000, 0x0000}, {0x6000, 0x0045}, {0x6000, 0x0010},
+        {0x6035, 0x003c}, {0x6000, 0x0011}, {0x6028, 0x0004}, {0x60e5, 0x0013},
+        {0x6088, 0x0014}, {0x600c, 0x002c}, {0x6078, 0x0033}, {0x60f7, 0x003b},
+        {0x6000, 0x003e}, {0x6011, 0x0043}, {0x6010, 0x0016}, {0x6082, 0x0039},
+        {0x6088, 0x0035}, {0x600a, 0x0022}, {0x6040, 0x0037}, {0x6000, 0x0023},
+        {0x60a0, 0x0034}, {0x601a, 0x0036}, {0x6002, 0x0006}, {0x60c0, 0x0007},
+        {0x60b7, 0x000d}, {0x6001, 0x000e}, {0x6000, 0x004c}, {0x6081, 0x004a},
+        {0x6099, 0x0021}, {0x6002, 0x0009}, {0x603e, 0x0024}, {0x6034, 0x0025},
+        {0x6081, 0x0026}, {0x6000, 0x0000}, {0x6000, 0x0045}, {0x6000, 0x0010},
+        {0x6000, 0x005c}, {0x6000, 0x0063}, {0x6000, 0x007c}, {0x6070, 0x0061},
+        {0x6080, 0x0062}, {0x6080, 0x0020}, {0x6030, 0x0028}, {0x6000, 0x006c},
+        {0x6000, 0x006e}, {0x6002, 0x0070}, {0x6094, 0x0071}, {0x60c1, 0x0073},
+        {0x6034, 0x003d}, {0x6057, 0x005a}, {0x60bb, 0x004f}, {0x609c, 0x0050},
+        {0x6080, 0x006d}, {0x6002, 0x0039}, {0x6033, 0x003a}, {0x60f1, 0x003b},
+        {0x6031, 0x003c}, {0x6000, 0x00ff}, {0x6014, 0x00e0}, {0x60ff, 0x0076},
+        {0x60a0, 0x0033}, {0x6020, 0x0042}, {0x6018, 0x0043}, {0x6000, 0x004c},
+        {0x60d0, 0x0087}, {0x600f, 0x0088}, {0x6003, 0x00d7}, {0x6010, 0x00d9},
+        {0x6005, 0x00da}, {0x6082, 0x00d3}, {0x60c0, 0x00f9}, {0x6006, 0x0044},
+        {0x6007, 0x00d1}, {0x6002, 0x00d2}, {0x6000, 0x00d2}, {0x6011, 0x00d8},
+        {0x6008, 0x00c8}, {0x6080, 0x00c9}, {0x6008, 0x007c}, {0x6020, 0x007d},
+        {0x6020, 0x007d}, {0x6000, 0x0090}, {0x600e, 0x0091}, {0x601a, 0x0091},
+        {0x6031, 0x0091}, {0x605a, 0x0091}, {0x6069, 0x0091}, {0x6075, 0x0091},
+        {0x607e, 0x0091}, {0x6088, 0x0091}, {0x608f, 0x0091}, {0x6096, 0x0091},
+        {0x60a3, 0x0091}, {0x60af, 0x0091}, {0x60c4, 0x0091}, {0x60d7, 0x0091},
+        {0x60e8, 0x0091}, {0x6020, 0x0091}, {0x6000, 0x0092}, {0x6006, 0x0093},
+        {0x60e3, 0x0093}, {0x6005, 0x0093}, {0x6005, 0x0093}, {0x6000, 0x0093},
+        {0x6004, 0x0093}, {0x6000, 0x0093}, {0x6000, 0x0093}, {0x6000, 0x0093},
+        {0x6000, 0x0093}, {0x6000, 0x0093}, {0x6000, 0x0093}, {0x6000, 0x0093},
+        {0x6000, 0x0096}, {0x6008, 0x0097}, {0x6019, 0x0097}, {0x6002, 0x0097},
+        {0x600c, 0x0097}, {0x6024, 0x0097}, {0x6030, 0x0097}, {0x6028, 0x0097},
+        {0x6026, 0x0097}, {0x6002, 0x0097}, {0x6098, 0x0097}, {0x6080, 0x0097},
+        {0x6000, 0x0097}, {0x6000, 0x0097}, {0x60ed, 0x00c3}, {0x609a, 0x00c4},
+        {0x6000, 0x00a4}, {0x6011, 0x00c5}, {0x6051, 0x00c6}, {0x6010, 0x00c7},
+        {0x6066, 0x00b6}, {0x60a5, 0x00b8}, {0x6064, 0x00b7}, {0x607c, 0x00b9},
+        {0x60af, 0x00b3}, {0x6097, 0x00b4}, {0x60ff, 0x00b5}, {0x60c5, 0x00b0},
+        {0x6094, 0x00b1}, {0x600f, 0x00b2}, {0x605c, 0x00c4}, {0x6000, 0x00a8},
+        {0x60c8, 0x00c0}, {0x6096, 0x00c1}, {0x601d, 0x0086}, {0x6000, 0x0050},
+        {0x6090, 0x0051}, {0x6018, 0x0052}, {0x6000, 0x0053}, {0x6000, 0x0054},
+        {0x6088, 0x0055}, {0x6000, 0x0057}, {0x6090, 0x005a}, {0x6018, 0x005b},
+        {0x6005, 0x005c}, {0x60ed, 0x00c3}, {0x6000, 0x007f}, {0x6005, 0x00da},
+        {0x601f, 0x00e5}, {0x6067, 0x00e1}, {0x6000, 0x00e0}, {0x60ff, 0x00dd},
+        {0x6000, 0x0005}, {0x6001, 0x00ff}, {0x6000, 0x0000}, {0x6000, 0x0045},
+        {0x6000, 0x0010},
+};
+
+static struct validx tbl_sensor_settings_common_a[] = {
+        {0x0041, 0x0000}, {0x006a, 0x0007}, {0x00ef, 0x0006}, {0x006a, 0x000d},
+        {0x0000, 0x00c0}, {0x0010, 0x0010}, {0x0001, 0x00c1}, {0x0041, 0x00c2},
+        {0x0004, 0x00d8}, {0x0012, 0x0004}, {0x0000, 0x0058}, {0x0041, 0x0000},
+        {50, 0xffff},
+        {0x0061, 0x0000},
+        {0xffff, 0xffff},
+        {0x6000, 0x00ff}, {0x6000, 0x007c}, {0x6007, 0x007d},
+        {30, 0xffff},
+        {0x0040, 0x0000},
+};
+
+static struct validx tbl_sensor_settings_common_b[] = {
+        {0x6001, 0x00ff}, {0x6038, 0x000c},
+        {10, 0xffff},
+        {0x6000, 0x0011},
+        /* backlight=31/64 */
+        {0x6001, 0x00ff}, {0x603e, 0x0024}, {0x6034, 0x0025},
+        /* bright=0/256 */
+        {0x6000, 0x00ff}, {0x6009, 0x007c}, {0x6000, 0x007d},
+        /* wbal=64/128 */
+        {0x6000, 0x00ff}, {0x6003, 0x007c}, {0x6040, 0x007d},
+        /* cntr=0/256 */
+        {0x6000, 0x00ff}, {0x6007, 0x007c}, {0x6000, 0x007d},
+        /* sat=128/256 */
+        {0x6000, 0x00ff}, {0x6001, 0x007c}, {0x6080, 0x007d},
+        /* sharpness=0/32 */
+        {0x6000, 0x00ff}, {0x6001, 0x0092}, {0x60c0, 0x0093},
+        /* hue=0/256 */
+        {0x6000, 0x00ff}, {0x6002, 0x007c}, {0x6000, 0x007d},
+        /* gam=32/64 */
+        {0x6000, 0x00ff}, {0x6008, 0x007c}, {0x6020, 0x007d},
+        /* image right up */
+        {0xffff, 0xffff},
+        {15, 0xffff},
+        {0x6001, 0x00ff}, {0x6000, 0x8004},
+        {0xffff, 0xffff},
+        {0x60a8, 0x0004},
+        {15, 0xffff},
+        {0x6001, 0x00ff}, {0x6000, 0x8004},
+        {0xffff, 0xffff},
+        {0x60f8, 0x0004},
+        /* image right up */
+        {0xffff, 0xffff},
+        /* backlight=31/64 */
+        {0x6001, 0x00ff}, {0x603e, 0x0024}, {0x6034, 0x0025},
+};
+
+static struct validx tbl_640[] = {
+        {0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0}, {0x6067, 0x00e1},
+        {0x6004, 0x00da}, {0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0},
+        {0x6001, 0x00ff}, {0x6000, 0x0012}, {0x6000, 0x0011}, {0x6011, 0x0017},
+        {0x6075, 0x0018}, {0x6001, 0x0019}, {0x6097, 0x001a}, {0x6036, 0x0032},
+        {0x60bb, 0x004f}, {0x6057, 0x005a}, {0x609c, 0x0050}, {0x6080, 0x006d},
+        {0x6092, 0x0026}, {0x60ff, 0x0020}, {0x6000, 0x0027}, {0x6000, 0x00ff},
+        {0x60c8, 0x00c0}, {0x6096, 0x00c1}, {0x6000, 0x008c}, {0x603d, 0x0086},
+        {0x6089, 0x0050}, {0x6090, 0x0051}, {0x602c, 0x0052}, {0x6000, 0x0053},
+        {0x6000, 0x0054}, {0x6088, 0x0055}, {0x6000, 0x0057}, {0x60a0, 0x005a},
+        {0x6078, 0x005b}, {0x6000, 0x005c}, {0x6004, 0x00d3}, {0x6000, 0x00e0},
+        {0x60ff, 0x00dd}, {0x60a1, 0x005a},
+};
+
+static struct validx tbl_800[] = {
+        {0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0}, {0x6067, 0x00e1},
+        {0x6004, 0x00da}, {0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0},
+        {0x6001, 0x00ff}, {0x6040, 0x0012}, {0x6000, 0x0011}, {0x6011, 0x0017},
+        {0x6043, 0x0018}, {0x6000, 0x0019}, {0x604b, 0x001a}, {0x6009, 0x0032},
+        {0x60ca, 0x004f}, {0x60a8, 0x0050}, {0x6000, 0x006d}, {0x6038, 0x003d},
+        {0x60c8, 0x0035}, {0x6000, 0x0022}, {0x6092, 0x0026}, {0x60ff, 0x0020},
+        {0x6000, 0x0027}, {0x6000, 0x00ff}, {0x6064, 0x00c0}, {0x604b, 0x00c1},
+        {0x6000, 0x008c}, {0x601d, 0x0086}, {0x6082, 0x00d3}, {0x6000, 0x00e0},
+        {0x60ff, 0x00dd}, {0x6020, 0x008c}, {0x6001, 0x00ff}, {0x6044, 0x0018},
+};
+
+static struct validx tbl_big_a[] = {
+        {0x0002, 0x00c1}, {0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0},
+        {0x6001, 0x00ff}, {0x6000, 0x0012}, {0x6000, 0x0000}, {0x6000, 0x0045},
+        {0x6000, 0x0010}, {0x6000, 0x0011}, {0x6011, 0x0017}, {0x6075, 0x0018},
+        {0x6001, 0x0019}, {0x6097, 0x001a}, {0x6036, 0x0032}, {0x60bb, 0x004f},
+        {0x609c, 0x0050}, {0x6057, 0x005a}, {0x6080, 0x006d}, {0x6043, 0x000f},
+        {0x608f, 0x0003}, {0x6005, 0x007c}, {0x6081, 0x0026}, {0x6000, 0x00ff},
+        {0x60c8, 0x00c0}, {0x6096, 0x00c1}, {0x6000, 0x008c},
+};
+
+static struct validx tbl_big_b[] = {
+        {0x603d, 0x0086}, {0x6000, 0x0050}, {0x6090, 0x0051}, {0x602c, 0x0052},
+        {0x6000, 0x0053}, {0x6000, 0x0054}, {0x6088, 0x0055}, {0x6000, 0x0057},
+        {0x6040, 0x005a}, {0x60f0, 0x005b}, {0x6001, 0x005c}, {0x6082, 0x00d3},
+        {0x6000, 0x008e},
+};
+
+static struct validx tbl_big_c[] = {
+        {0x6004, 0x00da}, {0x6000, 0x00e0}, {0x6067, 0x00e1}, {0x60ff, 0x00dd},
+        {0x6001, 0x00ff}, {0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0},
+        {0x6001, 0x00ff}, {0x6000, 0x0011}, {0x6000, 0x00ff}, {0x6010, 0x00c7},
+        {0x6000, 0x0092}, {0x6006, 0x0093}, {0x60e3, 0x0093}, {0x6005, 0x0093},
+        {0x6005, 0x0093}, {0x60ed, 0x00c3}, {0x6000, 0x00a4}, {0x60d0, 0x0087},
+        {0x6003, 0x0096}, {0x600c, 0x0097}, {0x6024, 0x0097}, {0x6030, 0x0097},
+        {0x6028, 0x0097}, {0x6026, 0x0097}, {0x6002, 0x0097}, {0x6001, 0x00ff},
+        {0x6043, 0x000f}, {0x608f, 0x0003}, {0x6000, 0x002d}, {0x6000, 0x002e},
+        {0x600a, 0x0022}, {0x6002, 0x0070}, {0x6008, 0x0014}, {0x6048, 0x0014},
+        {0x6000, 0x00ff}, {0x6000, 0x00e0}, {0x60ff, 0x00dd},
+};
+
+static struct validx tbl_post_unset_alt[] = {
+        {0x006a, 0x000d}, {0x6001, 0x00ff}, {0x6081, 0x0026}, {0x6000, 0x0000},
+        {0x6000, 0x0045}, {0x6000, 0x0010}, {0x6068, 0x000d},
+        {50, 0xffff},
+        {0x0021, 0x0000},
+};
+
+static int  ov2640_init_at_startup(struct gspca_dev *gspca_dev);
+static int  ov2640_configure_alt(struct gspca_dev *gspca_dev);
+static int  ov2640_init_pre_alt(struct gspca_dev *gspca_dev);
+static int  ov2640_init_post_alt(struct gspca_dev *gspca_dev);
+static void ov2640_post_unset_alt(struct gspca_dev *gspca_dev);
+static int  ov2640_camera_settings(struct gspca_dev *gspca_dev);
+/*==========================================================================*/
+
+void ov2640_init_settings(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->vcur.backlight  =  32;
+        sd->vcur.brightness =   0;
+        sd->vcur.sharpness  =   6;
+        sd->vcur.contrast   =   0;
+        sd->vcur.gamma      =  32;
+        sd->vcur.hue        =   0;
+        sd->vcur.saturation = 128;
+        sd->vcur.whitebal   =  64;
+
+        sd->vmax.backlight  =  64;
+        sd->vmax.brightness = 255;
+        sd->vmax.sharpness  =  31;
+        sd->vmax.contrast   = 255;
+        sd->vmax.gamma      =  64;
+        sd->vmax.hue        = 255 + 1;
+        sd->vmax.saturation = 255;
+        sd->vmax.whitebal   = 128;
+        sd->vmax.mirror     = 0;
+        sd->vmax.flip       = 0;
+        sd->vmax.AC50Hz     = 0;
+
+        sd->dev_camera_settings = ov2640_camera_settings;
+        sd->dev_init_at_startup = ov2640_init_at_startup;
+        sd->dev_configure_alt   = ov2640_configure_alt;
+        sd->dev_init_pre_alt    = ov2640_init_pre_alt;
+        sd->dev_post_unset_alt  = ov2640_post_unset_alt;
+}
+
+/*==========================================================================*/
+
+static void common(struct gspca_dev *gspca_dev)
+{
+        fetch_validx(gspca_dev, tbl_common, ARRAY_SIZE(tbl_common));
+}
+
+static int ov2640_init_at_startup(struct gspca_dev *gspca_dev)
+{
+        fetch_validx(gspca_dev, tbl_init_at_startup,
+                        ARRAY_SIZE(tbl_init_at_startup));
+
+        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, dat_init1);
+
+        common(gspca_dev);
+
+        ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0006, 1, dat_init2);
+
+        ctrl_out(gspca_dev, 0x40, 1, 0x00ef, 0x0006, 0, NULL);
+
+        ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, dat_init3);
+
+        ctrl_out(gspca_dev, 0x40, 1, 0x0051, 0x0000, 0, NULL);
+/*      ctrl_out(gspca_dev, 0x40, 11, 0x0000, 0x0000, 0, NULL); */
+
+        return 0;
+}
+
+static int ov2640_init_pre_alt(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->vold.backlight  = -1;
+        sd->vold.brightness = -1;
+        sd->vold.sharpness  = -1;
+        sd->vold.contrast   = -1;
+        sd->vold.saturation = -1;
+        sd->vold.gamma    = -1;
+        sd->vold.hue      = -1;
+        sd->vold.whitebal = -1;
+
+        ov2640_init_post_alt(gspca_dev);
+
+        return 0;
+}
+
+static int ov2640_init_post_alt(struct gspca_dev *gspca_dev)
+{
+        s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
+        s32 n; /* reserved for FETCH macros */
+
+        ctrl_out(gspca_dev, 0x40, 5, 0x0001, 0x0000, 0, NULL);
+
+        n = fetch_validx(gspca_dev, tbl_sensor_settings_common_a,
+                        ARRAY_SIZE(tbl_sensor_settings_common_a));
+        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, dat_post);
+        common(gspca_dev);
+        keep_on_fetching_validx(gspca_dev, tbl_sensor_settings_common_a,
+                                ARRAY_SIZE(tbl_sensor_settings_common_a), n);
+
+        switch (reso) {
+        case IMAGE_640:
+                n = fetch_validx(gspca_dev, tbl_640, ARRAY_SIZE(tbl_640));
+                ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, dat_640);
+                break;
+
+        case IMAGE_800:
+                n = fetch_validx(gspca_dev, tbl_800, ARRAY_SIZE(tbl_800));
+                ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, dat_800);
+                break;
+
+        case IMAGE_1600:
+        case IMAGE_1280:
+                n = fetch_validx(gspca_dev, tbl_big_a, ARRAY_SIZE(tbl_big_a));
+
+                if (reso == IMAGE_1280) {
+                        n = fetch_validx(gspca_dev, tbl_big_b,
+                                        ARRAY_SIZE(tbl_big_b));
+                } else {
+                        ctrl_out(gspca_dev, 0x40, 1, 0x601d, 0x0086, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x6001, 0x00d7, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x6082, 0x00d3, 0, NULL);
+                }
+
+                n = fetch_validx(gspca_dev, tbl_big_c, ARRAY_SIZE(tbl_big_c));
+
+                if (reso == IMAGE_1280) {
+                        ctrl_out(gspca_dev, 0x40, 1, 0x6001, 0x00ff, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
+                                        12, dat_1280);
+                } else {
+                        ctrl_out(gspca_dev, 0x40, 1, 0x6020, 0x008c, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x6001, 0x00ff, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x6076, 0x0018, 0, NULL);
+                        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
+                                        12, dat_1600);
+                }
+                break;
+        }
+
+        n = fetch_validx(gspca_dev, tbl_sensor_settings_common_b,
+                        ARRAY_SIZE(tbl_sensor_settings_common_b));
+        ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, c50);
+        keep_on_fetching_validx(gspca_dev, tbl_sensor_settings_common_b,
+                                ARRAY_SIZE(tbl_sensor_settings_common_b), n);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x8004, 1, c28);
+        keep_on_fetching_validx(gspca_dev, tbl_sensor_settings_common_b,
+                                ARRAY_SIZE(tbl_sensor_settings_common_b), n);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x8004, 1, ca8);
+        keep_on_fetching_validx(gspca_dev, tbl_sensor_settings_common_b,
+                                ARRAY_SIZE(tbl_sensor_settings_common_b), n);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, c50);
+        keep_on_fetching_validx(gspca_dev, tbl_sensor_settings_common_b,
+                                ARRAY_SIZE(tbl_sensor_settings_common_b), n);
+
+        ov2640_camera_settings(gspca_dev);
+
+        return 0;
+}
+
+static int ov2640_configure_alt(struct gspca_dev *gspca_dev)
+{
+        s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
+
+        switch (reso) {
+        case IMAGE_640:
+                gspca_dev->alt = 3 + 1;
+                break;
+
+        case IMAGE_800:
+        case IMAGE_1280:
+        case IMAGE_1600:
+                gspca_dev->alt = 1 + 1;
+                break;
+        }
+        return 0;
+}
+
+static int ov2640_camera_settings(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        s32 backlight = sd->vcur.backlight;
+        s32 bright = sd->vcur.brightness;
+        s32 sharp  = sd->vcur.sharpness;
+        s32 gam    = sd->vcur.gamma;
+        s32 cntr   = sd->vcur.contrast;
+        s32 sat    = sd->vcur.saturation;
+        s32 hue    = sd->vcur.hue;
+        s32 wbal   = sd->vcur.whitebal;
+
+        if (backlight != sd->vold.backlight) {
+                if (backlight < 0 || backlight > sd->vmax.backlight)
+                        backlight = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0x6001                 , 0x00ff,
+                                0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x601f + backlight     , 0x0024,
+                                0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x601f + backlight - 10, 0x0025,
+                                0, NULL);
+                /* No sd->vold.backlight=backlight; (to be done again later) */
+        }
+
+        if (bright != sd->vold.brightness) {
+                sd->vold.brightness = bright;
+                if (bright < 0 || bright > sd->vmax.brightness)
+                        bright = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000         , 0x00ff, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6009         , 0x007c, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000 + bright, 0x007d, 0, NULL);
+        }
+
+        if (wbal != sd->vold.whitebal) {
+                sd->vold.whitebal = wbal;
+                if (wbal < 0 || wbal > sd->vmax.whitebal)
+                        wbal = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000       , 0x00ff, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6003       , 0x007c, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000 + wbal, 0x007d, 0, NULL);
+        }
+
+        if (cntr != sd->vold.contrast) {
+                sd->vold.contrast = cntr;
+                if (cntr < 0 || cntr > sd->vmax.contrast)
+                        cntr = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000       , 0x00ff, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6007       , 0x007c, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000 + cntr, 0x007d, 0, NULL);
+        }
+
+        if (sat != sd->vold.saturation) {
+                sd->vold.saturation = sat;
+                if (sat < 0 || sat > sd->vmax.saturation)
+                        sat = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000      , 0x00ff, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6001      , 0x007c, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000 + sat, 0x007d, 0, NULL);
+        }
+
+        if (sharp != sd->vold.sharpness) {
+                sd->vold.sharpness = sharp;
+                if (sharp < 0 || sharp > sd->vmax.sharpness)
+                        sharp = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000        , 0x00ff, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6001        , 0x0092, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x60c0 + sharp, 0x0093, 0, NULL);
+        }
+
+        if (hue != sd->vold.hue) {
+                sd->vold.hue = hue;
+                if (hue < 0 || hue > sd->vmax.hue)
+                        hue = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000     , 0x00ff, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6002     , 0x007c, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000 + hue * (hue < 255), 0x007d,
+                                0, NULL);
+                if (hue >= sd->vmax.hue)
+                        sd->swapRB = 1;
+                else
+                        sd->swapRB = 0;
+        }
+
+        if (gam != sd->vold.gamma) {
+                sd->vold.gamma = gam;
+                if (gam < 0 || gam > sd->vmax.gamma)
+                        gam = 0;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000      , 0x00ff, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6008      , 0x007c, 0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x6000 + gam, 0x007d, 0, NULL);
+        }
+
+        if (backlight != sd->vold.backlight) {
+                sd->vold.backlight = backlight;
+
+                ctrl_out(gspca_dev, 0x40, 1, 0x6001                 , 0x00ff,
+                                0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x601f + backlight     , 0x0024,
+                                0, NULL);
+                ctrl_out(gspca_dev, 0x40, 1, 0x601f + backlight - 10, 0x0025,
+                                0, NULL);
+        }
+
+        return 0;
+}
+
+static void ov2640_post_unset_alt(struct gspca_dev *gspca_dev)
+{
+        ctrl_out(gspca_dev, 0x40, 5, 0x0000, 0x0000, 0, NULL);
+        msleep(20);
+        fetch_validx(gspca_dev, tbl_post_unset_alt,
+                        ARRAY_SIZE(tbl_post_unset_alt));
+}
diff --git a/drivers/media/video/gspca/gl860/gl860-ov9655.c b/drivers/media/video/gspca/gl860/gl860-ov9655.c
new file mode 100644
index 000000000000..eda3346f939c
--- /dev/null
+++ b/drivers/media/video/gspca/gl860/gl860-ov9655.c
@@ -0,0 +1,337 @@
+/* @file gl860-ov9655.c
+ * @author Olivier LORIN, from logs done by Simon (Sur3) and Almighurt
+ * on dsd's weblog
+ * @date 2009-08-27
+ *
+ * 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
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Sensor : OV9655 */
+
+#include "gl860.h"
+
+static struct validx tbl_init_at_startup[] = {
+        {0x0000, 0x0000}, {0x0010, 0x0010}, {0x0008, 0x00c0}, {0x0001, 0x00c1},
+        {0x0001, 0x00c2}, {0x0020, 0x0006}, {0x006a, 0x000d},
+
+        {0x0040, 0x0000},
+};
+
+static struct validx tbl_commmon[] = {
+        {0x0041, 0x0000}, {0x006a, 0x0007}, {0x0063, 0x0006}, {0x006a, 0x000d},
+        {0x0000, 0x00c0}, {0x0010, 0x0010}, {0x0001, 0x00c1}, {0x0041, 0x00c2},
+        {0x0004, 0x00d8}, {0x0012, 0x0004}, {0x0000, 0x0058}, {0x0040, 0x0000},
+        {0x00f3, 0x0006}, {0x0058, 0x0000}, {0x0048, 0x0000}, {0x0061, 0x0000},
+};
+
+static s32 tbl_length[] = {12, 56, 52, 54, 56, 42, 32, 12};
+
+static u8 *tbl_640[] = {
+        "\x00\x40\x07\x6a\x06\xf3\x0d\x6a" "\x10\x10\xc1\x01"
+        ,
+        "\x12\x80\x00\x00\x01\x98\x02\x80" "\x03\x12\x04\x03\x0b\x57\x0e\x61"
+        "\x0f\x42\x11\x01\x12\x60\x13\x00" "\x14\x3a\x16\x24\x17\x14\x18\x00"
+        "\x19\x01\x1a\x3d\x1e\x04\x24\x3c" "\x25\x36\x26\x72\x27\x08\x28\x08"
+        "\x29\x15\x2a\x00\x2b\x00\x2c\x08"
+        ,
+        "\x32\xff\x33\x00\x34\x3d\x35\x00" "\x36\xfa\x38\x72\x39\x57\x3a\x00"
+        "\x3b\x0c\x3d\x99\x3e\x0c\x3f\xc1" "\x40\xc0\x41\x00\x42\xc0\x43\x0a"
+        "\x44\xf0\x45\x46\x46\x62\x47\x2a" "\x48\x3c\x4a\xee\x4b\xe7\x4c\xe7"
+        "\x4d\xe7\x4e\xe7"
+        ,
+        "\x4f\x98\x50\x98\x51\x00\x52\x28" "\x53\x70\x54\x98\x58\x1a\x59\x85"
+        "\x5a\xa9\x5b\x64\x5c\x84\x5d\x53" "\x5e\x0e\x5f\xf0\x60\xf0\x61\xf0"
+        "\x62\x00\x63\x00\x64\x02\x65\x20" "\x66\x00\x69\x0a\x6b\x5a\x6c\x04"
+        "\x6d\x55\x6e\x00\x6f\x9d"
+        ,
+        "\x70\x15\x71\x78\x72\x00\x73\x00" "\x74\x3a\x75\x35\x76\x01\x77\x02"
+        "\x7a\x24\x7b\x04\x7c\x07\x7d\x10" "\x7e\x28\x7f\x36\x80\x44\x81\x52"
+        "\x82\x60\x83\x6c\x84\x78\x85\x8c" "\x86\x9e\x87\xbb\x88\xd2\x89\xe5"
+        "\x8a\x23\x8c\x8d\x90\x7c\x91\x7b"
+        ,
+        "\x9d\x02\x9e\x02\x9f\x74\xa0\x73" "\xa1\x40\xa4\x50\xa5\x68\xa6\x70"
+        "\xa8\xc1\xa9\xef\xaa\x92\xab\x04" "\xac\x80\xad\x80\xae\x80\xaf\x80"
+        "\xb2\xf2\xb3\x20\xb4\x20\xb5\x00" "\xb6\xaf"
+        ,
+        "\xbb\xae\xbc\x4f\xbd\x4e\xbe\x6a" "\xbf\x68\xc0\xaa\xc1\xc0\xc2\x01"
+        "\xc3\x4e\xc6\x85\xc7\x81\xc9\xe0" "\xca\xe8\xcb\xf0\xcc\xd8\xcd\x93"
+        ,
+        "\xd0\x01\xd1\x08\xd2\xe0\xd3\x01" "\xd4\x10\xd5\x80"
+};
+
+static u8 *tbl_800[] = {
+        "\x00\x40\x07\x6a\x06\xf3\x0d\x6a" "\x10\x10\xc1\x01"
+        ,
+        "\x12\x80\x00\x00\x01\x98\x02\x80" "\x03\x12\x04\x01\x0b\x57\x0e\x61"
+        "\x0f\x42\x11\x00\x12\x00\x13\x00" "\x14\x3a\x16\x24\x17\x1b\x18\xbb"
+        "\x19\x01\x1a\x81\x1e\x04\x24\x3c" "\x25\x36\x26\x72\x27\x08\x28\x08"
+        "\x29\x15\x2a\x00\x2b\x00\x2c\x08"
+        ,
+        "\x32\xa4\x33\x00\x34\x3d\x35\x00" "\x36\xf8\x38\x72\x39\x57\x3a\x00"
+        "\x3b\x0c\x3d\x99\x3e\x0c\x3f\xc2" "\x40\xc0\x41\x00\x42\xc0\x43\x0a"
+        "\x44\xf0\x45\x46\x46\x62\x47\x2a" "\x48\x3c\x4a\xec\x4b\xe8\x4c\xe8"
+        "\x4d\xe8\x4e\xe8"
+        ,
+        "\x4f\x98\x50\x98\x51\x00\x52\x28" "\x53\x70\x54\x98\x58\x1a\x59\x85"
+        "\x5a\xa9\x5b\x64\x5c\x84\x5d\x53" "\x5e\x0e\x5f\xf0\x60\xf0\x61\xf0"
+        "\x62\x00\x63\x00\x64\x02\x65\x20" "\x66\x00\x69\x02\x6b\x5a\x6c\x04"
+        "\x6d\x55\x6e\x00\x6f\x9d"
+        ,
+        "\x70\x08\x71\x78\x72\x00\x73\x01" "\x74\x3a\x75\x35\x76\x01\x77\x02"
+        "\x7a\x24\x7b\x04\x7c\x07\x7d\x10" "\x7e\x28\x7f\x36\x80\x44\x81\x52"
+        "\x82\x60\x83\x6c\x84\x78\x85\x8c" "\x86\x9e\x87\xbb\x88\xd2\x89\xe5"
+        "\x8a\x23\x8c\x0d\x90\x90\x91\x90"
+        ,
+        "\x9d\x02\x9e\x02\x9f\x94\xa0\x94" "\xa1\x01\xa4\x50\xa5\x68\xa6\x70"
+        "\xa8\xc1\xa9\xef\xaa\x92\xab\x04" "\xac\x80\xad\x80\xae\x80\xaf\x80"
+        "\xb2\xf2\xb3\x20\xb4\x20\xb5\x00" "\xb6\xaf"
+        ,
+        "\xbb\xae\xbc\x38\xbd\x39\xbe\x01" "\xbf\x01\xc0\xe2\xc1\xc0\xc2\x01"
+        "\xc3\x4e\xc6\x85\xc7\x81\xc9\xe0" "\xca\xe8\xcb\xf0\xcc\xd8\xcd\x93"
+        ,
+        "\xd0\x21\xd1\x18\xd2\xe0\xd3\x01" "\xd4\x28\xd5\x00"
+};
+
+static u8 c04[] = {0x04};
+static u8 dat_post_1[] = "\x04\x00\x10\x20\xa1\x00\x00\x02";
+static u8 dat_post_2[] = "\x10\x10\xc1\x02";
+static u8 dat_post_3[] = "\x04\x00\x10\x7c\xa1\x00\x00\x04";
+static u8 dat_post_4[] = "\x10\x02\xc1\x06";
+static u8 dat_post_5[] = "\x04\x00\x10\x7b\xa1\x00\x00\x08";
+static u8 dat_post_6[] = "\x10\x10\xc1\x05";
+static u8 dat_post_7[] = "\x04\x00\x10\x7c\xa1\x00\x00\x08";
+static u8 dat_post_8[] = "\x04\x00\x10\x7c\xa1\x00\x00\x09";
+
+static struct validx tbl_init_post_alt[] = {
+        {0x6032, 0x00ff}, {0x6032, 0x00ff}, {0x6032, 0x00ff}, {0x603c, 0x00ff},
+        {0x6003, 0x00ff}, {0x6032, 0x00ff}, {0x6032, 0x00ff}, {0x6001, 0x00ff},
+        {0x6000, 0x801e},
+        {0xffff, 0xffff},
+        {0x6004, 0x001e}, {0x6000, 0x801e},
+        {0xffff, 0xffff},
+        {0x6004, 0x001e}, {0x6012, 0x0003}, {0x6000, 0x801e},
+        {0xffff, 0xffff},
+        {0x6004, 0x001e}, {0x6000, 0x801e},
+        {0xffff, 0xffff},
+        {0x6004, 0x001e}, {0x6012, 0x0003},
+        {0xffff, 0xffff},
+        {0x6000, 0x801e},
+        {0xffff, 0xffff},
+        {0x6004, 0x001e}, {0x6000, 0x801e},
+        {0xffff, 0xffff},
+        {0x6004, 0x001e}, {0x6012, 0x0003}, {0x6000, 0x801e},
+        {0xffff, 0xffff},
+        {0x6004, 0x001e}, {0x6000, 0x801e},
+        {0xffff, 0xffff},
+        {0x6004, 0x001e}, {0x6012, 0x0003},
+        {0xffff, 0xffff},
+        {0x6000, 0x801e},
+        {0xffff, 0xffff},
+        {0x6004, 0x001e}, {0x6000, 0x801e},
+        {0xffff, 0xffff},
+        {0x6004, 0x001e}, {0x6012, 0x0003},
+};
+
+static int  ov9655_init_at_startup(struct gspca_dev *gspca_dev);
+static int  ov9655_configure_alt(struct gspca_dev *gspca_dev);
+static int  ov9655_init_pre_alt(struct gspca_dev *gspca_dev);
+static int  ov9655_init_post_alt(struct gspca_dev *gspca_dev);
+static void ov9655_post_unset_alt(struct gspca_dev *gspca_dev);
+static int  ov9655_camera_settings(struct gspca_dev *gspca_dev);
+/*==========================================================================*/
+
+void ov9655_init_settings(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->vcur.backlight  =   0;
+        sd->vcur.brightness = 128;
+        sd->vcur.sharpness  =   0;
+        sd->vcur.contrast   =   0;
+        sd->vcur.gamma      =   0;
+        sd->vcur.hue        =   0;
+        sd->vcur.saturation =   0;
+        sd->vcur.whitebal   =   0;
+
+        sd->vmax.backlight  =   0;
+        sd->vmax.brightness = 255;
+        sd->vmax.sharpness  =   0;
+        sd->vmax.contrast   =   0;
+        sd->vmax.gamma      =   0;
+        sd->vmax.hue        =   0 + 1;
+        sd->vmax.saturation =   0;
+        sd->vmax.whitebal   =   0;
+        sd->vmax.mirror     = 0;
+        sd->vmax.flip       = 0;
+        sd->vmax.AC50Hz     = 0;
+
+        sd->dev_camera_settings = ov9655_camera_settings;
+        sd->dev_init_at_startup = ov9655_init_at_startup;
+        sd->dev_configure_alt   = ov9655_configure_alt;
+        sd->dev_init_pre_alt    = ov9655_init_pre_alt;
+        sd->dev_post_unset_alt  = ov9655_post_unset_alt;
+}
+
+/*==========================================================================*/
+
+static int ov9655_init_at_startup(struct gspca_dev *gspca_dev)
+{
+        fetch_validx(gspca_dev, tbl_init_at_startup,
+                        ARRAY_SIZE(tbl_init_at_startup));
+        fetch_validx(gspca_dev, tbl_commmon, ARRAY_SIZE(tbl_commmon));
+/*      ctrl_out(gspca_dev, 0x40, 11, 0x0000, 0x0000, 0, NULL);*/
+
+        return 0;
+}
+
+static int ov9655_init_pre_alt(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->vold.brightness = -1;
+        sd->vold.hue = -1;
+
+        fetch_validx(gspca_dev, tbl_commmon, ARRAY_SIZE(tbl_commmon));
+
+        ov9655_init_post_alt(gspca_dev);
+
+        return 0;
+}
+
+static int ov9655_init_post_alt(struct gspca_dev *gspca_dev)
+{
+        s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
+        s32 n; /* reserved for FETCH macros */
+        s32 i;
+        u8 **tbl;
+
+        ctrl_out(gspca_dev, 0x40, 5, 0x0001, 0x0000, 0, NULL);
+
+        tbl = (reso == IMAGE_640) ? tbl_640 : tbl_800;
+
+        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
+                        tbl_length[0], tbl[0]);
+        for (i = 1; i < 7; i++)
+                ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200,
+                                tbl_length[i], tbl[i]);
+        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
+                        tbl_length[7], tbl[7]);
+
+        n = fetch_validx(gspca_dev, tbl_init_post_alt,
+                        ARRAY_SIZE(tbl_init_post_alt));
+
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+        ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_1);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+        ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_1);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+        ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
+        keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
+                                        ARRAY_SIZE(tbl_init_post_alt), n);
+
+        ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_1);
+
+        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 4, dat_post_2);
+        ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_3);
+
+        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 4, dat_post_4);
+        ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_5);
+
+        ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 4, dat_post_6);
+        ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_7);
+
+        ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_8);
+
+        ov9655_camera_settings(gspca_dev);
+
+        return 0;
+}
+
+static int ov9655_configure_alt(struct gspca_dev *gspca_dev)
+{
+        s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
+
+        switch (reso) {
+        case IMAGE_640:
+                gspca_dev->alt = 1 + 1;
+                break;
+
+        default:
+                gspca_dev->alt = 1 + 1;
+                break;
+        }
+        return 0;
+}
+
+static int ov9655_camera_settings(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        u8 dat_bright[] = "\x04\x00\x10\x7c\xa1\x00\x00\x70";
+
+        s32 bright = sd->vcur.brightness;
+        s32 hue    = sd->vcur.hue;
+
+        if (bright != sd->vold.brightness) {
+                sd->vold.brightness = bright;
+                if (bright < 0 || bright > sd->vmax.brightness)
+                        bright = 0;
+
+                dat_bright[3] = bright;
+                ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_bright);
+        }
+
+        if (hue != sd->vold.hue) {
+                sd->vold.hue = hue;
+                sd->swapRB = (hue != 0);
+        }
+
+        return 0;
+}
+
+static void ov9655_post_unset_alt(struct gspca_dev *gspca_dev)
+{
+        ctrl_out(gspca_dev, 0x40, 5, 0x0000, 0x0000, 0, NULL);
+        ctrl_out(gspca_dev, 0x40, 1, 0x0061, 0x0000, 0, NULL);
+}
diff --git a/drivers/media/video/gspca/gl860/gl860.c b/drivers/media/video/gspca/gl860/gl860.c
new file mode 100644
index 000000000000..6ef59ac7f502
--- /dev/null
+++ b/drivers/media/video/gspca/gl860/gl860.c
@@ -0,0 +1,785 @@
+/* @file gl860.c
+ * @date 2009-08-27
+ *
+ * Genesys Logic webcam with gl860 subdrivers
+ *
+ * Driver by Olivier Lorin <o.lorin@laposte.net>
+ * GSPCA by Jean-Francois Moine <http://moinejf.free.fr>
+ * Thanks BUGabundo and Malmostoso for your amazing help!
+ *
+ * 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
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#include "gspca.h"
+#include "gl860.h"
+
+MODULE_AUTHOR("Olivier Lorin <lorin@laposte.net>");
+MODULE_DESCRIPTION("GSPCA/Genesys Logic GL860 USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+/*======================== static function declarations ====================*/
+
+static void (*dev_init_settings)(struct gspca_dev *gspca_dev);
+
+static int  sd_config(struct gspca_dev *gspca_dev,
+                        const struct usb_device_id *id);
+static int  sd_init(struct gspca_dev *gspca_dev);
+static int  sd_isoc_init(struct gspca_dev *gspca_dev);
+static int  sd_start(struct gspca_dev *gspca_dev);
+static void sd_stop0(struct gspca_dev *gspca_dev);
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        struct gspca_frame *frame, u8 *data, s32 len);
+static void sd_callback(struct gspca_dev *gspca_dev);
+
+static int gl860_guess_sensor(struct gspca_dev *gspca_dev,
+                                s32 vendor_id, s32 product_id);
+
+/*============================ driver options ==============================*/
+
+static s32 AC50Hz = 0xff;
+module_param(AC50Hz, int, 0644);
+MODULE_PARM_DESC(AC50Hz, " Does AC power frequency is 50Hz? (0/1)");
+
+static char sensor[7];
+module_param_string(sensor, sensor, sizeof(sensor), 0644);
+MODULE_PARM_DESC(sensor,
+                " Driver sensor ('MI1320'/'MI2020'/'OV9655'/'OV2640'/'')");
+
+/*============================ webcam controls =============================*/
+
+/* Functions to get and set a control value */
+#define SD_SETGET(thename) \
+static int sd_set_##thename(struct gspca_dev *gspca_dev, s32 val)\
+{\
+        struct sd *sd = (struct sd *) gspca_dev;\
+\
+        sd->vcur.thename = val;\
+        if (gspca_dev->streaming)\
+                sd->dev_camera_settings(gspca_dev);\
+        return 0;\
+} \
+static int sd_get_##thename(struct gspca_dev *gspca_dev, s32 *val)\
+{\
+        struct sd *sd = (struct sd *) gspca_dev;\
+\
+        *val = sd->vcur.thename;\
+        return 0;\
+}
+
+SD_SETGET(mirror)
+SD_SETGET(flip)
+SD_SETGET(AC50Hz)
+SD_SETGET(backlight)
+SD_SETGET(brightness)
+SD_SETGET(gamma)
+SD_SETGET(hue)
+SD_SETGET(saturation)
+SD_SETGET(sharpness)
+SD_SETGET(whitebal)
+SD_SETGET(contrast)
+
+#define GL860_NCTRLS 11
+
+/* control table */
+static struct ctrl sd_ctrls_mi1320[GL860_NCTRLS];
+static struct ctrl sd_ctrls_mi2020[GL860_NCTRLS];
+static struct ctrl sd_ctrls_mi2020b[GL860_NCTRLS];
+static struct ctrl sd_ctrls_ov2640[GL860_NCTRLS];
+static struct ctrl sd_ctrls_ov9655[GL860_NCTRLS];
+
+#define SET_MY_CTRL(theid, \
+        thetype, thelabel, thename) \
+        if (sd->vmax.thename != 0) {\
+                sd_ctrls[nCtrls].qctrl.id   = theid;\
+                sd_ctrls[nCtrls].qctrl.type = thetype;\
+                strcpy(sd_ctrls[nCtrls].qctrl.name, thelabel);\
+                sd_ctrls[nCtrls].qctrl.minimum = 0;\
+                sd_ctrls[nCtrls].qctrl.maximum = sd->vmax.thename;\
+                sd_ctrls[nCtrls].qctrl.default_value = sd->vcur.thename;\
+                sd_ctrls[nCtrls].qctrl.step = \
+                        (sd->vmax.thename < 16) ? 1 : sd->vmax.thename/16;\
+                sd_ctrls[nCtrls].set = sd_set_##thename;\
+                sd_ctrls[nCtrls].get = sd_get_##thename;\
+                nCtrls++;\
+        }
+
+static int gl860_build_control_table(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct ctrl *sd_ctrls;
+        int nCtrls = 0;
+
+        if (_MI1320_)
+                sd_ctrls = sd_ctrls_mi1320;
+        else if (_MI2020_)
+                sd_ctrls = sd_ctrls_mi2020;
+        else if (_MI2020b_)
+                sd_ctrls = sd_ctrls_mi2020b;
+        else if (_OV2640_)
+                sd_ctrls = sd_ctrls_ov2640;
+        else if (_OV9655_)
+                sd_ctrls = sd_ctrls_ov9655;
+        else
+                return 0;
+
+        memset(sd_ctrls, 0, GL860_NCTRLS * sizeof(struct ctrl));
+
+        SET_MY_CTRL(V4L2_CID_BRIGHTNESS,
+                V4L2_CTRL_TYPE_INTEGER, "Brightness", brightness)
+        SET_MY_CTRL(V4L2_CID_SHARPNESS,
+                V4L2_CTRL_TYPE_INTEGER, "Sharpness", sharpness)
+        SET_MY_CTRL(V4L2_CID_CONTRAST,
+                V4L2_CTRL_TYPE_INTEGER, "Contrast", contrast)
+        SET_MY_CTRL(V4L2_CID_GAMMA,
+                V4L2_CTRL_TYPE_INTEGER, "Gamma", gamma)
+        SET_MY_CTRL(V4L2_CID_HUE,
+                V4L2_CTRL_TYPE_INTEGER, "Palette", hue)
+        SET_MY_CTRL(V4L2_CID_SATURATION,
+                V4L2_CTRL_TYPE_INTEGER, "Saturation", saturation)
+        SET_MY_CTRL(V4L2_CID_WHITE_BALANCE_TEMPERATURE,
+                V4L2_CTRL_TYPE_INTEGER, "White Bal.", whitebal)
+        SET_MY_CTRL(V4L2_CID_BACKLIGHT_COMPENSATION,
+                V4L2_CTRL_TYPE_INTEGER, "Backlight" , backlight)
+
+        SET_MY_CTRL(V4L2_CID_HFLIP,
+                V4L2_CTRL_TYPE_BOOLEAN, "Mirror", mirror)
+        SET_MY_CTRL(V4L2_CID_VFLIP,
+                V4L2_CTRL_TYPE_BOOLEAN, "Flip", flip)
+        SET_MY_CTRL(V4L2_CID_POWER_LINE_FREQUENCY,
+                V4L2_CTRL_TYPE_BOOLEAN, "50Hz", AC50Hz)
+
+        return nCtrls;
+}
+
+/*==================== sud-driver structure initialisation =================*/
+
+static struct sd_desc sd_desc_mi1320 = {
+        .name        = MODULE_NAME,
+        .ctrls       = sd_ctrls_mi1320,
+        .nctrls      = GL860_NCTRLS,
+        .config      = sd_config,
+        .init        = sd_init,
+        .isoc_init   = sd_isoc_init,
+        .start       = sd_start,
+        .stop0       = sd_stop0,
+        .pkt_scan    = sd_pkt_scan,
+        .dq_callback = sd_callback,
+};
+
+static struct sd_desc sd_desc_mi2020 = {
+        .name        = MODULE_NAME,
+        .ctrls       = sd_ctrls_mi2020,
+        .nctrls      = GL860_NCTRLS,
+        .config      = sd_config,
+        .init        = sd_init,
+        .isoc_init   = sd_isoc_init,
+        .start       = sd_start,
+        .stop0       = sd_stop0,
+        .pkt_scan    = sd_pkt_scan,
+        .dq_callback = sd_callback,
+};
+
+static struct sd_desc sd_desc_mi2020b = {
+        .name        = MODULE_NAME,
+        .ctrls       = sd_ctrls_mi2020b,
+        .nctrls      = GL860_NCTRLS,
+        .config      = sd_config,
+        .init        = sd_init,
+        .isoc_init   = sd_isoc_init,
+        .start       = sd_start,
+        .stop0       = sd_stop0,
+        .pkt_scan    = sd_pkt_scan,
+        .dq_callback = sd_callback,
+};
+
+static struct sd_desc sd_desc_ov2640 = {
+        .name        = MODULE_NAME,
+        .ctrls       = sd_ctrls_ov2640,
+        .nctrls      = GL860_NCTRLS,
+        .config      = sd_config,
+        .init        = sd_init,
+        .isoc_init   = sd_isoc_init,
+        .start       = sd_start,
+        .stop0       = sd_stop0,
+        .pkt_scan    = sd_pkt_scan,
+        .dq_callback = sd_callback,
+};
+
+static struct sd_desc sd_desc_ov9655 = {
+        .name        = MODULE_NAME,
+        .ctrls       = sd_ctrls_ov9655,
+        .nctrls      = GL860_NCTRLS,
+        .config      = sd_config,
+        .init        = sd_init,
+        .isoc_init   = sd_isoc_init,
+        .start       = sd_start,
+        .stop0       = sd_stop0,
+        .pkt_scan    = sd_pkt_scan,
+        .dq_callback = sd_callback,
+};
+
+/*=========================== sub-driver image sizes =======================*/
+
+static struct v4l2_pix_format mi2020_mode[] = {
+        { 640,  480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0
+        },
+        { 800,  600, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 800,
+                .sizeimage = 800 * 600,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 1
+        },
+        {1280, 1024, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 1280,
+                .sizeimage = 1280 * 1024,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 2
+        },
+        {1600, 1200, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 1600,
+                .sizeimage = 1600 * 1200,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 3
+        },
+};
+
+static struct v4l2_pix_format ov2640_mode[] = {
+        { 640,  480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0
+        },
+        { 800,  600, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 800,
+                .sizeimage = 800 * 600,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 1
+        },
+        {1280,  960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 1280,
+                .sizeimage = 1280 * 960,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 2
+        },
+        {1600, 1200, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 1600,
+                .sizeimage = 1600 * 1200,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 3
+        },
+};
+
+static struct v4l2_pix_format mi1320_mode[] = {
+        { 640,  480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0
+        },
+        { 800,  600, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 800,
+                .sizeimage = 800 * 600,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 1
+        },
+        {1280,  960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 1280,
+                .sizeimage = 1280 * 960,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 2
+        },
+};
+
+static struct v4l2_pix_format ov9655_mode[] = {
+        { 640,  480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0
+        },
+        {1280,  960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
+                .bytesperline = 1280,
+                .sizeimage = 1280 * 960,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 1
+        },
+};
+
+/*========================= sud-driver functions ===========================*/
+
+/* This function is called at probe time */
+static int sd_config(struct gspca_dev *gspca_dev,
+                        const struct usb_device_id *id)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        struct cam *cam;
+        s32 vendor_id, product_id;
+
+        /* Get USB VendorID and ProductID */
+        vendor_id  = le16_to_cpu(id->idVendor);
+        product_id = le16_to_cpu(id->idProduct);
+
+        sd->nbRightUp = 1;
+        sd->nbIm = -1;
+
+        sd->sensor = 0xff;
+        if (strcmp(sensor, "MI1320") == 0)
+                sd->sensor = ID_MI1320;
+        else if (strcmp(sensor, "OV2640") == 0)
+                sd->sensor = ID_OV2640;
+        else if (strcmp(sensor, "OV9655") == 0)
+                sd->sensor = ID_OV9655;
+        else if (strcmp(sensor, "MI2020") == 0)
+                sd->sensor = ID_MI2020;
+        else if (strcmp(sensor, "MI2020b") == 0)
+                sd->sensor = ID_MI2020b;
+
+        /* Get sensor and set the suitable init/start/../stop functions */
+        if (gl860_guess_sensor(gspca_dev, vendor_id, product_id) == -1)
+                return -1;
+
+        cam = &gspca_dev->cam;
+        gspca_dev->nbalt = 4;
+
+        switch (sd->sensor) {
+        case ID_MI1320:
+                gspca_dev->sd_desc = &sd_desc_mi1320;
+                cam->cam_mode = mi1320_mode;
+                cam->nmodes = ARRAY_SIZE(mi1320_mode);
+                dev_init_settings   = mi1320_init_settings;
+                break;
+
+        case ID_MI2020:
+                gspca_dev->sd_desc = &sd_desc_mi2020;
+                cam->cam_mode = mi2020_mode;
+                cam->nmodes = ARRAY_SIZE(mi2020_mode);
+                dev_init_settings   = mi2020_init_settings;
+                break;
+
+        case ID_MI2020b:
+                gspca_dev->sd_desc = &sd_desc_mi2020b;
+                cam->cam_mode = mi2020_mode;
+                cam->nmodes = ARRAY_SIZE(mi2020_mode);
+                dev_init_settings   = mi2020_init_settings;
+                break;
+
+        case ID_OV2640:
+                gspca_dev->sd_desc = &sd_desc_ov2640;
+                cam->cam_mode = ov2640_mode;
+                cam->nmodes = ARRAY_SIZE(ov2640_mode);
+                dev_init_settings   = ov2640_init_settings;
+                break;
+
+        case ID_OV9655:
+                gspca_dev->sd_desc = &sd_desc_ov9655;
+                cam->cam_mode = ov9655_mode;
+                cam->nmodes = ARRAY_SIZE(ov9655_mode);
+                dev_init_settings   = ov9655_init_settings;
+                break;
+        }
+
+        dev_init_settings(gspca_dev);
+        if (AC50Hz != 0xff)
+                ((struct sd *) gspca_dev)->vcur.AC50Hz = AC50Hz;
+        gl860_build_control_table(gspca_dev);
+
+        return 0;
+}
+
+/* This function is called at probe time after sd_config */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return sd->dev_init_at_startup(gspca_dev);
+}
+
+/* This function is called before to choose the alt setting */
+static int sd_isoc_init(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return sd->dev_configure_alt(gspca_dev);
+}
+
+/* This function is called to start the webcam */
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return sd->dev_init_pre_alt(gspca_dev);
+}
+
+/* This function is called to stop the webcam */
+static void sd_stop0(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        return sd->dev_post_unset_alt(gspca_dev);
+}
+
+/* This function is called when an image is being received */
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                        struct gspca_frame *frame, u8 *data, s32 len)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        static s32 nSkipped;
+
+        s32 mode = (s32) gspca_dev->curr_mode;
+        s32 nToSkip =
+                sd->swapRB * (gspca_dev->cam.cam_mode[mode].bytesperline + 1);
+
+        /* Test only against 0202h, so endianess does not matter */
+        switch (*(s16 *) data) {
+        case 0x0202:            /* End of frame, start a new one */
+                frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame, data, 0);
+                nSkipped = 0;
+                if (sd->nbIm >= 0 && sd->nbIm < 10)
+                        sd->nbIm++;
+                gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, 0);
+                break;
+
+        default:
+                data += 2;
+                len  -= 2;
+                if (nSkipped + len <= nToSkip)
+                        nSkipped += len;
+                else {
+                        if (nSkipped < nToSkip && nSkipped + len > nToSkip) {
+                                data += nToSkip - nSkipped;
+                                len  -= nToSkip - nSkipped;
+                                nSkipped = nToSkip + 1;
+                        }
+                        gspca_frame_add(gspca_dev,
+                                INTER_PACKET, frame, data, len);
+                }
+                break;
+        }
+}
+
+/* This function is called when an image has been read */
+/* This function is used to monitor webcam orientation */
+static void sd_callback(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (!_OV9655_) {
+                u8 state;
+                u8 upsideDown;
+
+                /* Probe sensor orientation */
+                ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, (void *)&state);
+
+                /* C8/40 means upside-down (looking backwards) */
+                /* D8/50 means right-up (looking onwards) */
+                upsideDown = (state == 0xc8 || state == 0x40);
+
+                if (upsideDown && sd->nbRightUp > -4) {
+                        if (sd->nbRightUp > 0)
+                                sd->nbRightUp = 0;
+                        if (sd->nbRightUp == -3) {
+                                sd->mirrorMask = 1;
+                                sd->waitSet = 1;
+                        }
+                        sd->nbRightUp--;
+                }
+                if (!upsideDown && sd->nbRightUp < 4) {
+                        if (sd->nbRightUp  < 0)
+                                sd->nbRightUp = 0;
+                        if (sd->nbRightUp == 3) {
+                                sd->mirrorMask = 0;
+                                sd->waitSet = 1;
+                        }
+                        sd->nbRightUp++;
+                }
+        }
+
+        if (sd->waitSet)
+                sd->dev_camera_settings(gspca_dev);
+}
+
+/*=================== USB driver structure initialisation ==================*/
+
+static const __devinitdata struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x05e3, 0x0503)},
+        {USB_DEVICE(0x05e3, 0xf191)},
+        {}
+};
+
+MODULE_DEVICE_TABLE(usb, device_table);
+
+static int sd_probe(struct usb_interface *intf,
+                                const struct usb_device_id *id)
+{
+        struct gspca_dev *gspca_dev;
+        s32 ret;
+
+        ret = gspca_dev_probe(intf, id,
+                        &sd_desc_mi1320, sizeof(struct sd), THIS_MODULE);
+
+        if (ret >= 0) {
+                gspca_dev = usb_get_intfdata(intf);
+
+                PDEBUG(D_PROBE,
+                        "Camera is now controlling video device /dev/video%d",
+                        gspca_dev->vdev.minor);
+        }
+
+        return ret;
+}
+
+static void sd_disconnect(struct usb_interface *intf)
+{
+        gspca_disconnect(intf);
+}
+
+static struct usb_driver sd_driver = {
+        .name       = MODULE_NAME,
+        .id_table   = device_table,
+        .probe      = sd_probe,
+        .disconnect = sd_disconnect,
+#ifdef CONFIG_PM
+        .suspend    = gspca_suspend,
+        .resume     = gspca_resume,
+#endif
+};
+
+/*====================== Init and Exit module functions ====================*/
+
+static int __init sd_mod_init(void)
+{
+        PDEBUG(D_PROBE, "driver startup - version %s", DRIVER_VERSION);
+
+        if (usb_register(&sd_driver) < 0)
+                return -1;
+        PDEBUG(D_PROBE, "driver registered");
+
+        return 0;
+}
+
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+        PDEBUG(D_PROBE, "driver deregistered");
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
+
+/*==========================================================================*/
+
+int gl860_RTx(struct gspca_dev *gspca_dev,
+                unsigned char pref, u32 req, u16 val, u16 index,
+                s32 len, void *pdata)
+{
+        struct usb_device *udev = gspca_dev->dev;
+        s32 r = 0;
+
+        if (pref == 0x40) { /* Send */
+                if (len > 0) {
+                        memcpy(gspca_dev->usb_buf, pdata, len);
+                        r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                        req, pref, val, index,
+                                        gspca_dev->usb_buf,
+                                        len, 400 + 200 * (len > 1));
+                } else {
+                        r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                        req, pref, val, index, NULL, len, 400);
+                }
+        } else { /* Receive */
+                if (len > 0) {
+                        r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                                        req, pref, val, index,
+                                        gspca_dev->usb_buf,
+                                        len, 400 + 200 * (len > 1));
+                        memcpy(pdata, gspca_dev->usb_buf, len);
+                } else {
+                        r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                                        req, pref, val, index, NULL, len, 400);
+                }
+        }
+
+        if (r < 0)
+                PDEBUG(D_ERR,
+                        "ctrl transfer failed %4d "
+                        "[p%02x r%d v%04x i%04x len%d]",
+                        r, pref, req, val, index, len);
+        else if (len > 1 && r < len)
+                PDEBUG(D_ERR, "short ctrl transfer %d/%d", r, len);
+
+        if ((_MI2020_ || _MI2020b_ || _MI2020c_) && (val || index))
+                msleep(1);
+        if (_OV2640_)
+                msleep(1);
+
+        return r;
+}
+
+int fetch_validx(struct gspca_dev *gspca_dev, struct validx *tbl, int len)
+{
+        int n;
+
+        for (n = 0; n < len; n++) {
+                if (tbl[n].idx != 0xffff)
+                        ctrl_out(gspca_dev, 0x40, 1, tbl[n].val,
+                                        tbl[n].idx, 0, NULL);
+                else if (tbl[n].val == 0xffff)
+                        break;
+                else
+                        msleep(tbl[n].val);
+        }
+        return n;
+}
+
+int keep_on_fetching_validx(struct gspca_dev *gspca_dev, struct validx *tbl,
+                                int len, int n)
+{
+        while (++n < len) {
+                if (tbl[n].idx != 0xffff)
+                        ctrl_out(gspca_dev, 0x40, 1, tbl[n].val, tbl[n].idx,
+                                        0, NULL);
+                else if (tbl[n].val == 0xffff)
+                        break;
+                else
+                        msleep(tbl[n].val);
+        }
+        return n;
+}
+
+void fetch_idxdata(struct gspca_dev *gspca_dev, struct idxdata *tbl, int len)
+{
+        int n;
+
+        for (n = 0; n < len; n++) {
+                if (memcmp(tbl[n].data, "\xff\xff\xff", 3) != 0)
+                        ctrl_out(gspca_dev, 0x40, 3, 0x7a00, tbl[n].idx,
+                                        3, tbl[n].data);
+                else
+                        msleep(tbl[n].idx);
+        }
+}
+
+static int gl860_guess_sensor(struct gspca_dev *gspca_dev,
+                                s32 vendor_id, s32 product_id)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        u8 probe, nb26, nb96, nOV, ntry;
+
+        if (product_id == 0xf191)
+                sd->sensor = ID_MI1320;
+
+        if (sd->sensor == 0xff) {
+                ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0004, 1, &probe);
+                ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0004, 1, &probe);
+
+                ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x0000, 0, NULL);
+                msleep(3);
+                ctrl_out(gspca_dev, 0x40, 1, 0x0010, 0x0010, 0, NULL);
+                msleep(3);
+                ctrl_out(gspca_dev, 0x40, 1, 0x0008, 0x00c0, 0, NULL);
+                msleep(3);
+                ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x00c1, 0, NULL);
+                msleep(3);
+                ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x00c2, 0, NULL);
+                msleep(3);
+                ctrl_out(gspca_dev, 0x40, 1, 0x0020, 0x0006, 0, NULL);
+                msleep(3);
+                ctrl_out(gspca_dev, 0x40, 1, 0x006a, 0x000d, 0, NULL);
+                msleep(56);
+
+                nOV = 0;
+                for (ntry = 0; ntry < 4; ntry++) {
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000, 0, NULL);
+                        msleep(3);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x0063, 0x0006, 0, NULL);
+                        msleep(3);
+                        ctrl_out(gspca_dev, 0x40, 1, 0x7a00, 0x8030, 0, NULL);
+                        msleep(10);
+                        ctrl_in(gspca_dev, 0xc0, 2, 0x7a00, 0x8030, 1, &probe);
+                        PDEBUG(D_PROBE, "1st probe=%02x", probe);
+                        if (probe == 0xff)
+                                nOV++;
+                }
+
+                if (nOV) {
+                        PDEBUG(D_PROBE, "0xff -> sensor OVXXXX");
+                        PDEBUG(D_PROBE, "Probing for sensor OV2640 or OV9655");
+
+                        nb26 = nb96 = 0;
+                        for (ntry = 0; ntry < 4; ntry++) {
+                                ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000,
+                                                0, NULL);
+                                msleep(3);
+                                ctrl_out(gspca_dev, 0x40, 1, 0x6000, 0x800a,
+                                                0, NULL);
+                                msleep(10);
+                                /* Wait for 26(OV2640) or 96(OV9655) */
+                                ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x800a,
+                                                1, &probe);
+
+                                PDEBUG(D_PROBE, "2nd probe=%02x", probe);
+                                if (probe == 0x00)
+                                        nb26++;
+                                if (probe == 0x26 || probe == 0x40) {
+                                        sd->sensor = ID_OV2640;
+                                        nb26 += 4;
+                                        break;
+                                }
+                                if (probe == 0x96 || probe == 0x55) {
+                                        sd->sensor = ID_OV9655;
+                                        nb96 += 4;
+                                        break;
+                                }
+                                if (probe == 0xff)
+                                        nb96++;
+                                msleep(3);
+                        }
+                        if (nb26 < 4 && nb96 < 4) {
+                                PDEBUG(D_PROBE, "No relevant answer ");
+                                PDEBUG(D_PROBE, "* 1.3Mpixels -> use OV9655");
+                                PDEBUG(D_PROBE, "* 2.0Mpixels -> use OV2640");
+                                PDEBUG(D_PROBE,
+                                        "To force a sensor, add that line to "
+                                        "/etc/modprobe.d/options.conf:");
+                                PDEBUG(D_PROBE, "options gspca_gl860 "
+                                        "sensor=\"OV2640\" or \"OV9655\"");
+                                return -1;
+                        }
+                } else { /* probe = 0 */
+                        PDEBUG(D_PROBE, "No 0xff -> sensor MI2020");
+                        sd->sensor = ID_MI2020;
+                }
+        }
+
+        if (_MI1320_) {
+                PDEBUG(D_PROBE, "05e3:f191 sensor MI1320 (1.3M)");
+        } else if (_MI2020_) {
+                PDEBUG(D_PROBE, "05e3:0503 sensor MI2020 (2.0M)");
+        } else if (_MI2020b_) {
+                PDEBUG(D_PROBE, "05e3:0503 sensor MI2020 alt. driver (2.0M)");
+        } else if (_OV9655_) {
+                PDEBUG(D_PROBE, "05e3:0503 sensor OV9655 (1.3M)");
+        } else if (_OV2640_) {
+                PDEBUG(D_PROBE, "05e3:0503 sensor OV2640 (2.0M)");
+        } else {
+                PDEBUG(D_PROBE, "***** Unknown sensor *****");
+                return -1;
+        }
+
+        return 0;
+}
diff --git a/drivers/media/video/gspca/gl860/gl860.h b/drivers/media/video/gspca/gl860/gl860.h
new file mode 100644
index 000000000000..cef4e24c1e61
--- /dev/null
+++ b/drivers/media/video/gspca/gl860/gl860.h
@@ -0,0 +1,108 @@
+/* @file gl860.h
+ * @author Olivier LORIN, tiré du pilote Syntek par Nicolas VIVIEN
+ * @date 2009-08-27
+ *
+ * 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
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GL860_DEV_H
+#define GL860_DEV_H
+#include <linux/version.h>
+
+#include "gspca.h"
+
+#define MODULE_NAME "gspca_gl860"
+#define DRIVER_VERSION "0.9d10"
+
+#define ctrl_in  gl860_RTx
+#define ctrl_out gl860_RTx
+
+#define ID_MI1320   1
+#define ID_OV2640   2
+#define ID_OV9655   4
+#define ID_MI2020   8
+#define ID_MI2020b 16
+
+#define _MI1320_  (((struct sd *) gspca_dev)->sensor == ID_MI1320)
+#define _MI2020_  (((struct sd *) gspca_dev)->sensor == ID_MI2020)
+#define _MI2020b_ (((struct sd *) gspca_dev)->sensor == ID_MI2020b)
+#define _MI2020c_ 0
+#define _OV2640_  (((struct sd *) gspca_dev)->sensor == ID_OV2640)
+#define _OV9655_  (((struct sd *) gspca_dev)->sensor == ID_OV9655)
+
+#define IMAGE_640   0
+#define IMAGE_800   1
+#define IMAGE_1280  2
+#define IMAGE_1600 3
+
+struct sd_gl860 {
+        u16 backlight;
+        u16 brightness;
+        u16 sharpness;
+        u16 contrast;
+        u16 gamma;
+        u16 hue;
+        u16 saturation;
+        u16 whitebal;
+        u8  mirror;
+        u8  flip;
+        u8  AC50Hz;
+};
+
+/* Specific webcam descriptor */
+struct sd {
+        struct gspca_dev gspca_dev;     /* !! must be the first item */
+
+        struct sd_gl860 vcur;
+        struct sd_gl860 vold;
+        struct sd_gl860 vmax;
+
+        int  (*dev_configure_alt)  (struct gspca_dev *);
+        int  (*dev_init_at_startup)(struct gspca_dev *);
+        int  (*dev_init_pre_alt)   (struct gspca_dev *);
+        void (*dev_post_unset_alt) (struct gspca_dev *);
+        int  (*dev_camera_settings)(struct gspca_dev *);
+
+        u8   swapRB;
+        u8  mirrorMask;
+        u8  sensor;
+        s32 nbIm;
+        s32 nbRightUp;
+        u8   waitSet;
+};
+
+struct validx {
+        u16 val;
+        u16 idx;
+};
+
+struct idxdata {
+        u8 idx;
+        u8 data[3];
+};
+
+int fetch_validx(struct gspca_dev *gspca_dev, struct validx *tbl, int len);
+int keep_on_fetching_validx(struct gspca_dev *gspca_dev, struct validx *tbl,
+                                int len, int n);
+void fetch_idxdata(struct gspca_dev *gspca_dev, struct idxdata *tbl, int len);
+
+int gl860_RTx(struct gspca_dev *gspca_dev,
+                        unsigned char pref, u32 req, u16 val, u16 index,
+                        s32 len, void *pdata);
+
+void mi1320_init_settings(struct gspca_dev *);
+void ov2640_init_settings(struct gspca_dev *);
+void ov9655_init_settings(struct gspca_dev *);
+void mi2020_init_settings(struct gspca_dev *);
+
+#endif
diff --git a/drivers/media/video/gspca/jeilinj.c b/drivers/media/video/gspca/jeilinj.c
index dbfa3ed6e8ef..a11c97ebeb0f 100644
--- a/drivers/media/video/gspca/jeilinj.c
+++ b/drivers/media/video/gspca/jeilinj.c
@@ -312,6 +312,8 @@ static int sd_start(struct gspca_dev *gspca_dev)
 
         /* create the JPEG header */
         dev->jpeg_hdr = kmalloc(JPEG_HDR_SZ, GFP_KERNEL);
+        if (dev->jpeg_hdr == NULL)
+                return -ENOMEM;
         jpeg_define(dev->jpeg_hdr, gspca_dev->height, gspca_dev->width,
                         0x21);          /* JPEG 422 */
         jpeg_set_qual(dev->jpeg_hdr, dev->quality);
diff --git a/drivers/media/video/gspca/m5602/m5602_ov7660.c b/drivers/media/video/gspca/m5602/m5602_ov7660.c
index 7aafeb7cfa07..2a28b74cb3f9 100644
--- a/drivers/media/video/gspca/m5602/m5602_ov7660.c
+++ b/drivers/media/video/gspca/m5602/m5602_ov7660.c
@@ -20,6 +20,18 @@
 
 static int ov7660_get_gain(struct gspca_dev *gspca_dev, __s32 *val);
 static int ov7660_set_gain(struct gspca_dev *gspca_dev, __s32 val);
+static int ov7660_get_auto_white_balance(struct gspca_dev *gspca_dev,
+                                         __s32 *val);
+static int ov7660_set_auto_white_balance(struct gspca_dev *gspca_dev,
+                                         __s32 val);
+static int ov7660_get_auto_gain(struct gspca_dev *gspca_dev, __s32 *val);
+static int ov7660_set_auto_gain(struct gspca_dev *gspca_dev, __s32 val);
+static int ov7660_get_auto_exposure(struct gspca_dev *gspca_dev, __s32 *val);
+static int ov7660_set_auto_exposure(struct gspca_dev *gspca_dev, __s32 val);
+static int ov7660_get_hflip(struct gspca_dev *gspca_dev, __s32 *val);
+static int ov7660_set_hflip(struct gspca_dev *gspca_dev, __s32 val);
+static int ov7660_get_vflip(struct gspca_dev *gspca_dev, __s32 *val);
+static int ov7660_set_vflip(struct gspca_dev *gspca_dev, __s32 val);
 
 const static struct ctrl ov7660_ctrls[] = {
 #define GAIN_IDX 1
@@ -37,6 +49,79 @@ const static struct ctrl ov7660_ctrls[] = {
                 .set = ov7660_set_gain,
                 .get = ov7660_get_gain
         },
+#define BLUE_BALANCE_IDX 2
+#define RED_BALANCE_IDX 3
+#define AUTO_WHITE_BALANCE_IDX 4
+        {
+                {
+                        .id             = V4L2_CID_AUTO_WHITE_BALANCE,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto white balance",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 1
+                },
+                .set = ov7660_set_auto_white_balance,
+                .get = ov7660_get_auto_white_balance
+        },
+#define AUTO_GAIN_CTRL_IDX 5
+        {
+                {
+                        .id             = V4L2_CID_AUTOGAIN,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto gain control",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 1
+                },
+                .set = ov7660_set_auto_gain,
+                .get = ov7660_get_auto_gain
+        },
+#define AUTO_EXPOSURE_IDX 6
+        {
+                {
+                        .id             = V4L2_CID_EXPOSURE_AUTO,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "auto exposure",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 1
+                },
+                .set = ov7660_set_auto_exposure,
+                .get = ov7660_get_auto_exposure
+        },
+#define HFLIP_IDX 7
+        {
+                {
+                        .id             = V4L2_CID_HFLIP,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "horizontal flip",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0
+                },
+                .set = ov7660_set_hflip,
+                .get = ov7660_get_hflip
+        },
+#define VFLIP_IDX 8
+        {
+                {
+                        .id             = V4L2_CID_VFLIP,
+                        .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                        .name           = "vertical flip",
+                        .minimum        = 0,
+                        .maximum        = 1,
+                        .step           = 1,
+                        .default_value  = 0
+                },
+                .set = ov7660_set_vflip,
+                .get = ov7660_get_vflip
+        },
+
 };
 
 static struct v4l2_pix_format ov7660_modes[] = {
@@ -137,7 +222,7 @@ int ov7660_init(struct sd *sd)
                 } else {
                         data[0] = init_ov7660[i][2];
                         err = m5602_write_sensor(sd,
-                                        init_ov7660[i][1], data, 1);
+                                init_ov7660[i][1], data, 1);
                 }
         }
 
@@ -148,6 +233,28 @@ int ov7660_init(struct sd *sd)
         if (err < 0)
                 return err;
 
+        err = ov7660_set_auto_white_balance(&sd->gspca_dev,
+                sensor_settings[AUTO_WHITE_BALANCE_IDX]);
+        if (err < 0)
+                return err;
+
+        err = ov7660_set_auto_gain(&sd->gspca_dev,
+                sensor_settings[AUTO_GAIN_CTRL_IDX]);
+        if (err < 0)
+                return err;
+
+        err = ov7660_set_auto_exposure(&sd->gspca_dev,
+                sensor_settings[AUTO_EXPOSURE_IDX]);
+        if (err < 0)
+                return err;
+        err = ov7660_set_hflip(&sd->gspca_dev,
+                sensor_settings[HFLIP_IDX]);
+        if (err < 0)
+                return err;
+
+        err = ov7660_set_vflip(&sd->gspca_dev,
+                sensor_settings[VFLIP_IDX]);
+
         return err;
 }
 
@@ -194,6 +301,159 @@ static int ov7660_set_gain(struct gspca_dev *gspca_dev, __s32 val)
         return err;
 }
 
+
+static int ov7660_get_auto_white_balance(struct gspca_dev *gspca_dev,
+                                         __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        *val = sensor_settings[AUTO_WHITE_BALANCE_IDX];
+        return 0;
+}
+
+static int ov7660_set_auto_white_balance(struct gspca_dev *gspca_dev,
+                                         __s32 val)
+{
+        int err;
+        u8 i2c_data;
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        PDEBUG(D_V4L2, "Set auto white balance to %d", val);
+
+        sensor_settings[AUTO_WHITE_BALANCE_IDX] = val;
+        err = m5602_read_sensor(sd, OV7660_COM8, &i2c_data, 1);
+        if (err < 0)
+                return err;
+
+        i2c_data = ((i2c_data & 0xfd) | ((val & 0x01) << 1));
+        err = m5602_write_sensor(sd, OV7660_COM8, &i2c_data, 1);
+
+        return err;
+}
+
+static int ov7660_get_auto_gain(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        *val = sensor_settings[AUTO_GAIN_CTRL_IDX];
+        PDEBUG(D_V4L2, "Read auto gain control %d", *val);
+        return 0;
+}
+
+static int ov7660_set_auto_gain(struct gspca_dev *gspca_dev, __s32 val)
+{
+        int err;
+        u8 i2c_data;
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        PDEBUG(D_V4L2, "Set auto gain control to %d", val);
+
+        sensor_settings[AUTO_GAIN_CTRL_IDX] = val;
+        err = m5602_read_sensor(sd, OV7660_COM8, &i2c_data, 1);
+        if (err < 0)
+                return err;
+
+        i2c_data = ((i2c_data & 0xfb) | ((val & 0x01) << 2));
+
+        return m5602_write_sensor(sd, OV7660_COM8, &i2c_data, 1);
+}
+
+static int ov7660_get_auto_exposure(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        *val = sensor_settings[AUTO_EXPOSURE_IDX];
+        PDEBUG(D_V4L2, "Read auto exposure control %d", *val);
+        return 0;
+}
+
+static int ov7660_set_auto_exposure(struct gspca_dev *gspca_dev,
+                                    __s32 val)
+{
+        int err;
+        u8 i2c_data;
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        PDEBUG(D_V4L2, "Set auto exposure control to %d", val);
+
+        sensor_settings[AUTO_EXPOSURE_IDX] = val;
+        err = m5602_read_sensor(sd, OV7660_COM8, &i2c_data, 1);
+        if (err < 0)
+                return err;
+
+        i2c_data = ((i2c_data & 0xfe) | ((val & 0x01) << 0));
+
+        return m5602_write_sensor(sd, OV7660_COM8, &i2c_data, 1);
+}
+
+static int ov7660_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        *val = sensor_settings[HFLIP_IDX];
+        PDEBUG(D_V4L2, "Read horizontal flip %d", *val);
+        return 0;
+}
+
+static int ov7660_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
+{
+        int err;
+        u8 i2c_data;
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        PDEBUG(D_V4L2, "Set horizontal flip to %d", val);
+
+        sensor_settings[HFLIP_IDX] = val;
+
+        i2c_data = ((val & 0x01) << 5) |
+                (sensor_settings[VFLIP_IDX] << 4);
+
+        err = m5602_write_sensor(sd, OV7660_MVFP, &i2c_data, 1);
+
+        return err;
+}
+
+static int ov7660_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        *val = sensor_settings[VFLIP_IDX];
+        PDEBUG(D_V4L2, "Read vertical flip %d", *val);
+
+        return 0;
+}
+
+static int ov7660_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
+{
+        int err;
+        u8 i2c_data;
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        PDEBUG(D_V4L2, "Set vertical flip to %d", val);
+        sensor_settings[VFLIP_IDX] = val;
+
+        i2c_data = ((val & 0x01) << 4) | (sensor_settings[VFLIP_IDX] << 5);
+        err = m5602_write_sensor(sd, OV7660_MVFP, &i2c_data, 1);
+        if (err < 0)
+                return err;
+
+        /* When vflip is toggled we need to readjust the bridge hsync/vsync */
+        if (gspca_dev->streaming)
+                err = ov7660_start(sd);
+
+        return err;
+}
+
 static void ov7660_dump_registers(struct sd *sd)
 {
         int address;
diff --git a/drivers/media/video/gspca/m5602/m5602_ov7660.h b/drivers/media/video/gspca/m5602/m5602_ov7660.h
index 3f2c169a93ea..f5588ebe667c 100644
--- a/drivers/media/video/gspca/m5602/m5602_ov7660.h
+++ b/drivers/media/video/gspca/m5602/m5602_ov7660.h
@@ -66,23 +66,23 @@
 #define OV7660_RBIAS            0x2c
 #define OV7660_HREF             0x32
 #define OV7660_ADC              0x37
-#define OV7660_OFON             0x39
-#define OV7660_TSLB             0x3a
-#define OV7660_COM12            0x3c
-#define OV7660_COM13            0x3d
+#define OV7660_OFON             0x39
+#define OV7660_TSLB             0x3a
+#define OV7660_COM12            0x3c
+#define OV7660_COM13            0x3d
 #define OV7660_LCC1             0x62
 #define OV7660_LCC2             0x63
 #define OV7660_LCC3             0x64
 #define OV7660_LCC4             0x65
 #define OV7660_LCC5             0x66
-#define OV7660_HV               0x69
-#define OV7660_RSVDA1           0xa1
+#define OV7660_HV               0x69
+#define OV7660_RSVDA1           0xa1
 
 #define OV7660_DEFAULT_GAIN             0x0e
-#define OV7660_DEFAULT_RED_GAIN 0x80
+#define OV7660_DEFAULT_RED_GAIN         0x80
 #define OV7660_DEFAULT_BLUE_GAIN        0x80
 #define OV7660_DEFAULT_SATURATION       0x00
-#define OV7660_DEFAULT_EXPOSURE 0x20
+#define OV7660_DEFAULT_EXPOSURE         0x20
 
 /* Kernel module parameters */
 extern int force_sensor;
@@ -149,45 +149,8 @@ static const unsigned char init_ov7660[][4] =
         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0d},
         {BRIDGE, M5602_XB_SENSOR_CTRL, 0x00},
-        {BRIDGE, M5602_XB_GPIO_DIR, 0x03},
-        {BRIDGE, M5602_XB_GPIO_DIR, 0x03},
-        {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
-        {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0c},
-
-        {SENSOR, OV7660_OFON, 0x0c},
-        {SENSOR, OV7660_COM2, 0x11},
-        {SENSOR, OV7660_COM7, 0x05},
-
         {BRIDGE, M5602_XB_GPIO_DIR, 0x01},
-        {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
-        {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
-        {BRIDGE, M5602_XB_GPIO_DIR_H, 0x06},
-        {BRIDGE, M5602_XB_GPIO_DAT_H, 0x00},
-        {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x08},
-        {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
-        {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
-        {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
-        {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
-        {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0c},
-        {BRIDGE, M5602_XB_GPIO_DIR, 0x05},
-        {BRIDGE, M5602_XB_GPIO_DAT, 0x00},
-        {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
-        {BRIDGE, M5602_XB_GPIO_EN_L, 0x00},
-
-        {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x02},
-        {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
-
-        {SENSOR, OV7660_AECH, OV7660_DEFAULT_EXPOSURE},
-        {SENSOR, OV7660_COM1, 0x00},
-
         {BRIDGE, M5602_XB_GPIO_DIR, 0x01},
-        {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
-        {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
-        {BRIDGE, M5602_XB_GPIO_DIR_H, 0x06},
-        {BRIDGE, M5602_XB_GPIO_DAT_H, 0x00},
-        {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x08},
-        {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
-
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
@@ -196,11 +159,8 @@ static const unsigned char init_ov7660[][4] =
         {BRIDGE, M5602_XB_GPIO_DAT, 0x00},
         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
         {BRIDGE, M5602_XB_GPIO_EN_L, 0x00},
-
         {SENSOR, OV7660_COM7, 0x80},
         {SENSOR, OV7660_CLKRC, 0x80},
-        {SENSOR, OV7660_BLUE_GAIN, 0x80},
-        {SENSOR, OV7660_RED_GAIN, 0x80},
         {SENSOR, OV7660_COM9, 0x4c},
         {SENSOR, OV7660_OFON, 0x43},
         {SENSOR, OV7660_COM12, 0x28},
@@ -212,17 +172,17 @@ static const unsigned char init_ov7660[][4] =
         {SENSOR, OV7660_PSHFT, 0x0b},
         {SENSOR, OV7660_VSTART, 0x01},
         {SENSOR, OV7660_VSTOP, 0x7a},
-        {SENSOR, OV7660_VREF, 0x00},
+        {SENSOR, OV7660_VSTOP, 0x00},
         {SENSOR, OV7660_COM7, 0x05},
-        {SENSOR, OV7660_COM6, 0x4b},
-        {SENSOR, OV7660_BBIAS, 0x98},
-        {SENSOR, OV7660_GbBIAS, 0x98},
-        {SENSOR, OV7660_RSVD29, 0x98},
-        {SENSOR, OV7660_RBIAS, 0x98},
+        {SENSOR, OV7660_COM6, 0x42},
+        {SENSOR, OV7660_BBIAS, 0x94},
+        {SENSOR, OV7660_GbBIAS, 0x94},
+        {SENSOR, OV7660_RSVD29, 0x94},
+        {SENSOR, OV7660_RBIAS, 0x94},
         {SENSOR, OV7660_COM1, 0x00},
         {SENSOR, OV7660_AECH, 0x00},
         {SENSOR, OV7660_AECHH, 0x00},
-        {SENSOR, OV7660_ADC, 0x04},
+        {SENSOR, OV7660_ADC, 0x05},
         {SENSOR, OV7660_COM13, 0x00},
         {SENSOR, OV7660_RSVDA1, 0x23},
         {SENSOR, OV7660_TSLB, 0x0d},
@@ -233,6 +193,47 @@ static const unsigned char init_ov7660[][4] =
         {SENSOR, OV7660_LCC4, 0x40},
         {SENSOR, OV7660_LCC5, 0x01},
 
+        {SENSOR, OV7660_AECH, 0x20},
+        {SENSOR, OV7660_COM1, 0x00},
+        {SENSOR, OV7660_OFON, 0x0c},
+        {SENSOR, OV7660_COM2, 0x11},
+        {SENSOR, OV7660_COM7, 0x05},
+        {BRIDGE, M5602_XB_GPIO_DIR, 0x01},
+        {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
+        {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
+        {BRIDGE, M5602_XB_GPIO_DIR_H, 0x06},
+        {BRIDGE, M5602_XB_GPIO_DAT_H, 0x00},
+        {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x08},
+        {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
+        {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
+        {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
+        {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
+        {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0c},
+        {BRIDGE, M5602_XB_GPIO_DIR, 0x05},
+        {BRIDGE, M5602_XB_GPIO_DAT, 0x00},
+        {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
+        {BRIDGE, M5602_XB_GPIO_EN_L, 0x00},
+        {SENSOR, OV7660_AECH, 0x5f},
+        {SENSOR, OV7660_COM1, 0x03},
+        {SENSOR, OV7660_OFON, 0x0c},
+        {SENSOR, OV7660_COM2, 0x11},
+        {SENSOR, OV7660_COM7, 0x05},
+        {BRIDGE, M5602_XB_GPIO_DIR, 0x01},
+        {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
+        {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
+        {BRIDGE, M5602_XB_GPIO_DIR_H, 0x06},
+        {BRIDGE, M5602_XB_GPIO_DAT_H, 0x00},
+        {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x08},
+        {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
+        {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
+        {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
+        {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
+        {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0c},
+        {BRIDGE, M5602_XB_GPIO_DIR, 0x05},
+        {BRIDGE, M5602_XB_GPIO_DAT, 0x00},
+        {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
+        {BRIDGE, M5602_XB_GPIO_EN_L, 0x00},
+
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x06},
         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
@@ -245,35 +246,18 @@ static const unsigned char init_ov7660[][4] =
         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
         {BRIDGE, M5602_XB_VSYNC_PARA, 0x01},
-        {BRIDGE, M5602_XB_VSYNC_PARA, 0xe0}, /* 480 */
+        {BRIDGE, M5602_XB_VSYNC_PARA, 0xec},
         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
         {BRIDGE, M5602_XB_SIG_INI, 0x00},
         {BRIDGE, M5602_XB_SIG_INI, 0x02},
-        {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
-        {BRIDGE, M5602_XB_VSYNC_PARA, 0x27}, /* 39 */
-        {BRIDGE, M5602_XB_VSYNC_PARA, 0x02},
-        {BRIDGE, M5602_XB_VSYNC_PARA, 0xa7}, /* 679 */
+        {BRIDGE, M5602_XB_HSYNC_PARA, 0x00},
+        {BRIDGE, M5602_XB_HSYNC_PARA, 0x27},
+        {BRIDGE, M5602_XB_HSYNC_PARA, 0x02},
+        {BRIDGE, M5602_XB_HSYNC_PARA, 0xa7},
         {BRIDGE, M5602_XB_SIG_INI, 0x00},
-
         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
-
-        {SENSOR, OV7660_AECH, 0x20},
-        {SENSOR, OV7660_COM1, 0x00},
-        {SENSOR, OV7660_OFON, 0x0c},
-        {SENSOR, OV7660_COM2, 0x11},
-        {SENSOR, OV7660_COM7, 0x05},
-        {SENSOR, OV7660_BLUE_GAIN, 0x80},
-        {SENSOR, OV7660_RED_GAIN, 0x80},
-
-        {BRIDGE, M5602_XB_GPIO_DIR, 0x01},
-        {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
-        {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
-        {BRIDGE, M5602_XB_GPIO_DIR_H, 0x06},
-        {BRIDGE, M5602_XB_GPIO_DAT_H, 0x00},
-        {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x08},
-        {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0}
 };
 
 #endif
diff --git a/drivers/media/video/gspca/m5602/m5602_s5k4aa.c b/drivers/media/video/gspca/m5602/m5602_s5k4aa.c
index 0163903d1c0f..59400e858965 100644
--- a/drivers/media/video/gspca/m5602/m5602_s5k4aa.c
+++ b/drivers/media/video/gspca/m5602/m5602_s5k4aa.c
@@ -47,6 +47,12 @@ static
                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 2550")
                 }
         }, {
+                .ident = "Fujitsu-Siemens Amilo Pa 2548",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 2548")
+                }
+        }, {
                 .ident = "MSI GX700",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
@@ -54,6 +60,13 @@ static
                         DMI_MATCH(DMI_BIOS_DATE, "07/26/2007")
                 }
         }, {
+                .ident = "MSI GX700",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "GX700"),
+                        DMI_MATCH(DMI_BIOS_DATE, "07/19/2007")
+                }
+        }, {
                 .ident = "MSI GX700/GX705/EX700",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx.c b/drivers/media/video/gspca/stv06xx/stv06xx.c
index 7af511b5e9c2..65489d6b0d89 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx.c
@@ -50,7 +50,6 @@ int stv06xx_write_bridge(struct sd *sd, u16 address, u16 i2c_data)
                               0x04, 0x40, address, 0, buf, len,
                               STV06XX_URB_MSG_TIMEOUT);
 
-
         PDEBUG(D_CONF, "Written 0x%x to address 0x%x, status: %d",
                i2c_data, address, err);
 
@@ -69,7 +68,7 @@ int stv06xx_read_bridge(struct sd *sd, u16 address, u8 *i2c_data)
 
         *i2c_data = buf[0];
 
-        PDEBUG(D_CONF, "Read 0x%x from address 0x%x, status %d",
+        PDEBUG(D_CONF, "Reading 0x%x from address 0x%x, status %d",
                *i2c_data, address, err);
 
         return (err < 0) ? err : 0;
@@ -111,14 +110,14 @@ int stv06xx_write_sensor_bytes(struct sd *sd, const u8 *data, u8 len)
         struct usb_device *udev = sd->gspca_dev.dev;
         __u8 *buf = sd->gspca_dev.usb_buf;
 
-        PDEBUG(D_USBO, "I2C: Command buffer contains %d entries", len);
+        PDEBUG(D_CONF, "I2C: Command buffer contains %d entries", len);
         for (i = 0; i < len;) {
                 /* Build the command buffer */
                 memset(buf, 0, I2C_BUFFER_LENGTH);
                 for (j = 0; j < I2C_MAX_BYTES && i < len; j++, i++) {
                         buf[j] = data[2*i];
                         buf[0x10 + j] = data[2*i+1];
-                        PDEBUG(D_USBO, "I2C: Writing 0x%02x to reg 0x%02x",
+                        PDEBUG(D_CONF, "I2C: Writing 0x%02x to reg 0x%02x",
                         data[2*i+1], data[2*i]);
                 }
                 buf[0x20] = sd->sensor->i2c_addr;
@@ -128,8 +127,8 @@ int stv06xx_write_sensor_bytes(struct sd *sd, const u8 *data, u8 len)
                                       0x04, 0x40, 0x0400, 0, buf,
                                       I2C_BUFFER_LENGTH,
                                       STV06XX_URB_MSG_TIMEOUT);
-                                      if (err < 0)
-                                        return err;
+                if (err < 0)
+                        return err;
         }
         return stv06xx_write_sensor_finish(sd);
 }
@@ -140,7 +139,7 @@ int stv06xx_write_sensor_words(struct sd *sd, const u16 *data, u8 len)
         struct usb_device *udev = sd->gspca_dev.dev;
         __u8 *buf = sd->gspca_dev.usb_buf;
 
-        PDEBUG(D_USBO, "I2C: Command buffer contains %d entries", len);
+        PDEBUG(D_CONF, "I2C: Command buffer contains %d entries", len);
 
         for (i = 0; i < len;) {
                 /* Build the command buffer */
@@ -149,7 +148,7 @@ int stv06xx_write_sensor_words(struct sd *sd, const u16 *data, u8 len)
                         buf[j] = data[2*i];
                         buf[0x10 + j * 2] = data[2*i+1];
                         buf[0x10 + j * 2 + 1] = data[2*i+1] >> 8;
-                        PDEBUG(D_USBO, "I2C: Writing 0x%04x to reg 0x%02x",
+                        PDEBUG(D_CONF, "I2C: Writing 0x%04x to reg 0x%02x",
                                 data[2*i+1], data[2*i]);
                 }
                 buf[0x20] = sd->sensor->i2c_addr;
@@ -189,7 +188,7 @@ int stv06xx_read_sensor(struct sd *sd, const u8 address, u16 *value)
                               0x04, 0x40, 0x1400, 0, buf, I2C_BUFFER_LENGTH,
                               STV06XX_URB_MSG_TIMEOUT);
         if (err < 0) {
-                PDEBUG(D_ERR, "I2C Read: error writing address: %d", err);
+                PDEBUG(D_ERR, "I2C: Read error writing address: %d", err);
                 return err;
         }
 
@@ -201,7 +200,7 @@ int stv06xx_read_sensor(struct sd *sd, const u8 address, u16 *value)
         else
                 *value = buf[0];
 
-        PDEBUG(D_USBO, "I2C: Read 0x%x from address 0x%x, status: %d",
+        PDEBUG(D_CONF, "I2C: Read 0x%x from address 0x%x, status: %d",
                *value, address, err);
 
         return (err < 0) ? err : 0;
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c b/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c
index e5024c8496ef..706e08dc5254 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c
@@ -37,7 +37,7 @@ static const struct ctrl hdcs1x00_ctrl[] = {
                         .type           = V4L2_CTRL_TYPE_INTEGER,
                         .name           = "exposure",
                         .minimum        = 0x00,
-                        .maximum        = 0xffff,
+                        .maximum        = 0xff,
                         .step           = 0x1,
                         .default_value  = HDCS_DEFAULT_EXPOSURE,
                         .flags          = V4L2_CTRL_FLAG_SLIDER
@@ -74,7 +74,35 @@ static struct v4l2_pix_format hdcs1x00_mode[] = {
         }
 };
 
-static const struct ctrl hdcs1020_ctrl[] = {};
+static const struct ctrl hdcs1020_ctrl[] = {
+        {
+                {
+                        .id             = V4L2_CID_EXPOSURE,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "exposure",
+                        .minimum        = 0x00,
+                        .maximum        = 0xffff,
+                        .step           = 0x1,
+                        .default_value  = HDCS_DEFAULT_EXPOSURE,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                },
+                .set = hdcs_set_exposure,
+                .get = hdcs_get_exposure
+        }, {
+                {
+                        .id             = V4L2_CID_GAIN,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "gain",
+                        .minimum        = 0x00,
+                        .maximum        = 0xff,
+                        .step           = 0x1,
+                        .default_value  = HDCS_DEFAULT_GAIN,
+                        .flags          = V4L2_CTRL_FLAG_SLIDER
+                },
+                .set = hdcs_set_gain,
+                .get = hdcs_get_gain
+        }
+};
 
 static struct v4l2_pix_format hdcs1020_mode[] = {
         {
@@ -120,6 +148,7 @@ struct hdcs {
         } exp;
 
         int psmp;
+        u8 exp_cache, gain_cache;
 };
 
 static int hdcs_reg_write_seq(struct sd *sd, u8 reg, u8 *vals, u8 len)
@@ -205,34 +234,8 @@ static int hdcs_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
         struct sd *sd = (struct sd *) gspca_dev;
         struct hdcs *hdcs = sd->sensor_priv;
 
-        /* Column time period */
-        int ct;
-        /* Column processing period */
-        int cp;
-        /* Row processing period */
-        int rp;
-        int cycles;
-        int err;
-        int rowexp;
-        u16 data[2];
-
-        err = stv06xx_read_sensor(sd, HDCS_ROWEXPL, &data[0]);
-        if (err < 0)
-                return err;
-
-        err = stv06xx_read_sensor(sd, HDCS_ROWEXPH, &data[1]);
-        if (err < 0)
-                return err;
-
-        rowexp = (data[1] << 8) | data[0];
-
-        ct = hdcs->exp.cto + hdcs->psmp + (HDCS_ADC_START_SIG_DUR + 2);
-        cp = hdcs->exp.cto + (hdcs->w * ct / 2);
-        rp = hdcs->exp.rs + cp;
+        *val = hdcs->exp_cache;
 
-        cycles = rp * rowexp;
-        *val = cycles / HDCS_CLK_FREQ_MHZ;
-        PDEBUG(D_V4L2, "Read exposure %d", *val);
         return 0;
 }
 
@@ -252,9 +255,12 @@ static int hdcs_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
            within the column processing period */
         int mnct;
         int cycles, err;
-        u8 exp[4];
+        u8 exp[14];
 
-        cycles = val * HDCS_CLK_FREQ_MHZ;
+        val &= 0xff;
+        hdcs->exp_cache = val;
+
+        cycles = val * HDCS_CLK_FREQ_MHZ * 257;
 
         ct = hdcs->exp.cto + hdcs->psmp + (HDCS_ADC_START_SIG_DUR + 2);
         cp = hdcs->exp.cto + (hdcs->w * ct / 2);
@@ -288,73 +294,79 @@ static int hdcs_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
                 srowexp = max_srowexp;
 
         if (IS_1020(sd)) {
-                exp[0] = rowexp & 0xff;
-                exp[1] = rowexp >> 8;
-                exp[2] = (srowexp >> 2) & 0xff;
-                /* this clears exposure error flag */
-                exp[3] = 0x1;
-                err = hdcs_reg_write_seq(sd, HDCS_ROWEXPL, exp, 4);
+                exp[0] = HDCS20_CONTROL;
+                exp[1] = 0x00;          /* Stop streaming */
+                exp[2] = HDCS_ROWEXPL;
+                exp[3] = rowexp & 0xff;
+                exp[4] = HDCS_ROWEXPH;
+                exp[5] = rowexp >> 8;
+                exp[6] = HDCS20_SROWEXP;
+                exp[7] = (srowexp >> 2) & 0xff;
+                exp[8] = HDCS20_ERROR;
+                exp[9] = 0x10;          /* Clear exposure error flag*/
+                exp[10] = HDCS20_CONTROL;
+                exp[11] = 0x04;         /* Restart streaming */
+                err = stv06xx_write_sensor_bytes(sd, exp, 6);
         } else {
-                exp[0] = rowexp & 0xff;
-                exp[1] = rowexp >> 8;
-                exp[2] = srowexp & 0xff;
-                exp[3] = srowexp >> 8;
-                err = hdcs_reg_write_seq(sd, HDCS_ROWEXPL, exp, 4);
+                exp[0] = HDCS00_CONTROL;
+                exp[1] = 0x00;         /* Stop streaming */
+                exp[2] = HDCS_ROWEXPL;
+                exp[3] = rowexp & 0xff;
+                exp[4] = HDCS_ROWEXPH;
+                exp[5] = rowexp >> 8;
+                exp[6] = HDCS00_SROWEXPL;
+                exp[7] = srowexp & 0xff;
+                exp[8] = HDCS00_SROWEXPH;
+                exp[9] = srowexp >> 8;
+                exp[10] = HDCS_STATUS;
+                exp[11] = 0x10;         /* Clear exposure error flag*/
+                exp[12] = HDCS00_CONTROL;
+                exp[13] = 0x04;         /* Restart streaming */
+                err = stv06xx_write_sensor_bytes(sd, exp, 7);
                 if (err < 0)
                         return err;
-
-                /* clear exposure error flag */
-                err = stv06xx_write_sensor(sd,
-                     HDCS_STATUS, BIT(4));
         }
         PDEBUG(D_V4L2, "Writing exposure %d, rowexp %d, srowexp %d",
                val, rowexp, srowexp);
         return err;
 }
 
-static int hdcs_set_gains(struct sd *sd, u8 r, u8 g, u8 b)
+static int hdcs_set_gains(struct sd *sd, u8 g)
 {
+        struct hdcs *hdcs = sd->sensor_priv;
+        int err;
         u8 gains[4];
 
+        hdcs->gain_cache = g;
+
         /* the voltage gain Av = (1 + 19 * val / 127) * (1 + bit7) */
-        if (r > 127)
-                r = 0x80 | (r / 2);
         if (g > 127)
                 g = 0x80 | (g / 2);
-        if (b > 127)
-                b = 0x80 | (b / 2);
 
         gains[0] = g;
-        gains[1] = r;
-        gains[2] = b;
+        gains[1] = g;
+        gains[2] = g;
         gains[3] = g;
 
-        return hdcs_reg_write_seq(sd, HDCS_ERECPGA, gains, 4);
+        err = hdcs_reg_write_seq(sd, HDCS_ERECPGA, gains, 4);
+                return err;
 }
 
 static int hdcs_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int err;
-        u16 data;
-
-        err = stv06xx_read_sensor(sd, HDCS_ERECPGA, &data);
+        struct hdcs *hdcs = sd->sensor_priv;
 
-        /* Bit 7 doubles the gain */
-        if (data & 0x80)
-                *val = (data & 0x7f) * 2;
-        else
-                *val = data;
+        *val = hdcs->gain_cache;
 
-        PDEBUG(D_V4L2, "Read gain %d", *val);
-        return err;
+        return 0;
 }
 
 static int hdcs_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 {
         PDEBUG(D_V4L2, "Writing gain %d", val);
         return hdcs_set_gains((struct sd *) gspca_dev,
-                               val & 0xff, val & 0xff, val & 0xff);
+                               val & 0xff);
 }
 
 static int hdcs_set_size(struct sd *sd,
@@ -572,16 +584,15 @@ static int hdcs_init(struct sd *sd)
         if (err < 0)
                 return err;
 
-        err = hdcs_set_gains(sd, HDCS_DEFAULT_GAIN, HDCS_DEFAULT_GAIN,
-                             HDCS_DEFAULT_GAIN);
+        err = hdcs_set_gains(sd, HDCS_DEFAULT_GAIN);
         if (err < 0)
                 return err;
 
-        err = hdcs_set_exposure(&sd->gspca_dev, HDCS_DEFAULT_EXPOSURE);
+        err = hdcs_set_size(sd, hdcs->array.width, hdcs->array.height);
         if (err < 0)
                 return err;
 
-        err = hdcs_set_size(sd, hdcs->array.width, hdcs->array.height);
+        err = hdcs_set_exposure(&sd->gspca_dev, HDCS_DEFAULT_EXPOSURE);
         return err;
 }
 
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.h b/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.h
index 412f06cf3d5c..37b31c99d956 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.h
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.h
@@ -124,7 +124,7 @@
 #define HDCS_RUN_ENABLE         (1 << 2)
 #define HDCS_SLEEP_MODE         (1 << 1)
 
-#define HDCS_DEFAULT_EXPOSURE   5000
+#define HDCS_DEFAULT_EXPOSURE   48
 #define HDCS_DEFAULT_GAIN       128
 
 static int hdcs_probe_1x00(struct sd *sd);
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c b/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c
index 87cb5b9ddfa7..c11f06e4ae76 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c
@@ -166,7 +166,7 @@ static int st6422_init(struct sd *sd)
 /* 10 compressed? */
 
                 { 0x1439, 0x00 },
-/* antiflimmer??  0xa2 ger perfekt bild mot monitor */
+/* anti-noise?  0xa2 gives a perfect image */
 
                 { 0x143b, 0x05 },
                 { 0x143c, 0x00 },       /* 0x00-0x01 - ??? */
@@ -197,15 +197,14 @@ static int st6422_init(struct sd *sd)
                 { 0x1500, 0x50 },       /* 0x00 - 0xFF  0x80 == compr ? */
 
                 { 0x1501, 0xaf },
-/* high val-> ljus area blir morkare. */
-/* low val -> ljus area blir ljusare. */
+/* high val-> light area gets darker */
+/* low val -> light area gets lighter */
                 { 0x1502, 0xc2 },
-/* high val-> ljus area blir morkare. */
-/* low val -> ljus area blir ljusare. */
+/* high val-> light area gets darker */
+/* low val -> light area gets lighter */
                 { 0x1503, 0x45 },
-/* high val-> ljus area blir morkare. */
-/* low val -> ljus area blir ljusare. */
-
+/* high val-> light area gets darker */
+/* low val -> light area gets lighter */
                 { 0x1505, 0x02 },
 /* 2  : 324x248  80352 bytes */
 /* 7  : 248x162  40176 bytes */
diff --git a/drivers/media/video/gspca/vc032x.c b/drivers/media/video/gspca/vc032x.c
index 619250e70718..589042f6adbe 100644
--- a/drivers/media/video/gspca/vc032x.c
+++ b/drivers/media/video/gspca/vc032x.c
@@ -2946,7 +2946,8 @@ static int sd_start(struct gspca_dev *gspca_dev)
                         reg_w(gspca_dev->dev, 0x89, 0x058c, 0x0000);
                         break;
                 default:
-                        reg_w(gspca_dev->dev, 0x89, 0xffff, 0xfdff);
+                        if (!(sd->flags & FL_SAMSUNG))
+                                reg_w(gspca_dev->dev, 0x89, 0xffff, 0xfdff);
                         break;
                 }
                 msleep(100);
@@ -2964,7 +2965,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
 
         if (sd->sensor == SENSOR_MI1310_SOC)
                 reg_w(dev, 0x89, 0x058c, 0x00ff);
-        else
+        else if (!(sd->flags & FL_SAMSUNG))
                 reg_w(dev, 0x89, 0xffff, 0xffff);
         reg_w(dev, 0xa0, 0x01, 0xb301);
         reg_w(dev, 0xa0, 0x09, 0xb003);
@@ -2981,7 +2982,7 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
 /*fixme: is this useful?*/
         if (sd->sensor == SENSOR_MI1310_SOC)
                 reg_w(dev, 0x89, 0x058c, 0x00ff);
-        else
+        else if (!(sd->flags & FL_SAMSUNG))
                 reg_w(dev, 0x89, 0xffff, 0xffff);
 }
 
diff --git a/drivers/media/video/ivtv/ivtv-driver.c b/drivers/media/video/ivtv/ivtv-driver.c
index 63ea0fb66063..463ec3457d7b 100644
--- a/drivers/media/video/ivtv/ivtv-driver.c
+++ b/drivers/media/video/ivtv/ivtv-driver.c
@@ -246,7 +246,7 @@ MODULE_PARM_DESC(newi2c,
                  "\t\t\t-1 is autodetect, 0 is off, 1 is on\n"
                  "\t\t\tDefault is autodetect");
 
-MODULE_PARM_DESC(ivtv_first_minor, "Set kernel number assigned to first card");
+MODULE_PARM_DESC(ivtv_first_minor, "Set device node number assigned to first card");
 
 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
 MODULE_DESCRIPTION("CX23415/CX23416 driver");
diff --git a/drivers/media/video/ivtv/ivtv-i2c.c b/drivers/media/video/ivtv/ivtv-i2c.c
index 8f15a31d3f66..b9c71e61f7d6 100644
--- a/drivers/media/video/ivtv/ivtv-i2c.c
+++ b/drivers/media/video/ivtv/ivtv-i2c.c
@@ -161,19 +161,19 @@ int ivtv_i2c_register(struct ivtv *itv, unsigned idx)
                 return -1;
         if (hw == IVTV_HW_TUNER) {
                 /* special tuner handling */
-                sd = v4l2_i2c_new_probed_subdev(&itv->v4l2_dev,
+                sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
                                 adap, mod, type,
-                                itv->card_i2c->radio);
+                                0, itv->card_i2c->radio);
                 if (sd)
                         sd->grp_id = 1 << idx;
-                sd = v4l2_i2c_new_probed_subdev(&itv->v4l2_dev,
+                sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
                                 adap, mod, type,
-                                itv->card_i2c->demod);
+                                0, itv->card_i2c->demod);
                 if (sd)
                         sd->grp_id = 1 << idx;
-                sd = v4l2_i2c_new_probed_subdev(&itv->v4l2_dev,
+                sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
                                 adap, mod, type,
-                                itv->card_i2c->tv);
+                                0, itv->card_i2c->tv);
                 if (sd)
                         sd->grp_id = 1 << idx;
                 return sd ? 0 : -1;
@@ -181,11 +181,11 @@ int ivtv_i2c_register(struct ivtv *itv, unsigned idx)
         if (!hw_addrs[idx])
                 return -1;
         if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) {
-                sd = v4l2_i2c_new_probed_subdev_addr(&itv->v4l2_dev,
-                                adap, mod, type, hw_addrs[idx]);
+                sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
+                                adap, mod, type, 0, I2C_ADDRS(hw_addrs[idx]));
         } else {
                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
-                                adap, mod, type, hw_addrs[idx]);
+                                adap, mod, type, hw_addrs[idx], NULL);
         }
         if (sd)
                 sd->grp_id = 1 << idx;
diff --git a/drivers/media/video/ivtv/ivtv-streams.c b/drivers/media/video/ivtv/ivtv-streams.c
index 15da01710efc..67699e3f2aaa 100644
--- a/drivers/media/video/ivtv/ivtv-streams.c
+++ b/drivers/media/video/ivtv/ivtv-streams.c
@@ -261,8 +261,8 @@ static int ivtv_reg_dev(struct ivtv *itv, int type)
         video_set_drvdata(s->vdev, s);
 
         /* Register device. First try the desired minor, then any free one. */
-        if (video_register_device(s->vdev, vfl_type, num)) {
-                IVTV_ERR("Couldn't register v4l2 device for %s kernel number %d\n",
+        if (video_register_device_no_warn(s->vdev, vfl_type, num)) {
+                IVTV_ERR("Couldn't register v4l2 device for %s (device node number %d)\n",
                                 s->name, num);
                 video_device_release(s->vdev);
                 s->vdev = NULL;
diff --git a/drivers/media/video/mt9m001.c b/drivers/media/video/mt9m001.c
index 4d794b42d6cd..45388d2ce2fd 100644
--- a/drivers/media/video/mt9m001.c
+++ b/drivers/media/video/mt9m001.c
@@ -13,13 +13,13 @@
 #include <linux/i2c.h>
 #include <linux/log2.h>
 
-#include <media/v4l2-common.h>
+#include <media/v4l2-subdev.h>
 #include <media/v4l2-chip-ident.h>
 #include <media/soc_camera.h>
 
 /* mt9m001 i2c address 0x5d
- * The platform has to define i2c_board_info
- * and call i2c_register_board_info() */
+ * The platform has to define ctruct i2c_board_info objects and link to them
+ * from struct soc_camera_link */
 
 /* mt9m001 selected register addresses */
 #define MT9M001_CHIP_VERSION            0x00
@@ -39,6 +39,13 @@
 #define MT9M001_GLOBAL_GAIN             0x35
 #define MT9M001_CHIP_ENABLE             0xF1
 
+#define MT9M001_MAX_WIDTH               1280
+#define MT9M001_MAX_HEIGHT              1024
+#define MT9M001_MIN_WIDTH               48
+#define MT9M001_MIN_HEIGHT              32
+#define MT9M001_COLUMN_SKIP             20
+#define MT9M001_ROW_SKIP                12
+
 static const struct soc_camera_data_format mt9m001_colour_formats[] = {
         /* Order important: first natively supported,
          * second supported with a GPIO extender */
@@ -69,12 +76,20 @@ static const struct soc_camera_data_format mt9m001_monochrome_formats[] = {
 };
 
 struct mt9m001 {
-        struct i2c_client *client;
-        struct soc_camera_device icd;
+        struct v4l2_subdev subdev;
+        struct v4l2_rect rect;  /* Sensor window */
+        __u32 fourcc;
         int model;      /* V4L2_IDENT_MT9M001* codes from v4l2-chip-ident.h */
+        unsigned int gain;
+        unsigned int exposure;
         unsigned char autoexposure;
 };
 
+static struct mt9m001 *to_mt9m001(const struct i2c_client *client)
+{
+        return container_of(i2c_get_clientdata(client), struct mt9m001, subdev);
+}
+
 static int reg_read(struct i2c_client *client, const u8 reg)
 {
         s32 data = i2c_smbus_read_word_data(client, reg);
@@ -109,35 +124,20 @@ static int reg_clear(struct i2c_client *client, const u8 reg,
         return reg_write(client, reg, ret & ~data);
 }
 
-static int mt9m001_init(struct soc_camera_device *icd)
+static int mt9m001_init(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct soc_camera_link *icl = client->dev.platform_data;
         int ret;
 
-        dev_dbg(icd->vdev->parent, "%s\n", __func__);
+        dev_dbg(&client->dev, "%s\n", __func__);
 
-        if (icl->power) {
-                ret = icl->power(&client->dev, 1);
-                if (ret < 0) {
-                        dev_err(icd->vdev->parent,
-                                "Platform failed to power-on the camera.\n");
-                        return ret;
-                }
-        }
-
-        /* The camera could have been already on, we reset it additionally */
-        if (icl->reset)
-                ret = icl->reset(&client->dev);
-        else
-                ret = -ENODEV;
+        /*
+         * We don't know, whether platform provides reset, issue a soft reset
+         * too. This returns all registers to their default values.
+         */
+        ret = reg_write(client, MT9M001_RESET, 1);
+        if (!ret)
+                ret = reg_write(client, MT9M001_RESET, 0);
 
-        if (ret < 0) {
-                /* Either no platform reset, or platform reset failed */
-                ret = reg_write(client, MT9M001_RESET, 1);
-                if (!ret)
-                        ret = reg_write(client, MT9M001_RESET, 0);
-        }
         /* Disable chip, synchronous option update */
         if (!ret)
                 ret = reg_write(client, MT9M001_OUTPUT_CONTROL, 0);
@@ -145,36 +145,12 @@ static int mt9m001_init(struct soc_camera_device *icd)
         return ret;
 }
 
-static int mt9m001_release(struct soc_camera_device *icd)
+static int mt9m001_s_stream(struct v4l2_subdev *sd, int enable)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct soc_camera_link *icl = client->dev.platform_data;
-
-        /* Disable the chip */
-        reg_write(client, MT9M001_OUTPUT_CONTROL, 0);
-
-        if (icl->power)
-                icl->power(&client->dev, 0);
-
-        return 0;
-}
+        struct i2c_client *client = sd->priv;
 
-static int mt9m001_start_capture(struct soc_camera_device *icd)
-{
-        struct i2c_client *client = to_i2c_client(icd->control);
-
-        /* Switch to master "normal" mode */
-        if (reg_write(client, MT9M001_OUTPUT_CONTROL, 2) < 0)
-                return -EIO;
-        return 0;
-}
-
-static int mt9m001_stop_capture(struct soc_camera_device *icd)
-{
-        struct i2c_client *client = to_i2c_client(icd->control);
-
-        /* Stop sensor readout */
-        if (reg_write(client, MT9M001_OUTPUT_CONTROL, 0) < 0)
+        /* Switch to master "normal" mode or stop sensor readout */
+        if (reg_write(client, MT9M001_OUTPUT_CONTROL, enable ? 2 : 0) < 0)
                 return -EIO;
         return 0;
 }
@@ -182,8 +158,7 @@ static int mt9m001_stop_capture(struct soc_camera_device *icd)
 static int mt9m001_set_bus_param(struct soc_camera_device *icd,
                                  unsigned long flags)
 {
-        struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
-        struct soc_camera_link *icl = mt9m001->client->dev.platform_data;
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         unsigned long width_flag = flags & SOCAM_DATAWIDTH_MASK;
 
         /* Only one width bit may be set */
@@ -205,8 +180,7 @@ static int mt9m001_set_bus_param(struct soc_camera_device *icd,
 
 static unsigned long mt9m001_query_bus_param(struct soc_camera_device *icd)
 {
-        struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
-        struct soc_camera_link *icl = mt9m001->client->dev.platform_data;
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         /* MT9M001 has all capture_format parameters fixed */
         unsigned long flags = SOCAM_PCLK_SAMPLE_FALLING |
                 SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_HIGH |
@@ -220,13 +194,35 @@ static unsigned long mt9m001_query_bus_param(struct soc_camera_device *icd)
         return soc_camera_apply_sensor_flags(icl, flags);
 }
 
-static int mt9m001_set_crop(struct soc_camera_device *icd,
-                            struct v4l2_rect *rect)
+static int mt9m001_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9m001 *mt9m001 = to_mt9m001(client);
+        struct v4l2_rect rect = a->c;
+        struct soc_camera_device *icd = client->dev.platform_data;
         int ret;
         const u16 hblank = 9, vblank = 25;
+        unsigned int total_h;
+
+        if (mt9m001->fourcc == V4L2_PIX_FMT_SBGGR8 ||
+            mt9m001->fourcc == V4L2_PIX_FMT_SBGGR16)
+                /*
+                 * Bayer format - even number of rows for simplicity,
+                 * but let the user play with the top row.
+                 */
+                rect.height = ALIGN(rect.height, 2);
+
+        /* Datasheet requirement: see register description */
+        rect.width = ALIGN(rect.width, 2);
+        rect.left = ALIGN(rect.left, 2);
+
+        soc_camera_limit_side(&rect.left, &rect.width,
+                     MT9M001_COLUMN_SKIP, MT9M001_MIN_WIDTH, MT9M001_MAX_WIDTH);
+
+        soc_camera_limit_side(&rect.top, &rect.height,
+                     MT9M001_ROW_SKIP, MT9M001_MIN_HEIGHT, MT9M001_MAX_HEIGHT);
+
+        total_h = rect.height + icd->y_skip_top + vblank;
 
         /* Blanking and start values - default... */
         ret = reg_write(client, MT9M001_HORIZONTAL_BLANKING, hblank);
@@ -236,66 +232,126 @@ static int mt9m001_set_crop(struct soc_camera_device *icd,
         /* The caller provides a supported format, as verified per
          * call to icd->try_fmt() */
         if (!ret)
-                ret = reg_write(client, MT9M001_COLUMN_START, rect->left);
+                ret = reg_write(client, MT9M001_COLUMN_START, rect.left);
         if (!ret)
-                ret = reg_write(client, MT9M001_ROW_START, rect->top);
+                ret = reg_write(client, MT9M001_ROW_START, rect.top);
         if (!ret)
-                ret = reg_write(client, MT9M001_WINDOW_WIDTH, rect->width - 1);
+                ret = reg_write(client, MT9M001_WINDOW_WIDTH, rect.width - 1);
         if (!ret)
                 ret = reg_write(client, MT9M001_WINDOW_HEIGHT,
-                                rect->height + icd->y_skip_top - 1);
+                                rect.height + icd->y_skip_top - 1);
         if (!ret && mt9m001->autoexposure) {
-                ret = reg_write(client, MT9M001_SHUTTER_WIDTH,
-                                rect->height + icd->y_skip_top + vblank);
+                ret = reg_write(client, MT9M001_SHUTTER_WIDTH, total_h);
                 if (!ret) {
                         const struct v4l2_queryctrl *qctrl =
                                 soc_camera_find_qctrl(icd->ops,
                                                       V4L2_CID_EXPOSURE);
-                        icd->exposure = (524 + (rect->height + icd->y_skip_top +
-                                                vblank - 1) *
-                                         (qctrl->maximum - qctrl->minimum)) /
+                        mt9m001->exposure = (524 + (total_h - 1) *
+                                 (qctrl->maximum - qctrl->minimum)) /
                                 1048 + qctrl->minimum;
                 }
         }
 
+        if (!ret)
+                mt9m001->rect = rect;
+
         return ret;
 }
 
-static int mt9m001_set_fmt(struct soc_camera_device *icd,
-                           struct v4l2_format *f)
+static int mt9m001_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+        struct i2c_client *client = sd->priv;
+        struct mt9m001 *mt9m001 = to_mt9m001(client);
+
+        a->c    = mt9m001->rect;
+        a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        return 0;
+}
+
+static int mt9m001_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+        a->bounds.left                  = MT9M001_COLUMN_SKIP;
+        a->bounds.top                   = MT9M001_ROW_SKIP;
+        a->bounds.width                 = MT9M001_MAX_WIDTH;
+        a->bounds.height                = MT9M001_MAX_HEIGHT;
+        a->defrect                      = a->bounds;
+        a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        a->pixelaspect.numerator        = 1;
+        a->pixelaspect.denominator      = 1;
+
+        return 0;
+}
+
+static int mt9m001_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
-        struct v4l2_rect rect = {
-                .left   = icd->x_current,
-                .top    = icd->y_current,
-                .width  = f->fmt.pix.width,
-                .height = f->fmt.pix.height,
+        struct i2c_client *client = sd->priv;
+        struct mt9m001 *mt9m001 = to_mt9m001(client);
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+
+        pix->width              = mt9m001->rect.width;
+        pix->height             = mt9m001->rect.height;
+        pix->pixelformat        = mt9m001->fourcc;
+        pix->field              = V4L2_FIELD_NONE;
+        pix->colorspace         = V4L2_COLORSPACE_SRGB;
+
+        return 0;
+}
+
+static int mt9m001_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct i2c_client *client = sd->priv;
+        struct mt9m001 *mt9m001 = to_mt9m001(client);
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+        struct v4l2_crop a = {
+                .c = {
+                        .left   = mt9m001->rect.left,
+                        .top    = mt9m001->rect.top,
+                        .width  = pix->width,
+                        .height = pix->height,
+                },
         };
+        int ret;
 
         /* No support for scaling so far, just crop. TODO: use skipping */
-        return mt9m001_set_crop(icd, &rect);
+        ret = mt9m001_s_crop(sd, &a);
+        if (!ret) {
+                pix->width = mt9m001->rect.width;
+                pix->height = mt9m001->rect.height;
+                mt9m001->fourcc = pix->pixelformat;
+        }
+
+        return ret;
 }
 
-static int mt9m001_try_fmt(struct soc_camera_device *icd,
-                           struct v4l2_format *f)
+static int mt9m001_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
+        struct i2c_client *client = sd->priv;
+        struct soc_camera_device *icd = client->dev.platform_data;
         struct v4l2_pix_format *pix = &f->fmt.pix;
 
-        v4l_bound_align_image(&pix->width, 48, 1280, 1,
-                              &pix->height, 32 + icd->y_skip_top,
-                              1024 + icd->y_skip_top, 0, 0);
+        v4l_bound_align_image(&pix->width, MT9M001_MIN_WIDTH,
+                MT9M001_MAX_WIDTH, 1,
+                &pix->height, MT9M001_MIN_HEIGHT + icd->y_skip_top,
+                MT9M001_MAX_HEIGHT + icd->y_skip_top, 0, 0);
+
+        if (pix->pixelformat == V4L2_PIX_FMT_SBGGR8 ||
+            pix->pixelformat == V4L2_PIX_FMT_SBGGR16)
+                pix->height = ALIGN(pix->height - 1, 2);
 
         return 0;
 }
 
-static int mt9m001_get_chip_id(struct soc_camera_device *icd,
-                               struct v4l2_dbg_chip_ident *id)
+static int mt9m001_g_chip_ident(struct v4l2_subdev *sd,
+                                struct v4l2_dbg_chip_ident *id)
 {
-        struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9m001 *mt9m001 = to_mt9m001(client);
 
         if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
                 return -EINVAL;
 
-        if (id->match.addr != mt9m001->client->addr)
+        if (id->match.addr != client->addr)
                 return -ENODEV;
 
         id->ident       = mt9m001->model;
@@ -305,10 +361,10 @@ static int mt9m001_get_chip_id(struct soc_camera_device *icd,
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mt9m001_get_register(struct soc_camera_device *icd,
-                                struct v4l2_dbg_register *reg)
+static int mt9m001_g_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = sd->priv;
 
         if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
@@ -325,10 +381,10 @@ static int mt9m001_get_register(struct soc_camera_device *icd,
         return 0;
 }
 
-static int mt9m001_set_register(struct soc_camera_device *icd,
-                                struct v4l2_dbg_register *reg)
+static int mt9m001_s_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = sd->priv;
 
         if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
@@ -381,39 +437,17 @@ static const struct v4l2_queryctrl mt9m001_controls[] = {
         }
 };
 
-static int mt9m001_video_probe(struct soc_camera_device *);
-static void mt9m001_video_remove(struct soc_camera_device *);
-static int mt9m001_get_control(struct soc_camera_device *, struct v4l2_control *);
-static int mt9m001_set_control(struct soc_camera_device *, struct v4l2_control *);
-
 static struct soc_camera_ops mt9m001_ops = {
-        .owner                  = THIS_MODULE,
-        .probe                  = mt9m001_video_probe,
-        .remove                 = mt9m001_video_remove,
-        .init                   = mt9m001_init,
-        .release                = mt9m001_release,
-        .start_capture          = mt9m001_start_capture,
-        .stop_capture           = mt9m001_stop_capture,
-        .set_crop               = mt9m001_set_crop,
-        .set_fmt                = mt9m001_set_fmt,
-        .try_fmt                = mt9m001_try_fmt,
         .set_bus_param          = mt9m001_set_bus_param,
         .query_bus_param        = mt9m001_query_bus_param,
         .controls               = mt9m001_controls,
         .num_controls           = ARRAY_SIZE(mt9m001_controls),
-        .get_control            = mt9m001_get_control,
-        .set_control            = mt9m001_set_control,
-        .get_chip_id            = mt9m001_get_chip_id,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-        .get_register           = mt9m001_get_register,
-        .set_register           = mt9m001_set_register,
-#endif
 };
 
-static int mt9m001_get_control(struct soc_camera_device *icd, struct v4l2_control *ctrl)
+static int mt9m001_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9m001 *mt9m001 = to_mt9m001(client);
         int data;
 
         switch (ctrl->id) {
@@ -426,14 +460,21 @@ static int mt9m001_get_control(struct soc_camera_device *icd, struct v4l2_contro
         case V4L2_CID_EXPOSURE_AUTO:
                 ctrl->value = mt9m001->autoexposure;
                 break;
+        case V4L2_CID_GAIN:
+                ctrl->value = mt9m001->gain;
+                break;
+        case V4L2_CID_EXPOSURE:
+                ctrl->value = mt9m001->exposure;
+                break;
         }
         return 0;
 }
 
-static int mt9m001_set_control(struct soc_camera_device *icd, struct v4l2_control *ctrl)
+static int mt9m001_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9m001 *mt9m001 = to_mt9m001(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
         const struct v4l2_queryctrl *qctrl;
         int data;
 
@@ -460,7 +501,7 @@ static int mt9m001_set_control(struct soc_camera_device *icd, struct v4l2_contro
                         unsigned long range = qctrl->default_value - qctrl->minimum;
                         data = ((ctrl->value - qctrl->minimum) * 8 + range / 2) / range;
 
-                        dev_dbg(&icd->dev, "Setting gain %d\n", data);
+                        dev_dbg(&client->dev, "Setting gain %d\n", data);
                         data = reg_write(client, MT9M001_GLOBAL_GAIN, data);
                         if (data < 0)
                                 return -EIO;
@@ -478,7 +519,7 @@ static int mt9m001_set_control(struct soc_camera_device *icd, struct v4l2_contro
                         else
                                 data = ((gain - 64) * 7 + 28) / 56 + 96;
 
-                        dev_dbg(&icd->dev, "Setting gain from %d to %d\n",
+                        dev_dbg(&client->dev, "Setting gain from %d to %d\n",
                                  reg_read(client, MT9M001_GLOBAL_GAIN), data);
                         data = reg_write(client, MT9M001_GLOBAL_GAIN, data);
                         if (data < 0)
@@ -486,7 +527,7 @@ static int mt9m001_set_control(struct soc_camera_device *icd, struct v4l2_contro
                 }
 
                 /* Success */
-                icd->gain = ctrl->value;
+                mt9m001->gain = ctrl->value;
                 break;
         case V4L2_CID_EXPOSURE:
                 /* mt9m001 has maximum == default */
@@ -497,23 +538,27 @@ static int mt9m001_set_control(struct soc_camera_device *icd, struct v4l2_contro
                         unsigned long shutter = ((ctrl->value - qctrl->minimum) * 1048 +
                                                  range / 2) / range + 1;
 
-                        dev_dbg(&icd->dev, "Setting shutter width from %d to %lu\n",
-                                 reg_read(client, MT9M001_SHUTTER_WIDTH), shutter);
+                        dev_dbg(&client->dev,
+                                "Setting shutter width from %d to %lu\n",
+                                reg_read(client, MT9M001_SHUTTER_WIDTH),
+                                shutter);
                         if (reg_write(client, MT9M001_SHUTTER_WIDTH, shutter) < 0)
                                 return -EIO;
-                        icd->exposure = ctrl->value;
+                        mt9m001->exposure = ctrl->value;
                         mt9m001->autoexposure = 0;
                 }
                 break;
         case V4L2_CID_EXPOSURE_AUTO:
                 if (ctrl->value) {
                         const u16 vblank = 25;
-                        if (reg_write(client, MT9M001_SHUTTER_WIDTH, icd->height +
-                                      icd->y_skip_top + vblank) < 0)
+                        unsigned int total_h = mt9m001->rect.height +
+                                icd->y_skip_top + vblank;
+                        if (reg_write(client, MT9M001_SHUTTER_WIDTH,
+                                      total_h) < 0)
                                 return -EIO;
                         qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
-                        icd->exposure = (524 + (icd->height + icd->y_skip_top + vblank - 1) *
-                                         (qctrl->maximum - qctrl->minimum)) /
+                        mt9m001->exposure = (524 + (total_h - 1) *
+                                 (qctrl->maximum - qctrl->minimum)) /
                                 1048 + qctrl->minimum;
                         mt9m001->autoexposure = 1;
                 } else
@@ -525,14 +570,14 @@ static int mt9m001_set_control(struct soc_camera_device *icd, struct v4l2_contro
 
 /* Interface active, can use i2c. If it fails, it can indeed mean, that
  * this wasn't our capture interface, so, we wait for the right one */
-static int mt9m001_video_probe(struct soc_camera_device *icd)
+static int mt9m001_video_probe(struct soc_camera_device *icd,
+                               struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
-        struct soc_camera_link *icl = client->dev.platform_data;
+        struct mt9m001 *mt9m001 = to_mt9m001(client);
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         s32 data;
-        int ret;
         unsigned long flags;
+        int ret;
 
         /* We must have a parent by now. And it cannot be a wrong one.
          * So this entire test is completely redundant. */
@@ -542,7 +587,7 @@ static int mt9m001_video_probe(struct soc_camera_device *icd)
 
         /* Enable the chip */
         data = reg_write(client, MT9M001_CHIP_ENABLE, 1);
-        dev_dbg(&icd->dev, "write: %d\n", data);
+        dev_dbg(&client->dev, "write: %d\n", data);
 
         /* Read out the chip version register */
         data = reg_read(client, MT9M001_CHIP_VERSION);
@@ -559,10 +604,9 @@ static int mt9m001_video_probe(struct soc_camera_device *icd)
                 icd->formats = mt9m001_monochrome_formats;
                 break;
         default:
-                ret = -ENODEV;
-                dev_err(&icd->dev,
+                dev_err(&client->dev,
                         "No MT9M001 chip detected, register read %x\n", data);
-                goto ei2c;
+                return -ENODEV;
         }
 
         icd->num_formats = 0;
@@ -585,42 +629,72 @@ static int mt9m001_video_probe(struct soc_camera_device *icd)
         if (flags & SOCAM_DATAWIDTH_8)
                 icd->num_formats++;
 
-        dev_info(&icd->dev, "Detected a MT9M001 chip ID %x (%s)\n", data,
+        mt9m001->fourcc = icd->formats->fourcc;
+
+        dev_info(&client->dev, "Detected a MT9M001 chip ID %x (%s)\n", data,
                  data == 0x8431 ? "C12STM" : "C12ST");
 
-        /* Now that we know the model, we can start video */
-        ret = soc_camera_video_start(icd);
-        if (ret)
-                goto eisis;
+        ret = mt9m001_init(client);
+        if (ret < 0)
+                dev_err(&client->dev, "Failed to initialise the camera\n");
 
-        return 0;
+        /* mt9m001_init() has reset the chip, returning registers to defaults */
+        mt9m001->gain = 64;
+        mt9m001->exposure = 255;
 
-eisis:
-ei2c:
         return ret;
 }
 
 static void mt9m001_video_remove(struct soc_camera_device *icd)
 {
-        struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
-        struct soc_camera_link *icl = mt9m001->client->dev.platform_data;
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
 
-        dev_dbg(&icd->dev, "Video %x removed: %p, %p\n", mt9m001->client->addr,
+        dev_dbg(&icd->dev, "Video removed: %p, %p\n",
                 icd->dev.parent, icd->vdev);
-        soc_camera_video_stop(icd);
         if (icl->free_bus)
                 icl->free_bus(icl);
 }
 
+static struct v4l2_subdev_core_ops mt9m001_subdev_core_ops = {
+        .g_ctrl         = mt9m001_g_ctrl,
+        .s_ctrl         = mt9m001_s_ctrl,
+        .g_chip_ident   = mt9m001_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+        .g_register     = mt9m001_g_register,
+        .s_register     = mt9m001_s_register,
+#endif
+};
+
+static struct v4l2_subdev_video_ops mt9m001_subdev_video_ops = {
+        .s_stream       = mt9m001_s_stream,
+        .s_fmt          = mt9m001_s_fmt,
+        .g_fmt          = mt9m001_g_fmt,
+        .try_fmt        = mt9m001_try_fmt,
+        .s_crop         = mt9m001_s_crop,
+        .g_crop         = mt9m001_g_crop,
+        .cropcap        = mt9m001_cropcap,
+};
+
+static struct v4l2_subdev_ops mt9m001_subdev_ops = {
+        .core   = &mt9m001_subdev_core_ops,
+        .video  = &mt9m001_subdev_video_ops,
+};
+
 static int mt9m001_probe(struct i2c_client *client,
                          const struct i2c_device_id *did)
 {
         struct mt9m001 *mt9m001;
-        struct soc_camera_device *icd;
+        struct soc_camera_device *icd = client->dev.platform_data;
         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
-        struct soc_camera_link *icl = client->dev.platform_data;
+        struct soc_camera_link *icl;
         int ret;
 
+        if (!icd) {
+                dev_err(&client->dev, "MT9M001: missing soc-camera data!\n");
+                return -EINVAL;
+        }
+
+        icl = to_soc_camera_link(icd);
         if (!icl) {
                 dev_err(&client->dev, "MT9M001 driver needs platform data\n");
                 return -EINVAL;
@@ -636,43 +710,40 @@ static int mt9m001_probe(struct i2c_client *client,
         if (!mt9m001)
                 return -ENOMEM;
 
-        mt9m001->client = client;
-        i2c_set_clientdata(client, mt9m001);
+        v4l2_i2c_subdev_init(&mt9m001->subdev, client, &mt9m001_subdev_ops);
 
         /* Second stage probe - when a capture adapter is there */
-        icd = &mt9m001->icd;
-        icd->ops        = &mt9m001_ops;
-        icd->control    = &client->dev;
-        icd->x_min      = 20;
-        icd->y_min      = 12;
-        icd->x_current  = 20;
-        icd->y_current  = 12;
-        icd->width_min  = 48;
-        icd->width_max  = 1280;
-        icd->height_min = 32;
-        icd->height_max = 1024;
-        icd->y_skip_top = 1;
-        icd->iface      = icl->bus_id;
+        icd->ops                = &mt9m001_ops;
+        icd->y_skip_top         = 0;
+
+        mt9m001->rect.left      = MT9M001_COLUMN_SKIP;
+        mt9m001->rect.top       = MT9M001_ROW_SKIP;
+        mt9m001->rect.width     = MT9M001_MAX_WIDTH;
+        mt9m001->rect.height    = MT9M001_MAX_HEIGHT;
+
         /* Simulated autoexposure. If enabled, we calculate shutter width
          * ourselves in the driver based on vertical blanking and frame width */
         mt9m001->autoexposure = 1;
 
-        ret = soc_camera_device_register(icd);
-        if (ret)
-                goto eisdr;
-
-        return 0;
+        ret = mt9m001_video_probe(icd, client);
+        if (ret) {
+                icd->ops = NULL;
+                i2c_set_clientdata(client, NULL);
+                kfree(mt9m001);
+        }
 
-eisdr:
-        kfree(mt9m001);
         return ret;
 }
 
 static int mt9m001_remove(struct i2c_client *client)
 {
-        struct mt9m001 *mt9m001 = i2c_get_clientdata(client);
+        struct mt9m001 *mt9m001 = to_mt9m001(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
 
-        soc_camera_device_unregister(&mt9m001->icd);
+        icd->ops = NULL;
+        mt9m001_video_remove(icd);
+        i2c_set_clientdata(client, NULL);
+        client->driver = NULL;
         kfree(mt9m001);
 
         return 0;
diff --git a/drivers/media/video/mt9m111.c b/drivers/media/video/mt9m111.c
index fc5e2de03766..90da699601ea 100644
--- a/drivers/media/video/mt9m111.c
+++ b/drivers/media/video/mt9m111.c
@@ -148,12 +148,12 @@ enum mt9m111_context {
 };
 
 struct mt9m111 {
-        struct i2c_client *client;
-        struct soc_camera_device icd;
+        struct v4l2_subdev subdev;
         int model;      /* V4L2_IDENT_MT9M11x* codes from v4l2-chip-ident.h */
         enum mt9m111_context context;
         struct v4l2_rect rect;
         u32 pixfmt;
+        unsigned int gain;
         unsigned char autoexposure;
         unsigned char datawidth;
         unsigned int powered:1;
@@ -166,6 +166,11 @@ struct mt9m111 {
         unsigned int autowhitebalance:1;
 };
 
+static struct mt9m111 *to_mt9m111(const struct i2c_client *client)
+{
+        return container_of(i2c_get_clientdata(client), struct mt9m111, subdev);
+}
+
 static int reg_page_map_set(struct i2c_client *client, const u16 reg)
 {
         int ret;
@@ -190,7 +195,7 @@ static int mt9m111_reg_read(struct i2c_client *client, const u16 reg)
 
         ret = reg_page_map_set(client, reg);
         if (!ret)
-                ret = swab16(i2c_smbus_read_word_data(client, (reg & 0xff)));
+                ret = swab16(i2c_smbus_read_word_data(client, reg & 0xff));
 
         dev_dbg(&client->dev, "read  reg.%03x -> %04x\n", reg, ret);
         return ret;
@@ -203,7 +208,7 @@ static int mt9m111_reg_write(struct i2c_client *client, const u16 reg,
 
         ret = reg_page_map_set(client, reg);
         if (!ret)
-                ret = i2c_smbus_write_word_data(client, (reg & 0xff),
+                ret = i2c_smbus_write_word_data(client, reg & 0xff,
                                                 swab16(data));
         dev_dbg(&client->dev, "write reg.%03x = %04x -> %d\n", reg, data, ret);
         return ret;
@@ -229,10 +234,9 @@ static int mt9m111_reg_clear(struct i2c_client *client, const u16 reg,
         return mt9m111_reg_write(client, reg, ret & ~data);
 }
 
-static int mt9m111_set_context(struct soc_camera_device *icd,
+static int mt9m111_set_context(struct i2c_client *client,
                                enum mt9m111_context ctxt)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
         int valB = MT9M111_CTXT_CTRL_RESTART | MT9M111_CTXT_CTRL_DEFECTCOR_B
                 | MT9M111_CTXT_CTRL_RESIZE_B | MT9M111_CTXT_CTRL_CTRL2_B
                 | MT9M111_CTXT_CTRL_GAMMA_B | MT9M111_CTXT_CTRL_READ_MODE_B
@@ -246,17 +250,16 @@ static int mt9m111_set_context(struct soc_camera_device *icd,
                 return reg_write(CONTEXT_CONTROL, valA);
 }
 
-static int mt9m111_setup_rect(struct soc_camera_device *icd,
+static int mt9m111_setup_rect(struct i2c_client *client,
                               struct v4l2_rect *rect)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret, is_raw_format;
         int width = rect->width;
         int height = rect->height;
 
-        if ((mt9m111->pixfmt == V4L2_PIX_FMT_SBGGR8)
-            || (mt9m111->pixfmt == V4L2_PIX_FMT_SBGGR16))
+        if (mt9m111->pixfmt == V4L2_PIX_FMT_SBGGR8 ||
+            mt9m111->pixfmt == V4L2_PIX_FMT_SBGGR16)
                 is_raw_format = 1;
         else
                 is_raw_format = 0;
@@ -292,9 +295,8 @@ static int mt9m111_setup_rect(struct soc_camera_device *icd,
         return ret;
 }
 
-static int mt9m111_setup_pixfmt(struct soc_camera_device *icd, u16 outfmt)
+static int mt9m111_setup_pixfmt(struct i2c_client *client, u16 outfmt)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
         int ret;
 
         ret = reg_write(OUTPUT_FORMAT_CTRL2_A, outfmt);
@@ -303,19 +305,19 @@ static int mt9m111_setup_pixfmt(struct soc_camera_device *icd, u16 outfmt)
         return ret;
 }
 
-static int mt9m111_setfmt_bayer8(struct soc_camera_device *icd)
+static int mt9m111_setfmt_bayer8(struct i2c_client *client)
 {
-        return mt9m111_setup_pixfmt(icd, MT9M111_OUTFMT_PROCESSED_BAYER);
+        return mt9m111_setup_pixfmt(client, MT9M111_OUTFMT_PROCESSED_BAYER);
 }
 
-static int mt9m111_setfmt_bayer10(struct soc_camera_device *icd)
+static int mt9m111_setfmt_bayer10(struct i2c_client *client)
 {
-        return mt9m111_setup_pixfmt(icd, MT9M111_OUTFMT_BYPASS_IFP);
+        return mt9m111_setup_pixfmt(client, MT9M111_OUTFMT_BYPASS_IFP);
 }
 
-static int mt9m111_setfmt_rgb565(struct soc_camera_device *icd)
+static int mt9m111_setfmt_rgb565(struct i2c_client *client)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int val = 0;
 
         if (mt9m111->swap_rgb_red_blue)
@@ -324,12 +326,12 @@ static int mt9m111_setfmt_rgb565(struct soc_camera_device *icd)
                 val |= MT9M111_OUTFMT_SWAP_RGB_EVEN;
         val |= MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565;
 
-        return mt9m111_setup_pixfmt(icd, val);
+        return mt9m111_setup_pixfmt(client, val);
 }
 
-static int mt9m111_setfmt_rgb555(struct soc_camera_device *icd)
+static int mt9m111_setfmt_rgb555(struct i2c_client *client)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int val = 0;
 
         if (mt9m111->swap_rgb_red_blue)
@@ -338,12 +340,12 @@ static int mt9m111_setfmt_rgb555(struct soc_camera_device *icd)
                 val |= MT9M111_OUTFMT_SWAP_RGB_EVEN;
         val |= MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB555;
 
-        return mt9m111_setup_pixfmt(icd, val);
+        return mt9m111_setup_pixfmt(client, val);
 }
 
-static int mt9m111_setfmt_yuv(struct soc_camera_device *icd)
+static int mt9m111_setfmt_yuv(struct i2c_client *client)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int val = 0;
 
         if (mt9m111->swap_yuv_cb_cr)
@@ -351,52 +353,22 @@ static int mt9m111_setfmt_yuv(struct soc_camera_device *icd)
         if (mt9m111->swap_yuv_y_chromas)
                 val |= MT9M111_OUTFMT_SWAP_YCbCr_C_Y;
 
-        return mt9m111_setup_pixfmt(icd, val);
+        return mt9m111_setup_pixfmt(client, val);
 }
 
-static int mt9m111_enable(struct soc_camera_device *icd)
+static int mt9m111_enable(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
-        struct soc_camera_link *icl = client->dev.platform_data;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
-        if (icl->power) {
-                ret = icl->power(&client->dev, 1);
-                if (ret < 0) {
-                        dev_err(icd->vdev->parent,
-                                "Platform failed to power-on the camera.\n");
-                        return ret;
-                }
-        }
-
         ret = reg_set(RESET, MT9M111_RESET_CHIP_ENABLE);
         if (!ret)
                 mt9m111->powered = 1;
         return ret;
 }
 
-static int mt9m111_disable(struct soc_camera_device *icd)
-{
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
-        struct soc_camera_link *icl = client->dev.platform_data;
-        int ret;
-
-        ret = reg_clear(RESET, MT9M111_RESET_CHIP_ENABLE);
-        if (!ret)
-                mt9m111->powered = 0;
-
-        if (icl->power)
-                icl->power(&client->dev, 0);
-
-        return ret;
-}
-
-static int mt9m111_reset(struct soc_camera_device *icd)
+static int mt9m111_reset(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct soc_camera_link *icl = client->dev.platform_data;
         int ret;
 
         ret = reg_set(RESET, MT9M111_RESET_RESET_MODE);
@@ -406,26 +378,12 @@ static int mt9m111_reset(struct soc_camera_device *icd)
                 ret = reg_clear(RESET, MT9M111_RESET_RESET_MODE
                                 | MT9M111_RESET_RESET_SOC);
 
-        if (icl->reset)
-                icl->reset(&client->dev);
-
         return ret;
 }
 
-static int mt9m111_start_capture(struct soc_camera_device *icd)
-{
-        return 0;
-}
-
-static int mt9m111_stop_capture(struct soc_camera_device *icd)
-{
-        return 0;
-}
-
 static unsigned long mt9m111_query_bus_param(struct soc_camera_device *icd)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
-        struct soc_camera_link *icl = mt9m111->client->dev.platform_data;
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         unsigned long flags = SOCAM_MASTER | SOCAM_PCLK_SAMPLE_RISING |
                 SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_HIGH |
                 SOCAM_DATA_ACTIVE_HIGH | SOCAM_DATAWIDTH_8;
@@ -438,62 +396,126 @@ static int mt9m111_set_bus_param(struct soc_camera_device *icd, unsigned long f)
         return 0;
 }
 
-static int mt9m111_set_crop(struct soc_camera_device *icd,
-                            struct v4l2_rect *rect)
+static int mt9m111_make_rect(struct i2c_client *client,
+                             struct v4l2_rect *rect)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
+
+        if (mt9m111->pixfmt == V4L2_PIX_FMT_SBGGR8 ||
+            mt9m111->pixfmt == V4L2_PIX_FMT_SBGGR16) {
+                /* Bayer format - even size lengths */
+                rect->width     = ALIGN(rect->width, 2);
+                rect->height    = ALIGN(rect->height, 2);
+                /* Let the user play with the starting pixel */
+        }
+
+        /* FIXME: the datasheet doesn't specify minimum sizes */
+        soc_camera_limit_side(&rect->left, &rect->width,
+                     MT9M111_MIN_DARK_COLS, 2, MT9M111_MAX_WIDTH);
+
+        soc_camera_limit_side(&rect->top, &rect->height,
+                     MT9M111_MIN_DARK_ROWS, 2, MT9M111_MAX_HEIGHT);
+
+        return mt9m111_setup_rect(client, rect);
+}
+
+static int mt9m111_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+        struct v4l2_rect rect = a->c;
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
-        dev_dbg(&icd->dev, "%s left=%d, top=%d, width=%d, height=%d\n",
-                __func__, rect->left, rect->top, rect->width,
-                rect->height);
+        dev_dbg(&client->dev, "%s left=%d, top=%d, width=%d, height=%d\n",
+                __func__, rect.left, rect.top, rect.width, rect.height);
 
-        ret = mt9m111_setup_rect(icd, rect);
+        ret = mt9m111_make_rect(client, &rect);
         if (!ret)
-                mt9m111->rect = *rect;
+                mt9m111->rect = rect;
         return ret;
 }
 
-static int mt9m111_set_pixfmt(struct soc_camera_device *icd, u32 pixfmt)
+static int mt9m111_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
+
+        a->c    = mt9m111->rect;
+        a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        return 0;
+}
+
+static int mt9m111_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+        a->bounds.left                  = MT9M111_MIN_DARK_COLS;
+        a->bounds.top                   = MT9M111_MIN_DARK_ROWS;
+        a->bounds.width                 = MT9M111_MAX_WIDTH;
+        a->bounds.height                = MT9M111_MAX_HEIGHT;
+        a->defrect                      = a->bounds;
+        a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        a->pixelaspect.numerator        = 1;
+        a->pixelaspect.denominator      = 1;
+
+        return 0;
+}
+
+static int mt9m111_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+
+        pix->width              = mt9m111->rect.width;
+        pix->height             = mt9m111->rect.height;
+        pix->pixelformat        = mt9m111->pixfmt;
+        pix->field              = V4L2_FIELD_NONE;
+        pix->colorspace         = V4L2_COLORSPACE_SRGB;
+
+        return 0;
+}
+
+static int mt9m111_set_pixfmt(struct i2c_client *client, u32 pixfmt)
+{
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         switch (pixfmt) {
         case V4L2_PIX_FMT_SBGGR8:
-                ret = mt9m111_setfmt_bayer8(icd);
+                ret = mt9m111_setfmt_bayer8(client);
                 break;
         case V4L2_PIX_FMT_SBGGR16:
-                ret = mt9m111_setfmt_bayer10(icd);
+                ret = mt9m111_setfmt_bayer10(client);
                 break;
         case V4L2_PIX_FMT_RGB555:
-                ret = mt9m111_setfmt_rgb555(icd);
+                ret = mt9m111_setfmt_rgb555(client);
                 break;
         case V4L2_PIX_FMT_RGB565:
-                ret = mt9m111_setfmt_rgb565(icd);
+                ret = mt9m111_setfmt_rgb565(client);
                 break;
         case V4L2_PIX_FMT_UYVY:
                 mt9m111->swap_yuv_y_chromas = 0;
                 mt9m111->swap_yuv_cb_cr = 0;
-                ret = mt9m111_setfmt_yuv(icd);
+                ret = mt9m111_setfmt_yuv(client);
                 break;
         case V4L2_PIX_FMT_VYUY:
                 mt9m111->swap_yuv_y_chromas = 0;
                 mt9m111->swap_yuv_cb_cr = 1;
-                ret = mt9m111_setfmt_yuv(icd);
+                ret = mt9m111_setfmt_yuv(client);
                 break;
         case V4L2_PIX_FMT_YUYV:
                 mt9m111->swap_yuv_y_chromas = 1;
                 mt9m111->swap_yuv_cb_cr = 0;
-                ret = mt9m111_setfmt_yuv(icd);
+                ret = mt9m111_setfmt_yuv(client);
                 break;
         case V4L2_PIX_FMT_YVYU:
                 mt9m111->swap_yuv_y_chromas = 1;
                 mt9m111->swap_yuv_cb_cr = 1;
-                ret = mt9m111_setfmt_yuv(icd);
+                ret = mt9m111_setfmt_yuv(client);
                 break;
         default:
-                dev_err(&icd->dev, "Pixel format not handled : %x\n", pixfmt);
+                dev_err(&client->dev, "Pixel format not handled : %x\n",
+                        pixfmt);
                 ret = -EINVAL;
         }
 
@@ -503,10 +525,10 @@ static int mt9m111_set_pixfmt(struct soc_camera_device *icd, u32 pixfmt)
         return ret;
 }
 
-static int mt9m111_set_fmt(struct soc_camera_device *icd,
-                           struct v4l2_format *f)
+static int mt9m111_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         struct v4l2_pix_format *pix = &f->fmt.pix;
         struct v4l2_rect rect = {
                 .left   = mt9m111->rect.left,
@@ -516,40 +538,56 @@ static int mt9m111_set_fmt(struct soc_camera_device *icd,
         };
         int ret;
 
-        dev_dbg(&icd->dev, "%s fmt=%x left=%d, top=%d, width=%d, height=%d\n",
-                __func__, pix->pixelformat, rect.left, rect.top, rect.width,
-                rect.height);
+        dev_dbg(&client->dev,
+                "%s fmt=%x left=%d, top=%d, width=%d, height=%d\n", __func__,
+                pix->pixelformat, rect.left, rect.top, rect.width, rect.height);
 
-        ret = mt9m111_setup_rect(icd, &rect);
+        ret = mt9m111_make_rect(client, &rect);
         if (!ret)
-                ret = mt9m111_set_pixfmt(icd, pix->pixelformat);
+                ret = mt9m111_set_pixfmt(client, pix->pixelformat);
         if (!ret)
                 mt9m111->rect = rect;
         return ret;
 }
 
-static int mt9m111_try_fmt(struct soc_camera_device *icd,
-                           struct v4l2_format *f)
+static int mt9m111_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
         struct v4l2_pix_format *pix = &f->fmt.pix;
+        bool bayer = pix->pixelformat == V4L2_PIX_FMT_SBGGR8 ||
+                pix->pixelformat == V4L2_PIX_FMT_SBGGR16;
+
+        /*
+         * With Bayer format enforce even side lengths, but let the user play
+         * with the starting pixel
+         */
 
         if (pix->height > MT9M111_MAX_HEIGHT)
                 pix->height = MT9M111_MAX_HEIGHT;
+        else if (pix->height < 2)
+                pix->height = 2;
+        else if (bayer)
+                pix->height = ALIGN(pix->height, 2);
+
         if (pix->width > MT9M111_MAX_WIDTH)
                 pix->width = MT9M111_MAX_WIDTH;
+        else if (pix->width < 2)
+                pix->width = 2;
+        else if (bayer)
+                pix->width = ALIGN(pix->width, 2);
 
         return 0;
 }
 
-static int mt9m111_get_chip_id(struct soc_camera_device *icd,
-                               struct v4l2_dbg_chip_ident *id)
+static int mt9m111_g_chip_ident(struct v4l2_subdev *sd,
+                                struct v4l2_dbg_chip_ident *id)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
 
         if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
                 return -EINVAL;
 
-        if (id->match.addr != mt9m111->client->addr)
+        if (id->match.addr != client->addr)
                 return -ENODEV;
 
         id->ident       = mt9m111->model;
@@ -559,11 +597,11 @@ static int mt9m111_get_chip_id(struct soc_camera_device *icd,
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mt9m111_get_register(struct soc_camera_device *icd,
-                                struct v4l2_dbg_register *reg)
+static int mt9m111_g_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
 {
+        struct i2c_client *client = sd->priv;
         int val;
-        struct i2c_client *client = to_i2c_client(icd->control);
 
         if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
                 return -EINVAL;
@@ -580,10 +618,10 @@ static int mt9m111_get_register(struct soc_camera_device *icd,
         return 0;
 }
 
-static int mt9m111_set_register(struct soc_camera_device *icd,
-                                struct v4l2_dbg_register *reg)
+static int mt9m111_s_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = sd->priv;
 
         if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0x2ff)
                 return -EINVAL;
@@ -635,45 +673,21 @@ static const struct v4l2_queryctrl mt9m111_controls[] = {
         }
 };
 
-static int mt9m111_video_probe(struct soc_camera_device *);
-static void mt9m111_video_remove(struct soc_camera_device *);
-static int mt9m111_get_control(struct soc_camera_device *,
-                               struct v4l2_control *);
-static int mt9m111_set_control(struct soc_camera_device *,
-                               struct v4l2_control *);
 static int mt9m111_resume(struct soc_camera_device *icd);
-static int mt9m111_init(struct soc_camera_device *icd);
-static int mt9m111_release(struct soc_camera_device *icd);
+static int mt9m111_suspend(struct soc_camera_device *icd, pm_message_t state);
 
 static struct soc_camera_ops mt9m111_ops = {
-        .owner                  = THIS_MODULE,
-        .probe                  = mt9m111_video_probe,
-        .remove                 = mt9m111_video_remove,
-        .init                   = mt9m111_init,
+        .suspend                = mt9m111_suspend,
         .resume                 = mt9m111_resume,
-        .release                = mt9m111_release,
-        .start_capture          = mt9m111_start_capture,
-        .stop_capture           = mt9m111_stop_capture,
-        .set_crop               = mt9m111_set_crop,
-        .set_fmt                = mt9m111_set_fmt,
-        .try_fmt                = mt9m111_try_fmt,
         .query_bus_param        = mt9m111_query_bus_param,
         .set_bus_param          = mt9m111_set_bus_param,
         .controls               = mt9m111_controls,
         .num_controls           = ARRAY_SIZE(mt9m111_controls),
-        .get_control            = mt9m111_get_control,
-        .set_control            = mt9m111_set_control,
-        .get_chip_id            = mt9m111_get_chip_id,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-        .get_register           = mt9m111_get_register,
-        .set_register           = mt9m111_set_register,
-#endif
 };
 
-static int mt9m111_set_flip(struct soc_camera_device *icd, int flip, int mask)
+static int mt9m111_set_flip(struct i2c_client *client, int flip, int mask)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         if (mt9m111->context == HIGHPOWER) {
@@ -691,9 +705,8 @@ static int mt9m111_set_flip(struct soc_camera_device *icd, int flip, int mask)
         return ret;
 }
 
-static int mt9m111_get_global_gain(struct soc_camera_device *icd)
+static int mt9m111_get_global_gain(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
         int data;
 
         data = reg_read(GLOBAL_GAIN);
@@ -703,15 +716,15 @@ static int mt9m111_get_global_gain(struct soc_camera_device *icd)
         return data;
 }
 
-static int mt9m111_set_global_gain(struct soc_camera_device *icd, int gain)
+static int mt9m111_set_global_gain(struct i2c_client *client, int gain)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         u16 val;
 
         if (gain > 63 * 2 * 2)
                 return -EINVAL;
 
-        icd->gain = gain;
+        mt9m111->gain = gain;
         if ((gain >= 64 * 2) && (gain < 63 * 2 * 2))
                 val = (1 << 10) | (1 << 9) | (gain / 4);
         else if ((gain >= 64) && (gain < 64 * 2))
@@ -722,10 +735,9 @@ static int mt9m111_set_global_gain(struct soc_camera_device *icd, int gain)
         return reg_write(GLOBAL_GAIN, val);
 }
 
-static int mt9m111_set_autoexposure(struct soc_camera_device *icd, int on)
+static int mt9m111_set_autoexposure(struct i2c_client *client, int on)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         if (on)
@@ -739,10 +751,9 @@ static int mt9m111_set_autoexposure(struct soc_camera_device *icd, int on)
         return ret;
 }
 
-static int mt9m111_set_autowhitebalance(struct soc_camera_device *icd, int on)
+static int mt9m111_set_autowhitebalance(struct i2c_client *client, int on)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         if (on)
@@ -756,11 +767,10 @@ static int mt9m111_set_autowhitebalance(struct soc_camera_device *icd, int on)
         return ret;
 }
 
-static int mt9m111_get_control(struct soc_camera_device *icd,
-                               struct v4l2_control *ctrl)
+static int mt9m111_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int data;
 
         switch (ctrl->id) {
@@ -785,7 +795,7 @@ static int mt9m111_get_control(struct soc_camera_device *icd,
                 ctrl->value = !!(data & MT9M111_RMB_MIRROR_COLS);
                 break;
         case V4L2_CID_GAIN:
-                data = mt9m111_get_global_gain(icd);
+                data = mt9m111_get_global_gain(client);
                 if (data < 0)
                         return data;
                 ctrl->value = data;
@@ -800,37 +810,36 @@ static int mt9m111_get_control(struct soc_camera_device *icd,
         return 0;
 }
 
-static int mt9m111_set_control(struct soc_camera_device *icd,
-                               struct v4l2_control *ctrl)
+static int mt9m111_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         const struct v4l2_queryctrl *qctrl;
         int ret;
 
         qctrl = soc_camera_find_qctrl(&mt9m111_ops, ctrl->id);
-
         if (!qctrl)
                 return -EINVAL;
 
         switch (ctrl->id) {
         case V4L2_CID_VFLIP:
                 mt9m111->vflip = ctrl->value;
-                ret = mt9m111_set_flip(icd, ctrl->value,
+                ret = mt9m111_set_flip(client, ctrl->value,
                                         MT9M111_RMB_MIRROR_ROWS);
                 break;
         case V4L2_CID_HFLIP:
                 mt9m111->hflip = ctrl->value;
-                ret = mt9m111_set_flip(icd, ctrl->value,
+                ret = mt9m111_set_flip(client, ctrl->value,
                                         MT9M111_RMB_MIRROR_COLS);
                 break;
         case V4L2_CID_GAIN:
-                ret = mt9m111_set_global_gain(icd, ctrl->value);
+                ret = mt9m111_set_global_gain(client, ctrl->value);
                 break;
         case V4L2_CID_EXPOSURE_AUTO:
-                ret =  mt9m111_set_autoexposure(icd, ctrl->value);
+                ret =  mt9m111_set_autoexposure(client, ctrl->value);
                 break;
         case V4L2_CID_AUTO_WHITE_BALANCE:
-                ret =  mt9m111_set_autowhitebalance(icd, ctrl->value);
+                ret =  mt9m111_set_autowhitebalance(client, ctrl->value);
                 break;
         default:
                 ret = -EINVAL;
@@ -839,62 +848,62 @@ static int mt9m111_set_control(struct soc_camera_device *icd,
         return ret;
 }
 
-static int mt9m111_restore_state(struct soc_camera_device *icd)
+static int mt9m111_suspend(struct soc_camera_device *icd, pm_message_t state)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
-
-        mt9m111_set_context(icd, mt9m111->context);
-        mt9m111_set_pixfmt(icd, mt9m111->pixfmt);
-        mt9m111_setup_rect(icd, &mt9m111->rect);
-        mt9m111_set_flip(icd, mt9m111->hflip, MT9M111_RMB_MIRROR_COLS);
-        mt9m111_set_flip(icd, mt9m111->vflip, MT9M111_RMB_MIRROR_ROWS);
-        mt9m111_set_global_gain(icd, icd->gain);
-        mt9m111_set_autoexposure(icd, mt9m111->autoexposure);
-        mt9m111_set_autowhitebalance(icd, mt9m111->autowhitebalance);
+        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
+
+        mt9m111->gain = mt9m111_get_global_gain(client);
+
+        return 0;
+}
+
+static int mt9m111_restore_state(struct i2c_client *client)
+{
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
+
+        mt9m111_set_context(client, mt9m111->context);
+        mt9m111_set_pixfmt(client, mt9m111->pixfmt);
+        mt9m111_setup_rect(client, &mt9m111->rect);
+        mt9m111_set_flip(client, mt9m111->hflip, MT9M111_RMB_MIRROR_COLS);
+        mt9m111_set_flip(client, mt9m111->vflip, MT9M111_RMB_MIRROR_ROWS);
+        mt9m111_set_global_gain(client, mt9m111->gain);
+        mt9m111_set_autoexposure(client, mt9m111->autoexposure);
+        mt9m111_set_autowhitebalance(client, mt9m111->autowhitebalance);
         return 0;
 }
 
 static int mt9m111_resume(struct soc_camera_device *icd)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret = 0;
 
         if (mt9m111->powered) {
-                ret = mt9m111_enable(icd);
+                ret = mt9m111_enable(client);
                 if (!ret)
-                        ret = mt9m111_reset(icd);
+                        ret = mt9m111_reset(client);
                 if (!ret)
-                        ret = mt9m111_restore_state(icd);
+                        ret = mt9m111_restore_state(client);
         }
         return ret;
 }
 
-static int mt9m111_init(struct soc_camera_device *icd)
+static int mt9m111_init(struct i2c_client *client)
 {
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         int ret;
 
         mt9m111->context = HIGHPOWER;
-        ret = mt9m111_enable(icd);
+        ret = mt9m111_enable(client);
         if (!ret)
-                ret = mt9m111_reset(icd);
+                ret = mt9m111_reset(client);
         if (!ret)
-                ret = mt9m111_set_context(icd, mt9m111->context);
+                ret = mt9m111_set_context(client, mt9m111->context);
         if (!ret)
-                ret = mt9m111_set_autoexposure(icd, mt9m111->autoexposure);
+                ret = mt9m111_set_autoexposure(client, mt9m111->autoexposure);
         if (ret)
-                dev_err(&icd->dev, "mt9m11x init failed: %d\n", ret);
-        return ret;
-}
-
-static int mt9m111_release(struct soc_camera_device *icd)
-{
-        int ret;
-
-        ret = mt9m111_disable(icd);
-        if (ret < 0)
-                dev_err(&icd->dev, "mt9m11x release failed: %d\n", ret);
-
+                dev_err(&client->dev, "mt9m11x init failed: %d\n", ret);
         return ret;
 }
 
@@ -902,10 +911,10 @@ static int mt9m111_release(struct soc_camera_device *icd)
  * Interface active, can use i2c. If it fails, it can indeed mean, that
  * this wasn't our capture interface, so, we wait for the right one
  */
-static int mt9m111_video_probe(struct soc_camera_device *icd)
+static int mt9m111_video_probe(struct soc_camera_device *icd,
+                               struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
         s32 data;
         int ret;
 
@@ -917,10 +926,13 @@ static int mt9m111_video_probe(struct soc_camera_device *icd)
             to_soc_camera_host(icd->dev.parent)->nr != icd->iface)
                 return -ENODEV;
 
-        ret = mt9m111_enable(icd);
-        if (ret)
-                goto ei2c;
-        ret = mt9m111_reset(icd);
+        mt9m111->autoexposure = 1;
+        mt9m111->autowhitebalance = 1;
+
+        mt9m111->swap_rgb_even_odd = 1;
+        mt9m111->swap_rgb_red_blue = 1;
+
+        ret = mt9m111_init(client);
         if (ret)
                 goto ei2c;
 
@@ -935,7 +947,7 @@ static int mt9m111_video_probe(struct soc_camera_device *icd)
                 break;
         default:
                 ret = -ENODEV;
-                dev_err(&icd->dev,
+                dev_err(&client->dev,
                         "No MT9M11x chip detected, register read %x\n", data);
                 goto ei2c;
         }
@@ -943,42 +955,51 @@ static int mt9m111_video_probe(struct soc_camera_device *icd)
         icd->formats = mt9m111_colour_formats;
         icd->num_formats = ARRAY_SIZE(mt9m111_colour_formats);
 
-        dev_info(&icd->dev, "Detected a MT9M11x chip ID %x\n", data);
+        dev_info(&client->dev, "Detected a MT9M11x chip ID %x\n", data);
 
-        ret = soc_camera_video_start(icd);
-        if (ret)
-                goto eisis;
-
-        mt9m111->autoexposure = 1;
-        mt9m111->autowhitebalance = 1;
-
-        mt9m111->swap_rgb_even_odd = 1;
-        mt9m111->swap_rgb_red_blue = 1;
-
-        return 0;
-eisis:
 ei2c:
         return ret;
 }
 
-static void mt9m111_video_remove(struct soc_camera_device *icd)
-{
-        struct mt9m111 *mt9m111 = container_of(icd, struct mt9m111, icd);
+static struct v4l2_subdev_core_ops mt9m111_subdev_core_ops = {
+        .g_ctrl         = mt9m111_g_ctrl,
+        .s_ctrl         = mt9m111_s_ctrl,
+        .g_chip_ident   = mt9m111_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+        .g_register     = mt9m111_g_register,
+        .s_register     = mt9m111_s_register,
+#endif
+};
 
-        dev_dbg(&icd->dev, "Video %x removed: %p, %p\n", mt9m111->client->addr,
-                mt9m111->icd.dev.parent, mt9m111->icd.vdev);
-        soc_camera_video_stop(&mt9m111->icd);
-}
+static struct v4l2_subdev_video_ops mt9m111_subdev_video_ops = {
+        .s_fmt          = mt9m111_s_fmt,
+        .g_fmt          = mt9m111_g_fmt,
+        .try_fmt        = mt9m111_try_fmt,
+        .s_crop         = mt9m111_s_crop,
+        .g_crop         = mt9m111_g_crop,
+        .cropcap        = mt9m111_cropcap,
+};
+
+static struct v4l2_subdev_ops mt9m111_subdev_ops = {
+        .core   = &mt9m111_subdev_core_ops,
+        .video  = &mt9m111_subdev_video_ops,
+};
 
 static int mt9m111_probe(struct i2c_client *client,
                          const struct i2c_device_id *did)
 {
         struct mt9m111 *mt9m111;
-        struct soc_camera_device *icd;
+        struct soc_camera_device *icd = client->dev.platform_data;
         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
-        struct soc_camera_link *icl = client->dev.platform_data;
+        struct soc_camera_link *icl;
         int ret;
 
+        if (!icd) {
+                dev_err(&client->dev, "MT9M11x: missing soc-camera data!\n");
+                return -EINVAL;
+        }
+
+        icl = to_soc_camera_link(icd);
         if (!icl) {
                 dev_err(&client->dev, "MT9M11x driver needs platform data\n");
                 return -EINVAL;
@@ -994,38 +1015,35 @@ static int mt9m111_probe(struct i2c_client *client,
         if (!mt9m111)
                 return -ENOMEM;
 
-        mt9m111->client = client;
-        i2c_set_clientdata(client, mt9m111);
+        v4l2_i2c_subdev_init(&mt9m111->subdev, client, &mt9m111_subdev_ops);
 
         /* Second stage probe - when a capture adapter is there */
-        icd             = &mt9m111->icd;
-        icd->ops        = &mt9m111_ops;
-        icd->control    = &client->dev;
-        icd->x_min      = MT9M111_MIN_DARK_COLS;
-        icd->y_min      = MT9M111_MIN_DARK_ROWS;
-        icd->x_current  = icd->x_min;
-        icd->y_current  = icd->y_min;
-        icd->width_min  = MT9M111_MIN_DARK_ROWS;
-        icd->width_max  = MT9M111_MAX_WIDTH;
-        icd->height_min = MT9M111_MIN_DARK_COLS;
-        icd->height_max = MT9M111_MAX_HEIGHT;
-        icd->y_skip_top = 0;
-        icd->iface      = icl->bus_id;
-
-        ret = soc_camera_device_register(icd);
-        if (ret)
-                goto eisdr;
-        return 0;
+        icd->ops                = &mt9m111_ops;
+        icd->y_skip_top         = 0;
+
+        mt9m111->rect.left      = MT9M111_MIN_DARK_COLS;
+        mt9m111->rect.top       = MT9M111_MIN_DARK_ROWS;
+        mt9m111->rect.width     = MT9M111_MAX_WIDTH;
+        mt9m111->rect.height    = MT9M111_MAX_HEIGHT;
+
+        ret = mt9m111_video_probe(icd, client);
+        if (ret) {
+                icd->ops = NULL;
+                i2c_set_clientdata(client, NULL);
+                kfree(mt9m111);
+        }
 
-eisdr:
-        kfree(mt9m111);
         return ret;
 }
 
 static int mt9m111_remove(struct i2c_client *client)
 {
-        struct mt9m111 *mt9m111 = i2c_get_clientdata(client);
-        soc_camera_device_unregister(&mt9m111->icd);
+        struct mt9m111 *mt9m111 = to_mt9m111(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
+
+        icd->ops = NULL;
+        i2c_set_clientdata(client, NULL);
+        client->driver = NULL;
         kfree(mt9m111);
 
         return 0;
diff --git a/drivers/media/video/mt9t031.c b/drivers/media/video/mt9t031.c
index 4207fb342670..6966f644977e 100644
--- a/drivers/media/video/mt9t031.c
+++ b/drivers/media/video/mt9t031.c
@@ -13,13 +13,13 @@
 #include <linux/i2c.h>
 #include <linux/log2.h>
 
-#include <media/v4l2-common.h>
+#include <media/v4l2-subdev.h>
 #include <media/v4l2-chip-ident.h>
 #include <media/soc_camera.h>
 
 /* mt9t031 i2c address 0x5d
- * The platform has to define i2c_board_info
- * and call i2c_register_board_info() */
+ * The platform has to define i2c_board_info and link to it from
+ * struct soc_camera_link */
 
 /* mt9t031 selected register addresses */
 #define MT9T031_CHIP_VERSION            0x00
@@ -47,7 +47,7 @@
 #define MT9T031_MAX_HEIGHT              1536
 #define MT9T031_MAX_WIDTH               2048
 #define MT9T031_MIN_HEIGHT              2
-#define MT9T031_MIN_WIDTH               2
+#define MT9T031_MIN_WIDTH               18
 #define MT9T031_HORIZONTAL_BLANK        142
 #define MT9T031_VERTICAL_BLANK          25
 #define MT9T031_COLUMN_SKIP             32
@@ -68,14 +68,21 @@ static const struct soc_camera_data_format mt9t031_colour_formats[] = {
 };
 
 struct mt9t031 {
-        struct i2c_client *client;
-        struct soc_camera_device icd;
+        struct v4l2_subdev subdev;
+        struct v4l2_rect rect;  /* Sensor window */
         int model;      /* V4L2_IDENT_MT9T031* codes from v4l2-chip-ident.h */
-        unsigned char autoexposure;
         u16 xskip;
         u16 yskip;
+        unsigned int gain;
+        unsigned int exposure;
+        unsigned char autoexposure;
 };
 
+static struct mt9t031 *to_mt9t031(const struct i2c_client *client)
+{
+        return container_of(i2c_get_clientdata(client), struct mt9t031, subdev);
+}
+
 static int reg_read(struct i2c_client *client, const u8 reg)
 {
         s32 data = i2c_smbus_read_word_data(client, reg);
@@ -136,21 +143,10 @@ static int get_shutter(struct i2c_client *client, u32 *data)
         return ret < 0 ? ret : 0;
 }
 
-static int mt9t031_init(struct soc_camera_device *icd)
+static int mt9t031_idle(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct soc_camera_link *icl = client->dev.platform_data;
         int ret;
 
-        if (icl->power) {
-                ret = icl->power(&client->dev, 1);
-                if (ret < 0) {
-                        dev_err(icd->vdev->parent,
-                                "Platform failed to power-on the camera.\n");
-                        return ret;
-                }
-        }
-
         /* Disable chip output, synchronous option update */
         ret = reg_write(client, MT9T031_RESET, 1);
         if (ret >= 0)
@@ -158,50 +154,39 @@ static int mt9t031_init(struct soc_camera_device *icd)
         if (ret >= 0)
                 ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
 
-        if (ret < 0 && icl->power)
-                icl->power(&client->dev, 0);
-
         return ret >= 0 ? 0 : -EIO;
 }
 
-static int mt9t031_release(struct soc_camera_device *icd)
+static int mt9t031_disable(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct soc_camera_link *icl = client->dev.platform_data;
-
         /* Disable the chip */
         reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
 
-        if (icl->power)
-                icl->power(&client->dev, 0);
-
         return 0;
 }
 
-static int mt9t031_start_capture(struct soc_camera_device *icd)
+static int mt9t031_s_stream(struct v4l2_subdev *sd, int enable)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-
-        /* Switch to master "normal" mode */
-        if (reg_set(client, MT9T031_OUTPUT_CONTROL, 2) < 0)
-                return -EIO;
-        return 0;
-}
+        struct i2c_client *client = sd->priv;
+        int ret;
 
-static int mt9t031_stop_capture(struct soc_camera_device *icd)
-{
-        struct i2c_client *client = to_i2c_client(icd->control);
+        if (enable)
+                /* Switch to master "normal" mode */
+                ret = reg_set(client, MT9T031_OUTPUT_CONTROL, 2);
+        else
+                /* Stop sensor readout */
+                ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
 
-        /* Stop sensor readout */
-        if (reg_clear(client, MT9T031_OUTPUT_CONTROL, 2) < 0)
+        if (ret < 0)
                 return -EIO;
+
         return 0;
 }
 
 static int mt9t031_set_bus_param(struct soc_camera_device *icd,
                                  unsigned long flags)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
 
         /* The caller should have queried our parameters, check anyway */
         if (flags & ~MT9T031_BUS_PARAM)
@@ -217,69 +202,73 @@ static int mt9t031_set_bus_param(struct soc_camera_device *icd,
 
 static unsigned long mt9t031_query_bus_param(struct soc_camera_device *icd)
 {
-        struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
-        struct soc_camera_link *icl = mt9t031->client->dev.platform_data;
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
 
         return soc_camera_apply_sensor_flags(icl, MT9T031_BUS_PARAM);
 }
 
-/* Round up minima and round down maxima */
-static void recalculate_limits(struct soc_camera_device *icd,
-                               u16 xskip, u16 yskip)
+/* target must be _even_ */
+static u16 mt9t031_skip(s32 *source, s32 target, s32 max)
 {
-        icd->x_min = (MT9T031_COLUMN_SKIP + xskip - 1) / xskip;
-        icd->y_min = (MT9T031_ROW_SKIP + yskip - 1) / yskip;
-        icd->width_min = (MT9T031_MIN_WIDTH + xskip - 1) / xskip;
-        icd->height_min = (MT9T031_MIN_HEIGHT + yskip - 1) / yskip;
-        icd->width_max = MT9T031_MAX_WIDTH / xskip;
-        icd->height_max = MT9T031_MAX_HEIGHT / yskip;
+        unsigned int skip;
+
+        if (*source < target + target / 2) {
+                *source = target;
+                return 1;
+        }
+
+        skip = min(max, *source + target / 2) / target;
+        if (skip > 8)
+                skip = 8;
+        *source = target * skip;
+
+        return skip;
 }
 
+/* rect is the sensor rectangle, the caller guarantees parameter validity */
 static int mt9t031_set_params(struct soc_camera_device *icd,
                               struct v4l2_rect *rect, u16 xskip, u16 yskip)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
+        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+        struct mt9t031 *mt9t031 = to_mt9t031(client);
         int ret;
-        u16 xbin, ybin, width, height, left, top;
+        u16 xbin, ybin;
         const u16 hblank = MT9T031_HORIZONTAL_BLANK,
                 vblank = MT9T031_VERTICAL_BLANK;
 
-        /* Make sure we don't exceed sensor limits */
-        if (rect->left + rect->width > icd->width_max)
-                rect->left = (icd->width_max - rect->width) / 2 + icd->x_min;
-
-        if (rect->top + rect->height > icd->height_max)
-                rect->top = (icd->height_max - rect->height) / 2 + icd->y_min;
-
-        width = rect->width * xskip;
-        height = rect->height * yskip;
-        left = rect->left * xskip;
-        top = rect->top * yskip;
-
         xbin = min(xskip, (u16)3);
         ybin = min(yskip, (u16)3);
 
-        dev_dbg(&icd->dev, "xskip %u, width %u/%u, yskip %u, height %u/%u\n",
-                xskip, width, rect->width, yskip, height, rect->height);
-
-        /* Could just do roundup(rect->left, [xy]bin * 2); but this is cheaper */
+        /*
+         * Could just do roundup(rect->left, [xy]bin * 2); but this is cheaper.
+         * There is always a valid suitably aligned value. The worst case is
+         * xbin = 3, width = 2048. Then we will start at 36, the last read out
+         * pixel will be 2083, which is < 2085 - first black pixel.
+         *
+         * MT9T031 datasheet imposes window left border alignment, depending on
+         * the selected xskip. Failing to conform to this requirement produces
+         * dark horizontal stripes in the image. However, even obeying to this
+         * requirement doesn't eliminate the stripes in all configurations. They
+         * appear "locally reproducibly," but can differ between tests under
+         * different lighting conditions.
+         */
         switch (xbin) {
-        case 2:
-                left = (left + 3) & ~3;
+        case 1:
+                rect->left &= ~1;
                 break;
-        case 3:
-                left = roundup(left, 6);
-        }
-
-        switch (ybin) {
         case 2:
-                top = (top + 3) & ~3;
+                rect->left &= ~3;
                 break;
         case 3:
-                top = roundup(top, 6);
+                rect->left = rect->left > roundup(MT9T031_COLUMN_SKIP, 6) ?
+                        (rect->left / 6) * 6 : roundup(MT9T031_COLUMN_SKIP, 6);
         }
 
+        rect->top &= ~1;
+
+        dev_dbg(&client->dev, "skip %u:%u, rect %ux%u@%u:%u\n",
+                xskip, yskip, rect->width, rect->height, rect->left, rect->top);
+
         /* Disable register update, reconfigure atomically */
         ret = reg_set(client, MT9T031_OUTPUT_CONTROL, 1);
         if (ret < 0)
@@ -299,29 +288,30 @@ static int mt9t031_set_params(struct soc_camera_device *icd,
                         ret = reg_write(client, MT9T031_ROW_ADDRESS_MODE,
                                         ((ybin - 1) << 4) | (yskip - 1));
         }
-        dev_dbg(&icd->dev, "new physical left %u, top %u\n", left, top);
+        dev_dbg(&client->dev, "new physical left %u, top %u\n",
+                rect->left, rect->top);
 
         /* The caller provides a supported format, as guaranteed by
          * icd->try_fmt_cap(), soc_camera_s_crop() and soc_camera_cropcap() */
         if (ret >= 0)
-                ret = reg_write(client, MT9T031_COLUMN_START, left);
+                ret = reg_write(client, MT9T031_COLUMN_START, rect->left);
         if (ret >= 0)
-                ret = reg_write(client, MT9T031_ROW_START, top);
+                ret = reg_write(client, MT9T031_ROW_START, rect->top);
         if (ret >= 0)
-                ret = reg_write(client, MT9T031_WINDOW_WIDTH, width - 1);
+                ret = reg_write(client, MT9T031_WINDOW_WIDTH, rect->width - 1);
         if (ret >= 0)
                 ret = reg_write(client, MT9T031_WINDOW_HEIGHT,
-                                height + icd->y_skip_top - 1);
+                                rect->height + icd->y_skip_top - 1);
         if (ret >= 0 && mt9t031->autoexposure) {
-                ret = set_shutter(client, height + icd->y_skip_top + vblank);
+                unsigned int total_h = rect->height + icd->y_skip_top + vblank;
+                ret = set_shutter(client, total_h);
                 if (ret >= 0) {
                         const u32 shutter_max = MT9T031_MAX_HEIGHT + vblank;
                         const struct v4l2_queryctrl *qctrl =
                                 soc_camera_find_qctrl(icd->ops,
                                                       V4L2_CID_EXPOSURE);
-                        icd->exposure = (shutter_max / 2 + (height +
-                                         icd->y_skip_top + vblank - 1) *
-                                         (qctrl->maximum - qctrl->minimum)) /
+                        mt9t031->exposure = (shutter_max / 2 + (total_h - 1) *
+                                 (qctrl->maximum - qctrl->minimum)) /
                                 shutter_max + qctrl->minimum;
                 }
         }
@@ -330,58 +320,99 @@ static int mt9t031_set_params(struct soc_camera_device *icd,
         if (ret >= 0)
                 ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 1);
 
+        if (ret >= 0) {
+                mt9t031->rect = *rect;
+                mt9t031->xskip = xskip;
+                mt9t031->yskip = yskip;
+        }
+
         return ret < 0 ? ret : 0;
 }
 
-static int mt9t031_set_crop(struct soc_camera_device *icd,
-                            struct v4l2_rect *rect)
+static int mt9t031_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
 {
-        struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
+        struct v4l2_rect rect = a->c;
+        struct i2c_client *client = sd->priv;
+        struct mt9t031 *mt9t031 = to_mt9t031(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
+
+        rect.width = ALIGN(rect.width, 2);
+        rect.height = ALIGN(rect.height, 2);
+
+        soc_camera_limit_side(&rect.left, &rect.width,
+                     MT9T031_COLUMN_SKIP, MT9T031_MIN_WIDTH, MT9T031_MAX_WIDTH);
+
+        soc_camera_limit_side(&rect.top, &rect.height,
+                     MT9T031_ROW_SKIP, MT9T031_MIN_HEIGHT, MT9T031_MAX_HEIGHT);
 
-        /* CROP - no change in scaling, or in limits */
-        return mt9t031_set_params(icd, rect, mt9t031->xskip, mt9t031->yskip);
+        return mt9t031_set_params(icd, &rect, mt9t031->xskip, mt9t031->yskip);
 }
 
-static int mt9t031_set_fmt(struct soc_camera_device *icd,
-                           struct v4l2_format *f)
+static int mt9t031_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
 {
-        struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
-        int ret;
-        u16 xskip, yskip;
-        struct v4l2_rect rect = {
-                .left   = icd->x_current,
-                .top    = icd->y_current,
-                .width  = f->fmt.pix.width,
-                .height = f->fmt.pix.height,
-        };
+        struct i2c_client *client = sd->priv;
+        struct mt9t031 *mt9t031 = to_mt9t031(client);
 
-        /*
-         * try_fmt has put rectangle within limits.
-         * S_FMT - use binning and skipping for scaling, recalculate
-         * limits, used for cropping
-         */
-        /* Is this more optimal than just a division? */
-        for (xskip = 8; xskip > 1; xskip--)
-                if (rect.width * xskip <= MT9T031_MAX_WIDTH)
-                        break;
+        a->c    = mt9t031->rect;
+        a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
-        for (yskip = 8; yskip > 1; yskip--)
-                if (rect.height * yskip <= MT9T031_MAX_HEIGHT)
-                        break;
+        return 0;
+}
 
-        recalculate_limits(icd, xskip, yskip);
+static int mt9t031_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+        a->bounds.left                  = MT9T031_COLUMN_SKIP;
+        a->bounds.top                   = MT9T031_ROW_SKIP;
+        a->bounds.width                 = MT9T031_MAX_WIDTH;
+        a->bounds.height                = MT9T031_MAX_HEIGHT;
+        a->defrect                      = a->bounds;
+        a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        a->pixelaspect.numerator        = 1;
+        a->pixelaspect.denominator      = 1;
 
-        ret = mt9t031_set_params(icd, &rect, xskip, yskip);
-        if (!ret) {
-                mt9t031->xskip = xskip;
-                mt9t031->yskip = yskip;
-        }
+        return 0;
+}
 
-        return ret;
+static int mt9t031_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct i2c_client *client = sd->priv;
+        struct mt9t031 *mt9t031 = to_mt9t031(client);
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+
+        pix->width              = mt9t031->rect.width / mt9t031->xskip;
+        pix->height             = mt9t031->rect.height / mt9t031->yskip;
+        pix->pixelformat        = V4L2_PIX_FMT_SGRBG10;
+        pix->field              = V4L2_FIELD_NONE;
+        pix->colorspace         = V4L2_COLORSPACE_SRGB;
+
+        return 0;
+}
+
+static int mt9t031_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct i2c_client *client = sd->priv;
+        struct mt9t031 *mt9t031 = to_mt9t031(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+        u16 xskip, yskip;
+        struct v4l2_rect rect = mt9t031->rect;
+
+        /*
+         * try_fmt has put width and height within limits.
+         * S_FMT: use binning and skipping for scaling
+         */
+        xskip = mt9t031_skip(&rect.width, pix->width, MT9T031_MAX_WIDTH);
+        yskip = mt9t031_skip(&rect.height, pix->height, MT9T031_MAX_HEIGHT);
+
+        /* mt9t031_set_params() doesn't change width and height */
+        return mt9t031_set_params(icd, &rect, xskip, yskip);
 }
 
-static int mt9t031_try_fmt(struct soc_camera_device *icd,
-                           struct v4l2_format *f)
+/*
+ * If a user window larger than sensor window is requested, we'll increase the
+ * sensor window.
+ */
+static int mt9t031_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
         struct v4l2_pix_format *pix = &f->fmt.pix;
 
@@ -392,15 +423,16 @@ static int mt9t031_try_fmt(struct soc_camera_device *icd,
         return 0;
 }
 
-static int mt9t031_get_chip_id(struct soc_camera_device *icd,
-                               struct v4l2_dbg_chip_ident *id)
+static int mt9t031_g_chip_ident(struct v4l2_subdev *sd,
+                                struct v4l2_dbg_chip_ident *id)
 {
-        struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9t031 *mt9t031 = to_mt9t031(client);
 
         if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
                 return -EINVAL;
 
-        if (id->match.addr != mt9t031->client->addr)
+        if (id->match.addr != client->addr)
                 return -ENODEV;
 
         id->ident       = mt9t031->model;
@@ -410,10 +442,10 @@ static int mt9t031_get_chip_id(struct soc_camera_device *icd,
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mt9t031_get_register(struct soc_camera_device *icd,
-                                struct v4l2_dbg_register *reg)
+static int mt9t031_g_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = sd->priv;
 
         if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
@@ -429,10 +461,10 @@ static int mt9t031_get_register(struct soc_camera_device *icd,
         return 0;
 }
 
-static int mt9t031_set_register(struct soc_camera_device *icd,
-                                struct v4l2_dbg_register *reg)
+static int mt9t031_s_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = sd->priv;
 
         if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
@@ -493,39 +525,17 @@ static const struct v4l2_queryctrl mt9t031_controls[] = {
         }
 };
 
-static int mt9t031_video_probe(struct soc_camera_device *);
-static void mt9t031_video_remove(struct soc_camera_device *);
-static int mt9t031_get_control(struct soc_camera_device *, struct v4l2_control *);
-static int mt9t031_set_control(struct soc_camera_device *, struct v4l2_control *);
-
 static struct soc_camera_ops mt9t031_ops = {
-        .owner                  = THIS_MODULE,
-        .probe                  = mt9t031_video_probe,
-        .remove                 = mt9t031_video_remove,
-        .init                   = mt9t031_init,
-        .release                = mt9t031_release,
-        .start_capture          = mt9t031_start_capture,
-        .stop_capture           = mt9t031_stop_capture,
-        .set_crop               = mt9t031_set_crop,
-        .set_fmt                = mt9t031_set_fmt,
-        .try_fmt                = mt9t031_try_fmt,
         .set_bus_param          = mt9t031_set_bus_param,
         .query_bus_param        = mt9t031_query_bus_param,
         .controls               = mt9t031_controls,
         .num_controls           = ARRAY_SIZE(mt9t031_controls),
-        .get_control            = mt9t031_get_control,
-        .set_control            = mt9t031_set_control,
-        .get_chip_id            = mt9t031_get_chip_id,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-        .get_register           = mt9t031_get_register,
-        .set_register           = mt9t031_set_register,
-#endif
 };
 
-static int mt9t031_get_control(struct soc_camera_device *icd, struct v4l2_control *ctrl)
+static int mt9t031_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9t031 *mt9t031 = to_mt9t031(client);
         int data;
 
         switch (ctrl->id) {
@@ -544,14 +554,21 @@ static int mt9t031_get_control(struct soc_camera_device *icd, struct v4l2_contro
         case V4L2_CID_EXPOSURE_AUTO:
                 ctrl->value = mt9t031->autoexposure;
                 break;
+        case V4L2_CID_GAIN:
+                ctrl->value = mt9t031->gain;
+                break;
+        case V4L2_CID_EXPOSURE:
+                ctrl->value = mt9t031->exposure;
+                break;
         }
         return 0;
 }
 
-static int mt9t031_set_control(struct soc_camera_device *icd, struct v4l2_control *ctrl)
+static int mt9t031_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9t031 *mt9t031 = to_mt9t031(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
         const struct v4l2_queryctrl *qctrl;
         int data;
 
@@ -586,7 +603,7 @@ static int mt9t031_set_control(struct soc_camera_device *icd, struct v4l2_contro
                         unsigned long range = qctrl->default_value - qctrl->minimum;
                         data = ((ctrl->value - qctrl->minimum) * 8 + range / 2) / range;
 
-                        dev_dbg(&icd->dev, "Setting gain %d\n", data);
+                        dev_dbg(&client->dev, "Setting gain %d\n", data);
                         data = reg_write(client, MT9T031_GLOBAL_GAIN, data);
                         if (data < 0)
                                 return -EIO;
@@ -606,7 +623,7 @@ static int mt9t031_set_control(struct soc_camera_device *icd, struct v4l2_contro
                                 /* calculated gain 65..1024 -> (1..120) << 8 + 0x60 */
                                 data = (((gain - 64 + 7) * 32) & 0xff00) | 0x60;
 
-                        dev_dbg(&icd->dev, "Setting gain from 0x%x to 0x%x\n",
+                        dev_dbg(&client->dev, "Set gain from 0x%x to 0x%x\n",
                                 reg_read(client, MT9T031_GLOBAL_GAIN), data);
                         data = reg_write(client, MT9T031_GLOBAL_GAIN, data);
                         if (data < 0)
@@ -614,7 +631,7 @@ static int mt9t031_set_control(struct soc_camera_device *icd, struct v4l2_contro
                 }
 
                 /* Success */
-                icd->gain = ctrl->value;
+                mt9t031->gain = ctrl->value;
                 break;
         case V4L2_CID_EXPOSURE:
                 /* mt9t031 has maximum == default */
@@ -627,11 +644,11 @@ static int mt9t031_set_control(struct soc_camera_device *icd, struct v4l2_contro
                         u32 old;
 
                         get_shutter(client, &old);
-                        dev_dbg(&icd->dev, "Setting shutter width from %u to %u\n",
+                        dev_dbg(&client->dev, "Set shutter from %u to %u\n",
                                 old, shutter);
                         if (set_shutter(client, shutter) < 0)
                                 return -EIO;
-                        icd->exposure = ctrl->value;
+                        mt9t031->exposure = ctrl->value;
                         mt9t031->autoexposure = 0;
                 }
                 break;
@@ -639,13 +656,14 @@ static int mt9t031_set_control(struct soc_camera_device *icd, struct v4l2_contro
                 if (ctrl->value) {
                         const u16 vblank = MT9T031_VERTICAL_BLANK;
                         const u32 shutter_max = MT9T031_MAX_HEIGHT + vblank;
-                        if (set_shutter(client, icd->height +
-                                        icd->y_skip_top + vblank) < 0)
+                        unsigned int total_h = mt9t031->rect.height +
+                                icd->y_skip_top + vblank;
+
+                        if (set_shutter(client, total_h) < 0)
                                 return -EIO;
                         qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
-                        icd->exposure = (shutter_max / 2 + (icd->height +
-                                         icd->y_skip_top + vblank - 1) *
-                                         (qctrl->maximum - qctrl->minimum)) /
+                        mt9t031->exposure = (shutter_max / 2 + (total_h - 1) *
+                                 (qctrl->maximum - qctrl->minimum)) /
                                 shutter_max + qctrl->minimum;
                         mt9t031->autoexposure = 1;
                 } else
@@ -657,22 +675,16 @@ static int mt9t031_set_control(struct soc_camera_device *icd, struct v4l2_contro
 
 /* Interface active, can use i2c. If it fails, it can indeed mean, that
  * this wasn't our capture interface, so, we wait for the right one */
-static int mt9t031_video_probe(struct soc_camera_device *icd)
+static int mt9t031_video_probe(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
+        struct soc_camera_device *icd = client->dev.platform_data;
+        struct mt9t031 *mt9t031 = to_mt9t031(client);
         s32 data;
         int ret;
 
-        /* We must have a parent by now. And it cannot be a wrong one.
-         * So this entire test is completely redundant. */
-        if (!icd->dev.parent ||
-            to_soc_camera_host(icd->dev.parent)->nr != icd->iface)
-                return -ENODEV;
-
         /* Enable the chip */
         data = reg_write(client, MT9T031_CHIP_ENABLE, 1);
-        dev_dbg(&icd->dev, "write: %d\n", data);
+        dev_dbg(&client->dev, "write: %d\n", data);
 
         /* Read out the chip version register */
         data = reg_read(client, MT9T031_CHIP_VERSION);
@@ -684,44 +696,64 @@ static int mt9t031_video_probe(struct soc_camera_device *icd)
                 icd->num_formats = ARRAY_SIZE(mt9t031_colour_formats);
                 break;
         default:
-                ret = -ENODEV;
-                dev_err(&icd->dev,
+                dev_err(&client->dev,
                         "No MT9T031 chip detected, register read %x\n", data);
-                goto ei2c;
+                return -ENODEV;
         }
 
-        dev_info(&icd->dev, "Detected a MT9T031 chip ID %x\n", data);
+        dev_info(&client->dev, "Detected a MT9T031 chip ID %x\n", data);
 
-        /* Now that we know the model, we can start video */
-        ret = soc_camera_video_start(icd);
-        if (ret)
-                goto evstart;
+        ret = mt9t031_idle(client);
+        if (ret < 0)
+                dev_err(&client->dev, "Failed to initialise the camera\n");
 
-        return 0;
+        /* mt9t031_idle() has reset the chip to default. */
+        mt9t031->exposure = 255;
+        mt9t031->gain = 64;
 
-evstart:
-ei2c:
         return ret;
 }
 
-static void mt9t031_video_remove(struct soc_camera_device *icd)
-{
-        struct mt9t031 *mt9t031 = container_of(icd, struct mt9t031, icd);
+static struct v4l2_subdev_core_ops mt9t031_subdev_core_ops = {
+        .g_ctrl         = mt9t031_g_ctrl,
+        .s_ctrl         = mt9t031_s_ctrl,
+        .g_chip_ident   = mt9t031_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+        .g_register     = mt9t031_g_register,
+        .s_register     = mt9t031_s_register,
+#endif
+};
 
-        dev_dbg(&icd->dev, "Video %x removed: %p, %p\n", mt9t031->client->addr,
-                icd->dev.parent, icd->vdev);
-        soc_camera_video_stop(icd);
-}
+static struct v4l2_subdev_video_ops mt9t031_subdev_video_ops = {
+        .s_stream       = mt9t031_s_stream,
+        .s_fmt          = mt9t031_s_fmt,
+        .g_fmt          = mt9t031_g_fmt,
+        .try_fmt        = mt9t031_try_fmt,
+        .s_crop         = mt9t031_s_crop,
+        .g_crop         = mt9t031_g_crop,
+        .cropcap        = mt9t031_cropcap,
+};
+
+static struct v4l2_subdev_ops mt9t031_subdev_ops = {
+        .core   = &mt9t031_subdev_core_ops,
+        .video  = &mt9t031_subdev_video_ops,
+};
 
 static int mt9t031_probe(struct i2c_client *client,
                          const struct i2c_device_id *did)
 {
         struct mt9t031 *mt9t031;
-        struct soc_camera_device *icd;
+        struct soc_camera_device *icd = client->dev.platform_data;
         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
-        struct soc_camera_link *icl = client->dev.platform_data;
+        struct soc_camera_link *icl;
         int ret;
 
+        if (!icd) {
+                dev_err(&client->dev, "MT9T031: missing soc-camera data!\n");
+                return -EINVAL;
+        }
+
+        icl = to_soc_camera_link(icd);
         if (!icl) {
                 dev_err(&client->dev, "MT9T031 driver needs platform data\n");
                 return -EINVAL;
@@ -737,23 +769,17 @@ static int mt9t031_probe(struct i2c_client *client,
         if (!mt9t031)
                 return -ENOMEM;
 
-        mt9t031->client = client;
-        i2c_set_clientdata(client, mt9t031);
+        v4l2_i2c_subdev_init(&mt9t031->subdev, client, &mt9t031_subdev_ops);
 
         /* Second stage probe - when a capture adapter is there */
-        icd = &mt9t031->icd;
-        icd->ops        = &mt9t031_ops;
-        icd->control    = &client->dev;
-        icd->x_min      = MT9T031_COLUMN_SKIP;
-        icd->y_min      = MT9T031_ROW_SKIP;
-        icd->x_current  = icd->x_min;
-        icd->y_current  = icd->y_min;
-        icd->width_min  = MT9T031_MIN_WIDTH;
-        icd->width_max  = MT9T031_MAX_WIDTH;
-        icd->height_min = MT9T031_MIN_HEIGHT;
-        icd->height_max = MT9T031_MAX_HEIGHT;
-        icd->y_skip_top = 0;
-        icd->iface      = icl->bus_id;
+        icd->ops                = &mt9t031_ops;
+        icd->y_skip_top         = 0;
+
+        mt9t031->rect.left      = MT9T031_COLUMN_SKIP;
+        mt9t031->rect.top       = MT9T031_ROW_SKIP;
+        mt9t031->rect.width     = MT9T031_MAX_WIDTH;
+        mt9t031->rect.height    = MT9T031_MAX_HEIGHT;
+
         /* Simulated autoexposure. If enabled, we calculate shutter width
          * ourselves in the driver based on vertical blanking and frame width */
         mt9t031->autoexposure = 1;
@@ -761,24 +787,29 @@ static int mt9t031_probe(struct i2c_client *client,
         mt9t031->xskip = 1;
         mt9t031->yskip = 1;
 
-        ret = soc_camera_device_register(icd);
-        if (ret)
-                goto eisdr;
+        mt9t031_idle(client);
 
-        return 0;
+        ret = mt9t031_video_probe(client);
+
+        mt9t031_disable(client);
+
+        if (ret) {
+                icd->ops = NULL;
+                i2c_set_clientdata(client, NULL);
+                kfree(mt9t031);
+        }
 
-eisdr:
-        i2c_set_clientdata(client, NULL);
-        kfree(mt9t031);
         return ret;
 }
 
 static int mt9t031_remove(struct i2c_client *client)
 {
-        struct mt9t031 *mt9t031 = i2c_get_clientdata(client);
+        struct mt9t031 *mt9t031 = to_mt9t031(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
 
-        soc_camera_device_unregister(&mt9t031->icd);
+        icd->ops = NULL;
         i2c_set_clientdata(client, NULL);
+        client->driver = NULL;
         kfree(mt9t031);
 
         return 0;
diff --git a/drivers/media/video/mt9v022.c b/drivers/media/video/mt9v022.c
index dbdcc86ae50d..995607f9d3ba 100644
--- a/drivers/media/video/mt9v022.c
+++ b/drivers/media/video/mt9v022.c
@@ -14,13 +14,13 @@
 #include <linux/delay.h>
 #include <linux/log2.h>
 
-#include <media/v4l2-common.h>
+#include <media/v4l2-subdev.h>
 #include <media/v4l2-chip-ident.h>
 #include <media/soc_camera.h>
 
 /* mt9v022 i2c address 0x48, 0x4c, 0x58, 0x5c
- * The platform has to define i2c_board_info
- * and call i2c_register_board_info() */
+ * The platform has to define ctruct i2c_board_info objects and link to them
+ * from struct soc_camera_link */
 
 static char *sensor_type;
 module_param(sensor_type, charp, S_IRUGO);
@@ -45,7 +45,7 @@ MODULE_PARM_DESC(sensor_type, "Sensor type: \"colour\" or \"monochrome\"");
 #define MT9V022_PIXEL_OPERATION_MODE    0x0f
 #define MT9V022_LED_OUT_CONTROL         0x1b
 #define MT9V022_ADC_MODE_CONTROL        0x1c
-#define MT9V022_ANALOG_GAIN             0x34
+#define MT9V022_ANALOG_GAIN             0x35
 #define MT9V022_BLACK_LEVEL_CALIB_CTRL  0x47
 #define MT9V022_PIXCLK_FV_LV            0x74
 #define MT9V022_DIGITAL_TEST_PATTERN    0x7f
@@ -55,6 +55,13 @@ MODULE_PARM_DESC(sensor_type, "Sensor type: \"colour\" or \"monochrome\"");
 /* Progressive scan, master, defaults */
 #define MT9V022_CHIP_CONTROL_DEFAULT    0x188
 
+#define MT9V022_MAX_WIDTH               752
+#define MT9V022_MAX_HEIGHT              480
+#define MT9V022_MIN_WIDTH               48
+#define MT9V022_MIN_HEIGHT              32
+#define MT9V022_COLUMN_SKIP             1
+#define MT9V022_ROW_SKIP                4
+
 static const struct soc_camera_data_format mt9v022_colour_formats[] = {
         /* Order important: first natively supported,
          * second supported with a GPIO extender */
@@ -85,12 +92,18 @@ static const struct soc_camera_data_format mt9v022_monochrome_formats[] = {
 };
 
 struct mt9v022 {
-        struct i2c_client *client;
-        struct soc_camera_device icd;
+        struct v4l2_subdev subdev;
+        struct v4l2_rect rect;  /* Sensor window */
+        __u32 fourcc;
         int model;      /* V4L2_IDENT_MT9V022* codes from v4l2-chip-ident.h */
         u16 chip_control;
 };
 
+static struct mt9v022 *to_mt9v022(const struct i2c_client *client)
+{
+        return container_of(i2c_get_clientdata(client), struct mt9v022, subdev);
+}
+
 static int reg_read(struct i2c_client *client, const u8 reg)
 {
         s32 data = i2c_smbus_read_word_data(client, reg);
@@ -125,29 +138,11 @@ static int reg_clear(struct i2c_client *client, const u8 reg,
         return reg_write(client, reg, ret & ~data);
 }
 
-static int mt9v022_init(struct soc_camera_device *icd)
+static int mt9v022_init(struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
-        struct soc_camera_link *icl = client->dev.platform_data;
+        struct mt9v022 *mt9v022 = to_mt9v022(client);
         int ret;
 
-        if (icl->power) {
-                ret = icl->power(&client->dev, 1);
-                if (ret < 0) {
-                        dev_err(icd->vdev->parent,
-                                "Platform failed to power-on the camera.\n");
-                        return ret;
-                }
-        }
-
-        /*
-         * The camera could have been already on, we hard-reset it additionally,
-         * if available. Soft reset is done in video_probe().
-         */
-        if (icl->reset)
-                icl->reset(&client->dev);
-
         /* Almost the default mode: master, parallel, simultaneous, and an
          * undocumented bit 0x200, which is present in table 7, but not in 8,
          * plus snapshot mode to disable scan for now */
@@ -161,6 +156,10 @@ static int mt9v022_init(struct soc_camera_device *icd)
                 /* AEC, AGC on */
                 ret = reg_set(client, MT9V022_AEC_AGC_ENABLE, 0x3);
         if (!ret)
+                ret = reg_write(client, MT9V022_ANALOG_GAIN, 16);
+        if (!ret)
+                ret = reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH, 480);
+        if (!ret)
                 ret = reg_write(client, MT9V022_MAX_TOTAL_SHUTTER_WIDTH, 480);
         if (!ret)
                 /* default - auto */
@@ -171,37 +170,19 @@ static int mt9v022_init(struct soc_camera_device *icd)
         return ret;
 }
 
-static int mt9v022_release(struct soc_camera_device *icd)
+static int mt9v022_s_stream(struct v4l2_subdev *sd, int enable)
 {
-        struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
-        struct soc_camera_link *icl = mt9v022->client->dev.platform_data;
-
-        if (icl->power)
-                icl->power(&mt9v022->client->dev, 0);
-
-        return 0;
-}
+        struct i2c_client *client = sd->priv;
+        struct mt9v022 *mt9v022 = to_mt9v022(client);
 
-static int mt9v022_start_capture(struct soc_camera_device *icd)
-{
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
-        /* Switch to master "normal" mode */
-        mt9v022->chip_control &= ~0x10;
-        if (reg_write(client, MT9V022_CHIP_CONTROL,
-                      mt9v022->chip_control) < 0)
-                return -EIO;
-        return 0;
-}
+        if (enable)
+                /* Switch to master "normal" mode */
+                mt9v022->chip_control &= ~0x10;
+        else
+                /* Switch to snapshot mode */
+                mt9v022->chip_control |= 0x10;
 
-static int mt9v022_stop_capture(struct soc_camera_device *icd)
-{
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
-        /* Switch to snapshot mode */
-        mt9v022->chip_control |= 0x10;
-        if (reg_write(client, MT9V022_CHIP_CONTROL,
-                      mt9v022->chip_control) < 0)
+        if (reg_write(client, MT9V022_CHIP_CONTROL, mt9v022->chip_control) < 0)
                 return -EIO;
         return 0;
 }
@@ -209,9 +190,9 @@ static int mt9v022_stop_capture(struct soc_camera_device *icd)
 static int mt9v022_set_bus_param(struct soc_camera_device *icd,
                                  unsigned long flags)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
-        struct soc_camera_link *icl = client->dev.platform_data;
+        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+        struct mt9v022 *mt9v022 = to_mt9v022(client);
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         unsigned int width_flag = flags & SOCAM_DATAWIDTH_MASK;
         int ret;
         u16 pixclk = 0;
@@ -255,7 +236,7 @@ static int mt9v022_set_bus_param(struct soc_camera_device *icd,
         if (ret < 0)
                 return ret;
 
-        dev_dbg(&icd->dev, "Calculated pixclk 0x%x, chip control 0x%x\n",
+        dev_dbg(&client->dev, "Calculated pixclk 0x%x, chip control 0x%x\n",
                 pixclk, mt9v022->chip_control);
 
         return 0;
@@ -263,8 +244,7 @@ static int mt9v022_set_bus_param(struct soc_camera_device *icd,
 
 static unsigned long mt9v022_query_bus_param(struct soc_camera_device *icd)
 {
-        struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
-        struct soc_camera_link *icl = mt9v022->client->dev.platform_data;
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         unsigned int width_flag;
 
         if (icl->query_bus_param)
@@ -280,60 +260,121 @@ static unsigned long mt9v022_query_bus_param(struct soc_camera_device *icd)
                 width_flag;
 }
 
-static int mt9v022_set_crop(struct soc_camera_device *icd,
-                            struct v4l2_rect *rect)
+static int mt9v022_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = sd->priv;
+        struct mt9v022 *mt9v022 = to_mt9v022(client);
+        struct v4l2_rect rect = a->c;
+        struct soc_camera_device *icd = client->dev.platform_data;
         int ret;
 
+        /* Bayer format - even size lengths */
+        if (mt9v022->fourcc == V4L2_PIX_FMT_SBGGR8 ||
+            mt9v022->fourcc == V4L2_PIX_FMT_SBGGR16) {
+                rect.width      = ALIGN(rect.width, 2);
+                rect.height     = ALIGN(rect.height, 2);
+                /* Let the user play with the starting pixel */
+        }
+
+        soc_camera_limit_side(&rect.left, &rect.width,
+                     MT9V022_COLUMN_SKIP, MT9V022_MIN_WIDTH, MT9V022_MAX_WIDTH);
+
+        soc_camera_limit_side(&rect.top, &rect.height,
+                     MT9V022_ROW_SKIP, MT9V022_MIN_HEIGHT, MT9V022_MAX_HEIGHT);
+
         /* Like in example app. Contradicts the datasheet though */
         ret = reg_read(client, MT9V022_AEC_AGC_ENABLE);
         if (ret >= 0) {
                 if (ret & 1) /* Autoexposure */
                         ret = reg_write(client, MT9V022_MAX_TOTAL_SHUTTER_WIDTH,
-                                        rect->height + icd->y_skip_top + 43);
+                                        rect.height + icd->y_skip_top + 43);
                 else
                         ret = reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH,
-                                        rect->height + icd->y_skip_top + 43);
+                                        rect.height + icd->y_skip_top + 43);
         }
         /* Setup frame format: defaults apart from width and height */
         if (!ret)
-                ret = reg_write(client, MT9V022_COLUMN_START, rect->left);
+                ret = reg_write(client, MT9V022_COLUMN_START, rect.left);
         if (!ret)
-                ret = reg_write(client, MT9V022_ROW_START, rect->top);
+                ret = reg_write(client, MT9V022_ROW_START, rect.top);
         if (!ret)
                 /* Default 94, Phytec driver says:
                  * "width + horizontal blank >= 660" */
                 ret = reg_write(client, MT9V022_HORIZONTAL_BLANKING,
-                                rect->width > 660 - 43 ? 43 :
-                                660 - rect->width);
+                                rect.width > 660 - 43 ? 43 :
+                                660 - rect.width);
         if (!ret)
                 ret = reg_write(client, MT9V022_VERTICAL_BLANKING, 45);
         if (!ret)
-                ret = reg_write(client, MT9V022_WINDOW_WIDTH, rect->width);
+                ret = reg_write(client, MT9V022_WINDOW_WIDTH, rect.width);
         if (!ret)
                 ret = reg_write(client, MT9V022_WINDOW_HEIGHT,
-                                rect->height + icd->y_skip_top);
+                                rect.height + icd->y_skip_top);
 
         if (ret < 0)
                 return ret;
 
-        dev_dbg(&icd->dev, "Frame %ux%u pixel\n", rect->width, rect->height);
+        dev_dbg(&client->dev, "Frame %ux%u pixel\n", rect.width, rect.height);
+
+        mt9v022->rect = rect;
+
+        return 0;
+}
+
+static int mt9v022_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+        struct i2c_client *client = sd->priv;
+        struct mt9v022 *mt9v022 = to_mt9v022(client);
+
+        a->c    = mt9v022->rect;
+        a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
         return 0;
 }
 
-static int mt9v022_set_fmt(struct soc_camera_device *icd,
-                           struct v4l2_format *f)
+static int mt9v022_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
 {
-        struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
+        a->bounds.left                  = MT9V022_COLUMN_SKIP;
+        a->bounds.top                   = MT9V022_ROW_SKIP;
+        a->bounds.width                 = MT9V022_MAX_WIDTH;
+        a->bounds.height                = MT9V022_MAX_HEIGHT;
+        a->defrect                      = a->bounds;
+        a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        a->pixelaspect.numerator        = 1;
+        a->pixelaspect.denominator      = 1;
+
+        return 0;
+}
+
+static int mt9v022_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct i2c_client *client = sd->priv;
+        struct mt9v022 *mt9v022 = to_mt9v022(client);
         struct v4l2_pix_format *pix = &f->fmt.pix;
-        struct v4l2_rect rect = {
-                .left   = icd->x_current,
-                .top    = icd->y_current,
-                .width  = pix->width,
-                .height = pix->height,
+
+        pix->width              = mt9v022->rect.width;
+        pix->height             = mt9v022->rect.height;
+        pix->pixelformat        = mt9v022->fourcc;
+        pix->field              = V4L2_FIELD_NONE;
+        pix->colorspace         = V4L2_COLORSPACE_SRGB;
+
+        return 0;
+}
+
+static int mt9v022_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct i2c_client *client = sd->priv;
+        struct mt9v022 *mt9v022 = to_mt9v022(client);
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+        struct v4l2_crop a = {
+                .c = {
+                        .left   = mt9v022->rect.left,
+                        .top    = mt9v022->rect.top,
+                        .width  = pix->width,
+                        .height = pix->height,
+                },
         };
+        int ret;
 
         /* The caller provides a supported format, as verified per call to
          * icd->try_fmt(), datawidth is from our supported format list */
@@ -356,30 +397,42 @@ static int mt9v022_set_fmt(struct soc_camera_device *icd,
         }
 
         /* No support for scaling on this camera, just crop. */
-        return mt9v022_set_crop(icd, &rect);
+        ret = mt9v022_s_crop(sd, &a);
+        if (!ret) {
+                pix->width = mt9v022->rect.width;
+                pix->height = mt9v022->rect.height;
+                mt9v022->fourcc = pix->pixelformat;
+        }
+
+        return ret;
 }
 
-static int mt9v022_try_fmt(struct soc_camera_device *icd,
-                           struct v4l2_format *f)
+static int mt9v022_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
+        struct i2c_client *client = sd->priv;
+        struct soc_camera_device *icd = client->dev.platform_data;
         struct v4l2_pix_format *pix = &f->fmt.pix;
+        int align = pix->pixelformat == V4L2_PIX_FMT_SBGGR8 ||
+                pix->pixelformat == V4L2_PIX_FMT_SBGGR16;
 
-        v4l_bound_align_image(&pix->width, 48, 752, 2 /* ? */,
-                              &pix->height, 32 + icd->y_skip_top,
-                              480 + icd->y_skip_top, 0, 0);
+        v4l_bound_align_image(&pix->width, MT9V022_MIN_WIDTH,
+                MT9V022_MAX_WIDTH, align,
+                &pix->height, MT9V022_MIN_HEIGHT + icd->y_skip_top,
+                MT9V022_MAX_HEIGHT + icd->y_skip_top, align, 0);
 
         return 0;
 }
 
-static int mt9v022_get_chip_id(struct soc_camera_device *icd,
-                               struct v4l2_dbg_chip_ident *id)
+static int mt9v022_g_chip_ident(struct v4l2_subdev *sd,
+                                struct v4l2_dbg_chip_ident *id)
 {
-        struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
+        struct i2c_client *client = sd->priv;
+        struct mt9v022 *mt9v022 = to_mt9v022(client);
 
         if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
                 return -EINVAL;
 
-        if (id->match.addr != mt9v022->client->addr)
+        if (id->match.addr != client->addr)
                 return -ENODEV;
 
         id->ident       = mt9v022->model;
@@ -389,10 +442,10 @@ static int mt9v022_get_chip_id(struct soc_camera_device *icd,
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mt9v022_get_register(struct soc_camera_device *icd,
-                                struct v4l2_dbg_register *reg)
+static int mt9v022_g_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = sd->priv;
 
         if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
@@ -409,10 +462,10 @@ static int mt9v022_get_register(struct soc_camera_device *icd,
         return 0;
 }
 
-static int mt9v022_set_register(struct soc_camera_device *icd,
-                                struct v4l2_dbg_register *reg)
+static int mt9v022_s_register(struct v4l2_subdev *sd,
+                              struct v4l2_dbg_register *reg)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = sd->priv;
 
         if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
                 return -EINVAL;
@@ -481,41 +534,22 @@ static const struct v4l2_queryctrl mt9v022_controls[] = {
         }
 };
 
-static int mt9v022_video_probe(struct soc_camera_device *);
-static void mt9v022_video_remove(struct soc_camera_device *);
-static int mt9v022_get_control(struct soc_camera_device *, struct v4l2_control *);
-static int mt9v022_set_control(struct soc_camera_device *, struct v4l2_control *);
-
 static struct soc_camera_ops mt9v022_ops = {
-        .owner                  = THIS_MODULE,
-        .probe                  = mt9v022_video_probe,
-        .remove                 = mt9v022_video_remove,
-        .init                   = mt9v022_init,
-        .release                = mt9v022_release,
-        .start_capture          = mt9v022_start_capture,
-        .stop_capture           = mt9v022_stop_capture,
-        .set_crop               = mt9v022_set_crop,
-        .set_fmt                = mt9v022_set_fmt,
-        .try_fmt                = mt9v022_try_fmt,
         .set_bus_param          = mt9v022_set_bus_param,
         .query_bus_param        = mt9v022_query_bus_param,
         .controls               = mt9v022_controls,
         .num_controls           = ARRAY_SIZE(mt9v022_controls),
-        .get_control            = mt9v022_get_control,
-        .set_control            = mt9v022_set_control,
-        .get_chip_id            = mt9v022_get_chip_id,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-        .get_register           = mt9v022_get_register,
-        .set_register           = mt9v022_set_register,
-#endif
 };
 
-static int mt9v022_get_control(struct soc_camera_device *icd,
-                               struct v4l2_control *ctrl)
+static int mt9v022_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = sd->priv;
+        const struct v4l2_queryctrl *qctrl;
+        unsigned long range;
         int data;
 
+        qctrl = soc_camera_find_qctrl(&mt9v022_ops, ctrl->id);
+
         switch (ctrl->id) {
         case V4L2_CID_VFLIP:
                 data = reg_read(client, MT9V022_READ_MODE);
@@ -541,19 +575,35 @@ static int mt9v022_get_control(struct soc_camera_device *icd,
                         return -EIO;
                 ctrl->value = !!(data & 0x2);
                 break;
+        case V4L2_CID_GAIN:
+                data = reg_read(client, MT9V022_ANALOG_GAIN);
+                if (data < 0)
+                        return -EIO;
+
+                range = qctrl->maximum - qctrl->minimum;
+                ctrl->value = ((data - 16) * range + 24) / 48 + qctrl->minimum;
+
+                break;
+        case V4L2_CID_EXPOSURE:
+                data = reg_read(client, MT9V022_TOTAL_SHUTTER_WIDTH);
+                if (data < 0)
+                        return -EIO;
+
+                range = qctrl->maximum - qctrl->minimum;
+                ctrl->value = ((data - 1) * range + 239) / 479 + qctrl->minimum;
+
+                break;
         }
         return 0;
 }
 
-static int mt9v022_set_control(struct soc_camera_device *icd,
-                               struct v4l2_control *ctrl)
+static int mt9v022_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
         int data;
-        struct i2c_client *client = to_i2c_client(icd->control);
+        struct i2c_client *client = sd->priv;
         const struct v4l2_queryctrl *qctrl;
 
         qctrl = soc_camera_find_qctrl(&mt9v022_ops, ctrl->id);
-
         if (!qctrl)
                 return -EINVAL;
 
@@ -580,12 +630,9 @@ static int mt9v022_set_control(struct soc_camera_device *icd,
                         return -EINVAL;
                 else {
                         unsigned long range = qctrl->maximum - qctrl->minimum;
-                        /* Datasheet says 16 to 64. autogain only works properly
-                         * after setting gain to maximum 14. Larger values
-                         * produce "white fly" noise effect. On the whole,
-                         * manually setting analog gain does no good. */
+                        /* Valid values 16 to 64, 32 to 64 must be even. */
                         unsigned long gain = ((ctrl->value - qctrl->minimum) *
-                                              10 + range / 2) / range + 4;
+                                              48 + range / 2) / range + 16;
                         if (gain >= 32)
                                 gain &= ~1;
                         /* The user wants to set gain manually, hope, she
@@ -594,11 +641,10 @@ static int mt9v022_set_control(struct soc_camera_device *icd,
                         if (reg_clear(client, MT9V022_AEC_AGC_ENABLE, 0x2) < 0)
                                 return -EIO;
 
-                        dev_info(&icd->dev, "Setting gain from %d to %lu\n",
-                                 reg_read(client, MT9V022_ANALOG_GAIN), gain);
+                        dev_dbg(&client->dev, "Setting gain from %d to %lu\n",
+                                reg_read(client, MT9V022_ANALOG_GAIN), gain);
                         if (reg_write(client, MT9V022_ANALOG_GAIN, gain) < 0)
                                 return -EIO;
-                        icd->gain = ctrl->value;
                 }
                 break;
         case V4L2_CID_EXPOSURE:
@@ -615,13 +661,12 @@ static int mt9v022_set_control(struct soc_camera_device *icd,
                         if (reg_clear(client, MT9V022_AEC_AGC_ENABLE, 0x1) < 0)
                                 return -EIO;
 
-                        dev_dbg(&icd->dev, "Shutter width from %d to %lu\n",
+                        dev_dbg(&client->dev, "Shutter width from %d to %lu\n",
                                 reg_read(client, MT9V022_TOTAL_SHUTTER_WIDTH),
                                 shutter);
                         if (reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH,
                                       shutter) < 0)
                                 return -EIO;
-                        icd->exposure = ctrl->value;
                 }
                 break;
         case V4L2_CID_AUTOGAIN:
@@ -646,11 +691,11 @@ static int mt9v022_set_control(struct soc_camera_device *icd,
 
 /* Interface active, can use i2c. If it fails, it can indeed mean, that
  * this wasn't our capture interface, so, we wait for the right one */
-static int mt9v022_video_probe(struct soc_camera_device *icd)
+static int mt9v022_video_probe(struct soc_camera_device *icd,
+                               struct i2c_client *client)
 {
-        struct i2c_client *client = to_i2c_client(icd->control);
-        struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
-        struct soc_camera_link *icl = client->dev.platform_data;
+        struct mt9v022 *mt9v022 = to_mt9v022(client);
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         s32 data;
         int ret;
         unsigned long flags;
@@ -665,7 +710,7 @@ static int mt9v022_video_probe(struct soc_camera_device *icd)
         /* must be 0x1311 or 0x1313 */
         if (data != 0x1311 && data != 0x1313) {
                 ret = -ENODEV;
-                dev_info(&icd->dev, "No MT9V022 detected, ID register 0x%x\n",
+                dev_info(&client->dev, "No MT9V022 found, ID register 0x%x\n",
                          data);
                 goto ei2c;
         }
@@ -677,7 +722,9 @@ static int mt9v022_video_probe(struct soc_camera_device *icd)
         /* 15 clock cycles */
         udelay(200);
         if (reg_read(client, MT9V022_RESET)) {
-                dev_err(&icd->dev, "Resetting MT9V022 failed!\n");
+                dev_err(&client->dev, "Resetting MT9V022 failed!\n");
+                if (ret > 0)
+                        ret = -EIO;
                 goto ei2c;
         }
 
@@ -694,7 +741,7 @@ static int mt9v022_video_probe(struct soc_camera_device *icd)
         }
 
         if (ret < 0)
-                goto eisis;
+                goto ei2c;
 
         icd->num_formats = 0;
 
@@ -716,42 +763,70 @@ static int mt9v022_video_probe(struct soc_camera_device *icd)
         if (flags & SOCAM_DATAWIDTH_8)
                 icd->num_formats++;
 
-        ret = soc_camera_video_start(icd);
-        if (ret < 0)
-                goto eisis;
+        mt9v022->fourcc = icd->formats->fourcc;
 
-        dev_info(&icd->dev, "Detected a MT9V022 chip ID %x, %s sensor\n",
+        dev_info(&client->dev, "Detected a MT9V022 chip ID %x, %s sensor\n",
                  data, mt9v022->model == V4L2_IDENT_MT9V022IX7ATM ?
                  "monochrome" : "colour");
 
-        return 0;
+        ret = mt9v022_init(client);
+        if (ret < 0)
+                dev_err(&client->dev, "Failed to initialise the camera\n");
 
-eisis:
 ei2c:
         return ret;
 }
 
 static void mt9v022_video_remove(struct soc_camera_device *icd)
 {
-        struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);
-        struct soc_camera_link *icl = mt9v022->client->dev.platform_data;
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
 
-        dev_dbg(&icd->dev, "Video %x removed: %p, %p\n", mt9v022->client->addr,
+        dev_dbg(&icd->dev, "Video removed: %p, %p\n",
                 icd->dev.parent, icd->vdev);
-        soc_camera_video_stop(icd);
         if (icl->free_bus)
                 icl->free_bus(icl);
 }
 
+static struct v4l2_subdev_core_ops mt9v022_subdev_core_ops = {
+        .g_ctrl         = mt9v022_g_ctrl,
+        .s_ctrl         = mt9v022_s_ctrl,
+        .g_chip_ident   = mt9v022_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+        .g_register     = mt9v022_g_register,
+        .s_register     = mt9v022_s_register,
+#endif
+};
+
+static struct v4l2_subdev_video_ops mt9v022_subdev_video_ops = {
+        .s_stream       = mt9v022_s_stream,
+        .s_fmt          = mt9v022_s_fmt,
+        .g_fmt          = mt9v022_g_fmt,
+        .try_fmt        = mt9v022_try_fmt,
+        .s_crop         = mt9v022_s_crop,
+        .g_crop         = mt9v022_g_crop,
+        .cropcap        = mt9v022_cropcap,
+};
+
+static struct v4l2_subdev_ops mt9v022_subdev_ops = {
+        .core   = &mt9v022_subdev_core_ops,
+        .video  = &mt9v022_subdev_video_ops,
+};
+
 static int mt9v022_probe(struct i2c_client *client,
                          const struct i2c_device_id *did)
 {
         struct mt9v022 *mt9v022;
-        struct soc_camera_device *icd;
+        struct soc_camera_device *icd = client->dev.platform_data;
         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
-        struct soc_camera_link *icl = client->dev.platform_data;
+        struct soc_camera_link *icl;
         int ret;
 
+        if (!icd) {
+                dev_err(&client->dev, "MT9V022: missing soc-camera data!\n");
+                return -EINVAL;
+        }
+
+        icl = to_soc_camera_link(icd);
         if (!icl) {
                 dev_err(&client->dev, "MT9V022 driver needs platform data\n");
                 return -EINVAL;
@@ -767,40 +842,41 @@ static int mt9v022_probe(struct i2c_client *client,
         if (!mt9v022)
                 return -ENOMEM;
 
+        v4l2_i2c_subdev_init(&mt9v022->subdev, client, &mt9v022_subdev_ops);
+
         mt9v022->chip_control = MT9V022_CHIP_CONTROL_DEFAULT;
-        mt9v022->client = client;
-        i2c_set_clientdata(client, mt9v022);
-
-        icd = &mt9v022->icd;
-        icd->ops        = &mt9v022_ops;
-        icd->control    = &client->dev;
-        icd->x_min      = 1;
-        icd->y_min      = 4;
-        icd->x_current  = 1;
-        icd->y_current  = 4;
-        icd->width_min  = 48;
-        icd->width_max  = 752;
-        icd->height_min = 32;
-        icd->height_max = 480;
-        icd->y_skip_top = 1;
-        icd->iface      = icl->bus_id;
-
-        ret = soc_camera_device_register(icd);
-        if (ret)
-                goto eisdr;
 
-        return 0;
+        icd->ops                = &mt9v022_ops;
+        /*
+         * MT9V022 _really_ corrupts the first read out line.
+         * TODO: verify on i.MX31
+         */
+        icd->y_skip_top         = 1;
+
+        mt9v022->rect.left      = MT9V022_COLUMN_SKIP;
+        mt9v022->rect.top       = MT9V022_ROW_SKIP;
+        mt9v022->rect.width     = MT9V022_MAX_WIDTH;
+        mt9v022->rect.height    = MT9V022_MAX_HEIGHT;
+
+        ret = mt9v022_video_probe(icd, client);
+        if (ret) {
+                icd->ops = NULL;
+                i2c_set_clientdata(client, NULL);
+                kfree(mt9v022);
+        }
 
-eisdr:
-        kfree(mt9v022);
         return ret;
 }
 
 static int mt9v022_remove(struct i2c_client *client)
 {
-        struct mt9v022 *mt9v022 = i2c_get_clientdata(client);
+        struct mt9v022 *mt9v022 = to_mt9v022(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
 
-        soc_camera_device_unregister(&mt9v022->icd);
+        icd->ops = NULL;
+        mt9v022_video_remove(icd);
+        i2c_set_clientdata(client, NULL);
+        client->driver = NULL;
         kfree(mt9v022);
 
         return 0;
diff --git a/drivers/media/video/mx1_camera.c b/drivers/media/video/mx1_camera.c
index 736c31d23194..5f37952c75cf 100644
--- a/drivers/media/video/mx1_camera.c
+++ b/drivers/media/video/mx1_camera.c
@@ -126,7 +126,7 @@ static int mx1_videobuf_setup(struct videobuf_queue *vq, unsigned int *count,
 {
         struct soc_camera_device *icd = vq->priv_data;
 
-        *size = icd->width * icd->height *
+        *size = icd->user_width * icd->user_height *
                 ((icd->current_fmt->depth + 7) >> 3);
 
         if (!*count)
@@ -135,7 +135,7 @@ static int mx1_videobuf_setup(struct videobuf_queue *vq, unsigned int *count,
         while (*size * *count > MAX_VIDEO_MEM * 1024 * 1024)
                 (*count)--;
 
-        dev_dbg(&icd->dev, "count=%d, size=%d\n", *count, *size);
+        dev_dbg(icd->dev.parent, "count=%d, size=%d\n", *count, *size);
 
         return 0;
 }
@@ -147,7 +147,7 @@ static void free_buffer(struct videobuf_queue *vq, struct mx1_buffer *buf)
 
         BUG_ON(in_interrupt());
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
+        dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                 vb, vb->baddr, vb->bsize);
 
         /* This waits until this buffer is out of danger, i.e., until it is no
@@ -165,7 +165,7 @@ static int mx1_videobuf_prepare(struct videobuf_queue *vq,
         struct mx1_buffer *buf = container_of(vb, struct mx1_buffer, vb);
         int ret;
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
+        dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                 vb, vb->baddr, vb->bsize);
 
         /* Added list head initialization on alloc */
@@ -178,12 +178,12 @@ static int mx1_videobuf_prepare(struct videobuf_queue *vq,
         buf->inwork = 1;
 
         if (buf->fmt    != icd->current_fmt ||
-            vb->width   != icd->width ||
-            vb->height  != icd->height ||
+            vb->width   != icd->user_width ||
+            vb->height  != icd->user_height ||
             vb->field   != field) {
                 buf->fmt        = icd->current_fmt;
-                vb->width       = icd->width;
-                vb->height      = icd->height;
+                vb->width       = icd->user_width;
+                vb->height      = icd->user_height;
                 vb->field       = field;
                 vb->state       = VIDEOBUF_NEEDS_INIT;
         }
@@ -216,10 +216,11 @@ out:
 static int mx1_camera_setup_dma(struct mx1_camera_dev *pcdev)
 {
         struct videobuf_buffer *vbuf = &pcdev->active->vb;
+        struct device *dev = pcdev->icd->dev.parent;
         int ret;
 
         if (unlikely(!pcdev->active)) {
-                dev_err(pcdev->soc_host.dev, "DMA End IRQ with no active buffer\n");
+                dev_err(dev, "DMA End IRQ with no active buffer\n");
                 return -EFAULT;
         }
 
@@ -229,7 +230,7 @@ static int mx1_camera_setup_dma(struct mx1_camera_dev *pcdev)
                 vbuf->size, pcdev->res->start +
                 CSIRXR, DMA_MODE_READ);
         if (unlikely(ret))
-                dev_err(pcdev->soc_host.dev, "Failed to setup DMA sg list\n");
+                dev_err(dev, "Failed to setup DMA sg list\n");
 
         return ret;
 }
@@ -243,7 +244,7 @@ static void mx1_videobuf_queue(struct videobuf_queue *vq,
         struct mx1_camera_dev *pcdev = ici->priv;
         struct mx1_buffer *buf = container_of(vb, struct mx1_buffer, vb);
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
+        dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                 vb, vb->baddr, vb->bsize);
 
         list_add_tail(&vb->queue, &pcdev->capture);
@@ -270,22 +271,23 @@ static void mx1_videobuf_release(struct videobuf_queue *vq,
         struct mx1_buffer *buf = container_of(vb, struct mx1_buffer, vb);
 #ifdef DEBUG
         struct soc_camera_device *icd = vq->priv_data;
+        struct device *dev = icd->dev.parent;
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
+        dev_dbg(dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                 vb, vb->baddr, vb->bsize);
 
         switch (vb->state) {
         case VIDEOBUF_ACTIVE:
-                dev_dbg(&icd->dev, "%s (active)\n", __func__);
+                dev_dbg(dev, "%s (active)\n", __func__);
                 break;
         case VIDEOBUF_QUEUED:
-                dev_dbg(&icd->dev, "%s (queued)\n", __func__);
+                dev_dbg(dev, "%s (queued)\n", __func__);
                 break;
         case VIDEOBUF_PREPARED:
-                dev_dbg(&icd->dev, "%s (prepared)\n", __func__);
+                dev_dbg(dev, "%s (prepared)\n", __func__);
                 break;
         default:
-                dev_dbg(&icd->dev, "%s (unknown)\n", __func__);
+                dev_dbg(dev, "%s (unknown)\n", __func__);
                 break;
         }
 #endif
@@ -325,6 +327,7 @@ static void mx1_camera_wakeup(struct mx1_camera_dev *pcdev,
 static void mx1_camera_dma_irq(int channel, void *data)
 {
         struct mx1_camera_dev *pcdev = data;
+        struct device *dev = pcdev->icd->dev.parent;
         struct mx1_buffer *buf;
         struct videobuf_buffer *vb;
         unsigned long flags;
@@ -334,14 +337,14 @@ static void mx1_camera_dma_irq(int channel, void *data)
         imx_dma_disable(channel);
 
         if (unlikely(!pcdev->active)) {
-                dev_err(pcdev->soc_host.dev, "DMA End IRQ with no active buffer\n");
+                dev_err(dev, "DMA End IRQ with no active buffer\n");
                 goto out;
         }
 
         vb = &pcdev->active->vb;
         buf = container_of(vb, struct mx1_buffer, vb);
         WARN_ON(buf->inwork || list_empty(&vb->queue));
-        dev_dbg(pcdev->soc_host.dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
+        dev_dbg(dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                 vb, vb->baddr, vb->bsize);
 
         mx1_camera_wakeup(pcdev, vb, buf);
@@ -362,7 +365,7 @@ static void mx1_camera_init_videobuf(struct videobuf_queue *q,
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct mx1_camera_dev *pcdev = ici->priv;
 
-        videobuf_queue_dma_contig_init(q, &mx1_videobuf_ops, ici->dev,
+        videobuf_queue_dma_contig_init(q, &mx1_videobuf_ops, icd->dev.parent,
                                         &pcdev->lock,
                                         V4L2_BUF_TYPE_VIDEO_CAPTURE,
                                         V4L2_FIELD_NONE,
@@ -381,8 +384,9 @@ static int mclk_get_divisor(struct mx1_camera_dev *pcdev)
          * they get a nice Oops */
         div = (lcdclk + 2 * mclk - 1) / (2 * mclk) - 1;
 
-        dev_dbg(pcdev->soc_host.dev, "System clock %lukHz, target freq %dkHz, "
-                "divisor %lu\n", lcdclk / 1000, mclk / 1000, div);
+        dev_dbg(pcdev->icd->dev.parent,
+                "System clock %lukHz, target freq %dkHz, divisor %lu\n",
+                lcdclk / 1000, mclk / 1000, div);
 
         return div;
 }
@@ -391,7 +395,7 @@ static void mx1_camera_activate(struct mx1_camera_dev *pcdev)
 {
         unsigned int csicr1 = CSICR1_EN;
 
-        dev_dbg(pcdev->soc_host.dev, "Activate device\n");
+        dev_dbg(pcdev->icd->dev.parent, "Activate device\n");
 
         clk_enable(pcdev->clk);
 
@@ -407,7 +411,7 @@ static void mx1_camera_activate(struct mx1_camera_dev *pcdev)
 
 static void mx1_camera_deactivate(struct mx1_camera_dev *pcdev)
 {
-        dev_dbg(pcdev->soc_host.dev, "Deactivate device\n");
+        dev_dbg(pcdev->icd->dev.parent, "Deactivate device\n");
 
         /* Disable all CSI interface */
         __raw_writel(0x00, pcdev->base + CSICR1);
@@ -428,14 +432,12 @@ static int mx1_camera_add_device(struct soc_camera_device *icd)
                 goto ebusy;
         }
 
-        dev_info(&icd->dev, "MX1 Camera driver attached to camera %d\n",
+        dev_info(icd->dev.parent, "MX1 Camera driver attached to camera %d\n",
                  icd->devnum);
 
         mx1_camera_activate(pcdev);
-        ret = icd->ops->init(icd);
 
-        if (!ret)
-                pcdev->icd = icd;
+        pcdev->icd = icd;
 
 ebusy:
         return ret;
@@ -456,20 +458,20 @@ static void mx1_camera_remove_device(struct soc_camera_device *icd)
         /* Stop DMA engine */
         imx_dma_disable(pcdev->dma_chan);
 
-        dev_info(&icd->dev, "MX1 Camera driver detached from camera %d\n",
+        dev_info(icd->dev.parent, "MX1 Camera driver detached from camera %d\n",
                  icd->devnum);
 
-        icd->ops->release(icd);
-
         mx1_camera_deactivate(pcdev);
 
         pcdev->icd = NULL;
 }
 
 static int mx1_camera_set_crop(struct soc_camera_device *icd,
-                               struct v4l2_rect *rect)
+                               struct v4l2_crop *a)
 {
-        return icd->ops->set_crop(icd, rect);
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+
+        return v4l2_subdev_call(sd, video, s_crop, a);
 }
 
 static int mx1_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
@@ -539,18 +541,19 @@ static int mx1_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
 static int mx1_camera_set_fmt(struct soc_camera_device *icd,
                               struct v4l2_format *f)
 {
-        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         const struct soc_camera_format_xlate *xlate;
         struct v4l2_pix_format *pix = &f->fmt.pix;
         int ret;
 
         xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
         if (!xlate) {
-                dev_warn(ici->dev, "Format %x not found\n", pix->pixelformat);
+                dev_warn(icd->dev.parent, "Format %x not found\n",
+                         pix->pixelformat);
                 return -EINVAL;
         }
 
-        ret = icd->ops->set_fmt(icd, f);
+        ret = v4l2_subdev_call(sd, video, s_fmt, f);
         if (!ret) {
                 icd->buswidth = xlate->buswidth;
                 icd->current_fmt = xlate->host_fmt;
@@ -562,10 +565,11 @@ static int mx1_camera_set_fmt(struct soc_camera_device *icd,
 static int mx1_camera_try_fmt(struct soc_camera_device *icd,
                               struct v4l2_format *f)
 {
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         /* TODO: limit to mx1 hardware capabilities */
 
         /* limit to sensor capabilities */
-        return icd->ops->try_fmt(icd, f);
+        return v4l2_subdev_call(sd, video, try_fmt, f);
 }
 
 static int mx1_camera_reqbufs(struct soc_camera_file *icf,
@@ -737,7 +741,7 @@ static int __init mx1_camera_probe(struct platform_device *pdev)
         pcdev->soc_host.drv_name        = DRIVER_NAME;
         pcdev->soc_host.ops             = &mx1_soc_camera_host_ops;
         pcdev->soc_host.priv            = pcdev;
-        pcdev->soc_host.dev             = &pdev->dev;
+        pcdev->soc_host.v4l2_dev.dev    = &pdev->dev;
         pcdev->soc_host.nr              = pdev->id;
         err = soc_camera_host_register(&pcdev->soc_host);
         if (err)
diff --git a/drivers/media/video/mx3_camera.c b/drivers/media/video/mx3_camera.c
index 9770cb7932ca..dff2e5e2d8c6 100644
--- a/drivers/media/video/mx3_camera.c
+++ b/drivers/media/video/mx3_camera.c
@@ -178,7 +178,7 @@ static void free_buffer(struct videobuf_queue *vq, struct mx3_camera_buffer *buf
 
         BUG_ON(in_interrupt());
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
+        dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                 vb, vb->baddr, vb->bsize);
 
         /*
@@ -220,7 +220,7 @@ static int mx3_videobuf_setup(struct videobuf_queue *vq, unsigned int *count,
         if (!mx3_cam->idmac_channel[0])
                 return -EINVAL;
 
-        *size = icd->width * icd->height * bpp;
+        *size = icd->user_width * icd->user_height * bpp;
 
         if (!*count)
                 *count = 32;
@@ -241,7 +241,7 @@ static int mx3_videobuf_prepare(struct videobuf_queue *vq,
         struct mx3_camera_buffer *buf =
                 container_of(vb, struct mx3_camera_buffer, vb);
         /* current_fmt _must_ always be set */
-        size_t new_size = icd->width * icd->height *
+        size_t new_size = icd->user_width * icd->user_height *
                 ((icd->current_fmt->depth + 7) >> 3);
         int ret;
 
@@ -251,12 +251,12 @@ static int mx3_videobuf_prepare(struct videobuf_queue *vq,
          */
 
         if (buf->fmt    != icd->current_fmt ||
-            vb->width   != icd->width ||
-            vb->height  != icd->height ||
+            vb->width   != icd->user_width ||
+            vb->height  != icd->user_height ||
             vb->field   != field) {
                 buf->fmt        = icd->current_fmt;
-                vb->width       = icd->width;
-                vb->height      = icd->height;
+                vb->width       = icd->user_width;
+                vb->height      = icd->user_height;
                 vb->field       = field;
                 if (vb->state != VIDEOBUF_NEEDS_INIT)
                         free_buffer(vq, buf);
@@ -354,9 +354,9 @@ static void mx3_videobuf_queue(struct videobuf_queue *vq,
 
         /* This is the configuration of one sg-element */
         video->out_pixel_fmt    = fourcc_to_ipu_pix(data_fmt->fourcc);
-        video->out_width        = icd->width;
-        video->out_height       = icd->height;
-        video->out_stride       = icd->width;
+        video->out_width        = icd->user_width;
+        video->out_height       = icd->user_height;
+        video->out_stride       = icd->user_width;
 
 #ifdef DEBUG
         /* helps to see what DMA actually has written */
@@ -375,7 +375,8 @@ static void mx3_videobuf_queue(struct videobuf_queue *vq,
         spin_unlock_irq(&mx3_cam->lock);
 
         cookie = txd->tx_submit(txd);
-        dev_dbg(&icd->dev, "Submitted cookie %d DMA 0x%08x\n", cookie, sg_dma_address(&buf->sg));
+        dev_dbg(icd->dev.parent, "Submitted cookie %d DMA 0x%08x\n",
+                cookie, sg_dma_address(&buf->sg));
 
         spin_lock_irq(&mx3_cam->lock);
 
@@ -402,9 +403,10 @@ static void mx3_videobuf_release(struct videobuf_queue *vq,
                 container_of(vb, struct mx3_camera_buffer, vb);
         unsigned long flags;
 
-        dev_dbg(&icd->dev, "Release%s DMA 0x%08x (state %d), queue %sempty\n",
+        dev_dbg(icd->dev.parent,
+                "Release%s DMA 0x%08x (state %d), queue %sempty\n",
                 mx3_cam->active == buf ? " active" : "", sg_dma_address(&buf->sg),
-                 vb->state, list_empty(&vb->queue) ? "" : "not ");
+                vb->state, list_empty(&vb->queue) ? "" : "not ");
         spin_lock_irqsave(&mx3_cam->lock, flags);
         if ((vb->state == VIDEOBUF_ACTIVE || vb->state == VIDEOBUF_QUEUED) &&
             !list_empty(&vb->queue)) {
@@ -431,7 +433,7 @@ static void mx3_camera_init_videobuf(struct videobuf_queue *q,
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct mx3_camera_dev *mx3_cam = ici->priv;
 
-        videobuf_queue_dma_contig_init(q, &mx3_videobuf_ops, ici->dev,
+        videobuf_queue_dma_contig_init(q, &mx3_videobuf_ops, icd->dev.parent,
                                        &mx3_cam->lock,
                                        V4L2_BUF_TYPE_VIDEO_CAPTURE,
                                        V4L2_FIELD_NONE,
@@ -484,7 +486,7 @@ static void mx3_camera_activate(struct mx3_camera_dev *mx3_cam,
 
         clk_enable(mx3_cam->clk);
         rate = clk_round_rate(mx3_cam->clk, mx3_cam->mclk);
-        dev_dbg(&icd->dev, "Set SENS_CONF to %x, rate %ld\n", conf, rate);
+        dev_dbg(icd->dev.parent, "Set SENS_CONF to %x, rate %ld\n", conf, rate);
         if (rate)
                 clk_set_rate(mx3_cam->clk, rate);
 }
@@ -494,29 +496,18 @@ static int mx3_camera_add_device(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct mx3_camera_dev *mx3_cam = ici->priv;
-        int ret;
 
-        if (mx3_cam->icd) {
-                ret = -EBUSY;
-                goto ebusy;
-        }
+        if (mx3_cam->icd)
+                return -EBUSY;
 
         mx3_camera_activate(mx3_cam, icd);
-        ret = icd->ops->init(icd);
-        if (ret < 0) {
-                clk_disable(mx3_cam->clk);
-                goto einit;
-        }
 
         mx3_cam->icd = icd;
 
-einit:
-ebusy:
-        if (!ret)
-                dev_info(&icd->dev, "MX3 Camera driver attached to camera %d\n",
-                         icd->devnum);
+        dev_info(icd->dev.parent, "MX3 Camera driver attached to camera %d\n",
+                 icd->devnum);
 
-        return ret;
+        return 0;
 }
 
 /* Called with .video_lock held */
@@ -533,13 +524,11 @@ static void mx3_camera_remove_device(struct soc_camera_device *icd)
                 *ichan = NULL;
         }
 
-        icd->ops->release(icd);
-
         clk_disable(mx3_cam->clk);
 
         mx3_cam->icd = NULL;
 
-        dev_info(&icd->dev, "MX3 Camera driver detached from camera %d\n",
+        dev_info(icd->dev.parent, "MX3 Camera driver detached from camera %d\n",
                  icd->devnum);
 }
 
@@ -551,7 +540,8 @@ static bool channel_change_requested(struct soc_camera_device *icd,
         struct idmac_channel *ichan = mx3_cam->idmac_channel[0];
 
         /* Do buffers have to be re-allocated or channel re-configured? */
-        return ichan && rect->width * rect->height > icd->width * icd->height;
+        return ichan && rect->width * rect->height >
+                icd->user_width * icd->user_height;
 }
 
 static int test_platform_param(struct mx3_camera_dev *mx3_cam,
@@ -599,8 +589,8 @@ static int test_platform_param(struct mx3_camera_dev *mx3_cam,
                 *flags |= SOCAM_DATAWIDTH_4;
                 break;
         default:
-                dev_info(mx3_cam->soc_host.dev, "Unsupported bus width %d\n",
-                         buswidth);
+                dev_warn(mx3_cam->soc_host.v4l2_dev.dev,
+                         "Unsupported bus width %d\n", buswidth);
                 return -EINVAL;
         }
 
@@ -615,7 +605,7 @@ static int mx3_camera_try_bus_param(struct soc_camera_device *icd,
         unsigned long bus_flags, camera_flags;
         int ret = test_platform_param(mx3_cam, depth, &bus_flags);
 
-        dev_dbg(ici->dev, "requested bus width %d bit: %d\n", depth, ret);
+        dev_dbg(icd->dev.parent, "request bus width %d bit: %d\n", depth, ret);
 
         if (ret < 0)
                 return ret;
@@ -624,7 +614,8 @@ static int mx3_camera_try_bus_param(struct soc_camera_device *icd,
 
         ret = soc_camera_bus_param_compatible(camera_flags, bus_flags);
         if (ret < 0)
-                dev_warn(&icd->dev, "Flags incompatible: camera %lx, host %lx\n",
+                dev_warn(icd->dev.parent,
+                         "Flags incompatible: camera %lx, host %lx\n",
                          camera_flags, bus_flags);
 
         return ret;
@@ -638,7 +629,7 @@ static bool chan_filter(struct dma_chan *chan, void *arg)
         if (!rq)
                 return false;
 
-        pdata = rq->mx3_cam->soc_host.dev->platform_data;
+        pdata = rq->mx3_cam->soc_host.v4l2_dev.dev->platform_data;
 
         return rq->id == chan->chan_id &&
                 pdata->dma_dev == chan->device->dev;
@@ -698,7 +689,8 @@ static int mx3_camera_get_formats(struct soc_camera_device *icd, int idx,
                         xlate->cam_fmt = icd->formats + idx;
                         xlate->buswidth = buswidth;
                         xlate++;
-                        dev_dbg(ici->dev, "Providing format %s using %s\n",
+                        dev_dbg(icd->dev.parent,
+                                "Providing format %s using %s\n",
                                 mx3_camera_formats[0].name,
                                 icd->formats[idx].name);
                 }
@@ -710,7 +702,8 @@ static int mx3_camera_get_formats(struct soc_camera_device *icd, int idx,
                         xlate->cam_fmt = icd->formats + idx;
                         xlate->buswidth = buswidth;
                         xlate++;
-                        dev_dbg(ici->dev, "Providing format %s using %s\n",
+                        dev_dbg(icd->dev.parent,
+                                "Providing format %s using %s\n",
                                 mx3_camera_formats[0].name,
                                 icd->formats[idx].name);
                 }
@@ -723,7 +716,7 @@ passthrough:
                         xlate->cam_fmt = icd->formats + idx;
                         xlate->buswidth = buswidth;
                         xlate++;
-                        dev_dbg(ici->dev,
+                        dev_dbg(icd->dev.parent,
                                 "Providing format %s in pass-through mode\n",
                                 icd->formats[idx].name);
                 }
@@ -733,13 +726,13 @@ passthrough:
 }
 
 static void configure_geometry(struct mx3_camera_dev *mx3_cam,
-                               struct v4l2_rect *rect)
+                               unsigned int width, unsigned int height)
 {
         u32 ctrl, width_field, height_field;
 
         /* Setup frame size - this cannot be changed on-the-fly... */
-        width_field = rect->width - 1;
-        height_field = rect->height - 1;
+        width_field = width - 1;
+        height_field = height - 1;
         csi_reg_write(mx3_cam, width_field | (height_field << 16), CSI_SENS_FRM_SIZE);
 
         csi_reg_write(mx3_cam, width_field << 16, CSI_FLASH_STROBE_1);
@@ -751,11 +744,6 @@ static void configure_geometry(struct mx3_camera_dev *mx3_cam,
         ctrl = csi_reg_read(mx3_cam, CSI_OUT_FRM_CTRL) & 0xffff0000;
         /* Sensor does the cropping */
         csi_reg_write(mx3_cam, ctrl | 0 | (0 << 8), CSI_OUT_FRM_CTRL);
-
-        /*
-         * No need to free resources here if we fail, we'll see if we need to
-         * do this next time we are called
-         */
 }
 
 static int acquire_dma_channel(struct mx3_camera_dev *mx3_cam)
@@ -792,25 +780,74 @@ static int acquire_dma_channel(struct mx3_camera_dev *mx3_cam)
         return 0;
 }
 
+/*
+ * FIXME: learn to use stride != width, then we can keep stride properly aligned
+ * and support arbitrary (even) widths.
+ */
+static inline void stride_align(__s32 *width)
+{
+        if (((*width + 7) &  ~7) < 4096)
+                *width = (*width + 7) &  ~7;
+        else
+                *width = *width &  ~7;
+}
+
+/*
+ * As long as we don't implement host-side cropping and scaling, we can use
+ * default g_crop and cropcap from soc_camera.c
+ */
 static int mx3_camera_set_crop(struct soc_camera_device *icd,
-                               struct v4l2_rect *rect)
+                               struct v4l2_crop *a)
 {
+        struct v4l2_rect *rect = &a->c;
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct mx3_camera_dev *mx3_cam = ici->priv;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        struct v4l2_format f = {.type = V4L2_BUF_TYPE_VIDEO_CAPTURE};
+        struct v4l2_pix_format *pix = &f.fmt.pix;
+        int ret;
 
-        /*
-         * We now know pixel formats and can decide upon DMA-channel(s)
-         * So far only direct camera-to-memory is supported
-         */
-        if (channel_change_requested(icd, rect)) {
-                int ret = acquire_dma_channel(mx3_cam);
+        soc_camera_limit_side(&rect->left, &rect->width, 0, 2, 4096);
+        soc_camera_limit_side(&rect->top, &rect->height, 0, 2, 4096);
+
+        ret = v4l2_subdev_call(sd, video, s_crop, a);
+        if (ret < 0)
+                return ret;
+
+        /* The capture device might have changed its output  */
+        ret = v4l2_subdev_call(sd, video, g_fmt, &f);
+        if (ret < 0)
+                return ret;
+
+        if (pix->width & 7) {
+                /* Ouch! We can only handle 8-byte aligned width... */
+                stride_align(&pix->width);
+                ret = v4l2_subdev_call(sd, video, s_fmt, &f);
                 if (ret < 0)
                         return ret;
         }
 
-        configure_geometry(mx3_cam, rect);
+        if (pix->width != icd->user_width || pix->height != icd->user_height) {
+                /*
+                 * We now know pixel formats and can decide upon DMA-channel(s)
+                 * So far only direct camera-to-memory is supported
+                 */
+                if (channel_change_requested(icd, rect)) {
+                        int ret = acquire_dma_channel(mx3_cam);
+                        if (ret < 0)
+                                return ret;
+                }
+
+                configure_geometry(mx3_cam, pix->width, pix->height);
+        }
+
+        dev_dbg(icd->dev.parent, "Sensor cropped %dx%d\n",
+                pix->width, pix->height);
 
-        return icd->ops->set_crop(icd, rect);
+        icd->user_width = pix->width;
+        icd->user_height = pix->height;
+
+        return ret;
 }
 
 static int mx3_camera_set_fmt(struct soc_camera_device *icd,
@@ -818,22 +855,21 @@ static int mx3_camera_set_fmt(struct soc_camera_device *icd,
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct mx3_camera_dev *mx3_cam = ici->priv;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         const struct soc_camera_format_xlate *xlate;
         struct v4l2_pix_format *pix = &f->fmt.pix;
-        struct v4l2_rect rect = {
-                .left   = icd->x_current,
-                .top    = icd->y_current,
-                .width  = pix->width,
-                .height = pix->height,
-        };
         int ret;
 
         xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
         if (!xlate) {
-                dev_warn(ici->dev, "Format %x not found\n", pix->pixelformat);
+                dev_warn(icd->dev.parent, "Format %x not found\n",
+                         pix->pixelformat);
                 return -EINVAL;
         }
 
+        stride_align(&pix->width);
+        dev_dbg(icd->dev.parent, "Set format %dx%d\n", pix->width, pix->height);
+
         ret = acquire_dma_channel(mx3_cam);
         if (ret < 0)
                 return ret;
@@ -844,21 +880,23 @@ static int mx3_camera_set_fmt(struct soc_camera_device *icd,
          * mxc_v4l2_s_fmt()
          */
 
-        configure_geometry(mx3_cam, &rect);
+        configure_geometry(mx3_cam, pix->width, pix->height);
 
-        ret = icd->ops->set_fmt(icd, f);
+        ret = v4l2_subdev_call(sd, video, s_fmt, f);
         if (!ret) {
                 icd->buswidth = xlate->buswidth;
                 icd->current_fmt = xlate->host_fmt;
         }
 
+        dev_dbg(icd->dev.parent, "Sensor set %dx%d\n", pix->width, pix->height);
+
         return ret;
 }
 
 static int mx3_camera_try_fmt(struct soc_camera_device *icd,
                               struct v4l2_format *f)
 {
-        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         const struct soc_camera_format_xlate *xlate;
         struct v4l2_pix_format *pix = &f->fmt.pix;
         __u32 pixfmt = pix->pixelformat;
@@ -867,7 +905,7 @@ static int mx3_camera_try_fmt(struct soc_camera_device *icd,
 
         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
         if (pixfmt && !xlate) {
-                dev_warn(ici->dev, "Format %x not found\n", pixfmt);
+                dev_warn(icd->dev.parent, "Format %x not found\n", pixfmt);
                 return -EINVAL;
         }
 
@@ -884,7 +922,7 @@ static int mx3_camera_try_fmt(struct soc_camera_device *icd,
         /* camera has to see its format, but the user the original one */
         pix->pixelformat = xlate->cam_fmt->fourcc;
         /* limit to sensor capabilities */
-        ret = icd->ops->try_fmt(icd, f);
+        ret = v4l2_subdev_call(sd, video, try_fmt, f);
         pix->pixelformat = xlate->host_fmt->fourcc;
 
         field = pix->field;
@@ -892,7 +930,7 @@ static int mx3_camera_try_fmt(struct soc_camera_device *icd,
         if (field == V4L2_FIELD_ANY) {
                 pix->field = V4L2_FIELD_NONE;
         } else if (field != V4L2_FIELD_NONE) {
-                dev_err(&icd->dev, "Field type %d unsupported.\n", field);
+                dev_err(icd->dev.parent, "Field type %d unsupported.\n", field);
                 return -EINVAL;
         }
 
@@ -931,14 +969,15 @@ static int mx3_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
         u32 dw, sens_conf;
         int ret = test_platform_param(mx3_cam, icd->buswidth, &bus_flags);
         const struct soc_camera_format_xlate *xlate;
+        struct device *dev = icd->dev.parent;
 
         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
         if (!xlate) {
-                dev_warn(ici->dev, "Format %x not found\n", pixfmt);
+                dev_warn(dev, "Format %x not found\n", pixfmt);
                 return -EINVAL;
         }
 
-        dev_dbg(ici->dev, "requested bus width %d bit: %d\n",
+        dev_dbg(dev, "requested bus width %d bit: %d\n",
                 icd->buswidth, ret);
 
         if (ret < 0)
@@ -947,9 +986,10 @@ static int mx3_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
         camera_flags = icd->ops->query_bus_param(icd);
 
         common_flags = soc_camera_bus_param_compatible(camera_flags, bus_flags);
+        dev_dbg(dev, "Flags cam: 0x%lx host: 0x%lx common: 0x%lx\n",
+                camera_flags, bus_flags, common_flags);
         if (!common_flags) {
-                dev_dbg(ici->dev, "no common flags: camera %lx, host %lx\n",
-                        camera_flags, bus_flags);
+                dev_dbg(dev, "no common flags");
                 return -EINVAL;
         }
 
@@ -1002,8 +1042,11 @@ static int mx3_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
                         SOCAM_DATAWIDTH_4;
 
         ret = icd->ops->set_bus_param(icd, common_flags);
-        if (ret < 0)
+        if (ret < 0) {
+                dev_dbg(dev, "camera set_bus_param(%lx) returned %d\n",
+                        common_flags, ret);
                 return ret;
+        }
 
         /*
          * So far only gated clock mode is supported. Add a line
@@ -1055,7 +1098,7 @@ static int mx3_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
 
         csi_reg_write(mx3_cam, sens_conf | dw, CSI_SENS_CONF);
 
-        dev_dbg(ici->dev, "Set SENS_CONF to %x\n", sens_conf | dw);
+        dev_dbg(dev, "Set SENS_CONF to %x\n", sens_conf | dw);
 
         return 0;
 }
@@ -1127,8 +1170,9 @@ static int __devinit mx3_camera_probe(struct platform_device *pdev)
         INIT_LIST_HEAD(&mx3_cam->capture);
         spin_lock_init(&mx3_cam->lock);
 
-        base = ioremap(res->start, res->end - res->start + 1);
+        base = ioremap(res->start, resource_size(res));
         if (!base) {
+                pr_err("Couldn't map %x@%x\n", resource_size(res), res->start);
                 err = -ENOMEM;
                 goto eioremap;
         }
@@ -1139,7 +1183,7 @@ static int __devinit mx3_camera_probe(struct platform_device *pdev)
         soc_host->drv_name      = MX3_CAM_DRV_NAME;
         soc_host->ops           = &mx3_soc_camera_host_ops;
         soc_host->priv          = mx3_cam;
-        soc_host->dev           = &pdev->dev;
+        soc_host->v4l2_dev.dev  = &pdev->dev;
         soc_host->nr            = pdev->id;
 
         err = soc_camera_host_register(soc_host);
@@ -1215,3 +1259,4 @@ module_exit(mx3_camera_exit);
 MODULE_DESCRIPTION("i.MX3x SoC Camera Host driver");
 MODULE_AUTHOR("Guennadi Liakhovetski <lg@denx.de>");
 MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" MX3_CAM_DRV_NAME);
diff --git a/drivers/media/video/mxb.c b/drivers/media/video/mxb.c
index 35890e8b2431..3454070e63f0 100644
--- a/drivers/media/video/mxb.c
+++ b/drivers/media/video/mxb.c
@@ -186,19 +186,19 @@ static int mxb_probe(struct saa7146_dev *dev)
         }
 
         mxb->saa7111a = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
-                        "saa7115", "saa7111", I2C_SAA7111A);
+                        "saa7115", "saa7111", I2C_SAA7111A, NULL);
         mxb->tea6420_1 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
-                        "tea6420", "tea6420", I2C_TEA6420_1);
+                        "tea6420", "tea6420", I2C_TEA6420_1, NULL);
         mxb->tea6420_2 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
-                        "tea6420", "tea6420", I2C_TEA6420_2);
+                        "tea6420", "tea6420", I2C_TEA6420_2, NULL);
         mxb->tea6415c = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
-                        "tea6415c", "tea6415c", I2C_TEA6415C);
+                        "tea6415c", "tea6415c", I2C_TEA6415C, NULL);
         mxb->tda9840 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
-                        "tda9840", "tda9840", I2C_TDA9840);
+                        "tda9840", "tda9840", I2C_TDA9840, NULL);
         mxb->tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
-                        "tuner", "tuner", I2C_TUNER);
+                        "tuner", "tuner", I2C_TUNER, NULL);
         if (v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
-                        "saa5246a", "saa5246a", I2C_SAA5246A)) {
+                        "saa5246a", "saa5246a", I2C_SAA5246A, NULL)) {
                 printk(KERN_INFO "mxb: found teletext decoder\n");
         }
 
diff --git a/drivers/media/video/ov772x.c b/drivers/media/video/ov772x.c
index 0bce255168bd..eccb40ab7fec 100644
--- a/drivers/media/video/ov772x.c
+++ b/drivers/media/video/ov772x.c
@@ -22,7 +22,7 @@
 #include <linux/delay.h>
 #include <linux/videodev2.h>
 #include <media/v4l2-chip-ident.h>
-#include <media/v4l2-common.h>
+#include <media/v4l2-subdev.h>
 #include <media/soc_camera.h>
 #include <media/ov772x.h>
 
@@ -382,11 +382,10 @@ struct regval_list {
 };
 
 struct ov772x_color_format {
-        char                     *name;
-        __u32                     fourcc;
-        u8                        dsp3;
-        u8                        com3;
-        u8                        com7;
+        const struct soc_camera_data_format *format;
+        u8 dsp3;
+        u8 com3;
+        u8 com7;
 };
 
 struct ov772x_win_size {
@@ -398,14 +397,15 @@ struct ov772x_win_size {
 };
 
 struct ov772x_priv {
+        struct v4l2_subdev                subdev;
         struct ov772x_camera_info        *info;
-        struct i2c_client                *client;
-        struct soc_camera_device          icd;
         const struct ov772x_color_format *fmt;
         const struct ov772x_win_size     *win;
         int                               model;
-        unsigned int                      flag_vflip:1;
-        unsigned int                      flag_hflip:1;
+        unsigned short                    flag_vflip:1;
+        unsigned short                    flag_hflip:1;
+        /* band_filter = COM8[5] ? 256 - BDBASE : 0 */
+        unsigned short                    band_filter;
 };
 
 #define ENDMARKER { 0xff, 0xff }
@@ -481,43 +481,43 @@ static const struct soc_camera_data_format ov772x_fmt_lists[] = {
  */
 static const struct ov772x_color_format ov772x_cfmts[] = {
         {
-                SETFOURCC(YUYV),
+                .format = &ov772x_fmt_lists[0],
                 .dsp3   = 0x0,
                 .com3   = SWAP_YUV,
                 .com7   = OFMT_YUV,
         },
         {
-                SETFOURCC(YVYU),
+                .format = &ov772x_fmt_lists[1],
                 .dsp3   = UV_ON,
                 .com3   = SWAP_YUV,
                 .com7   = OFMT_YUV,
         },
         {
-                SETFOURCC(UYVY),
+                .format = &ov772x_fmt_lists[2],
                 .dsp3   = 0x0,
                 .com3   = 0x0,
                 .com7   = OFMT_YUV,
         },
         {
-                SETFOURCC(RGB555),
+                .format = &ov772x_fmt_lists[3],
                 .dsp3   = 0x0,
                 .com3   = SWAP_RGB,
                 .com7   = FMT_RGB555 | OFMT_RGB,
         },
         {
-                SETFOURCC(RGB555X),
+                .format = &ov772x_fmt_lists[4],
                 .dsp3   = 0x0,
                 .com3   = 0x0,
                 .com7   = FMT_RGB555 | OFMT_RGB,
         },
         {
-                SETFOURCC(RGB565),
+                .format = &ov772x_fmt_lists[5],
                 .dsp3   = 0x0,
                 .com3   = SWAP_RGB,
                 .com7   = FMT_RGB565 | OFMT_RGB,
         },
         {
-                SETFOURCC(RGB565X),
+                .format = &ov772x_fmt_lists[6],
                 .dsp3   = 0x0,
                 .com3   = 0x0,
                 .com7   = FMT_RGB565 | OFMT_RGB,
@@ -570,6 +570,15 @@ static const struct v4l2_queryctrl ov772x_controls[] = {
                 .step           = 1,
                 .default_value  = 0,
         },
+        {
+                .id             = V4L2_CID_BAND_STOP_FILTER,
+                .type           = V4L2_CTRL_TYPE_INTEGER,
+                .name           = "Band-stop filter",
+                .minimum        = 0,
+                .maximum        = 256,
+                .step           = 1,
+                .default_value  = 0,
+        },
 };
 
 
@@ -577,6 +586,12 @@ static const struct v4l2_queryctrl ov772x_controls[] = {
  * general function
  */
 
+static struct ov772x_priv *to_ov772x(const struct i2c_client *client)
+{
+        return container_of(i2c_get_clientdata(client), struct ov772x_priv,
+                            subdev);
+}
+
 static int ov772x_write_array(struct i2c_client        *client,
                               const struct regval_list *vals)
 {
@@ -617,58 +632,29 @@ static int ov772x_reset(struct i2c_client *client)
  * soc_camera_ops function
  */
 
-static int ov772x_init(struct soc_camera_device *icd)
+static int ov772x_s_stream(struct v4l2_subdev *sd, int enable)
 {
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
-        int ret = 0;
+        struct i2c_client *client = sd->priv;
+        struct ov772x_priv *priv = to_ov772x(client);
 
-        if (priv->info->link.power) {
-                ret = priv->info->link.power(&priv->client->dev, 1);
-                if (ret < 0)
-                        return ret;
+        if (!enable) {
+                ov772x_mask_set(client, COM2, SOFT_SLEEP_MODE, SOFT_SLEEP_MODE);
+                return 0;
         }
 
-        if (priv->info->link.reset)
-                ret = priv->info->link.reset(&priv->client->dev);
-
-        return ret;
-}
-
-static int ov772x_release(struct soc_camera_device *icd)
-{
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
-        int ret = 0;
-
-        if (priv->info->link.power)
-                ret = priv->info->link.power(&priv->client->dev, 0);
-
-        return ret;
-}
-
-static int ov772x_start_capture(struct soc_camera_device *icd)
-{
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
-
         if (!priv->win || !priv->fmt) {
-                dev_err(&icd->dev, "norm or win select error\n");
+                dev_err(&client->dev, "norm or win select error\n");
                 return -EPERM;
         }
 
-        ov772x_mask_set(priv->client, COM2, SOFT_SLEEP_MODE, 0);
+        ov772x_mask_set(client, COM2, SOFT_SLEEP_MODE, 0);
 
-        dev_dbg(&icd->dev,
-                 "format %s, win %s\n", priv->fmt->name, priv->win->name);
+        dev_dbg(&client->dev, "format %s, win %s\n",
+                priv->fmt->format->name, priv->win->name);
 
         return 0;
 }
 
-static int ov772x_stop_capture(struct soc_camera_device *icd)
-{
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
-        ov772x_mask_set(priv->client, COM2, SOFT_SLEEP_MODE, SOFT_SLEEP_MODE);
-        return 0;
-}
-
 static int ov772x_set_bus_param(struct soc_camera_device *icd,
                                 unsigned long             flags)
 {
@@ -677,8 +663,9 @@ static int ov772x_set_bus_param(struct soc_camera_device *icd,
 
 static unsigned long ov772x_query_bus_param(struct soc_camera_device *icd)
 {
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
-        struct soc_camera_link *icl = &priv->info->link;
+        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+        struct ov772x_priv *priv = i2c_get_clientdata(client);
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         unsigned long flags = SOCAM_PCLK_SAMPLE_RISING | SOCAM_MASTER |
                 SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_HIGH |
                 SOCAM_DATA_ACTIVE_HIGH | priv->info->buswidth;
@@ -686,10 +673,10 @@ static unsigned long ov772x_query_bus_param(struct soc_camera_device *icd)
         return soc_camera_apply_sensor_flags(icl, flags);
 }
 
-static int ov772x_get_control(struct soc_camera_device *icd,
-                              struct v4l2_control *ctrl)
+static int ov772x_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
+        struct i2c_client *client = sd->priv;
+        struct ov772x_priv *priv = to_ov772x(client);
 
         switch (ctrl->id) {
         case V4L2_CID_VFLIP:
@@ -698,14 +685,17 @@ static int ov772x_get_control(struct soc_camera_device *icd,
         case V4L2_CID_HFLIP:
                 ctrl->value = priv->flag_hflip;
                 break;
+        case V4L2_CID_BAND_STOP_FILTER:
+                ctrl->value = priv->band_filter;
+                break;
         }
         return 0;
 }
 
-static int ov772x_set_control(struct soc_camera_device *icd,
-                              struct v4l2_control *ctrl)
+static int ov772x_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
+        struct i2c_client *client = sd->priv;
+        struct ov772x_priv *priv = to_ov772x(client);
         int ret = 0;
         u8 val;
 
@@ -715,24 +705,48 @@ static int ov772x_set_control(struct soc_camera_device *icd,
                 priv->flag_vflip = ctrl->value;
                 if (priv->info->flags & OV772X_FLAG_VFLIP)
                         val ^= VFLIP_IMG;
-                ret = ov772x_mask_set(priv->client, COM3, VFLIP_IMG, val);
+                ret = ov772x_mask_set(client, COM3, VFLIP_IMG, val);
                 break;
         case V4L2_CID_HFLIP:
                 val = ctrl->value ? HFLIP_IMG : 0x00;
                 priv->flag_hflip = ctrl->value;
                 if (priv->info->flags & OV772X_FLAG_HFLIP)
                         val ^= HFLIP_IMG;
-                ret = ov772x_mask_set(priv->client, COM3, HFLIP_IMG, val);
+                ret = ov772x_mask_set(client, COM3, HFLIP_IMG, val);
+                break;
+        case V4L2_CID_BAND_STOP_FILTER:
+                if ((unsigned)ctrl->value > 256)
+                        ctrl->value = 256;
+                if (ctrl->value == priv->band_filter)
+                        break;
+                if (!ctrl->value) {
+                        /* Switch the filter off, it is on now */
+                        ret = ov772x_mask_set(client, BDBASE, 0xff, 0xff);
+                        if (!ret)
+                                ret = ov772x_mask_set(client, COM8,
+                                                      BNDF_ON_OFF, 0);
+                } else {
+                        /* Switch the filter on, set AEC low limit */
+                        val = 256 - ctrl->value;
+                        ret = ov772x_mask_set(client, COM8,
+                                              BNDF_ON_OFF, BNDF_ON_OFF);
+                        if (!ret)
+                                ret = ov772x_mask_set(client, BDBASE,
+                                                      0xff, val);
+                }
+                if (!ret)
+                        priv->band_filter = ctrl->value;
                 break;
         }
 
         return ret;
 }
 
-static int ov772x_get_chip_id(struct soc_camera_device *icd,
-                              struct v4l2_dbg_chip_ident   *id)
+static int ov772x_g_chip_ident(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_chip_ident *id)
 {
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
+        struct i2c_client *client = sd->priv;
+        struct ov772x_priv *priv = to_ov772x(client);
 
         id->ident    = priv->model;
         id->revision = 0;
@@ -741,17 +755,17 @@ static int ov772x_get_chip_id(struct soc_camera_device *icd,
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int ov772x_get_register(struct soc_camera_device *icd,
-                               struct v4l2_dbg_register *reg)
+static int ov772x_g_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
 {
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
-        int                 ret;
+        struct i2c_client *client = sd->priv;
+        int ret;
 
         reg->size = 1;
         if (reg->reg > 0xff)
                 return -EINVAL;
 
-        ret = i2c_smbus_read_byte_data(priv->client, reg->reg);
+        ret = i2c_smbus_read_byte_data(client, reg->reg);
         if (ret < 0)
                 return ret;
 
@@ -760,21 +774,20 @@ static int ov772x_get_register(struct soc_camera_device *icd,
         return 0;
 }
 
-static int ov772x_set_register(struct soc_camera_device *icd,
-                               struct v4l2_dbg_register *reg)
+static int ov772x_s_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
 {
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
+        struct i2c_client *client = sd->priv;
 
         if (reg->reg > 0xff ||
             reg->val > 0xff)
                 return -EINVAL;
 
-        return i2c_smbus_write_byte_data(priv->client, reg->reg, reg->val);
+        return i2c_smbus_write_byte_data(client, reg->reg, reg->val);
 }
 #endif
 
-static const struct ov772x_win_size*
-ov772x_select_win(u32 width, u32 height)
+static const struct ov772x_win_size *ov772x_select_win(u32 width, u32 height)
 {
         __u32 diff;
         const struct ov772x_win_size *win;
@@ -793,9 +806,10 @@ ov772x_select_win(u32 width, u32 height)
         return win;
 }
 
-static int ov772x_set_params(struct ov772x_priv *priv, u32 width, u32 height,
-                             u32 pixfmt)
+static int ov772x_set_params(struct i2c_client *client,
+                             u32 *width, u32 *height, u32 pixfmt)
 {
+        struct ov772x_priv *priv = to_ov772x(client);
         int ret = -EINVAL;
         u8  val;
         int i;
@@ -805,7 +819,7 @@ static int ov772x_set_params(struct ov772x_priv *priv, u32 width, u32 height,
          */
         priv->fmt = NULL;
         for (i = 0; i < ARRAY_SIZE(ov772x_cfmts); i++) {
-                if (pixfmt == ov772x_cfmts[i].fourcc) {
+                if (pixfmt == ov772x_cfmts[i].format->fourcc) {
                         priv->fmt = ov772x_cfmts + i;
                         break;
                 }
@@ -816,12 +830,12 @@ static int ov772x_set_params(struct ov772x_priv *priv, u32 width, u32 height,
         /*
          * select win
          */
-        priv->win = ov772x_select_win(width, height);
+        priv->win = ov772x_select_win(*width, *height);
 
         /*
          * reset hardware
          */
-        ov772x_reset(priv->client);
+        ov772x_reset(client);
 
         /*
          * Edge Ctrl
@@ -835,17 +849,17 @@ static int ov772x_set_params(struct ov772x_priv *priv, u32 width, u32 height,
                  * Remove it when manual mode.
                  */
 
-                ret = ov772x_mask_set(priv->client, DSPAUTO, EDGE_ACTRL, 0x00);
+                ret = ov772x_mask_set(client, DSPAUTO, EDGE_ACTRL, 0x00);
                 if (ret < 0)
                         goto ov772x_set_fmt_error;
 
-                ret = ov772x_mask_set(priv->client,
+                ret = ov772x_mask_set(client,
                                       EDGE_TRSHLD, EDGE_THRESHOLD_MASK,
                                       priv->info->edgectrl.threshold);
                 if (ret < 0)
                         goto ov772x_set_fmt_error;
 
-                ret = ov772x_mask_set(priv->client,
+                ret = ov772x_mask_set(client,
                                       EDGE_STRNGT, EDGE_STRENGTH_MASK,
                                       priv->info->edgectrl.strength);
                 if (ret < 0)
@@ -857,13 +871,13 @@ static int ov772x_set_params(struct ov772x_priv *priv, u32 width, u32 height,
                  *
                  * set upper and lower limit
                  */
-                ret = ov772x_mask_set(priv->client,
+                ret = ov772x_mask_set(client,
                                       EDGE_UPPER, EDGE_UPPER_MASK,
                                       priv->info->edgectrl.upper);
                 if (ret < 0)
                         goto ov772x_set_fmt_error;
 
-                ret = ov772x_mask_set(priv->client,
+                ret = ov772x_mask_set(client,
                                       EDGE_LOWER, EDGE_LOWER_MASK,
                                       priv->info->edgectrl.lower);
                 if (ret < 0)
@@ -873,7 +887,7 @@ static int ov772x_set_params(struct ov772x_priv *priv, u32 width, u32 height,
         /*
          * set size format
          */
-        ret = ov772x_write_array(priv->client, priv->win->regs);
+        ret = ov772x_write_array(client, priv->win->regs);
         if (ret < 0)
                 goto ov772x_set_fmt_error;
 
@@ -882,7 +896,7 @@ static int ov772x_set_params(struct ov772x_priv *priv, u32 width, u32 height,
          */
         val = priv->fmt->dsp3;
         if (val) {
-                ret = ov772x_mask_set(priv->client,
+                ret = ov772x_mask_set(client,
                                       DSP_CTRL3, UV_MASK, val);
                 if (ret < 0)
                         goto ov772x_set_fmt_error;
@@ -901,7 +915,7 @@ static int ov772x_set_params(struct ov772x_priv *priv, u32 width, u32 height,
         if (priv->flag_hflip)
                 val ^= HFLIP_IMG;
 
-        ret = ov772x_mask_set(priv->client,
+        ret = ov772x_mask_set(client,
                               COM3, SWAP_MASK | IMG_MASK, val);
         if (ret < 0)
                 goto ov772x_set_fmt_error;
@@ -910,47 +924,99 @@ static int ov772x_set_params(struct ov772x_priv *priv, u32 width, u32 height,
          * set COM7
          */
         val = priv->win->com7_bit | priv->fmt->com7;
-        ret = ov772x_mask_set(priv->client,
+        ret = ov772x_mask_set(client,
                               COM7, (SLCT_MASK | FMT_MASK | OFMT_MASK),
                               val);
         if (ret < 0)
                 goto ov772x_set_fmt_error;
 
+        /*
+         * set COM8
+         */
+        if (priv->band_filter) {
+                ret = ov772x_mask_set(client, COM8, BNDF_ON_OFF, 1);
+                if (!ret)
+                        ret = ov772x_mask_set(client, BDBASE,
+                                              0xff, 256 - priv->band_filter);
+                if (ret < 0)
+                        goto ov772x_set_fmt_error;
+        }
+
+        *width = priv->win->width;
+        *height = priv->win->height;
+
         return ret;
 
 ov772x_set_fmt_error:
 
-        ov772x_reset(priv->client);
+        ov772x_reset(client);
         priv->win = NULL;
         priv->fmt = NULL;
 
         return ret;
 }
 
-static int ov772x_set_crop(struct soc_camera_device *icd,
-                           struct v4l2_rect *rect)
+static int ov772x_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
 {
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
+        a->c.left       = 0;
+        a->c.top        = 0;
+        a->c.width      = VGA_WIDTH;
+        a->c.height     = VGA_HEIGHT;
+        a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
-        if (!priv->fmt)
-                return -EINVAL;
+        return 0;
+}
 
-        return ov772x_set_params(priv, rect->width, rect->height,
-                                 priv->fmt->fourcc);
+static int ov772x_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
+{
+        a->bounds.left                  = 0;
+        a->bounds.top                   = 0;
+        a->bounds.width                 = VGA_WIDTH;
+        a->bounds.height                = VGA_HEIGHT;
+        a->defrect                      = a->bounds;
+        a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        a->pixelaspect.numerator        = 1;
+        a->pixelaspect.denominator      = 1;
+
+        return 0;
 }
 
-static int ov772x_set_fmt(struct soc_camera_device *icd,
-                          struct v4l2_format *f)
+static int ov772x_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct i2c_client *client = sd->priv;
+        struct ov772x_priv *priv = to_ov772x(client);
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+
+        if (!priv->win || !priv->fmt) {
+                u32 width = VGA_WIDTH, height = VGA_HEIGHT;
+                int ret = ov772x_set_params(client, &width, &height,
+                                            V4L2_PIX_FMT_YUYV);
+                if (ret < 0)
+                        return ret;
+        }
+
+        f->type                 = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        pix->width              = priv->win->width;
+        pix->height             = priv->win->height;
+        pix->pixelformat        = priv->fmt->format->fourcc;
+        pix->colorspace         = priv->fmt->format->colorspace;
+        pix->field              = V4L2_FIELD_NONE;
+
+        return 0;
+}
+
+static int ov772x_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
+        struct i2c_client *client = sd->priv;
         struct v4l2_pix_format *pix = &f->fmt.pix;
 
-        return ov772x_set_params(priv, pix->width, pix->height,
+        return ov772x_set_params(client, &pix->width, &pix->height,
                                  pix->pixelformat);
 }
 
-static int ov772x_try_fmt(struct soc_camera_device *icd,
-                          struct v4l2_format       *f)
+static int ov772x_try_fmt(struct v4l2_subdev *sd,
+                          struct v4l2_format *f)
 {
         struct v4l2_pix_format *pix = &f->fmt.pix;
         const struct ov772x_win_size *win;
@@ -967,9 +1033,10 @@ static int ov772x_try_fmt(struct soc_camera_device *icd,
         return 0;
 }
 
-static int ov772x_video_probe(struct soc_camera_device *icd)
+static int ov772x_video_probe(struct soc_camera_device *icd,
+                              struct i2c_client *client)
 {
-        struct ov772x_priv *priv = container_of(icd, struct ov772x_priv, icd);
+        struct ov772x_priv *priv = to_ov772x(client);
         u8                  pid, ver;
         const char         *devname;
 
@@ -986,7 +1053,7 @@ static int ov772x_video_probe(struct soc_camera_device *icd)
          */
         if (SOCAM_DATAWIDTH_10 != priv->info->buswidth &&
             SOCAM_DATAWIDTH_8  != priv->info->buswidth) {
-                dev_err(&icd->dev, "bus width error\n");
+                dev_err(&client->dev, "bus width error\n");
                 return -ENODEV;
         }
 
@@ -996,8 +1063,8 @@ static int ov772x_video_probe(struct soc_camera_device *icd)
         /*
          * check and show product ID and manufacturer ID
          */
-        pid = i2c_smbus_read_byte_data(priv->client, PID);
-        ver = i2c_smbus_read_byte_data(priv->client, VER);
+        pid = i2c_smbus_read_byte_data(client, PID);
+        ver = i2c_smbus_read_byte_data(client, VER);
 
         switch (VERSION(pid, ver)) {
         case OV7720:
@@ -1009,69 +1076,77 @@ static int ov772x_video_probe(struct soc_camera_device *icd)
                 priv->model = V4L2_IDENT_OV7725;
                 break;
         default:
-                dev_err(&icd->dev,
+                dev_err(&client->dev,
                         "Product ID error %x:%x\n", pid, ver);
                 return -ENODEV;
         }
 
-        dev_info(&icd->dev,
+        dev_info(&client->dev,
                  "%s Product ID %0x:%0x Manufacturer ID %x:%x\n",
                  devname,
                  pid,
                  ver,
-                 i2c_smbus_read_byte_data(priv->client, MIDH),
-                 i2c_smbus_read_byte_data(priv->client, MIDL));
-
-        return soc_camera_video_start(icd);
-}
+                 i2c_smbus_read_byte_data(client, MIDH),
+                 i2c_smbus_read_byte_data(client, MIDL));
 
-static void ov772x_video_remove(struct soc_camera_device *icd)
-{
-        soc_camera_video_stop(icd);
+        return 0;
 }
 
 static struct soc_camera_ops ov772x_ops = {
-        .owner                  = THIS_MODULE,
-        .probe                  = ov772x_video_probe,
-        .remove                 = ov772x_video_remove,
-        .init                   = ov772x_init,
-        .release                = ov772x_release,
-        .start_capture          = ov772x_start_capture,
-        .stop_capture           = ov772x_stop_capture,
-        .set_crop               = ov772x_set_crop,
-        .set_fmt                = ov772x_set_fmt,
-        .try_fmt                = ov772x_try_fmt,
         .set_bus_param          = ov772x_set_bus_param,
         .query_bus_param        = ov772x_query_bus_param,
         .controls               = ov772x_controls,
         .num_controls           = ARRAY_SIZE(ov772x_controls),
-        .get_control            = ov772x_get_control,
-        .set_control            = ov772x_set_control,
-        .get_chip_id            = ov772x_get_chip_id,
+};
+
+static struct v4l2_subdev_core_ops ov772x_subdev_core_ops = {
+        .g_ctrl         = ov772x_g_ctrl,
+        .s_ctrl         = ov772x_s_ctrl,
+        .g_chip_ident   = ov772x_g_chip_ident,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-        .get_register           = ov772x_get_register,
-        .set_register           = ov772x_set_register,
+        .g_register     = ov772x_g_register,
+        .s_register     = ov772x_s_register,
 #endif
 };
 
+static struct v4l2_subdev_video_ops ov772x_subdev_video_ops = {
+        .s_stream       = ov772x_s_stream,
+        .g_fmt          = ov772x_g_fmt,
+        .s_fmt          = ov772x_s_fmt,
+        .try_fmt        = ov772x_try_fmt,
+        .cropcap        = ov772x_cropcap,
+        .g_crop         = ov772x_g_crop,
+};
+
+static struct v4l2_subdev_ops ov772x_subdev_ops = {
+        .core   = &ov772x_subdev_core_ops,
+        .video  = &ov772x_subdev_video_ops,
+};
+
 /*
  * i2c_driver function
  */
 
 static int ov772x_probe(struct i2c_client *client,
-                         const struct i2c_device_id *did)
+                        const struct i2c_device_id *did)
 {
         struct ov772x_priv        *priv;
         struct ov772x_camera_info *info;
-        struct soc_camera_device  *icd;
+        struct soc_camera_device  *icd = client->dev.platform_data;
         struct i2c_adapter        *adapter = to_i2c_adapter(client->dev.parent);
+        struct soc_camera_link    *icl;
         int                        ret;
 
-        if (!client->dev.platform_data)
+        if (!icd) {
+                dev_err(&client->dev, "OV772X: missing soc-camera data!\n");
                 return -EINVAL;
+        }
 
-        info = container_of(client->dev.platform_data,
-                            struct ov772x_camera_info, link);
+        icl = to_soc_camera_link(icd);
+        if (!icl)
+                return -EINVAL;
+
+        info = container_of(icl, struct ov772x_camera_info, link);
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
                 dev_err(&adapter->dev,
@@ -1084,20 +1159,15 @@ static int ov772x_probe(struct i2c_client *client,
         if (!priv)
                 return -ENOMEM;
 
-        priv->info   = info;
-        priv->client = client;
-        i2c_set_clientdata(client, priv);
+        priv->info = info;
 
-        icd             = &priv->icd;
-        icd->ops        = &ov772x_ops;
-        icd->control    = &client->dev;
-        icd->width_max  = MAX_WIDTH;
-        icd->height_max = MAX_HEIGHT;
-        icd->iface      = priv->info->link.bus_id;
+        v4l2_i2c_subdev_init(&priv->subdev, client, &ov772x_subdev_ops);
 
-        ret = soc_camera_device_register(icd);
+        icd->ops                = &ov772x_ops;
 
+        ret = ov772x_video_probe(icd, client);
         if (ret) {
+                icd->ops = NULL;
                 i2c_set_clientdata(client, NULL);
                 kfree(priv);
         }
@@ -1107,9 +1177,10 @@ static int ov772x_probe(struct i2c_client *client,
 
 static int ov772x_remove(struct i2c_client *client)
 {
-        struct ov772x_priv *priv = i2c_get_clientdata(client);
+        struct ov772x_priv *priv = to_ov772x(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
 
-        soc_camera_device_unregister(&priv->icd);
+        icd->ops = NULL;
         i2c_set_clientdata(client, NULL);
         kfree(priv);
         return 0;
diff --git a/drivers/media/video/pvrusb2/pvrusb2-devattr.c b/drivers/media/video/pvrusb2/pvrusb2-devattr.c
index 336a20eded0f..e4d7c13cab87 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-devattr.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-devattr.c
@@ -298,6 +298,7 @@ static struct tda829x_config tda829x_no_probe = {
 
 static struct tda18271_config hauppauge_tda18271_dvb_config = {
         .gate    = TDA18271_GATE_ANALOG,
+        .output_opt = TDA18271_OUTPUT_LT_OFF,
 };
 
 static int pvr2_tda10048_attach(struct pvr2_dvb_adapter *adap)
@@ -393,6 +394,7 @@ static struct tda18271_std_map hauppauge_tda18271_std_map = {
 static struct tda18271_config hauppauge_tda18271_config = {
         .std_map = &hauppauge_tda18271_std_map,
         .gate    = TDA18271_GATE_ANALOG,
+        .output_opt = TDA18271_OUTPUT_LT_OFF,
 };
 
 static int pvr2_s5h1409_attach(struct pvr2_dvb_adapter *adap)
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.c b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
index cbc388729d77..13639b302700 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-hdw.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
@@ -2063,8 +2063,8 @@ static int pvr2_hdw_load_subdev(struct pvr2_hdw *hdw,
                 return -EINVAL;
         }
 
-        /* Note how the 2nd and 3rd arguments are the same for both
-         * v4l2_i2c_new_subdev() and v4l2_i2c_new_probed_subdev().  Why?
+        /* Note how the 2nd and 3rd arguments are the same for
+         * v4l2_i2c_new_subdev().  Why?
          * Well the 2nd argument is the module name to load, while the 3rd
          * argument is documented in the framework as being the "chipid" -
          * and every other place where I can find examples of this, the
@@ -2077,15 +2077,15 @@ static int pvr2_hdw_load_subdev(struct pvr2_hdw *hdw,
                            mid, i2caddr[0]);
                 sd = v4l2_i2c_new_subdev(&hdw->v4l2_dev, &hdw->i2c_adap,
                                          fname, fname,
-                                         i2caddr[0]);
+                                         i2caddr[0], NULL);
         } else {
                 pvr2_trace(PVR2_TRACE_INIT,
                            "Module ID %u:"
                            " Setting up with address probe list",
                            mid);
-                sd = v4l2_i2c_new_probed_subdev(&hdw->v4l2_dev, &hdw->i2c_adap,
+                sd = v4l2_i2c_new_subdev(&hdw->v4l2_dev, &hdw->i2c_adap,
                                                 fname, fname,
-                                                i2caddr);
+                                                0, i2caddr);
         }
 
         if (!sd) {
diff --git a/drivers/media/video/pxa_camera.c b/drivers/media/video/pxa_camera.c
index 016bb45ba0c3..6952e9602d5d 100644
--- a/drivers/media/video/pxa_camera.c
+++ b/drivers/media/video/pxa_camera.c
@@ -225,6 +225,10 @@ struct pxa_camera_dev {
         u32                     save_cicr[5];
 };
 
+struct pxa_cam {
+        unsigned long flags;
+};
+
 static const char *pxa_cam_driver_description = "PXA_Camera";
 
 static unsigned int vid_limit = 16;     /* Video memory limit, in Mb */
@@ -237,9 +241,9 @@ static int pxa_videobuf_setup(struct videobuf_queue *vq, unsigned int *count,
 {
         struct soc_camera_device *icd = vq->priv_data;
 
-        dev_dbg(&icd->dev, "count=%d, size=%d\n", *count, *size);
+        dev_dbg(icd->dev.parent, "count=%d, size=%d\n", *count, *size);
 
-        *size = roundup(icd->width * icd->height *
+        *size = roundup(icd->user_width * icd->user_height *
                         ((icd->current_fmt->depth + 7) >> 3), 8);
 
         if (0 == *count)
@@ -259,7 +263,7 @@ static void free_buffer(struct videobuf_queue *vq, struct pxa_buffer *buf)
 
         BUG_ON(in_interrupt());
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
+        dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                 &buf->vb, buf->vb.baddr, buf->vb.bsize);
 
         /* This waits until this buffer is out of danger, i.e., until it is no
@@ -270,7 +274,8 @@ static void free_buffer(struct videobuf_queue *vq, struct pxa_buffer *buf)
 
         for (i = 0; i < ARRAY_SIZE(buf->dmas); i++) {
                 if (buf->dmas[i].sg_cpu)
-                        dma_free_coherent(ici->dev, buf->dmas[i].sg_size,
+                        dma_free_coherent(ici->v4l2_dev.dev,
+                                          buf->dmas[i].sg_size,
                                           buf->dmas[i].sg_cpu,
                                           buf->dmas[i].sg_dma);
                 buf->dmas[i].sg_cpu = NULL;
@@ -325,19 +330,20 @@ static int pxa_init_dma_channel(struct pxa_camera_dev *pcdev,
                                 struct scatterlist **sg_first, int *sg_first_ofs)
 {
         struct pxa_cam_dma *pxa_dma = &buf->dmas[channel];
+        struct device *dev = pcdev->soc_host.v4l2_dev.dev;
         struct scatterlist *sg;
         int i, offset, sglen;
         int dma_len = 0, xfer_len = 0;
 
         if (pxa_dma->sg_cpu)
-                dma_free_coherent(pcdev->soc_host.dev, pxa_dma->sg_size,
+                dma_free_coherent(dev, pxa_dma->sg_size,
                                   pxa_dma->sg_cpu, pxa_dma->sg_dma);
 
         sglen = calculate_dma_sglen(*sg_first, dma->sglen,
                                     *sg_first_ofs, size);
 
         pxa_dma->sg_size = (sglen + 1) * sizeof(struct pxa_dma_desc);
-        pxa_dma->sg_cpu = dma_alloc_coherent(pcdev->soc_host.dev, pxa_dma->sg_size,
+        pxa_dma->sg_cpu = dma_alloc_coherent(dev, pxa_dma->sg_size,
                                              &pxa_dma->sg_dma, GFP_KERNEL);
         if (!pxa_dma->sg_cpu)
                 return -ENOMEM;
@@ -345,7 +351,7 @@ static int pxa_init_dma_channel(struct pxa_camera_dev *pcdev,
         pxa_dma->sglen = sglen;
         offset = *sg_first_ofs;
 
-        dev_dbg(pcdev->soc_host.dev, "DMA: sg_first=%p, sglen=%d, ofs=%d, dma.desc=%x\n",
+        dev_dbg(dev, "DMA: sg_first=%p, sglen=%d, ofs=%d, dma.desc=%x\n",
                 *sg_first, sglen, *sg_first_ofs, pxa_dma->sg_dma);
 
 
@@ -368,7 +374,7 @@ static int pxa_init_dma_channel(struct pxa_camera_dev *pcdev,
                 pxa_dma->sg_cpu[i].ddadr =
                         pxa_dma->sg_dma + (i + 1) * sizeof(struct pxa_dma_desc);
 
-                dev_vdbg(pcdev->soc_host.dev, "DMA: desc.%08x->@phys=0x%08x, len=%d\n",
+                dev_vdbg(dev, "DMA: desc.%08x->@phys=0x%08x, len=%d\n",
                          pxa_dma->sg_dma + i * sizeof(struct pxa_dma_desc),
                          sg_dma_address(sg) + offset, xfer_len);
                 offset = 0;
@@ -418,11 +424,12 @@ static int pxa_videobuf_prepare(struct videobuf_queue *vq,
         struct soc_camera_device *icd = vq->priv_data;
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct pxa_camera_dev *pcdev = ici->priv;
+        struct device *dev = pcdev->soc_host.v4l2_dev.dev;
         struct pxa_buffer *buf = container_of(vb, struct pxa_buffer, vb);
         int ret;
         int size_y, size_u = 0, size_v = 0;
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
+        dev_dbg(dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                 vb, vb->baddr, vb->bsize);
 
         /* Added list head initialization on alloc */
@@ -441,12 +448,12 @@ static int pxa_videobuf_prepare(struct videobuf_queue *vq,
         buf->inwork = 1;
 
         if (buf->fmt    != icd->current_fmt ||
-            vb->width   != icd->width ||
-            vb->height  != icd->height ||
+            vb->width   != icd->user_width ||
+            vb->height  != icd->user_height ||
             vb->field   != field) {
                 buf->fmt        = icd->current_fmt;
-                vb->width       = icd->width;
-                vb->height      = icd->height;
+                vb->width       = icd->user_width;
+                vb->height      = icd->user_height;
                 vb->field       = field;
                 vb->state       = VIDEOBUF_NEEDS_INIT;
         }
@@ -480,8 +487,7 @@ static int pxa_videobuf_prepare(struct videobuf_queue *vq,
                 ret = pxa_init_dma_channel(pcdev, buf, dma, 0, CIBR0, size_y,
                                            &sg, &next_ofs);
                 if (ret) {
-                        dev_err(pcdev->soc_host.dev,
-                                "DMA initialization for Y/RGB failed\n");
+                        dev_err(dev, "DMA initialization for Y/RGB failed\n");
                         goto fail;
                 }
 
@@ -490,8 +496,7 @@ static int pxa_videobuf_prepare(struct videobuf_queue *vq,
                         ret = pxa_init_dma_channel(pcdev, buf, dma, 1, CIBR1,
                                                    size_u, &sg, &next_ofs);
                 if (ret) {
-                        dev_err(pcdev->soc_host.dev,
-                                "DMA initialization for U failed\n");
+                        dev_err(dev, "DMA initialization for U failed\n");
                         goto fail_u;
                 }
 
@@ -500,8 +505,7 @@ static int pxa_videobuf_prepare(struct videobuf_queue *vq,
                         ret = pxa_init_dma_channel(pcdev, buf, dma, 2, CIBR2,
                                                    size_v, &sg, &next_ofs);
                 if (ret) {
-                        dev_err(pcdev->soc_host.dev,
-                                "DMA initialization for V failed\n");
+                        dev_err(dev, "DMA initialization for V failed\n");
                         goto fail_v;
                 }
 
@@ -514,10 +518,10 @@ static int pxa_videobuf_prepare(struct videobuf_queue *vq,
         return 0;
 
 fail_v:
-        dma_free_coherent(pcdev->soc_host.dev, buf->dmas[1].sg_size,
+        dma_free_coherent(dev, buf->dmas[1].sg_size,
                           buf->dmas[1].sg_cpu, buf->dmas[1].sg_dma);
 fail_u:
-        dma_free_coherent(pcdev->soc_host.dev, buf->dmas[0].sg_size,
+        dma_free_coherent(dev, buf->dmas[0].sg_size,
                           buf->dmas[0].sg_cpu, buf->dmas[0].sg_dma);
 fail:
         free_buffer(vq, buf);
@@ -541,7 +545,8 @@ static void pxa_dma_start_channels(struct pxa_camera_dev *pcdev)
         active = pcdev->active;
 
         for (i = 0; i < pcdev->channels; i++) {
-                dev_dbg(pcdev->soc_host.dev, "%s (channel=%d) ddadr=%08x\n", __func__,
+                dev_dbg(pcdev->soc_host.v4l2_dev.dev,
+                        "%s (channel=%d) ddadr=%08x\n", __func__,
                         i, active->dmas[i].sg_dma);
                 DDADR(pcdev->dma_chans[i]) = active->dmas[i].sg_dma;
                 DCSR(pcdev->dma_chans[i]) = DCSR_RUN;
@@ -553,7 +558,8 @@ static void pxa_dma_stop_channels(struct pxa_camera_dev *pcdev)
         int i;
 
         for (i = 0; i < pcdev->channels; i++) {
-                dev_dbg(pcdev->soc_host.dev, "%s (channel=%d)\n", __func__, i);
+                dev_dbg(pcdev->soc_host.v4l2_dev.dev,
+                        "%s (channel=%d)\n", __func__, i);
                 DCSR(pcdev->dma_chans[i]) = 0;
         }
 }
@@ -589,7 +595,7 @@ static void pxa_camera_start_capture(struct pxa_camera_dev *pcdev)
 {
         unsigned long cicr0, cifr;
 
-        dev_dbg(pcdev->soc_host.dev, "%s\n", __func__);
+        dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s\n", __func__);
         /* Reset the FIFOs */
         cifr = __raw_readl(pcdev->base + CIFR) | CIFR_RESET_F;
         __raw_writel(cifr, pcdev->base + CIFR);
@@ -609,7 +615,7 @@ static void pxa_camera_stop_capture(struct pxa_camera_dev *pcdev)
         __raw_writel(cicr0, pcdev->base + CICR0);
 
         pcdev->active = NULL;
-        dev_dbg(pcdev->soc_host.dev, "%s\n", __func__);
+        dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s\n", __func__);
 }
 
 /* Called under spinlock_irqsave(&pcdev->lock, ...) */
@@ -621,8 +627,8 @@ static void pxa_videobuf_queue(struct videobuf_queue *vq,
         struct pxa_camera_dev *pcdev = ici->priv;
         struct pxa_buffer *buf = container_of(vb, struct pxa_buffer, vb);
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d active=%p\n", __func__,
-                vb, vb->baddr, vb->bsize, pcdev->active);
+        dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %d active=%p\n",
+                __func__, vb, vb->baddr, vb->bsize, pcdev->active);
 
         list_add_tail(&vb->queue, &pcdev->capture);
 
@@ -639,22 +645,23 @@ static void pxa_videobuf_release(struct videobuf_queue *vq,
         struct pxa_buffer *buf = container_of(vb, struct pxa_buffer, vb);
 #ifdef DEBUG
         struct soc_camera_device *icd = vq->priv_data;
+        struct device *dev = icd->dev.parent;
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
+        dev_dbg(dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                 vb, vb->baddr, vb->bsize);
 
         switch (vb->state) {
         case VIDEOBUF_ACTIVE:
-                dev_dbg(&icd->dev, "%s (active)\n", __func__);
+                dev_dbg(dev, "%s (active)\n", __func__);
                 break;
         case VIDEOBUF_QUEUED:
-                dev_dbg(&icd->dev, "%s (queued)\n", __func__);
+                dev_dbg(dev, "%s (queued)\n", __func__);
                 break;
         case VIDEOBUF_PREPARED:
-                dev_dbg(&icd->dev, "%s (prepared)\n", __func__);
+                dev_dbg(dev, "%s (prepared)\n", __func__);
                 break;
         default:
-                dev_dbg(&icd->dev, "%s (unknown)\n", __func__);
+                dev_dbg(dev, "%s (unknown)\n", __func__);
                 break;
         }
 #endif
@@ -674,7 +681,8 @@ static void pxa_camera_wakeup(struct pxa_camera_dev *pcdev,
         do_gettimeofday(&vb->ts);
         vb->field_count++;
         wake_up(&vb->done);
-        dev_dbg(pcdev->soc_host.dev, "%s dequeud buffer (vb=0x%p)\n", __func__, vb);
+        dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s dequeud buffer (vb=0x%p)\n",
+                __func__, vb);
 
         if (list_empty(&pcdev->capture)) {
                 pxa_camera_stop_capture(pcdev);
@@ -710,7 +718,8 @@ static void pxa_camera_check_link_miss(struct pxa_camera_dev *pcdev)
         for (i = 0; i < pcdev->channels; i++)
                 if (DDADR(pcdev->dma_chans[i]) != DDADR_STOP)
                         is_dma_stopped = 0;
-        dev_dbg(pcdev->soc_host.dev, "%s : top queued buffer=%p, dma_stopped=%d\n",
+        dev_dbg(pcdev->soc_host.v4l2_dev.dev,
+                "%s : top queued buffer=%p, dma_stopped=%d\n",
                 __func__, pcdev->active, is_dma_stopped);
         if (pcdev->active && is_dma_stopped)
                 pxa_camera_start_capture(pcdev);
@@ -719,6 +728,7 @@ static void pxa_camera_check_link_miss(struct pxa_camera_dev *pcdev)
 static void pxa_camera_dma_irq(int channel, struct pxa_camera_dev *pcdev,
                                enum pxa_camera_active_dma act_dma)
 {
+        struct device *dev = pcdev->soc_host.v4l2_dev.dev;
         struct pxa_buffer *buf;
         unsigned long flags;
         u32 status, camera_status, overrun;
@@ -735,13 +745,13 @@ static void pxa_camera_dma_irq(int channel, struct pxa_camera_dev *pcdev,
                 overrun |= CISR_IFO_1 | CISR_IFO_2;
 
         if (status & DCSR_BUSERR) {
-                dev_err(pcdev->soc_host.dev, "DMA Bus Error IRQ!\n");
+                dev_err(dev, "DMA Bus Error IRQ!\n");
                 goto out;
         }
 
         if (!(status & (DCSR_ENDINTR | DCSR_STARTINTR))) {
-                dev_err(pcdev->soc_host.dev, "Unknown DMA IRQ source, "
-                        "status: 0x%08x\n", status);
+                dev_err(dev, "Unknown DMA IRQ source, status: 0x%08x\n",
+                        status);
                 goto out;
         }
 
@@ -764,7 +774,7 @@ static void pxa_camera_dma_irq(int channel, struct pxa_camera_dev *pcdev,
         buf = container_of(vb, struct pxa_buffer, vb);
         WARN_ON(buf->inwork || list_empty(&vb->queue));
 
-        dev_dbg(pcdev->soc_host.dev, "%s channel=%d %s%s(vb=0x%p) dma.desc=%x\n",
+        dev_dbg(dev, "%s channel=%d %s%s(vb=0x%p) dma.desc=%x\n",
                 __func__, channel, status & DCSR_STARTINTR ? "SOF " : "",
                 status & DCSR_ENDINTR ? "EOF " : "", vb, DDADR(channel));
 
@@ -775,7 +785,7 @@ static void pxa_camera_dma_irq(int channel, struct pxa_camera_dev *pcdev,
                  */
                 if (camera_status & overrun &&
                     !list_is_last(pcdev->capture.next, &pcdev->capture)) {
-                        dev_dbg(pcdev->soc_host.dev, "FIFO overrun! CISR: %x\n",
+                        dev_dbg(dev, "FIFO overrun! CISR: %x\n",
                                 camera_status);
                         pxa_camera_stop_capture(pcdev);
                         pxa_camera_start_capture(pcdev);
@@ -830,9 +840,11 @@ static void pxa_camera_init_videobuf(struct videobuf_queue *q,
                                 sizeof(struct pxa_buffer), icd);
 }
 
-static u32 mclk_get_divisor(struct pxa_camera_dev *pcdev)
+static u32 mclk_get_divisor(struct platform_device *pdev,
+                            struct pxa_camera_dev *pcdev)
 {
         unsigned long mclk = pcdev->mclk;
+        struct device *dev = &pdev->dev;
         u32 div;
         unsigned long lcdclk;
 
@@ -842,7 +854,7 @@ static u32 mclk_get_divisor(struct pxa_camera_dev *pcdev)
         /* mclk <= ciclk / 4 (27.4.2) */
         if (mclk > lcdclk / 4) {
                 mclk = lcdclk / 4;
-                dev_warn(pcdev->soc_host.dev, "Limiting master clock to %lu\n", mclk);
+                dev_warn(dev, "Limiting master clock to %lu\n", mclk);
         }
 
         /* We verify mclk != 0, so if anyone breaks it, here comes their Oops */
@@ -852,8 +864,8 @@ static u32 mclk_get_divisor(struct pxa_camera_dev *pcdev)
         if (pcdev->platform_flags & PXA_CAMERA_MCLK_EN)
                 pcdev->mclk = lcdclk / (2 * (div + 1));
 
-        dev_dbg(pcdev->soc_host.dev, "LCD clock %luHz, target freq %luHz, "
-                "divisor %u\n", lcdclk, mclk, div);
+        dev_dbg(dev, "LCD clock %luHz, target freq %luHz, divisor %u\n",
+                lcdclk, mclk, div);
 
         return div;
 }
@@ -870,14 +882,15 @@ static void recalculate_fifo_timeout(struct pxa_camera_dev *pcdev,
 static void pxa_camera_activate(struct pxa_camera_dev *pcdev)
 {
         struct pxacamera_platform_data *pdata = pcdev->pdata;
+        struct device *dev = pcdev->soc_host.v4l2_dev.dev;
         u32 cicr4 = 0;
 
-        dev_dbg(pcdev->soc_host.dev, "Registered platform device at %p data %p\n",
+        dev_dbg(dev, "Registered platform device at %p data %p\n",
                 pcdev, pdata);
 
         if (pdata && pdata->init) {
-                dev_dbg(pcdev->soc_host.dev, "%s: Init gpios\n", __func__);
-                pdata->init(pcdev->soc_host.dev);
+                dev_dbg(dev, "%s: Init gpios\n", __func__);
+                pdata->init(dev);
         }
 
         /* disable all interrupts */
@@ -919,7 +932,8 @@ static irqreturn_t pxa_camera_irq(int irq, void *data)
         struct videobuf_buffer *vb;
 
         status = __raw_readl(pcdev->base + CISR);
-        dev_dbg(pcdev->soc_host.dev, "Camera interrupt status 0x%lx\n", status);
+        dev_dbg(pcdev->soc_host.v4l2_dev.dev,
+                "Camera interrupt status 0x%lx\n", status);
 
         if (!status)
                 return IRQ_NONE;
@@ -951,24 +965,18 @@ static int pxa_camera_add_device(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct pxa_camera_dev *pcdev = ici->priv;
-        int ret;
 
-        if (pcdev->icd) {
-                ret = -EBUSY;
-                goto ebusy;
-        }
-
-        dev_info(&icd->dev, "PXA Camera driver attached to camera %d\n",
-                 icd->devnum);
+        if (pcdev->icd)
+                return -EBUSY;
 
         pxa_camera_activate(pcdev);
-        ret = icd->ops->init(icd);
 
-        if (!ret)
-                pcdev->icd = icd;
+        pcdev->icd = icd;
 
-ebusy:
-        return ret;
+        dev_info(icd->dev.parent, "PXA Camera driver attached to camera %d\n",
+                 icd->devnum);
+
+        return 0;
 }
 
 /* Called with .video_lock held */
@@ -979,7 +987,7 @@ static void pxa_camera_remove_device(struct soc_camera_device *icd)
 
         BUG_ON(icd != pcdev->icd);
 
-        dev_info(&icd->dev, "PXA Camera driver detached from camera %d\n",
+        dev_info(icd->dev.parent, "PXA Camera driver detached from camera %d\n",
                  icd->devnum);
 
         /* disable capture, disable interrupts */
@@ -990,8 +998,6 @@ static void pxa_camera_remove_device(struct soc_camera_device *icd)
         DCSR(pcdev->dma_chans[1]) = 0;
         DCSR(pcdev->dma_chans[2]) = 0;
 
-        icd->ops->release(icd);
-
         pxa_camera_deactivate(pcdev);
 
         pcdev->icd = NULL;
@@ -1039,57 +1045,17 @@ static int test_platform_param(struct pxa_camera_dev *pcdev,
         return 0;
 }
 
-static int pxa_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
+static void pxa_camera_setup_cicr(struct soc_camera_device *icd,
+                                  unsigned long flags, __u32 pixfmt)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct pxa_camera_dev *pcdev = ici->priv;
-        unsigned long dw, bpp, bus_flags, camera_flags, common_flags;
+        unsigned long dw, bpp;
         u32 cicr0, cicr1, cicr2, cicr3, cicr4 = 0;
-        int ret = test_platform_param(pcdev, icd->buswidth, &bus_flags);
-
-        if (ret < 0)
-                return ret;
-
-        camera_flags = icd->ops->query_bus_param(icd);
-
-        common_flags = soc_camera_bus_param_compatible(camera_flags, bus_flags);
-        if (!common_flags)
-                return -EINVAL;
-
-        pcdev->channels = 1;
-
-        /* Make choises, based on platform preferences */
-        if ((common_flags & SOCAM_HSYNC_ACTIVE_HIGH) &&
-            (common_flags & SOCAM_HSYNC_ACTIVE_LOW)) {
-                if (pcdev->platform_flags & PXA_CAMERA_HSP)
-                        common_flags &= ~SOCAM_HSYNC_ACTIVE_HIGH;
-                else
-                        common_flags &= ~SOCAM_HSYNC_ACTIVE_LOW;
-        }
-
-        if ((common_flags & SOCAM_VSYNC_ACTIVE_HIGH) &&
-            (common_flags & SOCAM_VSYNC_ACTIVE_LOW)) {
-                if (pcdev->platform_flags & PXA_CAMERA_VSP)
-                        common_flags &= ~SOCAM_VSYNC_ACTIVE_HIGH;
-                else
-                        common_flags &= ~SOCAM_VSYNC_ACTIVE_LOW;
-        }
-
-        if ((common_flags & SOCAM_PCLK_SAMPLE_RISING) &&
-            (common_flags & SOCAM_PCLK_SAMPLE_FALLING)) {
-                if (pcdev->platform_flags & PXA_CAMERA_PCP)
-                        common_flags &= ~SOCAM_PCLK_SAMPLE_RISING;
-                else
-                        common_flags &= ~SOCAM_PCLK_SAMPLE_FALLING;
-        }
-
-        ret = icd->ops->set_bus_param(icd, common_flags);
-        if (ret < 0)
-                return ret;
 
         /* Datawidth is now guaranteed to be equal to one of the three values.
          * We fix bit-per-pixel equal to data-width... */
-        switch (common_flags & SOCAM_DATAWIDTH_MASK) {
+        switch (flags & SOCAM_DATAWIDTH_MASK) {
         case SOCAM_DATAWIDTH_10:
                 dw = 4;
                 bpp = 0x40;
@@ -1110,18 +1076,18 @@ static int pxa_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
                 cicr4 |= CICR4_PCLK_EN;
         if (pcdev->platform_flags & PXA_CAMERA_MCLK_EN)
                 cicr4 |= CICR4_MCLK_EN;
-        if (common_flags & SOCAM_PCLK_SAMPLE_FALLING)
+        if (flags & SOCAM_PCLK_SAMPLE_FALLING)
                 cicr4 |= CICR4_PCP;
-        if (common_flags & SOCAM_HSYNC_ACTIVE_LOW)
+        if (flags & SOCAM_HSYNC_ACTIVE_LOW)
                 cicr4 |= CICR4_HSP;
-        if (common_flags & SOCAM_VSYNC_ACTIVE_LOW)
+        if (flags & SOCAM_VSYNC_ACTIVE_LOW)
                 cicr4 |= CICR4_VSP;
 
         cicr0 = __raw_readl(pcdev->base + CICR0);
         if (cicr0 & CICR0_ENB)
                 __raw_writel(cicr0 & ~CICR0_ENB, pcdev->base + CICR0);
 
-        cicr1 = CICR1_PPL_VAL(icd->width - 1) | bpp | dw;
+        cicr1 = CICR1_PPL_VAL(icd->user_width - 1) | bpp | dw;
 
         switch (pixfmt) {
         case V4L2_PIX_FMT_YUV422P:
@@ -1150,7 +1116,7 @@ static int pxa_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
         }
 
         cicr2 = 0;
-        cicr3 = CICR3_LPF_VAL(icd->height - 1) |
+        cicr3 = CICR3_LPF_VAL(icd->user_height - 1) |
                 CICR3_BFW_VAL(min((unsigned short)255, icd->y_skip_top));
         cicr4 |= pcdev->mclk_divisor;
 
@@ -1164,6 +1130,59 @@ static int pxa_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
                 CICR0_SIM_MP : (CICR0_SL_CAP_EN | CICR0_SIM_SP));
         cicr0 |= CICR0_DMAEN | CICR0_IRQ_MASK;
         __raw_writel(cicr0, pcdev->base + CICR0);
+}
+
+static int pxa_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
+{
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct pxa_camera_dev *pcdev = ici->priv;
+        unsigned long bus_flags, camera_flags, common_flags;
+        int ret = test_platform_param(pcdev, icd->buswidth, &bus_flags);
+        struct pxa_cam *cam = icd->host_priv;
+
+        if (ret < 0)
+                return ret;
+
+        camera_flags = icd->ops->query_bus_param(icd);
+
+        common_flags = soc_camera_bus_param_compatible(camera_flags, bus_flags);
+        if (!common_flags)
+                return -EINVAL;
+
+        pcdev->channels = 1;
+
+        /* Make choises, based on platform preferences */
+        if ((common_flags & SOCAM_HSYNC_ACTIVE_HIGH) &&
+            (common_flags & SOCAM_HSYNC_ACTIVE_LOW)) {
+                if (pcdev->platform_flags & PXA_CAMERA_HSP)
+                        common_flags &= ~SOCAM_HSYNC_ACTIVE_HIGH;
+                else
+                        common_flags &= ~SOCAM_HSYNC_ACTIVE_LOW;
+        }
+
+        if ((common_flags & SOCAM_VSYNC_ACTIVE_HIGH) &&
+            (common_flags & SOCAM_VSYNC_ACTIVE_LOW)) {
+                if (pcdev->platform_flags & PXA_CAMERA_VSP)
+                        common_flags &= ~SOCAM_VSYNC_ACTIVE_HIGH;
+                else
+                        common_flags &= ~SOCAM_VSYNC_ACTIVE_LOW;
+        }
+
+        if ((common_flags & SOCAM_PCLK_SAMPLE_RISING) &&
+            (common_flags & SOCAM_PCLK_SAMPLE_FALLING)) {
+                if (pcdev->platform_flags & PXA_CAMERA_PCP)
+                        common_flags &= ~SOCAM_PCLK_SAMPLE_RISING;
+                else
+                        common_flags &= ~SOCAM_PCLK_SAMPLE_FALLING;
+        }
+
+        cam->flags = common_flags;
+
+        ret = icd->ops->set_bus_param(icd, common_flags);
+        if (ret < 0)
+                return ret;
+
+        pxa_camera_setup_cicr(icd, common_flags, pixfmt);
 
         return 0;
 }
@@ -1227,8 +1246,9 @@ static int required_buswidth(const struct soc_camera_data_format *fmt)
 static int pxa_camera_get_formats(struct soc_camera_device *icd, int idx,
                                   struct soc_camera_format_xlate *xlate)
 {
-        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct device *dev = icd->dev.parent;
         int formats = 0, buswidth, ret;
+        struct pxa_cam *cam;
 
         buswidth = required_buswidth(icd->formats + idx);
 
@@ -1239,6 +1259,16 @@ static int pxa_camera_get_formats(struct soc_camera_device *icd, int idx,
         if (ret < 0)
                 return 0;
 
+        if (!icd->host_priv) {
+                cam = kzalloc(sizeof(*cam), GFP_KERNEL);
+                if (!cam)
+                        return -ENOMEM;
+
+                icd->host_priv = cam;
+        } else {
+                cam = icd->host_priv;
+        }
+
         switch (icd->formats[idx].fourcc) {
         case V4L2_PIX_FMT_UYVY:
                 formats++;
@@ -1247,7 +1277,7 @@ static int pxa_camera_get_formats(struct soc_camera_device *icd, int idx,
                         xlate->cam_fmt = icd->formats + idx;
                         xlate->buswidth = buswidth;
                         xlate++;
-                        dev_dbg(ici->dev, "Providing format %s using %s\n",
+                        dev_dbg(dev, "Providing format %s using %s\n",
                                 pxa_camera_formats[0].name,
                                 icd->formats[idx].name);
                 }
@@ -1262,7 +1292,7 @@ static int pxa_camera_get_formats(struct soc_camera_device *icd, int idx,
                         xlate->cam_fmt = icd->formats + idx;
                         xlate->buswidth = buswidth;
                         xlate++;
-                        dev_dbg(ici->dev, "Providing format %s packed\n",
+                        dev_dbg(dev, "Providing format %s packed\n",
                                 icd->formats[idx].name);
                 }
                 break;
@@ -1274,7 +1304,7 @@ static int pxa_camera_get_formats(struct soc_camera_device *icd, int idx,
                         xlate->cam_fmt = icd->formats + idx;
                         xlate->buswidth = icd->formats[idx].depth;
                         xlate++;
-                        dev_dbg(ici->dev,
+                        dev_dbg(dev,
                                 "Providing format %s in pass-through mode\n",
                                 icd->formats[idx].name);
                 }
@@ -1283,31 +1313,80 @@ static int pxa_camera_get_formats(struct soc_camera_device *icd, int idx,
         return formats;
 }
 
+static void pxa_camera_put_formats(struct soc_camera_device *icd)
+{
+        kfree(icd->host_priv);
+        icd->host_priv = NULL;
+}
+
+static int pxa_camera_check_frame(struct v4l2_pix_format *pix)
+{
+        /* limit to pxa hardware capabilities */
+        return pix->height < 32 || pix->height > 2048 || pix->width < 48 ||
+                pix->width > 2048 || (pix->width & 0x01);
+}
+
 static int pxa_camera_set_crop(struct soc_camera_device *icd,
-                               struct v4l2_rect *rect)
+                               struct v4l2_crop *a)
 {
+        struct v4l2_rect *rect = &a->c;
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct pxa_camera_dev *pcdev = ici->priv;
+        struct device *dev = icd->dev.parent;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct soc_camera_sense sense = {
                 .master_clock = pcdev->mclk,
                 .pixel_clock_max = pcdev->ciclk / 4,
         };
+        struct v4l2_format f;
+        struct v4l2_pix_format *pix = &f.fmt.pix, pix_tmp;
+        struct pxa_cam *cam = icd->host_priv;
         int ret;
 
         /* If PCLK is used to latch data from the sensor, check sense */
         if (pcdev->platform_flags & PXA_CAMERA_PCLK_EN)
                 icd->sense = &sense;
 
-        ret = icd->ops->set_crop(icd, rect);
+        ret = v4l2_subdev_call(sd, video, s_crop, a);
 
         icd->sense = NULL;
 
         if (ret < 0) {
-                dev_warn(ici->dev, "Failed to crop to %ux%u@%u:%u\n",
+                dev_warn(dev, "Failed to crop to %ux%u@%u:%u\n",
                          rect->width, rect->height, rect->left, rect->top);
-        } else if (sense.flags & SOCAM_SENSE_PCLK_CHANGED) {
+                return ret;
+        }
+
+        f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        ret = v4l2_subdev_call(sd, video, g_fmt, &f);
+        if (ret < 0)
+                return ret;
+
+        pix_tmp = *pix;
+        if (pxa_camera_check_frame(pix)) {
+                /*
+                 * Camera cropping produced a frame beyond our capabilities.
+                 * FIXME: just extract a subframe, that we can process.
+                 */
+                v4l_bound_align_image(&pix->width, 48, 2048, 1,
+                        &pix->height, 32, 2048, 0,
+                        icd->current_fmt->fourcc == V4L2_PIX_FMT_YUV422P ?
+                                4 : 0);
+                ret = v4l2_subdev_call(sd, video, s_fmt, &f);
+                if (ret < 0)
+                        return ret;
+
+                if (pxa_camera_check_frame(pix)) {
+                        dev_warn(icd->dev.parent,
+                                 "Inconsistent state. Use S_FMT to repair\n");
+                        return -EINVAL;
+                }
+        }
+
+        if (sense.flags & SOCAM_SENSE_PCLK_CHANGED) {
                 if (sense.pixel_clock > sense.pixel_clock_max) {
-                        dev_err(ici->dev,
+                        dev_err(dev,
                                 "pixel clock %lu set by the camera too high!",
                                 sense.pixel_clock);
                         return -EIO;
@@ -1315,6 +1394,11 @@ static int pxa_camera_set_crop(struct soc_camera_device *icd,
                 recalculate_fifo_timeout(pcdev, sense.pixel_clock);
         }
 
+        icd->user_width = pix->width;
+        icd->user_height = pix->height;
+
+        pxa_camera_setup_cicr(icd, cam->flags, icd->current_fmt->fourcc);
+
         return ret;
 }
 
@@ -1323,6 +1407,8 @@ static int pxa_camera_set_fmt(struct soc_camera_device *icd,
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct pxa_camera_dev *pcdev = ici->priv;
+        struct device *dev = icd->dev.parent;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         const struct soc_camera_data_format *cam_fmt = NULL;
         const struct soc_camera_format_xlate *xlate = NULL;
         struct soc_camera_sense sense = {
@@ -1335,7 +1421,7 @@ static int pxa_camera_set_fmt(struct soc_camera_device *icd,
 
         xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
         if (!xlate) {
-                dev_warn(ici->dev, "Format %x not found\n", pix->pixelformat);
+                dev_warn(dev, "Format %x not found\n", pix->pixelformat);
                 return -EINVAL;
         }
 
@@ -1346,16 +1432,21 @@ static int pxa_camera_set_fmt(struct soc_camera_device *icd,
                 icd->sense = &sense;
 
         cam_f.fmt.pix.pixelformat = cam_fmt->fourcc;
-        ret = icd->ops->set_fmt(icd, &cam_f);
+        ret = v4l2_subdev_call(sd, video, s_fmt, f);
 
         icd->sense = NULL;
 
         if (ret < 0) {
-                dev_warn(ici->dev, "Failed to configure for format %x\n",
+                dev_warn(dev, "Failed to configure for format %x\n",
                          pix->pixelformat);
+        } else if (pxa_camera_check_frame(pix)) {
+                dev_warn(dev,
+                         "Camera driver produced an unsupported frame %dx%d\n",
+                         pix->width, pix->height);
+                ret = -EINVAL;
         } else if (sense.flags & SOCAM_SENSE_PCLK_CHANGED) {
                 if (sense.pixel_clock > sense.pixel_clock_max) {
-                        dev_err(ici->dev,
+                        dev_err(dev,
                                 "pixel clock %lu set by the camera too high!",
                                 sense.pixel_clock);
                         return -EIO;
@@ -1375,6 +1466,7 @@ static int pxa_camera_try_fmt(struct soc_camera_device *icd,
                               struct v4l2_format *f)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         const struct soc_camera_format_xlate *xlate;
         struct v4l2_pix_format *pix = &f->fmt.pix;
         __u32 pixfmt = pix->pixelformat;
@@ -1383,7 +1475,7 @@ static int pxa_camera_try_fmt(struct soc_camera_device *icd,
 
         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
         if (!xlate) {
-                dev_warn(ici->dev, "Format %x not found\n", pixfmt);
+                dev_warn(ici->v4l2_dev.dev, "Format %x not found\n", pixfmt);
                 return -EINVAL;
         }
 
@@ -1395,7 +1487,7 @@ static int pxa_camera_try_fmt(struct soc_camera_device *icd,
          */
         v4l_bound_align_image(&pix->width, 48, 2048, 1,
                               &pix->height, 32, 2048, 0,
-                              xlate->host_fmt->fourcc == V4L2_PIX_FMT_YUV422P ? 4 : 0);
+                              pixfmt == V4L2_PIX_FMT_YUV422P ? 4 : 0);
 
         pix->bytesperline = pix->width *
                 DIV_ROUND_UP(xlate->host_fmt->depth, 8);
@@ -1404,15 +1496,15 @@ static int pxa_camera_try_fmt(struct soc_camera_device *icd,
         /* camera has to see its format, but the user the original one */
         pix->pixelformat = xlate->cam_fmt->fourcc;
         /* limit to sensor capabilities */
-        ret = icd->ops->try_fmt(icd, f);
-        pix->pixelformat = xlate->host_fmt->fourcc;
+        ret = v4l2_subdev_call(sd, video, try_fmt, f);
+        pix->pixelformat = pixfmt;
 
         field = pix->field;
 
         if (field == V4L2_FIELD_ANY) {
                 pix->field = V4L2_FIELD_NONE;
         } else if (field != V4L2_FIELD_NONE) {
-                dev_err(&icd->dev, "Field type %d unsupported.\n", field);
+                dev_err(icd->dev.parent, "Field type %d unsupported.\n", field);
                 return -EINVAL;
         }
 
@@ -1518,6 +1610,7 @@ static struct soc_camera_host_ops pxa_soc_camera_host_ops = {
         .resume         = pxa_camera_resume,
         .set_crop       = pxa_camera_set_crop,
         .get_formats    = pxa_camera_get_formats,
+        .put_formats    = pxa_camera_put_formats,
         .set_fmt        = pxa_camera_set_fmt,
         .try_fmt        = pxa_camera_try_fmt,
         .init_videobuf  = pxa_camera_init_videobuf,
@@ -1575,8 +1668,7 @@ static int __devinit pxa_camera_probe(struct platform_device *pdev)
                 pcdev->mclk = 20000000;
         }
 
-        pcdev->soc_host.dev = &pdev->dev;
-        pcdev->mclk_divisor = mclk_get_divisor(pcdev);
+        pcdev->mclk_divisor = mclk_get_divisor(pdev, pcdev);
 
         INIT_LIST_HEAD(&pcdev->capture);
         spin_lock_init(&pcdev->lock);
@@ -1641,6 +1733,7 @@ static int __devinit pxa_camera_probe(struct platform_device *pdev)
         pcdev->soc_host.drv_name        = PXA_CAM_DRV_NAME;
         pcdev->soc_host.ops             = &pxa_soc_camera_host_ops;
         pcdev->soc_host.priv            = pcdev;
+        pcdev->soc_host.v4l2_dev.dev    = &pdev->dev;
         pcdev->soc_host.nr              = pdev->id;
 
         err = soc_camera_host_register(&pcdev->soc_host);
@@ -1722,3 +1815,4 @@ module_exit(pxa_camera_exit);
 MODULE_DESCRIPTION("PXA27x SoC Camera Host driver");
 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" PXA_CAM_DRV_NAME);
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c
index 1b29487fd254..71145bff94fa 100644
--- a/drivers/media/video/saa7134/saa7134-cards.c
+++ b/drivers/media/video/saa7134/saa7134-cards.c
@@ -4164,7 +4164,7 @@ struct saa7134_board saa7134_boards[] = {
                 /*Dmitry Belimov <d.belimov@gmail.com> */
                 .name           = "Beholder BeholdTV 505 RDS",
                 .audio_clock    = 0x00200000,
-                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3, /* FIXME to MK5 */
+                .tuner_type     = TUNER_PHILIPS_FM1216MK5,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -4229,7 +4229,7 @@ struct saa7134_board saa7134_boards[] = {
                 /*Dmitry Belimov <d.belimov@gmail.com> */
                 .name           = "Beholder BeholdTV 507 RDS",
                 .audio_clock    = 0x00187de7,
-                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3, /* FIXME to MK5 */
+                .tuner_type     = TUNER_PHILIPS_FM1216MK5,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -4380,7 +4380,7 @@ struct saa7134_board saa7134_boards[] = {
                 /* Andrey Melnikoff <temnota@kmv.ru> */
                 .name           = "Beholder BeholdTV 607 FM",
                 .audio_clock    = 0x00187de7,
-                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3, /* FIXME to MK5 */
+                .tuner_type     = TUNER_PHILIPS_FM1216MK5,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -4408,7 +4408,7 @@ struct saa7134_board saa7134_boards[] = {
                 /* Andrey Melnikoff <temnota@kmv.ru> */
                 .name           = "Beholder BeholdTV 609 FM",
                 .audio_clock    = 0x00187de7,
-                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3, /* FIXME to MK5 */
+                .tuner_type     = TUNER_PHILIPS_FM1216MK5,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -4494,7 +4494,7 @@ struct saa7134_board saa7134_boards[] = {
                 /* Andrey Melnikoff <temnota@kmv.ru> */
                 .name           = "Beholder BeholdTV 607 RDS",
                 .audio_clock    = 0x00187de7,
-                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3, /* FIXME to MK5 */
+                .tuner_type     = TUNER_PHILIPS_FM1216MK5,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -4523,7 +4523,7 @@ struct saa7134_board saa7134_boards[] = {
                 /* Andrey Melnikoff <temnota@kmv.ru> */
                 .name           = "Beholder BeholdTV 609 RDS",
                 .audio_clock    = 0x00187de7,
-                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3, /* FIXME to MK5 */
+                .tuner_type     = TUNER_PHILIPS_FM1216MK5,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -4630,7 +4630,7 @@ struct saa7134_board saa7134_boards[] = {
                 /* Alexey Osipov <lion-simba@pridelands.ru> */
                 .name           = "Beholder BeholdTV M6 Extra",
                 .audio_clock    = 0x00187de7,
-                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3, /* FIXME to MK5 */
+                .tuner_type     = TUNER_PHILIPS_FM1216MK5,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -5257,6 +5257,27 @@ struct saa7134_board saa7134_boards[] = {
                         .amux = TV,
                 },
         },
+        [SAA7134_BOARD_ZOLID_HYBRID_PCI] = {
+                .name           = "Zolid Hybrid TV Tuner PCI",
+                .audio_clock    = 0x00187de7,
+                .tuner_type     = TUNER_PHILIPS_TDA8290,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .tuner_config   = 0,
+                .mpeg           = SAA7134_MPEG_DVB,
+                .ts_type        = SAA7134_MPEG_TS_PARALLEL,
+                .inputs         = {{
+                        .name = name_tv,
+                        .vmux = 1,
+                        .amux = TV,
+                        .tv   = 1,
+                } },
+                .radio = {      /* untested */
+                        .name = name_radio,
+                        .amux = TV,
+                },
+        },
 
 };
 
@@ -6390,6 +6411,12 @@ struct pci_device_id saa7134_pci_tbl[] = {
                 .subdevice    = 0x0138, /* LifeView FlyTV Prime30 OEM */
                 .driver_data  = SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM,
         }, {
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
+                .subvendor    = PCI_VENDOR_ID_PHILIPS,
+                .subdevice    = 0x2004,
+                .driver_data  = SAA7134_BOARD_ZOLID_HYBRID_PCI,
+        }, {
                 /* --- boards without eeprom + subsystem ID --- */
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
@@ -7208,22 +7235,22 @@ int saa7134_board_init2(struct saa7134_dev *dev)
                 if (dev->radio_type != UNSET)
                         v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_adap, "tuner", "tuner",
-                                dev->radio_addr);
+                                dev->radio_addr, NULL);
                 if (has_demod)
-                        v4l2_i2c_new_probed_subdev(&dev->v4l2_dev,
+                        v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_adap, "tuner", "tuner",
-                                v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
+                                0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
                 if (dev->tuner_addr == ADDR_UNSET) {
                         enum v4l2_i2c_tuner_type type =
                                 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
 
-                        v4l2_i2c_new_probed_subdev(&dev->v4l2_dev,
+                        v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_adap, "tuner", "tuner",
-                                v4l2_i2c_tuner_addrs(type));
+                                0, v4l2_i2c_tuner_addrs(type));
                 } else {
                         v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_adap, "tuner", "tuner",
-                                dev->tuner_addr);
+                                dev->tuner_addr, NULL);
                 }
         }
 
diff --git a/drivers/media/video/saa7134/saa7134-core.c b/drivers/media/video/saa7134/saa7134-core.c
index cb78c956d810..f87757fccc72 100644
--- a/drivers/media/video/saa7134/saa7134-core.c
+++ b/drivers/media/video/saa7134/saa7134-core.c
@@ -1000,7 +1000,7 @@ static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
                 struct v4l2_subdev *sd =
                         v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
                                 "saa6752hs", "saa6752hs",
-                                saa7134_boards[dev->board].empress_addr);
+                                saa7134_boards[dev->board].empress_addr, NULL);
 
                 if (sd)
                         sd->grp_id = GRP_EMPRESS;
@@ -1009,9 +1009,9 @@ static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
         if (saa7134_boards[dev->board].rds_addr) {
                 struct v4l2_subdev *sd;
 
-                sd = v4l2_i2c_new_probed_subdev_addr(&dev->v4l2_dev,
+                sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_adap, "saa6588", "saa6588",
-                                saa7134_boards[dev->board].rds_addr);
+                                0, I2C_ADDRS(saa7134_boards[dev->board].rds_addr));
                 if (sd) {
                         printk(KERN_INFO "%s: found RDS decoder\n", dev->name);
                         dev->has_rds = 1;
diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c
index ebde21dba7e3..a26e997a9ce6 100644
--- a/drivers/media/video/saa7134/saa7134-dvb.c
+++ b/drivers/media/video/saa7134/saa7134-dvb.c
@@ -1007,12 +1007,29 @@ static struct tda18271_config hcw_tda18271_config = {
         .std_map = &hauppauge_tda18271_std_map,
         .gate    = TDA18271_GATE_ANALOG,
         .config  = 3,
+        .output_opt = TDA18271_OUTPUT_LT_OFF,
 };
 
 static struct tda829x_config tda829x_no_probe = {
         .probe_tuner = TDA829X_DONT_PROBE,
 };
 
+static struct tda10048_config zolid_tda10048_config = {
+        .demod_address    = 0x10 >> 1,
+        .output_mode      = TDA10048_PARALLEL_OUTPUT,
+        .fwbulkwritelen   = TDA10048_BULKWRITE_200,
+        .inversion        = TDA10048_INVERSION_ON,
+        .dtv6_if_freq_khz = TDA10048_IF_3300,
+        .dtv7_if_freq_khz = TDA10048_IF_3500,
+        .dtv8_if_freq_khz = TDA10048_IF_4000,
+        .clk_freq_khz     = TDA10048_CLK_16000,
+        .disable_gate_access = 1,
+};
+
+static struct tda18271_config zolid_tda18271_config = {
+        .gate    = TDA18271_GATE_ANALOG,
+};
+
 /* ==================================================================
  * Core code
  */
@@ -1488,6 +1505,19 @@ static int dvb_init(struct saa7134_dev *dev)
                                         __func__);
 
                 break;
+        case SAA7134_BOARD_ZOLID_HYBRID_PCI:
+                fe0->dvb.frontend = dvb_attach(tda10048_attach,
+                                               &zolid_tda10048_config,
+                                               &dev->i2c_adap);
+                if (fe0->dvb.frontend != NULL) {
+                        dvb_attach(tda829x_attach, fe0->dvb.frontend,
+                                   &dev->i2c_adap, 0x4b,
+                                   &tda829x_no_probe);
+                        dvb_attach(tda18271_attach, fe0->dvb.frontend,
+                                   0x60, &dev->i2c_adap,
+                                   &zolid_tda18271_config);
+                }
+                break;
         default:
                 wprintk("Huh? unknown DVB card?\n");
                 break;
diff --git a/drivers/media/video/saa7134/saa7134-input.c b/drivers/media/video/saa7134/saa7134-input.c
index e1e83c7b966e..a0e8c62e6ae1 100644
--- a/drivers/media/video/saa7134/saa7134-input.c
+++ b/drivers/media/video/saa7134/saa7134-input.c
@@ -251,6 +251,10 @@ static int get_key_beholdm6xx(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
         if (data[10] != 0x6b && data[11] != 0x86 && disable_other_ir)
                 return 0;
 
+        /* Wrong data decode fix */
+        if (data[9] != (unsigned char)(~data[8]))
+                return 0;
+
         *ir_key = data[9];
         *ir_raw = data[9];
 
diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h
index d18bb9643856..6ee3e9b7769e 100644
--- a/drivers/media/video/saa7134/saa7134.h
+++ b/drivers/media/video/saa7134/saa7134.h
@@ -296,6 +296,7 @@ struct saa7134_format {
 #define SAA7134_BOARD_AVERMEDIA_STUDIO_505  170
 #define SAA7134_BOARD_BEHOLD_X7             171
 #define SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM 172
+#define SAA7134_BOARD_ZOLID_HYBRID_PCI          173
 
 #define SAA7134_MAXBOARDS 32
 #define SAA7134_INPUT_MAX 8
diff --git a/drivers/media/video/saa7164/Kconfig b/drivers/media/video/saa7164/Kconfig
new file mode 100644
index 000000000000..353263725172
--- /dev/null
+++ b/drivers/media/video/saa7164/Kconfig
@@ -0,0 +1,18 @@
+config VIDEO_SAA7164
+        tristate "NXP SAA7164 support"
+        depends on DVB_CORE && PCI && I2C
+        select I2C_ALGOBIT
+        select FW_LOADER
+        select VIDEO_TUNER
+        select VIDEO_TVEEPROM
+        select VIDEOBUF_DVB
+        select DVB_TDA10048 if !DVB_FE_CUSTOMISE
+        select DVB_S5H1411 if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_TDA18271 if !MEDIA_TUNER_CUSTOMISE
+        ---help---
+          This is a video4linux driver for NXP SAA7164 based
+          TV cards.
+
+          To compile this driver as a module, choose M here: the
+          module will be called saa7164
+
diff --git a/drivers/media/video/saa7164/Makefile b/drivers/media/video/saa7164/Makefile
new file mode 100644
index 000000000000..4b329fd42add
--- /dev/null
+++ b/drivers/media/video/saa7164/Makefile
@@ -0,0 +1,12 @@
+saa7164-objs    := saa7164-cards.o saa7164-core.o saa7164-i2c.o saa7164-dvb.o \
+                        saa7164-fw.o saa7164-bus.o saa7164-cmd.o saa7164-api.o \
+                        saa7164-buffer.o
+
+obj-$(CONFIG_VIDEO_SAA7164) += saa7164.o
+
+EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
+EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
+EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
+
+EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m)
diff --git a/drivers/media/video/saa7164/saa7164-api.c b/drivers/media/video/saa7164/saa7164-api.c
new file mode 100644
index 000000000000..bb6df1b276be
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-api.c
@@ -0,0 +1,600 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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/wait.h>
+
+#include "saa7164.h"
+
+int saa7164_api_transition_port(struct saa7164_tsport *port, u8 mode)
+{
+        int ret;
+
+        ret = saa7164_cmd_send(port->dev, port->hwcfg.unitid, SET_CUR,
+                SAA_STATE_CONTROL, sizeof(mode), &mode);
+        if (ret != SAA_OK)
+                printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
+
+        return ret;
+}
+
+int saa7164_api_get_fw_version(struct saa7164_dev *dev, u32 *version)
+{
+        int ret;
+
+        ret = saa7164_cmd_send(dev, 0, GET_CUR,
+                GET_FW_VERSION_CONTROL, sizeof(u32), version);
+        if (ret != SAA_OK)
+                printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
+
+        return ret;
+}
+
+int saa7164_api_read_eeprom(struct saa7164_dev *dev, u8 *buf, int buflen)
+{
+        u8 reg[] = { 0x0f, 0x00 };
+
+        if (buflen < 128)
+                return -ENOMEM;
+
+        /* Assumption: Hauppauge eeprom is at 0xa0 on on bus 0 */
+        /* TODO: Pull the details from the boards struct */
+        return saa7164_api_i2c_read(&dev->i2c_bus[0], 0xa0 >> 1, sizeof(reg),
+                &reg[0], 128, buf);
+}
+
+
+int saa7164_api_configure_port_mpeg2ts(struct saa7164_dev *dev,
+        struct saa7164_tsport *port,
+        tmComResTSFormatDescrHeader_t *tsfmt)
+{
+        dprintk(DBGLVL_API, "    bFormatIndex = 0x%x\n", tsfmt->bFormatIndex);
+        dprintk(DBGLVL_API, "    bDataOffset  = 0x%x\n", tsfmt->bDataOffset);
+        dprintk(DBGLVL_API, "    bPacketLength= 0x%x\n", tsfmt->bPacketLength);
+        dprintk(DBGLVL_API, "    bStrideLength= 0x%x\n", tsfmt->bStrideLength);
+        dprintk(DBGLVL_API, "    bguid        = (....)\n");
+
+        /* Cache the hardware configuration in the port */
+
+        port->bufcounter = port->hwcfg.BARLocation;
+        port->pitch = port->hwcfg.BARLocation + (2 * sizeof(u32));
+        port->bufsize = port->hwcfg.BARLocation + (3 * sizeof(u32));
+        port->bufoffset = port->hwcfg.BARLocation + (4 * sizeof(u32));
+        port->bufptr32l = port->hwcfg.BARLocation +
+                (4 * sizeof(u32)) +
+                (sizeof(u32) * port->hwcfg.buffercount) + sizeof(u32);
+        port->bufptr32h = port->hwcfg.BARLocation +
+                (4 * sizeof(u32)) +
+                (sizeof(u32) * port->hwcfg.buffercount);
+        port->bufptr64 = port->hwcfg.BARLocation +
+                (4 * sizeof(u32)) +
+                (sizeof(u32) * port->hwcfg.buffercount);
+        dprintk(DBGLVL_API, "   = port->hwcfg.BARLocation = 0x%x\n",
+                port->hwcfg.BARLocation);
+
+        dprintk(DBGLVL_API, "   = VS_FORMAT_MPEGTS (becomes dev->ts[%d])\n",
+                port->nr);
+
+        return 0;
+}
+
+int saa7164_api_dump_subdevs(struct saa7164_dev *dev, u8 *buf, int len)
+{
+        struct saa7164_tsport *port = 0;
+        u32 idx, next_offset;
+        int i;
+        tmComResDescrHeader_t *hdr, *t;
+        tmComResExtDevDescrHeader_t *exthdr;
+        tmComResPathDescrHeader_t *pathhdr;
+        tmComResAntTermDescrHeader_t *anttermhdr;
+        tmComResTunerDescrHeader_t *tunerunithdr;
+        tmComResDMATermDescrHeader_t *vcoutputtermhdr;
+        tmComResTSFormatDescrHeader_t *tsfmt;
+        u32 currpath = 0;
+
+        dprintk(DBGLVL_API,
+                "%s(?,?,%d) sizeof(tmComResDescrHeader_t) = %d bytes\n",
+                __func__, len, (u32)sizeof(tmComResDescrHeader_t));
+
+        for (idx = 0; idx < (len - sizeof(tmComResDescrHeader_t)); ) {
+
+                hdr = (tmComResDescrHeader_t *)(buf + idx);
+
+                if (hdr->type != CS_INTERFACE)
+                        return SAA_ERR_NOT_SUPPORTED;
+
+                dprintk(DBGLVL_API, "@ 0x%x = \n", idx);
+                switch (hdr->subtype) {
+                case GENERAL_REQUEST:
+                        dprintk(DBGLVL_API, " GENERAL_REQUEST\n");
+                        break;
+                case VC_TUNER_PATH:
+                        dprintk(DBGLVL_API, " VC_TUNER_PATH\n");
+                        pathhdr = (tmComResPathDescrHeader_t *)(buf + idx);
+                        dprintk(DBGLVL_API, "  pathid = 0x%x\n",
+                                pathhdr->pathid);
+                        currpath = pathhdr->pathid;
+                        break;
+                case VC_INPUT_TERMINAL:
+                        dprintk(DBGLVL_API, " VC_INPUT_TERMINAL\n");
+                        anttermhdr =
+                                (tmComResAntTermDescrHeader_t *)(buf + idx);
+                        dprintk(DBGLVL_API, "  terminalid   = 0x%x\n",
+                                anttermhdr->terminalid);
+                        dprintk(DBGLVL_API, "  terminaltype = 0x%x\n",
+                                anttermhdr->terminaltype);
+                        switch (anttermhdr->terminaltype) {
+                        case ITT_ANTENNA:
+                                dprintk(DBGLVL_API, "   = ITT_ANTENNA\n");
+                                break;
+                        case LINE_CONNECTOR:
+                                dprintk(DBGLVL_API, "   = LINE_CONNECTOR\n");
+                                break;
+                        case SPDIF_CONNECTOR:
+                                dprintk(DBGLVL_API, "   = SPDIF_CONNECTOR\n");
+                                break;
+                        case COMPOSITE_CONNECTOR:
+                                dprintk(DBGLVL_API,
+                                        "   = COMPOSITE_CONNECTOR\n");
+                                break;
+                        case SVIDEO_CONNECTOR:
+                                dprintk(DBGLVL_API, "   = SVIDEO_CONNECTOR\n");
+                                break;
+                        case COMPONENT_CONNECTOR:
+                                dprintk(DBGLVL_API,
+                                        "   = COMPONENT_CONNECTOR\n");
+                                break;
+                        case STANDARD_DMA:
+                                dprintk(DBGLVL_API, "   = STANDARD_DMA\n");
+                                break;
+                        default:
+                                dprintk(DBGLVL_API, "   = undefined (0x%x)\n",
+                                        anttermhdr->terminaltype);
+                        }
+                        dprintk(DBGLVL_API, "  assocterminal= 0x%x\n",
+                                anttermhdr->assocterminal);
+                        dprintk(DBGLVL_API, "  iterminal    = 0x%x\n",
+                                anttermhdr->iterminal);
+                        dprintk(DBGLVL_API, "  controlsize  = 0x%x\n",
+                                anttermhdr->controlsize);
+                        break;
+                case VC_OUTPUT_TERMINAL:
+                        dprintk(DBGLVL_API, " VC_OUTPUT_TERMINAL\n");
+                        vcoutputtermhdr =
+                                (tmComResDMATermDescrHeader_t *)(buf + idx);
+                        dprintk(DBGLVL_API, "  unitid = 0x%x\n",
+                                vcoutputtermhdr->unitid);
+                        dprintk(DBGLVL_API, "  terminaltype = 0x%x\n",
+                                vcoutputtermhdr->terminaltype);
+                        switch (vcoutputtermhdr->terminaltype) {
+                        case ITT_ANTENNA:
+                                dprintk(DBGLVL_API, "   = ITT_ANTENNA\n");
+                                break;
+                        case LINE_CONNECTOR:
+                                dprintk(DBGLVL_API, "   = LINE_CONNECTOR\n");
+                                break;
+                        case SPDIF_CONNECTOR:
+                                dprintk(DBGLVL_API, "   = SPDIF_CONNECTOR\n");
+                                break;
+                        case COMPOSITE_CONNECTOR:
+                                dprintk(DBGLVL_API,
+                                        "   = COMPOSITE_CONNECTOR\n");
+                                break;
+                        case SVIDEO_CONNECTOR:
+                                dprintk(DBGLVL_API, "   = SVIDEO_CONNECTOR\n");
+                                break;
+                        case COMPONENT_CONNECTOR:
+                                dprintk(DBGLVL_API,
+                                        "   = COMPONENT_CONNECTOR\n");
+                                break;
+                        case STANDARD_DMA:
+                                dprintk(DBGLVL_API, "   = STANDARD_DMA\n");
+                                break;
+                        default:
+                                dprintk(DBGLVL_API, "   = undefined (0x%x)\n",
+                                        vcoutputtermhdr->terminaltype);
+                        }
+                        dprintk(DBGLVL_API, "  assocterminal= 0x%x\n",
+                                vcoutputtermhdr->assocterminal);
+                        dprintk(DBGLVL_API, "  sourceid     = 0x%x\n",
+                                vcoutputtermhdr->sourceid);
+                        dprintk(DBGLVL_API, "  iterminal    = 0x%x\n",
+                                vcoutputtermhdr->iterminal);
+                        dprintk(DBGLVL_API, "  BARLocation  = 0x%x\n",
+                                vcoutputtermhdr->BARLocation);
+                        dprintk(DBGLVL_API, "  flags        = 0x%x\n",
+                                vcoutputtermhdr->flags);
+                        dprintk(DBGLVL_API, "  interruptid  = 0x%x\n",
+                                vcoutputtermhdr->interruptid);
+                        dprintk(DBGLVL_API, "  buffercount  = 0x%x\n",
+                                vcoutputtermhdr->buffercount);
+                        dprintk(DBGLVL_API, "  metadatasize = 0x%x\n",
+                                vcoutputtermhdr->metadatasize);
+                        dprintk(DBGLVL_API, "  controlsize  = 0x%x\n",
+                                vcoutputtermhdr->controlsize);
+                        dprintk(DBGLVL_API, "  numformats   = 0x%x\n",
+                                vcoutputtermhdr->numformats);
+
+                        t = (tmComResDescrHeader_t *)
+                                ((tmComResDMATermDescrHeader_t *)(buf + idx));
+                        next_offset = idx + (vcoutputtermhdr->len);
+                        for (i = 0; i < vcoutputtermhdr->numformats; i++) {
+                                t = (tmComResDescrHeader_t *)
+                                        (buf + next_offset);
+                                switch (t->subtype) {
+                                case VS_FORMAT_MPEG2TS:
+                                        tsfmt =
+                                        (tmComResTSFormatDescrHeader_t *)t;
+                                        if (currpath == 1)
+                                                port = &dev->ts1;
+                                        else
+                                                port = &dev->ts2;
+                                        memcpy(&port->hwcfg, vcoutputtermhdr,
+                                                sizeof(*vcoutputtermhdr));
+                                        saa7164_api_configure_port_mpeg2ts(dev,
+                                                port, tsfmt);
+                                        break;
+                                case VS_FORMAT_MPEG2PS:
+                                        dprintk(DBGLVL_API,
+                                                "   = VS_FORMAT_MPEG2PS\n");
+                                        break;
+                                case VS_FORMAT_VBI:
+                                        dprintk(DBGLVL_API,
+                                                "   = VS_FORMAT_VBI\n");
+                                        break;
+                                case VS_FORMAT_RDS:
+                                        dprintk(DBGLVL_API,
+                                                "   = VS_FORMAT_RDS\n");
+                                        break;
+                                case VS_FORMAT_UNCOMPRESSED:
+                                        dprintk(DBGLVL_API,
+                                        "   = VS_FORMAT_UNCOMPRESSED\n");
+                                        break;
+                                case VS_FORMAT_TYPE:
+                                        dprintk(DBGLVL_API,
+                                                "   = VS_FORMAT_TYPE\n");
+                                        break;
+                                default:
+                                        dprintk(DBGLVL_API,
+                                                "   = undefined (0x%x)\n",
+                                                t->subtype);
+                                }
+                                next_offset += t->len;
+                        }
+
+                        break;
+                case TUNER_UNIT:
+                        dprintk(DBGLVL_API, " TUNER_UNIT\n");
+                        tunerunithdr =
+                                (tmComResTunerDescrHeader_t *)(buf + idx);
+                        dprintk(DBGLVL_API, "  unitid = 0x%x\n",
+                                tunerunithdr->unitid);
+                        dprintk(DBGLVL_API, "  sourceid = 0x%x\n",
+                                tunerunithdr->sourceid);
+                        dprintk(DBGLVL_API, "  iunit = 0x%x\n",
+                                tunerunithdr->iunit);
+                        dprintk(DBGLVL_API, "  tuningstandards = 0x%x\n",
+                                tunerunithdr->tuningstandards);
+                        dprintk(DBGLVL_API, "  controlsize = 0x%x\n",
+                                tunerunithdr->controlsize);
+                        dprintk(DBGLVL_API, "  controls = 0x%x\n",
+                                tunerunithdr->controls);
+                        break;
+                case VC_SELECTOR_UNIT:
+                        dprintk(DBGLVL_API, " VC_SELECTOR_UNIT\n");
+                        break;
+                case VC_PROCESSING_UNIT:
+                        dprintk(DBGLVL_API, " VC_PROCESSING_UNIT\n");
+                        break;
+                case FEATURE_UNIT:
+                        dprintk(DBGLVL_API, " FEATURE_UNIT\n");
+                        break;
+                case ENCODER_UNIT:
+                        dprintk(DBGLVL_API, " ENCODER_UNIT\n");
+                        break;
+                case EXTENSION_UNIT:
+                        dprintk(DBGLVL_API, " EXTENSION_UNIT\n");
+                        exthdr = (tmComResExtDevDescrHeader_t *)(buf + idx);
+                        dprintk(DBGLVL_API, "  unitid = 0x%x\n",
+                                exthdr->unitid);
+                        dprintk(DBGLVL_API, "  deviceid = 0x%x\n",
+                                exthdr->deviceid);
+                        dprintk(DBGLVL_API, "  devicetype = 0x%x\n",
+                                exthdr->devicetype);
+                        if (exthdr->devicetype & 0x1)
+                                dprintk(DBGLVL_API, "   = Decoder Device\n");
+                        if (exthdr->devicetype & 0x2)
+                                dprintk(DBGLVL_API, "   = GPIO Source\n");
+                        if (exthdr->devicetype & 0x4)
+                                dprintk(DBGLVL_API, "   = Video Decoder\n");
+                        if (exthdr->devicetype & 0x8)
+                                dprintk(DBGLVL_API, "   = Audio Decoder\n");
+                        if (exthdr->devicetype & 0x20)
+                                dprintk(DBGLVL_API, "   = Crossbar\n");
+                        if (exthdr->devicetype & 0x40)
+                                dprintk(DBGLVL_API, "   = Tuner\n");
+                        if (exthdr->devicetype & 0x80)
+                                dprintk(DBGLVL_API, "   = IF PLL\n");
+                        if (exthdr->devicetype & 0x100)
+                                dprintk(DBGLVL_API, "   = Demodulator\n");
+                        if (exthdr->devicetype & 0x200)
+                                dprintk(DBGLVL_API, "   = RDS Decoder\n");
+                        if (exthdr->devicetype & 0x400)
+                                dprintk(DBGLVL_API, "   = Encoder\n");
+                        if (exthdr->devicetype & 0x800)
+                                dprintk(DBGLVL_API, "   = IR Decoder\n");
+                        if (exthdr->devicetype & 0x1000)
+                                dprintk(DBGLVL_API, "   = EEPROM\n");
+                        if (exthdr->devicetype & 0x2000)
+                                dprintk(DBGLVL_API,
+                                        "   = VBI Decoder\n");
+                        if (exthdr->devicetype & 0x10000)
+                                dprintk(DBGLVL_API,
+                                        "   = Streaming Device\n");
+                        if (exthdr->devicetype & 0x20000)
+                                dprintk(DBGLVL_API,
+                                        "   = DRM Device\n");
+                        if (exthdr->devicetype & 0x40000000)
+                                dprintk(DBGLVL_API,
+                                        "   = Generic Device\n");
+                        if (exthdr->devicetype & 0x80000000)
+                                dprintk(DBGLVL_API,
+                                        "   = Config Space Device\n");
+                        dprintk(DBGLVL_API, "  numgpiopins = 0x%x\n",
+                                exthdr->numgpiopins);
+                        dprintk(DBGLVL_API, "  numgpiogroups = 0x%x\n",
+                                exthdr->numgpiogroups);
+                        dprintk(DBGLVL_API, "  controlsize = 0x%x\n",
+                                exthdr->controlsize);
+                        break;
+                case PVC_INFRARED_UNIT:
+                        dprintk(DBGLVL_API, " PVC_INFRARED_UNIT\n");
+                        break;
+                case DRM_UNIT:
+                        dprintk(DBGLVL_API, " DRM_UNIT\n");
+                        break;
+                default:
+                        dprintk(DBGLVL_API, "default %d\n", hdr->subtype);
+                }
+
+                dprintk(DBGLVL_API, " 1.%x\n", hdr->len);
+                dprintk(DBGLVL_API, " 2.%x\n", hdr->type);
+                dprintk(DBGLVL_API, " 3.%x\n", hdr->subtype);
+                dprintk(DBGLVL_API, " 4.%x\n", hdr->unitid);
+
+                idx += hdr->len;
+        }
+
+        return 0;
+}
+
+int saa7164_api_enum_subdevs(struct saa7164_dev *dev)
+{
+        int ret;
+        u32 buflen = 0;
+        u8 *buf;
+
+        dprintk(DBGLVL_API, "%s()\n", __func__);
+
+        /* Get the total descriptor length */
+        ret = saa7164_cmd_send(dev, 0, GET_LEN,
+                GET_DESCRIPTORS_CONTROL, sizeof(buflen), &buflen);
+        if (ret != SAA_OK)
+                printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
+
+        dprintk(DBGLVL_API, "%s() total descriptor size = %d bytes.\n",
+                __func__, buflen);
+
+        /* Allocate enough storage for all of the descs */
+        buf = kzalloc(buflen, GFP_KERNEL);
+        if (buf == NULL)
+                return SAA_ERR_NO_RESOURCES;
+
+        /* Retrieve them */
+        ret = saa7164_cmd_send(dev, 0, GET_CUR,
+                GET_DESCRIPTORS_CONTROL, buflen, buf);
+        if (ret != SAA_OK) {
+                printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__, ret);
+                goto out;
+        }
+
+        if (debug & DBGLVL_API)
+                saa7164_dumphex16(dev, buf, (buflen/16)*16);
+
+        saa7164_api_dump_subdevs(dev, buf, buflen);
+
+out:
+        kfree(buf);
+        return ret;
+}
+
+int saa7164_api_i2c_read(struct saa7164_i2c *bus, u8 addr, u32 reglen, u8 *reg,
+        u32 datalen, u8 *data)
+{
+        struct saa7164_dev *dev = bus->dev;
+        u16 len = 0;
+        int unitid;
+        u32 regval;
+        u8 buf[256];
+        int ret;
+
+        dprintk(DBGLVL_API, "%s()\n", __func__);
+
+        if (reglen > 4)
+                return -EIO;
+
+        if (reglen == 1)
+                regval = *(reg);
+        else
+        if (reglen == 2)
+                regval = ((*(reg) << 8) || *(reg+1));
+        else
+        if (reglen == 3)
+                regval = ((*(reg) << 16) | (*(reg+1) << 8) | *(reg+2));
+        else
+        if (reglen == 4)
+                regval = ((*(reg) << 24) | (*(reg+1) << 16) |
+                        (*(reg+2) << 8) | *(reg+3));
+
+        /* Prepare the send buffer */
+        /* Bytes 00-03 source register length
+         *       04-07 source bytes to read
+         *       08... register address
+         */
+        memset(buf, 0, sizeof(buf));
+        memcpy((buf + 2 * sizeof(u32) + 0), reg, reglen);
+        *((u32 *)(buf + 0 * sizeof(u32))) = reglen;
+        *((u32 *)(buf + 1 * sizeof(u32))) = datalen;
+
+        unitid = saa7164_i2caddr_to_unitid(bus, addr);
+        if (unitid < 0) {
+                printk(KERN_ERR
+                        "%s() error, cannot translate regaddr 0x%x to unitid\n",
+                        __func__, addr);
+                return -EIO;
+        }
+
+        ret = saa7164_cmd_send(bus->dev, unitid, GET_LEN,
+                EXU_REGISTER_ACCESS_CONTROL, sizeof(len), &len);
+        if (ret != SAA_OK) {
+                printk(KERN_ERR "%s() error, ret(1) = 0x%x\n", __func__, ret);
+                return -EIO;
+        }
+
+        dprintk(DBGLVL_API, "%s() len = %d bytes\n", __func__, len);
+
+        if (debug & DBGLVL_I2C)
+                saa7164_dumphex16(dev, buf, 2 * 16);
+
+        ret = saa7164_cmd_send(bus->dev, unitid, GET_CUR,
+                EXU_REGISTER_ACCESS_CONTROL, len, &buf);
+        if (ret != SAA_OK)
+                printk(KERN_ERR "%s() error, ret(2) = 0x%x\n", __func__, ret);
+        else {
+                if (debug & DBGLVL_I2C)
+                        saa7164_dumphex16(dev, buf, sizeof(buf));
+                memcpy(data, (buf + 2 * sizeof(u32) + reglen), datalen);
+        }
+
+        return ret == SAA_OK ? 0 : -EIO;
+}
+
+/* For a given 8 bit i2c address device, write the buffer */
+int saa7164_api_i2c_write(struct saa7164_i2c *bus, u8 addr, u32 datalen,
+        u8 *data)
+{
+        struct saa7164_dev *dev = bus->dev;
+        u16 len = 0;
+        int unitid;
+        int reglen;
+        u8 buf[256];
+        int ret;
+
+        dprintk(DBGLVL_API, "%s()\n", __func__);
+
+        if ((datalen == 0) || (datalen > 232))
+                return -EIO;
+
+        memset(buf, 0, sizeof(buf));
+
+        unitid = saa7164_i2caddr_to_unitid(bus, addr);
+        if (unitid < 0) {
+                printk(KERN_ERR
+                        "%s() error, cannot translate regaddr 0x%x to unitid\n",
+                        __func__, addr);
+                return -EIO;
+        }
+
+        reglen = saa7164_i2caddr_to_reglen(bus, addr);
+        if (unitid < 0) {
+                printk(KERN_ERR
+                        "%s() error, cannot translate regaddr to reglen\n",
+                        __func__);
+                return -EIO;
+        }
+
+        ret = saa7164_cmd_send(bus->dev, unitid, GET_LEN,
+                EXU_REGISTER_ACCESS_CONTROL, sizeof(len), &len);
+        if (ret != SAA_OK) {
+                printk(KERN_ERR "%s() error, ret(1) = 0x%x\n", __func__, ret);
+                return -EIO;
+        }
+
+        dprintk(DBGLVL_API, "%s() len = %d bytes\n", __func__, len);
+
+        /* Prepare the send buffer */
+        /* Bytes 00-03 dest register length
+         *       04-07 dest bytes to write
+         *       08... register address
+         */
+        *((u32 *)(buf + 0 * sizeof(u32))) = reglen;
+        *((u32 *)(buf + 1 * sizeof(u32))) = datalen - reglen;
+        memcpy((buf + 2 * sizeof(u32)), data, datalen);
+
+        if (debug & DBGLVL_I2C)
+                saa7164_dumphex16(dev, buf, sizeof(buf));
+
+        ret = saa7164_cmd_send(bus->dev, unitid, SET_CUR,
+                EXU_REGISTER_ACCESS_CONTROL, len, &buf);
+        if (ret != SAA_OK)
+                printk(KERN_ERR "%s() error, ret(2) = 0x%x\n", __func__, ret);
+
+        return ret == SAA_OK ? 0 : -EIO;
+}
+
+
+int saa7164_api_modify_gpio(struct saa7164_dev *dev, u8 unitid,
+        u8 pin, u8 state)
+{
+        int ret;
+        tmComResGPIO_t t;
+
+        dprintk(DBGLVL_API, "%s(0x%x, %d, %d)\n",
+                __func__, unitid, pin, state);
+
+        if ((pin > 7) || (state > 2))
+                return SAA_ERR_BAD_PARAMETER;
+
+        t.pin = pin;
+        t.state = state;
+
+        ret = saa7164_cmd_send(dev, unitid, SET_CUR,
+                EXU_GPIO_CONTROL, sizeof(t), &t);
+        if (ret != SAA_OK)
+                printk(KERN_ERR "%s() error, ret = 0x%x\n",
+                        __func__, ret);
+
+        return ret;
+}
+
+int saa7164_api_set_gpiobit(struct saa7164_dev *dev, u8 unitid,
+        u8 pin)
+{
+        return saa7164_api_modify_gpio(dev, unitid, pin, 1);
+}
+
+int saa7164_api_clear_gpiobit(struct saa7164_dev *dev, u8 unitid,
+        u8 pin)
+{
+        return saa7164_api_modify_gpio(dev, unitid, pin, 0);
+}
+
+
+
diff --git a/drivers/media/video/saa7164/saa7164-buffer.c b/drivers/media/video/saa7164/saa7164-buffer.c
new file mode 100644
index 000000000000..9ca5c83d165b
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-buffer.c
@@ -0,0 +1,155 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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 "saa7164.h"
+
+/* The PCI address space for buffer handling looks like this:
+
+ +-u32 wide-------------+
+ |                      +
+ +-u64 wide------------------------------------+
+ +                                             +
+ +----------------------+
+ | CurrentBufferPtr     + Pointer to current PCI buffer >-+
+ +----------------------+                                 |
+ | Unused               +                                 |
+ +----------------------+                                 |
+ | Pitch                + = 188 (bytes)                   |
+ +----------------------+                                 |
+ | PCI buffer size      + = pitch * number of lines (312) |
+ +----------------------+                                 |
+ |0| Buf0 Write Offset  +                                 |
+ +----------------------+                                 v
+ |1| Buf1 Write Offset  +                                 |
+ +----------------------+                                 |
+ |2| Buf2 Write Offset  +                                 |
+ +----------------------+                                 |
+ |3| Buf3 Write Offset  +                                 |
+ +----------------------+                                 |
+ ... More write offsets                                   |
+ +---------------------------------------------+          |
+ +0| set of ptrs to PCI pagetables             +          |
+ +---------------------------------------------+          |
+ +1| set of ptrs to PCI pagetables             + <--------+
+ +---------------------------------------------+
+ +2| set of ptrs to PCI pagetables             +
+ +---------------------------------------------+
+ +3| set of ptrs to PCI pagetables             + >--+
+ +---------------------------------------------+    |
+ ... More buffer pointers                           |  +----------------+
+                                                    +->| pt[0] TS data  |
+                                                    |  +----------------+
+                                                    |
+                                                    |  +----------------+
+                                                    +->| pt[1] TS data  |
+                                                    |  +----------------+
+                                                    | etc
+ */
+
+/* Allocate a new buffer structure and associated PCI space in bytes.
+ * len must be a multiple of sizeof(u64)
+ */
+struct saa7164_buffer *saa7164_buffer_alloc(struct saa7164_tsport *port,
+        u32 len)
+{
+        struct saa7164_buffer *buf = 0;
+        struct saa7164_dev *dev = port->dev;
+        int i;
+
+        if ((len == 0) || (len >= 65536) || (len % sizeof(u64))) {
+                log_warn("%s() SAA_ERR_BAD_PARAMETER\n", __func__);
+                goto ret;
+        }
+
+        buf = kzalloc(sizeof(struct saa7164_buffer), GFP_KERNEL);
+        if (buf == NULL) {
+                log_warn("%s() SAA_ERR_NO_RESOURCES\n", __func__);
+                goto ret;
+        }
+
+        buf->port = port;
+        buf->flags = SAA7164_BUFFER_FREE;
+        /* TODO: arg len is being ignored */
+        buf->pci_size = SAA7164_PT_ENTRIES * 0x1000;
+        buf->pt_size = (SAA7164_PT_ENTRIES * sizeof(u64)) + 0x1000;
+
+        /* Allocate contiguous memory */
+        buf->cpu = pci_alloc_consistent(port->dev->pci, buf->pci_size,
+                &buf->dma);
+        if (!buf->cpu)
+                goto fail1;
+
+        buf->pt_cpu = pci_alloc_consistent(port->dev->pci, buf->pt_size,
+                &buf->pt_dma);
+        if (!buf->pt_cpu)
+                goto fail2;
+
+        /* init the buffers to a known pattern, easier during debugging */
+        memset(buf->cpu, 0xff, buf->pci_size);
+        memset(buf->pt_cpu, 0xff, buf->pt_size);
+
+        dprintk(DBGLVL_BUF, "%s()   allocated buffer @ 0x%p\n", __func__, buf);
+        dprintk(DBGLVL_BUF, "  pci_cpu @ 0x%p    dma @ 0x%08lx len = 0x%x\n",
+                buf->cpu, (long)buf->dma, buf->pci_size);
+        dprintk(DBGLVL_BUF, "   pt_cpu @ 0x%p pt_dma @ 0x%08lx len = 0x%x\n",
+                buf->pt_cpu, (long)buf->pt_dma, buf->pt_size);
+
+        /* Format the Page Table Entries to point into the data buffer */
+        for (i = 0 ; i < SAA7164_PT_ENTRIES; i++) {
+
+                *(buf->pt_cpu + i) = buf->dma + (i * 0x1000); /* TODO */
+
+        }
+
+        goto ret;
+
+fail2:
+        pci_free_consistent(port->dev->pci, buf->pci_size, buf->cpu, buf->dma);
+fail1:
+        kfree(buf);
+
+        buf = 0;
+ret:
+        return buf;
+}
+
+int saa7164_buffer_dealloc(struct saa7164_tsport *port,
+        struct saa7164_buffer *buf)
+{
+        struct saa7164_dev *dev = port->dev;
+
+        if ((buf == 0) || (port == 0))
+                return SAA_ERR_BAD_PARAMETER;
+
+        dprintk(DBGLVL_BUF, "%s() deallocating buffer @ 0x%p\n", __func__, buf);
+
+        if (buf->flags != SAA7164_BUFFER_FREE)
+                log_warn(" freeing a non-free buffer\n");
+
+        pci_free_consistent(port->dev->pci, buf->pci_size, buf->cpu, buf->dma);
+        pci_free_consistent(port->dev->pci, buf->pt_size, buf->pt_cpu,
+                buf->pt_dma);
+
+        kfree(buf);
+
+        return SAA_OK;
+}
+
diff --git a/drivers/media/video/saa7164/saa7164-bus.c b/drivers/media/video/saa7164/saa7164-bus.c
new file mode 100644
index 000000000000..83a04640a25a
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-bus.c
@@ -0,0 +1,448 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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 "saa7164.h"
+
+/* The message bus to/from the firmware is a ring buffer in PCI address
+ * space. Establish the defaults.
+ */
+int saa7164_bus_setup(struct saa7164_dev *dev)
+{
+        tmComResBusInfo_t *b    = &dev->bus;
+
+        mutex_init(&b->lock);
+
+        b->Type                 = TYPE_BUS_PCIe;
+        b->m_wMaxReqSize        = SAA_DEVICE_MAXREQUESTSIZE;
+
+        b->m_pdwSetRing         = (u8 *)(dev->bmmio +
+                ((u32)dev->busdesc.CommandRing));
+
+        b->m_dwSizeSetRing      = SAA_DEVICE_BUFFERBLOCKSIZE;
+
+        b->m_pdwGetRing         = (u8 *)(dev->bmmio +
+                ((u32)dev->busdesc.ResponseRing));
+
+        b->m_dwSizeGetRing      = SAA_DEVICE_BUFFERBLOCKSIZE;
+
+        b->m_pdwSetWritePos     = (u32 *)((u8 *)(dev->bmmio +
+                ((u32)dev->intfdesc.BARLocation) + (2 * sizeof(u64))));
+
+        b->m_pdwSetReadPos      = (u32 *)((u8 *)b->m_pdwSetWritePos +
+                1 * sizeof(u32));
+
+        b->m_pdwGetWritePos     = (u32 *)((u8 *)b->m_pdwSetWritePos +
+                2 * sizeof(u32));
+
+        b->m_pdwGetReadPos      = (u32 *)((u8 *)b->m_pdwSetWritePos +
+                3 * sizeof(u32));
+
+        return 0;
+}
+
+void saa7164_bus_dump(struct saa7164_dev *dev)
+{
+        tmComResBusInfo_t *b = &dev->bus;
+
+        dprintk(DBGLVL_BUS, "Dumping the bus structure:\n");
+        dprintk(DBGLVL_BUS, " .type             = %d\n", b->Type);
+        dprintk(DBGLVL_BUS, " .dev->bmmio       = 0x%p\n", dev->bmmio);
+        dprintk(DBGLVL_BUS, " .m_wMaxReqSize    = 0x%x\n", b->m_wMaxReqSize);
+        dprintk(DBGLVL_BUS, " .m_pdwSetRing     = 0x%p\n", b->m_pdwSetRing);
+        dprintk(DBGLVL_BUS, " .m_dwSizeSetRing  = 0x%x\n", b->m_dwSizeSetRing);
+        dprintk(DBGLVL_BUS, " .m_pdwGetRing     = 0x%p\n", b->m_pdwGetRing);
+        dprintk(DBGLVL_BUS, " .m_dwSizeGetRing  = 0x%x\n", b->m_dwSizeGetRing);
+
+        dprintk(DBGLVL_BUS, " .m_pdwSetWritePos = 0x%p (0x%08x)\n",
+                b->m_pdwSetWritePos, *b->m_pdwSetWritePos);
+
+        dprintk(DBGLVL_BUS, " .m_pdwSetReadPos  = 0x%p (0x%08x)\n",
+                b->m_pdwSetReadPos, *b->m_pdwSetReadPos);
+
+        dprintk(DBGLVL_BUS, " .m_pdwGetWritePos = 0x%p (0x%08x)\n",
+                b->m_pdwGetWritePos, *b->m_pdwGetWritePos);
+
+        dprintk(DBGLVL_BUS, " .m_pdwGetReadPos  = 0x%p (0x%08x)\n",
+                b->m_pdwGetReadPos, *b->m_pdwGetReadPos);
+}
+
+void saa7164_bus_dumpmsg(struct saa7164_dev *dev, tmComResInfo_t* m, void *buf)
+{
+        dprintk(DBGLVL_BUS, "Dumping msg structure:\n");
+        dprintk(DBGLVL_BUS, " .id               = %d\n",   m->id);
+        dprintk(DBGLVL_BUS, " .flags            = 0x%x\n", m->flags);
+        dprintk(DBGLVL_BUS, " .size             = 0x%x\n", m->size);
+        dprintk(DBGLVL_BUS, " .command          = 0x%x\n", m->command);
+        dprintk(DBGLVL_BUS, " .controlselector  = 0x%x\n", m->controlselector);
+        dprintk(DBGLVL_BUS, " .seqno            = %d\n",   m->seqno);
+        if (buf)
+                dprintk(DBGLVL_BUS, " .buffer (ignored)\n");
+}
+
+/*
+ * Places a command or a response on the bus. The implementation does not
+ * know if it is a command or a response it just places the data on the
+ * bus depending on the bus information given in the tmComResBusInfo_t
+ * structure. If the command or response does not fit into the bus ring
+ * buffer it will be refused.
+ *
+ * Return Value:
+ *  SAA_OK     The function executed successfully.
+ *  < 0        One or more members are not initialized.
+ */
+int saa7164_bus_set(struct saa7164_dev *dev, tmComResInfo_t* msg, void *buf)
+{
+        tmComResBusInfo_t *bus = &dev->bus;
+        u32 bytes_to_write, read_distance, timeout, curr_srp, curr_swp;
+        u32 new_swp, space_rem;
+        int ret = SAA_ERR_BAD_PARAMETER;
+
+        if (!msg) {
+                printk(KERN_ERR "%s() !msg\n", __func__);
+                return SAA_ERR_BAD_PARAMETER;
+        }
+
+        dprintk(DBGLVL_BUS, "%s()\n", __func__);
+
+        msg->size = cpu_to_le16(msg->size);
+        msg->command = cpu_to_le16(msg->command);
+        msg->controlselector = cpu_to_le16(msg->controlselector);
+
+        if (msg->size > dev->bus.m_wMaxReqSize) {
+                printk(KERN_ERR "%s() Exceeded dev->bus.m_wMaxReqSize\n",
+                        __func__);
+                return SAA_ERR_BAD_PARAMETER;
+        }
+
+        if ((msg->size > 0) && (buf == 0)) {
+                printk(KERN_ERR "%s() Missing message buffer\n", __func__);
+                return SAA_ERR_BAD_PARAMETER;
+        }
+
+        /* Lock the bus from any other access */
+        mutex_lock(&bus->lock);
+
+        bytes_to_write = sizeof(*msg) + msg->size;
+        read_distance = 0;
+        timeout = SAA_BUS_TIMEOUT;
+        curr_srp = le32_to_cpu(*bus->m_pdwSetReadPos);
+        curr_swp = le32_to_cpu(*bus->m_pdwSetWritePos);
+
+        /* Deal with ring wrapping issues */
+        if (curr_srp > curr_swp)
+                /* The ring has not wrapped yet */
+                read_distance = curr_srp - curr_swp;
+        else
+                /* Deal with the wrapped ring */
+                read_distance = (curr_srp + bus->m_dwSizeSetRing) - curr_swp;
+
+        dprintk(DBGLVL_BUS, "%s() bytes_to_write = %d\n", __func__,
+                bytes_to_write);
+
+        dprintk(DBGLVL_BUS, "%s() read_distance = %d\n", __func__,
+                read_distance);
+
+        dprintk(DBGLVL_BUS, "%s() curr_srp = %x\n", __func__, curr_srp);
+        dprintk(DBGLVL_BUS, "%s() curr_swp = %x\n", __func__, curr_swp);
+
+        /* Process the msg and write the content onto the bus */
+        while (bytes_to_write >= read_distance) {
+
+                if (timeout-- == 0) {
+                        printk(KERN_ERR "%s() bus timeout\n", __func__);
+                        ret = SAA_ERR_NO_RESOURCES;
+                        goto out;
+                }
+
+                /* TODO: Review this delay, efficient? */
+                /* Wait, allowing the hardware fetch time */
+                mdelay(1);
+
+                /* Check the space usage again */
+                curr_srp = le32_to_cpu(*bus->m_pdwSetReadPos);
+
+                /* Deal with ring wrapping issues */
+                if (curr_srp > curr_swp)
+                        /* Read didn't wrap around the buffer */
+                        read_distance = curr_srp - curr_swp;
+                else
+                        /* Deal with the wrapped ring */
+                        read_distance = (curr_srp + bus->m_dwSizeSetRing) -
+                                curr_swp;
+
+        }
+
+        /* Calculate the new write position */
+        new_swp = curr_swp + bytes_to_write;
+
+        dprintk(DBGLVL_BUS, "%s() new_swp = %x\n", __func__, new_swp);
+        dprintk(DBGLVL_BUS, "%s() bus->m_dwSizeSetRing = %x\n", __func__,
+                bus->m_dwSizeSetRing);
+
+        /* Mental Note: line 462 tmmhComResBusPCIe.cpp */
+
+        /* Check if we're going to wrap again */
+        if (new_swp > bus->m_dwSizeSetRing) {
+
+                /* Ring wraps */
+                new_swp -= bus->m_dwSizeSetRing;
+
+                space_rem = bus->m_dwSizeSetRing - curr_swp;
+
+                dprintk(DBGLVL_BUS, "%s() space_rem = %x\n", __func__,
+                        space_rem);
+
+                dprintk(DBGLVL_BUS, "%s() sizeof(*msg) = %d\n", __func__,
+                        (u32)sizeof(*msg));
+
+                if (space_rem < sizeof(*msg)) {
+                        dprintk(DBGLVL_BUS, "%s() tr4\n", __func__);
+
+                        /* Split the msg into pieces as the ring wraps */
+                        memcpy(bus->m_pdwSetRing + curr_swp, msg, space_rem);
+                        memcpy(bus->m_pdwSetRing, (u8 *)msg + space_rem,
+                                sizeof(*msg) - space_rem);
+
+                        memcpy(bus->m_pdwSetRing + sizeof(*msg) - space_rem,
+                                buf, msg->size);
+
+                } else if (space_rem == sizeof(*msg)) {
+                        dprintk(DBGLVL_BUS, "%s() tr5\n", __func__);
+
+                        /* Additional data at the beginning of the ring */
+                        memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
+                        memcpy(bus->m_pdwSetRing, buf, msg->size);
+
+                } else {
+                        /* Additional data wraps around the ring */
+                        memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
+                        if (msg->size > 0) {
+                                memcpy(bus->m_pdwSetRing + curr_swp +
+                                        sizeof(*msg), buf, space_rem -
+                                        sizeof(*msg));
+                                memcpy(bus->m_pdwSetRing, (u8 *)buf +
+                                        space_rem - sizeof(*msg),
+                                        bytes_to_write - space_rem);
+                        }
+
+                }
+
+        } /* (new_swp > bus->m_dwSizeSetRing) */
+        else {
+                dprintk(DBGLVL_BUS, "%s() tr6\n", __func__);
+
+                /* The ring buffer doesn't wrap, two simple copies */
+                memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
+                memcpy(bus->m_pdwSetRing + curr_swp + sizeof(*msg), buf,
+                        msg->size);
+        }
+
+        dprintk(DBGLVL_BUS, "%s() new_swp = %x\n", __func__, new_swp);
+
+        /* TODO: Convert all of the direct PCI writes into
+         * saa7164_writel/b calls for consistency.
+         */
+
+        /* Update the bus write position */
+        *bus->m_pdwSetWritePos = cpu_to_le32(new_swp);
+        ret = SAA_OK;
+
+out:
+        mutex_unlock(&bus->lock);
+        return ret;
+}
+
+/*
+ * Receive a command or a response from the bus. The implementation does not
+ * know if it is a command or a response it simply dequeues the data,
+ * depending on the bus information given in the tmComResBusInfo_t structure.
+ *
+ * Return Value:
+ *  0          The function executed successfully.
+ *  < 0        One or more members are not initialized.
+ */
+int saa7164_bus_get(struct saa7164_dev *dev, tmComResInfo_t* msg, void *buf,
+        int peekonly)
+{
+        tmComResBusInfo_t *bus = &dev->bus;
+        u32 bytes_to_read, write_distance, curr_grp, curr_gwp,
+                new_grp, buf_size, space_rem;
+        tmComResInfo_t msg_tmp;
+        int ret = SAA_ERR_BAD_PARAMETER;
+
+        if (msg == 0)
+                return ret;
+
+        if (msg->size > dev->bus.m_wMaxReqSize) {
+                printk(KERN_ERR "%s() Exceeded dev->bus.m_wMaxReqSize\n",
+                        __func__);
+                return ret;
+        }
+
+        if ((peekonly == 0) && (msg->size > 0) && (buf == 0)) {
+                printk(KERN_ERR
+                        "%s() Missing msg buf, size should be %d bytes\n",
+                        __func__, msg->size);
+                return ret;
+        }
+
+        mutex_lock(&bus->lock);
+
+        /* Peek the bus to see if a msg exists, if it's not what we're expecting
+         * then return cleanly else read the message from the bus.
+         */
+        curr_gwp = le32_to_cpu(*bus->m_pdwGetWritePos);
+        curr_grp = le32_to_cpu(*bus->m_pdwGetReadPos);
+
+        if (curr_gwp == curr_grp) {
+                dprintk(DBGLVL_BUS, "%s() No message on the bus\n", __func__);
+                ret = SAA_ERR_EMPTY;
+                goto out;
+        }
+
+        bytes_to_read = sizeof(*msg);
+
+        /* Calculate write distance to current read position */
+        write_distance = 0;
+        if (curr_gwp >= curr_grp)
+                /* Write doesn't wrap around the ring */
+                write_distance = curr_gwp - curr_grp;
+        else
+                /* Write wraps around the ring */
+                write_distance = curr_gwp + bus->m_dwSizeGetRing - curr_grp;
+
+        if (bytes_to_read > write_distance) {
+                printk(KERN_ERR "%s() No message/response found\n", __func__);
+                ret = SAA_ERR_INVALID_COMMAND;
+                goto out;
+        }
+
+        /* Calculate the new read position */
+        new_grp = curr_grp + bytes_to_read;
+        if (new_grp > bus->m_dwSizeGetRing) {
+
+                /* Ring wraps */
+                new_grp -= bus->m_dwSizeGetRing;
+                space_rem = bus->m_dwSizeGetRing - curr_grp;
+
+                memcpy(&msg_tmp, bus->m_pdwGetRing + curr_grp, space_rem);
+                memcpy((u8 *)&msg_tmp + space_rem, bus->m_pdwGetRing,
+                        bytes_to_read - space_rem);
+
+        } else {
+                /* No wrapping */
+                memcpy(&msg_tmp, bus->m_pdwGetRing + curr_grp, bytes_to_read);
+        }
+
+        /* No need to update the read positions, because this was a peek */
+        /* If the caller specifically want to peek, return */
+        if (peekonly) {
+                memcpy(msg, &msg_tmp, sizeof(*msg));
+                goto peekout;
+        }
+
+        /* Check if the command/response matches what is expected */
+        if ((msg_tmp.id != msg->id) || (msg_tmp.command != msg->command) ||
+                (msg_tmp.controlselector != msg->controlselector) ||
+                (msg_tmp.seqno != msg->seqno) || (msg_tmp.size != msg->size)) {
+
+                printk(KERN_ERR "%s() Unexpected msg miss-match\n", __func__);
+                saa7164_bus_dumpmsg(dev, msg, buf);
+                saa7164_bus_dumpmsg(dev, &msg_tmp, 0);
+                ret = SAA_ERR_INVALID_COMMAND;
+                goto out;
+        }
+
+        /* Get the actual command and response from the bus */
+        buf_size = msg->size;
+
+        bytes_to_read = sizeof(*msg) + msg->size;
+        /* Calculate write distance to current read position */
+        write_distance = 0;
+        if (curr_gwp >= curr_grp)
+                /* Write doesn't wrap around the ring */
+                write_distance = curr_gwp - curr_grp;
+        else
+                /* Write wraps around the ring */
+                write_distance = curr_gwp + bus->m_dwSizeGetRing - curr_grp;
+
+        if (bytes_to_read > write_distance) {
+                printk(KERN_ERR "%s() Invalid bus state, missing msg "
+                        "or mangled ring, faulty H/W / bad code?\n", __func__);
+                ret = SAA_ERR_INVALID_COMMAND;
+                goto out;
+        }
+
+        /* Calculate the new read position */
+        new_grp = curr_grp + bytes_to_read;
+        if (new_grp > bus->m_dwSizeGetRing) {
+
+                /* Ring wraps */
+                new_grp -= bus->m_dwSizeGetRing;
+                space_rem = bus->m_dwSizeGetRing - curr_grp;
+
+                if (space_rem < sizeof(*msg)) {
+                        /* msg wraps around the ring */
+                        memcpy(msg, bus->m_pdwGetRing + curr_grp, space_rem);
+                        memcpy((u8 *)msg + space_rem, bus->m_pdwGetRing,
+                                sizeof(*msg) - space_rem);
+                        if (buf)
+                                memcpy(buf, bus->m_pdwGetRing + sizeof(*msg) -
+                                        space_rem, buf_size);
+
+                } else if (space_rem == sizeof(*msg)) {
+                        memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
+                        if (buf)
+                                memcpy(buf, bus->m_pdwGetRing, buf_size);
+                } else {
+                        /* Additional data wraps around the ring */
+                        memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
+                        if (buf) {
+                                memcpy(buf, bus->m_pdwGetRing + curr_grp +
+                                        sizeof(*msg), space_rem - sizeof(*msg));
+                                memcpy(buf + space_rem - sizeof(*msg),
+                                        bus->m_pdwGetRing, bytes_to_read -
+                                        space_rem);
+                        }
+
+                }
+
+        } else {
+                /* No wrapping */
+                memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
+                if (buf)
+                        memcpy(buf, bus->m_pdwGetRing + curr_grp + sizeof(*msg),
+                                buf_size);
+        }
+
+        /* Update the read positions, adjusting the ring */
+        *bus->m_pdwGetReadPos = cpu_to_le32(new_grp);
+
+peekout:
+        msg->size = le16_to_cpu(msg->size);
+        msg->command = le16_to_cpu(msg->command);
+        msg->controlselector = le16_to_cpu(msg->controlselector);
+        ret = SAA_OK;
+out:
+        mutex_unlock(&bus->lock);
+        return ret;
+}
+
diff --git a/drivers/media/video/saa7164/saa7164-cards.c b/drivers/media/video/saa7164/saa7164-cards.c
new file mode 100644
index 000000000000..a3c299405f46
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-cards.c
@@ -0,0 +1,624 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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/init.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+
+#include "saa7164.h"
+
+/* The Bridge API needs to understand register widths (in bytes) for the
+ * attached I2C devices, so we can simplify the virtual i2c mechansms
+ * and keep the -i2c.c implementation clean.
+ */
+#define REGLEN_8bit     1
+#define REGLEN_16bit    2
+
+struct saa7164_board saa7164_boards[] = {
+        [SAA7164_BOARD_UNKNOWN] = {
+                /* Bridge will not load any firmware, without knowing
+                 * the rev this would be fatal. */
+                .name           = "Unknown",
+        },
+        [SAA7164_BOARD_UNKNOWN_REV2] = {
+                /* Bridge will load the v2 f/w and dump descriptors */
+                /* Required during new board bringup */
+                .name           = "Generic Rev2",
+                .chiprev        = SAA7164_CHIP_REV2,
+        },
+        [SAA7164_BOARD_UNKNOWN_REV3] = {
+                /* Bridge will load the v2 f/w and dump descriptors */
+                /* Required during new board bringup */
+                .name           = "Generic Rev3",
+                .chiprev        = SAA7164_CHIP_REV3,
+        },
+        [SAA7164_BOARD_HAUPPAUGE_HVR2200] = {
+                .name           = "Hauppauge WinTV-HVR2200",
+                .porta          = SAA7164_MPEG_DVB,
+                .portb          = SAA7164_MPEG_DVB,
+                .chiprev        = SAA7164_CHIP_REV3,
+                .unit           = {{
+                        .id             = 0x1d,
+                        .type           = SAA7164_UNIT_EEPROM,
+                        .name           = "4K EEPROM",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_0,
+                        .i2c_bus_addr   = 0xa0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x04,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-1",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x1b,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-2",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x1e,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "TDA10048-1",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0x10 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x1f,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "TDA10048-2",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0x12 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                } },
+        },
+        [SAA7164_BOARD_HAUPPAUGE_HVR2200_2] = {
+                .name           = "Hauppauge WinTV-HVR2200",
+                .porta          = SAA7164_MPEG_DVB,
+                .portb          = SAA7164_MPEG_DVB,
+                .chiprev        = SAA7164_CHIP_REV2,
+                .unit           = {{
+                        .id             = 0x06,
+                        .type           = SAA7164_UNIT_EEPROM,
+                        .name           = "4K EEPROM",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_0,
+                        .i2c_bus_addr   = 0xa0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x04,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-1",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x05,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "TDA10048-1",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0x10 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x1e,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-2",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x1f,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "TDA10048-2",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0x12 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                } },
+        },
+        [SAA7164_BOARD_HAUPPAUGE_HVR2200_3] = {
+                .name           = "Hauppauge WinTV-HVR2200",
+                .porta          = SAA7164_MPEG_DVB,
+                .portb          = SAA7164_MPEG_DVB,
+                .chiprev        = SAA7164_CHIP_REV2,
+                .unit           = {{
+                        .id             = 0x1d,
+                        .type           = SAA7164_UNIT_EEPROM,
+                        .name           = "4K EEPROM",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_0,
+                        .i2c_bus_addr   = 0xa0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x04,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-1",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x05,
+                        .type           = SAA7164_UNIT_ANALOG_DEMODULATOR,
+                        .name           = "TDA8290-1",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0x84 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x1b,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-2",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x1c,
+                        .type           = SAA7164_UNIT_ANALOG_DEMODULATOR,
+                        .name           = "TDA8290-2",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0x84 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x1e,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "TDA10048-1",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0x10 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x1f,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "TDA10048-2",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0x12 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                } },
+        },
+        [SAA7164_BOARD_HAUPPAUGE_HVR2250] = {
+                .name           = "Hauppauge WinTV-HVR2250",
+                .porta          = SAA7164_MPEG_DVB,
+                .portb          = SAA7164_MPEG_DVB,
+                .chiprev        = SAA7164_CHIP_REV3,
+                .unit           = {{
+                        .id             = 0x22,
+                        .type           = SAA7164_UNIT_EEPROM,
+                        .name           = "4K EEPROM",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_0,
+                        .i2c_bus_addr   = 0xa0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x04,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-1",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x07,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-1 (TOP)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0x32 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x08,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-1 (QAM)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0x34 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x1e,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-2",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x20,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-2 (TOP)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0x32 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x23,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-2 (QAM)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0x34 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                } },
+        },
+        [SAA7164_BOARD_HAUPPAUGE_HVR2250_2] = {
+                .name           = "Hauppauge WinTV-HVR2250",
+                .porta          = SAA7164_MPEG_DVB,
+                .portb          = SAA7164_MPEG_DVB,
+                .chiprev        = SAA7164_CHIP_REV3,
+                .unit           = {{
+                        .id             = 0x28,
+                        .type           = SAA7164_UNIT_EEPROM,
+                        .name           = "4K EEPROM",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_0,
+                        .i2c_bus_addr   = 0xa0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x04,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-1",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x07,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-1 (TOP)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0x32 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x08,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-1 (QAM)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0x34 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x24,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-2",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x26,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-2 (TOP)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0x32 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x29,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-2 (QAM)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0x34 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                } },
+        },
+        [SAA7164_BOARD_HAUPPAUGE_HVR2250_3] = {
+                .name           = "Hauppauge WinTV-HVR2250",
+                .porta          = SAA7164_MPEG_DVB,
+                .portb          = SAA7164_MPEG_DVB,
+                .chiprev        = SAA7164_CHIP_REV3,
+                .unit           = {{
+                        .id             = 0x26,
+                        .type           = SAA7164_UNIT_EEPROM,
+                        .name           = "4K EEPROM",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_0,
+                        .i2c_bus_addr   = 0xa0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x04,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-1",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x07,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-1 (TOP)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0x32 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x08,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-1 (QAM)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_1,
+                        .i2c_bus_addr   = 0x34 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x22,
+                        .type           = SAA7164_UNIT_TUNER,
+                        .name           = "TDA18271-2",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0xc0 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x24,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-2 (TOP)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0x32 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                }, {
+                        .id             = 0x27,
+                        .type           = SAA7164_UNIT_DIGITAL_DEMODULATOR,
+                        .name           = "CX24228/S5H1411-2 (QAM)",
+                        .i2c_bus_nr     = SAA7164_I2C_BUS_2,
+                        .i2c_bus_addr   = 0x34 >> 1,
+                        .i2c_reg_len    = REGLEN_8bit,
+                } },
+        },
+};
+const unsigned int saa7164_bcount = ARRAY_SIZE(saa7164_boards);
+
+/* ------------------------------------------------------------------ */
+/* PCI subsystem IDs                                                  */
+
+struct saa7164_subid saa7164_subids[] = {
+        {
+                .subvendor = 0x0070,
+                .subdevice = 0x8880,
+                .card      = SAA7164_BOARD_HAUPPAUGE_HVR2250,
+        }, {
+                .subvendor = 0x0070,
+                .subdevice = 0x8810,
+                .card      = SAA7164_BOARD_HAUPPAUGE_HVR2250,
+        }, {
+                .subvendor = 0x0070,
+                .subdevice = 0x8980,
+                .card      = SAA7164_BOARD_HAUPPAUGE_HVR2200,
+        }, {
+                .subvendor = 0x0070,
+                .subdevice = 0x8900,
+                .card      = SAA7164_BOARD_HAUPPAUGE_HVR2200_2,
+        }, {
+                .subvendor = 0x0070,
+                .subdevice = 0x8901,
+                .card      = SAA7164_BOARD_HAUPPAUGE_HVR2200_3,
+        }, {
+                .subvendor = 0x0070,
+                .subdevice = 0x88A1,
+                .card      = SAA7164_BOARD_HAUPPAUGE_HVR2250_3,
+        }, {
+                .subvendor = 0x0070,
+                .subdevice = 0x8891,
+                .card      = SAA7164_BOARD_HAUPPAUGE_HVR2250_2,
+        }, {
+                .subvendor = 0x0070,
+                .subdevice = 0x8851,
+                .card      = SAA7164_BOARD_HAUPPAUGE_HVR2250_2,
+        },
+};
+const unsigned int saa7164_idcount = ARRAY_SIZE(saa7164_subids);
+
+void saa7164_card_list(struct saa7164_dev *dev)
+{
+        int i;
+
+        if (0 == dev->pci->subsystem_vendor &&
+            0 == dev->pci->subsystem_device) {
+                printk(KERN_ERR
+                        "%s: Board has no valid PCIe Subsystem ID and can't\n"
+                        "%s: be autodetected. Pass card=<n> insmod option to\n"
+                        "%s: workaround that. Send complaints to the vendor\n"
+                        "%s: of the TV card. Best regards,\n"
+                        "%s:         -- tux\n",
+                        dev->name, dev->name, dev->name, dev->name, dev->name);
+        } else {
+                printk(KERN_ERR
+                        "%s: Your board isn't known (yet) to the driver.\n"
+                        "%s: Try to pick one of the existing card configs via\n"
+                        "%s: card=<n> insmod option.  Updating to the latest\n"
+                        "%s: version might help as well.\n",
+                        dev->name, dev->name, dev->name, dev->name);
+        }
+
+        printk(KERN_ERR "%s: Here are valid choices for the card=<n> insmod "
+                "option:\n", dev->name);
+
+        for (i = 0; i < saa7164_bcount; i++)
+                printk(KERN_ERR "%s:    card=%d -> %s\n",
+                       dev->name, i, saa7164_boards[i].name);
+}
+
+/* TODO: clean this define up into the -cards.c structs */
+#define PCIEBRIDGE_UNITID 2
+
+void saa7164_gpio_setup(struct saa7164_dev *dev)
+{
+
+
+        switch (dev->board) {
+        case SAA7164_BOARD_HAUPPAUGE_HVR2200:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2200_2:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2200_3:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2250:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2250_2:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2250_3:
+                /*
+                GPIO 2: s5h1411 / tda10048-1 demod reset
+                GPIO 3: s5h1411 / tda10048-2 demod reset
+                GPIO 7: IRBlaster Zilog reset
+                 */
+
+                /* Reset parts by going in and out of reset */
+                saa7164_api_clear_gpiobit(dev, PCIEBRIDGE_UNITID, 2);
+                saa7164_api_clear_gpiobit(dev, PCIEBRIDGE_UNITID, 3);
+
+                msleep(10);
+
+                saa7164_api_set_gpiobit(dev, PCIEBRIDGE_UNITID, 2);
+                saa7164_api_set_gpiobit(dev, PCIEBRIDGE_UNITID, 3);
+                break;
+        }
+
+}
+
+static void hauppauge_eeprom(struct saa7164_dev *dev, u8 *eeprom_data)
+{
+        struct tveeprom tv;
+
+        /* TODO: Assumption: eeprom on bus 0 */
+        tveeprom_hauppauge_analog(&dev->i2c_bus[0].i2c_client, &tv,
+                eeprom_data);
+
+        /* Make sure we support the board model */
+        switch (tv.model) {
+        case 88001:
+                /* Development board - Limit circulation */
+                /* WinTV-HVR2250 (PCIe, Retail, full-height bracket)
+                 * ATSC/QAM (TDA18271/S5H1411) and basic analog, no IR, FM */
+        case 88021:
+                /* WinTV-HVR2250 (PCIe, Retail, full-height bracket)
+                 * ATSC/QAM (TDA18271/S5H1411) and basic analog, MCE CIR, FM */
+                break;
+        case 88041:
+                /* WinTV-HVR2250 (PCIe, Retail, full-height bracket)
+                 * ATSC/QAM (TDA18271/S5H1411) and basic analog, no IR, FM */
+                break;
+        case 88061:
+                /* WinTV-HVR2250 (PCIe, Retail, full-height bracket)
+                 * ATSC/QAM (TDA18271/S5H1411) and basic analog, FM */
+                break;
+        case 89519:
+        case 89609:
+                /* WinTV-HVR2200 (PCIe, Retail, full-height)
+                 * DVB-T (TDA18271/TDA10048) and basic analog, no IR */
+                break;
+        case 89619:
+                /* WinTV-HVR2200 (PCIe, Retail, half-height)
+                 * DVB-T (TDA18271/TDA10048) and basic analog, no IR */
+                break;
+        default:
+                printk(KERN_ERR "%s: Warning: Unknown Hauppauge model #%d\n",
+                        dev->name, tv.model);
+                break;
+        }
+
+        printk(KERN_INFO "%s: Hauppauge eeprom: model=%d\n", dev->name,
+                tv.model);
+}
+
+void saa7164_card_setup(struct saa7164_dev *dev)
+{
+        static u8 eeprom[256];
+
+        if (dev->i2c_bus[0].i2c_rc == 0) {
+                if (saa7164_api_read_eeprom(dev, &eeprom[0],
+                        sizeof(eeprom)) < 0)
+                        return;
+        }
+
+        switch (dev->board) {
+        case SAA7164_BOARD_HAUPPAUGE_HVR2200:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2200_2:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2200_3:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2250:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2250_2:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2250_3:
+                hauppauge_eeprom(dev, &eeprom[0]);
+                break;
+        }
+}
+
+/* With most other drivers, the kernel expects to communicate with subdrivers
+ * through i2c. This bridge does not allow that, it does not expose any direct
+ * access to I2C. Instead we have to communicate through the device f/w for
+ * register access to 'processing units'. Each unit has a unique
+ * id, regardless of how the physical implementation occurs across
+ * the three physical i2c busses. The being said if we want leverge of
+ * the existing kernel drivers for tuners and demods we have to 'speak i2c',
+ * to this bridge implements 3 virtual i2c buses. This is a helper function
+ * for those.
+ *
+ * Description: Translate the kernels notion of an i2c address and bus into
+ * the appropriate unitid.
+ */
+int saa7164_i2caddr_to_unitid(struct saa7164_i2c *bus, int addr)
+{
+        /* For a given bus and i2c device address, return the saa7164 unique
+         * unitid. < 0 on error */
+
+        struct saa7164_dev *dev = bus->dev;
+        struct saa7164_unit *unit;
+        int i;
+
+        for (i = 0; i < SAA7164_MAX_UNITS; i++) {
+                unit = &saa7164_boards[dev->board].unit[i];
+
+                if (unit->type == SAA7164_UNIT_UNDEFINED)
+                        continue;
+                if ((bus->nr == unit->i2c_bus_nr) &&
+                        (addr == unit->i2c_bus_addr))
+                        return unit->id;
+        }
+
+        return -1;
+}
+
+/* The 7164 API needs to know the i2c register length in advance.
+ * this is a helper function. Based on a specific chip addr and bus return the
+ * reg length.
+ */
+int saa7164_i2caddr_to_reglen(struct saa7164_i2c *bus, int addr)
+{
+        /* For a given bus and i2c device address, return the
+         * saa7164 registry address width. < 0 on error
+         */
+
+        struct saa7164_dev *dev = bus->dev;
+        struct saa7164_unit *unit;
+        int i;
+
+        for (i = 0; i < SAA7164_MAX_UNITS; i++) {
+                unit = &saa7164_boards[dev->board].unit[i];
+
+                if (unit->type == SAA7164_UNIT_UNDEFINED)
+                        continue;
+
+                if ((bus->nr == unit->i2c_bus_nr) &&
+                        (addr == unit->i2c_bus_addr))
+                        return unit->i2c_reg_len;
+        }
+
+        return -1;
+}
+/* TODO: implement a 'findeeprom' functio like the above and fix any other
+ * eeprom related todo's in -api.c.
+ */
+
+/* Translate a unitid into a x readable device name, for display purposes.  */
+char *saa7164_unitid_name(struct saa7164_dev *dev, u8 unitid)
+{
+        char *undefed = "UNDEFINED";
+        char *bridge = "BRIDGE";
+        struct saa7164_unit *unit;
+        int i;
+
+        if (unitid == 0)
+                return bridge;
+
+        for (i = 0; i < SAA7164_MAX_UNITS; i++) {
+                unit = &saa7164_boards[dev->board].unit[i];
+
+                if (unit->type == SAA7164_UNIT_UNDEFINED)
+                        continue;
+
+                if (unitid == unit->id)
+                                return unit->name;
+        }
+
+        return undefed;
+}
+
diff --git a/drivers/media/video/saa7164/saa7164-cmd.c b/drivers/media/video/saa7164/saa7164-cmd.c
new file mode 100644
index 000000000000..e097f1a0969a
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-cmd.c
@@ -0,0 +1,572 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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/wait.h>
+
+#include "saa7164.h"
+
+int saa7164_cmd_alloc_seqno(struct saa7164_dev *dev)
+{
+        int i, ret = -1;
+
+        mutex_lock(&dev->lock);
+        for (i = 0; i < SAA_CMD_MAX_MSG_UNITS; i++) {
+                if (dev->cmds[i].inuse == 0) {
+                        dev->cmds[i].inuse = 1;
+                        dev->cmds[i].signalled = 0;
+                        dev->cmds[i].timeout = 0;
+                        ret = dev->cmds[i].seqno;
+                        break;
+                }
+        }
+        mutex_unlock(&dev->lock);
+
+        return ret;
+}
+
+void saa7164_cmd_free_seqno(struct saa7164_dev *dev, u8 seqno)
+{
+        mutex_lock(&dev->lock);
+        if ((dev->cmds[seqno].inuse == 1) &&
+                (dev->cmds[seqno].seqno == seqno)) {
+                dev->cmds[seqno].inuse = 0;
+                dev->cmds[seqno].signalled = 0;
+                dev->cmds[seqno].timeout = 0;
+        }
+        mutex_unlock(&dev->lock);
+}
+
+void saa7164_cmd_timeout_seqno(struct saa7164_dev *dev, u8 seqno)
+{
+        mutex_lock(&dev->lock);
+        if ((dev->cmds[seqno].inuse == 1) &&
+                (dev->cmds[seqno].seqno == seqno)) {
+                dev->cmds[seqno].timeout = 1;
+        }
+        mutex_unlock(&dev->lock);
+}
+
+u32 saa7164_cmd_timeout_get(struct saa7164_dev *dev, u8 seqno)
+{
+        int ret = 0;
+
+        mutex_lock(&dev->lock);
+        if ((dev->cmds[seqno].inuse == 1) &&
+                (dev->cmds[seqno].seqno == seqno)) {
+                ret = dev->cmds[seqno].timeout;
+        }
+        mutex_unlock(&dev->lock);
+
+        return ret;
+}
+
+/* Commands to the f/w get marshelled to/from this code then onto the PCI
+ * -bus/c running buffer. */
+int saa7164_irq_dequeue(struct saa7164_dev *dev)
+{
+        int ret = SAA_OK;
+        u32 timeout;
+        wait_queue_head_t *q = 0;
+        dprintk(DBGLVL_CMD, "%s()\n", __func__);
+
+        /* While any outstand message on the bus exists... */
+        do {
+
+                /* Peek the msg bus */
+                tmComResInfo_t tRsp = { 0, 0, 0, 0, 0, 0 };
+                ret = saa7164_bus_get(dev, &tRsp, NULL, 1);
+                if (ret != SAA_OK)
+                        break;
+
+                q = &dev->cmds[tRsp.seqno].wait;
+                timeout = saa7164_cmd_timeout_get(dev, tRsp.seqno);
+                dprintk(DBGLVL_CMD, "%s() timeout = %d\n", __func__, timeout);
+                if (!timeout) {
+                        dprintk(DBGLVL_CMD,
+                                "%s() signalled seqno(%d) (for dequeue)\n",
+                                __func__, tRsp.seqno);
+                        dev->cmds[tRsp.seqno].signalled = 1;
+                        wake_up(q);
+                } else {
+                        printk(KERN_ERR
+                                "%s() found timed out command on the bus\n",
+                                        __func__);
+                }
+        } while (0);
+
+        return ret;
+}
+
+/* Commands to the f/w get marshelled to/from this code then onto the PCI
+ * -bus/c running buffer. */
+int saa7164_cmd_dequeue(struct saa7164_dev *dev)
+{
+        int loop = 1;
+        int ret;
+        u32 timeout;
+        wait_queue_head_t *q = 0;
+        u8 tmp[512];
+        dprintk(DBGLVL_CMD, "%s()\n", __func__);
+
+        while (loop) {
+
+                tmComResInfo_t tRsp = { 0, 0, 0, 0, 0, 0 };
+                ret = saa7164_bus_get(dev, &tRsp, NULL, 1);
+                if (ret == SAA_ERR_EMPTY)
+                        return SAA_OK;
+
+                if (ret != SAA_OK)
+                        return ret;
+
+                q = &dev->cmds[tRsp.seqno].wait;
+                timeout = saa7164_cmd_timeout_get(dev, tRsp.seqno);
+                dprintk(DBGLVL_CMD, "%s() timeout = %d\n", __func__, timeout);
+                if (timeout) {
+                        printk(KERN_ERR "found timed out command on the bus\n");
+
+                        /* Clean the bus */
+                        ret = saa7164_bus_get(dev, &tRsp, &tmp, 0);
+                        printk(KERN_ERR "ret = %x\n", ret);
+                        if (ret == SAA_ERR_EMPTY)
+                                /* Someone else already fetched the response */
+                                return SAA_OK;
+
+                        if (ret != SAA_OK)
+                                return ret;
+
+                        if (tRsp.flags & PVC_CMDFLAG_CONTINUE)
+                                printk(KERN_ERR "split response\n");
+                        else
+                                saa7164_cmd_free_seqno(dev, tRsp.seqno);
+
+                        printk(KERN_ERR " timeout continue\n");
+                        continue;
+                }
+
+                dprintk(DBGLVL_CMD, "%s() signalled seqno(%d) (for dequeue)\n",
+                        __func__, tRsp.seqno);
+                dev->cmds[tRsp.seqno].signalled = 1;
+                wake_up(q);
+                return SAA_OK;
+        }
+
+        return SAA_OK;
+}
+
+int saa7164_cmd_set(struct saa7164_dev *dev, tmComResInfo_t* msg, void *buf)
+{
+        tmComResBusInfo_t *bus = &dev->bus;
+        u8 cmd_sent;
+        u16 size, idx;
+        u32 cmds;
+        void *tmp;
+        int ret = -1;
+
+        if (!msg) {
+                printk(KERN_ERR "%s() !msg\n", __func__);
+                return SAA_ERR_BAD_PARAMETER;
+        }
+
+        mutex_lock(&dev->cmds[msg->id].lock);
+
+        size = msg->size;
+        idx = 0;
+        cmds = size / bus->m_wMaxReqSize;
+        if (size % bus->m_wMaxReqSize == 0)
+                cmds -= 1;
+
+        cmd_sent = 0;
+
+        /* Split the request into smaller chunks */
+        for (idx = 0; idx < cmds; idx++) {
+
+                msg->flags |= SAA_CMDFLAG_CONTINUE;
+                msg->size = bus->m_wMaxReqSize;
+                tmp = buf + idx * bus->m_wMaxReqSize;
+
+                ret = saa7164_bus_set(dev, msg, tmp);
+                if (ret != SAA_OK) {
+                        printk(KERN_ERR "%s() set failed %d\n", __func__, ret);
+
+                        if (cmd_sent) {
+                                ret = SAA_ERR_BUSY;
+                                goto out;
+                        }
+                        ret = SAA_ERR_OVERFLOW;
+                        goto out;
+                }
+                cmd_sent = 1;
+        }
+
+        /* If not the last command... */
+        if (idx != 0)
+                msg->flags &= ~SAA_CMDFLAG_CONTINUE;
+
+        msg->size = size - idx * bus->m_wMaxReqSize;
+
+        ret = saa7164_bus_set(dev, msg, buf + idx * bus->m_wMaxReqSize);
+        if (ret != SAA_OK) {
+                printk(KERN_ERR "%s() set last failed %d\n", __func__, ret);
+
+                if (cmd_sent) {
+                        ret = SAA_ERR_BUSY;
+                        goto out;
+                }
+                ret = SAA_ERR_OVERFLOW;
+                goto out;
+        }
+        ret = SAA_OK;
+
+out:
+        mutex_unlock(&dev->cmds[msg->id].lock);
+        return ret;
+}
+
+/* Wait for a signal event, without holding a mutex. Either return TIMEOUT if
+ * the event never occured, or SAA_OK if it was signaled during the wait.
+ */
+int saa7164_cmd_wait(struct saa7164_dev *dev, u8 seqno)
+{
+        wait_queue_head_t *q = 0;
+        int ret = SAA_BUS_TIMEOUT;
+        unsigned long stamp;
+        int r;
+
+        if (debug >= 4)
+                saa7164_bus_dump(dev);
+
+        dprintk(DBGLVL_CMD, "%s(seqno=%d)\n", __func__, seqno);
+
+        mutex_lock(&dev->lock);
+        if ((dev->cmds[seqno].inuse == 1) &&
+                (dev->cmds[seqno].seqno == seqno)) {
+                q = &dev->cmds[seqno].wait;
+        }
+        mutex_unlock(&dev->lock);
+
+        if (q) {
+                /* If we haven't been signalled we need to wait */
+                if (dev->cmds[seqno].signalled == 0) {
+                        stamp = jiffies;
+                        dprintk(DBGLVL_CMD,
+                                "%s(seqno=%d) Waiting (signalled=%d)\n",
+                                __func__, seqno, dev->cmds[seqno].signalled);
+
+                        /* Wait for signalled to be flagged or timeout */
+                        /* In a highly stressed system this can easily extend
+                         * into multiple seconds before the deferred worker
+                         * is scheduled, and we're woken up via signal.
+                         * We typically are signalled in < 50ms but it can
+                         * take MUCH longer.
+                         */
+                        wait_event_timeout(*q, dev->cmds[seqno].signalled, (HZ * waitsecs));
+                        r = time_before(jiffies, stamp + (HZ * waitsecs));
+                        if (r)
+                                ret = SAA_OK;
+                        else
+                                saa7164_cmd_timeout_seqno(dev, seqno);
+
+                        dprintk(DBGLVL_CMD, "%s(seqno=%d) Waiting res = %d "
+                                "(signalled=%d)\n", __func__, seqno, r,
+                                dev->cmds[seqno].signalled);
+                } else
+                        ret = SAA_OK;
+        } else
+                printk(KERN_ERR "%s(seqno=%d) seqno is invalid\n",
+                        __func__, seqno);
+
+        return ret;
+}
+
+void saa7164_cmd_signal(struct saa7164_dev *dev, u8 seqno)
+{
+        int i;
+        dprintk(DBGLVL_CMD, "%s()\n", __func__);
+
+        mutex_lock(&dev->lock);
+        for (i = 0; i < SAA_CMD_MAX_MSG_UNITS; i++) {
+                if (dev->cmds[i].inuse == 1) {
+                        dprintk(DBGLVL_CMD,
+                                "seqno %d inuse, sig = %d, t/out = %d\n",
+                                dev->cmds[i].seqno,
+                                dev->cmds[i].signalled,
+                                dev->cmds[i].timeout);
+                }
+        }
+
+        for (i = 0; i < SAA_CMD_MAX_MSG_UNITS; i++) {
+                if ((dev->cmds[i].inuse == 1) && ((i == 0) ||
+                        (dev->cmds[i].signalled) || (dev->cmds[i].timeout))) {
+                        dprintk(DBGLVL_CMD, "%s(seqno=%d) calling wake_up\n",
+                                __func__, i);
+                        dev->cmds[i].signalled = 1;
+                        wake_up(&dev->cmds[i].wait);
+                }
+        }
+        mutex_unlock(&dev->lock);
+}
+
+int saa7164_cmd_send(struct saa7164_dev *dev, u8 id, tmComResCmd_t command,
+        u16 controlselector, u16 size, void *buf)
+{
+        tmComResInfo_t command_t, *pcommand_t;
+        tmComResInfo_t response_t, *presponse_t;
+        u8 errdata[256];
+        u16 resp_dsize;
+        u16 data_recd;
+        u32 loop;
+        int ret;
+        int safety = 0;
+
+        dprintk(DBGLVL_CMD, "%s(unitid = %s (%d) , command = 0x%x, "
+                "sel = 0x%x)\n", __func__, saa7164_unitid_name(dev, id), id,
+                command, controlselector);
+
+        if ((size == 0) || (buf == 0)) {
+                printk(KERN_ERR "%s() Invalid param\n", __func__);
+                return SAA_ERR_BAD_PARAMETER;
+        }
+
+        /* Prepare some basic command/response structures */
+        memset(&command_t, 0, sizeof(command_t));
+        memset(&response_t, 0, sizeof(&response_t));
+        pcommand_t = &command_t;
+        presponse_t = &response_t;
+        command_t.id = id;
+        command_t.command = command;
+        command_t.controlselector = controlselector;
+        command_t.size = size;
+
+        /* Allocate a unique sequence number */
+        ret = saa7164_cmd_alloc_seqno(dev);
+        if (ret < 0) {
+                printk(KERN_ERR "%s() No free sequences\n", __func__);
+                ret = SAA_ERR_NO_RESOURCES;
+                goto out;
+        }
+
+        command_t.seqno = (u8)ret;
+
+        /* Send Command */
+        resp_dsize = size;
+        pcommand_t->size = size;
+
+        dprintk(DBGLVL_CMD, "%s() pcommand_t.seqno = %d\n",
+                __func__, pcommand_t->seqno);
+
+        dprintk(DBGLVL_CMD, "%s() pcommand_t.size = %d\n",
+                __func__, pcommand_t->size);
+
+        ret = saa7164_cmd_set(dev, pcommand_t, buf);
+        if (ret != SAA_OK) {
+                printk(KERN_ERR "%s() set command failed %d\n", __func__, ret);
+
+                if (ret != SAA_ERR_BUSY)
+                        saa7164_cmd_free_seqno(dev, pcommand_t->seqno);
+                else
+                        /* Flag a timeout, because at least one
+                         * command was sent */
+                        saa7164_cmd_timeout_seqno(dev, pcommand_t->seqno);
+
+                goto out;
+        }
+
+        /* With split responses we have to collect the msgs piece by piece */
+        data_recd = 0;
+        loop = 1;
+        while (loop) {
+                dprintk(DBGLVL_CMD, "%s() loop\n", __func__);
+
+                ret = saa7164_cmd_wait(dev, pcommand_t->seqno);
+                dprintk(DBGLVL_CMD, "%s() loop ret = %d\n", __func__, ret);
+
+                /* if power is down and this is not a power command ... */
+
+                if (ret == SAA_BUS_TIMEOUT) {
+                        printk(KERN_ERR "Event timed out\n");
+                        saa7164_cmd_timeout_seqno(dev, pcommand_t->seqno);
+                        return ret;
+                }
+
+                if (ret != SAA_OK) {
+                        printk(KERN_ERR "spurious error\n");
+                        return ret;
+                }
+
+                /* Peek response */
+                ret = saa7164_bus_get(dev, presponse_t, NULL, 1);
+                if (ret == SAA_ERR_EMPTY) {
+                        dprintk(4, "%s() SAA_ERR_EMPTY\n", __func__);
+                        continue;
+                }
+                if (ret != SAA_OK) {
+                        printk(KERN_ERR "peek failed\n");
+                        return ret;
+                }
+
+                dprintk(DBGLVL_CMD, "%s() presponse_t->seqno = %d\n",
+                        __func__, presponse_t->seqno);
+
+                dprintk(DBGLVL_CMD, "%s() presponse_t->flags = 0x%x\n",
+                        __func__, presponse_t->flags);
+
+                dprintk(DBGLVL_CMD, "%s() presponse_t->size = %d\n",
+                        __func__, presponse_t->size);
+
+                /* Check if the response was for our command */
+                if (presponse_t->seqno != pcommand_t->seqno) {
+
+                        dprintk(DBGLVL_CMD,
+                                "wrong event: seqno = %d, "
+                                "expected seqno = %d, "
+                                "will dequeue regardless\n",
+                                presponse_t->seqno, pcommand_t->seqno);
+
+                        ret = saa7164_cmd_dequeue(dev);
+                        if (ret != SAA_OK) {
+                                printk(KERN_ERR "dequeue failed, ret = %d\n",
+                                        ret);
+                                if (safety++ > 16) {
+                                        printk(KERN_ERR
+                                        "dequeue exceeded, safety exit\n");
+                                        return SAA_ERR_BUSY;
+                                }
+                        }
+
+                        continue;
+                }
+
+                if ((presponse_t->flags & PVC_RESPONSEFLAG_ERROR) != 0) {
+
+                        memset(&errdata[0], 0, sizeof(errdata));
+
+                        ret = saa7164_bus_get(dev, presponse_t, &errdata[0], 0);
+                        if (ret != SAA_OK) {
+                                printk(KERN_ERR "get error(2)\n");
+                                return ret;
+                        }
+
+                        saa7164_cmd_free_seqno(dev, pcommand_t->seqno);
+
+                        dprintk(DBGLVL_CMD, "%s() errdata %02x%02x%02x%02x\n",
+                                __func__, errdata[0], errdata[1], errdata[2],
+                                errdata[3]);
+
+                        /* Map error codes */
+                        dprintk(DBGLVL_CMD, "%s() cmd, error code  = 0x%x\n",
+                                __func__, errdata[0]);
+
+                        switch (errdata[0]) {
+                        case PVC_ERRORCODE_INVALID_COMMAND:
+                                dprintk(DBGLVL_CMD, "%s() INVALID_COMMAND\n",
+                                        __func__);
+                                ret = SAA_ERR_INVALID_COMMAND;
+                                break;
+                        case PVC_ERRORCODE_INVALID_DATA:
+                                dprintk(DBGLVL_CMD, "%s() INVALID_DATA\n",
+                                        __func__);
+                                ret = SAA_ERR_BAD_PARAMETER;
+                                break;
+                        case PVC_ERRORCODE_TIMEOUT:
+                                dprintk(DBGLVL_CMD, "%s() TIMEOUT\n", __func__);
+                                ret = SAA_ERR_TIMEOUT;
+                                break;
+                        case PVC_ERRORCODE_NAK:
+                                dprintk(DBGLVL_CMD, "%s() NAK\n", __func__);
+                                ret = SAA_ERR_NULL_PACKET;
+                                break;
+                        case PVC_ERRORCODE_UNKNOWN:
+                        case PVC_ERRORCODE_INVALID_CONTROL:
+                                dprintk(DBGLVL_CMD,
+                                        "%s() UNKNOWN OR INVALID CONTROL\n",
+                                        __func__);
+                        default:
+                                dprintk(DBGLVL_CMD, "%s() UNKNOWN\n", __func__);
+                                ret = SAA_ERR_NOT_SUPPORTED;
+                        }
+
+                        /* See of other commands are on the bus */
+                        if (saa7164_cmd_dequeue(dev) != SAA_OK)
+                                printk(KERN_ERR "dequeue(2) failed\n");
+
+                        return ret;
+                }
+
+                /* If response is invalid */
+                if ((presponse_t->id != pcommand_t->id) ||
+                        (presponse_t->command != pcommand_t->command) ||
+                        (presponse_t->controlselector !=
+                                pcommand_t->controlselector) ||
+                        (((resp_dsize - data_recd) != presponse_t->size) &&
+                                !(presponse_t->flags & PVC_CMDFLAG_CONTINUE)) ||
+                        ((resp_dsize - data_recd) < presponse_t->size)) {
+
+                        /* Invalid */
+                        dprintk(DBGLVL_CMD, "%s() Invalid\n", __func__);
+                        ret = saa7164_bus_get(dev, presponse_t, 0, 0);
+                        if (ret != SAA_OK) {
+                                printk(KERN_ERR "get failed\n");
+                                return ret;
+                        }
+
+                        /* See of other commands are on the bus */
+                        if (saa7164_cmd_dequeue(dev) != SAA_OK)
+                                printk(KERN_ERR "dequeue(3) failed\n");
+                        continue;
+                }
+
+                /* OK, now we're actually getting out correct response */
+                ret = saa7164_bus_get(dev, presponse_t, buf + data_recd, 0);
+                if (ret != SAA_OK) {
+                        printk(KERN_ERR "get failed\n");
+                        return ret;
+                }
+
+                data_recd = presponse_t->size + data_recd;
+                if (resp_dsize == data_recd) {
+                        dprintk(DBGLVL_CMD, "%s() Resp recd\n", __func__);
+                        break;
+                }
+
+                /* See of other commands are on the bus */
+                if (saa7164_cmd_dequeue(dev) != SAA_OK)
+                        printk(KERN_ERR "dequeue(3) failed\n");
+
+                continue;
+
+        } /* (loop) */
+
+        /* Release the sequence number allocation */
+        saa7164_cmd_free_seqno(dev, pcommand_t->seqno);
+
+        /* if powerdown signal all pending commands */
+
+        dprintk(DBGLVL_CMD, "%s() Calling dequeue then exit\n", __func__);
+
+        /* See of other commands are on the bus */
+        if (saa7164_cmd_dequeue(dev) != SAA_OK)
+                printk(KERN_ERR "dequeue(4) failed\n");
+
+        ret = SAA_OK;
+out:
+        return ret;
+}
+
diff --git a/drivers/media/video/saa7164/saa7164-core.c b/drivers/media/video/saa7164/saa7164-core.c
new file mode 100644
index 000000000000..f0dbead188c8
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-core.c
@@ -0,0 +1,740 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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/init.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/kmod.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <asm/div64.h>
+
+#include "saa7164.h"
+
+MODULE_DESCRIPTION("Driver for NXP SAA7164 based TV cards");
+MODULE_AUTHOR("Steven Toth <stoth@kernellabs.com>");
+MODULE_LICENSE("GPL");
+
+/*
+  1 Basic
+  2
+  4 i2c
+  8 api
+ 16 cmd
+ 32 bus
+ */
+
+unsigned int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "enable debug messages");
+
+unsigned int waitsecs = 10;
+module_param(waitsecs, int, 0644);
+MODULE_PARM_DESC(debug, "timeout on firmware messages");
+
+static unsigned int card[]  = {[0 ... (SAA7164_MAXBOARDS - 1)] = UNSET };
+module_param_array(card,  int, NULL, 0444);
+MODULE_PARM_DESC(card, "card type");
+
+static unsigned int saa7164_devcount;
+
+static DEFINE_MUTEX(devlist);
+LIST_HEAD(saa7164_devlist);
+
+#define INT_SIZE 16
+
+static void saa7164_work_cmdhandler(struct work_struct *w)
+{
+        struct saa7164_dev *dev = container_of(w, struct saa7164_dev, workcmd);
+
+        /* Wake up any complete commands */
+        saa7164_irq_dequeue(dev);
+}
+
+static void saa7164_buffer_deliver(struct saa7164_buffer *buf)
+{
+        struct saa7164_tsport *port = buf->port;
+
+        /* Feed the transport payload into the kernel demux */
+        dvb_dmx_swfilter_packets(&port->dvb.demux, (u8 *)buf->cpu,
+                SAA7164_TS_NUMBER_OF_LINES);
+
+}
+
+static irqreturn_t saa7164_irq_ts(struct saa7164_tsport *port)
+{
+        struct saa7164_dev *dev = port->dev;
+        struct saa7164_buffer *buf;
+        struct list_head *c, *n;
+        int wp, i = 0, rp;
+
+        /* Find the current write point from the hardware */
+        wp = saa7164_readl(port->bufcounter);
+        if (wp > (port->hwcfg.buffercount - 1))
+                BUG();
+
+        /* Find the previous buffer to the current write point */
+        if (wp == 0)
+                rp = 7;
+        else
+                rp = wp - 1;
+
+        /* Lookup the WP in the buffer list */
+        /* TODO: turn this into a worker thread */
+        list_for_each_safe(c, n, &port->dmaqueue.list) {
+                buf = list_entry(c, struct saa7164_buffer, list);
+                if (i++ > port->hwcfg.buffercount)
+                        BUG();
+
+                if (buf->nr == rp) {
+                        /* Found the buffer, deal with it */
+                        dprintk(DBGLVL_IRQ, "%s() wp: %d processing: %d\n",
+                                __func__, wp, rp);
+                        saa7164_buffer_deliver(buf);
+                        break;
+                }
+
+        }
+        return 0;
+}
+
+/* Primary IRQ handler and dispatch mechanism */
+static irqreturn_t saa7164_irq(int irq, void *dev_id)
+{
+        struct saa7164_dev *dev = dev_id;
+        u32 intid, intstat[INT_SIZE/4];
+        int i, handled = 0, bit;
+
+        if (dev == 0) {
+                printk(KERN_ERR "%s() No device specified\n", __func__);
+                handled = 0;
+                goto out;
+        }
+
+        /* Check that the hardware is accessable. If the status bytes are
+         * 0xFF then the device is not accessable, the the IRQ belongs
+         * to another driver.
+         * 4 x u32 interrupt registers.
+         */
+        for (i = 0; i < INT_SIZE/4; i++) {
+
+                /* TODO: Convert into saa7164_readl() */
+                /* Read the 4 hardware interrupt registers */
+                intstat[i] = saa7164_readl(dev->int_status + (i * 4));
+
+                if (intstat[i])
+                        handled = 1;
+        }
+        if (handled == 0)
+                goto out;
+
+        /* For each of the HW interrupt registers */
+        for (i = 0; i < INT_SIZE/4; i++) {
+
+                if (intstat[i]) {
+                        /* Each function of the board has it's own interruptid.
+                         * Find the function that triggered then call
+                         * it's handler.
+                         */
+                        for (bit = 0; bit < 32; bit++) {
+
+                                if (((intstat[i] >> bit) & 0x00000001) == 0)
+                                        continue;
+
+                                /* Calculate the interrupt id (0x00 to 0x7f) */
+
+                                intid = (i * 32) + bit;
+                                if (intid == dev->intfdesc.bInterruptId) {
+                                        /* A response to an cmd/api call */
+                                        schedule_work(&dev->workcmd);
+                                } else if (intid ==
+                                        dev->ts1.hwcfg.interruptid) {
+
+                                        /* Transport path 1 */
+                                        saa7164_irq_ts(&dev->ts1);
+
+                                } else if (intid ==
+                                        dev->ts2.hwcfg.interruptid) {
+
+                                        /* Transport path 2 */
+                                        saa7164_irq_ts(&dev->ts2);
+
+                                } else {
+                                        /* Find the function */
+                                        dprintk(DBGLVL_IRQ,
+                                                "%s() unhandled interrupt "
+                                                "reg 0x%x bit 0x%x "
+                                                "intid = 0x%x\n",
+                                                __func__, i, bit, intid);
+                                }
+                        }
+
+                        /* Ack it */
+                        saa7164_writel(dev->int_ack + (i * 4), intstat[i]);
+
+                }
+        }
+out:
+        return IRQ_RETVAL(handled);
+}
+
+void saa7164_getfirmwarestatus(struct saa7164_dev *dev)
+{
+        struct saa7164_fw_status *s = &dev->fw_status;
+
+        dev->fw_status.status = saa7164_readl(SAA_DEVICE_SYSINIT_STATUS);
+        dev->fw_status.mode = saa7164_readl(SAA_DEVICE_SYSINIT_MODE);
+        dev->fw_status.spec = saa7164_readl(SAA_DEVICE_SYSINIT_SPEC);
+        dev->fw_status.inst = saa7164_readl(SAA_DEVICE_SYSINIT_INST);
+        dev->fw_status.cpuload = saa7164_readl(SAA_DEVICE_SYSINIT_CPULOAD);
+        dev->fw_status.remainheap =
+                saa7164_readl(SAA_DEVICE_SYSINIT_REMAINHEAP);
+
+        dprintk(1, "Firmware status:\n");
+        dprintk(1, " .status     = 0x%08x\n", s->status);
+        dprintk(1, " .mode       = 0x%08x\n", s->mode);
+        dprintk(1, " .spec       = 0x%08x\n", s->spec);
+        dprintk(1, " .inst       = 0x%08x\n", s->inst);
+        dprintk(1, " .cpuload    = 0x%08x\n", s->cpuload);
+        dprintk(1, " .remainheap = 0x%08x\n", s->remainheap);
+}
+
+u32 saa7164_getcurrentfirmwareversion(struct saa7164_dev *dev)
+{
+        u32 reg;
+
+        reg = saa7164_readl(SAA_DEVICE_VERSION);
+        dprintk(1, "Device running firmware version %d.%d.%d.%d (0x%x)\n",
+                (reg & 0x0000fc00) >> 10,
+                (reg & 0x000003e0) >> 5,
+                (reg & 0x0000001f),
+                (reg & 0xffff0000) >> 16,
+                reg);
+
+        return reg;
+}
+
+/* TODO: Debugging func, remove */
+void saa7164_dumphex16(struct saa7164_dev *dev, u8 *buf, int len)
+{
+        int i;
+
+        printk(KERN_INFO "--------------------> "
+                "00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n");
+
+        for (i = 0; i < len; i += 16)
+                printk(KERN_INFO "         [0x%08x] "
+                        "%02x %02x %02x %02x %02x %02x %02x %02x "
+                        "%02x %02x %02x %02x %02x %02x %02x %02x\n", i,
+                *(buf+i+0), *(buf+i+1), *(buf+i+2), *(buf+i+3),
+                *(buf+i+4), *(buf+i+5), *(buf+i+6), *(buf+i+7),
+                *(buf+i+8), *(buf+i+9), *(buf+i+10), *(buf+i+11),
+                *(buf+i+12), *(buf+i+13), *(buf+i+14), *(buf+i+15));
+}
+
+/* TODO: Debugging func, remove */
+void saa7164_dumpregs(struct saa7164_dev *dev, u32 addr)
+{
+        int i;
+
+        dprintk(1, "--------------------> "
+                "00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n");
+
+        for (i = 0; i < 0x100; i += 16)
+                dprintk(1, "region0[0x%08x] = "
+                        "%02x %02x %02x %02x %02x %02x %02x %02x"
+                        " %02x %02x %02x %02x %02x %02x %02x %02x\n", i,
+                        (u8)saa7164_readb(addr + i + 0),
+                        (u8)saa7164_readb(addr + i + 1),
+                        (u8)saa7164_readb(addr + i + 2),
+                        (u8)saa7164_readb(addr + i + 3),
+                        (u8)saa7164_readb(addr + i + 4),
+                        (u8)saa7164_readb(addr + i + 5),
+                        (u8)saa7164_readb(addr + i + 6),
+                        (u8)saa7164_readb(addr + i + 7),
+                        (u8)saa7164_readb(addr + i + 8),
+                        (u8)saa7164_readb(addr + i + 9),
+                        (u8)saa7164_readb(addr + i + 10),
+                        (u8)saa7164_readb(addr + i + 11),
+                        (u8)saa7164_readb(addr + i + 12),
+                        (u8)saa7164_readb(addr + i + 13),
+                        (u8)saa7164_readb(addr + i + 14),
+                        (u8)saa7164_readb(addr + i + 15)
+                        );
+}
+
+static void saa7164_dump_hwdesc(struct saa7164_dev *dev)
+{
+        dprintk(1, "@0x%p hwdesc sizeof(tmComResHWDescr_t) = %d bytes\n",
+                &dev->hwdesc, (u32)sizeof(tmComResHWDescr_t));
+
+        dprintk(1, " .bLength = 0x%x\n", dev->hwdesc.bLength);
+        dprintk(1, " .bDescriptorType = 0x%x\n", dev->hwdesc.bDescriptorType);
+        dprintk(1, " .bDescriptorSubtype = 0x%x\n",
+                dev->hwdesc.bDescriptorSubtype);
+
+        dprintk(1, " .bcdSpecVersion = 0x%x\n", dev->hwdesc.bcdSpecVersion);
+        dprintk(1, " .dwClockFrequency = 0x%x\n", dev->hwdesc.dwClockFrequency);
+        dprintk(1, " .dwClockUpdateRes = 0x%x\n", dev->hwdesc.dwClockUpdateRes);
+        dprintk(1, " .bCapabilities = 0x%x\n", dev->hwdesc.bCapabilities);
+        dprintk(1, " .dwDeviceRegistersLocation = 0x%x\n",
+                dev->hwdesc.dwDeviceRegistersLocation);
+
+        dprintk(1, " .dwHostMemoryRegion = 0x%x\n",
+                dev->hwdesc.dwHostMemoryRegion);
+
+        dprintk(1, " .dwHostMemoryRegionSize = 0x%x\n",
+                dev->hwdesc.dwHostMemoryRegionSize);
+
+        dprintk(1, " .dwHostHibernatMemRegion = 0x%x\n",
+                dev->hwdesc.dwHostHibernatMemRegion);
+
+        dprintk(1, " .dwHostHibernatMemRegionSize = 0x%x\n",
+                dev->hwdesc.dwHostHibernatMemRegionSize);
+}
+
+static void saa7164_dump_intfdesc(struct saa7164_dev *dev)
+{
+        dprintk(1, "@0x%p intfdesc "
+                "sizeof(tmComResInterfaceDescr_t) = %d bytes\n",
+                &dev->intfdesc, (u32)sizeof(tmComResInterfaceDescr_t));
+
+        dprintk(1, " .bLength = 0x%x\n", dev->intfdesc.bLength);
+        dprintk(1, " .bDescriptorType = 0x%x\n", dev->intfdesc.bDescriptorType);
+        dprintk(1, " .bDescriptorSubtype = 0x%x\n",
+                dev->intfdesc.bDescriptorSubtype);
+
+        dprintk(1, " .bFlags = 0x%x\n", dev->intfdesc.bFlags);
+        dprintk(1, " .bInterfaceType = 0x%x\n", dev->intfdesc.bInterfaceType);
+        dprintk(1, " .bInterfaceId = 0x%x\n", dev->intfdesc.bInterfaceId);
+        dprintk(1, " .bBaseInterface = 0x%x\n", dev->intfdesc.bBaseInterface);
+        dprintk(1, " .bInterruptId = 0x%x\n", dev->intfdesc.bInterruptId);
+        dprintk(1, " .bDebugInterruptId = 0x%x\n",
+                dev->intfdesc.bDebugInterruptId);
+
+        dprintk(1, " .BARLocation = 0x%x\n", dev->intfdesc.BARLocation);
+}
+
+static void saa7164_dump_busdesc(struct saa7164_dev *dev)
+{
+        dprintk(1, "@0x%p busdesc sizeof(tmComResBusDescr_t) = %d bytes\n",
+                &dev->busdesc, (u32)sizeof(tmComResBusDescr_t));
+
+        dprintk(1, " .CommandRing   = 0x%016Lx\n", dev->busdesc.CommandRing);
+        dprintk(1, " .ResponseRing  = 0x%016Lx\n", dev->busdesc.ResponseRing);
+        dprintk(1, " .CommandWrite  = 0x%x\n", dev->busdesc.CommandWrite);
+        dprintk(1, " .CommandRead   = 0x%x\n", dev->busdesc.CommandRead);
+        dprintk(1, " .ResponseWrite = 0x%x\n", dev->busdesc.ResponseWrite);
+        dprintk(1, " .ResponseRead  = 0x%x\n", dev->busdesc.ResponseRead);
+}
+
+/* Much of the hardware configuration and PCI registers are configured
+ * dynamically depending on firmware. We have to cache some initial
+ * structures then use these to locate other important structures
+ * from PCI space.
+ */
+static void saa7164_get_descriptors(struct saa7164_dev *dev)
+{
+        memcpy(&dev->hwdesc, dev->bmmio, sizeof(tmComResHWDescr_t));
+        memcpy(&dev->intfdesc, dev->bmmio + sizeof(tmComResHWDescr_t),
+                sizeof(tmComResInterfaceDescr_t));
+        memcpy(&dev->busdesc, dev->bmmio + dev->intfdesc.BARLocation,
+                sizeof(tmComResBusDescr_t));
+
+        if (dev->hwdesc.bLength != sizeof(tmComResHWDescr_t)) {
+                printk(KERN_ERR "Structure tmComResHWDescr_t is mangled\n");
+                printk(KERN_ERR "Need %x got %d\n", dev->hwdesc.bLength,
+                        (u32)sizeof(tmComResHWDescr_t));
+        } else
+                saa7164_dump_hwdesc(dev);
+
+        if (dev->intfdesc.bLength != sizeof(tmComResInterfaceDescr_t)) {
+                printk(KERN_ERR "struct tmComResInterfaceDescr_t is mangled\n");
+                printk(KERN_ERR "Need %x got %d\n", dev->intfdesc.bLength,
+                        (u32)sizeof(tmComResInterfaceDescr_t));
+        } else
+                saa7164_dump_intfdesc(dev);
+
+        saa7164_dump_busdesc(dev);
+}
+
+static int saa7164_pci_quirks(struct saa7164_dev *dev)
+{
+        return 0;
+}
+
+static int get_resources(struct saa7164_dev *dev)
+{
+        if (request_mem_region(pci_resource_start(dev->pci, 0),
+                pci_resource_len(dev->pci, 0), dev->name)) {
+
+                if (request_mem_region(pci_resource_start(dev->pci, 2),
+                        pci_resource_len(dev->pci, 2), dev->name))
+                        return 0;
+        }
+
+        printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx or 0x%llx\n",
+                dev->name,
+                (u64)pci_resource_start(dev->pci, 0),
+                (u64)pci_resource_start(dev->pci, 2));
+
+        return -EBUSY;
+}
+
+static int saa7164_dev_setup(struct saa7164_dev *dev)
+{
+        int i;
+
+        mutex_init(&dev->lock);
+        atomic_inc(&dev->refcount);
+        dev->nr = saa7164_devcount++;
+
+        sprintf(dev->name, "saa7164[%d]", dev->nr);
+
+        mutex_lock(&devlist);
+        list_add_tail(&dev->devlist, &saa7164_devlist);
+        mutex_unlock(&devlist);
+
+        /* board config */
+        dev->board = UNSET;
+        if (card[dev->nr] < saa7164_bcount)
+                dev->board = card[dev->nr];
+
+        for (i = 0; UNSET == dev->board  &&  i < saa7164_idcount; i++)
+                if (dev->pci->subsystem_vendor == saa7164_subids[i].subvendor &&
+                        dev->pci->subsystem_device ==
+                                saa7164_subids[i].subdevice)
+                                dev->board = saa7164_subids[i].card;
+
+        if (UNSET == dev->board) {
+                dev->board = SAA7164_BOARD_UNKNOWN;
+                saa7164_card_list(dev);
+        }
+
+        dev->pci_bus  = dev->pci->bus->number;
+        dev->pci_slot = PCI_SLOT(dev->pci->devfn);
+
+        /* I2C Defaults / setup */
+        dev->i2c_bus[0].dev = dev;
+        dev->i2c_bus[0].nr = 0;
+        dev->i2c_bus[1].dev = dev;
+        dev->i2c_bus[1].nr = 1;
+        dev->i2c_bus[2].dev = dev;
+        dev->i2c_bus[2].nr = 2;
+
+        /* Transport port A Defaults / setup */
+        dev->ts1.dev = dev;
+        dev->ts1.nr = 0;
+        mutex_init(&dev->ts1.dvb.lock);
+        INIT_LIST_HEAD(&dev->ts1.dmaqueue.list);
+        INIT_LIST_HEAD(&dev->ts1.dummy_dmaqueue.list);
+        mutex_init(&dev->ts1.dmaqueue_lock);
+        mutex_init(&dev->ts1.dummy_dmaqueue_lock);
+
+        /* Transport port B Defaults / setup */
+        dev->ts2.dev = dev;
+        dev->ts2.nr = 1;
+        mutex_init(&dev->ts2.dvb.lock);
+        INIT_LIST_HEAD(&dev->ts2.dmaqueue.list);
+        INIT_LIST_HEAD(&dev->ts2.dummy_dmaqueue.list);
+        mutex_init(&dev->ts2.dmaqueue_lock);
+        mutex_init(&dev->ts2.dummy_dmaqueue_lock);
+
+        if (get_resources(dev) < 0) {
+                printk(KERN_ERR "CORE %s No more PCIe resources for "
+                       "subsystem: %04x:%04x\n",
+                       dev->name, dev->pci->subsystem_vendor,
+                       dev->pci->subsystem_device);
+
+                saa7164_devcount--;
+                return -ENODEV;
+        }
+
+        /* PCI/e allocations */
+        dev->lmmio = ioremap(pci_resource_start(dev->pci, 0),
+                             pci_resource_len(dev->pci, 0));
+
+        dev->lmmio2 = ioremap(pci_resource_start(dev->pci, 2),
+                             pci_resource_len(dev->pci, 2));
+
+        dev->bmmio = (u8 __iomem *)dev->lmmio;
+        dev->bmmio2 = (u8 __iomem *)dev->lmmio2;
+
+        /* Inerrupt and ack register locations offset of bmmio */
+        dev->int_status = 0x183000 + 0xf80;
+        dev->int_ack = 0x183000 + 0xf90;
+
+        printk(KERN_INFO
+                "CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
+               dev->name, dev->pci->subsystem_vendor,
+               dev->pci->subsystem_device, saa7164_boards[dev->board].name,
+               dev->board, card[dev->nr] == dev->board ?
+               "insmod option" : "autodetected");
+
+        saa7164_pci_quirks(dev);
+
+        return 0;
+}
+
+static void saa7164_dev_unregister(struct saa7164_dev *dev)
+{
+        dprintk(1, "%s()\n", __func__);
+
+        release_mem_region(pci_resource_start(dev->pci, 0),
+                pci_resource_len(dev->pci, 0));
+
+        release_mem_region(pci_resource_start(dev->pci, 2),
+                pci_resource_len(dev->pci, 2));
+
+        if (!atomic_dec_and_test(&dev->refcount))
+                return;
+
+        iounmap(dev->lmmio);
+        iounmap(dev->lmmio2);
+
+        return;
+}
+
+static int __devinit saa7164_initdev(struct pci_dev *pci_dev,
+                                     const struct pci_device_id *pci_id)
+{
+        struct saa7164_dev *dev;
+        int err, i;
+        u32 version;
+
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (NULL == dev)
+                return -ENOMEM;
+
+        /* pci init */
+        dev->pci = pci_dev;
+        if (pci_enable_device(pci_dev)) {
+                err = -EIO;
+                goto fail_free;
+        }
+
+        if (saa7164_dev_setup(dev) < 0) {
+                err = -EINVAL;
+                goto fail_free;
+        }
+
+        /* print pci info */
+        pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
+        pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
+        printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, "
+               "latency: %d, mmio: 0x%llx\n", dev->name,
+               pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
+               dev->pci_lat,
+                (unsigned long long)pci_resource_start(pci_dev, 0));
+
+        pci_set_master(pci_dev);
+        /* TODO */
+        if (!pci_dma_supported(pci_dev, 0xffffffff)) {
+                printk("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name);
+                err = -EIO;
+                goto fail_irq;
+        }
+
+        err = request_irq(pci_dev->irq, saa7164_irq,
+                IRQF_SHARED | IRQF_DISABLED, dev->name, dev);
+        if (err < 0) {
+                printk(KERN_ERR "%s: can't get IRQ %d\n", dev->name,
+                        pci_dev->irq);
+                err = -EIO;
+                goto fail_irq;
+        }
+
+        pci_set_drvdata(pci_dev, dev);
+
+        /* Init the internal command list */
+        for (i = 0; i < SAA_CMD_MAX_MSG_UNITS; i++) {
+                dev->cmds[i].seqno = i;
+                dev->cmds[i].inuse = 0;
+                mutex_init(&dev->cmds[i].lock);
+                init_waitqueue_head(&dev->cmds[i].wait);
+        }
+
+        /* We need a deferred interrupt handler for cmd handling */
+        INIT_WORK(&dev->workcmd, saa7164_work_cmdhandler);
+
+        /* Only load the firmware if we know the board */
+        if (dev->board != SAA7164_BOARD_UNKNOWN) {
+
+                err = saa7164_downloadfirmware(dev);
+                if (err < 0) {
+                        printk(KERN_ERR
+                                "Failed to boot firmware, no features "
+                                "registered\n");
+                        goto fail_fw;
+                }
+
+                saa7164_get_descriptors(dev);
+                saa7164_dumpregs(dev, 0);
+                saa7164_getcurrentfirmwareversion(dev);
+                saa7164_getfirmwarestatus(dev);
+                err = saa7164_bus_setup(dev);
+                if (err < 0)
+                        printk(KERN_ERR
+                                "Failed to setup the bus, will continue\n");
+                saa7164_bus_dump(dev);
+
+                /* Ping the running firmware via the command bus and get the
+                 * firmware version, this checks the bus is running OK.
+                 */
+                version = 0;
+                if (saa7164_api_get_fw_version(dev, &version) == SAA_OK)
+                        dprintk(1, "Bus is operating correctly using "
+                                "version %d.%d.%d.%d (0x%x)\n",
+                                (version & 0x0000fc00) >> 10,
+                                (version & 0x000003e0) >> 5,
+                                (version & 0x0000001f),
+                                (version & 0xffff0000) >> 16,
+                                version);
+                else
+                        printk(KERN_ERR
+                                "Failed to communicate with the firmware\n");
+
+                /* Bring up the I2C buses */
+                saa7164_i2c_register(&dev->i2c_bus[0]);
+                saa7164_i2c_register(&dev->i2c_bus[1]);
+                saa7164_i2c_register(&dev->i2c_bus[2]);
+                saa7164_gpio_setup(dev);
+                saa7164_card_setup(dev);
+
+
+                /* Parse the dynamic device configuration, find various
+                 * media endpoints (MPEG, WMV, PS, TS) and cache their
+                 * configuration details into the driver, so we can
+                 * reference them later during simething_register() func,
+                 * interrupt handlers, deferred work handlers etc.
+                 */
+                saa7164_api_enum_subdevs(dev);
+
+                /* Begin to create the video sub-systems and register funcs */
+                if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB) {
+                        if (saa7164_dvb_register(&dev->ts1) < 0) {
+                                printk(KERN_ERR "%s() Failed to register "
+                                        "dvb adapters on porta\n",
+                                        __func__);
+                        }
+                }
+
+                if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB) {
+                        if (saa7164_dvb_register(&dev->ts2) < 0) {
+                                printk(KERN_ERR"%s() Failed to register "
+                                        "dvb adapters on portb\n",
+                                        __func__);
+                        }
+                }
+
+        } /* != BOARD_UNKNOWN */
+        else
+                printk(KERN_ERR "%s() Unsupported board detected, "
+                        "registering without firmware\n", __func__);
+
+        dprintk(1, "%s() parameter debug = %d\n", __func__, debug);
+        dprintk(1, "%s() parameter waitsecs = %d\n", __func__, waitsecs);
+
+fail_fw:
+        return 0;
+
+fail_irq:
+        saa7164_dev_unregister(dev);
+fail_free:
+        kfree(dev);
+        return err;
+}
+
+static void saa7164_shutdown(struct saa7164_dev *dev)
+{
+        dprintk(1, "%s()\n", __func__);
+}
+
+static void __devexit saa7164_finidev(struct pci_dev *pci_dev)
+{
+        struct saa7164_dev *dev = pci_get_drvdata(pci_dev);
+
+        saa7164_shutdown(dev);
+
+        if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB)
+                saa7164_dvb_unregister(&dev->ts1);
+
+        if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB)
+                saa7164_dvb_unregister(&dev->ts2);
+
+        saa7164_i2c_unregister(&dev->i2c_bus[0]);
+        saa7164_i2c_unregister(&dev->i2c_bus[1]);
+        saa7164_i2c_unregister(&dev->i2c_bus[2]);
+
+        pci_disable_device(pci_dev);
+
+        /* unregister stuff */
+        free_irq(pci_dev->irq, dev);
+        pci_set_drvdata(pci_dev, NULL);
+
+        mutex_lock(&devlist);
+        list_del(&dev->devlist);
+        mutex_unlock(&devlist);
+
+        saa7164_dev_unregister(dev);
+        kfree(dev);
+}
+
+static struct pci_device_id saa7164_pci_tbl[] = {
+        {
+                /* SAA7164 */
+                .vendor       = 0x1131,
+                .device       = 0x7164,
+                .subvendor    = PCI_ANY_ID,
+                .subdevice    = PCI_ANY_ID,
+        }, {
+                /* --- end of list --- */
+        }
+};
+MODULE_DEVICE_TABLE(pci, saa7164_pci_tbl);
+
+static struct pci_driver saa7164_pci_driver = {
+        .name     = "saa7164",
+        .id_table = saa7164_pci_tbl,
+        .probe    = saa7164_initdev,
+        .remove   = __devexit_p(saa7164_finidev),
+        /* TODO */
+        .suspend  = NULL,
+        .resume   = NULL,
+};
+
+static int saa7164_init(void)
+{
+        printk(KERN_INFO "saa7164 driver loaded\n");
+        return pci_register_driver(&saa7164_pci_driver);
+}
+
+static void saa7164_fini(void)
+{
+        pci_unregister_driver(&saa7164_pci_driver);
+}
+
+module_init(saa7164_init);
+module_exit(saa7164_fini);
+
diff --git a/drivers/media/video/saa7164/saa7164-dvb.c b/drivers/media/video/saa7164/saa7164-dvb.c
new file mode 100644
index 000000000000..6a2d847d6a88
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-dvb.c
@@ -0,0 +1,602 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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 "saa7164.h"
+
+#include "tda10048.h"
+#include "tda18271.h"
+#include "s5h1411.h"
+
+#define DRIVER_NAME "saa7164"
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+/* addr is in the card struct, get it from there */
+static struct tda10048_config hauppauge_hvr2200_1_config = {
+        .demod_address    = 0x10 >> 1,
+        .output_mode      = TDA10048_SERIAL_OUTPUT,
+        .fwbulkwritelen   = TDA10048_BULKWRITE_200,
+        .inversion        = TDA10048_INVERSION_ON,
+        .dtv6_if_freq_khz = TDA10048_IF_3300,
+        .dtv7_if_freq_khz = TDA10048_IF_3500,
+        .dtv8_if_freq_khz = TDA10048_IF_4000,
+        .clk_freq_khz     = TDA10048_CLK_16000,
+};
+static struct tda10048_config hauppauge_hvr2200_2_config = {
+        .demod_address    = 0x12 >> 1,
+        .output_mode      = TDA10048_SERIAL_OUTPUT,
+        .fwbulkwritelen   = TDA10048_BULKWRITE_200,
+        .inversion        = TDA10048_INVERSION_ON,
+        .dtv6_if_freq_khz = TDA10048_IF_3300,
+        .dtv7_if_freq_khz = TDA10048_IF_3500,
+        .dtv8_if_freq_khz = TDA10048_IF_4000,
+        .clk_freq_khz     = TDA10048_CLK_16000,
+};
+
+static struct tda18271_std_map hauppauge_tda18271_std_map = {
+        .atsc_6   = { .if_freq = 3250, .agc_mode = 3, .std = 3,
+                      .if_lvl = 6, .rfagc_top = 0x37 },
+        .qam_6    = { .if_freq = 4000, .agc_mode = 3, .std = 0,
+                      .if_lvl = 6, .rfagc_top = 0x37 },
+};
+
+static struct tda18271_config hauppauge_hvr22x0_tuner_config = {
+        .std_map        = &hauppauge_tda18271_std_map,
+        .gate           = TDA18271_GATE_ANALOG,
+        .role           = TDA18271_MASTER,
+};
+
+static struct tda18271_config hauppauge_hvr22x0s_tuner_config = {
+        .std_map        = &hauppauge_tda18271_std_map,
+        .gate           = TDA18271_GATE_ANALOG,
+        .role           = TDA18271_SLAVE,
+        .rf_cal_on_startup = 1
+};
+
+static struct s5h1411_config hauppauge_s5h1411_config = {
+        .output_mode   = S5H1411_SERIAL_OUTPUT,
+        .gpio          = S5H1411_GPIO_ON,
+        .qam_if        = S5H1411_IF_4000,
+        .vsb_if        = S5H1411_IF_3250,
+        .inversion     = S5H1411_INVERSION_ON,
+        .status_mode   = S5H1411_DEMODLOCKING,
+        .mpeg_timing   = S5H1411_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
+};
+
+static int saa7164_dvb_stop_tsport(struct saa7164_tsport *port)
+{
+        struct saa7164_dev *dev = port->dev;
+        int ret;
+
+        ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
+        if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
+                printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
+                        __func__, ret);
+                ret = -EIO;
+        } else {
+                dprintk(DBGLVL_DVB, "%s()    Stopped\n", __func__);
+                ret = 0;
+        }
+
+        return ret;
+}
+
+static int saa7164_dvb_acquire_tsport(struct saa7164_tsport *port)
+{
+        struct saa7164_dev *dev = port->dev;
+        int ret;
+
+        ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
+        if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
+                printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
+                        __func__, ret);
+                ret = -EIO;
+        } else {
+                dprintk(DBGLVL_DVB, "%s() Acquired\n", __func__);
+                ret = 0;
+        }
+
+        return ret;
+}
+
+static int saa7164_dvb_pause_tsport(struct saa7164_tsport *port)
+{
+        struct saa7164_dev *dev = port->dev;
+        int ret;
+
+        ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
+        if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
+                printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
+                        __func__, ret);
+                ret = -EIO;
+        } else {
+                dprintk(DBGLVL_DVB, "%s()   Paused\n", __func__);
+                ret = 0;
+        }
+
+        return ret;
+}
+
+/* Firmware is very windows centric, meaning you have to transition
+ * the part through AVStream / KS Windows stages, forwards or backwards.
+ * States are: stopped, acquired (h/w), paused, started.
+ */
+static int saa7164_dvb_stop_streaming(struct saa7164_tsport *port)
+{
+        struct saa7164_dev *dev = port->dev;
+        int ret;
+
+        dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
+
+        ret = saa7164_dvb_pause_tsport(port);
+        ret = saa7164_dvb_acquire_tsport(port);
+        ret = saa7164_dvb_stop_tsport(port);
+
+        return ret;
+}
+
+static int saa7164_dvb_cfg_tsport(struct saa7164_tsport *port)
+{
+        tmHWStreamParameters_t *params = &port->hw_streamingparams;
+        struct saa7164_dev *dev = port->dev;
+        struct saa7164_buffer *buf;
+        struct list_head *c, *n;
+        int i = 0;
+
+        dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
+
+        saa7164_writel(port->pitch, params->pitch);
+        saa7164_writel(port->bufsize, params->pitch * params->numberoflines);
+
+        dprintk(DBGLVL_DVB, " configured:\n");
+        dprintk(DBGLVL_DVB, "   lmmio       0x%p\n", dev->lmmio);
+        dprintk(DBGLVL_DVB, "   bufcounter  0x%x = 0x%x\n", port->bufcounter,
+                saa7164_readl(port->bufcounter));
+
+        dprintk(DBGLVL_DVB, "   pitch       0x%x = %d\n", port->pitch,
+                saa7164_readl(port->pitch));
+
+        dprintk(DBGLVL_DVB, "   bufsize     0x%x = %d\n", port->bufsize,
+                saa7164_readl(port->bufsize));
+
+        dprintk(DBGLVL_DVB, "   buffercount = %d\n", port->hwcfg.buffercount);
+        dprintk(DBGLVL_DVB, "   bufoffset = 0x%x\n", port->bufoffset);
+        dprintk(DBGLVL_DVB, "   bufptr32h = 0x%x\n", port->bufptr32h);
+        dprintk(DBGLVL_DVB, "   bufptr32l = 0x%x\n", port->bufptr32l);
+
+        /* Poke the buffers and offsets into PCI space */
+        mutex_lock(&port->dmaqueue_lock);
+        list_for_each_safe(c, n, &port->dmaqueue.list) {
+                buf = list_entry(c, struct saa7164_buffer, list);
+
+                /* TODO: Review this in light of 32v64 assignments */
+                saa7164_writel(port->bufoffset + (sizeof(u32) * i), 0);
+                saa7164_writel(port->bufptr32h + ((sizeof(u32) * 2) * i),
+                        buf->pt_dma);
+                saa7164_writel(port->bufptr32l + ((sizeof(u32) * 2) * i), 0);
+
+                dprintk(DBGLVL_DVB,
+                        "   buf[%d] offset 0x%llx (0x%x) "
+                        "buf 0x%llx/%llx (0x%x/%x)\n",
+                        i,
+                        (u64)port->bufoffset + (i * sizeof(u32)),
+                        saa7164_readl(port->bufoffset + (sizeof(u32) * i)),
+                        (u64)port->bufptr32h + ((sizeof(u32) * 2) * i),
+                        (u64)port->bufptr32l + ((sizeof(u32) * 2) * i),
+                        saa7164_readl(port->bufptr32h + ((sizeof(u32) * i)
+                                * 2)),
+                        saa7164_readl(port->bufptr32l + ((sizeof(u32) * i)
+                                * 2)));
+
+                if (i++ > port->hwcfg.buffercount)
+                        BUG();
+
+        }
+        mutex_unlock(&port->dmaqueue_lock);
+
+        return 0;
+}
+
+static int saa7164_dvb_start_tsport(struct saa7164_tsport *port)
+{
+        struct saa7164_dev *dev = port->dev;
+        int ret = 0, result;
+
+        dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
+
+        saa7164_dvb_cfg_tsport(port);
+
+        /* Acquire the hardware */
+        result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
+        if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
+                printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
+                        __func__, result);
+
+                /* Stop the hardware, regardless */
+                result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
+                if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
+                        printk(KERN_ERR "%s() acquire/forced stop transition "
+                                "failed, res = 0x%x\n", __func__, result);
+                }
+                ret = -EIO;
+                goto out;
+        } else
+                dprintk(DBGLVL_DVB, "%s()   Acquired\n", __func__);
+
+        /* Pause the hardware */
+        result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
+        if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
+                printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
+                                __func__, result);
+
+                /* Stop the hardware, regardless */
+                result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
+                if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
+                        printk(KERN_ERR "%s() pause/forced stop transition "
+                                "failed, res = 0x%x\n", __func__, result);
+                }
+
+                ret = -EIO;
+                goto out;
+        } else
+                dprintk(DBGLVL_DVB, "%s()   Paused\n", __func__);
+
+        /* Start the hardware */
+        result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
+        if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
+                printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
+                                __func__, result);
+
+                /* Stop the hardware, regardless */
+                result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
+                if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
+                        printk(KERN_ERR "%s() run/forced stop transition "
+                                "failed, res = 0x%x\n", __func__, result);
+                }
+
+                ret = -EIO;
+        } else
+                dprintk(DBGLVL_DVB, "%s()   Running\n", __func__);
+
+out:
+        return ret;
+}
+
+static int saa7164_dvb_start_feed(struct dvb_demux_feed *feed)
+{
+        struct dvb_demux *demux = feed->demux;
+        struct saa7164_tsport *port = (struct saa7164_tsport *) demux->priv;
+        struct saa7164_dvb *dvb = &port->dvb;
+        struct saa7164_dev *dev = port->dev;
+        int ret = 0;
+
+        dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
+
+        if (!demux->dmx.frontend)
+                return -EINVAL;
+
+        if (dvb) {
+                mutex_lock(&dvb->lock);
+                if (dvb->feeding++ == 0) {
+                        /* Start transport */
+                        ret = saa7164_dvb_start_tsport(port);
+                }
+                mutex_unlock(&dvb->lock);
+                dprintk(DBGLVL_DVB, "%s(port=%d) now feeding = %d\n",
+                        __func__, port->nr, dvb->feeding);
+        }
+
+        return ret;
+}
+
+static int saa7164_dvb_stop_feed(struct dvb_demux_feed *feed)
+{
+        struct dvb_demux *demux = feed->demux;
+        struct saa7164_tsport *port = (struct saa7164_tsport *) demux->priv;
+        struct saa7164_dvb *dvb = &port->dvb;
+        struct saa7164_dev *dev = port->dev;
+        int ret = 0;
+
+        dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
+
+        if (dvb) {
+                mutex_lock(&dvb->lock);
+                if (--dvb->feeding == 0) {
+                        /* Stop transport */
+                        ret = saa7164_dvb_stop_streaming(port);
+                }
+                mutex_unlock(&dvb->lock);
+                dprintk(DBGLVL_DVB, "%s(port=%d) now feeding = %d\n",
+                        __func__, port->nr, dvb->feeding);
+        }
+
+        return ret;
+}
+
+static int dvb_register(struct saa7164_tsport *port)
+{
+        struct saa7164_dvb *dvb = &port->dvb;
+        struct saa7164_dev *dev = port->dev;
+        struct saa7164_buffer *buf;
+        int result, i;
+
+        dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
+
+        /* Sanity check that the PCI configuration space is active */
+        if (port->hwcfg.BARLocation == 0) {
+                result = -ENOMEM;
+                printk(KERN_ERR "%s: dvb_register_adapter failed "
+                       "(errno = %d), NO PCI configuration\n",
+                        DRIVER_NAME, result);
+                goto fail_adapter;
+        }
+
+        /* Init and establish defaults */
+        port->hw_streamingparams.bitspersample = 8;
+        port->hw_streamingparams.samplesperline = 188;
+        port->hw_streamingparams.numberoflines =
+                (SAA7164_TS_NUMBER_OF_LINES * 188) / 188;
+
+        port->hw_streamingparams.pitch = 188;
+        port->hw_streamingparams.linethreshold = 0;
+        port->hw_streamingparams.pagetablelistvirt = 0;
+        port->hw_streamingparams.pagetablelistphys = 0;
+        port->hw_streamingparams.numpagetables = 2 +
+                ((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
+
+        port->hw_streamingparams.numpagetableentries = port->hwcfg.buffercount;
+
+        /* Allocate the PCI resources */
+        for (i = 0; i < port->hwcfg.buffercount; i++) {
+                buf = saa7164_buffer_alloc(port,
+                        port->hw_streamingparams.numberoflines *
+                        port->hw_streamingparams.pitch);
+
+                if (!buf) {
+                        result = -ENOMEM;
+                        printk(KERN_ERR "%s: dvb_register_adapter failed "
+                               "(errno = %d), unable to allocate buffers\n",
+                                DRIVER_NAME, result);
+                        goto fail_adapter;
+                }
+                buf->nr = i;
+
+                mutex_lock(&port->dmaqueue_lock);
+                list_add_tail(&buf->list, &port->dmaqueue.list);
+                mutex_unlock(&port->dmaqueue_lock);
+        }
+
+        /* register adapter */
+        result = dvb_register_adapter(&dvb->adapter, DRIVER_NAME, THIS_MODULE,
+                        &dev->pci->dev, adapter_nr);
+        if (result < 0) {
+                printk(KERN_ERR "%s: dvb_register_adapter failed "
+                       "(errno = %d)\n", DRIVER_NAME, result);
+                goto fail_adapter;
+        }
+        dvb->adapter.priv = port;
+
+        /* register frontend */
+        result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
+        if (result < 0) {
+                printk(KERN_ERR "%s: dvb_register_frontend failed "
+                       "(errno = %d)\n", DRIVER_NAME, result);
+                goto fail_frontend;
+        }
+
+        /* register demux stuff */
+        dvb->demux.dmx.capabilities =
+                DMX_TS_FILTERING | DMX_SECTION_FILTERING |
+                DMX_MEMORY_BASED_FILTERING;
+        dvb->demux.priv       = port;
+        dvb->demux.filternum  = 256;
+        dvb->demux.feednum    = 256;
+        dvb->demux.start_feed = saa7164_dvb_start_feed;
+        dvb->demux.stop_feed  = saa7164_dvb_stop_feed;
+        result = dvb_dmx_init(&dvb->demux);
+        if (result < 0) {
+                printk(KERN_ERR "%s: dvb_dmx_init failed (errno = %d)\n",
+                       DRIVER_NAME, result);
+                goto fail_dmx;
+        }
+
+        dvb->dmxdev.filternum    = 256;
+        dvb->dmxdev.demux        = &dvb->demux.dmx;
+        dvb->dmxdev.capabilities = 0;
+        result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
+        if (result < 0) {
+                printk(KERN_ERR "%s: dvb_dmxdev_init failed (errno = %d)\n",
+                       DRIVER_NAME, result);
+                goto fail_dmxdev;
+        }
+
+        dvb->fe_hw.source = DMX_FRONTEND_0;
+        result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
+        if (result < 0) {
+                printk(KERN_ERR "%s: add_frontend failed "
+                       "(DMX_FRONTEND_0, errno = %d)\n", DRIVER_NAME, result);
+                goto fail_fe_hw;
+        }
+
+        dvb->fe_mem.source = DMX_MEMORY_FE;
+        result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
+        if (result < 0) {
+                printk(KERN_ERR "%s: add_frontend failed "
+                       "(DMX_MEMORY_FE, errno = %d)\n", DRIVER_NAME, result);
+                goto fail_fe_mem;
+        }
+
+        result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
+        if (result < 0) {
+                printk(KERN_ERR "%s: connect_frontend failed (errno = %d)\n",
+                       DRIVER_NAME, result);
+                goto fail_fe_conn;
+        }
+
+        /* register network adapter */
+        dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
+        return 0;
+
+fail_fe_conn:
+        dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
+fail_fe_mem:
+        dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
+fail_fe_hw:
+        dvb_dmxdev_release(&dvb->dmxdev);
+fail_dmxdev:
+        dvb_dmx_release(&dvb->demux);
+fail_dmx:
+        dvb_unregister_frontend(dvb->frontend);
+fail_frontend:
+        dvb_frontend_detach(dvb->frontend);
+        dvb_unregister_adapter(&dvb->adapter);
+fail_adapter:
+        return result;
+}
+
+int saa7164_dvb_unregister(struct saa7164_tsport *port)
+{
+        struct saa7164_dvb *dvb = &port->dvb;
+        struct saa7164_dev *dev = port->dev;
+        struct saa7164_buffer *b;
+        struct list_head *c, *n;
+
+        dprintk(DBGLVL_DVB, "%s()\n", __func__);
+
+        /* Remove any allocated buffers */
+        mutex_lock(&port->dmaqueue_lock);
+        list_for_each_safe(c, n, &port->dmaqueue.list) {
+                b = list_entry(c, struct saa7164_buffer, list);
+                list_del(c);
+                saa7164_buffer_dealloc(port, b);
+        }
+        mutex_unlock(&port->dmaqueue_lock);
+
+        if (dvb->frontend == NULL)
+                return 0;
+
+        dvb_net_release(&dvb->net);
+        dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
+        dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
+        dvb_dmxdev_release(&dvb->dmxdev);
+        dvb_dmx_release(&dvb->demux);
+        dvb_unregister_frontend(dvb->frontend);
+        dvb_frontend_detach(dvb->frontend);
+        dvb_unregister_adapter(&dvb->adapter);
+        return 0;
+}
+
+/* All the DVB attach calls go here, this function get's modified
+ * for each new card.
+ */
+int saa7164_dvb_register(struct saa7164_tsport *port)
+{
+        struct saa7164_dev *dev = port->dev;
+        struct saa7164_dvb *dvb = &port->dvb;
+        struct saa7164_i2c *i2c_bus = NULL;
+        int ret;
+
+        dprintk(DBGLVL_DVB, "%s()\n", __func__);
+
+        /* init frontend */
+        switch (dev->board) {
+        case SAA7164_BOARD_HAUPPAUGE_HVR2200:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2200_2:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2200_3:
+                i2c_bus = &dev->i2c_bus[port->nr + 1];
+                switch (port->nr) {
+                case 0:
+                        port->dvb.frontend = dvb_attach(tda10048_attach,
+                                &hauppauge_hvr2200_1_config,
+                                &i2c_bus->i2c_adap);
+
+                        if (port->dvb.frontend != NULL) {
+                                /* TODO: addr is in the card struct */
+                                dvb_attach(tda18271_attach, port->dvb.frontend,
+                                        0xc0 >> 1, &i2c_bus->i2c_adap,
+                                        &hauppauge_hvr22x0_tuner_config);
+                        }
+
+                        break;
+                case 1:
+                        port->dvb.frontend = dvb_attach(tda10048_attach,
+                                &hauppauge_hvr2200_2_config,
+                                &i2c_bus->i2c_adap);
+
+                        if (port->dvb.frontend != NULL) {
+                                /* TODO: addr is in the card struct */
+                                dvb_attach(tda18271_attach, port->dvb.frontend,
+                                        0xc0 >> 1, &i2c_bus->i2c_adap,
+                                        &hauppauge_hvr22x0s_tuner_config);
+                        }
+
+                        break;
+                }
+                break;
+        case SAA7164_BOARD_HAUPPAUGE_HVR2250:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2250_2:
+        case SAA7164_BOARD_HAUPPAUGE_HVR2250_3:
+                i2c_bus = &dev->i2c_bus[port->nr + 1];
+
+                port->dvb.frontend = dvb_attach(s5h1411_attach,
+                        &hauppauge_s5h1411_config,
+                        &i2c_bus->i2c_adap);
+
+                if (port->dvb.frontend != NULL) {
+                        if (port->nr == 0) {
+                                /* Master TDA18271 */
+                                /* TODO: addr is in the card struct */
+                                dvb_attach(tda18271_attach, port->dvb.frontend,
+                                        0xc0 >> 1, &i2c_bus->i2c_adap,
+                                        &hauppauge_hvr22x0_tuner_config);
+                        } else {
+                                /* Slave TDA18271 */
+                                dvb_attach(tda18271_attach, port->dvb.frontend,
+                                        0xc0 >> 1, &i2c_bus->i2c_adap,
+                                        &hauppauge_hvr22x0s_tuner_config);
+                        }
+                }
+
+                break;
+        default:
+                printk(KERN_ERR "%s: The frontend isn't supported\n",
+                       dev->name);
+                break;
+        }
+        if (NULL == dvb->frontend) {
+                printk(KERN_ERR "%s() Frontend initialization failed\n",
+                       __func__);
+                return -1;
+        }
+
+        /* Put the analog decoder in standby to keep it quiet */
+
+        /* register everything */
+        ret = dvb_register(port);
+        if (ret < 0) {
+                if (dvb->frontend->ops.release)
+                        dvb->frontend->ops.release(dvb->frontend);
+                return ret;
+        }
+
+        return 0;
+}
+
diff --git a/drivers/media/video/saa7164/saa7164-fw.c b/drivers/media/video/saa7164/saa7164-fw.c
new file mode 100644
index 000000000000..ee0af3534ede
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-fw.c
@@ -0,0 +1,613 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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/firmware.h>
+
+#include "saa7164.h"
+
+#define SAA7164_REV2_FIRMWARE           "v4l-saa7164-1.0.2.fw"
+#define SAA7164_REV2_FIRMWARE_SIZE      3978608
+
+#define SAA7164_REV3_FIRMWARE           "v4l-saa7164-1.0.3.fw"
+#define SAA7164_REV3_FIRMWARE_SIZE      3978608
+
+struct fw_header {
+        u32     firmwaresize;
+        u32     bslsize;
+        u32     reserved;
+        u32     version;
+};
+
+int saa7164_dl_wait_ack(struct saa7164_dev *dev, u32 reg)
+{
+        u32 timeout = SAA_DEVICE_TIMEOUT;
+        while ((saa7164_readl(reg) & 0x01) == 0) {
+                timeout -= 10;
+                if (timeout == 0) {
+                        printk(KERN_ERR "%s() timeout (no d/l ack)\n",
+                                __func__);
+                        return -EBUSY;
+                }
+                msleep(100);
+        }
+
+        return 0;
+}
+
+int saa7164_dl_wait_clr(struct saa7164_dev *dev, u32 reg)
+{
+        u32 timeout = SAA_DEVICE_TIMEOUT;
+        while (saa7164_readl(reg) & 0x01) {
+                timeout -= 10;
+                if (timeout == 0) {
+                        printk(KERN_ERR "%s() timeout (no d/l clr)\n",
+                                __func__);
+                        return -EBUSY;
+                }
+                msleep(100);
+        }
+
+        return 0;
+}
+
+/* TODO: move dlflags into dev-> and change to write/readl/b */
+/* TODO: Excessive levels of debug */
+int saa7164_downloadimage(struct saa7164_dev *dev, u8 *src, u32 srcsize,
+        u32 dlflags, u8 *dst, u32 dstsize)
+{
+        u32 reg, timeout, offset;
+        u8 *srcbuf = NULL;
+        int ret;
+
+        u32 dlflag = dlflags;
+        u32 dlflag_ack = dlflag + 4;
+        u32 drflag = dlflag_ack + 4;
+        u32 drflag_ack = drflag + 4;
+        u32 bleflag = drflag_ack + 4;
+
+        dprintk(DBGLVL_FW,
+                "%s(image=%p, size=%d, flags=0x%x, dst=%p, dstsize=0x%x)\n",
+                __func__, src, srcsize, dlflags, dst, dstsize);
+
+        if ((src == 0) || (dst == 0)) {
+                ret = -EIO;
+                goto out;
+        }
+
+        srcbuf = kzalloc(4 * 1048576, GFP_KERNEL);
+        if (NULL == srcbuf) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        if (srcsize > (4*1048576)) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        memcpy(srcbuf, src, srcsize);
+
+        dprintk(DBGLVL_FW, "%s() dlflag = 0x%x\n", __func__, dlflag);
+        dprintk(DBGLVL_FW, "%s() dlflag_ack = 0x%x\n", __func__, dlflag_ack);
+        dprintk(DBGLVL_FW, "%s() drflag = 0x%x\n", __func__, drflag);
+        dprintk(DBGLVL_FW, "%s() drflag_ack = 0x%x\n", __func__, drflag_ack);
+        dprintk(DBGLVL_FW, "%s() bleflag = 0x%x\n", __func__, bleflag);
+
+        reg = saa7164_readl(dlflag);
+        dprintk(DBGLVL_FW, "%s() dlflag (0x%x)= 0x%x\n", __func__, dlflag, reg);
+        if (reg == 1)
+                dprintk(DBGLVL_FW,
+                        "%s() Download flag already set, please reboot\n",
+                        __func__);
+
+        /* Indicate download start */
+        saa7164_writel(dlflag, 1);
+        ret = saa7164_dl_wait_ack(dev, dlflag_ack);
+        if (ret < 0)
+                goto out;
+
+        /* Ack download start, then wait for wait */
+        saa7164_writel(dlflag, 0);
+        ret = saa7164_dl_wait_clr(dev, dlflag_ack);
+        if (ret < 0)
+                goto out;
+
+        /* Deal with the raw firmware, in the appropriate chunk size */
+        for (offset = 0; srcsize > dstsize;
+                srcsize -= dstsize, offset += dstsize) {
+
+                dprintk(DBGLVL_FW, "%s() memcpy %d\n", __func__, dstsize);
+                memcpy(dst, srcbuf + offset, dstsize);
+
+                /* Flag the data as ready */
+                saa7164_writel(drflag, 1);
+                ret = saa7164_dl_wait_ack(dev, drflag_ack);
+                if (ret < 0)
+                        goto out;
+
+                /* Wait for indication data was received */
+                saa7164_writel(drflag, 0);
+                ret = saa7164_dl_wait_clr(dev, drflag_ack);
+                if (ret < 0)
+                        goto out;
+
+        }
+
+        dprintk(DBGLVL_FW, "%s() memcpy(l) %d\n", __func__, dstsize);
+        /* Write last block to the device */
+        memcpy(dst, srcbuf+offset, srcsize);
+
+        /* Flag the data as ready */
+        saa7164_writel(drflag, 1);
+        ret = saa7164_dl_wait_ack(dev, drflag_ack);
+        if (ret < 0)
+                goto out;
+
+        saa7164_writel(drflag, 0);
+        timeout = 0;
+        while (saa7164_readl(bleflag) != SAA_DEVICE_IMAGE_BOOTING) {
+                if (saa7164_readl(bleflag) & SAA_DEVICE_IMAGE_CORRUPT) {
+                        printk(KERN_ERR "%s() image corrupt\n", __func__);
+                        ret = -EBUSY;
+                        goto out;
+                }
+
+                if (saa7164_readl(bleflag) & SAA_DEVICE_MEMORY_CORRUPT) {
+                        printk(KERN_ERR "%s() device memory corrupt\n",
+                                __func__);
+                        ret = -EBUSY;
+                        goto out;
+                }
+
+                msleep(10);
+                if (timeout++ > 60)
+                        break;
+        }
+
+        printk(KERN_INFO "%s() Image downloaded, booting...\n", __func__);
+
+        ret = saa7164_dl_wait_clr(dev, drflag_ack);
+        if (ret < 0)
+                goto out;
+
+        printk(KERN_INFO "%s() Image booted successfully.\n", __func__);
+        ret = 0;
+
+out:
+        kfree(srcbuf);
+        return ret;
+}
+
+/* TODO: Excessive debug */
+/* Load the firmware. Optionally it can be in ROM or newer versions
+ * can be on disk, saving the expense of the ROM hardware. */
+int saa7164_downloadfirmware(struct saa7164_dev *dev)
+{
+        /* u32 second_timeout = 60 * SAA_DEVICE_TIMEOUT; */
+        u32 tmp, filesize, version, err_flags, first_timeout, fwlength;
+        u32 second_timeout, updatebootloader = 1, bootloadersize = 0;
+        const struct firmware *fw = NULL;
+        struct fw_header *hdr, *boothdr = NULL, *fwhdr;
+        u32 bootloaderversion = 0, fwloadersize;
+        u8 *bootloaderoffset = NULL, *fwloaderoffset;
+        char *fwname;
+        int ret;
+
+        dprintk(DBGLVL_FW, "%s()\n", __func__);
+
+        if (saa7164_boards[dev->board].chiprev == SAA7164_CHIP_REV2) {
+                fwname = SAA7164_REV2_FIRMWARE;
+                fwlength = SAA7164_REV2_FIRMWARE_SIZE;
+        } else {
+                fwname = SAA7164_REV3_FIRMWARE;
+                fwlength = SAA7164_REV3_FIRMWARE_SIZE;
+        }
+
+        version = saa7164_getcurrentfirmwareversion(dev);
+
+        if (version == 0x00) {
+
+                second_timeout = 100;
+                first_timeout = 100;
+                err_flags = saa7164_readl(SAA_BOOTLOADERERROR_FLAGS);
+                dprintk(DBGLVL_FW, "%s() err_flags = %x\n",
+                        __func__, err_flags);
+
+                while (err_flags != SAA_DEVICE_IMAGE_BOOTING) {
+                        dprintk(DBGLVL_FW, "%s() err_flags = %x\n",
+                                __func__, err_flags);
+                        msleep(10);
+
+                        if (err_flags & SAA_DEVICE_IMAGE_CORRUPT) {
+                                printk(KERN_ERR "%s() firmware corrupt\n",
+                                        __func__);
+                                break;
+                        }
+                        if (err_flags & SAA_DEVICE_MEMORY_CORRUPT) {
+                                printk(KERN_ERR "%s() device memory corrupt\n",
+                                        __func__);
+                                break;
+                        }
+                        if (err_flags & SAA_DEVICE_NO_IMAGE) {
+                                printk(KERN_ERR "%s() no first image\n",
+                                __func__);
+                                break;
+                        }
+                        if (err_flags & SAA_DEVICE_IMAGE_SEARCHING) {
+                                first_timeout -= 10;
+                                if (first_timeout == 0) {
+                                        printk(KERN_ERR
+                                                "%s() no first image\n",
+                                                __func__);
+                                        break;
+                                }
+                        } else if (err_flags & SAA_DEVICE_IMAGE_LOADING) {
+                                second_timeout -= 10;
+                                if (second_timeout == 0) {
+                                        printk(KERN_ERR
+                                        "%s() FW load time exceeded\n",
+                                                __func__);
+                                        break;
+                                }
+                        } else {
+                                second_timeout -= 10;
+                                if (second_timeout == 0) {
+                                        printk(KERN_ERR
+                                        "%s() Unknown bootloader flags 0x%x\n",
+                                                __func__, err_flags);
+                                        break;
+                                }
+                        }
+
+                        err_flags = saa7164_readl(SAA_BOOTLOADERERROR_FLAGS);
+                } /* While != Booting */
+
+                if (err_flags == SAA_DEVICE_IMAGE_BOOTING) {
+                        dprintk(DBGLVL_FW, "%s() Loader 1 has loaded.\n",
+                                __func__);
+                        first_timeout = SAA_DEVICE_TIMEOUT;
+                        second_timeout = 60 * SAA_DEVICE_TIMEOUT;
+                        second_timeout = 100;
+
+                        err_flags = saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS);
+                        dprintk(DBGLVL_FW, "%s() err_flags2 = %x\n",
+                                __func__, err_flags);
+                        while (err_flags != SAA_DEVICE_IMAGE_BOOTING) {
+                                dprintk(DBGLVL_FW, "%s() err_flags2 = %x\n",
+                                        __func__, err_flags);
+                                msleep(10);
+
+                                if (err_flags & SAA_DEVICE_IMAGE_CORRUPT) {
+                                        printk(KERN_ERR
+                                                "%s() firmware corrupt\n",
+                                                __func__);
+                                        break;
+                                }
+                                if (err_flags & SAA_DEVICE_MEMORY_CORRUPT) {
+                                        printk(KERN_ERR
+                                                "%s() device memory corrupt\n",
+                                                __func__);
+                                        break;
+                                }
+                                if (err_flags & SAA_DEVICE_NO_IMAGE) {
+                                        printk(KERN_ERR "%s() no first image\n",
+                                                __func__);
+                                        break;
+                                }
+                                if (err_flags & SAA_DEVICE_IMAGE_SEARCHING) {
+                                        first_timeout -= 10;
+                                        if (first_timeout == 0) {
+                                                printk(KERN_ERR
+                                                "%s() no second image\n",
+                                                        __func__);
+                                                break;
+                                        }
+                                } else if (err_flags &
+                                        SAA_DEVICE_IMAGE_LOADING) {
+                                        second_timeout -= 10;
+                                        if (second_timeout == 0) {
+                                                printk(KERN_ERR
+                                                "%s() FW load time exceeded\n",
+                                                        __func__);
+                                                break;
+                                        }
+                                } else {
+                                        second_timeout -= 10;
+                                        if (second_timeout == 0) {
+                                                printk(KERN_ERR
+                                        "%s() Unknown bootloader flags 0x%x\n",
+                                                        __func__, err_flags);
+                                                break;
+                                        }
+                                }
+
+                                err_flags =
+                                saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS);
+                        } /* err_flags != SAA_DEVICE_IMAGE_BOOTING */
+
+                        dprintk(DBGLVL_FW, "%s() Loader flags 1:0x%x 2:0x%x.\n",
+                                __func__,
+                                saa7164_readl(SAA_BOOTLOADERERROR_FLAGS),
+                                saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS));
+
+                } /* err_flags == SAA_DEVICE_IMAGE_BOOTING */
+
+                /* It's possible for both firmwares to have booted,
+                 * but that doesn't mean they've finished booting yet.
+                 */
+                if ((saa7164_readl(SAA_BOOTLOADERERROR_FLAGS) ==
+                        SAA_DEVICE_IMAGE_BOOTING) &&
+                        (saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS) ==
+                        SAA_DEVICE_IMAGE_BOOTING)) {
+
+
+                        dprintk(DBGLVL_FW, "%s() Loader 2 has loaded.\n",
+                                __func__);
+
+                        first_timeout = SAA_DEVICE_TIMEOUT;
+                        while (first_timeout) {
+                                msleep(10);
+
+                                version =
+                                        saa7164_getcurrentfirmwareversion(dev);
+                                if (version) {
+                                        dprintk(DBGLVL_FW,
+                                        "%s() All f/w loaded successfully\n",
+                                                __func__);
+                                        break;
+                                } else {
+                                        first_timeout -= 10;
+                                        if (first_timeout == 0) {
+                                                printk(KERN_ERR
+                                                "%s() FW did not boot\n",
+                                                        __func__);
+                                                break;
+                                        }
+                                }
+                        }
+                }
+                version = saa7164_getcurrentfirmwareversion(dev);
+        } /* version == 0 */
+
+        /* Has the firmware really booted? */
+        if ((saa7164_readl(SAA_BOOTLOADERERROR_FLAGS) ==
+                SAA_DEVICE_IMAGE_BOOTING) &&
+                (saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS) ==
+                SAA_DEVICE_IMAGE_BOOTING) && (version == 0)) {
+
+                printk(KERN_ERR
+                        "%s() The firmware hung, probably bad firmware\n",
+                        __func__);
+
+                /* Tell the second stage loader we have a deadlock */
+                saa7164_writel(SAA_DEVICE_DEADLOCK_DETECTED_OFFSET,
+                        SAA_DEVICE_DEADLOCK_DETECTED);
+
+                saa7164_getfirmwarestatus(dev);
+
+                return -ENOMEM;
+        }
+
+        dprintk(DBGLVL_FW, "Device has Firmware Version %d.%d.%d.%d\n",
+                (version & 0x0000fc00) >> 10,
+                (version & 0x000003e0) >> 5,
+                (version & 0x0000001f),
+                (version & 0xffff0000) >> 16);
+
+        /* Load the firmwware from the disk if required */
+        if (version == 0) {
+
+                printk(KERN_INFO "%s() Waiting for firmware upload (%s)\n",
+                        __func__, fwname);
+
+                ret = request_firmware(&fw, fwname, &dev->pci->dev);
+                if (ret) {
+                        printk(KERN_ERR "%s() Upload failed. "
+                                "(file not found?)\n", __func__);
+                        return -ENOMEM;
+                }
+
+                printk(KERN_INFO "%s() firmware read %Zu bytes.\n",
+                        __func__, fw->size);
+
+                if (fw->size != fwlength) {
+                        printk(KERN_ERR "xc5000: firmware incorrect size\n");
+                        ret = -ENOMEM;
+                        goto out;
+                }
+
+                printk(KERN_INFO "%s() firmware loaded.\n", __func__);
+
+                hdr = (struct fw_header *)fw->data;
+                printk(KERN_INFO "Firmware file header part 1:\n");
+                printk(KERN_INFO " .FirmwareSize = 0x%x\n", hdr->firmwaresize);
+                printk(KERN_INFO " .BSLSize = 0x%x\n", hdr->bslsize);
+                printk(KERN_INFO " .Reserved = 0x%x\n", hdr->reserved);
+                printk(KERN_INFO " .Version = 0x%x\n", hdr->version);
+
+                /* Retreive bootloader if reqd */
+                if ((hdr->firmwaresize == 0) && (hdr->bslsize == 0))
+                        /* Second bootloader in the firmware file */
+                        filesize = hdr->reserved * 16;
+                else
+                        filesize = (hdr->firmwaresize + hdr->bslsize) *
+                                16 + sizeof(struct fw_header);
+
+                printk(KERN_INFO "%s() SecBootLoader.FileSize = %d\n",
+                        __func__, filesize);
+
+                /* Get bootloader (if reqd) and firmware header */
+                if ((hdr->firmwaresize == 0) && (hdr->bslsize == 0)) {
+                        /* Second boot loader is required */
+
+                        /* Get the loader header */
+                        boothdr = (struct fw_header *)(fw->data +
+                                sizeof(struct fw_header));
+
+                        bootloaderversion =
+                                saa7164_readl(SAA_DEVICE_2ND_VERSION);
+                        dprintk(DBGLVL_FW, "Onboard BootLoader:\n");
+                        dprintk(DBGLVL_FW, "->Flag 0x%x\n",
+                                saa7164_readl(SAA_BOOTLOADERERROR_FLAGS));
+                        dprintk(DBGLVL_FW, "->Ack 0x%x\n",
+                                saa7164_readl(SAA_DATAREADY_FLAG_ACK));
+                        dprintk(DBGLVL_FW, "->FW Version 0x%x\n", version);
+                        dprintk(DBGLVL_FW, "->Loader Version 0x%x\n",
+                                bootloaderversion);
+
+                        if ((saa7164_readl(SAA_BOOTLOADERERROR_FLAGS) ==
+                                0x03) && (saa7164_readl(SAA_DATAREADY_FLAG_ACK)
+                                == 0x00) && (version == 0x00)) {
+
+                                dprintk(DBGLVL_FW, "BootLoader version in  "
+                                        "rom %d.%d.%d.%d\n",
+                                        (bootloaderversion & 0x0000fc00) >> 10,
+                                        (bootloaderversion & 0x000003e0) >> 5,
+                                        (bootloaderversion & 0x0000001f),
+                                        (bootloaderversion & 0xffff0000) >> 16
+                                        );
+                                dprintk(DBGLVL_FW, "BootLoader version "
+                                        "in file %d.%d.%d.%d\n",
+                                        (boothdr->version & 0x0000fc00) >> 10,
+                                        (boothdr->version & 0x000003e0) >> 5,
+                                        (boothdr->version & 0x0000001f),
+                                        (boothdr->version & 0xffff0000) >> 16
+                                        );
+
+                                if (bootloaderversion == boothdr->version)
+                                        updatebootloader = 0;
+                        }
+
+                        /* Calculate offset to firmware header */
+                        tmp = (boothdr->firmwaresize + boothdr->bslsize) * 16 +
+                                (sizeof(struct fw_header) +
+                                sizeof(struct fw_header));
+
+                        fwhdr = (struct fw_header *)(fw->data+tmp);
+                } else {
+                        /* No second boot loader */
+                        fwhdr = hdr;
+                }
+
+                dprintk(DBGLVL_FW, "Firmware version in file %d.%d.%d.%d\n",
+                        (fwhdr->version & 0x0000fc00) >> 10,
+                        (fwhdr->version & 0x000003e0) >> 5,
+                        (fwhdr->version & 0x0000001f),
+                        (fwhdr->version & 0xffff0000) >> 16
+                        );
+
+                if (version == fwhdr->version) {
+                        /* No download, firmware already on board */
+                        ret = 0;
+                        goto out;
+                }
+
+                if ((hdr->firmwaresize == 0) && (hdr->bslsize == 0)) {
+                        if (updatebootloader) {
+                                /* Get ready to upload the bootloader */
+                                bootloadersize = (boothdr->firmwaresize +
+                                        boothdr->bslsize) * 16 +
+                                        sizeof(struct fw_header);
+
+                                bootloaderoffset = (u8 *)(fw->data +
+                                        sizeof(struct fw_header));
+
+                                dprintk(DBGLVL_FW, "bootloader d/l starts.\n");
+                                printk(KERN_INFO "%s() FirmwareSize = 0x%x\n",
+                                        __func__, boothdr->firmwaresize);
+                                printk(KERN_INFO "%s() BSLSize = 0x%x\n",
+                                        __func__, boothdr->bslsize);
+                                printk(KERN_INFO "%s() Reserved = 0x%x\n",
+                                        __func__, boothdr->reserved);
+                                printk(KERN_INFO "%s() Version = 0x%x\n",
+                                        __func__, boothdr->version);
+                                ret = saa7164_downloadimage(
+                                        dev,
+                                        bootloaderoffset,
+                                        bootloadersize,
+                                        SAA_DOWNLOAD_FLAGS,
+                                        dev->bmmio + SAA_DEVICE_DOWNLOAD_OFFSET,
+                                        SAA_DEVICE_BUFFERBLOCKSIZE);
+                                if (ret < 0) {
+                                        printk(KERN_ERR
+                                                "bootloader d/l has failed\n");
+                                        goto out;
+                                }
+                                dprintk(DBGLVL_FW,
+                                        "bootloader download complete.\n");
+
+                        }
+
+                        printk(KERN_ERR "starting firmware download(2)\n");
+                        bootloadersize = (boothdr->firmwaresize +
+                                boothdr->bslsize) * 16 +
+                                sizeof(struct fw_header);
+
+                        bootloaderoffset =
+                                (u8 *)(fw->data + sizeof(struct fw_header));
+
+                        fwloaderoffset = bootloaderoffset + bootloadersize;
+
+                        /* TODO: fix this bounds overrun here with old f/ws */
+                        fwloadersize = (fwhdr->firmwaresize + fwhdr->bslsize) *
+                                16 + sizeof(struct fw_header);
+
+                        ret = saa7164_downloadimage(
+                                dev,
+                                fwloaderoffset,
+                                fwloadersize,
+                                SAA_DEVICE_2ND_DOWNLOADFLAG_OFFSET,
+                                dev->bmmio + SAA_DEVICE_2ND_DOWNLOAD_OFFSET,
+                                SAA_DEVICE_2ND_BUFFERBLOCKSIZE);
+                        if (ret < 0) {
+                                printk(KERN_ERR "firmware download failed\n");
+                                goto out;
+                        }
+                        printk(KERN_ERR "firmware download complete.\n");
+
+                } else {
+
+                        /* No bootloader update reqd, download firmware only */
+                        printk(KERN_ERR "starting firmware download(3)\n");
+
+                        ret = saa7164_downloadimage(
+                                dev,
+                                (u8 *)fw->data,
+                                fw->size,
+                                SAA_DOWNLOAD_FLAGS,
+                                dev->bmmio + SAA_DEVICE_DOWNLOAD_OFFSET,
+                                SAA_DEVICE_BUFFERBLOCKSIZE);
+                        if (ret < 0) {
+                                printk(KERN_ERR "firmware download failed\n");
+                                goto out;
+                        }
+                        printk(KERN_ERR "firmware download complete.\n");
+                }
+        }
+
+        ret = 0;
+
+out:
+        if (fw)
+                release_firmware(fw);
+
+        return ret;
+}
diff --git a/drivers/media/video/saa7164/saa7164-i2c.c b/drivers/media/video/saa7164/saa7164-i2c.c
new file mode 100644
index 000000000000..e1ae9b01bf0f
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-i2c.c
@@ -0,0 +1,141 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+
+#include "saa7164.h"
+
+static int i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
+{
+        struct saa7164_i2c *bus = i2c_adap->algo_data;
+        struct saa7164_dev *dev = bus->dev;
+        int i, retval = 0;
+
+        dprintk(DBGLVL_I2C, "%s(num = %d)\n", __func__, num);
+
+        for (i = 0 ; i < num; i++) {
+                dprintk(DBGLVL_I2C, "%s(num = %d) addr = 0x%02x  len = 0x%x\n",
+                        __func__, num, msgs[i].addr, msgs[i].len);
+                if (msgs[i].flags & I2C_M_RD) {
+                        /* Unsupported - Yet*/
+                        printk(KERN_ERR "%s() Unsupported - Yet\n", __func__);
+                        continue;
+                } else if (i + 1 < num && (msgs[i + 1].flags & I2C_M_RD) &&
+                           msgs[i].addr == msgs[i + 1].addr) {
+                        /* write then read from same address */
+
+                        retval = saa7164_api_i2c_read(bus, msgs[i].addr,
+                                msgs[i].len, msgs[i].buf,
+                                msgs[i+1].len, msgs[i+1].buf
+                                );
+
+                        i++;
+
+                        if (retval < 0)
+                                goto err;
+                } else {
+                        /* write */
+                        retval = saa7164_api_i2c_write(bus, msgs[i].addr,
+                                msgs[i].len, msgs[i].buf);
+                }
+                if (retval < 0)
+                        goto err;
+        }
+        return num;
+
+ err:
+        return retval;
+}
+
+void saa7164_call_i2c_clients(struct saa7164_i2c *bus, unsigned int cmd,
+        void *arg)
+{
+        if (bus->i2c_rc != 0)
+                return;
+
+        i2c_clients_command(&bus->i2c_adap, cmd, arg);
+}
+
+static u32 saa7164_functionality(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm saa7164_i2c_algo_template = {
+        .master_xfer    = i2c_xfer,
+        .functionality  = saa7164_functionality,
+};
+
+/* ----------------------------------------------------------------------- */
+
+static struct i2c_adapter saa7164_i2c_adap_template = {
+        .name              = "saa7164",
+        .owner             = THIS_MODULE,
+        .algo              = &saa7164_i2c_algo_template,
+};
+
+static struct i2c_client saa7164_i2c_client_template = {
+        .name   = "saa7164 internal",
+};
+
+int saa7164_i2c_register(struct saa7164_i2c *bus)
+{
+        struct saa7164_dev *dev = bus->dev;
+
+        dprintk(DBGLVL_I2C, "%s(bus = %d)\n", __func__, bus->nr);
+
+        memcpy(&bus->i2c_adap, &saa7164_i2c_adap_template,
+               sizeof(bus->i2c_adap));
+
+        memcpy(&bus->i2c_algo, &saa7164_i2c_algo_template,
+               sizeof(bus->i2c_algo));
+
+        memcpy(&bus->i2c_client, &saa7164_i2c_client_template,
+               sizeof(bus->i2c_client));
+
+        bus->i2c_adap.dev.parent = &dev->pci->dev;
+
+        strlcpy(bus->i2c_adap.name, bus->dev->name,
+                sizeof(bus->i2c_adap.name));
+
+        bus->i2c_algo.data = bus;
+        bus->i2c_adap.algo_data = bus;
+        i2c_set_adapdata(&bus->i2c_adap, bus);
+        i2c_add_adapter(&bus->i2c_adap);
+
+        bus->i2c_client.adapter = &bus->i2c_adap;
+
+        if (0 != bus->i2c_rc)
+                printk(KERN_ERR "%s: i2c bus %d register FAILED\n",
+                        dev->name, bus->nr);
+
+        return bus->i2c_rc;
+}
+
+int saa7164_i2c_unregister(struct saa7164_i2c *bus)
+{
+        i2c_del_adapter(&bus->i2c_adap);
+        return 0;
+}
diff --git a/drivers/media/video/saa7164/saa7164-reg.h b/drivers/media/video/saa7164/saa7164-reg.h
new file mode 100644
index 000000000000..06be4c13d5b1
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-reg.h
@@ -0,0 +1,166 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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.
+ */
+
+/* TODO: Retest the driver with errors expressed as negatives */
+
+/* Result codes */
+#define SAA_OK                          0
+#define SAA_ERR_BAD_PARAMETER           0x09
+#define SAA_ERR_NO_RESOURCES            0x0c
+#define SAA_ERR_NOT_SUPPORTED           0x13
+#define SAA_ERR_BUSY                    0x15
+#define SAA_ERR_READ                    0x17
+#define SAA_ERR_TIMEOUT                 0x1f
+#define SAA_ERR_OVERFLOW                0x20
+#define SAA_ERR_EMPTY                   0x22
+#define SAA_ERR_NOT_STARTED             0x23
+#define SAA_ERR_ALREADY_STARTED         0x24
+#define SAA_ERR_NOT_STOPPED             0x25
+#define SAA_ERR_ALREADY_STOPPED         0x26
+#define SAA_ERR_INVALID_COMMAND         0x3e
+#define SAA_ERR_NULL_PACKET             0x59
+
+/* Errors and flags from the silicon */
+#define PVC_ERRORCODE_UNKNOWN           0x00
+#define PVC_ERRORCODE_INVALID_COMMAND   0x01
+#define PVC_ERRORCODE_INVALID_CONTROL   0x02
+#define PVC_ERRORCODE_INVALID_DATA      0x03
+#define PVC_ERRORCODE_TIMEOUT           0x04
+#define PVC_ERRORCODE_NAK               0x05
+#define PVC_RESPONSEFLAG_ERROR          0x01
+#define PVC_RESPONSEFLAG_OVERFLOW       0x02
+#define PVC_RESPONSEFLAG_RESET          0x04
+#define PVC_RESPONSEFLAG_INTERFACE      0x08
+#define PVC_RESPONSEFLAG_CONTINUED      0x10
+#define PVC_CMDFLAG_INTERRUPT           0x02
+#define PVC_CMDFLAG_INTERFACE           0x04
+#define PVC_CMDFLAG_SERIALIZE           0x08
+#define PVC_CMDFLAG_CONTINUE            0x10
+
+/* Silicon Commands */
+#define GET_DESCRIPTORS_CONTROL         0x01
+#define GET_STRING_CONTROL              0x03
+#define GET_LANGUAGE_CONTROL            0x05
+#define SET_POWER_CONTROL               0x07
+#define GET_FW_VERSION_CONTROL          0x09
+#define SET_DEBUG_LEVEL_CONTROL         0x0B
+#define GET_DEBUG_DATA_CONTROL          0x0C
+#define GET_PRODUCTION_INFO_CONTROL     0x0D
+
+/* cmd defines */
+#define SAA_CMDFLAG_CONTINUE            0x10
+#define SAA_CMD_MAX_MSG_UNITS           256
+
+/* Some defines */
+#define SAA_BUS_TIMEOUT                 50
+#define SAA_DEVICE_TIMEOUT              5000
+#define SAA_DEVICE_MAXREQUESTSIZE       256
+
+/* Register addresses */
+#define SAA_DEVICE_VERSION              0x30
+#define SAA_DOWNLOAD_FLAGS              0x34
+#define SAA_DOWNLOAD_FLAG               0x34
+#define SAA_DOWNLOAD_FLAG_ACK           0x38
+#define SAA_DATAREADY_FLAG              0x3C
+#define SAA_DATAREADY_FLAG_ACK          0x40
+
+/* Boot loader register and bit definitions */
+#define SAA_BOOTLOADERERROR_FLAGS       0x44
+#define SAA_DEVICE_IMAGE_SEARCHING      0x01
+#define SAA_DEVICE_IMAGE_LOADING        0x02
+#define SAA_DEVICE_IMAGE_BOOTING        0x03
+#define SAA_DEVICE_IMAGE_CORRUPT        0x04
+#define SAA_DEVICE_MEMORY_CORRUPT       0x08
+#define SAA_DEVICE_NO_IMAGE             0x10
+
+/* Register addresses */
+#define SAA_DEVICE_2ND_VERSION                  0x50
+#define SAA_DEVICE_2ND_DOWNLOADFLAG_OFFSET      0x54
+
+/* Register addresses */
+#define SAA_SECONDSTAGEERROR_FLAGS              0x64
+
+/* Bootloader regs and flags */
+#define SAA_DEVICE_DEADLOCK_DETECTED_OFFSET     0x6C
+#define SAA_DEVICE_DEADLOCK_DETECTED            0xDEADDEAD
+
+/* Basic firmware status registers */
+#define SAA_DEVICE_SYSINIT_STATUS_OFFSET        0x70
+#define SAA_DEVICE_SYSINIT_STATUS               0x70
+#define SAA_DEVICE_SYSINIT_MODE                 0x74
+#define SAA_DEVICE_SYSINIT_SPEC                 0x78
+#define SAA_DEVICE_SYSINIT_INST                 0x7C
+#define SAA_DEVICE_SYSINIT_CPULOAD              0x80
+#define SAA_DEVICE_SYSINIT_REMAINHEAP           0x84
+
+#define SAA_DEVICE_DOWNLOAD_OFFSET              0x1000
+#define SAA_DEVICE_BUFFERBLOCKSIZE              0x1000
+
+#define SAA_DEVICE_2ND_BUFFERBLOCKSIZE          0x100000
+#define SAA_DEVICE_2ND_DOWNLOAD_OFFSET          0x200000
+
+/* Descriptors */
+#define CS_INTERFACE    0x24
+
+/* Descriptor subtypes */
+#define VC_INPUT_TERMINAL               0x02
+#define VC_OUTPUT_TERMINAL              0x03
+#define VC_SELECTOR_UNIT                0x04
+#define VC_PROCESSING_UNIT              0x05
+#define FEATURE_UNIT                    0x06
+#define TUNER_UNIT                      0x09
+#define ENCODER_UNIT                    0x0A
+#define EXTENSION_UNIT                  0x0B
+#define VC_TUNER_PATH                   0xF0
+#define PVC_HARDWARE_DESCRIPTOR         0xF1
+#define PVC_INTERFACE_DESCRIPTOR        0xF2
+#define PVC_INFRARED_UNIT               0xF3
+#define DRM_UNIT                        0xF4
+#define GENERAL_REQUEST                 0xF5
+
+/* Format Types */
+#define VS_FORMAT_TYPE         0x02
+#define VS_FORMAT_TYPE_I       0x01
+#define VS_FORMAT_UNCOMPRESSED 0x04
+#define VS_FRAME_UNCOMPRESSED  0x05
+#define VS_FORMAT_MPEG2PS      0x09
+#define VS_FORMAT_MPEG2TS      0x0A
+#define VS_FORMAT_MPEG4SL      0x0B
+#define VS_FORMAT_WM9          0x0C
+#define VS_FORMAT_DIVX         0x0D
+#define VS_FORMAT_VBI          0x0E
+#define VS_FORMAT_RDS          0x0F
+
+/* Device extension commands */
+#define EXU_REGISTER_ACCESS_CONTROL     0x00
+#define EXU_GPIO_CONTROL                0x01
+#define EXU_GPIO_GROUP_CONTROL          0x02
+#define EXU_INTERRUPT_CONTROL           0x03
+
+/* State Transition and args */
+#define SAA_STATE_CONTROL       0x03
+#define SAA_DMASTATE_STOP       0x00
+#define SAA_DMASTATE_ACQUIRE    0x01
+#define SAA_DMASTATE_PAUSE      0x02
+#define SAA_DMASTATE_RUN        0x03
+
+/* Hardware registers */
+
diff --git a/drivers/media/video/saa7164/saa7164-types.h b/drivers/media/video/saa7164/saa7164-types.h
new file mode 100644
index 000000000000..99093f23aae5
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-types.h
@@ -0,0 +1,287 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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.
+ */
+
+/* TODO: Cleanup and shorten the namespace */
+
+/* Some structues are passed directly to/from the firmware and
+ * have strict alignment requirements. This is one of them.
+ */
+typedef struct {
+        u8      bLength;
+        u8      bDescriptorType;
+        u8      bDescriptorSubtype;
+        u16     bcdSpecVersion;
+        u32     dwClockFrequency;
+        u32     dwClockUpdateRes;
+        u8      bCapabilities;
+        u32     dwDeviceRegistersLocation;
+        u32     dwHostMemoryRegion;
+        u32     dwHostMemoryRegionSize;
+        u32     dwHostHibernatMemRegion;
+        u32     dwHostHibernatMemRegionSize;
+} __attribute__((packed)) tmComResHWDescr_t;
+
+/* This is DWORD aligned on windows but I can't find the right
+ * gcc syntax to match the binary data from the device.
+ * I've manually padded with Reserved[3] bytes to match the hardware,
+ * but this could break if GCC decies to pack in a different way.
+ */
+typedef struct {
+        u8      bLength;
+        u8      bDescriptorType;
+        u8      bDescriptorSubtype;
+        u8      bFlags;
+        u8      bInterfaceType;
+        u8      bInterfaceId;
+        u8      bBaseInterface;
+        u8      bInterruptId;
+        u8      bDebugInterruptId;
+        u8      BARLocation;
+        u8      Reserved[3];
+} tmComResInterfaceDescr_t;
+
+typedef struct {
+        u64     CommandRing;
+        u64     ResponseRing;
+        u32     CommandWrite;
+        u32     CommandRead;
+        u32     ResponseWrite;
+        u32     ResponseRead;
+} tmComResBusDescr_t;
+
+typedef enum {
+        NONE            = 0,
+        TYPE_BUS_PCI    = 1,
+        TYPE_BUS_PCIe   = 2,
+        TYPE_BUS_USB    = 3,
+        TYPE_BUS_I2C    = 4
+} tmBusType_t;
+
+typedef struct {
+        tmBusType_t Type;
+        u16     m_wMaxReqSize;
+        u8      *m_pdwSetRing;
+        u32     m_dwSizeSetRing;
+        u8      *m_pdwGetRing;
+        u32     m_dwSizeGetRing;
+        u32     *m_pdwSetWritePos;
+        u32     *m_pdwSetReadPos;
+        u32     *m_pdwGetWritePos;
+        u32     *m_pdwGetReadPos;
+
+        /* All access is protected */
+        struct mutex lock;
+
+} tmComResBusInfo_t;
+
+typedef struct {
+        u8      id;
+        u8      flags;
+        u16     size;
+        u32     command;
+        u16     controlselector;
+        u8      seqno;
+} __attribute__((packed)) tmComResInfo_t;
+
+typedef enum {
+        SET_CUR  = 0x01,
+        GET_CUR  = 0x81,
+        GET_MIN  = 0x82,
+        GET_MAX  = 0x83,
+        GET_RES  = 0x84,
+        GET_LEN  = 0x85,
+        GET_INFO = 0x86,
+        GET_DEF  = 0x87
+} tmComResCmd_t;
+
+struct cmd {
+        u8 seqno;
+        u32 inuse;
+        u32 timeout;
+        u32 signalled;
+        struct mutex lock;
+        wait_queue_head_t wait;
+};
+
+typedef struct {
+        u32     pathid;
+        u32     size;
+        void    *descriptor;
+} tmDescriptor_t;
+
+typedef struct {
+        u8      len;
+        u8      type;
+        u8      subtype;
+        u8      unitid;
+} __attribute__((packed)) tmComResDescrHeader_t;
+
+typedef struct {
+        u8      len;
+        u8      type;
+        u8      subtype;
+        u8      unitid;
+        u32     devicetype;
+        u16     deviceid;
+        u32     numgpiopins;
+        u8      numgpiogroups;
+        u8      controlsize;
+} __attribute__((packed)) tmComResExtDevDescrHeader_t;
+
+typedef struct {
+        u32     pin;
+        u8      state;
+} __attribute__((packed)) tmComResGPIO_t;
+
+typedef struct {
+        u8      len;
+        u8      type;
+        u8      subtype;
+        u8      pathid;
+} __attribute__((packed)) tmComResPathDescrHeader_t;
+
+/* terminaltype */
+typedef enum {
+        ITT_ANTENNA              = 0x0203,
+        LINE_CONNECTOR           = 0x0603,
+        SPDIF_CONNECTOR          = 0x0605,
+        COMPOSITE_CONNECTOR      = 0x0401,
+        SVIDEO_CONNECTOR         = 0x0402,
+        COMPONENT_CONNECTOR      = 0x0403,
+        STANDARD_DMA             = 0xF101
+} tmComResTermType_t;
+
+typedef struct {
+        u8      len;
+        u8      type;
+        u8      subtype;
+        u8      terminalid;
+        u16     terminaltype;
+        u8      assocterminal;
+        u8      iterminal;
+        u8      controlsize;
+} __attribute__((packed)) tmComResAntTermDescrHeader_t;
+
+typedef struct {
+        u8      len;
+        u8      type;
+        u8      subtype;
+        u8      unitid;
+        u8      sourceid;
+        u8      iunit;
+        u32     tuningstandards;
+        u8      controlsize;
+        u32     controls;
+} __attribute__((packed)) tmComResTunerDescrHeader_t;
+
+typedef enum {
+        /* the buffer does not contain any valid data */
+        TM_BUFFER_FLAG_EMPTY,
+
+        /* the buffer is filled with valid data */
+        TM_BUFFER_FLAG_DONE,
+
+        /* the buffer is the dummy buffer - TODO??? */
+        TM_BUFFER_FLAG_DUMMY_BUFFER
+} tmBufferFlag_t;
+
+typedef struct {
+        u64             *pagetablevirt;
+        u64             pagetablephys;
+        u16             offset;
+        u8              *context;
+        u64             timestamp;
+        tmBufferFlag_t  BufferFlag_t;
+        u32             lostbuffers;
+        u32             validbuffers;
+        u64             *dummypagevirt;
+        u64             dummypagephys;
+        u64             *addressvirt;
+} tmBuffer_t;
+
+typedef struct {
+        u32     bitspersample;
+        u32     samplesperline;
+        u32     numberoflines;
+        u32     pitch;
+        u32     linethreshold;
+        u64     **pagetablelistvirt;
+        u64     *pagetablelistphys;
+        u32     numpagetables;
+        u32     numpagetableentries;
+} tmHWStreamParameters_t;
+
+typedef struct {
+        tmHWStreamParameters_t          HWStreamParameters_t;
+        u64                             qwDummyPageTablePhys;
+        u64                             *pDummyPageTableVirt;
+} tmStreamParameters_t;
+
+typedef struct {
+        u8      len;
+        u8      type;
+        u8      subtyle;
+        u8      unitid;
+        u16     terminaltype;
+        u8      assocterminal;
+        u8      sourceid;
+        u8      iterminal;
+        u32     BARLocation;
+        u8      flags;
+        u8      interruptid;
+        u8      buffercount;
+        u8      metadatasize;
+        u8      numformats;
+        u8      controlsize;
+} __attribute__((packed)) tmComResDMATermDescrHeader_t;
+
+/*
+ *
+ * Description:
+ *  This is the transport stream format header.
+ *
+ * Settings:
+ *  bLength                 - The size of this descriptor in bytes.
+ *  bDescriptorType         - CS_INTERFACE.
+ *  bDescriptorSubtype      - VS_FORMAT_MPEG2TS descriptor subtype.
+ *  bFormatIndex            - A non-zero constant that uniquely identifies the
+ *                            format.
+ *  bDataOffset             - Offset to TSP packet within MPEG-2 TS transport
+ *                            stride, in bytes.
+ *  bPacketLength           - Length of TSP packet, in bytes (typically 188).
+ *  bStrideLength           - Length of MPEG-2 TS transport stride.
+ *  guidStrideFormat        - A Globally Unique Identifier indicating the
+ *                            format of the stride data (if any). Set to zeros
+ *                            if there is no Stride Data, or if the Stride
+ *                            Data is to be ignored by the application.
+ *
+ */
+typedef struct {
+        u8      len;
+        u8      type;
+        u8      subtype;
+        u8      bFormatIndex;
+        u8      bDataOffset;
+        u8      bPacketLength;
+        u8      bStrideLength;
+        u8      guidStrideFormat[16];
+} __attribute__((packed)) tmComResTSFormatDescrHeader_t;
+
diff --git a/drivers/media/video/saa7164/saa7164.h b/drivers/media/video/saa7164/saa7164.h
new file mode 100644
index 000000000000..6753008a9c9b
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164.h
@@ -0,0 +1,400 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.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.
+ */
+
+/*
+        Driver architecture
+        *******************
+
+        saa7164_core.c/buffer.c/cards.c/i2c.c/dvb.c
+                |       : Standard Linux driver framework for creating
+                |       : exposing and managing interfaces to the rest
+                |       : of the kernel or userland. Also uses _fw.c to load
+                |       : firmware direct into the PCIe bus, bypassing layers.
+                V
+        saa7164_api..() : Translate kernel specific functions/features
+                |       : into command buffers.
+                V
+        saa7164_cmd..() : Manages the flow of command packets on/off,
+                |       : the bus. Deal with bus errors, timeouts etc.
+                V
+        saa7164_bus..() : Manage a read/write memory ring buffer in the
+                |       : PCIe Address space.
+                |
+                |               saa7164_fw...() : Load any frimware
+                |                       |       : direct into the device
+                V                       V
+        <- ----------------- PCIe address space -------------------- ->
+*/
+
+#include <linux/pci.h>
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+#include <linux/kdev_t.h>
+
+#include <media/tuner.h>
+#include <media/tveeprom.h>
+#include <media/videobuf-dma-sg.h>
+#include <media/videobuf-dvb.h>
+
+#include "saa7164-reg.h"
+#include "saa7164-types.h"
+
+#include <linux/version.h>
+#include <linux/mutex.h>
+
+#define SAA7164_MAXBOARDS 8
+
+#define UNSET (-1U)
+#define SAA7164_BOARD_NOAUTO                    UNSET
+#define SAA7164_BOARD_UNKNOWN                   0
+#define SAA7164_BOARD_UNKNOWN_REV2              1
+#define SAA7164_BOARD_UNKNOWN_REV3              2
+#define SAA7164_BOARD_HAUPPAUGE_HVR2250         3
+#define SAA7164_BOARD_HAUPPAUGE_HVR2200         4
+#define SAA7164_BOARD_HAUPPAUGE_HVR2200_2       5
+#define SAA7164_BOARD_HAUPPAUGE_HVR2200_3       6
+#define SAA7164_BOARD_HAUPPAUGE_HVR2250_2       7
+#define SAA7164_BOARD_HAUPPAUGE_HVR2250_3       8
+
+#define SAA7164_MAX_UNITS               8
+#define SAA7164_TS_NUMBER_OF_LINES      312
+#define SAA7164_PT_ENTRIES              16 /* (312 * 188) / 4096 */
+
+#define DBGLVL_FW    4
+#define DBGLVL_DVB   8
+#define DBGLVL_I2C  16
+#define DBGLVL_API  32
+#define DBGLVL_CMD  64
+#define DBGLVL_BUS 128
+#define DBGLVL_IRQ 256
+#define DBGLVL_BUF 512
+
+enum port_t {
+        SAA7164_MPEG_UNDEFINED = 0,
+        SAA7164_MPEG_DVB,
+};
+
+enum saa7164_i2c_bus_nr {
+        SAA7164_I2C_BUS_0 = 0,
+        SAA7164_I2C_BUS_1,
+        SAA7164_I2C_BUS_2,
+};
+
+enum saa7164_buffer_flags {
+        SAA7164_BUFFER_UNDEFINED = 0,
+        SAA7164_BUFFER_FREE,
+        SAA7164_BUFFER_BUSY,
+        SAA7164_BUFFER_FULL
+};
+
+enum saa7164_unit_type {
+        SAA7164_UNIT_UNDEFINED = 0,
+        SAA7164_UNIT_DIGITAL_DEMODULATOR,
+        SAA7164_UNIT_ANALOG_DEMODULATOR,
+        SAA7164_UNIT_TUNER,
+        SAA7164_UNIT_EEPROM,
+        SAA7164_UNIT_ZILOG_IRBLASTER,
+        SAA7164_UNIT_ENCODER,
+};
+
+/* The PCIe bridge doesn't grant direct access to i2c.
+ * Instead, you address i2c devices using a uniqely
+ * allocated 'unitid' value via a messaging API. This
+ * is a problem. The kernel and existing demod/tuner
+ * drivers expect to talk 'i2c', so we have to maintain
+ * a translation layer, and a series of functions to
+ * convert i2c bus + device address into a unit id.
+ */
+struct saa7164_unit {
+        enum saa7164_unit_type type;
+        u8      id;
+        char    *name;
+        enum saa7164_i2c_bus_nr i2c_bus_nr;
+        u8      i2c_bus_addr;
+        u8      i2c_reg_len;
+};
+
+struct saa7164_board {
+        char    *name;
+        enum port_t porta, portb;
+        enum {
+                SAA7164_CHIP_UNDEFINED = 0,
+                SAA7164_CHIP_REV2,
+                SAA7164_CHIP_REV3,
+        } chiprev;
+        struct  saa7164_unit unit[SAA7164_MAX_UNITS];
+};
+
+struct saa7164_subid {
+        u16     subvendor;
+        u16     subdevice;
+        u32     card;
+};
+
+struct saa7164_fw_status {
+
+        /* RISC Core details */
+        u32     status;
+        u32     mode;
+        u32     spec;
+        u32     inst;
+        u32     cpuload;
+        u32     remainheap;
+
+        /* Firmware version */
+        u32     version;
+        u32     major;
+        u32     sub;
+        u32     rel;
+        u32     buildnr;
+};
+
+struct saa7164_dvb {
+        struct mutex lock;
+        struct dvb_adapter adapter;
+        struct dvb_frontend *frontend;
+        struct dvb_demux demux;
+        struct dmxdev dmxdev;
+        struct dmx_frontend fe_hw;
+        struct dmx_frontend fe_mem;
+        struct dvb_net net;
+        int feeding;
+};
+
+struct saa7164_i2c {
+        struct saa7164_dev              *dev;
+
+        enum saa7164_i2c_bus_nr         nr;
+
+        /* I2C I/O */
+        struct i2c_adapter              i2c_adap;
+        struct i2c_algo_bit_data        i2c_algo;
+        struct i2c_client               i2c_client;
+        u32                             i2c_rc;
+};
+
+struct saa7164_tsport;
+
+struct saa7164_buffer {
+        struct list_head list;
+
+        u32 nr;
+
+        struct saa7164_tsport *port;
+
+        /* Hardware Specific */
+        /* PCI Memory allocations */
+        enum saa7164_buffer_flags flags; /* Free, Busy, Full */
+
+        /* A block of page align PCI memory */
+        u32 pci_size;   /* PCI allocation size in bytes */
+        u64 *cpu;       /* Virtual address */
+        dma_addr_t dma; /* Physical address */
+
+        /* A page table that splits the block into a number of entries */
+        u32 pt_size;            /* PCI allocation size in bytes */
+        u64 *pt_cpu;            /* Virtual address */
+        dma_addr_t pt_dma;      /* Physical address */
+};
+
+struct saa7164_tsport {
+
+        struct saa7164_dev *dev;
+        int nr;
+        enum port_t type;
+
+        struct saa7164_dvb dvb;
+
+        /* HW related stream parameters */
+        tmHWStreamParameters_t hw_streamingparams;
+
+        /* DMA configuration values, is seeded during initialization */
+        tmComResDMATermDescrHeader_t hwcfg;
+
+        /* hardware specific registers */
+        u32 bufcounter;
+        u32 pitch;
+        u32 bufsize;
+        u32 bufoffset;
+        u32 bufptr32l;
+        u32 bufptr32h;
+        u64 bufptr64;
+
+        u32 numpte;     /* Number of entries in array, only valid in head */
+        struct mutex dmaqueue_lock;
+        struct mutex dummy_dmaqueue_lock;
+        struct saa7164_buffer dmaqueue;
+        struct saa7164_buffer dummy_dmaqueue;
+
+};
+
+struct saa7164_dev {
+        struct list_head        devlist;
+        atomic_t                refcount;
+
+        /* pci stuff */
+        struct pci_dev  *pci;
+        unsigned char   pci_rev, pci_lat;
+        int             pci_bus, pci_slot;
+        u32             __iomem *lmmio;
+        u8              __iomem *bmmio;
+        u32             __iomem *lmmio2;
+        u8              __iomem *bmmio2;
+        int             pci_irqmask;
+
+        /* board details */
+        int     nr;
+        int     hwrevision;
+        u32     board;
+        char    name[32];
+
+        /* firmware status */
+        struct saa7164_fw_status        fw_status;
+
+        tmComResHWDescr_t               hwdesc;
+        tmComResInterfaceDescr_t        intfdesc;
+        tmComResBusDescr_t              busdesc;
+
+        tmComResBusInfo_t               bus;
+
+        /* Interrupt status and ack registers */
+        u32 int_status;
+        u32 int_ack;
+
+        struct cmd                      cmds[SAA_CMD_MAX_MSG_UNITS];
+        struct mutex                    lock;
+
+        /* I2c related */
+        struct saa7164_i2c i2c_bus[3];
+
+        /* Transport related */
+        struct saa7164_tsport ts1, ts2;
+
+        /* Deferred command/api interrupts handling */
+        struct work_struct workcmd;
+
+};
+
+extern struct list_head saa7164_devlist;
+extern unsigned int waitsecs;
+
+/* ----------------------------------------------------------- */
+/* saa7164-core.c                                              */
+void saa7164_dumpregs(struct saa7164_dev *dev, u32 addr);
+void saa7164_dumphex16(struct saa7164_dev *dev, u8 *buf, int len);
+void saa7164_getfirmwarestatus(struct saa7164_dev *dev);
+u32 saa7164_getcurrentfirmwareversion(struct saa7164_dev *dev);
+
+/* ----------------------------------------------------------- */
+/* saa7164-fw.c                                                */
+int saa7164_downloadfirmware(struct saa7164_dev *dev);
+
+/* ----------------------------------------------------------- */
+/* saa7164-i2c.c                                               */
+extern int saa7164_i2c_register(struct saa7164_i2c *bus);
+extern int saa7164_i2c_unregister(struct saa7164_i2c *bus);
+extern void saa7164_call_i2c_clients(struct saa7164_i2c *bus,
+        unsigned int cmd, void *arg);
+
+/* ----------------------------------------------------------- */
+/* saa7164-bus.c                                               */
+int saa7164_bus_setup(struct saa7164_dev *dev);
+void saa7164_bus_dump(struct saa7164_dev *dev);
+int saa7164_bus_set(struct saa7164_dev *dev, tmComResInfo_t* msg, void *buf);
+int saa7164_bus_get(struct saa7164_dev *dev, tmComResInfo_t* msg,
+        void *buf, int peekonly);
+
+/* ----------------------------------------------------------- */
+/* saa7164-cmd.c                                               */
+int saa7164_cmd_send(struct saa7164_dev *dev,
+        u8 id, tmComResCmd_t command, u16 controlselector,
+        u16 size, void *buf);
+void saa7164_cmd_signal(struct saa7164_dev *dev, u8 seqno);
+int saa7164_irq_dequeue(struct saa7164_dev *dev);
+
+/* ----------------------------------------------------------- */
+/* saa7164-api.c                                               */
+int saa7164_api_get_fw_version(struct saa7164_dev *dev, u32 *version);
+int saa7164_api_enum_subdevs(struct saa7164_dev *dev);
+int saa7164_api_i2c_read(struct saa7164_i2c *bus, u8 addr, u32 reglen, u8 *reg,
+        u32 datalen, u8 *data);
+int saa7164_api_i2c_write(struct saa7164_i2c *bus, u8 addr,
+        u32 datalen, u8 *data);
+int saa7164_api_dif_write(struct saa7164_i2c *bus, u8 addr,
+        u32 datalen, u8 *data);
+int saa7164_api_read_eeprom(struct saa7164_dev *dev, u8 *buf, int buflen);
+int saa7164_api_set_gpiobit(struct saa7164_dev *dev, u8 unitid, u8 pin);
+int saa7164_api_clear_gpiobit(struct saa7164_dev *dev, u8 unitid, u8 pin);
+int saa7164_api_transition_port(struct saa7164_tsport *port, u8 mode);
+
+/* ----------------------------------------------------------- */
+/* saa7164-cards.c                                             */
+extern struct saa7164_board saa7164_boards[];
+extern const unsigned int saa7164_bcount;
+
+extern struct saa7164_subid saa7164_subids[];
+extern const unsigned int saa7164_idcount;
+
+extern void saa7164_card_list(struct saa7164_dev *dev);
+extern void saa7164_gpio_setup(struct saa7164_dev *dev);
+extern void saa7164_card_setup(struct saa7164_dev *dev);
+
+extern int saa7164_i2caddr_to_reglen(struct saa7164_i2c *bus, int addr);
+extern int saa7164_i2caddr_to_unitid(struct saa7164_i2c *bus, int addr);
+extern char *saa7164_unitid_name(struct saa7164_dev *dev, u8 unitid);
+
+/* ----------------------------------------------------------- */
+/* saa7164-dvb.c                                               */
+extern int saa7164_dvb_register(struct saa7164_tsport *port);
+extern int saa7164_dvb_unregister(struct saa7164_tsport *port);
+
+/* ----------------------------------------------------------- */
+/* saa7164-buffer.c                                            */
+extern struct saa7164_buffer *saa7164_buffer_alloc(struct saa7164_tsport *port,
+        u32 len);
+extern int saa7164_buffer_dealloc(struct saa7164_tsport *port,
+        struct saa7164_buffer *buf);
+
+/* ----------------------------------------------------------- */
+
+extern unsigned int debug;
+#define dprintk(level, fmt, arg...)\
+        do { if (debug & level)\
+                printk(KERN_DEBUG "%s: " fmt, dev->name, ## arg);\
+        } while (0)
+
+#define log_warn(fmt, arg...)\
+        do { \
+                printk(KERN_WARNING "%s: " fmt, dev->name, ## arg);\
+        } while (0)
+
+#define log_err(fmt, arg...)\
+        do { \
+                printk(KERN_ERROR "%s: " fmt, dev->name, ## arg);\
+        } while (0)
+
+#define saa7164_readl(reg) readl(dev->lmmio + ((reg) >> 2))
+#define saa7164_writel(reg, value) writel((value), dev->lmmio + ((reg) >> 2))
+
+
+#define saa7164_readb(reg)             readl(dev->bmmio + (reg))
+#define saa7164_writeb(reg, value)     writel((value), dev->bmmio + (reg))
+
diff --git a/drivers/media/video/sh_mobile_ceu_camera.c b/drivers/media/video/sh_mobile_ceu_camera.c
index 61c47b824083..5ab7c5aefd62 100644
--- a/drivers/media/video/sh_mobile_ceu_camera.c
+++ b/drivers/media/video/sh_mobile_ceu_camera.c
@@ -74,6 +74,13 @@
 #define CDBYR2 0x98 /* Capture data bottom-field address Y register 2 */
 #define CDBCR2 0x9c /* Capture data bottom-field address C register 2 */
 
+#undef DEBUG_GEOMETRY
+#ifdef DEBUG_GEOMETRY
+#define dev_geo dev_info
+#else
+#define dev_geo dev_dbg
+#endif
+
 /* per video frame buffer */
 struct sh_mobile_ceu_buffer {
         struct videobuf_buffer vb; /* v4l buffer must be first */
@@ -92,10 +99,21 @@ struct sh_mobile_ceu_dev {
         spinlock_t lock;
         struct list_head capture;
         struct videobuf_buffer *active;
-        int is_interlaced;
 
         struct sh_mobile_ceu_info *pdata;
 
+        u32 cflcr;
+
+        unsigned int is_interlaced:1;
+        unsigned int image_mode:1;
+        unsigned int is_16bit:1;
+};
+
+struct sh_mobile_ceu_cam {
+        struct v4l2_rect ceu_rect;
+        unsigned int cam_width;
+        unsigned int cam_height;
+        const struct soc_camera_data_format *extra_fmt;
         const struct soc_camera_data_format *camera_fmt;
 };
 
@@ -146,7 +164,8 @@ static int sh_mobile_ceu_videobuf_setup(struct videobuf_queue *vq,
         struct sh_mobile_ceu_dev *pcdev = ici->priv;
         int bytes_per_pixel = (icd->current_fmt->depth + 7) >> 3;
 
-        *size = PAGE_ALIGN(icd->width * icd->height * bytes_per_pixel);
+        *size = PAGE_ALIGN(icd->user_width * icd->user_height *
+                           bytes_per_pixel);
 
         if (0 == *count)
                 *count = 2;
@@ -156,7 +175,7 @@ static int sh_mobile_ceu_videobuf_setup(struct videobuf_queue *vq,
                         (*count)--;
         }
 
-        dev_dbg(&icd->dev, "count=%d, size=%d\n", *count, *size);
+        dev_dbg(icd->dev.parent, "count=%d, size=%d\n", *count, *size);
 
         return 0;
 }
@@ -165,8 +184,9 @@ static void free_buffer(struct videobuf_queue *vq,
                         struct sh_mobile_ceu_buffer *buf)
 {
         struct soc_camera_device *icd = vq->priv_data;
+        struct device *dev = icd->dev.parent;
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
+        dev_dbg(dev, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
                 &buf->vb, buf->vb.baddr, buf->vb.bsize);
 
         if (in_interrupt())
@@ -174,7 +194,7 @@ static void free_buffer(struct videobuf_queue *vq,
 
         videobuf_waiton(&buf->vb, 0, 0);
         videobuf_dma_contig_free(vq, &buf->vb);
-        dev_dbg(&icd->dev, "%s freed\n", __func__);
+        dev_dbg(dev, "%s freed\n", __func__);
         buf->vb.state = VIDEOBUF_NEEDS_INIT;
 }
 
@@ -205,7 +225,7 @@ static void sh_mobile_ceu_capture(struct sh_mobile_ceu_dev *pcdev)
         phys_addr_top = videobuf_to_dma_contig(pcdev->active);
         ceu_write(pcdev, CDAYR, phys_addr_top);
         if (pcdev->is_interlaced) {
-                phys_addr_bottom = phys_addr_top + icd->width;
+                phys_addr_bottom = phys_addr_top + icd->user_width;
                 ceu_write(pcdev, CDBYR, phys_addr_bottom);
         }
 
@@ -214,10 +234,12 @@ static void sh_mobile_ceu_capture(struct sh_mobile_ceu_dev *pcdev)
         case V4L2_PIX_FMT_NV21:
         case V4L2_PIX_FMT_NV16:
         case V4L2_PIX_FMT_NV61:
-                phys_addr_top += icd->width * icd->height;
+                phys_addr_top += icd->user_width *
+                        icd->user_height;
                 ceu_write(pcdev, CDACR, phys_addr_top);
                 if (pcdev->is_interlaced) {
-                        phys_addr_bottom = phys_addr_top + icd->width;
+                        phys_addr_bottom = phys_addr_top +
+                                icd->user_width;
                         ceu_write(pcdev, CDBCR, phys_addr_bottom);
                 }
         }
@@ -236,7 +258,7 @@ static int sh_mobile_ceu_videobuf_prepare(struct videobuf_queue *vq,
 
         buf = container_of(vb, struct sh_mobile_ceu_buffer, vb);
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
+        dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
                 vb, vb->baddr, vb->bsize);
 
         /* Added list head initialization on alloc */
@@ -251,12 +273,12 @@ static int sh_mobile_ceu_videobuf_prepare(struct videobuf_queue *vq,
         BUG_ON(NULL == icd->current_fmt);
 
         if (buf->fmt    != icd->current_fmt ||
-            vb->width   != icd->width ||
-            vb->height  != icd->height ||
+            vb->width   != icd->user_width ||
+            vb->height  != icd->user_height ||
             vb->field   != field) {
                 buf->fmt        = icd->current_fmt;
-                vb->width       = icd->width;
-                vb->height      = icd->height;
+                vb->width       = icd->user_width;
+                vb->height      = icd->user_height;
                 vb->field       = field;
                 vb->state       = VIDEOBUF_NEEDS_INIT;
         }
@@ -289,7 +311,7 @@ static void sh_mobile_ceu_videobuf_queue(struct videobuf_queue *vq,
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct sh_mobile_ceu_dev *pcdev = ici->priv;
 
-        dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
+        dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
                 vb, vb->baddr, vb->bsize);
 
         vb->state = VIDEOBUF_QUEUED;
@@ -304,6 +326,27 @@ static void sh_mobile_ceu_videobuf_queue(struct videobuf_queue *vq,
 static void sh_mobile_ceu_videobuf_release(struct videobuf_queue *vq,
                                            struct videobuf_buffer *vb)
 {
+        struct soc_camera_device *icd = vq->priv_data;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct sh_mobile_ceu_dev *pcdev = ici->priv;
+        unsigned long flags;
+
+        spin_lock_irqsave(&pcdev->lock, flags);
+
+        if (pcdev->active == vb) {
+                /* disable capture (release DMA buffer), reset */
+                ceu_write(pcdev, CAPSR, 1 << 16);
+                pcdev->active = NULL;
+        }
+
+        if ((vb->state == VIDEOBUF_ACTIVE || vb->state == VIDEOBUF_QUEUED) &&
+            !list_empty(&vb->queue)) {
+                vb->state = VIDEOBUF_ERROR;
+                list_del_init(&vb->queue);
+        }
+
+        spin_unlock_irqrestore(&pcdev->lock, flags);
+
         free_buffer(vq, container_of(vb, struct sh_mobile_ceu_buffer, vb));
 }
 
@@ -323,6 +366,10 @@ static irqreturn_t sh_mobile_ceu_irq(int irq, void *data)
         spin_lock_irqsave(&pcdev->lock, flags);
 
         vb = pcdev->active;
+        if (!vb)
+                /* Stale interrupt from a released buffer */
+                goto out;
+
         list_del_init(&vb->queue);
 
         if (!list_empty(&pcdev->capture))
@@ -337,6 +384,8 @@ static irqreturn_t sh_mobile_ceu_irq(int irq, void *data)
         do_gettimeofday(&vb->ts);
         vb->field_count++;
         wake_up(&vb->done);
+
+out:
         spin_unlock_irqrestore(&pcdev->lock, flags);
 
         return IRQ_HANDLED;
@@ -347,28 +396,23 @@ static int sh_mobile_ceu_add_device(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct sh_mobile_ceu_dev *pcdev = ici->priv;
-        int ret = -EBUSY;
 
         if (pcdev->icd)
-                goto err;
+                return -EBUSY;
 
-        dev_info(&icd->dev,
+        dev_info(icd->dev.parent,
                  "SuperH Mobile CEU driver attached to camera %d\n",
                  icd->devnum);
 
-        ret = icd->ops->init(icd);
-        if (ret)
-                goto err;
-
-        pm_runtime_get_sync(ici->dev);
+        clk_enable(pcdev->clk);
 
         ceu_write(pcdev, CAPSR, 1 << 16); /* reset */
         while (ceu_read(pcdev, CSTSR) & 1)
                 msleep(1);
 
         pcdev->icd = icd;
-err:
-        return ret;
+
+        return 0;
 }
 
 /* Called with .video_lock held */
@@ -394,25 +438,151 @@ static void sh_mobile_ceu_remove_device(struct soc_camera_device *icd)
         }
         spin_unlock_irqrestore(&pcdev->lock, flags);
 
-        pm_runtime_put_sync(ici->dev);
+        clk_disable(pcdev->clk);
 
-        icd->ops->release(icd);
-
-        dev_info(&icd->dev,
+        dev_info(icd->dev.parent,
                  "SuperH Mobile CEU driver detached from camera %d\n",
                  icd->devnum);
 
         pcdev->icd = NULL;
 }
 
+/*
+ * See chapter 29.4.12 "Capture Filter Control Register (CFLCR)"
+ * in SH7722 Hardware Manual
+ */
+static unsigned int size_dst(unsigned int src, unsigned int scale)
+{
+        unsigned int mant_pre = scale >> 12;
+        if (!src || !scale)
+                return src;
+        return ((mant_pre + 2 * (src - 1)) / (2 * mant_pre) - 1) *
+                mant_pre * 4096 / scale + 1;
+}
+
+static u16 calc_scale(unsigned int src, unsigned int *dst)
+{
+        u16 scale;
+
+        if (src == *dst)
+                return 0;
+
+        scale = (src * 4096 / *dst) & ~7;
+
+        while (scale > 4096 && size_dst(src, scale) < *dst)
+                scale -= 8;
+
+        *dst = size_dst(src, scale);
+
+        return scale;
+}
+
+/* rect is guaranteed to not exceed the scaled camera rectangle */
+static void sh_mobile_ceu_set_rect(struct soc_camera_device *icd,
+                                   unsigned int out_width,
+                                   unsigned int out_height)
+{
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct sh_mobile_ceu_cam *cam = icd->host_priv;
+        struct v4l2_rect *rect = &cam->ceu_rect;
+        struct sh_mobile_ceu_dev *pcdev = ici->priv;
+        unsigned int height, width, cdwdr_width, in_width, in_height;
+        unsigned int left_offset, top_offset;
+        u32 camor;
+
+        dev_dbg(icd->dev.parent, "Crop %ux%u@%u:%u\n",
+                rect->width, rect->height, rect->left, rect->top);
+
+        left_offset     = rect->left;
+        top_offset      = rect->top;
+
+        if (pcdev->image_mode) {
+                in_width = rect->width;
+                if (!pcdev->is_16bit) {
+                        in_width *= 2;
+                        left_offset *= 2;
+                }
+                width = cdwdr_width = out_width;
+        } else {
+                unsigned int w_factor = (icd->current_fmt->depth + 7) >> 3;
+
+                width = out_width * w_factor / 2;
+
+                if (!pcdev->is_16bit)
+                        w_factor *= 2;
+
+                in_width = rect->width * w_factor / 2;
+                left_offset = left_offset * w_factor / 2;
+
+                cdwdr_width = width * 2;
+        }
+
+        height = out_height;
+        in_height = rect->height;
+        if (pcdev->is_interlaced) {
+                height /= 2;
+                in_height /= 2;
+                top_offset /= 2;
+                cdwdr_width *= 2;
+        }
+
+        /* Set CAMOR, CAPWR, CFSZR, take care of CDWDR */
+        camor = left_offset | (top_offset << 16);
+
+        dev_geo(icd->dev.parent,
+                "CAMOR 0x%x, CAPWR 0x%x, CFSZR 0x%x, CDWDR 0x%x\n", camor,
+                (in_height << 16) | in_width, (height << 16) | width,
+                cdwdr_width);
+
+        ceu_write(pcdev, CAMOR, camor);
+        ceu_write(pcdev, CAPWR, (in_height << 16) | in_width);
+        ceu_write(pcdev, CFSZR, (height << 16) | width);
+        ceu_write(pcdev, CDWDR, cdwdr_width);
+}
+
+static u32 capture_save_reset(struct sh_mobile_ceu_dev *pcdev)
+{
+        u32 capsr = ceu_read(pcdev, CAPSR);
+        ceu_write(pcdev, CAPSR, 1 << 16); /* reset, stop capture */
+        return capsr;
+}
+
+static void capture_restore(struct sh_mobile_ceu_dev *pcdev, u32 capsr)
+{
+        unsigned long timeout = jiffies + 10 * HZ;
+
+        /*
+         * Wait until the end of the current frame. It can take a long time,
+         * but if it has been aborted by a CAPSR reset, it shoule exit sooner.
+         */
+        while ((ceu_read(pcdev, CSTSR) & 1) && time_before(jiffies, timeout))
+                msleep(1);
+
+        if (time_after(jiffies, timeout)) {
+                dev_err(pcdev->ici.v4l2_dev.dev,
+                        "Timeout waiting for frame end! Interface problem?\n");
+                return;
+        }
+
+        /* Wait until reset clears, this shall not hang... */
+        while (ceu_read(pcdev, CAPSR) & (1 << 16))
+                udelay(10);
+
+        /* Anything to restore? */
+        if (capsr & ~(1 << 16))
+                ceu_write(pcdev, CAPSR, capsr);
+}
+
 static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
                                        __u32 pixfmt)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct sh_mobile_ceu_dev *pcdev = ici->priv;
-        int ret, buswidth, width, height, cfszr_width, cdwdr_width;
+        int ret;
         unsigned long camera_flags, common_flags, value;
-        int yuv_mode, yuv_lineskip;
+        int yuv_lineskip;
+        struct sh_mobile_ceu_cam *cam = icd->host_priv;
+        u32 capsr = capture_save_reset(pcdev);
 
         camera_flags = icd->ops->query_bus_param(icd);
         common_flags = soc_camera_bus_param_compatible(camera_flags,
@@ -426,10 +596,10 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
 
         switch (common_flags & SOCAM_DATAWIDTH_MASK) {
         case SOCAM_DATAWIDTH_8:
-                buswidth = 8;
+                pcdev->is_16bit = 0;
                 break;
         case SOCAM_DATAWIDTH_16:
-                buswidth = 16;
+                pcdev->is_16bit = 1;
                 break;
         default:
                 return -EINVAL;
@@ -439,7 +609,7 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
         ceu_write(pcdev, CRCMPR, 0);
 
         value = 0x00000010; /* data fetch by default */
-        yuv_mode = yuv_lineskip = 0;
+        yuv_lineskip = 0;
 
         switch (icd->current_fmt->fourcc) {
         case V4L2_PIX_FMT_NV12:
@@ -448,8 +618,7 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
                 /* fall-through */
         case V4L2_PIX_FMT_NV16:
         case V4L2_PIX_FMT_NV61:
-                yuv_mode = 1;
-                switch (pcdev->camera_fmt->fourcc) {
+                switch (cam->camera_fmt->fourcc) {
                 case V4L2_PIX_FMT_UYVY:
                         value = 0x00000000; /* Cb0, Y0, Cr0, Y1 */
                         break;
@@ -473,36 +642,16 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
 
         value |= common_flags & SOCAM_VSYNC_ACTIVE_LOW ? 1 << 1 : 0;
         value |= common_flags & SOCAM_HSYNC_ACTIVE_LOW ? 1 << 0 : 0;
-        value |= buswidth == 16 ? 1 << 12 : 0;
+        value |= pcdev->is_16bit ? 1 << 12 : 0;
         ceu_write(pcdev, CAMCR, value);
 
         ceu_write(pcdev, CAPCR, 0x00300000);
         ceu_write(pcdev, CAIFR, pcdev->is_interlaced ? 0x101 : 0);
 
+        sh_mobile_ceu_set_rect(icd, icd->user_width, icd->user_height);
         mdelay(1);
 
-        if (yuv_mode) {
-                width = icd->width * 2;
-                width = buswidth == 16 ? width / 2 : width;
-                cfszr_width = cdwdr_width = icd->width;
-        } else {
-                width = icd->width * ((icd->current_fmt->depth + 7) >> 3);
-                width = buswidth == 16 ? width / 2 : width;
-                cfszr_width = buswidth == 8 ? width / 2 : width;
-                cdwdr_width = buswidth == 16 ? width * 2 : width;
-        }
-
-        height = icd->height;
-        if (pcdev->is_interlaced) {
-                height /= 2;
-                cdwdr_width *= 2;
-        }
-
-        ceu_write(pcdev, CAMOR, 0);
-        ceu_write(pcdev, CAPWR, (height << 16) | width);
-        ceu_write(pcdev, CFLCR, 0); /* no scaling */
-        ceu_write(pcdev, CFSZR, (height << 16) | cfszr_width);
-        ceu_write(pcdev, CLFCR, 0); /* no lowpass filter */
+        ceu_write(pcdev, CFLCR, pcdev->cflcr);
 
         /* A few words about byte order (observed in Big Endian mode)
          *
@@ -521,10 +670,15 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
                 value &= ~0x00000010; /* convert 4:2:2 -> 4:2:0 */
 
         ceu_write(pcdev, CDOCR, value);
-
-        ceu_write(pcdev, CDWDR, cdwdr_width);
         ceu_write(pcdev, CFWCR, 0); /* keep "datafetch firewall" disabled */
 
+        dev_dbg(icd->dev.parent, "S_FMT successful for %c%c%c%c %ux%u\n",
+                pixfmt & 0xff, (pixfmt >> 8) & 0xff,
+                (pixfmt >> 16) & 0xff, (pixfmt >> 24) & 0xff,
+                icd->user_width, icd->user_height);
+
+        capture_restore(pcdev, capsr);
+
         /* not in bundle mode: skip CBDSR, CDAYR2, CDACR2, CDBYR2, CDBCR2 */
         return 0;
 }
@@ -574,24 +728,35 @@ static const struct soc_camera_data_format sh_mobile_ceu_formats[] = {
 static int sh_mobile_ceu_get_formats(struct soc_camera_device *icd, int idx,
                                      struct soc_camera_format_xlate *xlate)
 {
-        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct device *dev = icd->dev.parent;
         int ret, k, n;
         int formats = 0;
+        struct sh_mobile_ceu_cam *cam;
 
         ret = sh_mobile_ceu_try_bus_param(icd);
         if (ret < 0)
                 return 0;
 
+        if (!icd->host_priv) {
+                cam = kzalloc(sizeof(*cam), GFP_KERNEL);
+                if (!cam)
+                        return -ENOMEM;
+
+                icd->host_priv = cam;
+        } else {
+                cam = icd->host_priv;
+        }
+
         /* Beginning of a pass */
         if (!idx)
-                icd->host_priv = NULL;
+                cam->extra_fmt = NULL;
 
         switch (icd->formats[idx].fourcc) {
         case V4L2_PIX_FMT_UYVY:
         case V4L2_PIX_FMT_VYUY:
         case V4L2_PIX_FMT_YUYV:
         case V4L2_PIX_FMT_YVYU:
-                if (icd->host_priv)
+                if (cam->extra_fmt)
                         goto add_single_format;
 
                 /*
@@ -603,7 +768,7 @@ static int sh_mobile_ceu_get_formats(struct soc_camera_device *icd, int idx,
                  * the host_priv pointer and check whether the format you're
                  * going to add now is already there.
                  */
-                icd->host_priv = (void *)sh_mobile_ceu_formats;
+                cam->extra_fmt = (void *)sh_mobile_ceu_formats;
 
                 n = ARRAY_SIZE(sh_mobile_ceu_formats);
                 formats += n;
@@ -612,7 +777,7 @@ static int sh_mobile_ceu_get_formats(struct soc_camera_device *icd, int idx,
                         xlate->cam_fmt = icd->formats + idx;
                         xlate->buswidth = icd->formats[idx].depth;
                         xlate++;
-                        dev_dbg(ici->dev, "Providing format %s using %s\n",
+                        dev_dbg(dev, "Providing format %s using %s\n",
                                 sh_mobile_ceu_formats[k].name,
                                 icd->formats[idx].name);
                 }
@@ -625,7 +790,7 @@ add_single_format:
                         xlate->cam_fmt = icd->formats + idx;
                         xlate->buswidth = icd->formats[idx].depth;
                         xlate++;
-                        dev_dbg(ici->dev,
+                        dev_dbg(dev,
                                 "Providing format %s in pass-through mode\n",
                                 icd->formats[idx].name);
                 }
@@ -634,82 +799,714 @@ add_single_format:
         return formats;
 }
 
+static void sh_mobile_ceu_put_formats(struct soc_camera_device *icd)
+{
+        kfree(icd->host_priv);
+        icd->host_priv = NULL;
+}
+
+/* Check if any dimension of r1 is smaller than respective one of r2 */
+static bool is_smaller(struct v4l2_rect *r1, struct v4l2_rect *r2)
+{
+        return r1->width < r2->width || r1->height < r2->height;
+}
+
+/* Check if r1 fails to cover r2 */
+static bool is_inside(struct v4l2_rect *r1, struct v4l2_rect *r2)
+{
+        return r1->left > r2->left || r1->top > r2->top ||
+                r1->left + r1->width < r2->left + r2->width ||
+                r1->top + r1->height < r2->top + r2->height;
+}
+
+static unsigned int scale_down(unsigned int size, unsigned int scale)
+{
+        return (size * 4096 + scale / 2) / scale;
+}
+
+static unsigned int scale_up(unsigned int size, unsigned int scale)
+{
+        return (size * scale + 2048) / 4096;
+}
+
+static unsigned int calc_generic_scale(unsigned int input, unsigned int output)
+{
+        return (input * 4096 + output / 2) / output;
+}
+
+static int client_g_rect(struct v4l2_subdev *sd, struct v4l2_rect *rect)
+{
+        struct v4l2_crop crop;
+        struct v4l2_cropcap cap;
+        int ret;
+
+        crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        ret = v4l2_subdev_call(sd, video, g_crop, &crop);
+        if (!ret) {
+                *rect = crop.c;
+                return ret;
+        }
+
+        /* Camera driver doesn't support .g_crop(), assume default rectangle */
+        cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        ret = v4l2_subdev_call(sd, video, cropcap, &cap);
+        if (ret < 0)
+                return ret;
+
+        *rect = cap.defrect;
+
+        return ret;
+}
+
+/*
+ * The common for both scaling and cropping iterative approach is:
+ * 1. try if the client can produce exactly what requested by the user
+ * 2. if (1) failed, try to double the client image until we get one big enough
+ * 3. if (2) failed, try to request the maximum image
+ */
+static int client_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *crop,
+                         struct v4l2_crop *cam_crop)
+{
+        struct v4l2_rect *rect = &crop->c, *cam_rect = &cam_crop->c;
+        struct device *dev = sd->v4l2_dev->dev;
+        struct v4l2_cropcap cap;
+        int ret;
+        unsigned int width, height;
+
+        v4l2_subdev_call(sd, video, s_crop, crop);
+        ret = client_g_rect(sd, cam_rect);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * Now cam_crop contains the current camera input rectangle, and it must
+         * be within camera cropcap bounds
+         */
+        if (!memcmp(rect, cam_rect, sizeof(*rect))) {
+                /* Even if camera S_CROP failed, but camera rectangle matches */
+                dev_dbg(dev, "Camera S_CROP successful for %ux%u@%u:%u\n",
+                        rect->width, rect->height, rect->left, rect->top);
+                return 0;
+        }
+
+        /* Try to fix cropping, that camera hasn't managed to set */
+        dev_geo(dev, "Fix camera S_CROP for %ux%u@%u:%u to %ux%u@%u:%u\n",
+                cam_rect->width, cam_rect->height,
+                cam_rect->left, cam_rect->top,
+                rect->width, rect->height, rect->left, rect->top);
+
+        /* We need sensor maximum rectangle */
+        ret = v4l2_subdev_call(sd, video, cropcap, &cap);
+        if (ret < 0)
+                return ret;
+
+        soc_camera_limit_side(&rect->left, &rect->width, cap.bounds.left, 2,
+                              cap.bounds.width);
+        soc_camera_limit_side(&rect->top, &rect->height, cap.bounds.top, 4,
+                              cap.bounds.height);
+
+        /*
+         * Popular special case - some cameras can only handle fixed sizes like
+         * QVGA, VGA,... Take care to avoid infinite loop.
+         */
+        width = max(cam_rect->width, 2);
+        height = max(cam_rect->height, 2);
+
+        while (!ret && (is_smaller(cam_rect, rect) ||
+                        is_inside(cam_rect, rect)) &&
+               (cap.bounds.width > width || cap.bounds.height > height)) {
+
+                width *= 2;
+                height *= 2;
+
+                cam_rect->width = width;
+                cam_rect->height = height;
+
+                /*
+                 * We do not know what capabilities the camera has to set up
+                 * left and top borders. We could try to be smarter in iterating
+                 * them, e.g., if camera current left is to the right of the
+                 * target left, set it to the middle point between the current
+                 * left and minimum left. But that would add too much
+                 * complexity: we would have to iterate each border separately.
+                 */
+                if (cam_rect->left > rect->left)
+                        cam_rect->left = cap.bounds.left;
+
+                if (cam_rect->left + cam_rect->width < rect->left + rect->width)
+                        cam_rect->width = rect->left + rect->width -
+                                cam_rect->left;
+
+                if (cam_rect->top > rect->top)
+                        cam_rect->top = cap.bounds.top;
+
+                if (cam_rect->top + cam_rect->height < rect->top + rect->height)
+                        cam_rect->height = rect->top + rect->height -
+                                cam_rect->top;
+
+                v4l2_subdev_call(sd, video, s_crop, cam_crop);
+                ret = client_g_rect(sd, cam_rect);
+                dev_geo(dev, "Camera S_CROP %d for %ux%u@%u:%u\n", ret,
+                        cam_rect->width, cam_rect->height,
+                        cam_rect->left, cam_rect->top);
+        }
+
+        /* S_CROP must not modify the rectangle */
+        if (is_smaller(cam_rect, rect) || is_inside(cam_rect, rect)) {
+                /*
+                 * The camera failed to configure a suitable cropping,
+                 * we cannot use the current rectangle, set to max
+                 */
+                *cam_rect = cap.bounds;
+                v4l2_subdev_call(sd, video, s_crop, cam_crop);
+                ret = client_g_rect(sd, cam_rect);
+                dev_geo(dev, "Camera S_CROP %d for max %ux%u@%u:%u\n", ret,
+                        cam_rect->width, cam_rect->height,
+                        cam_rect->left, cam_rect->top);
+        }
+
+        return ret;
+}
+
+static int get_camera_scales(struct v4l2_subdev *sd, struct v4l2_rect *rect,
+                             unsigned int *scale_h, unsigned int *scale_v)
+{
+        struct v4l2_format f;
+        int ret;
+
+        f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        ret = v4l2_subdev_call(sd, video, g_fmt, &f);
+        if (ret < 0)
+                return ret;
+
+        *scale_h = calc_generic_scale(rect->width, f.fmt.pix.width);
+        *scale_v = calc_generic_scale(rect->height, f.fmt.pix.height);
+
+        return 0;
+}
+
+static int get_camera_subwin(struct soc_camera_device *icd,
+                             struct v4l2_rect *cam_subrect,
+                             unsigned int cam_hscale, unsigned int cam_vscale)
+{
+        struct sh_mobile_ceu_cam *cam = icd->host_priv;
+        struct v4l2_rect *ceu_rect = &cam->ceu_rect;
+
+        if (!ceu_rect->width) {
+                struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+                struct device *dev = icd->dev.parent;
+                struct v4l2_format f;
+                struct v4l2_pix_format *pix = &f.fmt.pix;
+                int ret;
+                /* First time */
+
+                f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+                ret = v4l2_subdev_call(sd, video, g_fmt, &f);
+                if (ret < 0)
+                        return ret;
+
+                dev_geo(dev, "camera fmt %ux%u\n", pix->width, pix->height);
+
+                if (pix->width > 2560) {
+                        ceu_rect->width  = 2560;
+                        ceu_rect->left   = (pix->width - 2560) / 2;
+                } else {
+                        ceu_rect->width  = pix->width;
+                        ceu_rect->left   = 0;
+                }
+
+                if (pix->height > 1920) {
+                        ceu_rect->height = 1920;
+                        ceu_rect->top    = (pix->height - 1920) / 2;
+                } else {
+                        ceu_rect->height = pix->height;
+                        ceu_rect->top    = 0;
+                }
+
+                dev_geo(dev, "initialised CEU rect %ux%u@%u:%u\n",
+                        ceu_rect->width, ceu_rect->height,
+                        ceu_rect->left, ceu_rect->top);
+        }
+
+        cam_subrect->width      = scale_up(ceu_rect->width, cam_hscale);
+        cam_subrect->left       = scale_up(ceu_rect->left, cam_hscale);
+        cam_subrect->height     = scale_up(ceu_rect->height, cam_vscale);
+        cam_subrect->top        = scale_up(ceu_rect->top, cam_vscale);
+
+        return 0;
+}
+
+static int client_s_fmt(struct soc_camera_device *icd, struct v4l2_format *f,
+                        bool ceu_can_scale)
+{
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        struct device *dev = icd->dev.parent;
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+        unsigned int width = pix->width, height = pix->height, tmp_w, tmp_h;
+        unsigned int max_width, max_height;
+        struct v4l2_cropcap cap;
+        int ret;
+
+        cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        ret = v4l2_subdev_call(sd, video, cropcap, &cap);
+        if (ret < 0)
+                return ret;
+
+        max_width = min(cap.bounds.width, 2560);
+        max_height = min(cap.bounds.height, 1920);
+
+        ret = v4l2_subdev_call(sd, video, s_fmt, f);
+        if (ret < 0)
+                return ret;
+
+        dev_geo(dev, "camera scaled to %ux%u\n", pix->width, pix->height);
+
+        if ((width == pix->width && height == pix->height) || !ceu_can_scale)
+                return 0;
+
+        /* Camera set a format, but geometry is not precise, try to improve */
+        tmp_w = pix->width;
+        tmp_h = pix->height;
+
+        /* width <= max_width && height <= max_height - guaranteed by try_fmt */
+        while ((width > tmp_w || height > tmp_h) &&
+               tmp_w < max_width && tmp_h < max_height) {
+                tmp_w = min(2 * tmp_w, max_width);
+                tmp_h = min(2 * tmp_h, max_height);
+                pix->width = tmp_w;
+                pix->height = tmp_h;
+                ret = v4l2_subdev_call(sd, video, s_fmt, f);
+                dev_geo(dev, "Camera scaled to %ux%u\n",
+                        pix->width, pix->height);
+                if (ret < 0) {
+                        /* This shouldn't happen */
+                        dev_err(dev, "Client failed to set format: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+/**
+ * @rect        - camera cropped rectangle
+ * @sub_rect    - CEU cropped rectangle, mapped back to camera input area
+ * @ceu_rect    - on output calculated CEU crop rectangle
+ */
+static int client_scale(struct soc_camera_device *icd, struct v4l2_rect *rect,
+                        struct v4l2_rect *sub_rect, struct v4l2_rect *ceu_rect,
+                        struct v4l2_format *f, bool ceu_can_scale)
+{
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        struct sh_mobile_ceu_cam *cam = icd->host_priv;
+        struct device *dev = icd->dev.parent;
+        struct v4l2_format f_tmp = *f;
+        struct v4l2_pix_format *pix_tmp = &f_tmp.fmt.pix;
+        unsigned int scale_h, scale_v;
+        int ret;
+
+        /* 5. Apply iterative camera S_FMT for camera user window. */
+        ret = client_s_fmt(icd, &f_tmp, ceu_can_scale);
+        if (ret < 0)
+                return ret;
+
+        dev_geo(dev, "5: camera scaled to %ux%u\n",
+                pix_tmp->width, pix_tmp->height);
+
+        /* 6. Retrieve camera output window (g_fmt) */
+
+        /* unneeded - it is already in "f_tmp" */
+
+        /* 7. Calculate new camera scales. */
+        ret = get_camera_scales(sd, rect, &scale_h, &scale_v);
+        if (ret < 0)
+                return ret;
+
+        dev_geo(dev, "7: camera scales %u:%u\n", scale_h, scale_v);
+
+        cam->cam_width          = pix_tmp->width;
+        cam->cam_height         = pix_tmp->height;
+        f->fmt.pix.width        = pix_tmp->width;
+        f->fmt.pix.height       = pix_tmp->height;
+
+        /*
+         * 8. Calculate new CEU crop - apply camera scales to previously
+         *    calculated "effective" crop.
+         */
+        ceu_rect->left = scale_down(sub_rect->left, scale_h);
+        ceu_rect->width = scale_down(sub_rect->width, scale_h);
+        ceu_rect->top = scale_down(sub_rect->top, scale_v);
+        ceu_rect->height = scale_down(sub_rect->height, scale_v);
+
+        dev_geo(dev, "8: new CEU rect %ux%u@%u:%u\n",
+                ceu_rect->width, ceu_rect->height,
+                ceu_rect->left, ceu_rect->top);
+
+        return 0;
+}
+
+/* Get combined scales */
+static int get_scales(struct soc_camera_device *icd,
+                      unsigned int *scale_h, unsigned int *scale_v)
+{
+        struct sh_mobile_ceu_cam *cam = icd->host_priv;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        struct v4l2_crop cam_crop;
+        unsigned int width_in, height_in;
+        int ret;
+
+        cam_crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        ret = client_g_rect(sd, &cam_crop.c);
+        if (ret < 0)
+                return ret;
+
+        ret = get_camera_scales(sd, &cam_crop.c, scale_h, scale_v);
+        if (ret < 0)
+                return ret;
+
+        width_in = scale_up(cam->ceu_rect.width, *scale_h);
+        height_in = scale_up(cam->ceu_rect.height, *scale_v);
+
+        *scale_h = calc_generic_scale(cam->ceu_rect.width, icd->user_width);
+        *scale_v = calc_generic_scale(cam->ceu_rect.height, icd->user_height);
+
+        return 0;
+}
+
+/*
+ * CEU can scale and crop, but we don't want to waste bandwidth and kill the
+ * framerate by always requesting the maximum image from the client. See
+ * Documentation/video4linux/sh_mobile_camera_ceu.txt for a description of
+ * scaling and cropping algorithms and for the meaning of referenced here steps.
+ */
 static int sh_mobile_ceu_set_crop(struct soc_camera_device *icd,
-                                  struct v4l2_rect *rect)
+                                  struct v4l2_crop *a)
 {
-        return icd->ops->set_crop(icd, rect);
+        struct v4l2_rect *rect = &a->c;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct sh_mobile_ceu_dev *pcdev = ici->priv;
+        struct v4l2_crop cam_crop;
+        struct sh_mobile_ceu_cam *cam = icd->host_priv;
+        struct v4l2_rect *cam_rect = &cam_crop.c, *ceu_rect = &cam->ceu_rect;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        struct device *dev = icd->dev.parent;
+        struct v4l2_format f;
+        struct v4l2_pix_format *pix = &f.fmt.pix;
+        unsigned int scale_comb_h, scale_comb_v, scale_ceu_h, scale_ceu_v,
+                out_width, out_height;
+        u32 capsr, cflcr;
+        int ret;
+
+        /* 1. Calculate current combined scales. */
+        ret = get_scales(icd, &scale_comb_h, &scale_comb_v);
+        if (ret < 0)
+                return ret;
+
+        dev_geo(dev, "1: combined scales %u:%u\n", scale_comb_h, scale_comb_v);
+
+        /* 2. Apply iterative camera S_CROP for new input window. */
+        ret = client_s_crop(sd, a, &cam_crop);
+        if (ret < 0)
+                return ret;
+
+        dev_geo(dev, "2: camera cropped to %ux%u@%u:%u\n",
+                cam_rect->width, cam_rect->height,
+                cam_rect->left, cam_rect->top);
+
+        /* On success cam_crop contains current camera crop */
+
+        /*
+         * 3. If old combined scales applied to new crop produce an impossible
+         *    user window, adjust scales to produce nearest possible window.
+         */
+        out_width       = scale_down(rect->width, scale_comb_h);
+        out_height      = scale_down(rect->height, scale_comb_v);
+
+        if (out_width > 2560)
+                out_width = 2560;
+        else if (out_width < 2)
+                out_width = 2;
+
+        if (out_height > 1920)
+                out_height = 1920;
+        else if (out_height < 4)
+                out_height = 4;
+
+        dev_geo(dev, "3: Adjusted output %ux%u\n", out_width, out_height);
+
+        /* 4. Use G_CROP to retrieve actual input window: already in cam_crop */
+
+        /*
+         * 5. Using actual input window and calculated combined scales calculate
+         *    camera target output window.
+         */
+        pix->width              = scale_down(cam_rect->width, scale_comb_h);
+        pix->height             = scale_down(cam_rect->height, scale_comb_v);
+
+        dev_geo(dev, "5: camera target %ux%u\n", pix->width, pix->height);
+
+        /* 6. - 9. */
+        pix->pixelformat        = cam->camera_fmt->fourcc;
+        pix->colorspace         = cam->camera_fmt->colorspace;
+
+        capsr = capture_save_reset(pcdev);
+        dev_dbg(dev, "CAPSR 0x%x, CFLCR 0x%x\n", capsr, pcdev->cflcr);
+
+        /* Make relative to camera rectangle */
+        rect->left              -= cam_rect->left;
+        rect->top               -= cam_rect->top;
+
+        f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        ret = client_scale(icd, cam_rect, rect, ceu_rect, &f,
+                           pcdev->image_mode && !pcdev->is_interlaced);
+
+        dev_geo(dev, "6-9: %d\n", ret);
+
+        /* 10. Use CEU cropping to crop to the new window. */
+        sh_mobile_ceu_set_rect(icd, out_width, out_height);
+
+        dev_geo(dev, "10: CEU cropped to %ux%u@%u:%u\n",
+                ceu_rect->width, ceu_rect->height,
+                ceu_rect->left, ceu_rect->top);
+
+        /*
+         * 11. Calculate CEU scales from camera scales from results of (10) and
+         *     user window from (3)
+         */
+        scale_ceu_h = calc_scale(ceu_rect->width, &out_width);
+        scale_ceu_v = calc_scale(ceu_rect->height, &out_height);
+
+        dev_geo(dev, "11: CEU scales %u:%u\n", scale_ceu_h, scale_ceu_v);
+
+        /* 12. Apply CEU scales. */
+        cflcr = scale_ceu_h | (scale_ceu_v << 16);
+        if (cflcr != pcdev->cflcr) {
+                pcdev->cflcr = cflcr;
+                ceu_write(pcdev, CFLCR, cflcr);
+        }
+
+        /* Restore capture */
+        if (pcdev->active)
+                capsr |= 1;
+        capture_restore(pcdev, capsr);
+
+        icd->user_width = out_width;
+        icd->user_height = out_height;
+
+        /* Even if only camera cropping succeeded */
+        return ret;
 }
 
+/* Similar to set_crop multistage iterative algorithm */
 static int sh_mobile_ceu_set_fmt(struct soc_camera_device *icd,
                                  struct v4l2_format *f)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct sh_mobile_ceu_dev *pcdev = ici->priv;
-        __u32 pixfmt = f->fmt.pix.pixelformat;
-        const struct soc_camera_format_xlate *xlate;
+        struct sh_mobile_ceu_cam *cam = icd->host_priv;
+        struct v4l2_pix_format *pix = &f->fmt.pix;
         struct v4l2_format cam_f = *f;
+        struct v4l2_pix_format *cam_pix = &cam_f.fmt.pix;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        struct device *dev = icd->dev.parent;
+        __u32 pixfmt = pix->pixelformat;
+        const struct soc_camera_format_xlate *xlate;
+        struct v4l2_crop cam_crop;
+        struct v4l2_rect *cam_rect = &cam_crop.c, cam_subrect, ceu_rect;
+        unsigned int scale_cam_h, scale_cam_v;
+        u16 scale_v, scale_h;
         int ret;
+        bool is_interlaced, image_mode;
+
+        switch (pix->field) {
+        case V4L2_FIELD_INTERLACED:
+                is_interlaced = true;
+                break;
+        case V4L2_FIELD_ANY:
+        default:
+                pix->field = V4L2_FIELD_NONE;
+                /* fall-through */
+        case V4L2_FIELD_NONE:
+                is_interlaced = false;
+                break;
+        }
 
         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
         if (!xlate) {
-                dev_warn(ici->dev, "Format %x not found\n", pixfmt);
+                dev_warn(dev, "Format %x not found\n", pixfmt);
                 return -EINVAL;
         }
 
-        cam_f.fmt.pix.pixelformat = xlate->cam_fmt->fourcc;
-        ret = icd->ops->set_fmt(icd, &cam_f);
+        /* 1. Calculate current camera scales. */
+        cam_crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
-        if (!ret) {
-                icd->buswidth = xlate->buswidth;
-                icd->current_fmt = xlate->host_fmt;
-                pcdev->camera_fmt = xlate->cam_fmt;
+        ret = client_g_rect(sd, cam_rect);
+        if (ret < 0)
+                return ret;
+
+        ret = get_camera_scales(sd, cam_rect, &scale_cam_h, &scale_cam_v);
+        if (ret < 0)
+                return ret;
+
+        dev_geo(dev, "1: camera scales %u:%u\n", scale_cam_h, scale_cam_v);
+
+        /*
+         * 2. Calculate "effective" input crop (sensor subwindow) - CEU crop
+         *    scaled back at current camera scales onto input window.
+         */
+        ret = get_camera_subwin(icd, &cam_subrect, scale_cam_h, scale_cam_v);
+        if (ret < 0)
+                return ret;
+
+        dev_geo(dev, "2: subwin %ux%u@%u:%u\n",
+                cam_subrect.width, cam_subrect.height,
+                cam_subrect.left, cam_subrect.top);
+
+        /*
+         * 3. Calculate new combined scales from "effective" input window to
+         *    requested user window.
+         */
+        scale_h = calc_generic_scale(cam_subrect.width, pix->width);
+        scale_v = calc_generic_scale(cam_subrect.height, pix->height);
+
+        dev_geo(dev, "3: scales %u:%u\n", scale_h, scale_v);
+
+        /*
+         * 4. Calculate camera output window by applying combined scales to real
+         *    input window.
+         */
+        cam_pix->width = scale_down(cam_rect->width, scale_h);
+        cam_pix->height = scale_down(cam_rect->height, scale_v);
+        cam_pix->pixelformat = xlate->cam_fmt->fourcc;
+
+        switch (pixfmt) {
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV21:
+        case V4L2_PIX_FMT_NV16:
+        case V4L2_PIX_FMT_NV61:
+                image_mode = true;
+                break;
+        default:
+                image_mode = false;
         }
 
-        return ret;
+        dev_geo(dev, "4: camera output %ux%u\n",
+                cam_pix->width, cam_pix->height);
+
+        /* 5. - 9. */
+        ret = client_scale(icd, cam_rect, &cam_subrect, &ceu_rect, &cam_f,
+                           image_mode && !is_interlaced);
+
+        dev_geo(dev, "5-9: client scale %d\n", ret);
+
+        /* Done with the camera. Now see if we can improve the result */
+
+        dev_dbg(dev, "Camera %d fmt %ux%u, requested %ux%u\n",
+                ret, cam_pix->width, cam_pix->height, pix->width, pix->height);
+        if (ret < 0)
+                return ret;
+
+        /* 10. Use CEU scaling to scale to the requested user window. */
+
+        /* We cannot scale up */
+        if (pix->width > cam_pix->width)
+                pix->width = cam_pix->width;
+        if (pix->width > ceu_rect.width)
+                pix->width = ceu_rect.width;
+
+        if (pix->height > cam_pix->height)
+                pix->height = cam_pix->height;
+        if (pix->height > ceu_rect.height)
+                pix->height = ceu_rect.height;
+
+        /* Let's rock: scale pix->{width x height} down to width x height */
+        scale_h = calc_scale(ceu_rect.width, &pix->width);
+        scale_v = calc_scale(ceu_rect.height, &pix->height);
+
+        dev_geo(dev, "10: W: %u : 0x%x = %u, H: %u : 0x%x = %u\n",
+                ceu_rect.width, scale_h, pix->width,
+                ceu_rect.height, scale_v, pix->height);
+
+        pcdev->cflcr = scale_h | (scale_v << 16);
+
+        icd->buswidth = xlate->buswidth;
+        icd->current_fmt = xlate->host_fmt;
+        cam->camera_fmt = xlate->cam_fmt;
+        cam->ceu_rect = ceu_rect;
+
+        pcdev->is_interlaced = is_interlaced;
+        pcdev->image_mode = image_mode;
+
+        return 0;
 }
 
 static int sh_mobile_ceu_try_fmt(struct soc_camera_device *icd,
                                  struct v4l2_format *f)
 {
-        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
-        struct sh_mobile_ceu_dev *pcdev = ici->priv;
         const struct soc_camera_format_xlate *xlate;
-        __u32 pixfmt = f->fmt.pix.pixelformat;
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        __u32 pixfmt = pix->pixelformat;
+        int width, height;
         int ret;
 
         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
         if (!xlate) {
-                dev_warn(ici->dev, "Format %x not found\n", pixfmt);
+                dev_warn(icd->dev.parent, "Format %x not found\n", pixfmt);
                 return -EINVAL;
         }
 
         /* FIXME: calculate using depth and bus width */
 
-        v4l_bound_align_image(&f->fmt.pix.width, 2, 2560, 1,
-                              &f->fmt.pix.height, 4, 1920, 2, 0);
+        v4l_bound_align_image(&pix->width, 2, 2560, 1,
+                              &pix->height, 4, 1920, 2, 0);
+
+        width = pix->width;
+        height = pix->height;
 
-        f->fmt.pix.bytesperline = f->fmt.pix.width *
+        pix->bytesperline = pix->width *
                 DIV_ROUND_UP(xlate->host_fmt->depth, 8);
-        f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
+        pix->sizeimage = pix->height * pix->bytesperline;
+
+        pix->pixelformat = xlate->cam_fmt->fourcc;
 
         /* limit to sensor capabilities */
-        ret = icd->ops->try_fmt(icd, f);
+        ret = v4l2_subdev_call(sd, video, try_fmt, f);
+        pix->pixelformat = pixfmt;
         if (ret < 0)
                 return ret;
 
-        switch (f->fmt.pix.field) {
-        case V4L2_FIELD_INTERLACED:
-                pcdev->is_interlaced = 1;
-                break;
-        case V4L2_FIELD_ANY:
-                f->fmt.pix.field = V4L2_FIELD_NONE;
-                /* fall-through */
-        case V4L2_FIELD_NONE:
-                pcdev->is_interlaced = 0;
-                break;
-        default:
-                ret = -EINVAL;
-                break;
+        switch (pixfmt) {
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV21:
+        case V4L2_PIX_FMT_NV16:
+        case V4L2_PIX_FMT_NV61:
+                /* FIXME: check against rect_max after converting soc-camera */
+                /* We can scale precisely, need a bigger image from camera */
+                if (pix->width < width || pix->height < height) {
+                        int tmp_w = pix->width, tmp_h = pix->height;
+                        pix->width = 2560;
+                        pix->height = 1920;
+                        ret = v4l2_subdev_call(sd, video, try_fmt, f);
+                        if (ret < 0) {
+                                /* Shouldn't actually happen... */
+                                dev_err(icd->dev.parent,
+                                        "FIXME: try_fmt() returned %d\n", ret);
+                                pix->width = tmp_w;
+                                pix->height = tmp_h;
+                        }
+                }
+                if (pix->width > width)
+                        pix->width = width;
+                if (pix->height > height)
+                        pix->height = height;
         }
 
         return ret;
@@ -769,7 +1566,7 @@ static void sh_mobile_ceu_init_videobuf(struct videobuf_queue *q,
 
         videobuf_queue_dma_contig_init(q,
                                        &sh_mobile_ceu_videobuf_ops,
-                                       ici->dev, &pcdev->lock,
+                                       icd->dev.parent, &pcdev->lock,
                                        V4L2_BUF_TYPE_VIDEO_CAPTURE,
                                        pcdev->is_interlaced ?
                                        V4L2_FIELD_INTERLACED : V4L2_FIELD_NONE,
@@ -777,22 +1574,76 @@ static void sh_mobile_ceu_init_videobuf(struct videobuf_queue *q,
                                        icd);
 }
 
+static int sh_mobile_ceu_get_ctrl(struct soc_camera_device *icd,
+                                  struct v4l2_control *ctrl)
+{
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct sh_mobile_ceu_dev *pcdev = ici->priv;
+        u32 val;
+
+        switch (ctrl->id) {
+        case V4L2_CID_SHARPNESS:
+                val = ceu_read(pcdev, CLFCR);
+                ctrl->value = val ^ 1;
+                return 0;
+        }
+        return -ENOIOCTLCMD;
+}
+
+static int sh_mobile_ceu_set_ctrl(struct soc_camera_device *icd,
+                                  struct v4l2_control *ctrl)
+{
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct sh_mobile_ceu_dev *pcdev = ici->priv;
+
+        switch (ctrl->id) {
+        case V4L2_CID_SHARPNESS:
+                switch (icd->current_fmt->fourcc) {
+                case V4L2_PIX_FMT_NV12:
+                case V4L2_PIX_FMT_NV21:
+                case V4L2_PIX_FMT_NV16:
+                case V4L2_PIX_FMT_NV61:
+                        ceu_write(pcdev, CLFCR, !ctrl->value);
+                        return 0;
+                }
+                return -EINVAL;
+        }
+        return -ENOIOCTLCMD;
+}
+
+static const struct v4l2_queryctrl sh_mobile_ceu_controls[] = {
+        {
+                .id             = V4L2_CID_SHARPNESS,
+                .type           = V4L2_CTRL_TYPE_BOOLEAN,
+                .name           = "Low-pass filter",
+                .minimum        = 0,
+                .maximum        = 1,
+                .step           = 1,
+                .default_value  = 0,
+        },
+};
+
 static struct soc_camera_host_ops sh_mobile_ceu_host_ops = {
         .owner          = THIS_MODULE,
         .add            = sh_mobile_ceu_add_device,
         .remove         = sh_mobile_ceu_remove_device,
         .get_formats    = sh_mobile_ceu_get_formats,
+        .put_formats    = sh_mobile_ceu_put_formats,
         .set_crop       = sh_mobile_ceu_set_crop,
         .set_fmt        = sh_mobile_ceu_set_fmt,
         .try_fmt        = sh_mobile_ceu_try_fmt,
+        .set_ctrl       = sh_mobile_ceu_set_ctrl,
+        .get_ctrl       = sh_mobile_ceu_get_ctrl,
         .reqbufs        = sh_mobile_ceu_reqbufs,
         .poll           = sh_mobile_ceu_poll,
         .querycap       = sh_mobile_ceu_querycap,
         .set_bus_param  = sh_mobile_ceu_set_bus_param,
         .init_videobuf  = sh_mobile_ceu_init_videobuf,
+        .controls       = sh_mobile_ceu_controls,
+        .num_controls   = ARRAY_SIZE(sh_mobile_ceu_controls),
 };
 
-static int sh_mobile_ceu_probe(struct platform_device *pdev)
+static int __devinit sh_mobile_ceu_probe(struct platform_device *pdev)
 {
         struct sh_mobile_ceu_dev *pcdev;
         struct resource *res;
@@ -865,7 +1716,7 @@ static int sh_mobile_ceu_probe(struct platform_device *pdev)
         pm_runtime_resume(&pdev->dev);
 
         pcdev->ici.priv = pcdev;
-        pcdev->ici.dev = &pdev->dev;
+        pcdev->ici.v4l2_dev.dev = &pdev->dev;
         pcdev->ici.nr = pdev->id;
         pcdev->ici.drv_name = dev_name(&pdev->dev);
         pcdev->ici.ops = &sh_mobile_ceu_host_ops;
@@ -889,7 +1740,7 @@ exit:
         return err;
 }
 
-static int sh_mobile_ceu_remove(struct platform_device *pdev)
+static int __devexit sh_mobile_ceu_remove(struct platform_device *pdev)
 {
         struct soc_camera_host *soc_host = to_soc_camera_host(&pdev->dev);
         struct sh_mobile_ceu_dev *pcdev = container_of(soc_host,
@@ -927,7 +1778,7 @@ static struct platform_driver sh_mobile_ceu_driver = {
                 .pm     = &sh_mobile_ceu_dev_pm_ops,
         },
         .probe          = sh_mobile_ceu_probe,
-        .remove         = sh_mobile_ceu_remove,
+        .remove         = __exit_p(sh_mobile_ceu_remove),
 };
 
 static int __init sh_mobile_ceu_init(void)
@@ -946,3 +1797,4 @@ module_exit(sh_mobile_ceu_exit);
 MODULE_DESCRIPTION("SuperH Mobile CEU driver");
 MODULE_AUTHOR("Magnus Damm");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:sh_mobile_ceu");
diff --git a/drivers/media/video/sn9c102/sn9c102_core.c b/drivers/media/video/sn9c102/sn9c102_core.c
index 23edfdc4d4bc..9d84c94e8a40 100644
--- a/drivers/media/video/sn9c102/sn9c102_core.c
+++ b/drivers/media/video/sn9c102/sn9c102_core.c
@@ -1954,8 +1954,10 @@ sn9c102_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
                                     (!list_empty(&cam->outqueue)) ||
                                     (cam->state & DEV_DISCONNECTED) ||
                                     (cam->state & DEV_MISCONFIGURED),
-                                    cam->module_param.frame_timeout *
-                                    1000 * msecs_to_jiffies(1) );
+                                    msecs_to_jiffies(
+                                        cam->module_param.frame_timeout * 1000
+                                    )
+                                  );
                         if (timeout < 0) {
                                 mutex_unlock(&cam->fileop_mutex);
                                 return timeout;
diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
index 9f5ae8167855..59aa7a3694c2 100644
--- a/drivers/media/video/soc_camera.c
+++ b/drivers/media/video/soc_camera.c
@@ -21,15 +21,15 @@
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/list.h>
-#include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/vmalloc.h>
 
 #include <media/soc_camera.h>
 #include <media/v4l2-common.h>
-#include <media/v4l2-dev.h>
 #include <media/v4l2-ioctl.h>
+#include <media/v4l2-dev.h>
 #include <media/videobuf-core.h>
 
 /* Default to VGA resolution */
@@ -38,7 +38,7 @@
 
 static LIST_HEAD(hosts);
 static LIST_HEAD(devices);
-static DEFINE_MUTEX(list_lock);
+static DEFINE_MUTEX(list_lock);         /* Protects the list of hosts */
 
 const struct soc_camera_data_format *soc_camera_format_by_fourcc(
         struct soc_camera_device *icd, unsigned int fourcc)
@@ -152,12 +152,9 @@ static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id *a)
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
-        int ret = 0;
-
-        if (icd->ops->set_std)
-                ret = icd->ops->set_std(icd, a);
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
 
-        return ret;
+        return v4l2_subdev_call(sd, core, s_std, *a);
 }
 
 static int soc_camera_reqbufs(struct file *file, void *priv,
@@ -170,8 +167,6 @@ static int soc_camera_reqbufs(struct file *file, void *priv,
 
         WARN_ON(priv != file->private_data);
 
-        dev_dbg(&icd->dev, "%s: %d\n", __func__, p->memory);
-
         ret = videobuf_reqbufs(&icf->vb_vidq, p);
         if (ret < 0)
                 return ret;
@@ -209,10 +204,11 @@ static int soc_camera_dqbuf(struct file *file, void *priv,
         return videobuf_dqbuf(&icf->vb_vidq, p, file->f_flags & O_NONBLOCK);
 }
 
+/* Always entered with .video_lock held */
 static int soc_camera_init_user_formats(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
-        int i, fmts = 0;
+        int i, fmts = 0, ret;
 
         if (!ici->ops->get_formats)
                 /*
@@ -225,8 +221,12 @@ static int soc_camera_init_user_formats(struct soc_camera_device *icd)
                  * First pass - only count formats this host-sensor
                  * configuration can provide
                  */
-                for (i = 0; i < icd->num_formats; i++)
-                        fmts += ici->ops->get_formats(icd, i, NULL);
+                for (i = 0; i < icd->num_formats; i++) {
+                        ret = ici->ops->get_formats(icd, i, NULL);
+                        if (ret < 0)
+                                return ret;
+                        fmts += ret;
+                }
 
         if (!fmts)
                 return -ENXIO;
@@ -248,20 +248,39 @@ static int soc_camera_init_user_formats(struct soc_camera_device *icd)
                         icd->user_formats[i].cam_fmt = icd->formats + i;
                         icd->user_formats[i].buswidth = icd->formats[i].depth;
                 } else {
-                        fmts += ici->ops->get_formats(icd, i,
-                                                      &icd->user_formats[fmts]);
+                        ret = ici->ops->get_formats(icd, i,
+                                                    &icd->user_formats[fmts]);
+                        if (ret < 0)
+                                goto egfmt;
+                        fmts += ret;
                 }
 
         icd->current_fmt = icd->user_formats[0].host_fmt;
 
         return 0;
+
+egfmt:
+        icd->num_user_formats = 0;
+        vfree(icd->user_formats);
+        return ret;
 }
 
+/* Always entered with .video_lock held */
 static void soc_camera_free_user_formats(struct soc_camera_device *icd)
 {
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+
+        if (ici->ops->put_formats)
+                ici->ops->put_formats(icd);
+        icd->current_fmt = NULL;
+        icd->num_user_formats = 0;
         vfree(icd->user_formats);
+        icd->user_formats = NULL;
 }
 
+#define pixfmtstr(x) (x) & 0xff, ((x) >> 8) & 0xff, ((x) >> 16) & 0xff, \
+        ((x) >> 24) & 0xff
+
 /* Called with .vb_lock held */
 static int soc_camera_set_fmt(struct soc_camera_file *icf,
                               struct v4l2_format *f)
@@ -271,6 +290,9 @@ static int soc_camera_set_fmt(struct soc_camera_file *icf,
         struct v4l2_pix_format *pix = &f->fmt.pix;
         int ret;
 
+        dev_dbg(&icd->dev, "S_FMT(%c%c%c%c, %ux%u)\n",
+                pixfmtstr(pix->pixelformat), pix->width, pix->height);
+
         /* We always call try_fmt() before set_fmt() or set_crop() */
         ret = ici->ops->try_fmt(icd, f);
         if (ret < 0)
@@ -281,13 +303,13 @@ static int soc_camera_set_fmt(struct soc_camera_file *icf,
                 return ret;
         } else if (!icd->current_fmt ||
                    icd->current_fmt->fourcc != pix->pixelformat) {
-                dev_err(ici->dev,
+                dev_err(&icd->dev,
                         "Host driver hasn't set up current format correctly!\n");
                 return -EINVAL;
         }
 
-        icd->width              = pix->width;
-        icd->height             = pix->height;
+        icd->user_width         = pix->width;
+        icd->user_height        = pix->height;
         icf->vb_vidq.field      =
                 icd->field      = pix->field;
 
@@ -296,7 +318,7 @@ static int soc_camera_set_fmt(struct soc_camera_file *icf,
                          f->type);
 
         dev_dbg(&icd->dev, "set width: %d height: %d\n",
-                icd->width, icd->height);
+                icd->user_width, icd->user_height);
 
         /* set physical bus parameters */
         return ici->ops->set_bus_param(icd, pix->pixelformat);
@@ -304,30 +326,24 @@ static int soc_camera_set_fmt(struct soc_camera_file *icf,
 
 static int soc_camera_open(struct file *file)
 {
-        struct video_device *vdev;
-        struct soc_camera_device *icd;
+        struct video_device *vdev = video_devdata(file);
+        struct soc_camera_device *icd = container_of(vdev->parent,
+                                                     struct soc_camera_device,
+                                                     dev);
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         struct soc_camera_host *ici;
         struct soc_camera_file *icf;
         int ret;
 
-        icf = vmalloc(sizeof(*icf));
-        if (!icf)
-                return -ENOMEM;
-
-        /*
-         * It is safe to dereference these pointers now as long as a user has
-         * the video device open - we are protected by the held cdev reference.
-         */
+        if (!icd->ops)
+                /* No device driver attached */
+                return -ENODEV;
 
-        vdev = video_devdata(file);
-        icd = container_of(vdev->parent, struct soc_camera_device, dev);
         ici = to_soc_camera_host(icd->dev.parent);
 
-        if (!try_module_get(icd->ops->owner)) {
-                dev_err(&icd->dev, "Couldn't lock sensor driver.\n");
-                ret = -EINVAL;
-                goto emgd;
-        }
+        icf = vmalloc(sizeof(*icf));
+        if (!icf)
+                return -ENOMEM;
 
         if (!try_module_get(ici->ops->owner)) {
                 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
@@ -335,7 +351,10 @@ static int soc_camera_open(struct file *file)
                 goto emgi;
         }
 
-        /* Protect against icd->remove() until we module_get() both drivers. */
+        /*
+         * Protect against icd->ops->remove() until we module_get() both
+         * drivers.
+         */
         mutex_lock(&icd->video_lock);
 
         icf->icd = icd;
@@ -347,14 +366,24 @@ static int soc_camera_open(struct file *file)
                 struct v4l2_format f = {
                         .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
                         .fmt.pix = {
-                                .width          = icd->width,
-                                .height         = icd->height,
+                                .width          = icd->user_width,
+                                .height         = icd->user_height,
                                 .field          = icd->field,
                                 .pixelformat    = icd->current_fmt->fourcc,
                                 .colorspace     = icd->current_fmt->colorspace,
                         },
                 };
 
+                if (icl->power) {
+                        ret = icl->power(icd->pdev, 1);
+                        if (ret < 0)
+                                goto epower;
+                }
+
+                /* The camera could have been already on, try to reset */
+                if (icl->reset)
+                        icl->reset(icd->pdev);
+
                 ret = ici->ops->add(icd);
                 if (ret < 0) {
                         dev_err(&icd->dev, "Couldn't activate the camera: %d\n", ret);
@@ -367,28 +396,29 @@ static int soc_camera_open(struct file *file)
                         goto esfmt;
         }
 
-        mutex_unlock(&icd->video_lock);
-
         file->private_data = icf;
         dev_dbg(&icd->dev, "camera device open\n");
 
         ici->ops->init_videobuf(&icf->vb_vidq, icd);
 
+        mutex_unlock(&icd->video_lock);
+
         return 0;
 
         /*
-         * First three errors are entered with the .video_lock held
+         * First five errors are entered with the .video_lock held
          * and use_count == 1
          */
 esfmt:
         ici->ops->remove(icd);
 eiciadd:
+        if (icl->power)
+                icl->power(icd->pdev, 0);
+epower:
         icd->use_count--;
         mutex_unlock(&icd->video_lock);
         module_put(ici->ops->owner);
 emgi:
-        module_put(icd->ops->owner);
-emgd:
         vfree(icf);
         return ret;
 }
@@ -398,21 +428,24 @@ static int soc_camera_close(struct file *file)
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
-        struct video_device *vdev = icd->vdev;
 
         mutex_lock(&icd->video_lock);
         icd->use_count--;
-        if (!icd->use_count)
+        if (!icd->use_count) {
+                struct soc_camera_link *icl = to_soc_camera_link(icd);
+
                 ici->ops->remove(icd);
+                if (icl->power)
+                        icl->power(icd->pdev, 0);
+        }
 
         mutex_unlock(&icd->video_lock);
 
-        module_put(icd->ops->owner);
         module_put(ici->ops->owner);
 
         vfree(icf);
 
-        dev_dbg(vdev->parent, "camera device close\n");
+        dev_dbg(&icd->dev, "camera device close\n");
 
         return 0;
 }
@@ -422,10 +455,9 @@ static ssize_t soc_camera_read(struct file *file, char __user *buf,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
-        struct video_device *vdev = icd->vdev;
         int err = -EINVAL;
 
-        dev_err(vdev->parent, "camera device read not implemented\n");
+        dev_err(&icd->dev, "camera device read not implemented\n");
 
         return err;
 }
@@ -483,8 +515,8 @@ static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
 
         mutex_lock(&icf->vb_vidq.vb_lock);
 
-        if (videobuf_queue_is_busy(&icf->vb_vidq)) {
-                dev_err(&icd->dev, "S_FMT denied: queue busy\n");
+        if (icf->vb_vidq.bufs[0]) {
+                dev_err(&icd->dev, "S_FMT denied: queue initialised\n");
                 ret = -EBUSY;
                 goto unlock;
         }
@@ -525,8 +557,8 @@ static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv,
 
         WARN_ON(priv != file->private_data);
 
-        pix->width              = icd->width;
-        pix->height             = icd->height;
+        pix->width              = icd->user_width;
+        pix->height             = icd->user_height;
         pix->field              = icf->vb_vidq.field;
         pix->pixelformat        = icd->current_fmt->fourcc;
         pix->bytesperline       = pix->width *
@@ -555,18 +587,17 @@ static int soc_camera_streamon(struct file *file, void *priv,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         int ret;
 
         WARN_ON(priv != file->private_data);
 
-        dev_dbg(&icd->dev, "%s\n", __func__);
-
         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
 
         mutex_lock(&icd->video_lock);
 
-        icd->ops->start_capture(icd);
+        v4l2_subdev_call(sd, video, s_stream, 1);
 
         /* This calls buf_queue from host driver's videobuf_queue_ops */
         ret = videobuf_streamon(&icf->vb_vidq);
@@ -581,11 +612,10 @@ static int soc_camera_streamoff(struct file *file, void *priv,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
 
         WARN_ON(priv != file->private_data);
 
-        dev_dbg(&icd->dev, "%s\n", __func__);
-
         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
 
@@ -595,7 +625,7 @@ static int soc_camera_streamoff(struct file *file, void *priv,
          * remaining buffers. When the last buffer is freed, stop capture */
         videobuf_streamoff(&icf->vb_vidq);
 
-        icd->ops->stop_capture(icd);
+        v4l2_subdev_call(sd, video, s_stream, 0);
 
         mutex_unlock(&icd->video_lock);
 
@@ -607,6 +637,7 @@ static int soc_camera_queryctrl(struct file *file, void *priv,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         int i;
 
         WARN_ON(priv != file->private_data);
@@ -614,6 +645,15 @@ static int soc_camera_queryctrl(struct file *file, void *priv,
         if (!qc->id)
                 return -EINVAL;
 
+        /* First check host controls */
+        for (i = 0; i < ici->ops->num_controls; i++)
+                if (qc->id == ici->ops->controls[i].id) {
+                        memcpy(qc, &(ici->ops->controls[i]),
+                                sizeof(*qc));
+                        return 0;
+                }
+
+        /* Then device controls */
         for (i = 0; i < icd->ops->num_controls; i++)
                 if (qc->id == icd->ops->controls[i].id) {
                         memcpy(qc, &(icd->ops->controls[i]),
@@ -629,25 +669,19 @@ static int soc_camera_g_ctrl(struct file *file, void *priv,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        int ret;
 
         WARN_ON(priv != file->private_data);
 
-        switch (ctrl->id) {
-        case V4L2_CID_GAIN:
-                if (icd->gain == (unsigned short)~0)
-                        return -EINVAL;
-                ctrl->value = icd->gain;
-                return 0;
-        case V4L2_CID_EXPOSURE:
-                if (icd->exposure == (unsigned short)~0)
-                        return -EINVAL;
-                ctrl->value = icd->exposure;
-                return 0;
+        if (ici->ops->get_ctrl) {
+                ret = ici->ops->get_ctrl(icd, ctrl);
+                if (ret != -ENOIOCTLCMD)
+                        return ret;
         }
 
-        if (icd->ops->get_control)
-                return icd->ops->get_control(icd, ctrl);
-        return -EINVAL;
+        return v4l2_subdev_call(sd, core, g_ctrl, ctrl);
 }
 
 static int soc_camera_s_ctrl(struct file *file, void *priv,
@@ -655,12 +689,19 @@ static int soc_camera_s_ctrl(struct file *file, void *priv,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        int ret;
 
         WARN_ON(priv != file->private_data);
 
-        if (icd->ops->set_control)
-                return icd->ops->set_control(icd, ctrl);
-        return -EINVAL;
+        if (ici->ops->set_ctrl) {
+                ret = ici->ops->set_ctrl(icd, ctrl);
+                if (ret != -ENOIOCTLCMD)
+                        return ret;
+        }
+
+        return v4l2_subdev_call(sd, core, s_ctrl, ctrl);
 }
 
 static int soc_camera_cropcap(struct file *file, void *fh,
@@ -668,20 +709,9 @@ static int soc_camera_cropcap(struct file *file, void *fh,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
-        a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-        a->bounds.left                  = icd->x_min;
-        a->bounds.top                   = icd->y_min;
-        a->bounds.width                 = icd->width_max;
-        a->bounds.height                = icd->height_max;
-        a->defrect.left                 = icd->x_min;
-        a->defrect.top                  = icd->y_min;
-        a->defrect.width                = DEFAULT_WIDTH;
-        a->defrect.height               = DEFAULT_HEIGHT;
-        a->pixelaspect.numerator        = 1;
-        a->pixelaspect.denominator      = 1;
-
-        return 0;
+        return ici->ops->cropcap(icd, a);
 }
 
 static int soc_camera_g_crop(struct file *file, void *fh,
@@ -689,36 +719,53 @@ static int soc_camera_g_crop(struct file *file, void *fh,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        int ret;
 
-        a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-        a->c.left       = icd->x_current;
-        a->c.top        = icd->y_current;
-        a->c.width      = icd->width;
-        a->c.height     = icd->height;
+        mutex_lock(&icf->vb_vidq.vb_lock);
+        ret = ici->ops->get_crop(icd, a);
+        mutex_unlock(&icf->vb_vidq.vb_lock);
 
-        return 0;
+        return ret;
 }
 
+/*
+ * According to the V4L2 API, drivers shall not update the struct v4l2_crop
+ * argument with the actual geometry, instead, the user shall use G_CROP to
+ * retrieve it. However, we expect camera host and client drivers to update
+ * the argument, which we then use internally, but do not return to the user.
+ */
 static int soc_camera_s_crop(struct file *file, void *fh,
                              struct v4l2_crop *a)
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct v4l2_rect *rect = &a->c;
+        struct v4l2_crop current_crop;
         int ret;
 
         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
 
+        dev_dbg(&icd->dev, "S_CROP(%ux%u@%u:%u)\n",
+                rect->width, rect->height, rect->left, rect->top);
+
         /* Cropping is allowed during a running capture, guard consistency */
         mutex_lock(&icf->vb_vidq.vb_lock);
 
-        ret = ici->ops->set_crop(icd, &a->c);
-        if (!ret) {
-                icd->width      = a->c.width;
-                icd->height     = a->c.height;
-                icd->x_current  = a->c.left;
-                icd->y_current  = a->c.top;
+        /* If get_crop fails, we'll let host and / or client drivers decide */
+        ret = ici->ops->get_crop(icd, &current_crop);
+
+        /* Prohibit window size change with initialised buffers */
+        if (icf->vb_vidq.bufs[0] && !ret &&
+            (a->c.width != current_crop.c.width ||
+             a->c.height != current_crop.c.height)) {
+                dev_err(&icd->dev,
+                        "S_CROP denied: queue initialised and sizes differ\n");
+                ret = -EBUSY;
+        } else {
+                ret = ici->ops->set_crop(icd, a);
         }
 
         mutex_unlock(&icf->vb_vidq.vb_lock);
@@ -731,11 +778,9 @@ static int soc_camera_g_chip_ident(struct file *file, void *fh,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
 
-        if (!icd->ops->get_chip_id)
-                return -EINVAL;
-
-        return icd->ops->get_chip_id(icd, id);
+        return v4l2_subdev_call(sd, core, g_chip_ident, id);
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
@@ -744,11 +789,9 @@ static int soc_camera_g_register(struct file *file, void *fh,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
 
-        if (!icd->ops->get_register)
-                return -EINVAL;
-
-        return icd->ops->get_register(icd, reg);
+        return v4l2_subdev_call(sd, core, g_register, reg);
 }
 
 static int soc_camera_s_register(struct file *file, void *fh,
@@ -756,37 +799,12 @@ static int soc_camera_s_register(struct file *file, void *fh,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
 
-        if (!icd->ops->set_register)
-                return -EINVAL;
-
-        return icd->ops->set_register(icd, reg);
+        return v4l2_subdev_call(sd, core, s_register, reg);
 }
 #endif
 
-static int device_register_link(struct soc_camera_device *icd)
-{
-        int ret = dev_set_name(&icd->dev, "%u-%u", icd->iface, icd->devnum);
-
-        if (!ret)
-                ret = device_register(&icd->dev);
-
-        if (ret < 0) {
-                /* Prevent calling device_unregister() */
-                icd->dev.parent = NULL;
-                dev_err(&icd->dev, "Cannot register device: %d\n", ret);
-        /* Even if probe() was unsuccessful for all registered drivers,
-         * device_register() returns 0, and we add the link, just to
-         * document this camera's control device */
-        } else if (icd->control)
-                /* Have to sysfs_remove_link() before device_unregister()? */
-                if (sysfs_create_link(&icd->dev.kobj, &icd->control->kobj,
-                                      "control"))
-                        dev_warn(&icd->dev,
-                                 "Failed creating the control symlink\n");
-        return ret;
-}
-
 /* So far this function cannot fail */
 static void scan_add_host(struct soc_camera_host *ici)
 {
@@ -796,106 +814,193 @@ static void scan_add_host(struct soc_camera_host *ici)
 
         list_for_each_entry(icd, &devices, list) {
                 if (icd->iface == ici->nr) {
-                        icd->dev.parent = ici->dev;
-                        device_register_link(icd);
+                        int ret;
+                        icd->dev.parent = ici->v4l2_dev.dev;
+                        dev_set_name(&icd->dev, "%u-%u", icd->iface,
+                                     icd->devnum);
+                        ret = device_register(&icd->dev);
+                        if (ret < 0) {
+                                icd->dev.parent = NULL;
+                                dev_err(&icd->dev,
+                                        "Cannot register device: %d\n", ret);
+                        }
                 }
         }
 
         mutex_unlock(&list_lock);
 }
 
-/* return: 0 if no match found or a match found and
- * device_register() successful, error code otherwise */
-static int scan_add_device(struct soc_camera_device *icd)
+#ifdef CONFIG_I2C_BOARDINFO
+static int soc_camera_init_i2c(struct soc_camera_device *icd,
+                               struct soc_camera_link *icl)
 {
-        struct soc_camera_host *ici;
-        int ret = 0;
+        struct i2c_client *client;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct i2c_adapter *adap = i2c_get_adapter(icl->i2c_adapter_id);
+        struct v4l2_subdev *subdev;
+        int ret;
 
-        mutex_lock(&list_lock);
+        if (!adap) {
+                ret = -ENODEV;
+                dev_err(&icd->dev, "Cannot get I2C adapter #%d. No driver?\n",
+                        icl->i2c_adapter_id);
+                goto ei2cga;
+        }
 
-        list_add_tail(&icd->list, &devices);
+        icl->board_info->platform_data = icd;
 
-        /* Watch out for class_for_each_device / class_find_device API by
-         * Dave Young <hidave.darkstar@gmail.com> */
-        list_for_each_entry(ici, &hosts, list) {
-                if (icd->iface == ici->nr) {
-                        ret = 1;
-                        icd->dev.parent = ici->dev;
-                        break;
-                }
+        subdev = v4l2_i2c_new_subdev_board(&ici->v4l2_dev, adap,
+                                icl->module_name, icl->board_info, NULL);
+        if (!subdev) {
+                ret = -ENOMEM;
+                goto ei2cnd;
         }
 
-        mutex_unlock(&list_lock);
+        client = subdev->priv;
 
-        if (ret)
-                ret = device_register_link(icd);
+        /* Use to_i2c_client(dev) to recover the i2c client */
+        dev_set_drvdata(&icd->dev, &client->dev);
 
+        return 0;
+ei2cnd:
+        i2c_put_adapter(adap);
+ei2cga:
         return ret;
 }
 
+static void soc_camera_free_i2c(struct soc_camera_device *icd)
+{
+        struct i2c_client *client =
+                to_i2c_client(to_soc_camera_control(icd));
+        dev_set_drvdata(&icd->dev, NULL);
+        v4l2_device_unregister_subdev(i2c_get_clientdata(client));
+        i2c_unregister_device(client);
+        i2c_put_adapter(client->adapter);
+}
+#else
+#define soc_camera_init_i2c(icd, icl)   (-ENODEV)
+#define soc_camera_free_i2c(icd)        do {} while (0)
+#endif
+
+static int soc_camera_video_start(struct soc_camera_device *icd);
+static int video_dev_create(struct soc_camera_device *icd);
+/* Called during host-driver probe */
 static int soc_camera_probe(struct device *dev)
 {
         struct soc_camera_device *icd = to_soc_camera_dev(dev);
-        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        struct soc_camera_host *ici = to_soc_camera_host(dev->parent);
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
+        struct device *control = NULL;
+        struct v4l2_subdev *sd;
+        struct v4l2_format f = {.type = V4L2_BUF_TYPE_VIDEO_CAPTURE};
         int ret;
 
-        /*
-         * Possible race scenario:
-         * modprobe <camera-host-driver> triggers __func__
-         * at this moment respective <camera-sensor-driver> gets rmmod'ed
-         * to protect take module references.
-         */
+        dev_info(dev, "Probing %s\n", dev_name(dev));
 
-        if (!try_module_get(icd->ops->owner)) {
-                dev_err(&icd->dev, "Couldn't lock sensor driver.\n");
-                ret = -EINVAL;
-                goto emgd;
+        if (icl->power) {
+                ret = icl->power(icd->pdev, 1);
+                if (ret < 0) {
+                        dev_err(dev,
+                                "Platform failed to power-on the camera.\n");
+                        goto epower;
+                }
         }
 
-        if (!try_module_get(ici->ops->owner)) {
-                dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
+        /* The camera could have been already on, try to reset */
+        if (icl->reset)
+                icl->reset(icd->pdev);
+
+        ret = ici->ops->add(icd);
+        if (ret < 0)
+                goto eadd;
+
+        /* Must have icd->vdev before registering the device */
+        ret = video_dev_create(icd);
+        if (ret < 0)
+                goto evdc;
+
+        /* Non-i2c cameras, e.g., soc_camera_platform, have no board_info */
+        if (icl->board_info) {
+                ret = soc_camera_init_i2c(icd, icl);
+                if (ret < 0)
+                        goto eadddev;
+        } else if (!icl->add_device || !icl->del_device) {
                 ret = -EINVAL;
-                goto emgi;
+                goto eadddev;
+        } else {
+                if (icl->module_name)
+                        ret = request_module(icl->module_name);
+
+                ret = icl->add_device(icl, &icd->dev);
+                if (ret < 0)
+                        goto eadddev;
+
+                /*
+                 * FIXME: this is racy, have to use driver-binding notification,
+                 * when it is available
+                 */
+                control = to_soc_camera_control(icd);
+                if (!control || !control->driver || !dev_get_drvdata(control) ||
+                    !try_module_get(control->driver->owner)) {
+                        icl->del_device(icl);
+                        goto enodrv;
+                }
         }
 
+        /* At this point client .probe() should have run already */
+        ret = soc_camera_init_user_formats(icd);
+        if (ret < 0)
+                goto eiufmt;
+
+        icd->field = V4L2_FIELD_ANY;
+
+        /* ..._video_start() will create a device node, so we have to protect */
         mutex_lock(&icd->video_lock);
 
-        /* We only call ->add() here to activate and probe the camera.
-         * We shall ->remove() and deactivate it immediately afterwards. */
-        ret = ici->ops->add(icd);
+        ret = soc_camera_video_start(icd);
         if (ret < 0)
-                goto eiadd;
+                goto evidstart;
+
+        /* Try to improve our guess of a reasonable window format */
+        sd = soc_camera_to_subdev(icd);
+        if (!v4l2_subdev_call(sd, video, g_fmt, &f)) {
+                icd->user_width         = f.fmt.pix.width;
+                icd->user_height        = f.fmt.pix.height;
+        }
 
-        ret = icd->ops->probe(icd);
-        if (ret >= 0) {
-                const struct v4l2_queryctrl *qctrl;
+        /* Do we have to sysfs_remove_link() before device_unregister()? */
+        if (sysfs_create_link(&icd->dev.kobj, &to_soc_camera_control(icd)->kobj,
+                              "control"))
+                dev_warn(&icd->dev, "Failed creating the control symlink\n");
 
-                qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_GAIN);
-                icd->gain = qctrl ? qctrl->default_value : (unsigned short)~0;
-                qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
-                icd->exposure = qctrl ? qctrl->default_value :
-                        (unsigned short)~0;
+        ici->ops->remove(icd);
 
-                ret = soc_camera_init_user_formats(icd);
-                if (ret < 0) {
-                        if (icd->ops->remove)
-                                icd->ops->remove(icd);
-                        goto eiufmt;
-                }
+        if (icl->power)
+                icl->power(icd->pdev, 0);
 
-                icd->height     = DEFAULT_HEIGHT;
-                icd->width      = DEFAULT_WIDTH;
-                icd->field      = V4L2_FIELD_ANY;
-        }
+        mutex_unlock(&icd->video_lock);
 
+        return 0;
+
+evidstart:
+        mutex_unlock(&icd->video_lock);
+        soc_camera_free_user_formats(icd);
 eiufmt:
+        if (icl->board_info) {
+                soc_camera_free_i2c(icd);
+        } else {
+                icl->del_device(icl);
+                module_put(control->driver->owner);
+        }
+enodrv:
+eadddev:
+        video_device_release(icd->vdev);
+evdc:
         ici->ops->remove(icd);
-eiadd:
-        mutex_unlock(&icd->video_lock);
-        module_put(ici->ops->owner);
-emgi:
-        module_put(icd->ops->owner);
-emgd:
+eadd:
+        if (icl->power)
+                icl->power(icd->pdev, 0);
+epower:
         return ret;
 }
 
@@ -904,12 +1009,28 @@ emgd:
 static int soc_camera_remove(struct device *dev)
 {
         struct soc_camera_device *icd = to_soc_camera_dev(dev);
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
+        struct video_device *vdev = icd->vdev;
 
-        mutex_lock(&icd->video_lock);
-        if (icd->ops->remove)
-                icd->ops->remove(icd);
-        mutex_unlock(&icd->video_lock);
+        BUG_ON(!dev->parent);
 
+        if (vdev) {
+                mutex_lock(&icd->video_lock);
+                video_unregister_device(vdev);
+                icd->vdev = NULL;
+                mutex_unlock(&icd->video_lock);
+        }
+
+        if (icl->board_info) {
+                soc_camera_free_i2c(icd);
+        } else {
+                struct device_driver *drv = to_soc_camera_control(icd) ?
+                        to_soc_camera_control(icd)->driver : NULL;
+                if (drv) {
+                        icl->del_device(icl);
+                        module_put(drv->owner);
+                }
+        }
         soc_camera_free_user_formats(icd);
 
         return 0;
@@ -957,14 +1078,33 @@ static void dummy_release(struct device *dev)
 {
 }
 
+static int default_cropcap(struct soc_camera_device *icd,
+                           struct v4l2_cropcap *a)
+{
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        return v4l2_subdev_call(sd, video, cropcap, a);
+}
+
+static int default_g_crop(struct soc_camera_device *icd, struct v4l2_crop *a)
+{
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        return v4l2_subdev_call(sd, video, g_crop, a);
+}
+
+static int default_s_crop(struct soc_camera_device *icd, struct v4l2_crop *a)
+{
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        return v4l2_subdev_call(sd, video, s_crop, a);
+}
+
 int soc_camera_host_register(struct soc_camera_host *ici)
 {
         struct soc_camera_host *ix;
+        int ret;
 
         if (!ici || !ici->ops ||
             !ici->ops->try_fmt ||
             !ici->ops->set_fmt ||
-            !ici->ops->set_crop ||
             !ici->ops->set_bus_param ||
             !ici->ops->querycap ||
             !ici->ops->init_videobuf ||
@@ -972,18 +1112,27 @@ int soc_camera_host_register(struct soc_camera_host *ici)
             !ici->ops->add ||
             !ici->ops->remove ||
             !ici->ops->poll ||
-            !ici->dev)
+            !ici->v4l2_dev.dev)
                 return -EINVAL;
 
+        if (!ici->ops->set_crop)
+                ici->ops->set_crop = default_s_crop;
+        if (!ici->ops->get_crop)
+                ici->ops->get_crop = default_g_crop;
+        if (!ici->ops->cropcap)
+                ici->ops->cropcap = default_cropcap;
+
         mutex_lock(&list_lock);
         list_for_each_entry(ix, &hosts, list) {
                 if (ix->nr == ici->nr) {
-                        mutex_unlock(&list_lock);
-                        return -EBUSY;
+                        ret = -EBUSY;
+                        goto edevreg;
                 }
         }
 
-        dev_set_drvdata(ici->dev, ici);
+        ret = v4l2_device_register(ici->v4l2_dev.dev, &ici->v4l2_dev);
+        if (ret < 0)
+                goto edevreg;
 
         list_add_tail(&ici->list, &hosts);
         mutex_unlock(&list_lock);
@@ -991,6 +1140,10 @@ int soc_camera_host_register(struct soc_camera_host *ici)
         scan_add_host(ici);
 
         return 0;
+
+edevreg:
+        mutex_unlock(&list_lock);
+        return ret;
 }
 EXPORT_SYMBOL(soc_camera_host_register);
 
@@ -1004,42 +1157,34 @@ void soc_camera_host_unregister(struct soc_camera_host *ici)
         list_del(&ici->list);
 
         list_for_each_entry(icd, &devices, list) {
-                if (icd->dev.parent == ici->dev) {
+                if (icd->iface == ici->nr) {
+                        /* The bus->remove will be called */
                         device_unregister(&icd->dev);
                         /* Not before device_unregister(), .remove
                          * needs parent to call ici->ops->remove() */
                         icd->dev.parent = NULL;
+
+                        /* If the host module is loaded again, device_register()
+                         * would complain "already initialised" */
                         memset(&icd->dev.kobj, 0, sizeof(icd->dev.kobj));
                 }
         }
 
         mutex_unlock(&list_lock);
 
-        dev_set_drvdata(ici->dev, NULL);
+        v4l2_device_unregister(&ici->v4l2_dev);
 }
 EXPORT_SYMBOL(soc_camera_host_unregister);
 
 /* Image capture device */
-int soc_camera_device_register(struct soc_camera_device *icd)
+static int soc_camera_device_register(struct soc_camera_device *icd)
 {
         struct soc_camera_device *ix;
         int num = -1, i;
 
-        if (!icd || !icd->ops ||
-            !icd->ops->probe ||
-            !icd->ops->init ||
-            !icd->ops->release ||
-            !icd->ops->start_capture ||
-            !icd->ops->stop_capture ||
-            !icd->ops->set_crop ||
-            !icd->ops->set_fmt ||
-            !icd->ops->try_fmt ||
-            !icd->ops->query_bus_param ||
-            !icd->ops->set_bus_param)
-                return -EINVAL;
-
         for (i = 0; i < 256 && num < 0; i++) {
                 num = i;
+                /* Check if this index is available on this interface */
                 list_for_each_entry(ix, &devices, list) {
                         if (ix->iface == icd->iface && ix->devnum == i) {
                                 num = -1;
@@ -1061,21 +1206,15 @@ int soc_camera_device_register(struct soc_camera_device *icd)
         icd->host_priv          = NULL;
         mutex_init(&icd->video_lock);
 
-        return scan_add_device(icd);
+        list_add_tail(&icd->list, &devices);
+
+        return 0;
 }
-EXPORT_SYMBOL(soc_camera_device_register);
 
-void soc_camera_device_unregister(struct soc_camera_device *icd)
+static void soc_camera_device_unregister(struct soc_camera_device *icd)
 {
-        mutex_lock(&list_lock);
         list_del(&icd->list);
-
-        /* The bus->remove will be eventually called */
-        if (icd->dev.parent)
-                device_unregister(&icd->dev);
-        mutex_unlock(&list_lock);
 }
-EXPORT_SYMBOL(soc_camera_device_unregister);
 
 static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
         .vidioc_querycap         = soc_camera_querycap,
@@ -1106,23 +1245,13 @@ static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
 #endif
 };
 
-/*
- * Usually called from the struct soc_camera_ops .probe() method, i.e., from
- * soc_camera_probe() above with .video_lock held
- */
-int soc_camera_video_start(struct soc_camera_device *icd)
+static int video_dev_create(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
-        int err = -ENOMEM;
-        struct video_device *vdev;
+        struct video_device *vdev = video_device_alloc();
 
-        if (!icd->dev.parent)
-                return -ENODEV;
-
-        vdev = video_device_alloc();
         if (!vdev)
-                goto evidallocd;
-        dev_dbg(ici->dev, "Allocated video_device %p\n", vdev);
+                return -ENOMEM;
 
         strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
 
@@ -1132,87 +1261,93 @@ int soc_camera_video_start(struct soc_camera_device *icd)
         vdev->ioctl_ops         = &soc_camera_ioctl_ops;
         vdev->release           = video_device_release;
         vdev->minor             = -1;
-        vdev->tvnorms           = V4L2_STD_UNKNOWN,
+        vdev->tvnorms           = V4L2_STD_UNKNOWN;
 
-        err = video_register_device(vdev, VFL_TYPE_GRABBER, vdev->minor);
-        if (err < 0) {
-                dev_err(vdev->parent, "video_register_device failed\n");
-                goto evidregd;
-        }
         icd->vdev = vdev;
 
         return 0;
-
-evidregd:
-        video_device_release(vdev);
-evidallocd:
-        return err;
 }
-EXPORT_SYMBOL(soc_camera_video_start);
 
-/* Called from client .remove() methods with .video_lock held */
-void soc_camera_video_stop(struct soc_camera_device *icd)
+/*
+ * Called from soc_camera_probe() above (with .video_lock held???)
+ */
+static int soc_camera_video_start(struct soc_camera_device *icd)
 {
-        struct video_device *vdev = icd->vdev;
+        int ret;
 
-        dev_dbg(&icd->dev, "%s\n", __func__);
+        if (!icd->dev.parent)
+                return -ENODEV;
 
-        if (!icd->dev.parent || !vdev)
-                return;
+        if (!icd->ops ||
+            !icd->ops->query_bus_param ||
+            !icd->ops->set_bus_param)
+                return -EINVAL;
+
+        ret = video_register_device(icd->vdev, VFL_TYPE_GRABBER,
+                                    icd->vdev->minor);
+        if (ret < 0) {
+                dev_err(&icd->dev, "video_register_device failed: %d\n", ret);
+                return ret;
+        }
 
-        video_unregister_device(vdev);
-        icd->vdev = NULL;
+        return 0;
 }
-EXPORT_SYMBOL(soc_camera_video_stop);
 
 static int __devinit soc_camera_pdrv_probe(struct platform_device *pdev)
 {
         struct soc_camera_link *icl = pdev->dev.platform_data;
-        struct i2c_adapter *adap;
-        struct i2c_client *client;
+        struct soc_camera_device *icd;
+        int ret;
 
         if (!icl)
                 return -EINVAL;
 
-        adap = i2c_get_adapter(icl->i2c_adapter_id);
-        if (!adap) {
-                dev_warn(&pdev->dev, "Cannot get adapter #%d. No driver?\n",
-                         icl->i2c_adapter_id);
-                /* -ENODEV and -ENXIO do not produce an error on probe()... */
-                return -ENOENT;
-        }
-
-        icl->board_info->platform_data = icl;
-        client = i2c_new_device(adap, icl->board_info);
-        if (!client) {
-                i2c_put_adapter(adap);
+        icd = kzalloc(sizeof(*icd), GFP_KERNEL);
+        if (!icd)
                 return -ENOMEM;
-        }
 
-        platform_set_drvdata(pdev, client);
+        icd->iface = icl->bus_id;
+        icd->pdev = &pdev->dev;
+        platform_set_drvdata(pdev, icd);
+        icd->dev.platform_data = icl;
+
+        ret = soc_camera_device_register(icd);
+        if (ret < 0)
+                goto escdevreg;
+
+        icd->user_width         = DEFAULT_WIDTH;
+        icd->user_height        = DEFAULT_HEIGHT;
 
         return 0;
+
+escdevreg:
+        kfree(icd);
+
+        return ret;
 }
 
+/* Only called on rmmod for each platform device, since they are not
+ * hot-pluggable. Now we know, that all our users - hosts and devices have
+ * been unloaded already */
 static int __devexit soc_camera_pdrv_remove(struct platform_device *pdev)
 {
-        struct i2c_client *client = platform_get_drvdata(pdev);
+        struct soc_camera_device *icd = platform_get_drvdata(pdev);
 
-        if (!client)
-                return -ENODEV;
+        if (!icd)
+                return -EINVAL;
 
-        i2c_unregister_device(client);
-        i2c_put_adapter(client->adapter);
+        soc_camera_device_unregister(icd);
+
+        kfree(icd);
 
         return 0;
 }
 
 static struct platform_driver __refdata soc_camera_pdrv = {
-        .probe  = soc_camera_pdrv_probe,
-        .remove = __devexit_p(soc_camera_pdrv_remove),
-        .driver = {
-                .name = "soc-camera-pdrv",
-                .owner = THIS_MODULE,
+        .remove  = __devexit_p(soc_camera_pdrv_remove),
+        .driver  = {
+                .name   = "soc-camera-pdrv",
+                .owner  = THIS_MODULE,
         },
 };
 
@@ -1225,7 +1360,7 @@ static int __init soc_camera_init(void)
         if (ret)
                 goto edrvr;
 
-        ret = platform_driver_register(&soc_camera_pdrv);
+        ret = platform_driver_probe(&soc_camera_pdrv, soc_camera_pdrv_probe);
         if (ret)
                 goto epdr;
 
diff --git a/drivers/media/video/soc_camera_platform.c b/drivers/media/video/soc_camera_platform.c
index c48676356ab7..b6a575ce5da2 100644
--- a/drivers/media/video/soc_camera_platform.c
+++ b/drivers/media/video/soc_camera_platform.c
@@ -16,54 +16,32 @@
 #include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/videodev2.h>
-#include <media/v4l2-common.h>
+#include <media/v4l2-subdev.h>
 #include <media/soc_camera.h>
 #include <media/soc_camera_platform.h>
 
 struct soc_camera_platform_priv {
-        struct soc_camera_platform_info *info;
-        struct soc_camera_device icd;
+        struct v4l2_subdev subdev;
         struct soc_camera_data_format format;
 };
 
-static struct soc_camera_platform_info *
-soc_camera_platform_get_info(struct soc_camera_device *icd)
+static struct soc_camera_platform_priv *get_priv(struct platform_device *pdev)
 {
-        struct soc_camera_platform_priv *priv;
-        priv = container_of(icd, struct soc_camera_platform_priv, icd);
-        return priv->info;
-}
-
-static int soc_camera_platform_init(struct soc_camera_device *icd)
-{
-        struct soc_camera_platform_info *p = soc_camera_platform_get_info(icd);
-
-        if (p->power)
-                p->power(1);
-
-        return 0;
-}
-
-static int soc_camera_platform_release(struct soc_camera_device *icd)
-{
-        struct soc_camera_platform_info *p = soc_camera_platform_get_info(icd);
-
-        if (p->power)
-                p->power(0);
-
-        return 0;
+        struct v4l2_subdev *subdev = platform_get_drvdata(pdev);
+        return container_of(subdev, struct soc_camera_platform_priv, subdev);
 }
 
-static int soc_camera_platform_start_capture(struct soc_camera_device *icd)
+static struct soc_camera_platform_info *get_info(struct soc_camera_device *icd)
 {
-        struct soc_camera_platform_info *p = soc_camera_platform_get_info(icd);
-        return p->set_capture(p, 1);
+        struct platform_device *pdev =
+                to_platform_device(to_soc_camera_control(icd));
+        return pdev->dev.platform_data;
 }
 
-static int soc_camera_platform_stop_capture(struct soc_camera_device *icd)
+static int soc_camera_platform_s_stream(struct v4l2_subdev *sd, int enable)
 {
-        struct soc_camera_platform_info *p = soc_camera_platform_get_info(icd);
-        return p->set_capture(p, 0);
+        struct soc_camera_platform_info *p = v4l2_get_subdevdata(sd);
+        return p->set_capture(p, enable);
 }
 
 static int soc_camera_platform_set_bus_param(struct soc_camera_device *icd,
@@ -75,26 +53,14 @@ static int soc_camera_platform_set_bus_param(struct soc_camera_device *icd,
 static unsigned long
 soc_camera_platform_query_bus_param(struct soc_camera_device *icd)
 {
-        struct soc_camera_platform_info *p = soc_camera_platform_get_info(icd);
+        struct soc_camera_platform_info *p = get_info(icd);
         return p->bus_param;
 }
 
-static int soc_camera_platform_set_crop(struct soc_camera_device *icd,
-                                        struct v4l2_rect *rect)
-{
-        return 0;
-}
-
-static int soc_camera_platform_set_fmt(struct soc_camera_device *icd,
+static int soc_camera_platform_try_fmt(struct v4l2_subdev *sd,
                                        struct v4l2_format *f)
 {
-        return 0;
-}
-
-static int soc_camera_platform_try_fmt(struct soc_camera_device *icd,
-                                       struct v4l2_format *f)
-{
-        struct soc_camera_platform_info *p = soc_camera_platform_get_info(icd);
+        struct soc_camera_platform_info *p = v4l2_get_subdevdata(sd);
         struct v4l2_pix_format *pix = &f->fmt.pix;
 
         pix->width = p->format.width;
@@ -102,82 +68,99 @@ static int soc_camera_platform_try_fmt(struct soc_camera_device *icd,
         return 0;
 }
 
-static int soc_camera_platform_video_probe(struct soc_camera_device *icd)
+static void soc_camera_platform_video_probe(struct soc_camera_device *icd,
+                                            struct platform_device *pdev)
 {
-        struct soc_camera_platform_priv *priv;
-        priv = container_of(icd, struct soc_camera_platform_priv, icd);
+        struct soc_camera_platform_priv *priv = get_priv(pdev);
+        struct soc_camera_platform_info *p = pdev->dev.platform_data;
 
-        priv->format.name = priv->info->format_name;
-        priv->format.depth = priv->info->format_depth;
-        priv->format.fourcc = priv->info->format.pixelformat;
-        priv->format.colorspace = priv->info->format.colorspace;
+        priv->format.name = p->format_name;
+        priv->format.depth = p->format_depth;
+        priv->format.fourcc = p->format.pixelformat;
+        priv->format.colorspace = p->format.colorspace;
 
         icd->formats = &priv->format;
         icd->num_formats = 1;
-
-        return soc_camera_video_start(icd);
 }
 
-static void soc_camera_platform_video_remove(struct soc_camera_device *icd)
-{
-        soc_camera_video_stop(icd);
-}
+static struct v4l2_subdev_core_ops platform_subdev_core_ops;
+
+static struct v4l2_subdev_video_ops platform_subdev_video_ops = {
+        .s_stream       = soc_camera_platform_s_stream,
+        .try_fmt        = soc_camera_platform_try_fmt,
+};
+
+static struct v4l2_subdev_ops platform_subdev_ops = {
+        .core   = &platform_subdev_core_ops,
+        .video  = &platform_subdev_video_ops,
+};
 
 static struct soc_camera_ops soc_camera_platform_ops = {
-        .owner                  = THIS_MODULE,
-        .probe                  = soc_camera_platform_video_probe,
-        .remove                 = soc_camera_platform_video_remove,
-        .init                   = soc_camera_platform_init,
-        .release                = soc_camera_platform_release,
-        .start_capture          = soc_camera_platform_start_capture,
-        .stop_capture           = soc_camera_platform_stop_capture,
-        .set_crop               = soc_camera_platform_set_crop,
-        .set_fmt                = soc_camera_platform_set_fmt,
-        .try_fmt                = soc_camera_platform_try_fmt,
         .set_bus_param          = soc_camera_platform_set_bus_param,
         .query_bus_param        = soc_camera_platform_query_bus_param,
 };
 
 static int soc_camera_platform_probe(struct platform_device *pdev)
 {
+        struct soc_camera_host *ici;
         struct soc_camera_platform_priv *priv;
-        struct soc_camera_platform_info *p;
+        struct soc_camera_platform_info *p = pdev->dev.platform_data;
         struct soc_camera_device *icd;
         int ret;
 
-        p = pdev->dev.platform_data;
         if (!p)
                 return -EINVAL;
 
+        if (!p->dev) {
+                dev_err(&pdev->dev,
+                        "Platform has not set soc_camera_device pointer!\n");
+                return -EINVAL;
+        }
+
         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
 
-        priv->info = p;
-        platform_set_drvdata(pdev, priv);
+        icd = to_soc_camera_dev(p->dev);
+
+        /* soc-camera convention: control's drvdata points to the subdev */
+        platform_set_drvdata(pdev, &priv->subdev);
+        /* Set the control device reference */
+        dev_set_drvdata(&icd->dev, &pdev->dev);
+
+        icd->y_skip_top         = 0;
+        icd->ops                = &soc_camera_platform_ops;
+
+        ici = to_soc_camera_host(icd->dev.parent);
 
-        icd = &priv->icd;
-        icd->ops        = &soc_camera_platform_ops;
-        icd->control    = &pdev->dev;
-        icd->width_min  = 0;
-        icd->width_max  = priv->info->format.width;
-        icd->height_min = 0;
-        icd->height_max = priv->info->format.height;
-        icd->y_skip_top = 0;
-        icd->iface      = priv->info->iface;
+        soc_camera_platform_video_probe(icd, pdev);
 
-        ret = soc_camera_device_register(icd);
+        v4l2_subdev_init(&priv->subdev, &platform_subdev_ops);
+        v4l2_set_subdevdata(&priv->subdev, p);
+        strncpy(priv->subdev.name, dev_name(&pdev->dev), V4L2_SUBDEV_NAME_SIZE);
+
+        ret = v4l2_device_register_subdev(&ici->v4l2_dev, &priv->subdev);
         if (ret)
-                kfree(priv);
+                goto evdrs;
+
+        return ret;
 
+evdrs:
+        icd->ops = NULL;
+        platform_set_drvdata(pdev, NULL);
+        kfree(priv);
         return ret;
 }
 
 static int soc_camera_platform_remove(struct platform_device *pdev)
 {
-        struct soc_camera_platform_priv *priv = platform_get_drvdata(pdev);
+        struct soc_camera_platform_priv *priv = get_priv(pdev);
+        struct soc_camera_platform_info *p = pdev->dev.platform_data;
+        struct soc_camera_device *icd = to_soc_camera_dev(p->dev);
 
-        soc_camera_device_unregister(&priv->icd);
+        v4l2_device_unregister_subdev(&priv->subdev);
+        icd->ops = NULL;
+        platform_set_drvdata(pdev, NULL);
         kfree(priv);
         return 0;
 }
@@ -185,6 +168,7 @@ static int soc_camera_platform_remove(struct platform_device *pdev)
 static struct platform_driver soc_camera_platform_driver = {
         .driver         = {
                 .name   = "soc_camera_platform",
+                .owner  = THIS_MODULE,
         },
         .probe          = soc_camera_platform_probe,
         .remove         = soc_camera_platform_remove,
@@ -206,3 +190,4 @@ module_exit(soc_camera_platform_module_exit);
 MODULE_DESCRIPTION("SoC Camera Platform driver");
 MODULE_AUTHOR("Magnus Damm");
 MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:soc_camera_platform");
diff --git a/drivers/media/video/tuner-core.c b/drivers/media/video/tuner-core.c
index 2816f1839230..aba92e2313d8 100644
--- a/drivers/media/video/tuner-core.c
+++ b/drivers/media/video/tuner-core.c
@@ -29,6 +29,7 @@
 #include "tuner-simple.h"
 #include "tda9887.h"
 #include "xc5000.h"
+#include "tda18271.h"
 
 #define UNSET (-1U)
 
@@ -420,6 +421,17 @@ static void set_type(struct i2c_client *c, unsigned int type,
                         goto attach_failed;
                 break;
         }
+        case TUNER_NXP_TDA18271:
+        {
+                struct tda18271_config cfg = {
+                        .config = t->config,
+                };
+
+                if (!dvb_attach(tda18271_attach, &t->fe, t->i2c->addr,
+                                t->i2c->adapter, &cfg))
+                        goto attach_failed;
+                break;
+        }
         default:
                 if (!dvb_attach(simple_tuner_attach, &t->fe,
                                 t->i2c->adapter, t->i2c->addr, t->type))
diff --git a/drivers/media/video/tvp514x.c b/drivers/media/video/tvp514x.c
index 3750f7fadb12..244372627df2 100644
--- a/drivers/media/video/tvp514x.c
+++ b/drivers/media/video/tvp514x.c
@@ -31,7 +31,10 @@
 #include <linux/i2c.h>
 #include <linux/delay.h>
 #include <linux/videodev2.h>
-#include <media/v4l2-int-device.h>
+
+#include <media/v4l2-device.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-chip-ident.h>
 #include <media/tvp514x.h>
 
 #include "tvp514x_regs.h"
@@ -49,15 +52,11 @@ static int debug;
 module_param(debug, bool, 0644);
 MODULE_PARM_DESC(debug, "Debug level (0-1)");
 
-#define dump_reg(client, reg, val)                              \
-        do {                                                    \
-                val = tvp514x_read_reg(client, reg);            \
-                v4l_info(client, "Reg(0x%.2X): 0x%.2X\n", reg, val); \
-        } while (0)
+MODULE_AUTHOR("Texas Instruments");
+MODULE_DESCRIPTION("TVP514X linux decoder driver");
+MODULE_LICENSE("GPL");
 
-/**
- * enum tvp514x_std - enum for supported standards
- */
+/* enum tvp514x_std - enum for supported standards */
 enum tvp514x_std {
         STD_NTSC_MJ = 0,
         STD_PAL_BDGHIN,
@@ -65,14 +64,6 @@ enum tvp514x_std {
 };
 
 /**
- * enum tvp514x_state - enum for different decoder states
- */
-enum tvp514x_state {
-        STATE_NOT_DETECTED,
-        STATE_DETECTED
-};
-
-/**
  * struct tvp514x_std_info - Structure to store standard informations
  * @width: Line width in pixels
  * @height:Number of active lines
@@ -89,33 +80,27 @@ struct tvp514x_std_info {
 static struct tvp514x_reg tvp514x_reg_list_default[0x40];
 /**
  * struct tvp514x_decoder - TVP5146/47 decoder object
- * @v4l2_int_device: Slave handle
- * @tvp514x_slave: Slave pointer which is used by @v4l2_int_device
+ * @sd: Subdevice Slave handle
  * @tvp514x_regs: copy of hw's regs with preset values.
  * @pdata: Board specific
- * @client: I2C client data
- * @id: Entry from I2C table
  * @ver: Chip version
- * @state: TVP5146/47 decoder state - detected or not-detected
+ * @streaming: TVP5146/47 decoder streaming - enabled or disabled.
  * @pix: Current pixel format
  * @num_fmts: Number of formats
  * @fmt_list: Format list
  * @current_std: Current standard
  * @num_stds: Number of standards
  * @std_list: Standards list
- * @route: input and output routing at chip level
+ * @input: Input routing at chip level
+ * @output: Output routing at chip level
  */
 struct tvp514x_decoder {
-        struct v4l2_int_device v4l2_int_device;
-        struct v4l2_int_slave tvp514x_slave;
+        struct v4l2_subdev sd;
         struct tvp514x_reg tvp514x_regs[ARRAY_SIZE(tvp514x_reg_list_default)];
         const struct tvp514x_platform_data *pdata;
-        struct i2c_client *client;
-
-        struct i2c_device_id *id;
 
         int ver;
-        enum tvp514x_state state;
+        int streaming;
 
         struct v4l2_pix_format pix;
         int num_fmts;
@@ -124,15 +109,18 @@ struct tvp514x_decoder {
         enum tvp514x_std current_std;
         int num_stds;
         struct tvp514x_std_info *std_list;
-
-        struct v4l2_routing route;
+        /* Input and Output Routing parameters */
+        u32 input;
+        u32 output;
 };
 
 /* TVP514x default register values */
 static struct tvp514x_reg tvp514x_reg_list_default[] = {
-        {TOK_WRITE, REG_INPUT_SEL, 0x05},       /* Composite selected */
+        /* Composite selected */
+        {TOK_WRITE, REG_INPUT_SEL, 0x05},
         {TOK_WRITE, REG_AFE_GAIN_CTRL, 0x0F},
-        {TOK_WRITE, REG_VIDEO_STD, 0x00},       /* Auto mode */
+        /* Auto mode */
+        {TOK_WRITE, REG_VIDEO_STD, 0x00},
         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
         {TOK_SKIP, REG_AUTOSWITCH_MASK, 0x3F},
         {TOK_WRITE, REG_COLOR_KILLER, 0x10},
@@ -145,53 +133,74 @@ static struct tvp514x_reg tvp514x_reg_list_default[] = {
         {TOK_WRITE, REG_HUE, 0x00},
         {TOK_WRITE, REG_CHROMA_CONTROL1, 0x00},
         {TOK_WRITE, REG_CHROMA_CONTROL2, 0x0E},
-        {TOK_SKIP, 0x0F, 0x00}, /* Reserved */
+        /* Reserved */
+        {TOK_SKIP, 0x0F, 0x00},
         {TOK_WRITE, REG_COMP_PR_SATURATION, 0x80},
         {TOK_WRITE, REG_COMP_Y_CONTRAST, 0x80},
         {TOK_WRITE, REG_COMP_PB_SATURATION, 0x80},
-        {TOK_SKIP, 0x13, 0x00}, /* Reserved */
+        /* Reserved */
+        {TOK_SKIP, 0x13, 0x00},
         {TOK_WRITE, REG_COMP_Y_BRIGHTNESS, 0x80},
-        {TOK_SKIP, 0x15, 0x00}, /* Reserved */
-        {TOK_SKIP, REG_AVID_START_PIXEL_LSB, 0x55},     /* NTSC timing */
+        /* Reserved */
+        {TOK_SKIP, 0x15, 0x00},
+        /* NTSC timing */
+        {TOK_SKIP, REG_AVID_START_PIXEL_LSB, 0x55},
         {TOK_SKIP, REG_AVID_START_PIXEL_MSB, 0x00},
         {TOK_SKIP, REG_AVID_STOP_PIXEL_LSB, 0x25},
         {TOK_SKIP, REG_AVID_STOP_PIXEL_MSB, 0x03},
-        {TOK_SKIP, REG_HSYNC_START_PIXEL_LSB, 0x00},    /* NTSC timing */
+        /* NTSC timing */
+        {TOK_SKIP, REG_HSYNC_START_PIXEL_LSB, 0x00},
         {TOK_SKIP, REG_HSYNC_START_PIXEL_MSB, 0x00},
         {TOK_SKIP, REG_HSYNC_STOP_PIXEL_LSB, 0x40},
         {TOK_SKIP, REG_HSYNC_STOP_PIXEL_MSB, 0x00},
-        {TOK_SKIP, REG_VSYNC_START_LINE_LSB, 0x04},     /* NTSC timing */
+        /* NTSC timing */
+        {TOK_SKIP, REG_VSYNC_START_LINE_LSB, 0x04},
         {TOK_SKIP, REG_VSYNC_START_LINE_MSB, 0x00},
         {TOK_SKIP, REG_VSYNC_STOP_LINE_LSB, 0x07},
         {TOK_SKIP, REG_VSYNC_STOP_LINE_MSB, 0x00},
-        {TOK_SKIP, REG_VBLK_START_LINE_LSB, 0x01},      /* NTSC timing */
+        /* NTSC timing */
+        {TOK_SKIP, REG_VBLK_START_LINE_LSB, 0x01},
         {TOK_SKIP, REG_VBLK_START_LINE_MSB, 0x00},
         {TOK_SKIP, REG_VBLK_STOP_LINE_LSB, 0x15},
         {TOK_SKIP, REG_VBLK_STOP_LINE_MSB, 0x00},
-        {TOK_SKIP, 0x26, 0x00}, /* Reserved */
-        {TOK_SKIP, 0x27, 0x00}, /* Reserved */
+        /* Reserved */
+        {TOK_SKIP, 0x26, 0x00},
+        /* Reserved */
+        {TOK_SKIP, 0x27, 0x00},
         {TOK_SKIP, REG_FAST_SWTICH_CONTROL, 0xCC},
-        {TOK_SKIP, 0x29, 0x00}, /* Reserved */
+        /* Reserved */
+        {TOK_SKIP, 0x29, 0x00},
         {TOK_SKIP, REG_FAST_SWTICH_SCART_DELAY, 0x00},
-        {TOK_SKIP, 0x2B, 0x00}, /* Reserved */
+        /* Reserved */
+        {TOK_SKIP, 0x2B, 0x00},
         {TOK_SKIP, REG_SCART_DELAY, 0x00},
         {TOK_SKIP, REG_CTI_DELAY, 0x00},
         {TOK_SKIP, REG_CTI_CONTROL, 0x00},
-        {TOK_SKIP, 0x2F, 0x00}, /* Reserved */
-        {TOK_SKIP, 0x30, 0x00}, /* Reserved */
-        {TOK_SKIP, 0x31, 0x00}, /* Reserved */
-        {TOK_WRITE, REG_SYNC_CONTROL, 0x00},    /* HS, VS active high */
-        {TOK_WRITE, REG_OUTPUT_FORMATTER1, 0x00},       /* 10-bit BT.656 */
-        {TOK_WRITE, REG_OUTPUT_FORMATTER2, 0x11},       /* Enable clk & data */
-        {TOK_WRITE, REG_OUTPUT_FORMATTER3, 0xEE},       /* Enable AVID & FLD */
-        {TOK_WRITE, REG_OUTPUT_FORMATTER4, 0xAF},       /* Enable VS & HS */
+        /* Reserved */
+        {TOK_SKIP, 0x2F, 0x00},
+        /* Reserved */
+        {TOK_SKIP, 0x30, 0x00},
+        /* Reserved */
+        {TOK_SKIP, 0x31, 0x00},
+        /* HS, VS active high */
+        {TOK_WRITE, REG_SYNC_CONTROL, 0x00},
+        /* 10-bit BT.656 */
+        {TOK_WRITE, REG_OUTPUT_FORMATTER1, 0x00},
+        /* Enable clk & data */
+        {TOK_WRITE, REG_OUTPUT_FORMATTER2, 0x11},
+        /* Enable AVID & FLD */
+        {TOK_WRITE, REG_OUTPUT_FORMATTER3, 0xEE},
+        /* Enable VS & HS */
+        {TOK_WRITE, REG_OUTPUT_FORMATTER4, 0xAF},
         {TOK_WRITE, REG_OUTPUT_FORMATTER5, 0xFF},
         {TOK_WRITE, REG_OUTPUT_FORMATTER6, 0xFF},
-        {TOK_WRITE, REG_CLEAR_LOST_LOCK, 0x01}, /* Clear status */
+        /* Clear status */
+        {TOK_WRITE, REG_CLEAR_LOST_LOCK, 0x01},
         {TOK_TERM, 0, 0},
 };
 
-/* List of image formats supported by TVP5146/47 decoder
+/**
+ * List of image formats supported by TVP5146/47 decoder
  * Currently we are using 8 bit mode only, but can be
  * extended to 10/20 bit mode.
  */
@@ -205,7 +214,7 @@ static const struct v4l2_fmtdesc tvp514x_fmt_list[] = {
         },
 };
 
-/*
+/**
  * Supported standards -
  *
  * Currently supports two standards only, need to add support for rest of the
@@ -240,35 +249,32 @@ static struct tvp514x_std_info tvp514x_std_list[] = {
         },
         /* Standard: need to add for additional standard */
 };
-/*
- * Control structure for Auto Gain
- *     This is temporary data, will get replaced once
- *     v4l2_ctrl_query_fill supports it.
- */
-static const struct v4l2_queryctrl tvp514x_autogain_ctrl = {
-        .id = V4L2_CID_AUTOGAIN,
-        .name = "Gain, Automatic",
-        .type = V4L2_CTRL_TYPE_BOOLEAN,
-        .minimum = 0,
-        .maximum = 1,
-        .step = 1,
-        .default_value = 1,
-};
 
-/*
- * Read a value from a register in an TVP5146/47 decoder device.
+
+static inline struct tvp514x_decoder *to_decoder(struct v4l2_subdev *sd)
+{
+        return container_of(sd, struct tvp514x_decoder, sd);
+}
+
+
+/**
+ * tvp514x_read_reg() - Read a value from a register in an TVP5146/47.
+ * @sd: ptr to v4l2_subdev struct
+ * @reg: TVP5146/47 register address
+ *
  * Returns value read if successful, or non-zero (-1) otherwise.
  */
-static int tvp514x_read_reg(struct i2c_client *client, u8 reg)
+static int tvp514x_read_reg(struct v4l2_subdev *sd, u8 reg)
 {
-        int err;
-        int retry = 0;
+        int err, retry = 0;
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
 read_again:
 
         err = i2c_smbus_read_byte_data(client, reg);
         if (err == -1) {
                 if (retry <= I2C_RETRY_COUNT) {
-                        v4l_warn(client, "Read: retry ... %d\n", retry);
+                        v4l2_warn(sd, "Read: retry ... %d\n", retry);
                         retry++;
                         msleep_interruptible(10);
                         goto read_again;
@@ -278,20 +284,39 @@ read_again:
         return err;
 }
 
-/*
+/**
+ * dump_reg() - dump the register content of TVP5146/47.
+ * @sd: ptr to v4l2_subdev struct
+ * @reg: TVP5146/47 register address
+ */
+static void dump_reg(struct v4l2_subdev *sd, u8 reg)
+{
+        u32 val;
+
+        val = tvp514x_read_reg(sd, reg);
+        v4l2_info(sd, "Reg(0x%.2X): 0x%.2X\n", reg, val);
+}
+
+/**
+ * tvp514x_write_reg() - Write a value to a register in TVP5146/47
+ * @sd: ptr to v4l2_subdev struct
+ * @reg: TVP5146/47 register address
+ * @val: value to be written to the register
+ *
  * Write a value to a register in an TVP5146/47 decoder device.
  * Returns zero if successful, or non-zero otherwise.
  */
-static int tvp514x_write_reg(struct i2c_client *client, u8 reg, u8 val)
+static int tvp514x_write_reg(struct v4l2_subdev *sd, u8 reg, u8 val)
 {
-        int err;
-        int retry = 0;
+        int err, retry = 0;
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
 write_again:
 
         err = i2c_smbus_write_byte_data(client, reg, val);
         if (err) {
                 if (retry <= I2C_RETRY_COUNT) {
-                        v4l_warn(client, "Write: retry ... %d\n", retry);
+                        v4l2_warn(sd, "Write: retry ... %d\n", retry);
                         retry++;
                         msleep_interruptible(10);
                         goto write_again;
@@ -301,17 +326,19 @@ write_again:
         return err;
 }
 
-/*
- * tvp514x_write_regs : Initializes a list of TVP5146/47 registers
+/**
+ * tvp514x_write_regs() : Initializes a list of TVP5146/47 registers
+ * @sd: ptr to v4l2_subdev struct
+ * @reglist: list of TVP5146/47 registers and values
+ *
+ * Initializes a list of TVP5146/47 registers:-
  *              if token is TOK_TERM, then entire write operation terminates
  *              if token is TOK_DELAY, then a delay of 'val' msec is introduced
  *              if token is TOK_SKIP, then the register write is skipped
  *              if token is TOK_WRITE, then the register write is performed
- *
- * reglist - list of registers to be written
  * Returns zero if successful, or non-zero otherwise.
  */
-static int tvp514x_write_regs(struct i2c_client *client,
+static int tvp514x_write_regs(struct v4l2_subdev *sd,
                               const struct tvp514x_reg reglist[])
 {
         int err;
@@ -326,31 +353,33 @@ static int tvp514x_write_regs(struct i2c_client *client,
                 if (next->token == TOK_SKIP)
                         continue;
 
-                err = tvp514x_write_reg(client, next->reg, (u8) next->val);
+                err = tvp514x_write_reg(sd, next->reg, (u8) next->val);
                 if (err) {
-                        v4l_err(client, "Write failed. Err[%d]\n", err);
+                        v4l2_err(sd, "Write failed. Err[%d]\n", err);
                         return err;
                 }
         }
         return 0;
 }
 
-/*
- * tvp514x_get_current_std:
- * Returns the current standard detected by TVP5146/47
+/**
+ * tvp514x_get_current_std() : Get the current standard detected by TVP5146/47
+ * @sd: ptr to v4l2_subdev struct
+ *
+ * Get current standard detected by TVP5146/47, STD_INVALID if there is no
+ * standard detected.
  */
-static enum tvp514x_std tvp514x_get_current_std(struct tvp514x_decoder
-                                                *decoder)
+static enum tvp514x_std tvp514x_get_current_std(struct v4l2_subdev *sd)
 {
         u8 std, std_status;
 
-        std = tvp514x_read_reg(decoder->client, REG_VIDEO_STD);
-        if ((std & VIDEO_STD_MASK) == VIDEO_STD_AUTO_SWITCH_BIT) {
+        std = tvp514x_read_reg(sd, REG_VIDEO_STD);
+        if ((std & VIDEO_STD_MASK) == VIDEO_STD_AUTO_SWITCH_BIT)
                 /* use the standard status register */
-                std_status = tvp514x_read_reg(decoder->client,
-                                REG_VIDEO_STD_STATUS);
-        } else
-                std_status = std;       /* use the standard register itself */
+                std_status = tvp514x_read_reg(sd, REG_VIDEO_STD_STATUS);
+        else
+                /* use the standard register itself */
+                std_status = std;
 
         switch (std_status & VIDEO_STD_MASK) {
         case VIDEO_STD_NTSC_MJ_BIT:
@@ -366,94 +395,99 @@ static enum tvp514x_std tvp514x_get_current_std(struct tvp514x_decoder
         return STD_INVALID;
 }
 
-/*
- * TVP5146/47 register dump function
- */
-static void tvp514x_reg_dump(struct tvp514x_decoder *decoder)
+/* TVP5146/47 register dump function */
+static void tvp514x_reg_dump(struct v4l2_subdev *sd)
 {
-        u8 value;
-
-        dump_reg(decoder->client, REG_INPUT_SEL, value);
-        dump_reg(decoder->client, REG_AFE_GAIN_CTRL, value);
-        dump_reg(decoder->client, REG_VIDEO_STD, value);
-        dump_reg(decoder->client, REG_OPERATION_MODE, value);
-        dump_reg(decoder->client, REG_COLOR_KILLER, value);
-        dump_reg(decoder->client, REG_LUMA_CONTROL1, value);
-        dump_reg(decoder->client, REG_LUMA_CONTROL2, value);
-        dump_reg(decoder->client, REG_LUMA_CONTROL3, value);
-        dump_reg(decoder->client, REG_BRIGHTNESS, value);
-        dump_reg(decoder->client, REG_CONTRAST, value);
-        dump_reg(decoder->client, REG_SATURATION, value);
-        dump_reg(decoder->client, REG_HUE, value);
-        dump_reg(decoder->client, REG_CHROMA_CONTROL1, value);
-        dump_reg(decoder->client, REG_CHROMA_CONTROL2, value);
-        dump_reg(decoder->client, REG_COMP_PR_SATURATION, value);
-        dump_reg(decoder->client, REG_COMP_Y_CONTRAST, value);
-        dump_reg(decoder->client, REG_COMP_PB_SATURATION, value);
-        dump_reg(decoder->client, REG_COMP_Y_BRIGHTNESS, value);
-        dump_reg(decoder->client, REG_AVID_START_PIXEL_LSB, value);
-        dump_reg(decoder->client, REG_AVID_START_PIXEL_MSB, value);
-        dump_reg(decoder->client, REG_AVID_STOP_PIXEL_LSB, value);
-        dump_reg(decoder->client, REG_AVID_STOP_PIXEL_MSB, value);
-        dump_reg(decoder->client, REG_HSYNC_START_PIXEL_LSB, value);
-        dump_reg(decoder->client, REG_HSYNC_START_PIXEL_MSB, value);
-        dump_reg(decoder->client, REG_HSYNC_STOP_PIXEL_LSB, value);
-        dump_reg(decoder->client, REG_HSYNC_STOP_PIXEL_MSB, value);
-        dump_reg(decoder->client, REG_VSYNC_START_LINE_LSB, value);
-        dump_reg(decoder->client, REG_VSYNC_START_LINE_MSB, value);
-        dump_reg(decoder->client, REG_VSYNC_STOP_LINE_LSB, value);
-        dump_reg(decoder->client, REG_VSYNC_STOP_LINE_MSB, value);
-        dump_reg(decoder->client, REG_VBLK_START_LINE_LSB, value);
-        dump_reg(decoder->client, REG_VBLK_START_LINE_MSB, value);
-        dump_reg(decoder->client, REG_VBLK_STOP_LINE_LSB, value);
-        dump_reg(decoder->client, REG_VBLK_STOP_LINE_MSB, value);
-        dump_reg(decoder->client, REG_SYNC_CONTROL, value);
-        dump_reg(decoder->client, REG_OUTPUT_FORMATTER1, value);
-        dump_reg(decoder->client, REG_OUTPUT_FORMATTER2, value);
-        dump_reg(decoder->client, REG_OUTPUT_FORMATTER3, value);
-        dump_reg(decoder->client, REG_OUTPUT_FORMATTER4, value);
-        dump_reg(decoder->client, REG_OUTPUT_FORMATTER5, value);
-        dump_reg(decoder->client, REG_OUTPUT_FORMATTER6, value);
-        dump_reg(decoder->client, REG_CLEAR_LOST_LOCK, value);
+        dump_reg(sd, REG_INPUT_SEL);
+        dump_reg(sd, REG_AFE_GAIN_CTRL);
+        dump_reg(sd, REG_VIDEO_STD);
+        dump_reg(sd, REG_OPERATION_MODE);
+        dump_reg(sd, REG_COLOR_KILLER);
+        dump_reg(sd, REG_LUMA_CONTROL1);
+        dump_reg(sd, REG_LUMA_CONTROL2);
+        dump_reg(sd, REG_LUMA_CONTROL3);
+        dump_reg(sd, REG_BRIGHTNESS);
+        dump_reg(sd, REG_CONTRAST);
+        dump_reg(sd, REG_SATURATION);
+        dump_reg(sd, REG_HUE);
+        dump_reg(sd, REG_CHROMA_CONTROL1);
+        dump_reg(sd, REG_CHROMA_CONTROL2);
+        dump_reg(sd, REG_COMP_PR_SATURATION);
+        dump_reg(sd, REG_COMP_Y_CONTRAST);
+        dump_reg(sd, REG_COMP_PB_SATURATION);
+        dump_reg(sd, REG_COMP_Y_BRIGHTNESS);
+        dump_reg(sd, REG_AVID_START_PIXEL_LSB);
+        dump_reg(sd, REG_AVID_START_PIXEL_MSB);
+        dump_reg(sd, REG_AVID_STOP_PIXEL_LSB);
+        dump_reg(sd, REG_AVID_STOP_PIXEL_MSB);
+        dump_reg(sd, REG_HSYNC_START_PIXEL_LSB);
+        dump_reg(sd, REG_HSYNC_START_PIXEL_MSB);
+        dump_reg(sd, REG_HSYNC_STOP_PIXEL_LSB);
+        dump_reg(sd, REG_HSYNC_STOP_PIXEL_MSB);
+        dump_reg(sd, REG_VSYNC_START_LINE_LSB);
+        dump_reg(sd, REG_VSYNC_START_LINE_MSB);
+        dump_reg(sd, REG_VSYNC_STOP_LINE_LSB);
+        dump_reg(sd, REG_VSYNC_STOP_LINE_MSB);
+        dump_reg(sd, REG_VBLK_START_LINE_LSB);
+        dump_reg(sd, REG_VBLK_START_LINE_MSB);
+        dump_reg(sd, REG_VBLK_STOP_LINE_LSB);
+        dump_reg(sd, REG_VBLK_STOP_LINE_MSB);
+        dump_reg(sd, REG_SYNC_CONTROL);
+        dump_reg(sd, REG_OUTPUT_FORMATTER1);
+        dump_reg(sd, REG_OUTPUT_FORMATTER2);
+        dump_reg(sd, REG_OUTPUT_FORMATTER3);
+        dump_reg(sd, REG_OUTPUT_FORMATTER4);
+        dump_reg(sd, REG_OUTPUT_FORMATTER5);
+        dump_reg(sd, REG_OUTPUT_FORMATTER6);
+        dump_reg(sd, REG_CLEAR_LOST_LOCK);
 }
 
-/*
- * Configure the TVP5146/47 with the current register settings
+/**
+ * tvp514x_configure() - Configure the TVP5146/47 registers
+ * @sd: ptr to v4l2_subdev struct
+ * @decoder: ptr to tvp514x_decoder structure
+ *
  * Returns zero if successful, or non-zero otherwise.
  */
-static int tvp514x_configure(struct tvp514x_decoder *decoder)
+static int tvp514x_configure(struct v4l2_subdev *sd,
+                struct tvp514x_decoder *decoder)
 {
         int err;
 
         /* common register initialization */
         err =
-            tvp514x_write_regs(decoder->client, decoder->tvp514x_regs);
+            tvp514x_write_regs(sd, decoder->tvp514x_regs);
         if (err)
                 return err;
 
         if (debug)
-                tvp514x_reg_dump(decoder);
+                tvp514x_reg_dump(sd);
 
         return 0;
 }
 
-/*
- * Detect if an tvp514x is present, and if so which revision.
+/**
+ * tvp514x_detect() - Detect if an tvp514x is present, and if so which revision.
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @decoder: pointer to tvp514x_decoder structure
+ *
  * A device is considered to be detected if the chip ID (LSB and MSB)
  * registers match the expected values.
  * Any value of the rom version register is accepted.
  * Returns ENODEV error number if no device is detected, or zero
  * if a device is detected.
  */
-static int tvp514x_detect(struct tvp514x_decoder *decoder)
+static int tvp514x_detect(struct v4l2_subdev *sd,
+                struct tvp514x_decoder *decoder)
 {
         u8 chip_id_msb, chip_id_lsb, rom_ver;
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        chip_id_msb = tvp514x_read_reg(decoder->client, REG_CHIP_ID_MSB);
-        chip_id_lsb = tvp514x_read_reg(decoder->client, REG_CHIP_ID_LSB);
-        rom_ver = tvp514x_read_reg(decoder->client, REG_ROM_VERSION);
+        chip_id_msb = tvp514x_read_reg(sd, REG_CHIP_ID_MSB);
+        chip_id_lsb = tvp514x_read_reg(sd, REG_CHIP_ID_LSB);
+        rom_ver = tvp514x_read_reg(sd, REG_ROM_VERSION);
 
-        v4l_dbg(1, debug, decoder->client,
+        v4l2_dbg(1, debug, sd,
                  "chip id detected msb:0x%x lsb:0x%x rom version:0x%x\n",
                  chip_id_msb, chip_id_lsb, rom_ver);
         if ((chip_id_msb != TVP514X_CHIP_ID_MSB)
@@ -462,38 +496,30 @@ static int tvp514x_detect(struct tvp514x_decoder *decoder)
                 /* We didn't read the values we expected, so this must not be
                  * an TVP5146/47.
                  */
-                v4l_err(decoder->client,
-                        "chip id mismatch msb:0x%x lsb:0x%x\n",
-                        chip_id_msb, chip_id_lsb);
+                v4l2_err(sd, "chip id mismatch msb:0x%x lsb:0x%x\n",
+                                chip_id_msb, chip_id_lsb);
                 return -ENODEV;
         }
 
         decoder->ver = rom_ver;
-        decoder->state = STATE_DETECTED;
 
-        v4l_info(decoder->client,
-                        "%s found at 0x%x (%s)\n", decoder->client->name,
-                        decoder->client->addr << 1,
-                        decoder->client->adapter->name);
+        v4l2_info(sd, "%s (Version - 0x%.2x) found at 0x%x (%s)\n",
+                        client->name, decoder->ver,
+                        client->addr << 1, client->adapter->name);
         return 0;
 }
 
-/*
- * Following are decoder interface functions implemented by
- * TVP5146/47 decoder driver.
- */
-
 /**
- * ioctl_querystd - V4L2 decoder interface handler for VIDIOC_QUERYSTD ioctl
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_querystd() - V4L2 decoder interface handler for querystd
+ * @sd: pointer to standard V4L2 sub-device structure
  * @std_id: standard V4L2 std_id ioctl enum
  *
  * Returns the current standard detected by TVP5146/47. If no active input is
  * detected, returns -EINVAL
  */
-static int ioctl_querystd(struct v4l2_int_device *s, v4l2_std_id *std_id)
+static int tvp514x_querystd(struct v4l2_subdev *sd, v4l2_std_id *std_id)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
         enum tvp514x_std current_std;
         enum tvp514x_input input_sel;
         u8 sync_lock_status, lock_mask;
@@ -502,11 +528,11 @@ static int ioctl_querystd(struct v4l2_int_device *s, v4l2_std_id *std_id)
                 return -EINVAL;
 
         /* get the current standard */
-        current_std = tvp514x_get_current_std(decoder);
+        current_std = tvp514x_get_current_std(sd);
         if (current_std == STD_INVALID)
                 return -EINVAL;
 
-        input_sel = decoder->route.input;
+        input_sel = decoder->input;
 
         switch (input_sel) {
         case INPUT_CVBS_VI1A:
@@ -544,42 +570,39 @@ static int ioctl_querystd(struct v4l2_int_device *s, v4l2_std_id *std_id)
                 return -EINVAL;
         }
         /* check whether signal is locked */
-        sync_lock_status = tvp514x_read_reg(decoder->client, REG_STATUS1);
+        sync_lock_status = tvp514x_read_reg(sd, REG_STATUS1);
         if (lock_mask != (sync_lock_status & lock_mask))
                 return -EINVAL; /* No input detected */
 
         decoder->current_std = current_std;
         *std_id = decoder->std_list[current_std].standard.id;
 
-        v4l_dbg(1, debug, decoder->client, "Current STD: %s",
+        v4l2_dbg(1, debug, sd, "Current STD: %s",
                         decoder->std_list[current_std].standard.name);
         return 0;
 }
 
 /**
- * ioctl_s_std - V4L2 decoder interface handler for VIDIOC_S_STD ioctl
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_s_std() - V4L2 decoder interface handler for s_std
+ * @sd: pointer to standard V4L2 sub-device structure
  * @std_id: standard V4L2 v4l2_std_id ioctl enum
  *
  * If std_id is supported, sets the requested standard. Otherwise, returns
  * -EINVAL
  */
-static int ioctl_s_std(struct v4l2_int_device *s, v4l2_std_id *std_id)
+static int tvp514x_s_std(struct v4l2_subdev *sd, v4l2_std_id std_id)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
         int err, i;
 
-        if (std_id == NULL)
-                return -EINVAL;
-
         for (i = 0; i < decoder->num_stds; i++)
-                if (*std_id & decoder->std_list[i].standard.id)
+                if (std_id & decoder->std_list[i].standard.id)
                         break;
 
         if ((i == decoder->num_stds) || (i == STD_INVALID))
                 return -EINVAL;
 
-        err = tvp514x_write_reg(decoder->client, REG_VIDEO_STD,
+        err = tvp514x_write_reg(sd, REG_VIDEO_STD,
                                 decoder->std_list[i].video_std);
         if (err)
                 return err;
@@ -588,24 +611,26 @@ static int ioctl_s_std(struct v4l2_int_device *s, v4l2_std_id *std_id)
         decoder->tvp514x_regs[REG_VIDEO_STD].val =
                 decoder->std_list[i].video_std;
 
-        v4l_dbg(1, debug, decoder->client, "Standard set to: %s",
+        v4l2_dbg(1, debug, sd, "Standard set to: %s",
                         decoder->std_list[i].standard.name);
         return 0;
 }
 
 /**
- * ioctl_s_routing - V4L2 decoder interface handler for VIDIOC_S_INPUT ioctl
- * @s: pointer to standard V4L2 device structure
- * @index: number of the input
+ * tvp514x_s_routing() - V4L2 decoder interface handler for s_routing
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @input: input selector for routing the signal
+ * @output: output selector for routing the signal
+ * @config: config value. Not used
  *
  * If index is valid, selects the requested input. Otherwise, returns -EINVAL if
  * the input is not supported or there is no active signal present in the
  * selected input.
  */
-static int ioctl_s_routing(struct v4l2_int_device *s,
-                                struct v4l2_routing *route)
+static int tvp514x_s_routing(struct v4l2_subdev *sd,
+                                u32 input, u32 output, u32 config)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
         int err;
         enum tvp514x_input input_sel;
         enum tvp514x_output output_sel;
@@ -613,20 +638,21 @@ static int ioctl_s_routing(struct v4l2_int_device *s,
         u8 sync_lock_status, lock_mask;
         int try_count = LOCK_RETRY_COUNT;
 
-        if ((!route) || (route->input >= INPUT_INVALID) ||
-                        (route->output >= OUTPUT_INVALID))
-                return -EINVAL; /* Index out of bound */
+        if ((input >= INPUT_INVALID) ||
+                        (output >= OUTPUT_INVALID))
+                /* Index out of bound */
+                return -EINVAL;
 
-        input_sel = route->input;
-        output_sel = route->output;
+        input_sel = input;
+        output_sel = output;
 
-        err = tvp514x_write_reg(decoder->client, REG_INPUT_SEL, input_sel);
+        err = tvp514x_write_reg(sd, REG_INPUT_SEL, input_sel);
         if (err)
                 return err;
 
-        output_sel |= tvp514x_read_reg(decoder->client,
+        output_sel |= tvp514x_read_reg(sd,
                         REG_OUTPUT_FORMATTER1) & 0x7;
-        err = tvp514x_write_reg(decoder->client, REG_OUTPUT_FORMATTER1,
+        err = tvp514x_write_reg(sd, REG_OUTPUT_FORMATTER1,
                         output_sel);
         if (err)
                 return err;
@@ -637,7 +663,7 @@ static int ioctl_s_routing(struct v4l2_int_device *s,
         /* Clear status */
         msleep(LOCK_RETRY_DELAY);
         err =
-            tvp514x_write_reg(decoder->client, REG_CLEAR_LOST_LOCK, 0x01);
+            tvp514x_write_reg(sd, REG_CLEAR_LOST_LOCK, 0x01);
         if (err)
                 return err;
 
@@ -672,7 +698,7 @@ static int ioctl_s_routing(struct v4l2_int_device *s,
                 lock_mask = STATUS_HORZ_SYNC_LOCK_BIT |
                         STATUS_VIRT_SYNC_LOCK_BIT;
                 break;
-        /*Need to add other interfaces*/
+        /* Need to add other interfaces*/
         default:
                 return -EINVAL;
         }
@@ -682,42 +708,41 @@ static int ioctl_s_routing(struct v4l2_int_device *s,
                 msleep(LOCK_RETRY_DELAY);
 
                 /* get the current standard for future reference */
-                current_std = tvp514x_get_current_std(decoder);
+                current_std = tvp514x_get_current_std(sd);
                 if (current_std == STD_INVALID)
                         continue;
 
-                sync_lock_status = tvp514x_read_reg(decoder->client,
+                sync_lock_status = tvp514x_read_reg(sd,
                                 REG_STATUS1);
                 if (lock_mask == (sync_lock_status & lock_mask))
-                        break;  /* Input detected */
+                        /* Input detected */
+                        break;
         }
 
         if ((current_std == STD_INVALID) || (try_count < 0))
                 return -EINVAL;
 
         decoder->current_std = current_std;
-        decoder->route.input = route->input;
-        decoder->route.output = route->output;
+        decoder->input = input;
+        decoder->output = output;
 
-        v4l_dbg(1, debug, decoder->client,
-                        "Input set to: %d, std : %d",
+        v4l2_dbg(1, debug, sd, "Input set to: %d, std : %d",
                         input_sel, current_std);
 
         return 0;
 }
 
 /**
- * ioctl_queryctrl - V4L2 decoder interface handler for VIDIOC_QUERYCTRL ioctl
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_queryctrl() - V4L2 decoder interface handler for queryctrl
+ * @sd: pointer to standard V4L2 sub-device structure
  * @qctrl: standard V4L2 v4l2_queryctrl structure
  *
  * If the requested control is supported, returns the control information.
  * Otherwise, returns -EINVAL if the control is not supported.
  */
 static int
-ioctl_queryctrl(struct v4l2_int_device *s, struct v4l2_queryctrl *qctrl)
+tvp514x_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qctrl)
 {
-        struct tvp514x_decoder *decoder = s->priv;
         int err = -EINVAL;
 
         if (qctrl == NULL)
@@ -725,13 +750,13 @@ ioctl_queryctrl(struct v4l2_int_device *s, struct v4l2_queryctrl *qctrl)
 
         switch (qctrl->id) {
         case V4L2_CID_BRIGHTNESS:
-                /* Brightness supported is (0-255),
-                 */
+                /* Brightness supported is (0-255), */
                 err = v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
                 break;
         case V4L2_CID_CONTRAST:
         case V4L2_CID_SATURATION:
-                /* Saturation and Contrast supported is -
+                /**
+                 * Saturation and Contrast supported is -
                  *      Contrast: 0 - 255 (Default - 128)
                  *      Saturation: 0 - 255 (Default - 128)
                  */
@@ -744,30 +769,27 @@ ioctl_queryctrl(struct v4l2_int_device *s, struct v4l2_queryctrl *qctrl)
                 err = v4l2_ctrl_query_fill(qctrl, -180, 180, 180, 0);
                 break;
         case V4L2_CID_AUTOGAIN:
-                /* Autogain is either 0 or 1*/
-                memcpy(qctrl, &tvp514x_autogain_ctrl,
-                                sizeof(struct v4l2_queryctrl));
-                err = 0;
+                /**
+                 * Auto Gain supported is -
+                 *      0 - 1 (Default - 1)
+                 */
+                err = v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
                 break;
         default:
-                v4l_err(decoder->client,
-                        "invalid control id %d\n", qctrl->id);
+                v4l2_err(sd, "invalid control id %d\n", qctrl->id);
                 return err;
         }
 
-        v4l_dbg(1, debug, decoder->client,
-                        "Query Control: %s : Min - %d, Max - %d, Def - %d",
-                        qctrl->name,
-                        qctrl->minimum,
-                        qctrl->maximum,
+        v4l2_dbg(1, debug, sd, "Query Control:%s: Min - %d, Max - %d, Def - %d",
+                        qctrl->name, qctrl->minimum, qctrl->maximum,
                         qctrl->default_value);
 
         return err;
 }
 
 /**
- * ioctl_g_ctrl - V4L2 decoder interface handler for VIDIOC_G_CTRL ioctl
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_g_ctrl() - V4L2 decoder interface handler for g_ctrl
+ * @sd: pointer to standard V4L2 sub-device structure
  * @ctrl: pointer to v4l2_control structure
  *
  * If the requested control is supported, returns the control's current
@@ -775,9 +797,9 @@ ioctl_queryctrl(struct v4l2_int_device *s, struct v4l2_queryctrl *qctrl)
  * supported.
  */
 static int
-ioctl_g_ctrl(struct v4l2_int_device *s, struct v4l2_control *ctrl)
+tvp514x_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
 
         if (ctrl == NULL)
                 return -EINVAL;
@@ -811,74 +833,70 @@ ioctl_g_ctrl(struct v4l2_int_device *s, struct v4l2_control *ctrl)
 
                 break;
         default:
-                v4l_err(decoder->client,
-                        "invalid control id %d\n", ctrl->id);
+                v4l2_err(sd, "invalid control id %d\n", ctrl->id);
                 return -EINVAL;
         }
 
-        v4l_dbg(1, debug, decoder->client,
-                        "Get Control: ID - %d - %d",
+        v4l2_dbg(1, debug, sd, "Get Control: ID - %d - %d",
                         ctrl->id, ctrl->value);
         return 0;
 }
 
 /**
- * ioctl_s_ctrl - V4L2 decoder interface handler for VIDIOC_S_CTRL ioctl
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_s_ctrl() - V4L2 decoder interface handler for s_ctrl
+ * @sd: pointer to standard V4L2 sub-device structure
  * @ctrl: pointer to v4l2_control structure
  *
  * If the requested control is supported, sets the control's current
  * value in HW. Otherwise, returns -EINVAL if the control is not supported.
  */
 static int
-ioctl_s_ctrl(struct v4l2_int_device *s, struct v4l2_control *ctrl)
+tvp514x_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
         int err = -EINVAL, value;
 
         if (ctrl == NULL)
                 return err;
 
-        value = (__s32) ctrl->value;
+        value = ctrl->value;
 
         switch (ctrl->id) {
         case V4L2_CID_BRIGHTNESS:
                 if (ctrl->value < 0 || ctrl->value > 255) {
-                        v4l_err(decoder->client,
-                                        "invalid brightness setting %d\n",
+                        v4l2_err(sd, "invalid brightness setting %d\n",
                                         ctrl->value);
                         return -ERANGE;
                 }
-                err = tvp514x_write_reg(decoder->client, REG_BRIGHTNESS,
+                err = tvp514x_write_reg(sd, REG_BRIGHTNESS,
                                 value);
                 if (err)
                         return err;
+
                 decoder->tvp514x_regs[REG_BRIGHTNESS].val = value;
                 break;
         case V4L2_CID_CONTRAST:
                 if (ctrl->value < 0 || ctrl->value > 255) {
-                        v4l_err(decoder->client,
-                                        "invalid contrast setting %d\n",
+                        v4l2_err(sd, "invalid contrast setting %d\n",
                                         ctrl->value);
                         return -ERANGE;
                 }
-                err = tvp514x_write_reg(decoder->client, REG_CONTRAST,
-                                value);
+                err = tvp514x_write_reg(sd, REG_CONTRAST, value);
                 if (err)
                         return err;
+
                 decoder->tvp514x_regs[REG_CONTRAST].val = value;
                 break;
         case V4L2_CID_SATURATION:
                 if (ctrl->value < 0 || ctrl->value > 255) {
-                        v4l_err(decoder->client,
-                                        "invalid saturation setting %d\n",
+                        v4l2_err(sd, "invalid saturation setting %d\n",
                                         ctrl->value);
                         return -ERANGE;
                 }
-                err = tvp514x_write_reg(decoder->client, REG_SATURATION,
-                                value);
+                err = tvp514x_write_reg(sd, REG_SATURATION, value);
                 if (err)
                         return err;
+
                 decoder->tvp514x_regs[REG_SATURATION].val = value;
                 break;
         case V4L2_CID_HUE:
@@ -889,15 +907,13 @@ ioctl_s_ctrl(struct v4l2_int_device *s, struct v4l2_control *ctrl)
                 else if (value == 0)
                         value = 0;
                 else {
-                        v4l_err(decoder->client,
-                                        "invalid hue setting %d\n",
-                                        ctrl->value);
+                        v4l2_err(sd, "invalid hue setting %d\n", ctrl->value);
                         return -ERANGE;
                 }
-                err = tvp514x_write_reg(decoder->client, REG_HUE,
-                                value);
+                err = tvp514x_write_reg(sd, REG_HUE, value);
                 if (err)
                         return err;
+
                 decoder->tvp514x_regs[REG_HUE].val = value;
                 break;
         case V4L2_CID_AUTOGAIN:
@@ -906,41 +922,38 @@ ioctl_s_ctrl(struct v4l2_int_device *s, struct v4l2_control *ctrl)
                 else if (value == 0)
                         value = 0x0C;
                 else {
-                        v4l_err(decoder->client,
-                                        "invalid auto gain setting %d\n",
+                        v4l2_err(sd, "invalid auto gain setting %d\n",
                                         ctrl->value);
                         return -ERANGE;
                 }
-                err = tvp514x_write_reg(decoder->client, REG_AFE_GAIN_CTRL,
-                                value);
+                err = tvp514x_write_reg(sd, REG_AFE_GAIN_CTRL, value);
                 if (err)
                         return err;
+
                 decoder->tvp514x_regs[REG_AFE_GAIN_CTRL].val = value;
                 break;
         default:
-                v4l_err(decoder->client,
-                        "invalid control id %d\n", ctrl->id);
+                v4l2_err(sd, "invalid control id %d\n", ctrl->id);
                 return err;
         }
 
-        v4l_dbg(1, debug, decoder->client,
-                        "Set Control: ID - %d - %d",
+        v4l2_dbg(1, debug, sd, "Set Control: ID - %d - %d",
                         ctrl->id, ctrl->value);
 
         return err;
 }
 
 /**
- * ioctl_enum_fmt_cap - Implement the CAPTURE buffer VIDIOC_ENUM_FMT ioctl
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_enum_fmt_cap() - V4L2 decoder interface handler for enum_fmt
+ * @sd: pointer to standard V4L2 sub-device structure
  * @fmt: standard V4L2 VIDIOC_ENUM_FMT ioctl structure
  *
  * Implement the VIDIOC_ENUM_FMT ioctl to enumerate supported formats
  */
 static int
-ioctl_enum_fmt_cap(struct v4l2_int_device *s, struct v4l2_fmtdesc *fmt)
+tvp514x_enum_fmt_cap(struct v4l2_subdev *sd, struct v4l2_fmtdesc *fmt)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
         int index;
 
         if (fmt == NULL)
@@ -948,24 +961,25 @@ ioctl_enum_fmt_cap(struct v4l2_int_device *s, struct v4l2_fmtdesc *fmt)
 
         index = fmt->index;
         if ((index >= decoder->num_fmts) || (index < 0))
-                return -EINVAL; /* Index out of bound */
+                /* Index out of bound */
+                return -EINVAL;
 
         if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return -EINVAL; /* only capture is supported */
+                /* only capture is supported */
+                return -EINVAL;
 
         memcpy(fmt, &decoder->fmt_list[index],
                 sizeof(struct v4l2_fmtdesc));
 
-        v4l_dbg(1, debug, decoder->client,
-                        "Current FMT: index - %d (%s)",
+        v4l2_dbg(1, debug, sd, "Current FMT: index - %d (%s)",
                         decoder->fmt_list[index].index,
                         decoder->fmt_list[index].description);
         return 0;
 }
 
 /**
- * ioctl_try_fmt_cap - Implement the CAPTURE buffer VIDIOC_TRY_FMT ioctl
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_try_fmt_cap() - V4L2 decoder interface handler for try_fmt
+ * @sd: pointer to standard V4L2 sub-device structure
  * @f: pointer to standard V4L2 VIDIOC_TRY_FMT ioctl structure
  *
  * Implement the VIDIOC_TRY_FMT ioctl for the CAPTURE buffer type. This
@@ -973,9 +987,9 @@ ioctl_enum_fmt_cap(struct v4l2_int_device *s, struct v4l2_fmtdesc *fmt)
  * without actually making it take effect.
  */
 static int
-ioctl_try_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
+tvp514x_try_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
         int ifmt;
         struct v4l2_pix_format *pix;
         enum tvp514x_std current_std;
@@ -984,12 +998,13 @@ ioctl_try_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
                 return -EINVAL;
 
         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                /* only capture is supported */
                 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
         pix = &f->fmt.pix;
 
         /* Calculate height and width based on current standard */
-        current_std = tvp514x_get_current_std(decoder);
+        current_std = tvp514x_get_current_std(sd);
         if (current_std == STD_INVALID)
                 return -EINVAL;
 
@@ -1003,7 +1018,8 @@ ioctl_try_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
                         break;
         }
         if (ifmt == decoder->num_fmts)
-                ifmt = 0;       /* None of the format matched, select default */
+                /* None of the format matched, select default */
+                ifmt = 0;
         pix->pixelformat = decoder->fmt_list[ifmt].pixelformat;
 
         pix->field = V4L2_FIELD_INTERLACED;
@@ -1012,8 +1028,7 @@ ioctl_try_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
         pix->colorspace = V4L2_COLORSPACE_SMPTE170M;
         pix->priv = 0;
 
-        v4l_dbg(1, debug, decoder->client,
-                        "Try FMT: pixelformat - %s, bytesperline - %d"
+        v4l2_dbg(1, debug, sd, "Try FMT: pixelformat - %s, bytesperline - %d"
                         "Width - %d, Height - %d",
                         decoder->fmt_list[ifmt].description, pix->bytesperline,
                         pix->width, pix->height);
@@ -1021,8 +1036,8 @@ ioctl_try_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
 }
 
 /**
- * ioctl_s_fmt_cap - V4L2 decoder interface handler for VIDIOC_S_FMT ioctl
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_s_fmt_cap() - V4L2 decoder interface handler for s_fmt
+ * @sd: pointer to standard V4L2 sub-device structure
  * @f: pointer to standard V4L2 VIDIOC_S_FMT ioctl structure
  *
  * If the requested format is supported, configures the HW to use that
@@ -1030,9 +1045,9 @@ ioctl_try_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
  * correctly configured.
  */
 static int
-ioctl_s_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
+tvp514x_s_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
         struct v4l2_pix_format *pix;
         int rval;
 
@@ -1040,10 +1055,11 @@ ioctl_s_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
                 return -EINVAL;
 
         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return -EINVAL; /* only capture is supported */
+                /* only capture is supported */
+                return -EINVAL;
 
         pix = &f->fmt.pix;
-        rval = ioctl_try_fmt_cap(s, f);
+        rval = tvp514x_try_fmt_cap(sd, f);
         if (rval)
                 return rval;
 
@@ -1053,28 +1069,28 @@ ioctl_s_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
 }
 
 /**
- * ioctl_g_fmt_cap - V4L2 decoder interface handler for ioctl_g_fmt_cap
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_g_fmt_cap() - V4L2 decoder interface handler for tvp514x_g_fmt_cap
+ * @sd: pointer to standard V4L2 sub-device structure
  * @f: pointer to standard V4L2 v4l2_format structure
  *
  * Returns the decoder's current pixel format in the v4l2_format
  * parameter.
  */
 static int
-ioctl_g_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
+tvp514x_g_fmt_cap(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
 
         if (f == NULL)
                 return -EINVAL;
 
         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return -EINVAL; /* only capture is supported */
+                /* only capture is supported */
+                return -EINVAL;
 
         f->fmt.pix = decoder->pix;
 
-        v4l_dbg(1, debug, decoder->client,
-                        "Current FMT: bytesperline - %d"
+        v4l2_dbg(1, debug, sd, "Current FMT: bytesperline - %d"
                         "Width - %d, Height - %d",
                         decoder->pix.bytesperline,
                         decoder->pix.width, decoder->pix.height);
@@ -1082,16 +1098,16 @@ ioctl_g_fmt_cap(struct v4l2_int_device *s, struct v4l2_format *f)
 }
 
 /**
- * ioctl_g_parm - V4L2 decoder interface handler for VIDIOC_G_PARM ioctl
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_g_parm() - V4L2 decoder interface handler for g_parm
+ * @sd: pointer to standard V4L2 sub-device structure
  * @a: pointer to standard V4L2 VIDIOC_G_PARM ioctl structure
  *
  * Returns the decoder's video CAPTURE parameters.
  */
 static int
-ioctl_g_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a)
+tvp514x_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
         struct v4l2_captureparm *cparm;
         enum tvp514x_std current_std;
 
@@ -1099,13 +1115,14 @@ ioctl_g_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a)
                 return -EINVAL;
 
         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return -EINVAL; /* only capture is supported */
+                /* only capture is supported */
+                return -EINVAL;
 
         memset(a, 0, sizeof(*a));
         a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
         /* get the current standard */
-        current_std = tvp514x_get_current_std(decoder);
+        current_std = tvp514x_get_current_std(sd);
         if (current_std == STD_INVALID)
                 return -EINVAL;
 
@@ -1120,17 +1137,17 @@ ioctl_g_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a)
 }
 
 /**
- * ioctl_s_parm - V4L2 decoder interface handler for VIDIOC_S_PARM ioctl
- * @s: pointer to standard V4L2 device structure
+ * tvp514x_s_parm() - V4L2 decoder interface handler for s_parm
+ * @sd: pointer to standard V4L2 sub-device structure
  * @a: pointer to standard V4L2 VIDIOC_S_PARM ioctl structure
  *
  * Configures the decoder to use the input parameters, if possible. If
  * not possible, returns the appropriate error code.
  */
 static int
-ioctl_s_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a)
+tvp514x_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *a)
 {
-        struct tvp514x_decoder *decoder = s->priv;
+        struct tvp514x_decoder *decoder = to_decoder(sd);
         struct v4l2_fract *timeperframe;
         enum tvp514x_std current_std;
 
@@ -1138,12 +1155,13 @@ ioctl_s_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a)
                 return -EINVAL;
 
         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return -EINVAL; /* only capture is supported */
+                /* only capture is supported */
+                return -EINVAL;
 
         timeperframe = &a->parm.capture.timeperframe;
 
         /* get the current standard */
-        current_std = tvp514x_get_current_std(decoder);
+        current_std = tvp514x_get_current_std(sd);
         if (current_std == STD_INVALID)
                 return -EINVAL;
 
@@ -1156,111 +1174,58 @@ ioctl_s_parm(struct v4l2_int_device *s, struct v4l2_streamparm *a)
 }
 
 /**
- * ioctl_g_ifparm - V4L2 decoder interface handler for vidioc_int_g_ifparm_num
- * @s: pointer to standard V4L2 device structure
- * @p: pointer to standard V4L2 vidioc_int_g_ifparm_num ioctl structure
- *
- * Gets slave interface parameters.
- * Calculates the required xclk value to support the requested
- * clock parameters in p. This value is returned in the p
- * parameter.
- */
-static int ioctl_g_ifparm(struct v4l2_int_device *s, struct v4l2_ifparm *p)
-{
-        struct tvp514x_decoder *decoder = s->priv;
-        int rval;
-
-        if (p == NULL)
-                return -EINVAL;
-
-        if (NULL == decoder->pdata->ifparm)
-                return -EINVAL;
-
-        rval = decoder->pdata->ifparm(p);
-        if (rval) {
-                v4l_err(decoder->client, "g_ifparm.Err[%d]\n", rval);
-                return rval;
-        }
-
-        p->u.bt656.clock_curr = TVP514X_XCLK_BT656;
-
-        return 0;
-}
-
-/**
- * ioctl_g_priv - V4L2 decoder interface handler for vidioc_int_g_priv_num
- * @s: pointer to standard V4L2 device structure
- * @p: void pointer to hold decoder's private data address
- *
- * Returns device's (decoder's) private data area address in p parameter
- */
-static int ioctl_g_priv(struct v4l2_int_device *s, void *p)
-{
-        struct tvp514x_decoder *decoder = s->priv;
-
-        if (NULL == decoder->pdata->priv_data_set)
-                return -EINVAL;
-
-        return decoder->pdata->priv_data_set(p);
-}
-
-/**
- * ioctl_s_power - V4L2 decoder interface handler for vidioc_int_s_power_num
- * @s: pointer to standard V4L2 device structure
- * @on: power state to which device is to be set
+ * tvp514x_s_stream() - V4L2 decoder i/f handler for s_stream
+ * @sd: pointer to standard V4L2 sub-device structure
+ * @enable: streaming enable or disable
  *
- * Sets devices power state to requrested state, if possible.
+ * Sets streaming to enable or disable, if possible.
  */
-static int ioctl_s_power(struct v4l2_int_device *s, enum v4l2_power on)
+static int tvp514x_s_stream(struct v4l2_subdev *sd, int enable)
 {
-        struct tvp514x_decoder *decoder = s->priv;
         int err = 0;
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+        struct tvp514x_decoder *decoder = to_decoder(sd);
 
-        switch (on) {
-        case V4L2_POWER_OFF:
-                /* Power Down Sequence */
-                err =
-                    tvp514x_write_reg(decoder->client, REG_OPERATION_MODE,
-                                        0x01);
-                /* Disable mux for TVP5146/47 decoder data path */
-                if (decoder->pdata->power_set)
-                        err |= decoder->pdata->power_set(on);
-                decoder->state = STATE_NOT_DETECTED;
-                break;
+        if (decoder->streaming == enable)
+                return 0;
 
-        case V4L2_POWER_STANDBY:
-                if (decoder->pdata->power_set)
-                        err = decoder->pdata->power_set(on);
+        switch (enable) {
+        case 0:
+        {
+                /* Power Down Sequence */
+                err = tvp514x_write_reg(sd, REG_OPERATION_MODE, 0x01);
+                if (err) {
+                        v4l2_err(sd, "Unable to turn off decoder\n");
+                        return err;
+                }
+                decoder->streaming = enable;
                 break;
+        }
+        case 1:
+        {
+                struct tvp514x_reg *int_seq = (struct tvp514x_reg *)
+                                client->driver->id_table->driver_data;
 
-        case V4L2_POWER_ON:
-                /* Enable mux for TVP5146/47 decoder data path */
-                if ((decoder->pdata->power_set) &&
-                                (decoder->state == STATE_NOT_DETECTED)) {
-                        int i;
-                        struct tvp514x_init_seq *int_seq =
-                                (struct tvp514x_init_seq *)
-                                decoder->id->driver_data;
-
-                        err = decoder->pdata->power_set(on);
-
-                        /* Power Up Sequence */
-                        for (i = 0; i < int_seq->no_regs; i++) {
-                                err |= tvp514x_write_reg(decoder->client,
-                                                int_seq->init_reg_seq[i].reg,
-                                                int_seq->init_reg_seq[i].val);
-                        }
-                        /* Detect the sensor is not already detected */
-                        err |= tvp514x_detect(decoder);
-                        if (err) {
-                                v4l_err(decoder->client,
-                                                "Unable to detect decoder\n");
-                                return err;
-                        }
+                /* Power Up Sequence */
+                err = tvp514x_write_regs(sd, int_seq);
+                if (err) {
+                        v4l2_err(sd, "Unable to turn on decoder\n");
+                        return err;
                 }
-                err |= tvp514x_configure(decoder);
+                /* Detect if not already detected */
+                err = tvp514x_detect(sd, decoder);
+                if (err) {
+                        v4l2_err(sd, "Unable to detect decoder\n");
+                        return err;
+                }
+                err = tvp514x_configure(sd, decoder);
+                if (err) {
+                        v4l2_err(sd, "Unable to configure decoder\n");
+                        return err;
+                }
+                decoder->streaming = enable;
                 break;
-
+        }
         default:
                 err = -ENODEV;
                 break;
@@ -1269,93 +1234,38 @@ static int ioctl_s_power(struct v4l2_int_device *s, enum v4l2_power on)
         return err;
 }
 
-/**
- * ioctl_init - V4L2 decoder interface handler for VIDIOC_INT_INIT
- * @s: pointer to standard V4L2 device structure
- *
- * Initialize the decoder device (calls tvp514x_configure())
- */
-static int ioctl_init(struct v4l2_int_device *s)
-{
-        struct tvp514x_decoder *decoder = s->priv;
-
-        /* Set default standard to auto */
-        decoder->tvp514x_regs[REG_VIDEO_STD].val =
-            VIDEO_STD_AUTO_SWITCH_BIT;
-
-        return tvp514x_configure(decoder);
-}
-
-/**
- * ioctl_dev_exit - V4L2 decoder interface handler for vidioc_int_dev_exit_num
- * @s: pointer to standard V4L2 device structure
- *
- * Delinitialise the dev. at slave detach. The complement of ioctl_dev_init.
- */
-static int ioctl_dev_exit(struct v4l2_int_device *s)
-{
-        return 0;
-}
-
-/**
- * ioctl_dev_init - V4L2 decoder interface handler for vidioc_int_dev_init_num
- * @s: pointer to standard V4L2 device structure
- *
- * Initialise the device when slave attaches to the master. Returns 0 if
- * TVP5146/47 device could be found, otherwise returns appropriate error.
- */
-static int ioctl_dev_init(struct v4l2_int_device *s)
-{
-        struct tvp514x_decoder *decoder = s->priv;
-        int err;
-
-        err = tvp514x_detect(decoder);
-        if (err < 0) {
-                v4l_err(decoder->client,
-                        "Unable to detect decoder\n");
-                return err;
-        }
-
-        v4l_info(decoder->client,
-                 "chip version 0x%.2x detected\n", decoder->ver);
+static const struct v4l2_subdev_core_ops tvp514x_core_ops = {
+        .queryctrl = tvp514x_queryctrl,
+        .g_ctrl = tvp514x_g_ctrl,
+        .s_ctrl = tvp514x_s_ctrl,
+        .s_std = tvp514x_s_std,
+};
 
-        return 0;
-}
+static const struct v4l2_subdev_video_ops tvp514x_video_ops = {
+        .s_routing = tvp514x_s_routing,
+        .querystd = tvp514x_querystd,
+        .enum_fmt = tvp514x_enum_fmt_cap,
+        .g_fmt = tvp514x_g_fmt_cap,
+        .try_fmt = tvp514x_try_fmt_cap,
+        .s_fmt = tvp514x_s_fmt_cap,
+        .g_parm = tvp514x_g_parm,
+        .s_parm = tvp514x_s_parm,
+        .s_stream = tvp514x_s_stream,
+};
 
-static struct v4l2_int_ioctl_desc tvp514x_ioctl_desc[] = {
-        {vidioc_int_dev_init_num, (v4l2_int_ioctl_func*) ioctl_dev_init},
-        {vidioc_int_dev_exit_num, (v4l2_int_ioctl_func*) ioctl_dev_exit},
-        {vidioc_int_s_power_num, (v4l2_int_ioctl_func*) ioctl_s_power},
-        {vidioc_int_g_priv_num, (v4l2_int_ioctl_func*) ioctl_g_priv},
-        {vidioc_int_g_ifparm_num, (v4l2_int_ioctl_func*) ioctl_g_ifparm},
-        {vidioc_int_init_num, (v4l2_int_ioctl_func*) ioctl_init},
-        {vidioc_int_enum_fmt_cap_num,
-         (v4l2_int_ioctl_func *) ioctl_enum_fmt_cap},
-        {vidioc_int_try_fmt_cap_num,
-         (v4l2_int_ioctl_func *) ioctl_try_fmt_cap},
-        {vidioc_int_g_fmt_cap_num,
-         (v4l2_int_ioctl_func *) ioctl_g_fmt_cap},
-        {vidioc_int_s_fmt_cap_num,
-         (v4l2_int_ioctl_func *) ioctl_s_fmt_cap},
-        {vidioc_int_g_parm_num, (v4l2_int_ioctl_func *) ioctl_g_parm},
-        {vidioc_int_s_parm_num, (v4l2_int_ioctl_func *) ioctl_s_parm},
-        {vidioc_int_queryctrl_num,
-         (v4l2_int_ioctl_func *) ioctl_queryctrl},
-        {vidioc_int_g_ctrl_num, (v4l2_int_ioctl_func *) ioctl_g_ctrl},
-        {vidioc_int_s_ctrl_num, (v4l2_int_ioctl_func *) ioctl_s_ctrl},
-        {vidioc_int_querystd_num, (v4l2_int_ioctl_func *) ioctl_querystd},
-        {vidioc_int_s_std_num, (v4l2_int_ioctl_func *) ioctl_s_std},
-        {vidioc_int_s_video_routing_num,
-                (v4l2_int_ioctl_func *) ioctl_s_routing},
+static const struct v4l2_subdev_ops tvp514x_ops = {
+        .core = &tvp514x_core_ops,
+        .video = &tvp514x_video_ops,
 };
 
 static struct tvp514x_decoder tvp514x_dev = {
-        .state = STATE_NOT_DETECTED,
+        .streaming = 0,
 
         .fmt_list = tvp514x_fmt_list,
         .num_fmts = ARRAY_SIZE(tvp514x_fmt_list),
 
-        .pix = {                /* Default to NTSC 8-bit YUV 422 */
+        .pix = {
+                /* Default to NTSC 8-bit YUV 422 */
                 .width = NTSC_NUM_ACTIVE_PIXELS,
                 .height = NTSC_NUM_ACTIVE_LINES,
                 .pixelformat = V4L2_PIX_FMT_UYVY,
@@ -1369,20 +1279,13 @@ static struct tvp514x_decoder tvp514x_dev = {
         .current_std = STD_NTSC_MJ,
         .std_list = tvp514x_std_list,
         .num_stds = ARRAY_SIZE(tvp514x_std_list),
-        .v4l2_int_device = {
-                .module = THIS_MODULE,
-                .name = TVP514X_MODULE_NAME,
-                .type = v4l2_int_type_slave,
-        },
-        .tvp514x_slave = {
-                .ioctls = tvp514x_ioctl_desc,
-                .num_ioctls = ARRAY_SIZE(tvp514x_ioctl_desc),
-        },
+
 };
 
 /**
- * tvp514x_probe - decoder driver i2c probe handler
+ * tvp514x_probe() - decoder driver i2c probe handler
  * @client: i2c driver client device structure
+ * @id: i2c driver id table
  *
  * Register decoder as an i2c client device and V4L2
  * device.
@@ -1391,88 +1294,71 @@ static int
 tvp514x_probe(struct i2c_client *client, const struct i2c_device_id *id)
 {
         struct tvp514x_decoder *decoder;
-        int err;
+        struct v4l2_subdev *sd;
 
         /* Check if the adapter supports the needed features */
         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                 return -EIO;
 
+        if (!client->dev.platform_data) {
+                v4l2_err(client, "No platform data!!\n");
+                return -ENODEV;
+        }
+
         decoder = kzalloc(sizeof(*decoder), GFP_KERNEL);
         if (!decoder)
                 return -ENOMEM;
 
-        if (!client->dev.platform_data) {
-                v4l_err(client, "No platform data!!\n");
-                err = -ENODEV;
-                goto out_free;
-        }
-
+        /* Initialize the tvp514x_decoder with default configuration */
         *decoder = tvp514x_dev;
-        decoder->v4l2_int_device.priv = decoder;
-        decoder->pdata = client->dev.platform_data;
-        decoder->v4l2_int_device.u.slave = &decoder->tvp514x_slave;
+        /* Copy default register configuration */
         memcpy(decoder->tvp514x_regs, tvp514x_reg_list_default,
                         sizeof(tvp514x_reg_list_default));
-        /*
+
+        /* Copy board specific information here */
+        decoder->pdata = client->dev.platform_data;
+
+        /**
          * Fetch platform specific data, and configure the
          * tvp514x_reg_list[] accordingly. Since this is one
          * time configuration, no need to preserve.
          */
         decoder->tvp514x_regs[REG_OUTPUT_FORMATTER2].val |=
-                        (decoder->pdata->clk_polarity << 1);
+                (decoder->pdata->clk_polarity << 1);
         decoder->tvp514x_regs[REG_SYNC_CONTROL].val |=
-                        ((decoder->pdata->hs_polarity << 2) |
-                        (decoder->pdata->vs_polarity << 3));
-        /*
-         * Save the id data, required for power up sequence
-         */
-        decoder->id = (struct i2c_device_id *)id;
-        /* Attach to Master */
-        strcpy(decoder->v4l2_int_device.u.slave->attach_to,
-                        decoder->pdata->master);
-        decoder->client = client;
-        i2c_set_clientdata(client, decoder);
+                ((decoder->pdata->hs_polarity << 2) |
+                 (decoder->pdata->vs_polarity << 3));
+        /* Set default standard to auto */
+        decoder->tvp514x_regs[REG_VIDEO_STD].val =
+                VIDEO_STD_AUTO_SWITCH_BIT;
 
         /* Register with V4L2 layer as slave device */
-        err = v4l2_int_device_register(&decoder->v4l2_int_device);
-        if (err) {
-                i2c_set_clientdata(client, NULL);
-                v4l_err(client,
-                        "Unable to register to v4l2. Err[%d]\n", err);
-                goto out_free;
-
-        } else
-                v4l_info(client, "Registered to v4l2 master %s!!\n",
-                                decoder->pdata->master);
+        sd = &decoder->sd;
+        v4l2_i2c_subdev_init(sd, client, &tvp514x_ops);
+
+        v4l2_info(sd, "%s decoder driver registered !!\n", sd->name);
+
         return 0;
 
-out_free:
-        kfree(decoder);
-        return err;
 }
 
 /**
- * tvp514x_remove - decoder driver i2c remove handler
+ * tvp514x_remove() - decoder driver i2c remove handler
  * @client: i2c driver client device structure
  *
  * Unregister decoder as an i2c client device and V4L2
  * device. Complement of tvp514x_probe().
  */
-static int __exit tvp514x_remove(struct i2c_client *client)
+static int tvp514x_remove(struct i2c_client *client)
 {
-        struct tvp514x_decoder *decoder = i2c_get_clientdata(client);
-
-        if (!client->adapter)
-                return -ENODEV; /* our client isn't attached */
+        struct v4l2_subdev *sd = i2c_get_clientdata(client);
+        struct tvp514x_decoder *decoder = to_decoder(sd);
 
-        v4l2_int_device_unregister(&decoder->v4l2_int_device);
-        i2c_set_clientdata(client, NULL);
+        v4l2_device_unregister_subdev(sd);
         kfree(decoder);
         return 0;
 }
-/*
- * TVP5146 Init/Power on Sequence
- */
+/* TVP5146 Init/Power on Sequence */
 static const struct tvp514x_reg tvp5146_init_reg_seq[] = {
         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x02},
         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
@@ -1485,14 +1371,10 @@ static const struct tvp514x_reg tvp5146_init_reg_seq[] = {
         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
+        {TOK_TERM, 0, 0},
 };
-static const struct tvp514x_init_seq tvp5146_init = {
-        .no_regs = ARRAY_SIZE(tvp5146_init_reg_seq),
-        .init_reg_seq = tvp5146_init_reg_seq,
-};
-/*
- * TVP5147 Init/Power on Sequence
- */
+
+/* TVP5147 Init/Power on Sequence */
 static const struct tvp514x_reg tvp5147_init_reg_seq[] =        {
         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS1, 0x02},
         {TOK_WRITE, REG_VBUS_ADDRESS_ACCESS2, 0x00},
@@ -1512,71 +1394,51 @@ static const struct tvp514x_reg tvp5147_init_reg_seq[] =	{
         {TOK_WRITE, REG_VBUS_DATA_ACCESS_NO_VBUS_ADDR_INCR, 0x00},
         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
+        {TOK_TERM, 0, 0},
 };
-static const struct tvp514x_init_seq tvp5147_init = {
-        .no_regs = ARRAY_SIZE(tvp5147_init_reg_seq),
-        .init_reg_seq = tvp5147_init_reg_seq,
-};
-/*
- * TVP5146M2/TVP5147M1 Init/Power on Sequence
- */
+
+/* TVP5146M2/TVP5147M1 Init/Power on Sequence */
 static const struct tvp514x_reg tvp514xm_init_reg_seq[] = {
         {TOK_WRITE, REG_OPERATION_MODE, 0x01},
         {TOK_WRITE, REG_OPERATION_MODE, 0x00},
+        {TOK_TERM, 0, 0},
 };
-static const struct tvp514x_init_seq tvp514xm_init = {
-        .no_regs = ARRAY_SIZE(tvp514xm_init_reg_seq),
-        .init_reg_seq = tvp514xm_init_reg_seq,
-};
-/*
+
+/**
  * I2C Device Table -
  *
  * name - Name of the actual device/chip.
  * driver_data - Driver data
  */
 static const struct i2c_device_id tvp514x_id[] = {
-        {"tvp5146", (unsigned long)&tvp5146_init},
-        {"tvp5146m2", (unsigned long)&tvp514xm_init},
-        {"tvp5147", (unsigned long)&tvp5147_init},
-        {"tvp5147m1", (unsigned long)&tvp514xm_init},
+        {"tvp5146", (unsigned long)tvp5146_init_reg_seq},
+        {"tvp5146m2", (unsigned long)tvp514xm_init_reg_seq},
+        {"tvp5147", (unsigned long)tvp5147_init_reg_seq},
+        {"tvp5147m1", (unsigned long)tvp514xm_init_reg_seq},
         {},
 };
 
 MODULE_DEVICE_TABLE(i2c, tvp514x_id);
 
-static struct i2c_driver tvp514x_i2c_driver = {
+static struct i2c_driver tvp514x_driver = {
         .driver = {
-                   .name = TVP514X_MODULE_NAME,
-                   .owner = THIS_MODULE,
-                   },
+                .owner = THIS_MODULE,
+                .name = TVP514X_MODULE_NAME,
+        },
         .probe = tvp514x_probe,
-        .remove = __exit_p(tvp514x_remove),
+        .remove = tvp514x_remove,
         .id_table = tvp514x_id,
 };
 
-/**
- * tvp514x_init
- *
- * Module init function
- */
 static int __init tvp514x_init(void)
 {
-        return i2c_add_driver(&tvp514x_i2c_driver);
+        return i2c_add_driver(&tvp514x_driver);
 }
 
-/**
- * tvp514x_cleanup
- *
- * Module exit function
- */
-static void __exit tvp514x_cleanup(void)
+static void __exit tvp514x_exit(void)
 {
-        i2c_del_driver(&tvp514x_i2c_driver);
+        i2c_del_driver(&tvp514x_driver);
 }
 
 module_init(tvp514x_init);
-module_exit(tvp514x_cleanup);
-
-MODULE_AUTHOR("Texas Instruments");
-MODULE_DESCRIPTION("TVP514X linux decoder driver");
-MODULE_LICENSE("GPL");
+module_exit(tvp514x_exit);
diff --git a/drivers/media/video/tvp514x_regs.h b/drivers/media/video/tvp514x_regs.h
index 351620aeecc2..18f29ad0dfe2 100644
--- a/drivers/media/video/tvp514x_regs.h
+++ b/drivers/media/video/tvp514x_regs.h
@@ -284,14 +284,4 @@ struct tvp514x_reg {
         u32 val;
 };
 
-/**
- * struct tvp514x_init_seq - Structure for TVP5146/47/46M2/47M1 power up
- *              Sequence.
- * @ no_regs - Number of registers to write for power up sequence.
- * @ init_reg_seq - Array of registers and respective value to write.
- */
-struct tvp514x_init_seq {
-        unsigned int no_regs;
-        const struct tvp514x_reg *init_reg_seq;
-};
 #endif                          /* ifndef _TVP514X_REGS_H */
diff --git a/drivers/media/video/tw9910.c b/drivers/media/video/tw9910.c
index aa5065ea09ed..269ab044072a 100644
--- a/drivers/media/video/tw9910.c
+++ b/drivers/media/video/tw9910.c
@@ -24,7 +24,7 @@
 #include <linux/delay.h>
 #include <linux/videodev2.h>
 #include <media/v4l2-chip-ident.h>
-#include <media/v4l2-common.h>
+#include <media/v4l2-subdev.h>
 #include <media/soc_camera.h>
 #include <media/tw9910.h>
 
@@ -223,9 +223,8 @@ struct tw9910_hsync_ctrl {
 };
 
 struct tw9910_priv {
+        struct v4l2_subdev                subdev;
         struct tw9910_video_info       *info;
-        struct i2c_client              *client;
-        struct soc_camera_device        icd;
         const struct tw9910_scale_ctrl *scale;
 };
 
@@ -356,6 +355,12 @@ static const struct tw9910_hsync_ctrl tw9910_hsync_ctrl = {
 /*
  * general function
  */
+static struct tw9910_priv *to_tw9910(const struct i2c_client *client)
+{
+        return container_of(i2c_get_clientdata(client), struct tw9910_priv,
+                            subdev);
+}
+
 static int tw9910_set_scale(struct i2c_client *client,
                             const struct tw9910_scale_ctrl *scale)
 {
@@ -509,44 +514,20 @@ tw9910_select_norm(struct soc_camera_device *icd, u32 width, u32 height)
 /*
  * soc_camera_ops function
  */
-static int tw9910_init(struct soc_camera_device *icd)
-{
-        struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
-        int ret = 0;
-
-        if (priv->info->link.power) {
-                ret = priv->info->link.power(&priv->client->dev, 1);
-                if (ret < 0)
-                        return ret;
-        }
-
-        if (priv->info->link.reset)
-                ret = priv->info->link.reset(&priv->client->dev);
-
-        return ret;
-}
-
-static int tw9910_release(struct soc_camera_device *icd)
+static int tw9910_s_stream(struct v4l2_subdev *sd, int enable)
 {
-        struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
-        int ret = 0;
-
-        if (priv->info->link.power)
-                ret = priv->info->link.power(&priv->client->dev, 0);
-
-        return ret;
-}
+        struct i2c_client *client = sd->priv;
+        struct tw9910_priv *priv = to_tw9910(client);
 
-static int tw9910_start_capture(struct soc_camera_device *icd)
-{
-        struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
+        if (!enable)
+                return 0;
 
         if (!priv->scale) {
-                dev_err(&icd->dev, "norm select error\n");
+                dev_err(&client->dev, "norm select error\n");
                 return -EPERM;
         }
 
-        dev_dbg(&icd->dev, "%s %dx%d\n",
+        dev_dbg(&client->dev, "%s %dx%d\n",
                  priv->scale->name,
                  priv->scale->width,
                  priv->scale->height);
@@ -554,11 +535,6 @@ static int tw9910_start_capture(struct soc_camera_device *icd)
         return 0;
 }
 
-static int tw9910_stop_capture(struct soc_camera_device *icd)
-{
-        return 0;
-}
-
 static int tw9910_set_bus_param(struct soc_camera_device *icd,
                                 unsigned long flags)
 {
@@ -567,8 +543,9 @@ static int tw9910_set_bus_param(struct soc_camera_device *icd,
 
 static unsigned long tw9910_query_bus_param(struct soc_camera_device *icd)
 {
-        struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
-        struct soc_camera_link *icl = priv->client->dev.platform_data;
+        struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+        struct tw9910_priv *priv = to_tw9910(client);
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         unsigned long flags = SOCAM_PCLK_SAMPLE_RISING | SOCAM_MASTER |
                 SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_HIGH |
                 SOCAM_DATA_ACTIVE_HIGH | priv->info->buswidth;
@@ -576,21 +553,11 @@ static unsigned long tw9910_query_bus_param(struct soc_camera_device *icd)
         return soc_camera_apply_sensor_flags(icl, flags);
 }
 
-static int tw9910_get_chip_id(struct soc_camera_device *icd,
-                              struct v4l2_dbg_chip_ident *id)
-{
-        id->ident = V4L2_IDENT_TW9910;
-        id->revision = 0;
-
-        return 0;
-}
-
-static int tw9910_set_std(struct soc_camera_device *icd,
-                          v4l2_std_id *a)
+static int tw9910_s_std(struct v4l2_subdev *sd, v4l2_std_id norm)
 {
         int ret = -EINVAL;
 
-        if (*a & (V4L2_STD_NTSC | V4L2_STD_PAL))
+        if (norm & (V4L2_STD_NTSC | V4L2_STD_PAL))
                 ret = 0;
 
         return ret;
@@ -606,17 +573,26 @@ static int tw9910_enum_input(struct soc_camera_device *icd,
         return 0;
 }
 
+static int tw9910_g_chip_ident(struct v4l2_subdev *sd,
+                               struct v4l2_dbg_chip_ident *id)
+{
+        id->ident = V4L2_IDENT_TW9910;
+        id->revision = 0;
+
+        return 0;
+}
+
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-static int tw9910_get_register(struct soc_camera_device *icd,
-                               struct v4l2_dbg_register *reg)
+static int tw9910_g_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
 {
-        struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
+        struct i2c_client *client = sd->priv;
         int ret;
 
         if (reg->reg > 0xff)
                 return -EINVAL;
 
-        ret = i2c_smbus_read_byte_data(priv->client, reg->reg);
+        ret = i2c_smbus_read_byte_data(client, reg->reg);
         if (ret < 0)
                 return ret;
 
@@ -628,23 +604,25 @@ static int tw9910_get_register(struct soc_camera_device *icd,
         return 0;
 }
 
-static int tw9910_set_register(struct soc_camera_device *icd,
-                               struct v4l2_dbg_register *reg)
+static int tw9910_s_register(struct v4l2_subdev *sd,
+                             struct v4l2_dbg_register *reg)
 {
-        struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
+        struct i2c_client *client = sd->priv;
 
         if (reg->reg > 0xff ||
             reg->val > 0xff)
                 return -EINVAL;
 
-        return i2c_smbus_write_byte_data(priv->client, reg->reg, reg->val);
+        return i2c_smbus_write_byte_data(client, reg->reg, reg->val);
 }
 #endif
 
-static int tw9910_set_crop(struct soc_camera_device *icd,
-                           struct v4l2_rect *rect)
+static int tw9910_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
 {
-        struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
+        struct v4l2_rect *rect = &a->c;
+        struct i2c_client *client = sd->priv;
+        struct tw9910_priv *priv = to_tw9910(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
         int                 ret  = -EINVAL;
         u8                  val;
 
@@ -658,8 +636,8 @@ static int tw9910_set_crop(struct soc_camera_device *icd,
         /*
          * reset hardware
          */
-        tw9910_reset(priv->client);
-        ret = tw9910_write_array(priv->client, tw9910_default_regs);
+        tw9910_reset(client);
+        ret = tw9910_write_array(client, tw9910_default_regs);
         if (ret < 0)
                 goto tw9910_set_fmt_error;
 
@@ -670,7 +648,7 @@ static int tw9910_set_crop(struct soc_camera_device *icd,
         if (SOCAM_DATAWIDTH_16 == priv->info->buswidth)
                 val = LEN;
 
-        ret = tw9910_mask_set(priv->client, OPFORM, LEN, val);
+        ret = tw9910_mask_set(client, OPFORM, LEN, val);
         if (ret < 0)
                 goto tw9910_set_fmt_error;
 
@@ -698,52 +676,139 @@ static int tw9910_set_crop(struct soc_camera_device *icd,
                 val = 0;
         }
 
-        ret = tw9910_mask_set(priv->client, VBICNTL, RTSEL_MASK, val);
+        ret = tw9910_mask_set(client, VBICNTL, RTSEL_MASK, val);
         if (ret < 0)
                 goto tw9910_set_fmt_error;
 
         /*
          * set scale
          */
-        ret = tw9910_set_scale(priv->client, priv->scale);
+        ret = tw9910_set_scale(client, priv->scale);
         if (ret < 0)
                 goto tw9910_set_fmt_error;
 
         /*
          * set cropping
          */
-        ret = tw9910_set_cropping(priv->client, &tw9910_cropping_ctrl);
+        ret = tw9910_set_cropping(client, &tw9910_cropping_ctrl);
         if (ret < 0)
                 goto tw9910_set_fmt_error;
 
         /*
          * set hsync
          */
-        ret = tw9910_set_hsync(priv->client, &tw9910_hsync_ctrl);
+        ret = tw9910_set_hsync(client, &tw9910_hsync_ctrl);
         if (ret < 0)
                 goto tw9910_set_fmt_error;
 
+        rect->width = priv->scale->width;
+        rect->height = priv->scale->height;
+        rect->left = 0;
+        rect->top = 0;
+
         return ret;
 
 tw9910_set_fmt_error:
 
-        tw9910_reset(priv->client);
+        tw9910_reset(client);
         priv->scale = NULL;
 
         return ret;
 }
 
-static int tw9910_set_fmt(struct soc_camera_device *icd,
-                          struct v4l2_format *f)
+static int tw9910_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
+{
+        struct i2c_client *client = sd->priv;
+        struct tw9910_priv *priv = to_tw9910(client);
+
+        if (!priv->scale) {
+                int ret;
+                struct v4l2_crop crop = {
+                        .c = {
+                                .left   = 0,
+                                .top    = 0,
+                                .width  = 640,
+                                .height = 480,
+                        },
+                };
+                ret = tw9910_s_crop(sd, &crop);
+                if (ret < 0)
+                        return ret;
+        }
+
+        a->c.left       = 0;
+        a->c.top        = 0;
+        a->c.width      = priv->scale->width;
+        a->c.height     = priv->scale->height;
+        a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        return 0;
+}
+
+static int tw9910_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a)
 {
+        a->bounds.left                  = 0;
+        a->bounds.top                   = 0;
+        a->bounds.width                 = 768;
+        a->bounds.height                = 576;
+        a->defrect.left                 = 0;
+        a->defrect.top                  = 0;
+        a->defrect.width                = 640;
+        a->defrect.height               = 480;
+        a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        a->pixelaspect.numerator        = 1;
+        a->pixelaspect.denominator      = 1;
+
+        return 0;
+}
+
+static int tw9910_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct i2c_client *client = sd->priv;
+        struct tw9910_priv *priv = to_tw9910(client);
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+
+        if (!priv->scale) {
+                int ret;
+                struct v4l2_crop crop = {
+                        .c = {
+                                .left   = 0,
+                                .top    = 0,
+                                .width  = 640,
+                                .height = 480,
+                        },
+                };
+                ret = tw9910_s_crop(sd, &crop);
+                if (ret < 0)
+                        return ret;
+        }
+
+        f->type                 = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        pix->width              = priv->scale->width;
+        pix->height             = priv->scale->height;
+        pix->pixelformat        = V4L2_PIX_FMT_VYUY;
+        pix->colorspace         = V4L2_COLORSPACE_SMPTE170M;
+        pix->field              = V4L2_FIELD_INTERLACED;
+
+        return 0;
+}
+
+static int tw9910_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+        struct i2c_client *client = sd->priv;
+        struct tw9910_priv *priv = to_tw9910(client);
         struct v4l2_pix_format *pix = &f->fmt.pix;
-        struct v4l2_rect rect = {
-                .left   = icd->x_current,
-                .top    = icd->y_current,
-                .width  = pix->width,
-                .height = pix->height,
+        /* See tw9910_s_crop() - no proper cropping support */
+        struct v4l2_crop a = {
+                .c = {
+                        .left   = 0,
+                        .top    = 0,
+                        .width  = pix->width,
+                        .height = pix->height,
+                },
         };
-        int i;
+        int i, ret;
 
         /*
          * check color format
@@ -755,19 +820,25 @@ static int tw9910_set_fmt(struct soc_camera_device *icd,
         if (i == ARRAY_SIZE(tw9910_color_fmt))
                 return -EINVAL;
 
-        return tw9910_set_crop(icd, &rect);
+        ret = tw9910_s_crop(sd, &a);
+        if (!ret) {
+                pix->width = priv->scale->width;
+                pix->height = priv->scale->height;
+        }
+        return ret;
 }
 
-static int tw9910_try_fmt(struct soc_camera_device *icd,
-                          struct v4l2_format *f)
+static int tw9910_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
 {
+        struct i2c_client *client = sd->priv;
+        struct soc_camera_device *icd = client->dev.platform_data;
         struct v4l2_pix_format *pix = &f->fmt.pix;
         const struct tw9910_scale_ctrl *scale;
 
         if (V4L2_FIELD_ANY == pix->field) {
                 pix->field = V4L2_FIELD_INTERLACED;
         } else if (V4L2_FIELD_INTERLACED != pix->field) {
-                dev_err(&icd->dev, "Field type invalid.\n");
+                dev_err(&client->dev, "Field type invalid.\n");
                 return -EINVAL;
         }
 
@@ -784,11 +855,11 @@ static int tw9910_try_fmt(struct soc_camera_device *icd,
         return 0;
 }
 
-static int tw9910_video_probe(struct soc_camera_device *icd)
+static int tw9910_video_probe(struct soc_camera_device *icd,
+                              struct i2c_client *client)
 {
-        struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
+        struct tw9910_priv *priv = to_tw9910(client);
         s32 val;
-        int ret;
 
         /*
          * We must have a parent by now. And it cannot be a wrong one.
@@ -803,7 +874,7 @@ static int tw9910_video_probe(struct soc_camera_device *icd)
          */
         if (SOCAM_DATAWIDTH_16 != priv->info->buswidth &&
             SOCAM_DATAWIDTH_8  != priv->info->buswidth) {
-                dev_err(&icd->dev, "bus width error\n");
+                dev_err(&client->dev, "bus width error\n");
                 return -ENODEV;
         }
 
@@ -813,54 +884,54 @@ static int tw9910_video_probe(struct soc_camera_device *icd)
         /*
          * check and show Product ID
          */
-        val = i2c_smbus_read_byte_data(priv->client, ID);
+        val = i2c_smbus_read_byte_data(client, ID);
+
         if (0x0B != GET_ID(val) ||
             0x00 != GET_ReV(val)) {
-                dev_err(&icd->dev,
+                dev_err(&client->dev,
                         "Product ID error %x:%x\n", GET_ID(val), GET_ReV(val));
                 return -ENODEV;
         }
 
-        dev_info(&icd->dev,
+        dev_info(&client->dev,
                  "tw9910 Product ID %0x:%0x\n", GET_ID(val), GET_ReV(val));
 
-        ret = soc_camera_video_start(icd);
-        if (ret < 0)
-                return ret;
-
         icd->vdev->tvnorms      = V4L2_STD_NTSC | V4L2_STD_PAL;
         icd->vdev->current_norm = V4L2_STD_NTSC;
 
-        return ret;
-}
-
-static void tw9910_video_remove(struct soc_camera_device *icd)
-{
-        soc_camera_video_stop(icd);
+        return 0;
 }
 
 static struct soc_camera_ops tw9910_ops = {
-        .owner                  = THIS_MODULE,
-        .probe                  = tw9910_video_probe,
-        .remove                 = tw9910_video_remove,
-        .init                   = tw9910_init,
-        .release                = tw9910_release,
-        .start_capture          = tw9910_start_capture,
-        .stop_capture           = tw9910_stop_capture,
-        .set_crop               = tw9910_set_crop,
-        .set_fmt                = tw9910_set_fmt,
-        .try_fmt                = tw9910_try_fmt,
         .set_bus_param          = tw9910_set_bus_param,
         .query_bus_param        = tw9910_query_bus_param,
-        .get_chip_id            = tw9910_get_chip_id,
-        .set_std                = tw9910_set_std,
         .enum_input             = tw9910_enum_input,
+};
+
+static struct v4l2_subdev_core_ops tw9910_subdev_core_ops = {
+        .g_chip_ident   = tw9910_g_chip_ident,
+        .s_std          = tw9910_s_std,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
-        .get_register           = tw9910_get_register,
-        .set_register           = tw9910_set_register,
+        .g_register     = tw9910_g_register,
+        .s_register     = tw9910_s_register,
 #endif
 };
 
+static struct v4l2_subdev_video_ops tw9910_subdev_video_ops = {
+        .s_stream       = tw9910_s_stream,
+        .g_fmt          = tw9910_g_fmt,
+        .s_fmt          = tw9910_s_fmt,
+        .try_fmt        = tw9910_try_fmt,
+        .cropcap        = tw9910_cropcap,
+        .g_crop         = tw9910_g_crop,
+        .s_crop         = tw9910_s_crop,
+};
+
+static struct v4l2_subdev_ops tw9910_subdev_ops = {
+        .core   = &tw9910_subdev_core_ops,
+        .video  = &tw9910_subdev_video_ops,
+};
+
 /*
  * i2c_driver function
  */
@@ -871,18 +942,24 @@ static int tw9910_probe(struct i2c_client *client,
 {
         struct tw9910_priv             *priv;
         struct tw9910_video_info       *info;
-        struct soc_camera_device       *icd;
-        const struct tw9910_scale_ctrl *scale;
-        int                             i, ret;
+        struct soc_camera_device       *icd = client->dev.platform_data;
+        struct i2c_adapter             *adapter =
+                to_i2c_adapter(client->dev.parent);
+        struct soc_camera_link         *icl;
+        int                             ret;
+
+        if (!icd) {
+                dev_err(&client->dev, "TW9910: missing soc-camera data!\n");
+                return -EINVAL;
+        }
 
-        if (!client->dev.platform_data)
+        icl = to_soc_camera_link(icd);
+        if (!icl)
                 return -EINVAL;
 
-        info = container_of(client->dev.platform_data,
-                            struct tw9910_video_info, link);
+        info = container_of(icl, struct tw9910_video_info, link);
 
-        if (!i2c_check_functionality(to_i2c_adapter(client->dev.parent),
-                                     I2C_FUNC_SMBUS_BYTE_DATA)) {
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
                 dev_err(&client->dev,
                         "I2C-Adapter doesn't support "
                         "I2C_FUNC_SMBUS_BYTE_DATA\n");
@@ -894,40 +971,15 @@ static int tw9910_probe(struct i2c_client *client,
                 return -ENOMEM;
 
         priv->info   = info;
-        priv->client = client;
-        i2c_set_clientdata(client, priv);
 
-        icd          = &priv->icd;
+        v4l2_i2c_subdev_init(&priv->subdev, client, &tw9910_subdev_ops);
+
         icd->ops     = &tw9910_ops;
-        icd->control = &client->dev;
         icd->iface   = info->link.bus_id;
 
-        /*
-         * set width and height
-         */
-        icd->width_max  = tw9910_ntsc_scales[0].width; /* set default */
-        icd->width_min  = tw9910_ntsc_scales[0].width;
-        icd->height_max = tw9910_ntsc_scales[0].height;
-        icd->height_min = tw9910_ntsc_scales[0].height;
-
-        scale = tw9910_ntsc_scales;
-        for (i = 0; i < ARRAY_SIZE(tw9910_ntsc_scales); i++) {
-                icd->width_max  = max(scale[i].width,  icd->width_max);
-                icd->width_min  = min(scale[i].width,  icd->width_min);
-                icd->height_max = max(scale[i].height, icd->height_max);
-                icd->height_min = min(scale[i].height, icd->height_min);
-        }
-        scale = tw9910_pal_scales;
-        for (i = 0; i < ARRAY_SIZE(tw9910_pal_scales); i++) {
-                icd->width_max  = max(scale[i].width,  icd->width_max);
-                icd->width_min  = min(scale[i].width,  icd->width_min);
-                icd->height_max = max(scale[i].height, icd->height_max);
-                icd->height_min = min(scale[i].height, icd->height_min);
-        }
-
-        ret = soc_camera_device_register(icd);
-
+        ret = tw9910_video_probe(icd, client);
         if (ret) {
+                icd->ops = NULL;
                 i2c_set_clientdata(client, NULL);
                 kfree(priv);
         }
@@ -937,9 +989,10 @@ static int tw9910_probe(struct i2c_client *client,
 
 static int tw9910_remove(struct i2c_client *client)
 {
-        struct tw9910_priv *priv = i2c_get_clientdata(client);
+        struct tw9910_priv *priv = to_tw9910(client);
+        struct soc_camera_device *icd = client->dev.platform_data;
 
-        soc_camera_device_unregister(&priv->icd);
+        icd->ops = NULL;
         i2c_set_clientdata(client, NULL);
         kfree(priv);
         return 0;
diff --git a/drivers/media/video/usbvision/usbvision-i2c.c b/drivers/media/video/usbvision/usbvision-i2c.c
index 1fe5befbbf85..f97fd06d5948 100644
--- a/drivers/media/video/usbvision/usbvision-i2c.c
+++ b/drivers/media/video/usbvision/usbvision-i2c.c
@@ -246,9 +246,9 @@ int usbvision_i2c_register(struct usb_usbvision *usbvision)
         switch (usbvision_device_data[usbvision->DevModel].Codec) {
         case CODEC_SAA7113:
         case CODEC_SAA7111:
-                v4l2_i2c_new_probed_subdev(&usbvision->v4l2_dev,
+                v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
                                 &usbvision->i2c_adap, "saa7115",
-                                "saa7115_auto", saa711x_addrs);
+                                "saa7115_auto", 0, saa711x_addrs);
                 break;
         }
         if (usbvision_device_data[usbvision->DevModel].Tuner == 1) {
@@ -256,16 +256,16 @@ int usbvision_i2c_register(struct usb_usbvision *usbvision)
                 enum v4l2_i2c_tuner_type type;
                 struct tuner_setup tun_setup;
 
-                sd = v4l2_i2c_new_probed_subdev(&usbvision->v4l2_dev,
+                sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
                                 &usbvision->i2c_adap, "tuner",
-                                "tuner", v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
+                                "tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
                 /* depending on whether we found a demod or not, select
                    the tuner type. */
                 type = sd ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
 
-                sd = v4l2_i2c_new_probed_subdev(&usbvision->v4l2_dev,
+                sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
                                 &usbvision->i2c_adap, "tuner",
-                                "tuner", v4l2_i2c_tuner_addrs(type));
+                                "tuner", 0, v4l2_i2c_tuner_addrs(type));
 
                 if (usbvision->tuner_type != -1) {
                         tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
diff --git a/drivers/media/video/uvc/uvc_video.c b/drivers/media/video/uvc/uvc_video.c
index 5b757f32d997..f960e8ea4f17 100644
--- a/drivers/media/video/uvc/uvc_video.c
+++ b/drivers/media/video/uvc/uvc_video.c
@@ -124,13 +124,14 @@ static int uvc_get_video_ctrl(struct uvc_streaming *stream,
         int ret;
 
         size = stream->dev->uvc_version >= 0x0110 ? 34 : 26;
+        if ((stream->dev->quirks & UVC_QUIRK_PROBE_DEF) &&
+                        query == UVC_GET_DEF)
+                return -EIO;
+
         data = kmalloc(size, GFP_KERNEL);
         if (data == NULL)
                 return -ENOMEM;
 
-        if ((stream->dev->quirks & UVC_QUIRK_PROBE_DEF) && query == UVC_GET_DEF)
-                return -EIO;
-
         ret = __uvc_query_ctrl(stream->dev, query, 0, stream->intfnum,
                 probe ? UVC_VS_PROBE_CONTROL : UVC_VS_COMMIT_CONTROL, data,
                 size, UVC_CTRL_STREAMING_TIMEOUT);
diff --git a/drivers/media/video/v4l1-compat.c b/drivers/media/video/v4l1-compat.c
index 761fbd64db58..0c2105ca611e 100644
--- a/drivers/media/video/v4l1-compat.c
+++ b/drivers/media/video/v4l1-compat.c
@@ -564,10 +564,9 @@ static noinline long v4l1_compat_get_input_info(
                 break;
         }
         chan->norm = 0;
-        err = drv(file, VIDIOC_G_STD, &sid);
-        if (err < 0)
-                dprintk("VIDIOCGCHAN / VIDIOC_G_STD: %ld\n", err);
-        if (err == 0) {
+        /* Note: G_STD might not be present for radio receivers,
+         * so we should ignore any errors. */
+        if (drv(file, VIDIOC_G_STD, &sid) == 0) {
                 if (sid & V4L2_STD_PAL)
                         chan->norm = VIDEO_MODE_PAL;
                 if (sid & V4L2_STD_NTSC)
@@ -776,10 +775,9 @@ static noinline long v4l1_compat_get_tuner(
                         tun->flags |= VIDEO_TUNER_SECAM;
         }
 
-        err = drv(file, VIDIOC_G_STD, &sid);
-        if (err < 0)
-                dprintk("VIDIOCGTUNER / VIDIOC_G_STD: %ld\n", err);
-        if (err == 0) {
+        /* Note: G_STD might not be present for radio receivers,
+         * so we should ignore any errors. */
+        if (drv(file, VIDIOC_G_STD, &sid) == 0) {
                 if (sid & V4L2_STD_PAL)
                         tun->mode = VIDEO_MODE_PAL;
                 if (sid & V4L2_STD_NTSC)
diff --git a/drivers/media/video/v4l2-common.c b/drivers/media/video/v4l2-common.c
index 3a0c64935b0e..f5a93ae3cdf9 100644
--- a/drivers/media/video/v4l2-common.c
+++ b/drivers/media/video/v4l2-common.c
@@ -814,139 +814,6 @@ EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
 
 
 /* Load an i2c sub-device. */
-struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
-                struct i2c_adapter *adapter,
-                const char *module_name, const char *client_type, u8 addr)
-{
-        struct v4l2_subdev *sd = NULL;
-        struct i2c_client *client;
-        struct i2c_board_info info;
-
-        BUG_ON(!v4l2_dev);
-
-        if (module_name)
-                request_module(module_name);
-
-        /* Setup the i2c board info with the device type and
-           the device address. */
-        memset(&info, 0, sizeof(info));
-        strlcpy(info.type, client_type, sizeof(info.type));
-        info.addr = addr;
-
-        /* Create the i2c client */
-        client = i2c_new_device(adapter, &info);
-        /* Note: it is possible in the future that
-           c->driver is NULL if the driver is still being loaded.
-           We need better support from the kernel so that we
-           can easily wait for the load to finish. */
-        if (client == NULL || client->driver == NULL)
-                goto error;
-
-        /* Lock the module so we can safely get the v4l2_subdev pointer */
-        if (!try_module_get(client->driver->driver.owner))
-                goto error;
-        sd = i2c_get_clientdata(client);
-
-        /* Register with the v4l2_device which increases the module's
-           use count as well. */
-        if (v4l2_device_register_subdev(v4l2_dev, sd))
-                sd = NULL;
-        /* Decrease the module use count to match the first try_module_get. */
-        module_put(client->driver->driver.owner);
-
-        if (sd) {
-                /* We return errors from v4l2_subdev_call only if we have the
-                   callback as the .s_config is not mandatory */
-                int err = v4l2_subdev_call(sd, core, s_config, 0, NULL);
-
-                if (err && err != -ENOIOCTLCMD) {
-                        v4l2_device_unregister_subdev(sd);
-                        sd = NULL;
-                }
-        }
-
-error:
-        /* If we have a client but no subdev, then something went wrong and
-           we must unregister the client. */
-        if (client && sd == NULL)
-                i2c_unregister_device(client);
-        return sd;
-}
-EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
-
-/* Probe and load an i2c sub-device. */
-struct v4l2_subdev *v4l2_i2c_new_probed_subdev(struct v4l2_device *v4l2_dev,
-        struct i2c_adapter *adapter,
-        const char *module_name, const char *client_type,
-        const unsigned short *addrs)
-{
-        struct v4l2_subdev *sd = NULL;
-        struct i2c_client *client = NULL;
-        struct i2c_board_info info;
-
-        BUG_ON(!v4l2_dev);
-
-        if (module_name)
-                request_module(module_name);
-
-        /* Setup the i2c board info with the device type and
-           the device address. */
-        memset(&info, 0, sizeof(info));
-        strlcpy(info.type, client_type, sizeof(info.type));
-
-        /* Probe and create the i2c client */
-        client = i2c_new_probed_device(adapter, &info, addrs);
-        /* Note: it is possible in the future that
-           c->driver is NULL if the driver is still being loaded.
-           We need better support from the kernel so that we
-           can easily wait for the load to finish. */
-        if (client == NULL || client->driver == NULL)
-                goto error;
-
-        /* Lock the module so we can safely get the v4l2_subdev pointer */
-        if (!try_module_get(client->driver->driver.owner))
-                goto error;
-        sd = i2c_get_clientdata(client);
-
-        /* Register with the v4l2_device which increases the module's
-           use count as well. */
-        if (v4l2_device_register_subdev(v4l2_dev, sd))
-                sd = NULL;
-        /* Decrease the module use count to match the first try_module_get. */
-        module_put(client->driver->driver.owner);
-
-        if (sd) {
-                /* We return errors from v4l2_subdev_call only if we have the
-                   callback as the .s_config is not mandatory */
-                int err = v4l2_subdev_call(sd, core, s_config, 0, NULL);
-
-                if (err && err != -ENOIOCTLCMD) {
-                        v4l2_device_unregister_subdev(sd);
-                        sd = NULL;
-                }
-        }
-
-error:
-        /* If we have a client but no subdev, then something went wrong and
-           we must unregister the client. */
-        if (client && sd == NULL)
-                i2c_unregister_device(client);
-        return sd;
-}
-EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev);
-
-struct v4l2_subdev *v4l2_i2c_new_probed_subdev_addr(struct v4l2_device *v4l2_dev,
-                struct i2c_adapter *adapter,
-                const char *module_name, const char *client_type, u8 addr)
-{
-        unsigned short addrs[2] = { addr, I2C_CLIENT_END };
-
-        return v4l2_i2c_new_probed_subdev(v4l2_dev, adapter,
-                        module_name, client_type, addrs);
-}
-EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev_addr);
-
-/* Load an i2c sub-device. */
 struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
                 struct i2c_adapter *adapter, const char *module_name,
                 struct i2c_board_info *info, const unsigned short *probe_addrs)
diff --git a/drivers/media/video/v4l2-dev.c b/drivers/media/video/v4l2-dev.c
index a7f1b69a7dab..500cbe9891ac 100644
--- a/drivers/media/video/v4l2-dev.c
+++ b/drivers/media/video/v4l2-dev.c
@@ -66,7 +66,49 @@ static struct device_attribute video_device_attrs[] = {
  */
 static struct video_device *video_device[VIDEO_NUM_DEVICES];
 static DEFINE_MUTEX(videodev_lock);
-static DECLARE_BITMAP(video_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES);
+static DECLARE_BITMAP(devnode_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES);
+
+/* Device node utility functions */
+
+/* Note: these utility functions all assume that vfl_type is in the range
+   [0, VFL_TYPE_MAX-1]. */
+
+#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
+/* Return the bitmap corresponding to vfl_type. */
+static inline unsigned long *devnode_bits(int vfl_type)
+{
+        /* Any types not assigned to fixed minor ranges must be mapped to
+           one single bitmap for the purposes of finding a free node number
+           since all those unassigned types use the same minor range. */
+        int idx = (vfl_type > VFL_TYPE_VTX) ? VFL_TYPE_MAX - 1 : vfl_type;
+
+        return devnode_nums[idx];
+}
+#else
+/* Return the bitmap corresponding to vfl_type. */
+static inline unsigned long *devnode_bits(int vfl_type)
+{
+        return devnode_nums[vfl_type];
+}
+#endif
+
+/* Mark device node number vdev->num as used */
+static inline void devnode_set(struct video_device *vdev)
+{
+        set_bit(vdev->num, devnode_bits(vdev->vfl_type));
+}
+
+/* Mark device node number vdev->num as unused */
+static inline void devnode_clear(struct video_device *vdev)
+{
+        clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
+}
+
+/* Try to find a free device node number in the range [from, to> */
+static inline int devnode_find(struct video_device *vdev, int from, int to)
+{
+        return find_next_zero_bit(devnode_bits(vdev->vfl_type), to, from);
+}
 
 struct video_device *video_device_alloc(void)
 {
@@ -119,8 +161,8 @@ static void v4l2_device_release(struct device *cd)
            the release() callback. */
         vdev->cdev = NULL;
 
-        /* Mark minor as free */
-        clear_bit(vdev->num, video_nums[vdev->vfl_type]);
+        /* Mark device node number as free */
+        devnode_clear(vdev);
 
         mutex_unlock(&videodev_lock);
 
@@ -299,32 +341,28 @@ static const struct file_operations v4l2_fops = {
 };
 
 /**
- * get_index - assign stream number based on parent device
+ * get_index - assign stream index number based on parent device
  * @vdev: video_device to assign index number to, vdev->parent should be assigned
- * @num:  -1 if auto assign, requested number otherwise
  *
  * Note that when this is called the new device has not yet been registered
- * in the video_device array.
+ * in the video_device array, but it was able to obtain a minor number.
+ *
+ * This means that we can always obtain a free stream index number since
+ * the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
+ * use of the video_device array.
  *
- * Returns -ENFILE if num is already in use, a free index number if
- * successful.
+ * Returns a free index number.
  */
-static int get_index(struct video_device *vdev, int num)
+static int get_index(struct video_device *vdev)
 {
         /* This can be static since this function is called with the global
            videodev_lock held. */
         static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
         int i;
 
-        if (num >= VIDEO_NUM_DEVICES) {
-                printk(KERN_ERR "videodev: %s num is too large\n", __func__);
-                return -EINVAL;
-        }
-
-        /* Some drivers do not set the parent. In that case always return
-           num or 0. */
+        /* Some drivers do not set the parent. In that case always return 0. */
         if (vdev->parent == NULL)
-                return num >= 0 ? num : 0;
+                return 0;
 
         bitmap_zero(used, VIDEO_NUM_DEVICES);
 
@@ -335,35 +373,23 @@ static int get_index(struct video_device *vdev, int num)
                 }
         }
 
-        if (num >= 0) {
-                if (test_bit(num, used))
-                        return -ENFILE;
-                return num;
-        }
-
-        i = find_first_zero_bit(used, VIDEO_NUM_DEVICES);
-        return i == VIDEO_NUM_DEVICES ? -ENFILE : i;
+        return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
 }
 
-int video_register_device(struct video_device *vdev, int type, int nr)
-{
-        return video_register_device_index(vdev, type, nr, -1);
-}
-EXPORT_SYMBOL(video_register_device);
-
 /**
- *      video_register_device_index - register video4linux devices
+ *      video_register_device - register video4linux devices
  *      @vdev: video device structure we want to register
  *      @type: type of device to register
- *      @nr:   which device number (0 == /dev/video0, 1 == /dev/video1, ...
+ *      @nr:   which device node number (0 == /dev/video0, 1 == /dev/video1, ...
  *             -1 == first free)
- *      @index: stream number based on parent device;
- *              -1 if auto assign, requested number otherwise
+ *      @warn_if_nr_in_use: warn if the desired device node number
+ *             was already in use and another number was chosen instead.
  *
- *      The registration code assigns minor numbers based on the type
- *      requested. -ENFILE is returned in all the device slots for this
- *      category are full. If not then the minor field is set and the
- *      driver initialize function is called (if non %NULL).
+ *      The registration code assigns minor numbers and device node numbers
+ *      based on the requested type and registers the new device node with
+ *      the kernel.
+ *      An error is returned if no free minor or device node number could be
+ *      found, or if the registration of the device node failed.
  *
  *      Zero is returned on success.
  *
@@ -377,8 +403,8 @@ EXPORT_SYMBOL(video_register_device);
  *
  *      %VFL_TYPE_RADIO - A radio card
  */
-int video_register_device_index(struct video_device *vdev, int type, int nr,
-                                        int index)
+static int __video_register_device(struct video_device *vdev, int type, int nr,
+                int warn_if_nr_in_use)
 {
         int i = 0;
         int ret;
@@ -421,7 +447,7 @@ int video_register_device_index(struct video_device *vdev, int type, int nr,
         if (vdev->v4l2_dev && vdev->v4l2_dev->dev)
                 vdev->parent = vdev->v4l2_dev->dev;
 
-        /* Part 2: find a free minor, kernel number and device index. */
+        /* Part 2: find a free minor, device node number and device index. */
 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
         /* Keep the ranges for the first four types for historical
          * reasons.
@@ -452,21 +478,22 @@ int video_register_device_index(struct video_device *vdev, int type, int nr,
         }
 #endif
 
-        /* Pick a minor number */
+        /* Pick a device node number */
         mutex_lock(&videodev_lock);
-        nr = find_next_zero_bit(video_nums[type], minor_cnt, nr == -1 ? 0 : nr);
+        nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
         if (nr == minor_cnt)
-                nr = find_first_zero_bit(video_nums[type], minor_cnt);
+                nr = devnode_find(vdev, 0, minor_cnt);
         if (nr == minor_cnt) {
-                printk(KERN_ERR "could not get a free kernel number\n");
+                printk(KERN_ERR "could not get a free device node number\n");
                 mutex_unlock(&videodev_lock);
                 return -ENFILE;
         }
 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
-        /* 1-on-1 mapping of kernel number to minor number */
+        /* 1-on-1 mapping of device node number to minor number */
         i = nr;
 #else
-        /* The kernel number and minor numbers are independent */
+        /* The device node number and minor numbers are independent, so
+           we just find the first free minor number. */
         for (i = 0; i < VIDEO_NUM_DEVICES; i++)
                 if (video_device[i] == NULL)
                         break;
@@ -478,17 +505,13 @@ int video_register_device_index(struct video_device *vdev, int type, int nr,
 #endif
         vdev->minor = i + minor_offset;
         vdev->num = nr;
-        set_bit(nr, video_nums[type]);
+        devnode_set(vdev);
+
         /* Should not happen since we thought this minor was free */
         WARN_ON(video_device[vdev->minor] != NULL);
-        ret = vdev->index = get_index(vdev, index);
+        vdev->index = get_index(vdev);
         mutex_unlock(&videodev_lock);
 
-        if (ret < 0) {
-                printk(KERN_ERR "%s: get_index failed\n", __func__);
-                goto cleanup;
-        }
-
         /* Part 3: Initialize the character device */
         vdev->cdev = cdev_alloc();
         if (vdev->cdev == NULL) {
@@ -517,7 +540,7 @@ int video_register_device_index(struct video_device *vdev, int type, int nr,
         vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
         if (vdev->parent)
                 vdev->dev.parent = vdev->parent;
-        dev_set_name(&vdev->dev, "%s%d", name_base, nr);
+        dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
         ret = device_register(&vdev->dev);
         if (ret < 0) {
                 printk(KERN_ERR "%s: device_register failed\n", __func__);
@@ -527,6 +550,10 @@ int video_register_device_index(struct video_device *vdev, int type, int nr,
            reference to the device goes away. */
         vdev->dev.release = v4l2_device_release;
 
+        if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
+                printk(KERN_WARNING "%s: requested %s%d, got %s%d\n",
+                                __func__, name_base, nr, name_base, vdev->num);
+
         /* Part 5: Activate this minor. The char device can now be used. */
         mutex_lock(&videodev_lock);
         video_device[vdev->minor] = vdev;
@@ -537,13 +564,24 @@ cleanup:
         mutex_lock(&videodev_lock);
         if (vdev->cdev)
                 cdev_del(vdev->cdev);
-        clear_bit(vdev->num, video_nums[type]);
+        devnode_clear(vdev);
         mutex_unlock(&videodev_lock);
         /* Mark this video device as never having been registered. */
         vdev->minor = -1;
         return ret;
 }
-EXPORT_SYMBOL(video_register_device_index);
+
+int video_register_device(struct video_device *vdev, int type, int nr)
+{
+        return __video_register_device(vdev, type, nr, 1);
+}
+EXPORT_SYMBOL(video_register_device);
+
+int video_register_device_no_warn(struct video_device *vdev, int type, int nr)
+{
+        return __video_register_device(vdev, type, nr, 0);
+}
+EXPORT_SYMBOL(video_register_device_no_warn);
 
 /**
  *      video_unregister_device - unregister a video4linux device
diff --git a/drivers/media/video/vino.c b/drivers/media/video/vino.c
index f3b6e15d91f2..cd6a3446ab7e 100644
--- a/drivers/media/video/vino.c
+++ b/drivers/media/video/vino.c
@@ -4333,11 +4333,11 @@ static int __init vino_module_init(void)
         vino_init_stage++;
 
         vino_drvdata->decoder =
-                v4l2_i2c_new_probed_subdev_addr(&vino_drvdata->v4l2_dev,
-                        &vino_i2c_adapter, "saa7191", "saa7191", 0x45);
+                v4l2_i2c_new_subdev(&vino_drvdata->v4l2_dev, &vino_i2c_adapter,
+                               "saa7191", "saa7191", 0, I2C_ADDRS(0x45));
         vino_drvdata->camera =
-                v4l2_i2c_new_probed_subdev_addr(&vino_drvdata->v4l2_dev,
-                        &vino_i2c_adapter, "indycam", "indycam", 0x2b);
+                v4l2_i2c_new_subdev(&vino_drvdata->v4l2_dev, &vino_i2c_adapter,
+                               "indycam", "indycam", 0, I2C_ADDRS(0x2b));
 
         dprintk("init complete!\n");
 
diff --git a/drivers/media/video/w9968cf.c b/drivers/media/video/w9968cf.c
index 602484dd3da9..37fcdc447db5 100644
--- a/drivers/media/video/w9968cf.c
+++ b/drivers/media/video/w9968cf.c
@@ -3515,9 +3515,9 @@ w9968cf_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
         w9968cf_turn_on_led(cam);
 
         w9968cf_i2c_init(cam);
-        cam->sensor_sd = v4l2_i2c_new_probed_subdev(&cam->v4l2_dev,
+        cam->sensor_sd = v4l2_i2c_new_subdev(&cam->v4l2_dev,
                         &cam->i2c_adapter,
-                        "ovcamchip", "ovcamchip", addrs);
+                        "ovcamchip", "ovcamchip", 0, addrs);
 
         usb_set_intfdata(intf, cam);
         mutex_unlock(&cam->dev_mutex);
diff --git a/drivers/media/video/zc0301/zc0301_core.c b/drivers/media/video/zc0301/zc0301_core.c
index 96971044fc78..b3c6436b33ba 100644
--- a/drivers/media/video/zc0301/zc0301_core.c
+++ b/drivers/media/video/zc0301/zc0301_core.c
@@ -819,8 +819,10 @@ zc0301_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
                             (!list_empty(&cam->outqueue)) ||
                             (cam->state & DEV_DISCONNECTED) ||
                             (cam->state & DEV_MISCONFIGURED),
-                            cam->module_param.frame_timeout *
-                            1000 * msecs_to_jiffies(1) );
+                            msecs_to_jiffies(
+                                cam->module_param.frame_timeout * 1000
+                            )
+                          );
                 if (timeout < 0) {
                         mutex_unlock(&cam->fileop_mutex);
                         return timeout;
diff --git a/drivers/media/video/zoran/zoran_card.c b/drivers/media/video/zoran/zoran_card.c
index 0c4d9b1f8e6f..be70574870de 100644
--- a/drivers/media/video/zoran/zoran_card.c
+++ b/drivers/media/video/zoran/zoran_card.c
@@ -1357,15 +1357,15 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
                 goto zr_free_irq;
         }
 
-        zr->decoder = v4l2_i2c_new_probed_subdev(&zr->v4l2_dev,
+        zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
                 &zr->i2c_adapter, zr->card.mod_decoder, zr->card.i2c_decoder,
-                zr->card.addrs_decoder);
+                0, zr->card.addrs_decoder);
 
         if (zr->card.mod_encoder)
-                zr->encoder = v4l2_i2c_new_probed_subdev(&zr->v4l2_dev,
+                zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
                         &zr->i2c_adapter,
                         zr->card.mod_encoder, zr->card.i2c_encoder,
-                        zr->card.addrs_encoder);
+                        0, zr->card.addrs_encoder);
 
         dprintk(2,
                 KERN_INFO "%s: Initializing videocodec bus...\n",