Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

Pull second set of media updates from Mauro Carvalho Chehab:
 "Despite its size, most of the stuff here is trivial.  This series
  contains:

   - s5p-mfc: additions at the driver and at the core to support H.264
     hardware codec;
   - Some improvements at s5p and davinci embedded drivers;
   - Some V4L2 compliance fixes applied on a few drivers;
   - Several random trivial patches, including several fixes and a few
     new board support additions;

  Notes:

   1) Some Exynos media patches were dependent on some -arm fixes that
      got merged on changeset 782cd9e.  That's why this pull request is
      based that changeset.

   2) As promised, I reviewed the pending VB2 DMABUF series.

      While setting a test environment, it was noticed that the upstream
      support for Samsung Exynos 4 boards (smdk310 and Origen) are
      broken upstream, likely due to regressions: both defconfigs are
      wrong and regulator settings for both boards are broken.  That,
      allied with some bug at the dummy regulator driver, causes OOPSes
      during boot time.

      Long story short: even fixing the above, the proposed patches
      OOPSed when running the DMABUF test.  Not sure yet if the OOPSes
      are due to some other undetected regressions, or due to some bug
      on the patches.

      Due to the above, DMABUF patches for vb2 got NACKed for 3.7."

* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (109 commits)
  [media] m5mols: Add missing #include <linux/sizes.h>
  [media] stk1160: Add support for S-Video input
  Revert "[media] omap3isp: Replace cpu_is_omap3630() with ISP revision check"
  [media]  dvb: LNA implementation changes
  [media] v4l2-ioctl: fix W=1 warnings
  [media] v4l2-ioctl: add blocks check for VIDIOC_SUBDEV_G/S_EDID
  [media] omap3isp: Fix compilation error in ispreg.h
  [media] rc-msi-digivox-ii: Add full scan keycodes
  [media] cx25821: testing the wrong variable
  [media] tda18271-common: hold the I2C adapter during write transfers
  [media] ds3000: add module parameter to force firmware upload
  [media] drivers/media: Remove unnecessary semicolon
  [media] winbond: remove space from driver name
  [media] iguanair: cannot send data from the stack
  [media] omap3isp: Replace cpu_is_omap3630() with ISP revision check
  [media] dvb-usb: print small buffers via %*ph
  [media] uvc: Add return code check at vb2_queue_init()
  [media] em28xx: Replace memcpy with struct assignment
  [media] bt8xx: Add video4linux control V4L2_CID_COLOR_KILLER
  [media] mem2mem_testdev: Use devm_kzalloc() in probe
  ...

Conflicts:
	arch/arm/mach-davinci/include/mach/da8xx.h

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;