11 files changed, 218 insertions, 128 deletions

diff --git a/drivers/media/i2c/cx25840/cx25840-core.c b/drivers/media/i2c/cx25840/cx25840-core.c
index d8eac3e30a7e..2cee69e34184 100644
--- a/drivers/media/i2c/cx25840/cx25840-core.c
+++ b/drivers/media/i2c/cx25840/cx25840-core.c
@@ -599,7 +599,7 @@ static void cx23885_initialize(struct i2c_client *client)
                 cx25840_write4(client, 0x114, 0x01bf0c9e);
                 cx25840_write4(client, 0x110, 0x000a030c);
                 break;
-        };
+        }
 
         /* ADC2 input select */
         cx25840_write(client, 0x102, 0x10);
diff --git a/drivers/media/i2c/m5mols/m5mols.h b/drivers/media/i2c/m5mols/m5mols.h
index 86c815be348c..90a6c520f115 100644
--- a/drivers/media/i2c/m5mols/m5mols.h
+++ b/drivers/media/i2c/m5mols/m5mols.h
@@ -16,9 +16,17 @@
 #ifndef M5MOLS_H
 #define M5MOLS_H
 
+#include <linux/sizes.h>
 #include <media/v4l2-subdev.h>
 #include "m5mols_reg.h"
 
+
+/* An amount of data transmitted in addition to the value
+ * determined by CAPP_JPEG_SIZE_MAX register.
+ */
+#define M5MOLS_JPEG_TAGS_SIZE           0x20000
+#define M5MOLS_MAIN_JPEG_SIZE_MAX       (5 * SZ_1M)
+
 extern int m5mols_debug;
 
 enum m5mols_restype {
@@ -67,12 +75,14 @@ struct m5mols_exif {
 /**
  * struct m5mols_capture - Structure for the capture capability
  * @exif: EXIF information
+ * @buf_size: internal JPEG frame buffer size, in bytes
  * @main: size in bytes of the main image
  * @thumb: size in bytes of the thumb image, if it was accompanied
  * @total: total size in bytes of the produced image
  */
 struct m5mols_capture {
         struct m5mols_exif exif;
+        unsigned int buf_size;
         u32 main;
         u32 thumb;
         u32 total;
diff --git a/drivers/media/i2c/m5mols/m5mols_capture.c b/drivers/media/i2c/m5mols/m5mols_capture.c
index cb243bd278ce..ab34ccedf31e 100644
--- a/drivers/media/i2c/m5mols/m5mols_capture.c
+++ b/drivers/media/i2c/m5mols/m5mols_capture.c
@@ -105,6 +105,7 @@ static int m5mols_capture_info(struct m5mols_info *info)
 
 int m5mols_start_capture(struct m5mols_info *info)
 {
+        unsigned int framesize = info->cap.buf_size - M5MOLS_JPEG_TAGS_SIZE;
         struct v4l2_subdev *sd = &info->sd;
         int ret;
 
@@ -121,6 +122,8 @@ int m5mols_start_capture(struct m5mols_info *info)
         if (!ret)
                 ret = m5mols_write(sd, CAPP_MAIN_IMAGE_SIZE, info->resolution);
         if (!ret)
+                ret = m5mols_write(sd, CAPP_JPEG_SIZE_MAX, framesize);
+        if (!ret)
                 ret = m5mols_set_mode(info, REG_CAPTURE);
         if (!ret)
                 /* Wait until a frame is captured to ISP internal memory */
diff --git a/drivers/media/i2c/m5mols/m5mols_core.c b/drivers/media/i2c/m5mols/m5mols_core.c
index 2f490ef26c38..8131d651de9e 100644
--- a/drivers/media/i2c/m5mols/m5mols_core.c
+++ b/drivers/media/i2c/m5mols/m5mols_core.c
@@ -599,6 +599,51 @@ static int m5mols_set_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
         return ret;
 }
 
+static int m5mols_get_frame_desc(struct v4l2_subdev *sd, unsigned int pad,
+                                 struct v4l2_mbus_frame_desc *fd)
+{
+        struct m5mols_info *info = to_m5mols(sd);
+
+        if (pad != 0 || fd == NULL)
+                return -EINVAL;
+
+        mutex_lock(&info->lock);
+        /*
+         * .get_frame_desc is only used for compressed formats,
+         * thus we always return the capture frame parameters here.
+         */
+        fd->entry[0].length = info->cap.buf_size;
+        fd->entry[0].pixelcode = info->ffmt[M5MOLS_RESTYPE_CAPTURE].code;
+        mutex_unlock(&info->lock);
+
+        fd->entry[0].flags = V4L2_MBUS_FRAME_DESC_FL_LEN_MAX;
+        fd->num_entries = 1;
+
+        return 0;
+}
+
+static int m5mols_set_frame_desc(struct v4l2_subdev *sd, unsigned int pad,
+                                 struct v4l2_mbus_frame_desc *fd)
+{
+        struct m5mols_info *info = to_m5mols(sd);
+        struct v4l2_mbus_framefmt *mf = &info->ffmt[M5MOLS_RESTYPE_CAPTURE];
+
+        if (pad != 0 || fd == NULL)
+                return -EINVAL;
+
+        fd->entry[0].flags = V4L2_MBUS_FRAME_DESC_FL_LEN_MAX;
+        fd->num_entries = 1;
+        fd->entry[0].length = clamp_t(u32, fd->entry[0].length,
+                                      mf->width * mf->height,
+                                      M5MOLS_MAIN_JPEG_SIZE_MAX);
+        mutex_lock(&info->lock);
+        info->cap.buf_size = fd->entry[0].length;
+        mutex_unlock(&info->lock);
+
+        return 0;
+}
+
+
 static int m5mols_enum_mbus_code(struct v4l2_subdev *sd,
                                  struct v4l2_subdev_fh *fh,
                                  struct v4l2_subdev_mbus_code_enum *code)
@@ -615,6 +660,8 @@ static struct v4l2_subdev_pad_ops m5mols_pad_ops = {
         .enum_mbus_code = m5mols_enum_mbus_code,
         .get_fmt        = m5mols_get_fmt,
         .set_fmt        = m5mols_set_fmt,
+        .get_frame_desc = m5mols_get_frame_desc,
+        .set_frame_desc = m5mols_set_frame_desc,
 };
 
 /**
diff --git a/drivers/media/i2c/m5mols/m5mols_reg.h b/drivers/media/i2c/m5mols/m5mols_reg.h
index 14d4be72aeff..58d8027508df 100644
--- a/drivers/media/i2c/m5mols/m5mols_reg.h
+++ b/drivers/media/i2c/m5mols/m5mols_reg.h
@@ -310,6 +310,7 @@
 #define REG_JPEG                0x10
 
 #define CAPP_MAIN_IMAGE_SIZE    I2C_REG(CAT_CAPT_PARM, 0x01, 1)
+#define CAPP_JPEG_SIZE_MAX      I2C_REG(CAT_CAPT_PARM, 0x0f, 4)
 #define CAPP_JPEG_RATIO         I2C_REG(CAT_CAPT_PARM, 0x17, 1)
 
 #define CAPP_MCC_MODE           I2C_REG(CAT_CAPT_PARM, 0x1d, 1)
diff --git a/drivers/media/i2c/mt9p031.c b/drivers/media/i2c/mt9p031.c
index 2c0f4077c491..e32833262d32 100644
--- a/drivers/media/i2c/mt9p031.c
+++ b/drivers/media/i2c/mt9p031.c
@@ -574,7 +574,6 @@ static int mt9p031_set_crop(struct v4l2_subdev *subdev,
  * V4L2 subdev control operations
  */
 
-#define V4L2_CID_TEST_PATTERN           (V4L2_CID_USER_BASE | 0x1001)
 #define V4L2_CID_BLC_AUTO               (V4L2_CID_USER_BASE | 0x1002)
 #define V4L2_CID_BLC_TARGET_LEVEL       (V4L2_CID_USER_BASE | 0x1003)
 #define V4L2_CID_BLC_ANALOG_OFFSET      (V4L2_CID_USER_BASE | 0x1004)
@@ -740,18 +739,6 @@ static const char * const mt9p031_test_pattern_menu[] = {
 static const struct v4l2_ctrl_config mt9p031_ctrls[] = {
         {
                 .ops            = &mt9p031_ctrl_ops,
-                .id             = V4L2_CID_TEST_PATTERN,
-                .type           = V4L2_CTRL_TYPE_MENU,
-                .name           = "Test Pattern",
-                .min            = 0,
-                .max            = ARRAY_SIZE(mt9p031_test_pattern_menu) - 1,
-                .step           = 0,
-                .def            = 0,
-                .flags          = 0,
-                .menu_skip_mask = 0,
-                .qmenu          = mt9p031_test_pattern_menu,
-        }, {
-                .ops            = &mt9p031_ctrl_ops,
                 .id             = V4L2_CID_BLC_AUTO,
                 .type           = V4L2_CTRL_TYPE_BOOLEAN,
                 .name           = "BLC, Auto",
@@ -950,7 +937,7 @@ static int mt9p031_probe(struct i2c_client *client,
         mt9p031->model = did->driver_data;
         mt9p031->reset = -1;
 
-        v4l2_ctrl_handler_init(&mt9p031->ctrls, ARRAY_SIZE(mt9p031_ctrls) + 5);
+        v4l2_ctrl_handler_init(&mt9p031->ctrls, ARRAY_SIZE(mt9p031_ctrls) + 6);
 
         v4l2_ctrl_new_std(&mt9p031->ctrls, &mt9p031_ctrl_ops,
                           V4L2_CID_EXPOSURE, MT9P031_SHUTTER_WIDTH_MIN,
@@ -966,6 +953,10 @@ static int mt9p031_probe(struct i2c_client *client,
         v4l2_ctrl_new_std(&mt9p031->ctrls, &mt9p031_ctrl_ops,
                           V4L2_CID_PIXEL_RATE, pdata->target_freq,
                           pdata->target_freq, 1, pdata->target_freq);
+        v4l2_ctrl_new_std_menu_items(&mt9p031->ctrls, &mt9p031_ctrl_ops,
+                          V4L2_CID_TEST_PATTERN,
+                          ARRAY_SIZE(mt9p031_test_pattern_menu) - 1, 0,
+                          0, mt9p031_test_pattern_menu);
 
         for (i = 0; i < ARRAY_SIZE(mt9p031_ctrls); ++i)
                 v4l2_ctrl_new_custom(&mt9p031->ctrls, &mt9p031_ctrls[i], NULL);
diff --git a/drivers/media/i2c/mt9t001.c b/drivers/media/i2c/mt9t001.c
index 6d343adf891d..2e189d8b71bb 100644
--- a/drivers/media/i2c/mt9t001.c
+++ b/drivers/media/i2c/mt9t001.c
@@ -371,7 +371,7 @@ static int mt9t001_set_crop(struct v4l2_subdev *subdev,
  * V4L2 subdev control operations
  */
 
-#define V4L2_CID_TEST_PATTERN           (V4L2_CID_USER_BASE | 0x1001)
+#define V4L2_CID_TEST_PATTERN_COLOR     (V4L2_CID_USER_BASE | 0x1001)
 #define V4L2_CID_BLACK_LEVEL_AUTO       (V4L2_CID_USER_BASE | 0x1002)
 #define V4L2_CID_BLACK_LEVEL_OFFSET     (V4L2_CID_USER_BASE | 0x1003)
 #define V4L2_CID_BLACK_LEVEL_CALIBRATE  (V4L2_CID_USER_BASE | 0x1004)
@@ -487,12 +487,11 @@ static int mt9t001_s_ctrl(struct v4l2_ctrl *ctrl)
                                      ctrl->val >> 16);
 
         case V4L2_CID_TEST_PATTERN:
-                ret = mt9t001_set_output_control(mt9t001,
+                return mt9t001_set_output_control(mt9t001,
                         ctrl->val ? 0 : MT9T001_OUTPUT_CONTROL_TEST_DATA,
                         ctrl->val ? MT9T001_OUTPUT_CONTROL_TEST_DATA : 0);
-                if (ret < 0)
-                        return ret;
 
+        case V4L2_CID_TEST_PATTERN_COLOR:
                 return mt9t001_write(client, MT9T001_TEST_DATA, ctrl->val << 2);
 
         case V4L2_CID_BLACK_LEVEL_AUTO:
@@ -533,12 +532,17 @@ static struct v4l2_ctrl_ops mt9t001_ctrl_ops = {
         .s_ctrl = mt9t001_s_ctrl,
 };
 
+static const char * const mt9t001_test_pattern_menu[] = {
+        "Disabled",
+        "Enabled",
+};
+
 static const struct v4l2_ctrl_config mt9t001_ctrls[] = {
         {
                 .ops            = &mt9t001_ctrl_ops,
-                .id             = V4L2_CID_TEST_PATTERN,
+                .id             = V4L2_CID_TEST_PATTERN_COLOR,
                 .type           = V4L2_CTRL_TYPE_INTEGER,
-                .name           = "Test pattern",
+                .name           = "Test Pattern Color",
                 .min            = 0,
                 .max            = 1023,
                 .step           = 1,
@@ -741,7 +745,7 @@ static int mt9t001_probe(struct i2c_client *client,
                 return -ENOMEM;
 
         v4l2_ctrl_handler_init(&mt9t001->ctrls, ARRAY_SIZE(mt9t001_ctrls) +
-                                                ARRAY_SIZE(mt9t001_gains) + 3);
+                                                ARRAY_SIZE(mt9t001_gains) + 4);
 
         v4l2_ctrl_new_std(&mt9t001->ctrls, &mt9t001_ctrl_ops,
                           V4L2_CID_EXPOSURE, MT9T001_SHUTTER_WIDTH_MIN,
@@ -752,6 +756,10 @@ static int mt9t001_probe(struct i2c_client *client,
         v4l2_ctrl_new_std(&mt9t001->ctrls, &mt9t001_ctrl_ops,
                           V4L2_CID_PIXEL_RATE, pdata->ext_clk, pdata->ext_clk,
                           1, pdata->ext_clk);
+        v4l2_ctrl_new_std_menu_items(&mt9t001->ctrls, &mt9t001_ctrl_ops,
+                        V4L2_CID_TEST_PATTERN,
+                        ARRAY_SIZE(mt9t001_test_pattern_menu) - 1, 0,
+                        0, mt9t001_test_pattern_menu);
 
         for (i = 0; i < ARRAY_SIZE(mt9t001_ctrls); ++i)
                 v4l2_ctrl_new_custom(&mt9t001->ctrls, &mt9t001_ctrls[i], NULL);
diff --git a/drivers/media/i2c/mt9v032.c b/drivers/media/i2c/mt9v032.c
index e2177405dad2..3f356cb28256 100644
--- a/drivers/media/i2c/mt9v032.c
+++ b/drivers/media/i2c/mt9v032.c
@@ -141,6 +141,10 @@ struct mt9v032 {
         u16 chip_control;
         u16 aec_agc;
         u16 hblank;
+        struct {
+                struct v4l2_ctrl *test_pattern;
+                struct v4l2_ctrl *test_pattern_color;
+        };
 };
 
 static struct mt9v032 *to_mt9v032(struct v4l2_subdev *sd)
@@ -500,7 +504,7 @@ static int mt9v032_set_crop(struct v4l2_subdev *subdev,
  * V4L2 subdev control operations
  */
 
-#define V4L2_CID_TEST_PATTERN           (V4L2_CID_USER_BASE | 0x1001)
+#define V4L2_CID_TEST_PATTERN_COLOR     (V4L2_CID_USER_BASE | 0x1001)
 
 static int mt9v032_s_ctrl(struct v4l2_ctrl *ctrl)
 {
@@ -545,7 +549,7 @@ static int mt9v032_s_ctrl(struct v4l2_ctrl *ctrl)
                 break;
 
         case V4L2_CID_TEST_PATTERN:
-                switch (ctrl->val) {
+                switch (mt9v032->test_pattern->val) {
                 case 0:
                         data = 0;
                         break;
@@ -562,13 +566,13 @@ static int mt9v032_s_ctrl(struct v4l2_ctrl *ctrl)
                              | MT9V032_TEST_PATTERN_ENABLE;
                         break;
                 default:
-                        data = (ctrl->val << MT9V032_TEST_PATTERN_DATA_SHIFT)
+                        data = (mt9v032->test_pattern_color->val <<
+                                MT9V032_TEST_PATTERN_DATA_SHIFT)
                              | MT9V032_TEST_PATTERN_USE_DATA
                              | MT9V032_TEST_PATTERN_ENABLE
                              | MT9V032_TEST_PATTERN_FLIP;
                         break;
                 }
-
                 return mt9v032_write(client, MT9V032_TEST_PATTERN, data);
         }
 
@@ -579,18 +583,24 @@ static struct v4l2_ctrl_ops mt9v032_ctrl_ops = {
         .s_ctrl = mt9v032_s_ctrl,
 };
 
-static const struct v4l2_ctrl_config mt9v032_ctrls[] = {
-        {
-                .ops            = &mt9v032_ctrl_ops,
-                .id             = V4L2_CID_TEST_PATTERN,
-                .type           = V4L2_CTRL_TYPE_INTEGER,
-                .name           = "Test pattern",
-                .min            = 0,
-                .max            = 1023,
-                .step           = 1,
-                .def            = 0,
-                .flags          = 0,
-        }
+static const char * const mt9v032_test_pattern_menu[] = {
+        "Disabled",
+        "Gray Vertical Shade",
+        "Gray Horizontal Shade",
+        "Gray Diagonal Shade",
+        "Plain",
+};
+
+static const struct v4l2_ctrl_config mt9v032_test_pattern_color = {
+        .ops            = &mt9v032_ctrl_ops,
+        .id             = V4L2_CID_TEST_PATTERN_COLOR,
+        .type           = V4L2_CTRL_TYPE_INTEGER,
+        .name           = "Test Pattern Color",
+        .min            = 0,
+        .max            = 1023,
+        .step           = 1,
+        .def            = 0,
+        .flags          = 0,
 };
 
 /* -----------------------------------------------------------------------------
@@ -741,7 +751,7 @@ static int mt9v032_probe(struct i2c_client *client,
         mutex_init(&mt9v032->power_lock);
         mt9v032->pdata = pdata;
 
-        v4l2_ctrl_handler_init(&mt9v032->ctrls, ARRAY_SIZE(mt9v032_ctrls) + 8);
+        v4l2_ctrl_handler_init(&mt9v032->ctrls, 10);
 
         v4l2_ctrl_new_std(&mt9v032->ctrls, &mt9v032_ctrl_ops,
                           V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
@@ -763,6 +773,14 @@ static int mt9v032_probe(struct i2c_client *client,
                           V4L2_CID_VBLANK, MT9V032_VERTICAL_BLANKING_MIN,
                           MT9V032_VERTICAL_BLANKING_MAX, 1,
                           MT9V032_VERTICAL_BLANKING_DEF);
+        mt9v032->test_pattern = v4l2_ctrl_new_std_menu_items(&mt9v032->ctrls,
+                                &mt9v032_ctrl_ops, V4L2_CID_TEST_PATTERN,
+                                ARRAY_SIZE(mt9v032_test_pattern_menu) - 1, 0, 0,
+                                mt9v032_test_pattern_menu);
+        mt9v032->test_pattern_color = v4l2_ctrl_new_custom(&mt9v032->ctrls,
+                                      &mt9v032_test_pattern_color, NULL);
+
+        v4l2_ctrl_cluster(2, &mt9v032->test_pattern);
 
         mt9v032->pixel_rate =
                 v4l2_ctrl_new_std(&mt9v032->ctrls, &mt9v032_ctrl_ops,
@@ -784,8 +802,6 @@ static int mt9v032_probe(struct i2c_client *client,
                 v4l2_ctrl_cluster(2, &mt9v032->link_freq);
         }
 
-        for (i = 0; i < ARRAY_SIZE(mt9v032_ctrls); ++i)
-                v4l2_ctrl_new_custom(&mt9v032->ctrls, &mt9v032_ctrls[i], NULL);
 
         mt9v032->subdev.ctrl_handler = &mt9v032->ctrls;
 
diff --git a/drivers/media/i2c/soc_camera/ov2640.c b/drivers/media/i2c/soc_camera/ov2640.c
index 78ac5744cb5d..d2d298b6354e 100644
--- a/drivers/media/i2c/soc_camera/ov2640.c
+++ b/drivers/media/i2c/soc_camera/ov2640.c
@@ -684,6 +684,11 @@ static int ov2640_s_ctrl(struct v4l2_ctrl *ctrl)
                 &container_of(ctrl->handler, struct ov2640_priv, hdl)->subdev;
         struct i2c_client  *client = v4l2_get_subdevdata(sd);
         u8 val;
+        int ret;
+
+        ret = i2c_smbus_write_byte_data(client, BANK_SEL, BANK_SEL_SENS);
+        if (ret < 0)
+                return ret;
 
         switch (ctrl->id) {
         case V4L2_CID_VFLIP:
diff --git a/drivers/media/i2c/ths7303.c b/drivers/media/i2c/ths7303.c
index e5c0eedebc58..c31cc04fffd2 100644
--- a/drivers/media/i2c/ths7303.c
+++ b/drivers/media/i2c/ths7303.c
@@ -28,6 +28,18 @@
 #include <media/v4l2-subdev.h>
 #include <media/v4l2-chip-ident.h>
 
+#define THS7303_CHANNEL_1       1
+#define THS7303_CHANNEL_2       2
+#define THS7303_CHANNEL_3       3
+
+enum ths7303_filter_mode {
+        THS7303_FILTER_MODE_480I_576I,
+        THS7303_FILTER_MODE_480P_576P,
+        THS7303_FILTER_MODE_720P_1080I,
+        THS7303_FILTER_MODE_1080P,
+        THS7303_FILTER_MODE_DISABLE
+};
+
 MODULE_DESCRIPTION("TI THS7303 video amplifier driver");
 MODULE_AUTHOR("Chaithrika U S");
 MODULE_LICENSE("GPL");
@@ -37,35 +49,96 @@ module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Debug level 0-1");
 
 /* following function is used to set ths7303 */
-static int ths7303_setvalue(struct v4l2_subdev *sd, v4l2_std_id std)
+int ths7303_setval(struct v4l2_subdev *sd, enum ths7303_filter_mode mode)
 {
+        u8 input_bias_chroma = 3;
+        u8 input_bias_luma = 3;
+        int disable = 0;
         int err = 0;
-        u8 val;
-        struct i2c_client *client;
+        u8 val = 0;
+        u8 temp;
 
-        client = v4l2_get_subdevdata(sd);
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (std & (V4L2_STD_ALL & ~V4L2_STD_SECAM)) {
-                val = 0x02;
-                v4l2_dbg(1, debug, sd, "setting value for SDTV format\n");
-        } else {
-                val = 0x00;
-                v4l2_dbg(1, debug, sd, "disabling all channels\n");
+        if (!client)
+                return -EINVAL;
+
+        switch (mode) {
+        case THS7303_FILTER_MODE_1080P:
+                val = (3 << 6);
+                val |= (3 << 3);
+                break;
+        case THS7303_FILTER_MODE_720P_1080I:
+                val = (2 << 6);
+                val |= (2 << 3);
+                break;
+        case THS7303_FILTER_MODE_480P_576P:
+                val = (1 << 6);
+                val |= (1 << 3);
+                break;
+        case THS7303_FILTER_MODE_480I_576I:
+                break;
+        case THS7303_FILTER_MODE_DISABLE:
+                pr_info("mode disabled\n");
+                /* disable all channels */
+                disable = 1;
+        default:
+                /* disable all channels */
+                disable = 1;
         }
+        /* Setup channel 2 - Luma - Green */
+        temp = val;
+        if (!disable)
+                val |= input_bias_luma;
+        err = i2c_smbus_write_byte_data(client, THS7303_CHANNEL_2, val);
+        if (err)
+                goto out;
 
-        err |= i2c_smbus_write_byte_data(client, 0x01, val);
-        err |= i2c_smbus_write_byte_data(client, 0x02, val);
-        err |= i2c_smbus_write_byte_data(client, 0x03, val);
+        /* setup two chroma channels */
+        if (!disable)
+                temp |= input_bias_chroma;
 
+        err = i2c_smbus_write_byte_data(client, THS7303_CHANNEL_1, temp);
         if (err)
-                v4l2_err(sd, "write failed\n");
+                goto out;
 
+        err = i2c_smbus_write_byte_data(client, THS7303_CHANNEL_3, temp);
+        if (err)
+                goto out;
+        return err;
+out:
+        pr_info("write byte data failed\n");
         return err;
 }
 
 static int ths7303_s_std_output(struct v4l2_subdev *sd, v4l2_std_id norm)
 {
-        return ths7303_setvalue(sd, norm);
+        if (norm & (V4L2_STD_ALL & ~V4L2_STD_SECAM))
+                return ths7303_setval(sd, THS7303_FILTER_MODE_480I_576I);
+        else
+                return ths7303_setval(sd, THS7303_FILTER_MODE_DISABLE);
+}
+
+/* for setting filter for HD output */
+static int ths7303_s_dv_timings(struct v4l2_subdev *sd,
+                               struct v4l2_dv_timings *dv_timings)
+{
+        u32 height = dv_timings->bt.height;
+        int interlaced = dv_timings->bt.interlaced;
+        int res = 0;
+
+        if (height == 1080 && !interlaced)
+                res = ths7303_setval(sd, THS7303_FILTER_MODE_1080P);
+        else if ((height == 720 && !interlaced) ||
+                        (height == 1080 && interlaced))
+                res = ths7303_setval(sd, THS7303_FILTER_MODE_720P_1080I);
+        else if ((height == 480 || height == 576) && !interlaced)
+                res = ths7303_setval(sd, THS7303_FILTER_MODE_480P_576P);
+        else
+                /* disable all channels */
+                res = ths7303_setval(sd, THS7303_FILTER_MODE_DISABLE);
+
+        return res;
 }
 
 static int ths7303_g_chip_ident(struct v4l2_subdev *sd,
@@ -78,6 +151,7 @@ static int ths7303_g_chip_ident(struct v4l2_subdev *sd,
 
 static const struct v4l2_subdev_video_ops ths7303_video_ops = {
         .s_std_output   = ths7303_s_std_output,
+        .s_dv_timings    = ths7303_s_dv_timings,
 };
 
 static const struct v4l2_subdev_core_ops ths7303_core_ops = {
@@ -107,7 +181,7 @@ static int ths7303_probe(struct i2c_client *client,
 
         v4l2_i2c_subdev_init(sd, client, &ths7303_ops);
 
-        return ths7303_setvalue(sd, std_id);
+        return ths7303_s_std_output(sd, std_id);
 }
 
 static int ths7303_remove(struct i2c_client *client)
diff --git a/drivers/media/i2c/tvp514x.c b/drivers/media/i2c/tvp514x.c
index 1f3943bb87d5..d5e10215a28f 100644
--- a/drivers/media/i2c/tvp514x.c
+++ b/drivers/media/i2c/tvp514x.c
@@ -519,6 +519,12 @@ static int tvp514x_querystd(struct v4l2_subdev *sd, v4l2_std_id *std_id)
 
         *std_id = V4L2_STD_UNKNOWN;
 
+        /* To query the standard the TVP514x must power on the ADCs. */
+        if (!decoder->streaming) {
+                tvp514x_s_stream(sd, 1);
+                msleep(LOCK_RETRY_DELAY);
+        }
+
         /* query the current standard */
         current_std = tvp514x_query_current_std(sd);
         if (current_std == STD_INVALID)
@@ -625,25 +631,12 @@ static int tvp514x_s_routing(struct v4l2_subdev *sd,
         int err;
         enum tvp514x_input input_sel;
         enum tvp514x_output output_sel;
-        u8 sync_lock_status, lock_mask;
-        int try_count = LOCK_RETRY_COUNT;
 
         if ((input >= INPUT_INVALID) ||
                         (output >= OUTPUT_INVALID))
                 /* Index out of bound */
                 return -EINVAL;
 
-        /*
-         * For the sequence streamon -> streamoff and again s_input
-         * it fails to lock the signal, since streamoff puts TVP514x
-         * into power off state which leads to failure in sub-sequent s_input.
-         *
-         * So power up the TVP514x device here, since it is important to lock
-         * the signal at this stage.
-         */
-        if (!decoder->streaming)
-                tvp514x_s_stream(sd, 1);
-
         input_sel = input;
         output_sel = output;
 
@@ -660,64 +653,6 @@ static int tvp514x_s_routing(struct v4l2_subdev *sd,
 
         decoder->tvp514x_regs[REG_INPUT_SEL].val = input_sel;
         decoder->tvp514x_regs[REG_OUTPUT_FORMATTER1].val = output_sel;
-
-        /* Clear status */
-        msleep(LOCK_RETRY_DELAY);
-        err =
-            tvp514x_write_reg(sd, REG_CLEAR_LOST_LOCK, 0x01);
-        if (err)
-                return err;
-
-        switch (input_sel) {
-        case INPUT_CVBS_VI1A:
-        case INPUT_CVBS_VI1B:
-        case INPUT_CVBS_VI1C:
-        case INPUT_CVBS_VI2A:
-        case INPUT_CVBS_VI2B:
-        case INPUT_CVBS_VI2C:
-        case INPUT_CVBS_VI3A:
-        case INPUT_CVBS_VI3B:
-        case INPUT_CVBS_VI3C:
-        case INPUT_CVBS_VI4A:
-                lock_mask = STATUS_CLR_SUBCAR_LOCK_BIT |
-                        STATUS_HORZ_SYNC_LOCK_BIT |
-                        STATUS_VIRT_SYNC_LOCK_BIT;
-                break;
-
-        case INPUT_SVIDEO_VI2A_VI1A:
-        case INPUT_SVIDEO_VI2B_VI1B:
-        case INPUT_SVIDEO_VI2C_VI1C:
-        case INPUT_SVIDEO_VI2A_VI3A:
-        case INPUT_SVIDEO_VI2B_VI3B:
-        case INPUT_SVIDEO_VI2C_VI3C:
-        case INPUT_SVIDEO_VI4A_VI1A:
-        case INPUT_SVIDEO_VI4A_VI1B:
-        case INPUT_SVIDEO_VI4A_VI1C:
-        case INPUT_SVIDEO_VI4A_VI3A:
-        case INPUT_SVIDEO_VI4A_VI3B:
-        case INPUT_SVIDEO_VI4A_VI3C:
-                lock_mask = STATUS_HORZ_SYNC_LOCK_BIT |
-                        STATUS_VIRT_SYNC_LOCK_BIT;
-                break;
-        /* Need to add other interfaces*/
-        default:
-                return -EINVAL;
-        }
-
-        while (try_count-- > 0) {
-                /* Allow decoder to sync up with new input */
-                msleep(LOCK_RETRY_DELAY);
-
-                sync_lock_status = tvp514x_read_reg(sd,
-                                REG_STATUS1);
-                if (lock_mask == (sync_lock_status & lock_mask))
-                        /* Input detected */
-                        break;
-        }
-
-        if (try_count < 0)
-                return -EINVAL;
-
         decoder->input = input;
         decoder->output = output;