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

Pull media updates from Mauro Carvalho Chehab:

 - Some cleanups at V4L2 documentation

 - new drivers: ts2020 frontend, ov9650 sensor, s5c73m3 sensor,
   sh-mobile veu mem2mem driver, radio-ma901, davinci_vpfe staging
   driver

 - Lots of missing MAINTAINERS entries added

 - several em28xx driver improvements, including its conversion to
   videobuf2

 - several fixups on drivers to make them to better comply with the API

 - DVB core: add support for DVBv5 stats, allowing the implementation of
   statistics for new standards like ISDB

 - mb86a20s: add statistics to the driver

 - lots of new board additions, cleanups, and driver improvements.

* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (596 commits)
  [media] media: Add 0x3009 USB PID to ttusb2 driver (fixed diff)
  [media] rtl28xxu: Add USB IDs for Compro VideoMate U620F
  [media] em28xx: add usb id for terratec h5 rev. 3
  [media] media: rc: gpio-ir-recv: add support for device tree parsing
  [media] mceusb: move check earlier to make smatch happy
  [media] radio-si470x doc: add info about v4l2-ctl and sox+alsa
  [media] staging: media: Remove unnecessary OOM messages
  [media] sh_vou: Use vou_dev instead of vou_file wherever possible
  [media] sh_vou: Use video_drvdata()
  [media] drivers/media/platform/soc_camera/pxa_camera.c: use devm_ functions
  [media] mt9t112: mt9t111 format set up differs from mt9t112
  [media] sh-mobile-ceu-camera: fix SHARPNESS control default
  Revert "[media] fc0011: Return early, if the frequency is already tuned"
  [media] cx18/ivtv: fix regression: remove __init from a non-init function
  [media] em28xx: fix analog streaming with USB bulk transfers
  [media] stv0900: remove unnecessary null pointer check
  [media] fc0011: Return early, if the frequency is already tuned
  [media] fc0011: Add some sanity checks and cleanups
  [media] fc0011: Fix xin value clamping
  Revert "[media] [PATH,1/2] mxl5007 move reset to attach"
  ...

93 files changed, 3680 insertions, 2171 deletions

diff --git a/drivers/media/platform/Kconfig b/drivers/media/platform/Kconfig
index 33241120a58c..05d7b6333461 100644
--- a/drivers/media/platform/Kconfig
+++ b/drivers/media/platform/Kconfig
@@ -92,7 +92,7 @@ config VIDEO_M32R_AR_M64278
 
 config VIDEO_OMAP2
         tristate "OMAP2 Camera Capture Interface driver"
-        depends on VIDEO_DEV && ARCH_OMAP2
+        depends on VIDEO_DEV && ARCH_OMAP2 && VIDEO_V4L2_INT_DEVICE
         select VIDEOBUF_DMA_SG
         ---help---
           This is a v4l2 driver for the TI OMAP2 camera capture interface
@@ -202,6 +202,15 @@ config VIDEO_SAMSUNG_EXYNOS_GSC
         help
           This is a v4l2 driver for Samsung EXYNOS5 SoC G-Scaler.
 
+config VIDEO_SH_VEU
+        tristate "SuperH VEU mem2mem video processing driver"
+        depends on VIDEO_DEV && VIDEO_V4L2
+        select VIDEOBUF2_DMA_CONTIG
+        select V4L2_MEM2MEM_DEV
+        help
+            Support for the Video Engine Unit (VEU) on SuperH and
+            SH-Mobile SoCs.
+
 endif # V4L_MEM2MEM_DRIVERS
 
 menuconfig V4L_TEST_DRIVERS
diff --git a/drivers/media/platform/Makefile b/drivers/media/platform/Makefile
index 4817d2802171..42089ba3600f 100644
--- a/drivers/media/platform/Makefile
+++ b/drivers/media/platform/Makefile
@@ -25,6 +25,8 @@ obj-$(CONFIG_VIDEO_MEM2MEM_TESTDEV) += mem2mem_testdev.o
 obj-$(CONFIG_VIDEO_MX2_EMMAPRP)         += mx2_emmaprp.o
 obj-$(CONFIG_VIDEO_CODA)                += coda.o
 
+obj-$(CONFIG_VIDEO_SH_VEU)              += sh_veu.o
+
 obj-$(CONFIG_VIDEO_MEM2MEM_DEINTERLACE) += m2m-deinterlace.o
 
 obj-$(CONFIG_VIDEO_S3C_CAMIF)           += s3c-camif/
diff --git a/drivers/media/platform/blackfin/Kconfig b/drivers/media/platform/blackfin/Kconfig
index ecd5323768b7..cc239972fa2c 100644
--- a/drivers/media/platform/blackfin/Kconfig
+++ b/drivers/media/platform/blackfin/Kconfig
@@ -7,4 +7,9 @@ config VIDEO_BLACKFIN_CAPTURE
           Choose PPI or EPPI as its interface.
 
           To compile this driver as a module, choose M here: the
-          module will be called bfin_video_capture.
+          module will be called bfin_capture.
+
+config VIDEO_BLACKFIN_PPI
+        tristate
+        depends on VIDEO_BLACKFIN_CAPTURE
+        default VIDEO_BLACKFIN_CAPTURE
diff --git a/drivers/media/platform/blackfin/Makefile b/drivers/media/platform/blackfin/Makefile
index aa3a0a216387..30421bc23080 100644
--- a/drivers/media/platform/blackfin/Makefile
+++ b/drivers/media/platform/blackfin/Makefile
@@ -1,2 +1,2 @@
-bfin_video_capture-objs := bfin_capture.o ppi.o
-obj-$(CONFIG_VIDEO_BLACKFIN_CAPTURE) += bfin_video_capture.o
+obj-$(CONFIG_VIDEO_BLACKFIN_CAPTURE) += bfin_capture.o
+obj-$(CONFIG_VIDEO_BLACKFIN_PPI)     += ppi.o
diff --git a/drivers/media/platform/blackfin/bfin_capture.c b/drivers/media/platform/blackfin/bfin_capture.c
index 1aad2a65d2f3..5f209d5810dc 100644
--- a/drivers/media/platform/blackfin/bfin_capture.c
+++ b/drivers/media/platform/blackfin/bfin_capture.c
@@ -52,6 +52,7 @@ struct bcap_format {
         u32 pixelformat;
         enum v4l2_mbus_pixelcode mbus_code;
         int bpp; /* bits per pixel */
+        int dlen; /* data length for ppi in bits */
 };
 
 struct bcap_buffer {
@@ -76,18 +77,20 @@ struct bcap_device {
         unsigned int cur_input;
         /* current selected standard */
         v4l2_std_id std;
+        /* current selected dv_timings */
+        struct v4l2_dv_timings dv_timings;
         /* used to store pixel format */
         struct v4l2_pix_format fmt;
         /* bits per pixel*/
         int bpp;
+        /* data length for ppi in bits */
+        int dlen;
         /* used to store sensor supported format */
         struct bcap_format *sensor_formats;
         /* number of sensor formats array */
         int num_sensor_formats;
         /* pointing to current video buffer */
         struct bcap_buffer *cur_frm;
-        /* pointing to next video buffer */
-        struct bcap_buffer *next_frm;
         /* buffer queue used in videobuf2 */
         struct vb2_queue buffer_queue;
         /* allocator-specific contexts for each plane */
@@ -116,24 +119,35 @@ static const struct bcap_format bcap_formats[] = {
                 .pixelformat = V4L2_PIX_FMT_UYVY,
                 .mbus_code   = V4L2_MBUS_FMT_UYVY8_2X8,
                 .bpp         = 16,
+                .dlen        = 8,
         },
         {
                 .desc        = "YCbCr 4:2:2 Interleaved YUYV",
                 .pixelformat = V4L2_PIX_FMT_YUYV,
                 .mbus_code   = V4L2_MBUS_FMT_YUYV8_2X8,
                 .bpp         = 16,
+                .dlen        = 8,
+        },
+        {
+                .desc        = "YCbCr 4:2:2 Interleaved UYVY",
+                .pixelformat = V4L2_PIX_FMT_UYVY,
+                .mbus_code   = V4L2_MBUS_FMT_UYVY8_1X16,
+                .bpp         = 16,
+                .dlen        = 16,
         },
         {
                 .desc        = "RGB 565",
                 .pixelformat = V4L2_PIX_FMT_RGB565,
                 .mbus_code   = V4L2_MBUS_FMT_RGB565_2X8_LE,
                 .bpp         = 16,
+                .dlen        = 8,
         },
         {
                 .desc        = "RGB 444",
                 .pixelformat = V4L2_PIX_FMT_RGB444,
                 .mbus_code   = V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE,
                 .bpp         = 16,
+                .dlen        = 8,
         },
 
 };
@@ -366,9 +380,39 @@ static int bcap_start_streaming(struct vb2_queue *vq, unsigned int count)
         params.width = bcap_dev->fmt.width;
         params.height = bcap_dev->fmt.height;
         params.bpp = bcap_dev->bpp;
+        params.dlen = bcap_dev->dlen;
         params.ppi_control = bcap_dev->cfg->ppi_control;
         params.int_mask = bcap_dev->cfg->int_mask;
-        params.blank_clocks = bcap_dev->cfg->blank_clocks;
+        if (bcap_dev->cfg->inputs[bcap_dev->cur_input].capabilities
+                        & V4L2_IN_CAP_CUSTOM_TIMINGS) {
+                struct v4l2_bt_timings *bt = &bcap_dev->dv_timings.bt;
+
+                params.hdelay = bt->hsync + bt->hbackporch;
+                params.vdelay = bt->vsync + bt->vbackporch;
+                params.line = bt->hfrontporch + bt->hsync
+                                + bt->hbackporch + bt->width;
+                params.frame = bt->vfrontporch + bt->vsync
+                                + bt->vbackporch + bt->height;
+                if (bt->interlaced)
+                        params.frame += bt->il_vfrontporch + bt->il_vsync
+                                        + bt->il_vbackporch;
+        } else if (bcap_dev->cfg->inputs[bcap_dev->cur_input].capabilities
+                        & V4L2_IN_CAP_STD) {
+                params.hdelay = 0;
+                params.vdelay = 0;
+                if (bcap_dev->std & V4L2_STD_525_60) {
+                        params.line = 858;
+                        params.frame = 525;
+                } else {
+                        params.line = 864;
+                        params.frame = 625;
+                }
+        } else {
+                params.hdelay = 0;
+                params.vdelay = 0;
+                params.line = params.width + bcap_dev->cfg->blank_pixels;
+                params.frame = params.height;
+        }
         ret = ppi->ops->set_params(ppi, &params);
         if (ret < 0) {
                 v4l2_err(&bcap_dev->v4l2_dev,
@@ -409,10 +453,10 @@ static int bcap_stop_streaming(struct vb2_queue *vq)
 
         /* release all active buffers */
         while (!list_empty(&bcap_dev->dma_queue)) {
-                bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next,
+                bcap_dev->cur_frm = list_entry(bcap_dev->dma_queue.next,
                                                 struct bcap_buffer, list);
-                list_del(&bcap_dev->next_frm->list);
-                vb2_buffer_done(&bcap_dev->next_frm->vb, VB2_BUF_STATE_ERROR);
+                list_del(&bcap_dev->cur_frm->list);
+                vb2_buffer_done(&bcap_dev->cur_frm->vb, VB2_BUF_STATE_ERROR);
         }
         return 0;
 }
@@ -484,17 +528,26 @@ static irqreturn_t bcap_isr(int irq, void *dev_id)
 {
         struct ppi_if *ppi = dev_id;
         struct bcap_device *bcap_dev = ppi->priv;
-        struct timeval timevalue;
         struct vb2_buffer *vb = &bcap_dev->cur_frm->vb;
         dma_addr_t addr;
 
         spin_lock(&bcap_dev->lock);
 
-        if (bcap_dev->cur_frm != bcap_dev->next_frm) {
-                do_gettimeofday(&timevalue);
-                vb->v4l2_buf.timestamp = timevalue;
-                vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
-                bcap_dev->cur_frm = bcap_dev->next_frm;
+        if (!list_empty(&bcap_dev->dma_queue)) {
+                v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
+                if (ppi->err) {
+                        vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
+                        ppi->err = false;
+                } else {
+                        vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
+                }
+                bcap_dev->cur_frm = list_entry(bcap_dev->dma_queue.next,
+                                struct bcap_buffer, list);
+                list_del(&bcap_dev->cur_frm->list);
+        } else {
+                /* clear error flag, we will get a new frame */
+                if (ppi->err)
+                        ppi->err = false;
         }
 
         ppi->ops->stop(ppi);
@@ -502,13 +555,8 @@ static irqreturn_t bcap_isr(int irq, void *dev_id)
         if (bcap_dev->stop) {
                 complete(&bcap_dev->comp);
         } else {
-                if (!list_empty(&bcap_dev->dma_queue)) {
-                        bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next,
-                                                struct bcap_buffer, list);
-                        list_del(&bcap_dev->next_frm->list);
-                        addr = vb2_dma_contig_plane_dma_addr(&bcap_dev->next_frm->vb, 0);
-                        ppi->ops->update_addr(ppi, (unsigned long)addr);
-                }
+                addr = vb2_dma_contig_plane_dma_addr(&bcap_dev->cur_frm->vb, 0);
+                ppi->ops->update_addr(ppi, (unsigned long)addr);
                 ppi->ops->start(ppi);
         }
 
@@ -542,9 +590,8 @@ static int bcap_streamon(struct file *file, void *priv,
         }
 
         /* get the next frame from the dma queue */
-        bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next,
+        bcap_dev->cur_frm = list_entry(bcap_dev->dma_queue.next,
                                         struct bcap_buffer, list);
-        bcap_dev->cur_frm = bcap_dev->next_frm;
         /* remove buffer from the dma queue */
         list_del(&bcap_dev->cur_frm->list);
         addr = vb2_dma_contig_plane_dma_addr(&bcap_dev->cur_frm->vb, 0);
@@ -602,6 +649,37 @@ static int bcap_s_std(struct file *file, void *priv, v4l2_std_id *std)
         return 0;
 }
 
+static int bcap_g_dv_timings(struct file *file, void *priv,
+                                struct v4l2_dv_timings *timings)
+{
+        struct bcap_device *bcap_dev = video_drvdata(file);
+        int ret;
+
+        ret = v4l2_subdev_call(bcap_dev->sd, video,
+                                g_dv_timings, timings);
+        if (ret < 0)
+                return ret;
+
+        bcap_dev->dv_timings = *timings;
+        return 0;
+}
+
+static int bcap_s_dv_timings(struct file *file, void *priv,
+                                struct v4l2_dv_timings *timings)
+{
+        struct bcap_device *bcap_dev = video_drvdata(file);
+        int ret;
+        if (vb2_is_busy(&bcap_dev->buffer_queue))
+                return -EBUSY;
+
+        ret = v4l2_subdev_call(bcap_dev->sd, video, s_dv_timings, timings);
+        if (ret < 0)
+                return ret;
+
+        bcap_dev->dv_timings = *timings;
+        return 0;
+}
+
 static int bcap_enum_input(struct file *file, void *priv,
                                 struct v4l2_input *input)
 {
@@ -650,13 +728,15 @@ static int bcap_s_input(struct file *file, void *priv, unsigned int index)
                 return ret;
         }
         bcap_dev->cur_input = index;
+        /* if this route has specific config, update ppi control */
+        if (route->ppi_control)
+                config->ppi_control = route->ppi_control;
         return 0;
 }
 
 static int bcap_try_format(struct bcap_device *bcap,
                                 struct v4l2_pix_format *pixfmt,
-                                enum v4l2_mbus_pixelcode *mbus_code,
-                                int *bpp)
+                                struct bcap_format *bcap_fmt)
 {
         struct bcap_format *sf = bcap->sensor_formats;
         struct bcap_format *fmt = NULL;
@@ -671,16 +751,20 @@ static int bcap_try_format(struct bcap_device *bcap,
         if (i == bcap->num_sensor_formats)
                 fmt = &sf[0];
 
-        if (mbus_code)
-                *mbus_code = fmt->mbus_code;
-        if (bpp)
-                *bpp = fmt->bpp;
         v4l2_fill_mbus_format(&mbus_fmt, pixfmt, fmt->mbus_code);
         ret = v4l2_subdev_call(bcap->sd, video,
                                 try_mbus_fmt, &mbus_fmt);
         if (ret < 0)
                 return ret;
         v4l2_fill_pix_format(pixfmt, &mbus_fmt);
+        if (bcap_fmt) {
+                for (i = 0; i < bcap->num_sensor_formats; i++) {
+                        fmt = &sf[i];
+                        if (mbus_fmt.code == fmt->mbus_code)
+                                break;
+                }
+                *bcap_fmt = *fmt;
+        }
         pixfmt->bytesperline = pixfmt->width * fmt->bpp / 8;
         pixfmt->sizeimage = pixfmt->bytesperline * pixfmt->height;
         return 0;
@@ -709,7 +793,7 @@ static int bcap_try_fmt_vid_cap(struct file *file, void *priv,
         struct bcap_device *bcap_dev = video_drvdata(file);
         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 
-        return bcap_try_format(bcap_dev, pixfmt, NULL, NULL);
+        return bcap_try_format(bcap_dev, pixfmt, NULL);
 }
 
 static int bcap_g_fmt_vid_cap(struct file *file, void *priv,
@@ -726,24 +810,25 @@ static int bcap_s_fmt_vid_cap(struct file *file, void *priv,
 {
         struct bcap_device *bcap_dev = video_drvdata(file);
         struct v4l2_mbus_framefmt mbus_fmt;
-        enum v4l2_mbus_pixelcode mbus_code;
+        struct bcap_format bcap_fmt;
         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
-        int ret, bpp;
+        int ret;
 
         if (vb2_is_busy(&bcap_dev->buffer_queue))
                 return -EBUSY;
 
         /* see if format works */
-        ret = bcap_try_format(bcap_dev, pixfmt, &mbus_code, &bpp);
+        ret = bcap_try_format(bcap_dev, pixfmt, &bcap_fmt);
         if (ret < 0)
                 return ret;
 
-        v4l2_fill_mbus_format(&mbus_fmt, pixfmt, mbus_code);
+        v4l2_fill_mbus_format(&mbus_fmt, pixfmt, bcap_fmt.mbus_code);
         ret = v4l2_subdev_call(bcap_dev->sd, video, s_mbus_fmt, &mbus_fmt);
         if (ret < 0)
                 return ret;
         bcap_dev->fmt = *pixfmt;
-        bcap_dev->bpp = bpp;
+        bcap_dev->bpp = bcap_fmt.bpp;
+        bcap_dev->dlen = bcap_fmt.dlen;
         return 0;
 }
 
@@ -834,6 +919,8 @@ static const struct v4l2_ioctl_ops bcap_ioctl_ops = {
         .vidioc_querystd         = bcap_querystd,
         .vidioc_s_std            = bcap_s_std,
         .vidioc_g_std            = bcap_g_std,
+        .vidioc_s_dv_timings     = bcap_s_dv_timings,
+        .vidioc_g_dv_timings     = bcap_g_dv_timings,
         .vidioc_reqbufs          = bcap_reqbufs,
         .vidioc_querybuf         = bcap_querybuf,
         .vidioc_qbuf             = bcap_qbuf,
@@ -869,6 +956,7 @@ static int bcap_probe(struct platform_device *pdev)
         struct i2c_adapter *i2c_adap;
         struct bfin_capture_config *config;
         struct vb2_queue *q;
+        struct bcap_route *route;
         int ret;
 
         config = pdev->dev.platform_data;
@@ -978,6 +1066,12 @@ static int bcap_probe(struct platform_device *pdev)
                                                  NULL);
         if (bcap_dev->sd) {
                 int i;
+                if (!config->num_inputs) {
+                        v4l2_err(&bcap_dev->v4l2_dev,
+                                        "Unable to work without input\n");
+                        goto err_unreg_vdev;
+                }
+
                 /* update tvnorms from the sub devices */
                 for (i = 0; i < config->num_inputs; i++)
                         vfd->tvnorms |= config->inputs[i].std;
@@ -989,8 +1083,24 @@ static int bcap_probe(struct platform_device *pdev)
 
         v4l2_info(&bcap_dev->v4l2_dev, "v4l2 sub device registered\n");
 
+        /*
+         * explicitly set input, otherwise some boards
+         * may not work at the state as we expected
+         */
+        route = &config->routes[0];
+        ret = v4l2_subdev_call(bcap_dev->sd, video, s_routing,
+                                route->input, route->output, 0);
+        if ((ret < 0) && (ret != -ENOIOCTLCMD)) {
+                v4l2_err(&bcap_dev->v4l2_dev, "Failed to set input\n");
+                goto err_unreg_vdev;
+        }
+        bcap_dev->cur_input = 0;
+        /* if this route has specific config, update ppi control */
+        if (route->ppi_control)
+                config->ppi_control = route->ppi_control;
+
         /* now we can probe the default state */
-        if (vfd->tvnorms) {
+        if (config->inputs[0].capabilities & V4L2_IN_CAP_STD) {
                 v4l2_std_id std;
                 ret = v4l2_subdev_call(bcap_dev->sd, core, g_std, &std);
                 if (ret) {
@@ -1000,6 +1110,17 @@ static int bcap_probe(struct platform_device *pdev)
                 }
                 bcap_dev->std = std;
         }
+        if (config->inputs[0].capabilities & V4L2_IN_CAP_CUSTOM_TIMINGS) {
+                struct v4l2_dv_timings dv_timings;
+                ret = v4l2_subdev_call(bcap_dev->sd, video,
+                                g_dv_timings, &dv_timings);
+                if (ret) {
+                        v4l2_err(&bcap_dev->v4l2_dev,
+                                        "Unable to get dv timings\n");
+                        goto err_unreg_vdev;
+                }
+                bcap_dev->dv_timings = dv_timings;
+        }
         ret = bcap_init_sensor_formats(bcap_dev);
         if (ret) {
                 v4l2_err(&bcap_dev->v4l2_dev,
diff --git a/drivers/media/platform/blackfin/ppi.c b/drivers/media/platform/blackfin/ppi.c
index d29592186b02..01b5b501347e 100644
--- a/drivers/media/platform/blackfin/ppi.c
+++ b/drivers/media/platform/blackfin/ppi.c
@@ -17,6 +17,7 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <linux/module.h>
 #include <linux/slab.h>
 
 #include <asm/bfin_ppi.h>
@@ -58,15 +59,33 @@ static irqreturn_t ppi_irq_err(int irq, void *dev_id)
                  * others are W1C
                  */
                 status = bfin_read16(&reg->status);
+                if (status & 0x3000)
+                        ppi->err = true;
                 bfin_write16(&reg->status, 0xff00);
                 break;
         }
         case PPI_TYPE_EPPI:
         {
                 struct bfin_eppi_regs *reg = info->base;
+                unsigned short status;
+
+                status = bfin_read16(&reg->status);
+                if (status & 0x2)
+                        ppi->err = true;
                 bfin_write16(&reg->status, 0xffff);
                 break;
         }
+        case PPI_TYPE_EPPI3:
+        {
+                struct bfin_eppi3_regs *reg = info->base;
+                unsigned long stat;
+
+                stat = bfin_read32(&reg->stat);
+                if (stat & 0x2)
+                        ppi->err = true;
+                bfin_write32(&reg->stat, 0xc0ff);
+                break;
+        }
         default:
                 break;
         }
@@ -128,6 +147,12 @@ static int ppi_start(struct ppi_if *ppi)
                 bfin_write32(&reg->control, ppi->ppi_control);
                 break;
         }
+        case PPI_TYPE_EPPI3:
+        {
+                struct bfin_eppi3_regs *reg = info->base;
+                bfin_write32(&reg->ctl, ppi->ppi_control);
+                break;
+        }
         default:
                 return -EINVAL;
         }
@@ -155,6 +180,12 @@ static int ppi_stop(struct ppi_if *ppi)
                 bfin_write32(&reg->control, ppi->ppi_control);
                 break;
         }
+        case PPI_TYPE_EPPI3:
+        {
+                struct bfin_eppi3_regs *reg = info->base;
+                bfin_write32(&reg->ctl, ppi->ppi_control);
+                break;
+        }
         default:
                 return -EINVAL;
         }
@@ -171,17 +202,23 @@ static int ppi_set_params(struct ppi_if *ppi, struct ppi_params *params)
 {
         const struct ppi_info *info = ppi->info;
         int dma32 = 0;
-        int dma_config, bytes_per_line, lines_per_frame;
+        int dma_config, bytes_per_line;
+        int hcount, hdelay, samples_per_line;
 
         bytes_per_line = params->width * params->bpp / 8;
-        lines_per_frame = params->height;
+        /* convert parameters unit from pixels to samples */
+        hcount = params->width * params->bpp / params->dlen;
+        hdelay = params->hdelay * params->bpp / params->dlen;
+        samples_per_line = params->line * params->bpp / params->dlen;
         if (params->int_mask == 0xFFFFFFFF)
                 ppi->err_int = false;
         else
                 ppi->err_int = true;
 
-        dma_config = (DMA_FLOW_STOP | WNR | RESTART | DMA2D | DI_EN);
+        dma_config = (DMA_FLOW_STOP | RESTART | DMA2D | DI_EN_Y);
         ppi->ppi_control = params->ppi_control & ~PORT_EN;
+        if (!(ppi->ppi_control & PORT_DIR))
+                dma_config |= WNR;
         switch (info->type) {
         case PPI_TYPE_PPI:
         {
@@ -191,8 +228,8 @@ static int ppi_set_params(struct ppi_if *ppi, struct ppi_params *params)
                         dma32 = 1;
 
                 bfin_write16(&reg->control, ppi->ppi_control);
-                bfin_write16(&reg->count, bytes_per_line - 1);
-                bfin_write16(&reg->frame, lines_per_frame);
+                bfin_write16(&reg->count, samples_per_line - 1);
+                bfin_write16(&reg->frame, params->frame);
                 break;
         }
         case PPI_TYPE_EPPI:
@@ -204,12 +241,31 @@ static int ppi_set_params(struct ppi_if *ppi, struct ppi_params *params)
                         dma32 = 1;
 
                 bfin_write32(&reg->control, ppi->ppi_control);
-                bfin_write16(&reg->line, bytes_per_line + params->blank_clocks);
-                bfin_write16(&reg->frame, lines_per_frame);
-                bfin_write16(&reg->hdelay, 0);
-                bfin_write16(&reg->vdelay, 0);
-                bfin_write16(&reg->hcount, bytes_per_line);
-                bfin_write16(&reg->vcount, lines_per_frame);
+                bfin_write16(&reg->line, samples_per_line);
+                bfin_write16(&reg->frame, params->frame);
+                bfin_write16(&reg->hdelay, hdelay);
+                bfin_write16(&reg->vdelay, params->vdelay);
+                bfin_write16(&reg->hcount, hcount);
+                bfin_write16(&reg->vcount, params->height);
+                break;
+        }
+        case PPI_TYPE_EPPI3:
+        {
+                struct bfin_eppi3_regs *reg = info->base;
+
+                if ((params->ppi_control & PACK_EN)
+                        || (params->ppi_control & 0x70000) > DLEN_16)
+                        dma32 = 1;
+
+                bfin_write32(&reg->ctl, ppi->ppi_control);
+                bfin_write32(&reg->line, samples_per_line);
+                bfin_write32(&reg->frame, params->frame);
+                bfin_write32(&reg->hdly, hdelay);
+                bfin_write32(&reg->vdly, params->vdelay);
+                bfin_write32(&reg->hcnt, hcount);
+                bfin_write32(&reg->vcnt, params->height);
+                if (params->int_mask)
+                        bfin_write32(&reg->imsk, params->int_mask & 0xFF);
                 break;
         }
         default:
@@ -217,17 +273,17 @@ static int ppi_set_params(struct ppi_if *ppi, struct ppi_params *params)
         }
 
         if (dma32) {
-                dma_config |= WDSIZE_32;
+                dma_config |= WDSIZE_32 | PSIZE_32;
                 set_dma_x_count(info->dma_ch, bytes_per_line >> 2);
                 set_dma_x_modify(info->dma_ch, 4);
                 set_dma_y_modify(info->dma_ch, 4);
         } else {
-                dma_config |= WDSIZE_16;
+                dma_config |= WDSIZE_16 | PSIZE_16;
                 set_dma_x_count(info->dma_ch, bytes_per_line >> 1);
                 set_dma_x_modify(info->dma_ch, 2);
                 set_dma_y_modify(info->dma_ch, 2);
         }
-        set_dma_y_count(info->dma_ch, lines_per_frame);
+        set_dma_y_count(info->dma_ch, params->height);
         set_dma_config(info->dma_ch, dma_config);
 
         SSYNC();
@@ -263,9 +319,15 @@ struct ppi_if *ppi_create_instance(const struct ppi_info *info)
         pr_info("ppi probe success\n");
         return ppi;
 }
+EXPORT_SYMBOL(ppi_create_instance);
 
 void ppi_delete_instance(struct ppi_if *ppi)
 {
         peripheral_free_list(ppi->info->pin_req);
         kfree(ppi);
 }
+EXPORT_SYMBOL(ppi_delete_instance);
+
+MODULE_DESCRIPTION("Analog Devices PPI driver");
+MODULE_AUTHOR("Scott Jiang <Scott.Jiang.Linux@gmail.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/platform/coda.c b/drivers/media/platform/coda.c
index 4a980e029ca7..20827ba168fc 100644
--- a/drivers/media/platform/coda.c
+++ b/drivers/media/platform/coda.c
@@ -178,6 +178,10 @@ struct coda_ctx {
         int                             idx;
 };
 
+static const u8 coda_filler_nal[14] = { 0x00, 0x00, 0x00, 0x01, 0x0c, 0xff,
+                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80 };
+static const u8 coda_filler_size[8] = { 0, 7, 14, 13, 12, 11, 10, 9 };
+
 static inline void coda_write(struct coda_dev *dev, u32 data, u32 reg)
 {
         v4l2_dbg(1, coda_debug, &dev->v4l2_dev,
@@ -944,6 +948,24 @@ static int coda_alloc_framebuffers(struct coda_ctx *ctx, struct coda_q_data *q_d
         return 0;
 }
 
+static int coda_h264_padding(int size, char *p)
+{
+        int nal_size;
+        int diff;
+
+        diff = size - (size & ~0x7);
+        if (diff == 0)
+                return 0;
+
+        nal_size = coda_filler_size[diff];
+        memcpy(p, coda_filler_nal, nal_size);
+
+        /* Add rbsp stop bit and trailing at the end */
+        *(p + nal_size - 1) = 0x80;
+
+        return nal_size;
+}
+
 static int coda_start_streaming(struct vb2_queue *q, unsigned int count)
 {
         struct coda_ctx *ctx = vb2_get_drv_priv(q);
@@ -1171,7 +1193,15 @@ static int coda_start_streaming(struct vb2_queue *q, unsigned int count)
                                 coda_read(dev, CODA_CMD_ENC_HEADER_BB_START);
                 memcpy(&ctx->vpu_header[1][0], vb2_plane_vaddr(buf, 0),
                        ctx->vpu_header_size[1]);
-                ctx->vpu_header_size[2] = 0;
+                /*
+                 * Length of H.264 headers is variable and thus it might not be
+                 * aligned for the coda to append the encoded frame. In that is
+                 * the case a filler NAL must be added to header 2.
+                 */
+                ctx->vpu_header_size[2] = coda_h264_padding(
+                                        (ctx->vpu_header_size[0] +
+                                         ctx->vpu_header_size[1]),
+                                         ctx->vpu_header[2]);
                 break;
         case V4L2_PIX_FMT_MPEG4:
                 /*
diff --git a/drivers/media/platform/davinci/Kconfig b/drivers/media/platform/davinci/Kconfig
index 3c56037c82fc..ccfde4eb626a 100644
--- a/drivers/media/platform/davinci/Kconfig
+++ b/drivers/media/platform/davinci/Kconfig
@@ -97,25 +97,15 @@ config VIDEO_ISIF
            To compile this driver as a module, choose M here: the
            module will be called vpfe.
 
-config VIDEO_DM644X_VPBE
-        tristate "DM644X VPBE HW module"
-        depends on ARCH_DAVINCI_DM644x
+config VIDEO_DAVINCI_VPBE_DISPLAY
+        tristate "DM644X/DM365/DM355 VPBE HW module"
+        depends on ARCH_DAVINCI_DM644x || ARCH_DAVINCI_DM355 || ARCH_DAVINCI_DM365
         select VIDEO_VPSS_SYSTEM
         select VIDEOBUF2_DMA_CONTIG
         help
-            Enables VPBE modules used for display on a DM644x
-            SoC.
+            Enables Davinci VPBE module used for display devices.
+            This module is common for following DM644x/DM365/DM355
+            based display devices.
 
             To compile this driver as a module, choose M here: the
             module will be called vpbe.
-
-
-config VIDEO_VPBE_DISPLAY
-        tristate "VPBE V4L2 Display driver"
-        depends on ARCH_DAVINCI_DM644x
-        select VIDEO_DM644X_VPBE
-        help
-            Enables VPBE V4L2 Display driver on a DM644x device
-
-            To compile this driver as a module, choose M here: the
-            module will be called vpbe_display.
diff --git a/drivers/media/platform/davinci/Makefile b/drivers/media/platform/davinci/Makefile
index 74ed92d09257..f40f5219ca50 100644
--- a/drivers/media/platform/davinci/Makefile
+++ b/drivers/media/platform/davinci/Makefile
@@ -16,5 +16,5 @@ obj-$(CONFIG_VIDEO_VPFE_CAPTURE) += vpfe_capture.o
 obj-$(CONFIG_VIDEO_DM6446_CCDC) += dm644x_ccdc.o
 obj-$(CONFIG_VIDEO_DM355_CCDC) += dm355_ccdc.o
 obj-$(CONFIG_VIDEO_ISIF) += isif.o
-obj-$(CONFIG_VIDEO_DM644X_VPBE) += vpbe.o vpbe_osd.o vpbe_venc.o
-obj-$(CONFIG_VIDEO_VPBE_DISPLAY) += vpbe_display.o
+obj-$(CONFIG_VIDEO_DAVINCI_VPBE_DISPLAY) += vpbe.o vpbe_osd.o \
+        vpbe_venc.o vpbe_display.o
diff --git a/drivers/media/platform/davinci/dm355_ccdc.c b/drivers/media/platform/davinci/dm355_ccdc.c
index f263cabade7a..4277e4ad810c 100644
--- a/drivers/media/platform/davinci/dm355_ccdc.c
+++ b/drivers/media/platform/davinci/dm355_ccdc.c
@@ -557,7 +557,7 @@ static int ccdc_config_vdfc(struct ccdc_vertical_dft *dfc)
  */
 static void ccdc_config_csc(struct ccdc_csc *csc)
 {
-        u32 val1, val2;
+        u32 val1 = 0, val2;
         int i;
 
         if (!csc->enable)
diff --git a/drivers/media/platform/davinci/vpbe.c b/drivers/media/platform/davinci/vpbe.c
index 841b91a3d255..4ca0f9a2ad8a 100644
--- a/drivers/media/platform/davinci/vpbe.c
+++ b/drivers/media/platform/davinci/vpbe.c
@@ -558,9 +558,9 @@ static int platform_device_get(struct device *dev, void *data)
         struct platform_device *pdev = to_platform_device(dev);
         struct vpbe_device *vpbe_dev = data;
 
-        if (strcmp("vpbe-osd", pdev->name) == 0)
+        if (strstr(pdev->name, "vpbe-osd") != NULL)
                 vpbe_dev->osd_device = platform_get_drvdata(pdev);
-        if (strcmp("vpbe-venc", pdev->name) == 0)
+        if (strstr(pdev->name, "vpbe-venc") != NULL)
                 vpbe_dev->venc_device = dev_get_platdata(&pdev->dev);
 
         return 0;
@@ -584,7 +584,6 @@ static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
         struct v4l2_subdev **enc_subdev;
         struct osd_state *osd_device;
         struct i2c_adapter *i2c_adap;
-        int output_index;
         int num_encoders;
         int ret = 0;
         int err;
@@ -632,8 +631,10 @@ static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
 
         err = bus_for_each_dev(&platform_bus_type, NULL, vpbe_dev,
                                platform_device_get);
-        if (err < 0)
-                return err;
+        if (err < 0) {
+                ret = err;
+                goto fail_dev_unregister;
+        }
 
         vpbe_dev->venc = venc_sub_dev_init(&vpbe_dev->v4l2_dev,
                                            vpbe_dev->cfg->venc.module_name);
@@ -731,7 +732,6 @@ static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
         /* set the current encoder and output to that of venc by default */
         vpbe_dev->current_sd_index = 0;
         vpbe_dev->current_out_index = 0;
-        output_index = 0;
 
         mutex_unlock(&vpbe_dev->lock);
 
diff --git a/drivers/media/platform/davinci/vpbe_display.c b/drivers/media/platform/davinci/vpbe_display.c
index e707a6f2325b..5e6b0cab514b 100644
--- a/drivers/media/platform/davinci/vpbe_display.c
+++ b/drivers/media/platform/davinci/vpbe_display.c
@@ -791,7 +791,6 @@ static int vpbe_display_g_crop(struct file *file, void *priv,
         struct vpbe_device *vpbe_dev = fh->disp_dev->vpbe_dev;
         struct osd_state *osd_device = fh->disp_dev->osd_device;
         struct v4l2_rect *rect = &crop->c;
-        int ret;
 
         v4l2_dbg(1, debug, &vpbe_dev->v4l2_dev,
                         "VIDIOC_G_CROP, layer id = %d\n",
@@ -799,7 +798,7 @@ static int vpbe_display_g_crop(struct file *file, void *priv,
 
         if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
                 v4l2_err(&vpbe_dev->v4l2_dev, "Invalid buf type\n");
-                ret = -EINVAL;
+                return -EINVAL;
         }
         osd_device->ops.get_layer_config(osd_device,
                                 layer->layer_info.id, cfg);
@@ -1393,9 +1392,9 @@ static int vpbe_display_reqbufs(struct file *file, void *priv,
         }
         /* Initialize videobuf queue as per the buffer type */
         layer->alloc_ctx = vb2_dma_contig_init_ctx(vpbe_dev->pdev);
-        if (!layer->alloc_ctx) {
+        if (IS_ERR(layer->alloc_ctx)) {
                 v4l2_err(&vpbe_dev->v4l2_dev, "Failed to get the context\n");
-                return -EINVAL;
+                return PTR_ERR(layer->alloc_ctx);
         }
         q = &layer->buffer_queue;
         memset(q, 0, sizeof(*q));
@@ -1656,7 +1655,7 @@ static int vpbe_device_get(struct device *dev, void *data)
         if (strcmp("vpbe_controller", pdev->name) == 0)
                 vpbe_disp->vpbe_dev = platform_get_drvdata(pdev);
 
-        if (strcmp("vpbe-osd", pdev->name) == 0)
+        if (strstr(pdev->name, "vpbe-osd") != NULL)
                 vpbe_disp->osd_device = platform_get_drvdata(pdev);
 
         return 0;
diff --git a/drivers/media/platform/davinci/vpbe_osd.c b/drivers/media/platform/davinci/vpbe_osd.c
index 707f243f810d..12ad17c52ef3 100644
--- a/drivers/media/platform/davinci/vpbe_osd.c
+++ b/drivers/media/platform/davinci/vpbe_osd.c
@@ -39,7 +39,22 @@
 #include <linux/io.h>
 #include "vpbe_osd_regs.h"
 
-#define MODULE_NAME     VPBE_OSD_SUBDEV_NAME
+#define MODULE_NAME     "davinci-vpbe-osd"
+
+static struct platform_device_id vpbe_osd_devtype[] = {
+        {
+                .name = DM644X_VPBE_OSD_SUBDEV_NAME,
+                .driver_data = VPBE_VERSION_1,
+        }, {
+                .name = DM365_VPBE_OSD_SUBDEV_NAME,
+                .driver_data = VPBE_VERSION_2,
+        }, {
+                .name = DM355_VPBE_OSD_SUBDEV_NAME,
+                .driver_data = VPBE_VERSION_3,
+        },
+};
+
+MODULE_DEVICE_TABLE(platform, vpbe_osd_devtype);
 
 /* register access routines */
 static inline u32 osd_read(struct osd_state *sd, u32 offset)
@@ -129,7 +144,7 @@ static int _osd_dm6446_vid0_pingpong(struct osd_state *sd,
         struct osd_platform_data *pdata;
 
         pdata = (struct osd_platform_data *)sd->dev->platform_data;
-        if (pdata->field_inv_wa_enable) {
+        if (pdata != NULL && pdata->field_inv_wa_enable) {
 
                 if (!field_inversion || !lconfig->interlaced) {
                         osd_write(sd, fb_base_phys & ~0x1F, OSD_VIDWIN0ADR);
@@ -1526,7 +1541,7 @@ static const struct vpbe_osd_ops osd_ops = {
 
 static int osd_probe(struct platform_device *pdev)
 {
-        struct osd_platform_data *pdata;
+        const struct platform_device_id *pdev_id;
         struct osd_state *osd;
         struct resource *res;
         int ret = 0;
@@ -1535,16 +1550,15 @@ static int osd_probe(struct platform_device *pdev)
         if (osd == NULL)
                 return -ENOMEM;
 
-        osd->dev = &pdev->dev;
-        pdata = (struct osd_platform_data *)pdev->dev.platform_data;
-        osd->vpbe_type = (enum vpbe_version)pdata->vpbe_type;
-        if (NULL == pdev->dev.platform_data) {
-                dev_err(osd->dev, "No platform data defined for OSD"
-                        " sub device\n");
-                ret = -ENOENT;
+        pdev_id = platform_get_device_id(pdev);
+        if (!pdev_id) {
+                ret = -EINVAL;
                 goto free_mem;
         }
 
+        osd->dev = &pdev->dev;
+        osd->vpbe_type = pdev_id->driver_data;
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
                 dev_err(osd->dev, "Unable to get OSD register address map\n");
@@ -1595,6 +1609,7 @@ static struct platform_driver osd_driver = {
                 .name   = MODULE_NAME,
                 .owner  = THIS_MODULE,
         },
+        .id_table       = vpbe_osd_devtype
 };
 
 module_platform_driver(osd_driver);
diff --git a/drivers/media/platform/davinci/vpbe_venc.c b/drivers/media/platform/davinci/vpbe_venc.c
index aed7369b962a..bdbebd59df98 100644
--- a/drivers/media/platform/davinci/vpbe_venc.c
+++ b/drivers/media/platform/davinci/vpbe_venc.c
@@ -38,7 +38,22 @@
 
 #include "vpbe_venc_regs.h"
 
-#define MODULE_NAME     VPBE_VENC_SUBDEV_NAME
+#define MODULE_NAME     "davinci-vpbe-venc"
+
+static struct platform_device_id vpbe_venc_devtype[] = {
+        {
+                .name = DM644X_VPBE_VENC_SUBDEV_NAME,
+                .driver_data = VPBE_VERSION_1,
+        }, {
+                .name = DM365_VPBE_VENC_SUBDEV_NAME,
+                .driver_data = VPBE_VERSION_2,
+        }, {
+                .name = DM355_VPBE_VENC_SUBDEV_NAME,
+                .driver_data = VPBE_VERSION_3,
+        },
+};
+
+MODULE_DEVICE_TABLE(platform, vpbe_venc_devtype);
 
 static int debug = 2;
 module_param(debug, int, 0644);
@@ -54,6 +69,7 @@ struct venc_state {
         spinlock_t lock;
         void __iomem *venc_base;
         void __iomem *vdaccfg_reg;
+        enum vpbe_version venc_type;
 };
 
 static inline struct venc_state *to_state(struct v4l2_subdev *sd)
@@ -127,7 +143,7 @@ static int venc_set_dac(struct v4l2_subdev *sd, u32 out_index)
 static void venc_enabledigitaloutput(struct v4l2_subdev *sd, int benable)
 {
         struct venc_state *venc = to_state(sd);
-        struct venc_platform_data *pdata = venc->pdata;
+
         v4l2_dbg(debug, 2, sd, "venc_enabledigitaloutput\n");
 
         if (benable) {
@@ -159,7 +175,7 @@ static void venc_enabledigitaloutput(struct v4l2_subdev *sd, int benable)
 
                 /* Disable LCD output control (accepting default polarity) */
                 venc_write(sd, VENC_LCDOUT, 0);
-                if (pdata->venc_type != VPBE_VERSION_3)
+                if (venc->venc_type != VPBE_VERSION_3)
                         venc_write(sd, VENC_CMPNT, 0x100);
                 venc_write(sd, VENC_HSPLS, 0);
                 venc_write(sd, VENC_HINT, 0);
@@ -203,11 +219,11 @@ static int venc_set_ntsc(struct v4l2_subdev *sd)
 
         venc_enabledigitaloutput(sd, 0);
 
-        if (pdata->venc_type == VPBE_VERSION_3) {
+        if (venc->venc_type == VPBE_VERSION_3) {
                 venc_write(sd, VENC_CLKCTL, 0x01);
                 venc_write(sd, VENC_VIDCTL, 0);
                 val = vdaccfg_write(sd, VDAC_CONFIG_SD_V3);
-        } else if (pdata->venc_type == VPBE_VERSION_2) {
+        } else if (venc->venc_type == VPBE_VERSION_2) {
                 venc_write(sd, VENC_CLKCTL, 0x01);
                 venc_write(sd, VENC_VIDCTL, 0);
                 vdaccfg_write(sd, VDAC_CONFIG_SD_V2);
@@ -238,7 +254,6 @@ static int venc_set_ntsc(struct v4l2_subdev *sd)
 static int venc_set_pal(struct v4l2_subdev *sd)
 {
         struct venc_state *venc = to_state(sd);
-        struct venc_platform_data *pdata = venc->pdata;
 
         v4l2_dbg(debug, 2, sd, "venc_set_pal\n");
 
@@ -249,11 +264,11 @@ static int venc_set_pal(struct v4l2_subdev *sd)
 
         venc_enabledigitaloutput(sd, 0);
 
-        if (pdata->venc_type == VPBE_VERSION_3) {
+        if (venc->venc_type == VPBE_VERSION_3) {
                 venc_write(sd, VENC_CLKCTL, 0x1);
                 venc_write(sd, VENC_VIDCTL, 0);
                 vdaccfg_write(sd, VDAC_CONFIG_SD_V3);
-        } else if (pdata->venc_type == VPBE_VERSION_2) {
+        } else if (venc->venc_type == VPBE_VERSION_2) {
                 venc_write(sd, VENC_CLKCTL, 0x1);
                 venc_write(sd, VENC_VIDCTL, 0);
                 vdaccfg_write(sd, VDAC_CONFIG_SD_V2);
@@ -293,8 +308,8 @@ static int venc_set_480p59_94(struct v4l2_subdev *sd)
         struct venc_platform_data *pdata = venc->pdata;
 
         v4l2_dbg(debug, 2, sd, "venc_set_480p59_94\n");
-        if ((pdata->venc_type != VPBE_VERSION_1) &&
-            (pdata->venc_type != VPBE_VERSION_2))
+        if (venc->venc_type != VPBE_VERSION_1 &&
+            venc->venc_type != VPBE_VERSION_2)
                 return -EINVAL;
 
         /* Setup clock at VPSS & VENC for SD */
@@ -303,12 +318,12 @@ static int venc_set_480p59_94(struct v4l2_subdev *sd)
 
         venc_enabledigitaloutput(sd, 0);
 
-        if (pdata->venc_type == VPBE_VERSION_2)
+        if (venc->venc_type == VPBE_VERSION_2)
                 vdaccfg_write(sd, VDAC_CONFIG_HD_V2);
         venc_write(sd, VENC_OSDCLK0, 0);
         venc_write(sd, VENC_OSDCLK1, 1);
 
-        if (pdata->venc_type == VPBE_VERSION_1) {
+        if (venc->venc_type == VPBE_VERSION_1) {
                 venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAFRQ,
                             VENC_VDPRO_DAFRQ);
                 venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAUPS,
@@ -341,8 +356,8 @@ static int venc_set_576p50(struct v4l2_subdev *sd)
 
         v4l2_dbg(debug, 2, sd, "venc_set_576p50\n");
 
-        if ((pdata->venc_type != VPBE_VERSION_1) &&
-          (pdata->venc_type != VPBE_VERSION_2))
+        if (venc->venc_type != VPBE_VERSION_1 &&
+            venc->venc_type != VPBE_VERSION_2)
                 return -EINVAL;
         /* Setup clock at VPSS & VENC for SD */
         if (pdata->setup_clock(VPBE_ENC_CUSTOM_TIMINGS, 27000000) < 0)
@@ -350,13 +365,13 @@ static int venc_set_576p50(struct v4l2_subdev *sd)
 
         venc_enabledigitaloutput(sd, 0);
 
-        if (pdata->venc_type == VPBE_VERSION_2)
+        if (venc->venc_type == VPBE_VERSION_2)
                 vdaccfg_write(sd, VDAC_CONFIG_HD_V2);
 
         venc_write(sd, VENC_OSDCLK0, 0);
         venc_write(sd, VENC_OSDCLK1, 1);
 
-        if (pdata->venc_type == VPBE_VERSION_1) {
+        if (venc->venc_type == VPBE_VERSION_1) {
                 venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAFRQ,
                             VENC_VDPRO_DAFRQ);
                 venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAUPS,
@@ -460,14 +475,14 @@ static int venc_s_dv_timings(struct v4l2_subdev *sd,
         else if (height == 480)
                 return venc_set_480p59_94(sd);
         else if ((height == 720) &&
-                        (venc->pdata->venc_type == VPBE_VERSION_2)) {
+                        (venc->venc_type == VPBE_VERSION_2)) {
                 /* TBD setup internal 720p mode here */
                 ret = venc_set_720p60_internal(sd);
                 /* for DM365 VPBE, there is DAC inside */
                 vdaccfg_write(sd, VDAC_CONFIG_HD_V2);
                 return ret;
         } else if ((height == 1080) &&
-                (venc->pdata->venc_type == VPBE_VERSION_2)) {
+                (venc->venc_type == VPBE_VERSION_2)) {
                 /* TBD setup internal 1080i mode here */
                 ret = venc_set_1080i30_internal(sd);
                 /* for DM365 VPBE, there is DAC inside */
@@ -556,7 +571,7 @@ static int venc_device_get(struct device *dev, void *data)
         struct platform_device *pdev = to_platform_device(dev);
         struct venc_state **venc = data;
 
-        if (strcmp(MODULE_NAME, pdev->name) == 0)
+        if (strstr(pdev->name, "vpbe-venc") != NULL)
                 *venc = platform_get_drvdata(pdev);
 
         return 0;
@@ -593,6 +608,7 @@ EXPORT_SYMBOL(venc_sub_dev_init);
 
 static int venc_probe(struct platform_device *pdev)
 {
+        const struct platform_device_id *pdev_id;
         struct venc_state *venc;
         struct resource *res;
         int ret;
@@ -601,6 +617,12 @@ static int venc_probe(struct platform_device *pdev)
         if (venc == NULL)
                 return -ENOMEM;
 
+        pdev_id = platform_get_device_id(pdev);
+        if (!pdev_id) {
+                ret = -EINVAL;
+                goto free_mem;
+        }
+        venc->venc_type = pdev_id->driver_data;
         venc->pdev = &pdev->dev;
         venc->pdata = pdev->dev.platform_data;
         if (NULL == venc->pdata) {
@@ -630,7 +652,7 @@ static int venc_probe(struct platform_device *pdev)
                 goto release_venc_mem_region;
         }
 
-        if (venc->pdata->venc_type != VPBE_VERSION_1) {
+        if (venc->venc_type != VPBE_VERSION_1) {
                 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
                 if (!res) {
                         dev_err(venc->pdev,
@@ -681,7 +703,7 @@ static int venc_remove(struct platform_device *pdev)
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         iounmap((void *)venc->venc_base);
         release_mem_region(res->start, resource_size(res));
-        if (venc->pdata->venc_type != VPBE_VERSION_1) {
+        if (venc->venc_type != VPBE_VERSION_1) {
                 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
                 iounmap((void *)venc->vdaccfg_reg);
                 release_mem_region(res->start, resource_size(res));
@@ -698,6 +720,7 @@ static struct platform_driver venc_driver = {
                 .name   = MODULE_NAME,
                 .owner  = THIS_MODULE,
         },
+        .id_table       = vpbe_venc_devtype
 };
 
 module_platform_driver(venc_driver);
diff --git a/drivers/media/platform/davinci/vpfe_capture.c b/drivers/media/platform/davinci/vpfe_capture.c
index be9d3e1b4868..28d019da4c01 100644
--- a/drivers/media/platform/davinci/vpfe_capture.c
+++ b/drivers/media/platform/davinci/vpfe_capture.c
@@ -560,10 +560,7 @@ static void vpfe_schedule_bottom_field(struct vpfe_device *vpfe_dev)
 
 static void vpfe_process_buffer_complete(struct vpfe_device *vpfe_dev)
 {
-        struct timeval timevalue;
-
-        do_gettimeofday(&timevalue);
-        vpfe_dev->cur_frm->ts = timevalue;
+        v4l2_get_timestamp(&vpfe_dev->cur_frm->ts);
         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);
diff --git a/drivers/media/platform/davinci/vpif_capture.c b/drivers/media/platform/davinci/vpif_capture.c
index a409ccefb380..5892d2bc8eee 100644
--- a/drivers/media/platform/davinci/vpif_capture.c
+++ b/drivers/media/platform/davinci/vpif_capture.c
@@ -411,7 +411,7 @@ static struct vb2_ops video_qops = {
  */
 static void vpif_process_buffer_complete(struct common_obj *common)
 {
-        do_gettimeofday(&common->cur_frm->vb.v4l2_buf.timestamp);
+        v4l2_get_timestamp(&common->cur_frm->vb.v4l2_buf.timestamp);
         vb2_buffer_done(&common->cur_frm->vb,
                                             VB2_BUF_STATE_DONE);
         /* Make curFrm pointing to nextFrm */
diff --git a/drivers/media/platform/davinci/vpif_display.c b/drivers/media/platform/davinci/vpif_display.c
index 9f2b603be9c9..dd249c96126d 100644
--- a/drivers/media/platform/davinci/vpif_display.c
+++ b/drivers/media/platform/davinci/vpif_display.c
@@ -402,7 +402,7 @@ static void process_interlaced_mode(int fid, struct common_obj *common)
                 /* one frame is displayed If next frame is
                  *  available, release cur_frm and move on */
                 /* Copy frame display time */
-                do_gettimeofday(&common->cur_frm->vb.v4l2_buf.timestamp);
+                v4l2_get_timestamp(&common->cur_frm->vb.v4l2_buf.timestamp);
                 /* Change status of the cur_frm */
                 vb2_buffer_done(&common->cur_frm->vb,
                                             VB2_BUF_STATE_DONE);
@@ -462,8 +462,8 @@ static irqreturn_t vpif_channel_isr(int irq, void *dev_id)
                         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->vb.
-                                                v4l2_buf.timestamp);
+                                v4l2_get_timestamp(&common->cur_frm->vb.
+                                                   v4l2_buf.timestamp);
                                 vb2_buffer_done(&common->cur_frm->vb,
                                             VB2_BUF_STATE_DONE);
                                 /* Make cur_frm pointing to next_frm */
diff --git a/drivers/media/platform/davinci/vpss.c b/drivers/media/platform/davinci/vpss.c
index 684e815a81b6..a19c552232d1 100644
--- a/drivers/media/platform/davinci/vpss.c
+++ b/drivers/media/platform/davinci/vpss.c
@@ -50,13 +50,29 @@ MODULE_AUTHOR("Texas Instruments");
 /* VENCINT - vpss_int8 */
 #define DM355_VPSSBL_EVTSEL_DEFAULT     0x4
 
-#define DM365_ISP5_PCCR                 0x04
+#define DM365_ISP5_PCCR                         0x04
+#define DM365_ISP5_PCCR_BL_CLK_ENABLE           BIT(0)
+#define DM365_ISP5_PCCR_ISIF_CLK_ENABLE         BIT(1)
+#define DM365_ISP5_PCCR_H3A_CLK_ENABLE          BIT(2)
+#define DM365_ISP5_PCCR_RSZ_CLK_ENABLE          BIT(3)
+#define DM365_ISP5_PCCR_IPIPE_CLK_ENABLE        BIT(4)
+#define DM365_ISP5_PCCR_IPIPEIF_CLK_ENABLE      BIT(5)
+#define DM365_ISP5_PCCR_RSV                     BIT(6)
+
+#define DM365_ISP5_BCR                  0x08
+#define DM365_ISP5_BCR_ISIF_OUT_ENABLE  BIT(1)
+
 #define DM365_ISP5_INTSEL1              0x10
 #define DM365_ISP5_INTSEL2              0x14
 #define DM365_ISP5_INTSEL3              0x18
 #define DM365_ISP5_CCDCMUX              0x20
 #define DM365_ISP5_PG_FRAME_SIZE        0x28
 #define DM365_VPBE_CLK_CTRL             0x00
+
+#define VPSS_CLK_CTRL                   0x01c40044
+#define VPSS_CLK_CTRL_VENCCLKEN         BIT(3)
+#define VPSS_CLK_CTRL_DACCLKEN          BIT(4)
+
 /*
  * vpss interrupts. VDINT0 - vpss_int0, VDINT1 - vpss_int1,
  * AF - vpss_int3
@@ -94,12 +110,19 @@ struct vpss_hw_ops {
         void (*select_ccdc_source)(enum vpss_ccdc_source_sel src_sel);
         /* clear wbl overflow bit */
         int (*clear_wbl_overflow)(enum vpss_wbl_sel wbl_sel);
+        /* set sync polarity */
+        void (*set_sync_pol)(struct vpss_sync_pol);
+        /* set the PG_FRAME_SIZE register*/
+        void (*set_pg_frame_size)(struct vpss_pg_frame_size);
+        /* check and clear interrupt if occured */
+        int (*dma_complete_interrupt)(void);
 };
 
 /* vpss configuration */
 struct vpss_oper_config {
         __iomem void *vpss_regs_base0;
         __iomem void *vpss_regs_base1;
+        resource_size_t *vpss_regs_base2;
         enum vpss_platform_type platform;
         spinlock_t vpss_lock;
         struct vpss_hw_ops hw_ops;
@@ -157,6 +180,14 @@ 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_dma_complete_interrupt(void)
+{
+        if (!oper_cfg.hw_ops.dma_complete_interrupt)
+                return 2;
+        return oper_cfg.hw_ops.dma_complete_interrupt();
+}
+EXPORT_SYMBOL(vpss_dma_complete_interrupt);
+
 int vpss_select_ccdc_source(enum vpss_ccdc_source_sel src_sel)
 {
         if (!oper_cfg.hw_ops.select_ccdc_source)
@@ -182,6 +213,15 @@ static int dm644x_clear_wbl_overflow(enum vpss_wbl_sel wbl_sel)
         return 0;
 }
 
+void vpss_set_sync_pol(struct vpss_sync_pol sync)
+{
+        if (!oper_cfg.hw_ops.set_sync_pol)
+                return;
+
+        oper_cfg.hw_ops.set_sync_pol(sync);
+}
+EXPORT_SYMBOL(vpss_set_sync_pol);
+
 int vpss_clear_wbl_overflow(enum vpss_wbl_sel wbl_sel)
 {
         if (!oper_cfg.hw_ops.clear_wbl_overflow)
@@ -347,6 +387,15 @@ void dm365_vpss_set_sync_pol(struct vpss_sync_pol sync)
 }
 EXPORT_SYMBOL(dm365_vpss_set_sync_pol);
 
+void vpss_set_pg_frame_size(struct vpss_pg_frame_size frame_size)
+{
+        if (!oper_cfg.hw_ops.set_pg_frame_size)
+                return;
+
+        oper_cfg.hw_ops.set_pg_frame_size(frame_size);
+}
+EXPORT_SYMBOL(vpss_set_pg_frame_size);
+
 void dm365_vpss_set_pg_frame_size(struct vpss_pg_frame_size frame_size)
 {
         int current_reg = ((frame_size.hlpfr >> 1) - 1) << 16;
@@ -425,6 +474,16 @@ static int vpss_probe(struct platform_device *pdev)
                 oper_cfg.hw_ops.enable_clock = dm365_enable_clock;
                 oper_cfg.hw_ops.select_ccdc_source = dm365_select_ccdc_source;
                 /* Setup vpss interrupts */
+                isp5_write((isp5_read(DM365_ISP5_PCCR) |
+                                      DM365_ISP5_PCCR_BL_CLK_ENABLE |
+                                      DM365_ISP5_PCCR_ISIF_CLK_ENABLE |
+                                      DM365_ISP5_PCCR_H3A_CLK_ENABLE |
+                                      DM365_ISP5_PCCR_RSZ_CLK_ENABLE |
+                                      DM365_ISP5_PCCR_IPIPE_CLK_ENABLE |
+                                      DM365_ISP5_PCCR_IPIPEIF_CLK_ENABLE |
+                                      DM365_ISP5_PCCR_RSV), DM365_ISP5_PCCR);
+                isp5_write((isp5_read(DM365_ISP5_BCR) |
+                            DM365_ISP5_BCR_ISIF_OUT_ENABLE), DM365_ISP5_BCR);
                 isp5_write(DM365_ISP5_INTSEL1_DEFAULT, DM365_ISP5_INTSEL1);
                 isp5_write(DM365_ISP5_INTSEL2_DEFAULT, DM365_ISP5_INTSEL2);
                 isp5_write(DM365_ISP5_INTSEL3_DEFAULT, DM365_ISP5_INTSEL3);
@@ -470,11 +529,20 @@ static struct platform_driver vpss_driver = {
 
 static void vpss_exit(void)
 {
+        iounmap(oper_cfg.vpss_regs_base2);
+        release_mem_region(VPSS_CLK_CTRL, 4);
         platform_driver_unregister(&vpss_driver);
 }
 
 static int __init vpss_init(void)
 {
+        if (!request_mem_region(VPSS_CLK_CTRL, 4, "vpss_clock_control"))
+                return -EBUSY;
+
+        oper_cfg.vpss_regs_base2 = ioremap(VPSS_CLK_CTRL, 4);
+        writel(VPSS_CLK_CTRL_VENCCLKEN |
+                     VPSS_CLK_CTRL_DACCLKEN, oper_cfg.vpss_regs_base2);
+
         return platform_driver_register(&vpss_driver);
 }
 subsys_initcall(vpss_init);
diff --git a/drivers/media/platform/exynos-gsc/gsc-core.c b/drivers/media/platform/exynos-gsc/gsc-core.c
index c1a07133cc56..82d9f6ac12f3 100644
--- a/drivers/media/platform/exynos-gsc/gsc-core.c
+++ b/drivers/media/platform/exynos-gsc/gsc-core.c
@@ -185,6 +185,15 @@ static const struct gsc_fmt gsc_formats[] = {
                 .corder         = GSC_CRCB,
                 .num_planes     = 3,
                 .num_comp       = 3,
+        }, {
+                .name           = "YUV 4:2:0 n.c. 2p, Y/CbCr tiled",
+                .pixelformat    = V4L2_PIX_FMT_NV12MT_16X16,
+                .depth          = { 8, 4 },
+                .color          = GSC_YUV420,
+                .yorder         = GSC_LSB_Y,
+                .corder         = GSC_CBCR,
+                .num_planes     = 2,
+                .num_comp       = 2,
         }
 };
 
@@ -935,8 +944,8 @@ static struct gsc_variant gsc_v_100_variant = {
         .pix_max                = &gsc_v_100_max,
         .pix_min                = &gsc_v_100_min,
         .pix_align              = &gsc_v_100_align,
-        .in_buf_cnt             = 8,
-        .out_buf_cnt            = 16,
+        .in_buf_cnt             = 32,
+        .out_buf_cnt            = 32,
         .sc_up_max              = 8,
         .sc_down_max            = 16,
         .poly_sc_down_max       = 4,
@@ -993,12 +1002,8 @@ static void *gsc_get_drv_data(struct platform_device *pdev)
 
 static void gsc_clk_put(struct gsc_dev *gsc)
 {
-        if (IS_ERR_OR_NULL(gsc->clock))
-                return;
-
-        clk_unprepare(gsc->clock);
-        clk_put(gsc->clock);
-        gsc->clock = NULL;
+        if (!IS_ERR(gsc->clock))
+                clk_unprepare(gsc->clock);
 }
 
 static int gsc_clk_get(struct gsc_dev *gsc)
@@ -1007,27 +1012,22 @@ static int gsc_clk_get(struct gsc_dev *gsc)
 
         dev_dbg(&gsc->pdev->dev, "gsc_clk_get Called\n");
 
-        gsc->clock = clk_get(&gsc->pdev->dev, GSC_CLOCK_GATE_NAME);
-        if (IS_ERR(gsc->clock))
-                goto err_print;
+        gsc->clock = devm_clk_get(&gsc->pdev->dev, GSC_CLOCK_GATE_NAME);
+        if (IS_ERR(gsc->clock)) {
+                dev_err(&gsc->pdev->dev, "failed to get clock~~~: %s\n",
+                        GSC_CLOCK_GATE_NAME);
+                return PTR_ERR(gsc->clock);
+        }
 
         ret = clk_prepare(gsc->clock);
         if (ret < 0) {
-                clk_put(gsc->clock);
-                gsc->clock = NULL;
-                goto err;
+                dev_err(&gsc->pdev->dev, "clock prepare failed for clock: %s\n",
+                        GSC_CLOCK_GATE_NAME);
+                gsc->clock = ERR_PTR(-EINVAL);
+                return ret;
         }
 
         return 0;
-
-err:
-        dev_err(&gsc->pdev->dev, "clock prepare failed for clock: %s\n",
-                                        GSC_CLOCK_GATE_NAME);
-        gsc_clk_put(gsc);
-err_print:
-        dev_err(&gsc->pdev->dev, "failed to get clock~~~: %s\n",
-                                        GSC_CLOCK_GATE_NAME);
-        return -ENXIO;
 }
 
 static int gsc_m2m_suspend(struct gsc_dev *gsc)
@@ -1096,6 +1096,7 @@ static int gsc_probe(struct platform_device *pdev)
         init_waitqueue_head(&gsc->irq_queue);
         spin_lock_init(&gsc->slock);
         mutex_init(&gsc->lock);
+        gsc->clock = ERR_PTR(-EINVAL);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         gsc->regs = devm_ioremap_resource(dev, res);
@@ -1157,6 +1158,7 @@ static int gsc_remove(struct platform_device *pdev)
 
         vb2_dma_contig_cleanup_ctx(gsc->alloc_ctx);
         pm_runtime_disable(&pdev->dev);
+        gsc_clk_put(gsc);
 
         dev_dbg(&pdev->dev, "%s driver unloaded\n", pdev->name);
         return 0;
diff --git a/drivers/media/platform/exynos-gsc/gsc-core.h b/drivers/media/platform/exynos-gsc/gsc-core.h
index 5f157efd24f0..cc19bba09bd1 100644
--- a/drivers/media/platform/exynos-gsc/gsc-core.h
+++ b/drivers/media/platform/exynos-gsc/gsc-core.h
@@ -427,6 +427,11 @@ static inline void gsc_ctx_state_lock_clear(u32 state, struct gsc_ctx *ctx)
         spin_unlock_irqrestore(&ctx->gsc_dev->slock, flags);
 }
 
+static inline int is_tiled(const struct gsc_fmt *fmt)
+{
+        return fmt->pixelformat == V4L2_PIX_FMT_NV12MT_16X16;
+}
+
 static inline void gsc_hw_enable_control(struct gsc_dev *dev, bool on)
 {
         u32 cfg = readl(dev->regs + GSC_ENABLE);
diff --git a/drivers/media/platform/exynos-gsc/gsc-m2m.c b/drivers/media/platform/exynos-gsc/gsc-m2m.c
index c267c57c76fd..386c0a7a3a52 100644
--- a/drivers/media/platform/exynos-gsc/gsc-m2m.c
+++ b/drivers/media/platform/exynos-gsc/gsc-m2m.c
@@ -99,22 +99,28 @@ static void gsc_m2m_job_abort(void *priv)
                 gsc_m2m_job_finish(ctx, VB2_BUF_STATE_ERROR);
 }
 
-static int gsc_fill_addr(struct gsc_ctx *ctx)
+static int gsc_get_bufs(struct gsc_ctx *ctx)
 {
         struct gsc_frame *s_frame, *d_frame;
-        struct vb2_buffer *vb = NULL;
+        struct vb2_buffer *src_vb, *dst_vb;
         int ret;
 
         s_frame = &ctx->s_frame;
         d_frame = &ctx->d_frame;
 
-        vb = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
-        ret = gsc_prepare_addr(ctx, vb, s_frame, &s_frame->addr);
+        src_vb = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
+        ret = gsc_prepare_addr(ctx, src_vb, s_frame, &s_frame->addr);
         if (ret)
                 return ret;
 
-        vb = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
-        return gsc_prepare_addr(ctx, vb, d_frame, &d_frame->addr);
+        dst_vb = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
+        ret = gsc_prepare_addr(ctx, dst_vb, d_frame, &d_frame->addr);
+        if (ret)
+                return ret;
+
+        dst_vb->v4l2_buf.timestamp = src_vb->v4l2_buf.timestamp;
+
+        return 0;
 }
 
 static void gsc_m2m_device_run(void *priv)
@@ -148,7 +154,7 @@ static void gsc_m2m_device_run(void *priv)
                 goto put_device;
         }
 
-        ret = gsc_fill_addr(ctx);
+        ret = gsc_get_bufs(ctx);
         if (ret) {
                 pr_err("Wrong address");
                 goto put_device;
@@ -367,6 +373,13 @@ static int gsc_m2m_reqbufs(struct file *file, void *fh,
         return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);
 }
 
+static int gsc_m2m_expbuf(struct file *file, void *fh,
+                                struct v4l2_exportbuffer *eb)
+{
+        struct gsc_ctx *ctx = fh_to_ctx(fh);
+        return v4l2_m2m_expbuf(file, ctx->m2m_ctx, eb);
+}
+
 static int gsc_m2m_querybuf(struct file *file, void *fh,
                                         struct v4l2_buffer *buf)
 {
@@ -548,6 +561,7 @@ static const struct v4l2_ioctl_ops gsc_m2m_ioctl_ops = {
         .vidioc_s_fmt_vid_cap_mplane    = gsc_m2m_s_fmt_mplane,
         .vidioc_s_fmt_vid_out_mplane    = gsc_m2m_s_fmt_mplane,
         .vidioc_reqbufs                 = gsc_m2m_reqbufs,
+        .vidioc_expbuf                  = gsc_m2m_expbuf,
         .vidioc_querybuf                = gsc_m2m_querybuf,
         .vidioc_qbuf                    = gsc_m2m_qbuf,
         .vidioc_dqbuf                   = gsc_m2m_dqbuf,
@@ -565,7 +579,7 @@ static int queue_init(void *priv, struct vb2_queue *src_vq,
 
         memset(src_vq, 0, sizeof(*src_vq));
         src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-        src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
+        src_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
         src_vq->drv_priv = ctx;
         src_vq->ops = &gsc_m2m_qops;
         src_vq->mem_ops = &vb2_dma_contig_memops;
@@ -577,7 +591,7 @@ static int queue_init(void *priv, struct vb2_queue *src_vq,
 
         memset(dst_vq, 0, sizeof(*dst_vq));
         dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-        dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
+        dst_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
         dst_vq->drv_priv = ctx;
         dst_vq->ops = &gsc_m2m_qops;
         dst_vq->mem_ops = &vb2_dma_contig_memops;
@@ -597,7 +611,7 @@ static int gsc_m2m_open(struct file *file)
         if (mutex_lock_interruptible(&gsc->lock))
                 return -ERESTARTSYS;
 
-        ctx = kzalloc(sizeof (*ctx), GFP_KERNEL);
+        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
         if (!ctx) {
                 ret = -ENOMEM;
                 goto unlock;
diff --git a/drivers/media/platform/exynos-gsc/gsc-regs.c b/drivers/media/platform/exynos-gsc/gsc-regs.c
index 0146b354dc22..6f5b5a486cf3 100644
--- a/drivers/media/platform/exynos-gsc/gsc-regs.c
+++ b/drivers/media/platform/exynos-gsc/gsc-regs.c
@@ -214,6 +214,9 @@ void gsc_hw_set_in_image_format(struct gsc_ctx *ctx)
                 break;
         }
 
+        if (is_tiled(frame->fmt))
+                cfg |= GSC_IN_TILE_C_16x8 | GSC_IN_TILE_MODE;
+
         writel(cfg, dev->regs + GSC_IN_CON);
 }
 
@@ -334,6 +337,9 @@ void gsc_hw_set_out_image_format(struct gsc_ctx *ctx)
                 break;
         }
 
+        if (is_tiled(frame->fmt))
+                cfg |= GSC_OUT_TILE_C_16x8 | GSC_OUT_TILE_MODE;
+
 end_set:
         writel(cfg, dev->regs + GSC_OUT_CON);
 }
diff --git a/drivers/media/platform/fsl-viu.c b/drivers/media/platform/fsl-viu.c
index 9115a2c8d075..5f7db3f1f6f5 100644
--- a/drivers/media/platform/fsl-viu.c
+++ b/drivers/media/platform/fsl-viu.c
@@ -1181,7 +1181,7 @@ static void viu_capture_intr(struct viu_dev *dev, u32 status)
 
                 if (waitqueue_active(&buf->vb.done)) {
                         list_del(&buf->vb.queue);
-                        do_gettimeofday(&buf->vb.ts);
+                        v4l2_get_timestamp(&buf->vb.ts);
                         buf->vb.state = VIDEOBUF_DONE;
                         buf->vb.field_count++;
                         wake_up(&buf->vb.done);
diff --git a/drivers/media/platform/m2m-deinterlace.c b/drivers/media/platform/m2m-deinterlace.c
index 05c560f2ef06..6c4db9b98989 100644
--- a/drivers/media/platform/m2m-deinterlace.c
+++ b/drivers/media/platform/m2m-deinterlace.c
@@ -28,7 +28,7 @@ MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com");
 MODULE_LICENSE("GPL");
 MODULE_VERSION("0.0.1");
 
-static bool debug = true;
+static bool debug;
 module_param(debug, bool, 0644);
 
 /* Flags that indicate a format can be used for capture/output */
@@ -917,10 +917,8 @@ static int deinterlace_open(struct file *file)
         ctx->xt = kzalloc(sizeof(struct dma_async_tx_descriptor) +
                                 sizeof(struct data_chunk), GFP_KERNEL);
         if (!ctx->xt) {
-                int ret = PTR_ERR(ctx->xt);
-
                 kfree(ctx);
-                return ret;
+                return -ENOMEM;
         }
 
         ctx->colorspace = V4L2_COLORSPACE_REC709;
diff --git a/drivers/media/platform/marvell-ccic/mcam-core.c b/drivers/media/platform/marvell-ccic/mcam-core.c
index ce2b7b4788d6..92a33f081852 100644
--- a/drivers/media/platform/marvell-ccic/mcam-core.c
+++ b/drivers/media/platform/marvell-ccic/mcam-core.c
@@ -22,6 +22,7 @@
 #include <linux/videodev2.h>
 #include <media/v4l2-device.h>
 #include <media/v4l2-ioctl.h>
+#include <media/v4l2-ctrls.h>
 #include <media/v4l2-chip-ident.h>
 #include <media/ov7670.h>
 #include <media/videobuf2-vmalloc.h>
@@ -30,13 +31,6 @@
 
 #include "mcam-core.h"
 
-/*
- * Basic frame stats - to be deleted shortly
- */
-static int frames;
-static int singles;
-static int delivered;
-
 #ifdef MCAM_MODE_VMALLOC
 /*
  * Internal DMA buffer management.  Since the controller cannot do S/G I/O,
@@ -367,10 +361,10 @@ static void mcam_frame_tasklet(unsigned long data)
                 if (!test_bit(bufno, &cam->flags))
                         continue;
                 if (list_empty(&cam->buffers)) {
-                        singles++;
+                        cam->frame_state.singles++;
                         break;  /* Leave it valid, hope for better later */
                 }
-                delivered++;
+                cam->frame_state.delivered++;
                 clear_bit(bufno, &cam->flags);
                 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer,
                                 queue);
@@ -452,7 +446,7 @@ static void mcam_set_contig_buffer(struct mcam_camera *cam, int frame)
                 mcam_reg_write(cam, frame == 0 ? REG_Y0BAR : REG_Y1BAR,
                                 vb2_dma_contig_plane_dma_addr(&buf->vb_buf, 0));
                 set_bit(CF_SINGLE_BUFFER, &cam->flags);
-                singles++;
+                cam->frame_state.singles++;
                 return;
         }
         /*
@@ -485,7 +479,7 @@ static void mcam_dma_contig_done(struct mcam_camera *cam, int frame)
         struct mcam_vb_buffer *buf = cam->vb_bufs[frame];
 
         if (!test_bit(CF_SINGLE_BUFFER, &cam->flags)) {
-                delivered++;
+                cam->frame_state.delivered++;
                 mcam_buffer_done(cam, frame, &buf->vb_buf);
         }
         mcam_set_contig_buffer(cam, frame);
@@ -578,13 +572,13 @@ static void mcam_dma_sg_done(struct mcam_camera *cam, int frame)
          */
         } else {
                 set_bit(CF_SG_RESTART, &cam->flags);
-                singles++;
+                cam->frame_state.singles++;
                 cam->vb_bufs[0] = NULL;
         }
         /*
          * Now we can give the completed frame back to user space.
          */
-        delivered++;
+        cam->frame_state.delivered++;
         mcam_buffer_done(cam, frame, &buf->vb_buf);
 }
 
@@ -1232,47 +1226,6 @@ static int mcam_vidioc_dqbuf(struct file *filp, void *priv,
         return ret;
 }
 
-
-
-static int mcam_vidioc_queryctrl(struct file *filp, void *priv,
-                struct v4l2_queryctrl *qc)
-{
-        struct mcam_camera *cam = priv;
-        int ret;
-
-        mutex_lock(&cam->s_mutex);
-        ret = sensor_call(cam, core, queryctrl, qc);
-        mutex_unlock(&cam->s_mutex);
-        return ret;
-}
-
-
-static int mcam_vidioc_g_ctrl(struct file *filp, void *priv,
-                struct v4l2_control *ctrl)
-{
-        struct mcam_camera *cam = priv;
-        int ret;
-
-        mutex_lock(&cam->s_mutex);
-        ret = sensor_call(cam, core, g_ctrl, ctrl);
-        mutex_unlock(&cam->s_mutex);
-        return ret;
-}
-
-
-static int mcam_vidioc_s_ctrl(struct file *filp, void *priv,
-                struct v4l2_control *ctrl)
-{
-        struct mcam_camera *cam = priv;
-        int ret;
-
-        mutex_lock(&cam->s_mutex);
-        ret = sensor_call(cam, core, s_ctrl, ctrl);
-        mutex_unlock(&cam->s_mutex);
-        return ret;
-}
-
-
 static int mcam_vidioc_querycap(struct file *file, void *priv,
                 struct v4l2_capability *cap)
 {
@@ -1520,9 +1473,6 @@ static const struct v4l2_ioctl_ops mcam_v4l_ioctl_ops = {
         .vidioc_dqbuf           = mcam_vidioc_dqbuf,
         .vidioc_streamon        = mcam_vidioc_streamon,
         .vidioc_streamoff       = mcam_vidioc_streamoff,
-        .vidioc_queryctrl       = mcam_vidioc_queryctrl,
-        .vidioc_g_ctrl          = mcam_vidioc_g_ctrl,
-        .vidioc_s_ctrl          = mcam_vidioc_s_ctrl,
         .vidioc_g_parm          = mcam_vidioc_g_parm,
         .vidioc_s_parm          = mcam_vidioc_s_parm,
         .vidioc_enum_framesizes = mcam_vidioc_enum_framesizes,
@@ -1545,7 +1495,9 @@ static int mcam_v4l_open(struct file *filp)
 
         filp->private_data = cam;
 
-        frames = singles = delivered = 0;
+        cam->frame_state.frames = 0;
+        cam->frame_state.singles = 0;
+        cam->frame_state.delivered = 0;
         mutex_lock(&cam->s_mutex);
         if (cam->users == 0) {
                 ret = mcam_setup_vb2(cam);
@@ -1566,8 +1518,9 @@ static int mcam_v4l_release(struct file *filp)
 {
         struct mcam_camera *cam = filp->private_data;
 
-        cam_dbg(cam, "Release, %d frames, %d singles, %d delivered\n", frames,
-                        singles, delivered);
+        cam_dbg(cam, "Release, %d frames, %d singles, %d delivered\n",
+                        cam->frame_state.frames, cam->frame_state.singles,
+                        cam->frame_state.delivered);
         mutex_lock(&cam->s_mutex);
         (cam->users)--;
         if (cam->users == 0) {
@@ -1660,7 +1613,7 @@ static void mcam_frame_complete(struct mcam_camera *cam, int frame)
         clear_bit(CF_DMA_ACTIVE, &cam->flags);
         cam->next_buf = frame;
         cam->buf_seq[frame] = ++(cam->sequence);
-        frames++;
+        cam->frame_state.frames++;
         /*
          * "This should never happen"
          */
@@ -1786,14 +1739,19 @@ int mccic_register(struct mcam_camera *cam)
         /*
          * Get the v4l2 setup done.
          */
+        ret = v4l2_ctrl_handler_init(&cam->ctrl_handler, 10);
+        if (ret)
+                goto out_unregister;
+        cam->v4l2_dev.ctrl_handler = &cam->ctrl_handler;
+
         mutex_lock(&cam->s_mutex);
         cam->vdev = mcam_v4l_template;
         cam->vdev.debug = 0;
         cam->vdev.v4l2_dev = &cam->v4l2_dev;
+        video_set_drvdata(&cam->vdev, cam);
         ret = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
         if (ret)
                 goto out;
-        video_set_drvdata(&cam->vdev, cam);
 
         /*
          * If so requested, try to get our DMA buffers now.
@@ -1805,6 +1763,7 @@ int mccic_register(struct mcam_camera *cam)
         }
 
 out:
+        v4l2_ctrl_handler_free(&cam->ctrl_handler);
         mutex_unlock(&cam->s_mutex);
         return ret;
 out_unregister:
@@ -1829,6 +1788,7 @@ void mccic_shutdown(struct mcam_camera *cam)
         if (cam->buffer_mode == B_vmalloc)
                 mcam_free_dma_bufs(cam);
         video_unregister_device(&cam->vdev);
+        v4l2_ctrl_handler_free(&cam->ctrl_handler);
         v4l2_device_unregister(&cam->v4l2_dev);
 }
 
diff --git a/drivers/media/platform/marvell-ccic/mcam-core.h b/drivers/media/platform/marvell-ccic/mcam-core.h
index bd6acba9fb37..01dec9e5fc2b 100644
--- a/drivers/media/platform/marvell-ccic/mcam-core.h
+++ b/drivers/media/platform/marvell-ccic/mcam-core.h
@@ -8,6 +8,7 @@
 
 #include <linux/list.h>
 #include <media/v4l2-common.h>
+#include <media/v4l2-ctrls.h>
 #include <media/v4l2-dev.h>
 #include <media/videobuf2-core.h>
 
@@ -15,15 +16,15 @@
  * Create our own symbols for the supported buffer modes, but, for now,
  * base them entirely on which videobuf2 options have been selected.
  */
-#if defined(CONFIG_VIDEOBUF2_VMALLOC) || defined(CONFIG_VIDEOBUF2_VMALLOC_MODULE)
+#if IS_ENABLED(CONFIG_VIDEOBUF2_VMALLOC)
 #define MCAM_MODE_VMALLOC 1
 #endif
 
-#if defined(CONFIG_VIDEOBUF2_DMA_CONTIG) || defined(CONFIG_VIDEOBUF2_DMA_CONTIG_MODULE)
+#if IS_ENABLED(CONFIG_VIDEOBUF2_DMA_CONTIG)
 #define MCAM_MODE_DMA_CONTIG 1
 #endif
 
-#if defined(CONFIG_VIDEOBUF2_DMA_SG) || defined(CONFIG_VIDEOBUF2_DMA_SG_MODULE)
+#if IS_ENABLED(CONFIG_VIDEOBUF2_DMA_SG)
 #define MCAM_MODE_DMA_SG 1
 #endif
 
@@ -73,6 +74,14 @@ static inline int mcam_buffer_mode_supported(enum mcam_buffer_mode mode)
         }
 }
 
+/*
+ * Basic frame states
+ */
+struct mcam_frame_state {
+        unsigned int frames;
+        unsigned int singles;
+        unsigned int delivered;
+};
 
 /*
  * A description of one of our devices.
@@ -104,10 +113,12 @@ struct mcam_camera {
          * should not be touched by the platform code.
          */
         struct v4l2_device v4l2_dev;
+        struct v4l2_ctrl_handler ctrl_handler;
         enum mcam_state state;
         unsigned long flags;            /* Buffer status, mainly (dev_lock) */
         int users;                      /* How many open FDs */
 
+        struct mcam_frame_state frame_state;    /* Frame state counter */
         /*
          * Subsystem structures.
          */
diff --git a/drivers/media/platform/omap/Kconfig b/drivers/media/platform/omap/Kconfig
index 390ab094f9f2..37ad446b35b3 100644
--- a/drivers/media/platform/omap/Kconfig
+++ b/drivers/media/platform/omap/Kconfig
@@ -6,7 +6,7 @@ config VIDEO_OMAP2_VOUT
         depends on ARCH_OMAP2 || ARCH_OMAP3
         select VIDEOBUF_GEN
         select VIDEOBUF_DMA_CONTIG
-        select OMAP2_DSS
+        select OMAP2_DSS if HAS_IOMEM && ARCH_OMAP2PLUS
         select OMAP2_VRFB if ARCH_OMAP2 || ARCH_OMAP3
         select VIDEO_OMAP2_VOUT_VRFB if VIDEO_OMAP2_VOUT && OMAP2_VRFB
         default n
diff --git a/drivers/media/platform/omap/omap_vout.c b/drivers/media/platform/omap/omap_vout.c
index 35cc526e6c93..96c4a17e4280 100644
--- a/drivers/media/platform/omap/omap_vout.c
+++ b/drivers/media/platform/omap/omap_vout.c
@@ -205,19 +205,21 @@ static u32 omap_vout_uservirt_to_phys(u32 virtp)
         struct vm_area_struct *vma;
         struct mm_struct *mm = current->mm;
 
-        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) {
+        if (virtp >= PAGE_OFFSET)
+                return virt_to_phys((void *) virtp);
+
+        down_read(&current->mm->mmap_sem);
+        vma = find_vma(mm, virtp);
+        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);
+                up_read(&current->mm->mmap_sem);
         } 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);
@@ -595,7 +597,7 @@ static void omap_vout_isr(void *arg, unsigned int irqstatus)
                 return;
 
         spin_lock(&vout->vbq_lock);
-        do_gettimeofday(&timevalue);
+        v4l2_get_timestamp(&timevalue);
 
         switch (cur_display->type) {
         case OMAP_DISPLAY_TYPE_DSI:
@@ -1230,21 +1232,6 @@ static int vidioc_s_fmt_vid_overlay(struct file *file, void *fh,
         return ret;
 }
 
-static int vidioc_enum_fmt_vid_overlay(struct file *file, void *fh,
-                        struct v4l2_fmtdesc *fmt)
-{
-        int index = fmt->index;
-
-        if (index >= NUM_OUTPUT_FORMATS)
-                return -EINVAL;
-
-        fmt->flags = omap_formats[index].flags;
-        strlcpy(fmt->description, omap_formats[index].description,
-                        sizeof(fmt->description));
-        fmt->pixelformat = omap_formats[index].pixelformat;
-        return 0;
-}
-
 static int vidioc_g_fmt_vid_overlay(struct file *file, void *fh,
                         struct v4l2_format *f)
 {
@@ -1858,10 +1845,9 @@ static const struct v4l2_ioctl_ops vout_ioctl_ops = {
         .vidioc_s_fbuf                          = vidioc_s_fbuf,
         .vidioc_g_fbuf                          = vidioc_g_fbuf,
         .vidioc_s_ctrl                          = vidioc_s_ctrl,
-        .vidioc_try_fmt_vid_overlay             = vidioc_try_fmt_vid_overlay,
-        .vidioc_s_fmt_vid_overlay               = vidioc_s_fmt_vid_overlay,
-        .vidioc_enum_fmt_vid_overlay            = vidioc_enum_fmt_vid_overlay,
-        .vidioc_g_fmt_vid_overlay               = vidioc_g_fmt_vid_overlay,
+        .vidioc_try_fmt_vid_out_overlay         = vidioc_try_fmt_vid_overlay,
+        .vidioc_s_fmt_vid_out_overlay           = vidioc_s_fmt_vid_overlay,
+        .vidioc_g_fmt_vid_out_overlay           = vidioc_g_fmt_vid_overlay,
         .vidioc_cropcap                         = vidioc_cropcap,
         .vidioc_g_crop                          = vidioc_g_crop,
         .vidioc_s_crop                          = vidioc_s_crop,
diff --git a/drivers/media/platform/omap24xxcam.c b/drivers/media/platform/omap24xxcam.c
index 8b7ccea982e7..debb44ceb185 100644
--- a/drivers/media/platform/omap24xxcam.c
+++ b/drivers/media/platform/omap24xxcam.c
@@ -402,7 +402,7 @@ static void omap24xxcam_vbq_complete(struct omap24xxcam_sgdma *sgdma,
                 omap24xxcam_core_disable(cam);
         spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
 
-        do_gettimeofday(&vb->ts);
+        v4l2_get_timestamp(&vb->ts);
         vb->field_count = atomic_add_return(2, &fh->field_count);
         if (csr & csr_error) {
                 vb->state = VIDEOBUF_ERROR;
diff --git a/drivers/media/platform/omap3isp/isp.c b/drivers/media/platform/omap3isp/isp.c
index e4aaee91201d..383a727b8aa0 100644
--- a/drivers/media/platform/omap3isp/isp.c
+++ b/drivers/media/platform/omap3isp/isp.c
@@ -1406,28 +1406,15 @@ static const char *isp_clocks[] = {
         "l3_ick",
 };
 
-static void isp_put_clocks(struct isp_device *isp)
-{
-        unsigned int i;
-
-        for (i = 0; i < ARRAY_SIZE(isp_clocks); ++i) {
-                if (isp->clock[i]) {
-                        clk_put(isp->clock[i]);
-                        isp->clock[i] = NULL;
-                }
-        }
-}
-
 static int isp_get_clocks(struct isp_device *isp)
 {
         struct clk *clk;
         unsigned int i;
 
         for (i = 0; i < ARRAY_SIZE(isp_clocks); ++i) {
-                clk = clk_get(isp->dev, isp_clocks[i]);
+                clk = devm_clk_get(isp->dev, isp_clocks[i]);
                 if (IS_ERR(clk)) {
                         dev_err(isp->dev, "clk_get %s failed\n", isp_clocks[i]);
-                        isp_put_clocks(isp);
                         return PTR_ERR(clk);
                 }
 
@@ -1993,7 +1980,6 @@ error_csiphy:
 static int isp_remove(struct platform_device *pdev)
 {
         struct isp_device *isp = platform_get_drvdata(pdev);
-        int i;
 
         isp_unregister_entities(isp);
         isp_cleanup_modules(isp);
@@ -2004,26 +1990,6 @@ static int isp_remove(struct platform_device *pdev)
         isp->domain = NULL;
         omap3isp_put(isp);
 
-        free_irq(isp->irq_num, isp);
-        isp_put_clocks(isp);
-
-        for (i = 0; i < OMAP3_ISP_IOMEM_LAST; i++) {
-                if (isp->mmio_base[i]) {
-                        iounmap(isp->mmio_base[i]);
-                        isp->mmio_base[i] = NULL;
-                }
-
-                if (isp->mmio_base_phys[i]) {
-                        release_mem_region(isp->mmio_base_phys[i],
-                                           isp->mmio_size[i]);
-                        isp->mmio_base_phys[i] = 0;
-                }
-        }
-
-        regulator_put(isp->isp_csiphy1.vdd);
-        regulator_put(isp->isp_csiphy2.vdd);
-        kfree(isp);
-
         return 0;
 }
 
@@ -2041,7 +2007,8 @@ static int isp_map_mem_resource(struct platform_device *pdev,
                 return -ENODEV;
         }
 
-        if (!request_mem_region(mem->start, resource_size(mem), pdev->name)) {
+        if (!devm_request_mem_region(isp->dev, mem->start, resource_size(mem),
+                                     pdev->name)) {
                 dev_err(isp->dev,
                         "cannot reserve camera register I/O region\n");
                 return -ENODEV;
@@ -2050,8 +2017,9 @@ static int isp_map_mem_resource(struct platform_device *pdev,
         isp->mmio_size[res] = resource_size(mem);
 
         /* map the region */
-        isp->mmio_base[res] = ioremap_nocache(isp->mmio_base_phys[res],
-                                              isp->mmio_size[res]);
+        isp->mmio_base[res] = devm_ioremap_nocache(isp->dev,
+                                                   isp->mmio_base_phys[res],
+                                                   isp->mmio_size[res]);
         if (!isp->mmio_base[res]) {
                 dev_err(isp->dev, "cannot map camera register I/O region\n");
                 return -ENODEV;
@@ -2081,7 +2049,7 @@ static int isp_probe(struct platform_device *pdev)
         if (pdata == NULL)
                 return -EINVAL;
 
-        isp = kzalloc(sizeof(*isp), GFP_KERNEL);
+        isp = devm_kzalloc(&pdev->dev, sizeof(*isp), GFP_KERNEL);
         if (!isp) {
                 dev_err(&pdev->dev, "could not allocate memory\n");
                 return -ENOMEM;
@@ -2104,8 +2072,8 @@ static int isp_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, isp);
 
         /* Regulators */
-        isp->isp_csiphy1.vdd = regulator_get(&pdev->dev, "VDD_CSIPHY1");
-        isp->isp_csiphy2.vdd = regulator_get(&pdev->dev, "VDD_CSIPHY2");
+        isp->isp_csiphy1.vdd = devm_regulator_get(&pdev->dev, "VDD_CSIPHY1");
+        isp->isp_csiphy2.vdd = devm_regulator_get(&pdev->dev, "VDD_CSIPHY2");
 
         /* Clocks
          *
@@ -2180,7 +2148,8 @@ static int isp_probe(struct platform_device *pdev)
                 goto detach_dev;
         }
 
-        if (request_irq(isp->irq_num, isp_isr, IRQF_SHARED, "OMAP3 ISP", isp)) {
+        if (devm_request_irq(isp->dev, isp->irq_num, isp_isr, IRQF_SHARED,
+                             "OMAP3 ISP", isp)) {
                 dev_err(isp->dev, "Unable to request IRQ\n");
                 ret = -EINVAL;
                 goto detach_dev;
@@ -2189,7 +2158,7 @@ static int isp_probe(struct platform_device *pdev)
         /* Entities */
         ret = isp_initialize_modules(isp);
         if (ret < 0)
-                goto error_irq;
+                goto detach_dev;
 
         ret = isp_register_entities(isp);
         if (ret < 0)
@@ -2202,8 +2171,6 @@ static int isp_probe(struct platform_device *pdev)
 
 error_modules:
         isp_cleanup_modules(isp);
-error_irq:
-        free_irq(isp->irq_num, isp);
 detach_dev:
         iommu_detach_device(isp->domain, &pdev->dev);
 free_domain:
@@ -2211,26 +2178,9 @@ free_domain:
 error_isp:
         omap3isp_put(isp);
 error:
-        isp_put_clocks(isp);
-
-        for (i = 0; i < OMAP3_ISP_IOMEM_LAST; i++) {
-                if (isp->mmio_base[i]) {
-                        iounmap(isp->mmio_base[i]);
-                        isp->mmio_base[i] = NULL;
-                }
-
-                if (isp->mmio_base_phys[i]) {
-                        release_mem_region(isp->mmio_base_phys[i],
-                                           isp->mmio_size[i]);
-                        isp->mmio_base_phys[i] = 0;
-                }
-        }
-        regulator_put(isp->isp_csiphy2.vdd);
-        regulator_put(isp->isp_csiphy1.vdd);
         platform_set_drvdata(pdev, NULL);
 
         mutex_destroy(&isp->isp_mutex);
-        kfree(isp);
 
         return ret;
 }
diff --git a/drivers/media/platform/omap3isp/ispccp2.c b/drivers/media/platform/omap3isp/ispccp2.c
index 85f0de85f37c..c5d84c977e29 100644
--- a/drivers/media/platform/omap3isp/ispccp2.c
+++ b/drivers/media/platform/omap3isp/ispccp2.c
@@ -1136,7 +1136,7 @@ int omap3isp_ccp2_init(struct isp_device *isp)
          * TODO: Don't hardcode the usage of PHY1 (shared with CSI2c).
          */
         if (isp->revision == ISP_REVISION_2_0) {
-                ccp2->vdds_csib = regulator_get(isp->dev, "vdds_csib");
+                ccp2->vdds_csib = devm_regulator_get(isp->dev, "vdds_csib");
                 if (IS_ERR(ccp2->vdds_csib)) {
                         dev_dbg(isp->dev,
                                 "Could not get regulator vdds_csib\n");
@@ -1147,10 +1147,8 @@ int omap3isp_ccp2_init(struct isp_device *isp)
         }
 
         ret = ccp2_init_entities(ccp2);
-        if (ret < 0) {
-                regulator_put(ccp2->vdds_csib);
+        if (ret < 0)
                 return ret;
-        }
 
         ccp2_reset(ccp2);
         return 0;
@@ -1166,6 +1164,4 @@ void omap3isp_ccp2_cleanup(struct isp_device *isp)
 
         omap3isp_video_cleanup(&ccp2->video_in);
         media_entity_cleanup(&ccp2->subdev.entity);
-
-        regulator_put(ccp2->vdds_csib);
 }
diff --git a/drivers/media/platform/omap3isp/ispcsiphy.c b/drivers/media/platform/omap3isp/ispcsiphy.c
index 3d56b33f85e8..c09de32f986a 100644
--- a/drivers/media/platform/omap3isp/ispcsiphy.c
+++ b/drivers/media/platform/omap3isp/ispcsiphy.c
@@ -32,7 +32,8 @@
 #include "ispreg.h"
 #include "ispcsiphy.h"
 
-static void csiphy_routing_cfg_3630(struct isp_csiphy *phy, u32 iface,
+static void csiphy_routing_cfg_3630(struct isp_csiphy *phy,
+                                    enum isp_interface_type iface,
                                     bool ccp2_strobe)
 {
         u32 reg = isp_reg_readl(
@@ -40,6 +41,8 @@ static void csiphy_routing_cfg_3630(struct isp_csiphy *phy, u32 iface,
         u32 shift, mode;
 
         switch (iface) {
+        default:
+        /* Should not happen in practice, but let's keep the compiler happy. */
         case ISP_INTERFACE_CCP2B_PHY1:
                 reg &= ~OMAP3630_CONTROL_CAMERA_PHY_CTRL_CSI1_RX_SEL_PHY2;
                 shift = OMAP3630_CONTROL_CAMERA_PHY_CTRL_CAMMODE_PHY1_SHIFT;
@@ -59,9 +62,8 @@ static void csiphy_routing_cfg_3630(struct isp_csiphy *phy, u32 iface,
         }
 
         /* Select data/clock or data/strobe mode for CCP2 */
-        switch (iface) {
-        case ISP_INTERFACE_CCP2B_PHY1:
-        case ISP_INTERFACE_CCP2B_PHY2:
+        if (iface == ISP_INTERFACE_CCP2B_PHY1 ||
+            iface == ISP_INTERFACE_CCP2B_PHY2) {
                 if (ccp2_strobe)
                         mode = OMAP3630_CONTROL_CAMERA_PHY_CTRL_CAMMODE_CCP2_DATA_STROBE;
                 else
@@ -110,7 +112,8 @@ static void csiphy_routing_cfg_3430(struct isp_csiphy *phy, u32 iface, bool on,
  * and 3630, so they will not hold their contents in off-mode. This isn't an
  * issue since the MPU power domain is forced on whilst the ISP is in use.
  */
-static void csiphy_routing_cfg(struct isp_csiphy *phy, u32 iface, bool on,
+static void csiphy_routing_cfg(struct isp_csiphy *phy,
+                               enum isp_interface_type iface, bool on,
                                bool ccp2_strobe)
 {
         if (phy->isp->mmio_base[OMAP3_ISP_IOMEM_3630_CONTROL_CAMERA_PHY_CTRL]
diff --git a/drivers/media/platform/omap3isp/isph3a_aewb.c b/drivers/media/platform/omap3isp/isph3a_aewb.c
index 036e9961d027..75fd82b152ba 100644
--- a/drivers/media/platform/omap3isp/isph3a_aewb.c
+++ b/drivers/media/platform/omap3isp/isph3a_aewb.c
@@ -300,13 +300,11 @@ int omap3isp_h3a_aewb_init(struct isp_device *isp)
         struct ispstat *aewb = &isp->isp_aewb;
         struct omap3isp_h3a_aewb_config *aewb_cfg;
         struct omap3isp_h3a_aewb_config *aewb_recover_cfg;
-        int ret;
 
-        aewb_cfg = kzalloc(sizeof(*aewb_cfg), GFP_KERNEL);
+        aewb_cfg = devm_kzalloc(isp->dev, sizeof(*aewb_cfg), GFP_KERNEL);
         if (!aewb_cfg)
                 return -ENOMEM;
 
-        memset(aewb, 0, sizeof(*aewb));
         aewb->ops = &h3a_aewb_ops;
         aewb->priv = aewb_cfg;
         aewb->dma_ch = -1;
@@ -314,12 +312,12 @@ int omap3isp_h3a_aewb_init(struct isp_device *isp)
         aewb->isp = isp;
 
         /* Set recover state configuration */
-        aewb_recover_cfg = kzalloc(sizeof(*aewb_recover_cfg), GFP_KERNEL);
+        aewb_recover_cfg = devm_kzalloc(isp->dev, sizeof(*aewb_recover_cfg),
+                                        GFP_KERNEL);
         if (!aewb_recover_cfg) {
                 dev_err(aewb->isp->dev, "AEWB: cannot allocate memory for "
                                         "recover configuration.\n");
-                ret = -ENOMEM;
-                goto err_recover_alloc;
+                return -ENOMEM;
         }
 
         aewb_recover_cfg->saturation_limit = OMAP3ISP_AEWB_MAX_SATURATION_LIM;
@@ -336,25 +334,13 @@ int omap3isp_h3a_aewb_init(struct isp_device *isp)
         if (h3a_aewb_validate_params(aewb, aewb_recover_cfg)) {
                 dev_err(aewb->isp->dev, "AEWB: recover configuration is "
                                         "invalid.\n");
-                ret = -EINVAL;
-                goto err_conf;
+                return -EINVAL;
         }
 
         aewb_recover_cfg->buf_size = h3a_aewb_get_buf_size(aewb_recover_cfg);
         aewb->recover_priv = aewb_recover_cfg;
 
-        ret = omap3isp_stat_init(aewb, "AEWB", &h3a_aewb_subdev_ops);
-        if (ret)
-                goto err_conf;
-
-        return 0;
-
-err_conf:
-        kfree(aewb_recover_cfg);
-err_recover_alloc:
-        kfree(aewb_cfg);
-
-        return ret;
+        return omap3isp_stat_init(aewb, "AEWB", &h3a_aewb_subdev_ops);
 }
 
 /*
@@ -362,7 +348,5 @@ err_recover_alloc:
  */
 void omap3isp_h3a_aewb_cleanup(struct isp_device *isp)
 {
-        kfree(isp->isp_aewb.priv);
-        kfree(isp->isp_aewb.recover_priv);
         omap3isp_stat_cleanup(&isp->isp_aewb);
 }
diff --git a/drivers/media/platform/omap3isp/isph3a_af.c b/drivers/media/platform/omap3isp/isph3a_af.c
index 42ccce318d5d..a0bf5af32438 100644
--- a/drivers/media/platform/omap3isp/isph3a_af.c
+++ b/drivers/media/platform/omap3isp/isph3a_af.c
@@ -363,13 +363,11 @@ int omap3isp_h3a_af_init(struct isp_device *isp)
         struct ispstat *af = &isp->isp_af;
         struct omap3isp_h3a_af_config *af_cfg;
         struct omap3isp_h3a_af_config *af_recover_cfg;
-        int ret;
 
-        af_cfg = kzalloc(sizeof(*af_cfg), GFP_KERNEL);
+        af_cfg = devm_kzalloc(isp->dev, sizeof(*af_cfg), GFP_KERNEL);
         if (af_cfg == NULL)
                 return -ENOMEM;
 
-        memset(af, 0, sizeof(*af));
         af->ops = &h3a_af_ops;
         af->priv = af_cfg;
         af->dma_ch = -1;
@@ -377,12 +375,12 @@ int omap3isp_h3a_af_init(struct isp_device *isp)
         af->isp = isp;
 
         /* Set recover state configuration */
-        af_recover_cfg = kzalloc(sizeof(*af_recover_cfg), GFP_KERNEL);
+        af_recover_cfg = devm_kzalloc(isp->dev, sizeof(*af_recover_cfg),
+                                      GFP_KERNEL);
         if (!af_recover_cfg) {
                 dev_err(af->isp->dev, "AF: cannot allocate memory for recover "
                                       "configuration.\n");
-                ret = -ENOMEM;
-                goto err_recover_alloc;
+                return -ENOMEM;
         }
 
         af_recover_cfg->paxel.h_start = OMAP3ISP_AF_PAXEL_HZSTART_MIN;
@@ -394,30 +392,16 @@ int omap3isp_h3a_af_init(struct isp_device *isp)
         if (h3a_af_validate_params(af, af_recover_cfg)) {
                 dev_err(af->isp->dev, "AF: recover configuration is "
                                       "invalid.\n");
-                ret = -EINVAL;
-                goto err_conf;
+                return -EINVAL;
         }
 
         af_recover_cfg->buf_size = h3a_af_get_buf_size(af_recover_cfg);
         af->recover_priv = af_recover_cfg;
 
-        ret = omap3isp_stat_init(af, "AF", &h3a_af_subdev_ops);
-        if (ret)
-                goto err_conf;
-
-        return 0;
-
-err_conf:
-        kfree(af_recover_cfg);
-err_recover_alloc:
-        kfree(af_cfg);
-
-        return ret;
+        return omap3isp_stat_init(af, "AF", &h3a_af_subdev_ops);
 }
 
 void omap3isp_h3a_af_cleanup(struct isp_device *isp)
 {
-        kfree(isp->isp_af.priv);
-        kfree(isp->isp_af.recover_priv);
         omap3isp_stat_cleanup(&isp->isp_af);
 }
diff --git a/drivers/media/platform/omap3isp/isphist.c b/drivers/media/platform/omap3isp/isphist.c
index 2d759c56f37c..e070c24048ef 100644
--- a/drivers/media/platform/omap3isp/isphist.c
+++ b/drivers/media/platform/omap3isp/isphist.c
@@ -114,14 +114,14 @@ static void hist_setup_regs(struct ispstat *hist, void *priv)
         /* Regions size and position */
         for (c = 0; c < OMAP3ISP_HIST_MAX_REGIONS; c++) {
                 if (c < conf->num_regions) {
-                        reg_hor[c] = conf->region[c].h_start <<
-                                     ISPHIST_REG_START_SHIFT;
-                        reg_hor[c] = conf->region[c].h_end <<
-                                     ISPHIST_REG_END_SHIFT;
-                        reg_ver[c] = conf->region[c].v_start <<
-                                     ISPHIST_REG_START_SHIFT;
-                        reg_ver[c] = conf->region[c].v_end <<
-                                     ISPHIST_REG_END_SHIFT;
+                        reg_hor[c] = (conf->region[c].h_start <<
+                                     ISPHIST_REG_START_SHIFT)
+                                   | (conf->region[c].h_end <<
+                                     ISPHIST_REG_END_SHIFT);
+                        reg_ver[c] = (conf->region[c].v_start <<
+                                     ISPHIST_REG_START_SHIFT)
+                                   | (conf->region[c].v_end <<
+                                     ISPHIST_REG_END_SHIFT);
                 } else {
                         reg_hor[c] = 0;
                         reg_ver[c] = 0;
@@ -477,11 +477,10 @@ int omap3isp_hist_init(struct isp_device *isp)
         struct omap3isp_hist_config *hist_cfg;
         int ret = -1;
 
-        hist_cfg = kzalloc(sizeof(*hist_cfg), GFP_KERNEL);
+        hist_cfg = devm_kzalloc(isp->dev, sizeof(*hist_cfg), GFP_KERNEL);
         if (hist_cfg == NULL)
                 return -ENOMEM;
 
-        memset(hist, 0, sizeof(*hist));
         hist->isp = isp;
 
         if (HIST_CONFIG_DMA)
@@ -504,7 +503,6 @@ int omap3isp_hist_init(struct isp_device *isp)
 
         ret = omap3isp_stat_init(hist, "histogram", &hist_subdev_ops);
         if (ret) {
-                kfree(hist_cfg);
                 if (HIST_USING_DMA(hist))
                         omap_free_dma(hist->dma_ch);
         }
@@ -519,6 +517,5 @@ void omap3isp_hist_cleanup(struct isp_device *isp)
 {
         if (HIST_USING_DMA(&isp->isp_hist))
                 omap_free_dma(isp->isp_hist.dma_ch);
-        kfree(isp->isp_hist.priv);
         omap3isp_stat_cleanup(&isp->isp_hist);
 }
diff --git a/drivers/media/platform/omap3isp/isppreview.c b/drivers/media/platform/omap3isp/isppreview.c
index 691b92a3c3e7..cd8831aebdeb 100644
--- a/drivers/media/platform/omap3isp/isppreview.c
+++ b/drivers/media/platform/omap3isp/isppreview.c
@@ -82,8 +82,9 @@ static struct omap3isp_prev_csc flr_prev_csc = {
  * The preview engine crops several rows and columns internally depending on
  * which filters are enabled. To avoid format changes when the filters are
  * enabled or disabled (which would prevent them from being turned on or off
- * during streaming), the driver assumes all the filters are enabled when
- * computing sink crop and source format limits.
+ * during streaming), the driver assumes all filters that can be configured
+ * during streaming are enabled when computing sink crop and source format
+ * limits.
  *
  * If a filter is disabled, additional cropping is automatically added at the
  * preview engine input by the driver to avoid overflow at line and frame end.
@@ -92,25 +93,23 @@ static struct omap3isp_prev_csc flr_prev_csc = {
  * Median filter                4 pixels
  * Noise filter,
  * Faulty pixels correction     4 pixels, 4 lines
- * CFA filter                   4 pixels, 4 lines in Bayer mode
- *                                        2 lines in other modes
  * Color suppression            2 pixels
  * or luma enhancement
  * -------------------------------------------------------------
- * Maximum total                14 pixels, 8 lines
+ * Maximum total                10 pixels, 4 lines
  *
  * The color suppression and luma enhancement filters are applied after bayer to
  * YUV conversion. They thus can crop one pixel on the left and one pixel on the
  * right side of the image without changing the color pattern. When both those
  * filters are disabled, the driver must crop the two pixels on the same side of
  * the image to avoid changing the bayer pattern. The left margin is thus set to
- * 8 pixels and the right margin to 6 pixels.
+ * 6 pixels and the right margin to 4 pixels.
  */
 
-#define PREV_MARGIN_LEFT        8
-#define PREV_MARGIN_RIGHT       6
-#define PREV_MARGIN_TOP         4
-#define PREV_MARGIN_BOTTOM      4
+#define PREV_MARGIN_LEFT        6
+#define PREV_MARGIN_RIGHT       4
+#define PREV_MARGIN_TOP         2
+#define PREV_MARGIN_BOTTOM      2
 
 #define PREV_MIN_IN_WIDTH       64
 #define PREV_MIN_IN_HEIGHT      8
@@ -1080,7 +1079,6 @@ static void preview_config_input_format(struct isp_prev_device *prev,
  */
 static void preview_config_input_size(struct isp_prev_device *prev, u32 active)
 {
-        const struct v4l2_mbus_framefmt *format = &prev->formats[PREV_PAD_SINK];
         struct isp_device *isp = to_isp_device(prev);
         unsigned int sph = prev->crop.left;
         unsigned int eph = prev->crop.left + prev->crop.width - 1;
@@ -1088,14 +1086,6 @@ static void preview_config_input_size(struct isp_prev_device *prev, u32 active)
         unsigned int elv = prev->crop.top + prev->crop.height - 1;
         u32 features;
 
-        if (format->code != V4L2_MBUS_FMT_Y8_1X8 &&
-            format->code != V4L2_MBUS_FMT_Y10_1X10) {
-                sph -= 2;
-                eph += 2;
-                slv -= 2;
-                elv += 2;
-        }
-
         features = (prev->params.params[0].features & active)
                  | (prev->params.params[1].features & ~active);
 
@@ -1849,6 +1839,18 @@ static void preview_try_crop(struct isp_prev_device *prev,
                 right -= 2;
         }
 
+        /* The CFA filter crops 4 lines and 4 columns in Bayer mode, and 2 lines
+         * and no columns in other modes. Increase the margins based on the sink
+         * format.
+         */
+        if (sink->code != V4L2_MBUS_FMT_Y8_1X8 &&
+            sink->code != V4L2_MBUS_FMT_Y10_1X10) {
+                left += 2;
+                right -= 2;
+                top += 2;
+                bottom -= 2;
+        }
+
         /* Restrict left/top to even values to keep the Bayer pattern. */
         crop->left &= ~1;
         crop->top &= ~1;
diff --git a/drivers/media/platform/omap3isp/ispqueue.c b/drivers/media/platform/omap3isp/ispqueue.c
index 15bf3eab2224..e15f01342058 100644
--- a/drivers/media/platform/omap3isp/ispqueue.c
+++ b/drivers/media/platform/omap3isp/ispqueue.c
@@ -366,7 +366,7 @@ static int isp_video_buffer_prepare_pfnmap(struct isp_video_buffer *buf)
         unsigned long this_pfn;
         unsigned long start;
         unsigned long end;
-        dma_addr_t pa;
+        dma_addr_t pa = 0;
         int ret = -EFAULT;
 
         start = buf->vbuf.m.userptr;
@@ -419,7 +419,7 @@ done:
 static int isp_video_buffer_prepare_vm_flags(struct isp_video_buffer *buf)
 {
         struct vm_area_struct *vma;
-        pgprot_t vm_page_prot;
+        pgprot_t uninitialized_var(vm_page_prot);
         unsigned long start;
         unsigned long end;
         int ret = -EFAULT;
@@ -674,6 +674,7 @@ static int isp_video_queue_alloc(struct isp_video_queue *queue,
                 buf->vbuf.index = i;
                 buf->vbuf.length = size;
                 buf->vbuf.type = queue->type;
+                buf->vbuf.flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
                 buf->vbuf.field = V4L2_FIELD_NONE;
                 buf->vbuf.memory = memory;
 
diff --git a/drivers/media/platform/s3c-camif/camif-core.c b/drivers/media/platform/s3c-camif/camif-core.c
index 09a8c9cac5c9..0d0fab1a7b5e 100644
--- a/drivers/media/platform/s3c-camif/camif-core.c
+++ b/drivers/media/platform/s3c-camif/camif-core.c
@@ -27,6 +27,7 @@
 #include <linux/pm_runtime.h>
 #include <linux/slab.h>
 #include <linux/types.h>
+#include <linux/version.h>
 
 #include <media/media-device.h>
 #include <media/v4l2-ctrls.h>
diff --git a/drivers/media/platform/s5p-fimc/fimc-capture.c b/drivers/media/platform/s5p-fimc/fimc-capture.c
index fdb6740248a7..f553cc2a8ee8 100644
--- a/drivers/media/platform/s5p-fimc/fimc-capture.c
+++ b/drivers/media/platform/s5p-fimc/fimc-capture.c
@@ -486,6 +486,7 @@ static struct vb2_ops fimc_capture_qops = {
 int fimc_capture_ctrls_create(struct fimc_dev *fimc)
 {
         struct fimc_vid_cap *vid_cap = &fimc->vid_cap;
+        struct v4l2_subdev *sensor = fimc->pipeline.subdevs[IDX_SENSOR];
         int ret;
 
         if (WARN_ON(vid_cap->ctx == NULL))
@@ -494,11 +495,13 @@ int fimc_capture_ctrls_create(struct fimc_dev *fimc)
                 return 0;
 
         ret = fimc_ctrls_create(vid_cap->ctx);
-        if (ret || vid_cap->user_subdev_api || !vid_cap->ctx->ctrls.ready)
+
+        if (ret || vid_cap->user_subdev_api || !sensor ||
+            !vid_cap->ctx->ctrls.ready)
                 return ret;
 
         return v4l2_ctrl_add_handler(&vid_cap->ctx->ctrls.handler,
-                    fimc->pipeline.subdevs[IDX_SENSOR]->ctrl_handler, NULL);
+                                     sensor->ctrl_handler, NULL);
 }
 
 static int fimc_capture_set_default_format(struct fimc_dev *fimc);
@@ -510,8 +513,8 @@ static int fimc_capture_open(struct file *file)
 
         dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
 
-        if (mutex_lock_interruptible(&fimc->lock))
-                return -ERESTARTSYS;
+        fimc_md_graph_lock(fimc);
+        mutex_lock(&fimc->lock);
 
         if (fimc_m2m_active(fimc))
                 goto unlock;
@@ -546,6 +549,7 @@ static int fimc_capture_open(struct file *file)
         }
 unlock:
         mutex_unlock(&fimc->lock);
+        fimc_md_graph_unlock(fimc);
         return ret;
 }
 
@@ -626,8 +630,8 @@ static struct fimc_fmt *fimc_capture_try_format(struct fimc_ctx *ctx,
 {
         bool rotation = ctx->rotation == 90 || ctx->rotation == 270;
         struct fimc_dev *fimc = ctx->fimc_dev;
-        struct fimc_variant *var = fimc->variant;
-        struct fimc_pix_limit *pl = var->pix_limit;
+        const struct fimc_variant *var = fimc->variant;
+        const struct fimc_pix_limit *pl = var->pix_limit;
         struct fimc_frame *dst = &ctx->d_frame;
         u32 depth, min_w, max_w, min_h, align_h = 3;
         u32 mask = FMT_FLAGS_CAM;
@@ -699,8 +703,8 @@ static void fimc_capture_try_selection(struct fimc_ctx *ctx,
 {
         bool rotate = ctx->rotation == 90 || ctx->rotation == 270;
         struct fimc_dev *fimc = ctx->fimc_dev;
-        struct fimc_variant *var = fimc->variant;
-        struct fimc_pix_limit *pl = var->pix_limit;
+        const struct fimc_variant *var = fimc->variant;
+        const struct fimc_pix_limit *pl = var->pix_limit;
         struct fimc_frame *sink = &ctx->s_frame;
         u32 max_w, max_h, min_w = 0, min_h = 0, min_sz;
         u32 align_sz = 0, align_h = 4;
@@ -793,6 +797,21 @@ static int fimc_cap_enum_fmt_mplane(struct file *file, void *priv,
         return 0;
 }
 
+static struct media_entity *fimc_pipeline_get_head(struct media_entity *me)
+{
+        struct media_pad *pad = &me->pads[0];
+
+        while (!(pad->flags & MEDIA_PAD_FL_SOURCE)) {
+                pad = media_entity_remote_source(pad);
+                if (!pad)
+                        break;
+                me = pad->entity;
+                pad = &me->pads[0];
+        }
+
+        return me;
+}
+
 /**
  * fimc_pipeline_try_format - negotiate and/or set formats at pipeline
  *                            elements
@@ -808,19 +827,23 @@ static int fimc_pipeline_try_format(struct fimc_ctx *ctx,
 {
         struct fimc_dev *fimc = ctx->fimc_dev;
         struct v4l2_subdev *sd = fimc->pipeline.subdevs[IDX_SENSOR];
-        struct v4l2_subdev *csis = fimc->pipeline.subdevs[IDX_CSIS];
         struct v4l2_subdev_format sfmt;
         struct v4l2_mbus_framefmt *mf = &sfmt.format;
-        struct fimc_fmt *ffmt = NULL;
-        int ret, i = 0;
+        struct media_entity *me;
+        struct fimc_fmt *ffmt;
+        struct media_pad *pad;
+        int ret, i = 1;
+        u32 fcc;
 
         if (WARN_ON(!sd || !tfmt))
                 return -EINVAL;
 
         memset(&sfmt, 0, sizeof(sfmt));
         sfmt.format = *tfmt;
-
         sfmt.which = set ? V4L2_SUBDEV_FORMAT_ACTIVE : V4L2_SUBDEV_FORMAT_TRY;
+
+        me = fimc_pipeline_get_head(&sd->entity);
+
         while (1) {
                 ffmt = fimc_find_format(NULL, mf->code != 0 ? &mf->code : NULL,
                                         FMT_FLAGS_CAM, i++);
@@ -833,40 +856,52 @@ static int fimc_pipeline_try_format(struct fimc_ctx *ctx,
                 }
                 mf->code = tfmt->code = ffmt->mbus_code;
 
-                ret = v4l2_subdev_call(sd, pad, set_fmt, NULL, &sfmt);
-                if (ret)
-                        return ret;
-                if (mf->code != tfmt->code) {
-                        mf->code = 0;
-                        continue;
+                /* set format on all pipeline subdevs */
+                while (me != &fimc->vid_cap.subdev.entity) {
+                        sd = media_entity_to_v4l2_subdev(me);
+
+                        sfmt.pad = 0;
+                        ret = v4l2_subdev_call(sd, pad, set_fmt, NULL, &sfmt);
+                        if (ret)
+                                return ret;
+
+                        if (me->pads[0].flags & MEDIA_PAD_FL_SINK) {
+                                sfmt.pad = me->num_pads - 1;
+                                mf->code = tfmt->code;
+                                ret = v4l2_subdev_call(sd, pad, set_fmt, NULL,
+                                                                        &sfmt);
+                                if (ret)
+                                        return ret;
+                        }
+
+                        pad = media_entity_remote_source(&me->pads[sfmt.pad]);
+                        if (!pad)
+                                return -EINVAL;
+                        me = pad->entity;
                 }
-                if (mf->width != tfmt->width || mf->height != tfmt->height) {
-                        u32 fcc = ffmt->fourcc;
-                        tfmt->width  = mf->width;
-                        tfmt->height = mf->height;
-                        ffmt = fimc_capture_try_format(ctx,
-                                               &tfmt->width, &tfmt->height,
-                                               NULL, &fcc, FIMC_SD_PAD_SOURCE);
-                        if (ffmt && ffmt->mbus_code)
-                                mf->code = ffmt->mbus_code;
-                        if (mf->width != tfmt->width ||
-                            mf->height != tfmt->height)
-                                continue;
-                        tfmt->code = mf->code;
-                }
-                if (csis)
-                        ret = v4l2_subdev_call(csis, pad, set_fmt, NULL, &sfmt);
 
-                if (mf->code == tfmt->code &&
-                    mf->width == tfmt->width && mf->height == tfmt->height)
-                        break;
+                if (mf->code != tfmt->code)
+                        continue;
+
+                fcc = ffmt->fourcc;
+                tfmt->width  = mf->width;
+                tfmt->height = mf->height;
+                ffmt = fimc_capture_try_format(ctx, &tfmt->width, &tfmt->height,
+                                        NULL, &fcc, FIMC_SD_PAD_SINK);
+                ffmt = fimc_capture_try_format(ctx, &tfmt->width, &tfmt->height,
+                                        NULL, &fcc, FIMC_SD_PAD_SOURCE);
+                if (ffmt && ffmt->mbus_code)
+                        mf->code = ffmt->mbus_code;
+                if (mf->width != tfmt->width || mf->height != tfmt->height)
+                        continue;
+                tfmt->code = mf->code;
+                break;
         }
 
         if (fmt_id && ffmt)
                 *fmt_id = ffmt;
         *tfmt = *mf;
 
-        dbg("code: 0x%x, %dx%d, %p", mf->code, mf->width, mf->height, ffmt);
         return 0;
 }
 
@@ -884,14 +919,16 @@ static int fimc_get_sensor_frame_desc(struct v4l2_subdev *sensor,
 {
         struct v4l2_mbus_frame_desc fd;
         int i, ret;
+        int pad;
 
         for (i = 0; i < num_planes; i++)
                 fd.entry[i].length = plane_fmt[i].sizeimage;
 
+        pad = sensor->entity.num_pads - 1;
         if (try)
-                ret = v4l2_subdev_call(sensor, pad, set_frame_desc, 0, &fd);
+                ret = v4l2_subdev_call(sensor, pad, set_frame_desc, pad, &fd);
         else
-                ret = v4l2_subdev_call(sensor, pad, get_frame_desc, 0, &fd);
+                ret = v4l2_subdev_call(sensor, pad, get_frame_desc, pad, &fd);
 
         if (ret < 0)
                 return ret;
@@ -916,9 +953,9 @@ static int fimc_cap_g_fmt_mplane(struct file *file, void *fh,
                                  struct v4l2_format *f)
 {
         struct fimc_dev *fimc = video_drvdata(file);
-        struct fimc_ctx *ctx = fimc->vid_cap.ctx;
 
-        return fimc_fill_format(&ctx->d_frame, f);
+        __fimc_get_format(&fimc->vid_cap.ctx->d_frame, f);
+        return 0;
 }
 
 static int fimc_cap_try_fmt_mplane(struct file *file, void *fh,
@@ -929,6 +966,10 @@ static int fimc_cap_try_fmt_mplane(struct file *file, void *fh,
         struct fimc_ctx *ctx = fimc->vid_cap.ctx;
         struct v4l2_mbus_framefmt mf;
         struct fimc_fmt *ffmt = NULL;
+        int ret = 0;
+
+        fimc_md_graph_lock(fimc);
+        mutex_lock(&fimc->lock);
 
         if (fimc_jpeg_fourcc(pix->pixelformat)) {
                 fimc_capture_try_format(ctx, &pix->width, &pix->height,
@@ -940,16 +981,16 @@ static int fimc_cap_try_fmt_mplane(struct file *file, void *fh,
         ffmt = fimc_capture_try_format(ctx, &pix->width, &pix->height,
                                        NULL, &pix->pixelformat,
                                        FIMC_SD_PAD_SOURCE);
-        if (!ffmt)
-                return -EINVAL;
+        if (!ffmt) {
+                ret = -EINVAL;
+                goto unlock;
+        }
 
         if (!fimc->vid_cap.user_subdev_api) {
                 mf.width = pix->width;
                 mf.height = pix->height;
                 mf.code = ffmt->mbus_code;
-                fimc_md_graph_lock(fimc);
                 fimc_pipeline_try_format(ctx, &mf, &ffmt, false);
-                fimc_md_graph_unlock(fimc);
                 pix->width = mf.width;
                 pix->height = mf.height;
                 if (ffmt)
@@ -961,8 +1002,11 @@ static int fimc_cap_try_fmt_mplane(struct file *file, void *fh,
         if (ffmt->flags & FMT_FLAGS_COMPRESSED)
                 fimc_get_sensor_frame_desc(fimc->pipeline.subdevs[IDX_SENSOR],
                                         pix->plane_fmt, ffmt->memplanes, true);
+unlock:
+        mutex_unlock(&fimc->lock);
+        fimc_md_graph_unlock(fimc);
 
-        return 0;
+        return ret;
 }
 
 static void fimc_capture_mark_jpeg_xfer(struct fimc_ctx *ctx,
@@ -979,7 +1023,8 @@ static void fimc_capture_mark_jpeg_xfer(struct fimc_ctx *ctx,
                 clear_bit(ST_CAPT_JPEG, &ctx->fimc_dev->state);
 }
 
-static int fimc_capture_set_format(struct fimc_dev *fimc, struct v4l2_format *f)
+static int __fimc_capture_set_format(struct fimc_dev *fimc,
+                                     struct v4l2_format *f)
 {
         struct fimc_ctx *ctx = fimc->vid_cap.ctx;
         struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp;
@@ -1014,12 +1059,10 @@ static int fimc_capture_set_format(struct fimc_dev *fimc, struct v4l2_format *f)
                 mf->code   = ff->fmt->mbus_code;
                 mf->width  = pix->width;
                 mf->height = pix->height;
-
-                fimc_md_graph_lock(fimc);
                 ret = fimc_pipeline_try_format(ctx, mf, &s_fmt, true);
-                fimc_md_graph_unlock(fimc);
                 if (ret)
                         return ret;
+
                 pix->width  = mf->width;
                 pix->height = mf->height;
         }
@@ -1034,8 +1077,10 @@ static int fimc_capture_set_format(struct fimc_dev *fimc, struct v4l2_format *f)
                         return ret;
         }
 
-        for (i = 0; i < ff->fmt->memplanes; i++)
+        for (i = 0; i < ff->fmt->memplanes; i++) {
+                ff->bytesperline[i] = pix->plane_fmt[i].bytesperline;
                 ff->payload[i] = pix->plane_fmt[i].sizeimage;
+        }
 
         set_frame_bounds(ff, pix->width, pix->height);
         /* Reset the composition rectangle if not yet configured */
@@ -1058,8 +1103,23 @@ static int fimc_cap_s_fmt_mplane(struct file *file, void *priv,
                                  struct v4l2_format *f)
 {
         struct fimc_dev *fimc = video_drvdata(file);
+        int ret;
+
+        fimc_md_graph_lock(fimc);
+        mutex_lock(&fimc->lock);
+        /*
+         * The graph is walked within __fimc_capture_set_format() to set
+         * the format at subdevs thus the graph mutex needs to be held at
+         * this point and acquired before the video mutex, to avoid  AB-BA
+         * deadlock when fimc_md_link_notify() is called by other thread.
+         * Ideally the graph walking and setting format at the whole pipeline
+         * should be removed from this driver and handled in userspace only.
+         */
+        ret = __fimc_capture_set_format(fimc, f);
 
-        return fimc_capture_set_format(fimc, f);
+        mutex_unlock(&fimc->lock);
+        fimc_md_graph_unlock(fimc);
+        return ret;
 }
 
 static int fimc_cap_enum_input(struct file *file, void *priv,
@@ -1528,6 +1588,10 @@ static int fimc_subdev_set_fmt(struct v4l2_subdev *sd,
                 *mf = fmt->format;
                 return 0;
         }
+        /* There must be a bug in the driver if this happens */
+        if (WARN_ON(ffmt == NULL))
+                return -EINVAL;
+
         /* Update RGB Alpha control state and value range */
         fimc_alpha_ctrl_update(ctx);
 
@@ -1624,16 +1688,6 @@ static int fimc_subdev_set_selection(struct v4l2_subdev *sd,
         fimc_capture_try_selection(ctx, r, V4L2_SEL_TGT_CROP);
 
         switch (sel->target) {
-        case V4L2_SEL_TGT_COMPOSE_BOUNDS:
-                f = &ctx->d_frame;
-        case V4L2_SEL_TGT_CROP_BOUNDS:
-                r->width = f->o_width;
-                r->height = f->o_height;
-                r->left = 0;
-                r->top = 0;
-                mutex_unlock(&fimc->lock);
-                return 0;
-
         case V4L2_SEL_TGT_CROP:
                 try_sel = v4l2_subdev_get_try_crop(fh, sel->pad);
                 break;
@@ -1652,9 +1706,9 @@ static int fimc_subdev_set_selection(struct v4l2_subdev *sd,
                 spin_lock_irqsave(&fimc->slock, flags);
                 set_frame_crop(f, r->left, r->top, r->width, r->height);
                 set_bit(ST_CAPT_APPLY_CFG, &fimc->state);
-                spin_unlock_irqrestore(&fimc->slock, flags);
                 if (sel->target == V4L2_SEL_TGT_COMPOSE)
                         ctx->state |= FIMC_COMPOSE;
+                spin_unlock_irqrestore(&fimc->slock, flags);
         }
 
         dbg("target %#x: (%d,%d)/%dx%d", sel->target, r->left, r->top,
@@ -1690,7 +1744,7 @@ static int fimc_capture_set_default_format(struct fimc_dev *fimc)
                 },
         };
 
-        return fimc_capture_set_format(fimc, &fmt);
+        return __fimc_capture_set_format(fimc, &fmt);
 }
 
 /* fimc->lock must be already initialized */
@@ -1752,6 +1806,12 @@ static int fimc_register_capture_device(struct fimc_dev *fimc,
         ret = media_entity_init(&vfd->entity, 1, &vid_cap->vd_pad, 0);
         if (ret)
                 goto err_ent;
+        /*
+         * For proper order of acquiring/releasing the video
+         * and the graph mutex.
+         */
+        v4l2_disable_ioctl_locking(vfd, VIDIOC_TRY_FMT);
+        v4l2_disable_ioctl_locking(vfd, VIDIOC_S_FMT);
 
         ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
         if (ret)
diff --git a/drivers/media/platform/s5p-fimc/fimc-core.c b/drivers/media/platform/s5p-fimc/fimc-core.c
index acc0f84ffa56..e3916bde45cf 100644
--- a/drivers/media/platform/s5p-fimc/fimc-core.c
+++ b/drivers/media/platform/s5p-fimc/fimc-core.c
@@ -241,7 +241,7 @@ static int fimc_get_scaler_factor(u32 src, u32 tar, u32 *ratio, u32 *shift)
 
 int fimc_set_scaler_info(struct fimc_ctx *ctx)
 {
-        struct fimc_variant *variant = ctx->fimc_dev->variant;
+        const struct fimc_variant *variant = ctx->fimc_dev->variant;
         struct device *dev = &ctx->fimc_dev->pdev->dev;
         struct fimc_scaler *sc = &ctx->scaler;
         struct fimc_frame *s_frame = &ctx->s_frame;
@@ -257,14 +257,14 @@ int fimc_set_scaler_info(struct fimc_ctx *ctx)
                 ty = d_frame->height;
         }
         if (tx <= 0 || ty <= 0) {
-                dev_err(dev, "Invalid target size: %dx%d", tx, ty);
+                dev_err(dev, "Invalid target size: %dx%d\n", tx, ty);
                 return -EINVAL;
         }
 
         sx = s_frame->width;
         sy = s_frame->height;
         if (sx <= 0 || sy <= 0) {
-                dev_err(dev, "Invalid source size: %dx%d", sx, sy);
+                dev_err(dev, "Invalid source size: %dx%d\n", sx, sy);
                 return -EINVAL;
         }
         sc->real_width = sx;
@@ -440,7 +440,7 @@ void fimc_set_yuv_order(struct fimc_ctx *ctx)
 
 void fimc_prepare_dma_offset(struct fimc_ctx *ctx, struct fimc_frame *f)
 {
-        struct fimc_variant *variant = ctx->fimc_dev->variant;
+        const struct fimc_variant *variant = ctx->fimc_dev->variant;
         u32 i, depth = 0;
 
         for (i = 0; i < f->fmt->colplanes; i++)
@@ -524,8 +524,7 @@ static int fimc_set_color_effect(struct fimc_ctx *ctx, enum v4l2_colorfx colorfx
 static int __fimc_s_ctrl(struct fimc_ctx *ctx, struct v4l2_ctrl *ctrl)
 {
         struct fimc_dev *fimc = ctx->fimc_dev;
-        struct fimc_variant *variant = fimc->variant;
-        unsigned int flags = FIMC_DST_FMT | FIMC_SRC_FMT;
+        const struct fimc_variant *variant = fimc->variant;
         int ret = 0;
 
         if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
@@ -541,8 +540,7 @@ static int __fimc_s_ctrl(struct fimc_ctx *ctx, struct v4l2_ctrl *ctrl)
                 break;
 
         case V4L2_CID_ROTATE:
-                if (fimc_capture_pending(fimc) ||
-                    (ctx->state & flags) == flags) {
+                if (fimc_capture_pending(fimc)) {
                         ret = fimc_check_scaler_ratio(ctx, ctx->s_frame.width,
                                         ctx->s_frame.height, ctx->d_frame.width,
                                         ctx->d_frame.height, ctrl->val);
@@ -591,7 +589,7 @@ static const struct v4l2_ctrl_ops fimc_ctrl_ops = {
 
 int fimc_ctrls_create(struct fimc_ctx *ctx)
 {
-        struct fimc_variant *variant = ctx->fimc_dev->variant;
+        const struct fimc_variant *variant = ctx->fimc_dev->variant;
         unsigned int max_alpha = fimc_get_alpha_mask(ctx->d_frame.fmt);
         struct fimc_ctrls *ctrls = &ctx->ctrls;
         struct v4l2_ctrl_handler *handler = &ctrls->handler;
@@ -691,7 +689,7 @@ void fimc_alpha_ctrl_update(struct fimc_ctx *ctx)
         v4l2_ctrl_unlock(ctrl);
 }
 
-int fimc_fill_format(struct fimc_frame *frame, struct v4l2_format *f)
+void __fimc_get_format(struct fimc_frame *frame, struct v4l2_format *f)
 {
         struct v4l2_pix_format_mplane *pixm = &f->fmt.pix_mp;
         int i;
@@ -704,35 +702,9 @@ int fimc_fill_format(struct fimc_frame *frame, struct v4l2_format *f)
         pixm->num_planes = frame->fmt->memplanes;
 
         for (i = 0; i < pixm->num_planes; ++i) {
-                int bpl = frame->f_width;
-                if (frame->fmt->colplanes == 1) /* packed formats */
-                        bpl = (bpl * frame->fmt->depth[0]) / 8;
-                pixm->plane_fmt[i].bytesperline = bpl;
-
-                if (frame->fmt->flags & FMT_FLAGS_COMPRESSED) {
-                        pixm->plane_fmt[i].sizeimage = frame->payload[i];
-                        continue;
-                }
-                pixm->plane_fmt[i].sizeimage = (frame->o_width *
-                        frame->o_height * frame->fmt->depth[i]) / 8;
+                pixm->plane_fmt[i].bytesperline = frame->bytesperline[i];
+                pixm->plane_fmt[i].sizeimage = frame->payload[i];
         }
-        return 0;
-}
-
-void fimc_fill_frame(struct fimc_frame *frame, struct v4l2_format *f)
-{
-        struct v4l2_pix_format_mplane *pixm = &f->fmt.pix_mp;
-
-        frame->f_width  = pixm->plane_fmt[0].bytesperline;
-        if (frame->fmt->colplanes == 1)
-                frame->f_width = (frame->f_width * 8) / frame->fmt->depth[0];
-        frame->f_height = pixm->height;
-        frame->width    = pixm->width;
-        frame->height   = pixm->height;
-        frame->o_width  = pixm->width;
-        frame->o_height = pixm->height;
-        frame->offs_h   = 0;
-        frame->offs_v   = 0;
 }
 
 /**
@@ -765,9 +737,16 @@ void fimc_adjust_mplane_format(struct fimc_fmt *fmt, u32 width, u32 height,
                 if (fmt->colplanes == 1 && /* Packed */
                     (bpl == 0 || ((bpl * 8) / fmt->depth[i]) < pix->width))
                         bpl = (pix->width * fmt->depth[0]) / 8;
-
-                if (i == 0) /* Same bytesperline for each plane. */
+                /*
+                 * Currently bytesperline for each plane is same, except
+                 * V4L2_PIX_FMT_YUV420M format. This calculation may need
+                 * to be changed when other multi-planar formats are added
+                 * to the fimc_formats[] array.
+                 */
+                if (i == 0)
                         bytesperline = bpl;
+                else if (i == 1 && fmt->memplanes == 3)
+                        bytesperline /= 2;
 
                 plane_fmt->bytesperline = bytesperline;
                 plane_fmt->sizeimage = max((pix->width * pix->height *
@@ -811,11 +790,11 @@ static void fimc_clk_put(struct fimc_dev *fimc)
 {
         int i;
         for (i = 0; i < MAX_FIMC_CLOCKS; i++) {
-                if (IS_ERR_OR_NULL(fimc->clock[i]))
+                if (IS_ERR(fimc->clock[i]))
                         continue;
                 clk_unprepare(fimc->clock[i]);
                 clk_put(fimc->clock[i]);
-                fimc->clock[i] = NULL;
+                fimc->clock[i] = ERR_PTR(-EINVAL);
         }
 }
 
@@ -823,14 +802,19 @@ static int fimc_clk_get(struct fimc_dev *fimc)
 {
         int i, ret;
 
+        for (i = 0; i < MAX_FIMC_CLOCKS; i++)
+                fimc->clock[i] = ERR_PTR(-EINVAL);
+
         for (i = 0; i < MAX_FIMC_CLOCKS; i++) {
                 fimc->clock[i] = clk_get(&fimc->pdev->dev, fimc_clocks[i]);
-                if (IS_ERR(fimc->clock[i]))
+                if (IS_ERR(fimc->clock[i])) {
+                        ret = PTR_ERR(fimc->clock[i]);
                         goto err;
+                }
                 ret = clk_prepare(fimc->clock[i]);
                 if (ret < 0) {
                         clk_put(fimc->clock[i]);
-                        fimc->clock[i] = NULL;
+                        fimc->clock[i] = ERR_PTR(-EINVAL);
                         goto err;
                 }
         }
@@ -881,7 +865,7 @@ static int fimc_m2m_resume(struct fimc_dev *fimc)
 
 static int fimc_probe(struct platform_device *pdev)
 {
-        struct fimc_drvdata *drv_data = fimc_get_drvdata(pdev);
+        const struct fimc_drvdata *drv_data = fimc_get_drvdata(pdev);
         struct s5p_platform_fimc *pdata;
         struct fimc_dev *fimc;
         struct resource *res;
@@ -922,8 +906,14 @@ static int fimc_probe(struct platform_device *pdev)
         ret = fimc_clk_get(fimc);
         if (ret)
                 return ret;
-        clk_set_rate(fimc->clock[CLK_BUS], drv_data->lclk_frequency);
-        clk_enable(fimc->clock[CLK_BUS]);
+
+        ret = clk_set_rate(fimc->clock[CLK_BUS], drv_data->lclk_frequency);
+        if (ret < 0)
+                return ret;
+
+        ret = clk_enable(fimc->clock[CLK_BUS]);
+        if (ret < 0)
+                return ret;
 
         ret = devm_request_irq(&pdev->dev, res->start, fimc_irq_handler,
                                0, dev_name(&pdev->dev), fimc);
@@ -957,6 +947,7 @@ err_pm:
 err_sd:
         fimc_unregister_capture_subdev(fimc);
 err_clk:
+        clk_disable(fimc->clock[CLK_BUS]);
         fimc_clk_put(fimc);
         return ret;
 }
@@ -1051,7 +1042,7 @@ static int fimc_remove(struct platform_device *pdev)
 }
 
 /* Image pixel limits, similar across several FIMC HW revisions. */
-static struct fimc_pix_limit s5p_pix_limit[4] = {
+static const struct fimc_pix_limit s5p_pix_limit[4] = {
         [0] = {
                 .scaler_en_w    = 3264,
                 .scaler_dis_w   = 8192,
@@ -1086,7 +1077,7 @@ static struct fimc_pix_limit s5p_pix_limit[4] = {
         },
 };
 
-static struct fimc_variant fimc0_variant_s5p = {
+static const struct fimc_variant fimc0_variant_s5p = {
         .has_inp_rot     = 1,
         .has_out_rot     = 1,
         .has_cam_if      = 1,
@@ -1098,7 +1089,7 @@ static struct fimc_variant fimc0_variant_s5p = {
         .pix_limit       = &s5p_pix_limit[0],
 };
 
-static struct fimc_variant fimc2_variant_s5p = {
+static const struct fimc_variant fimc2_variant_s5p = {
         .has_cam_if      = 1,
         .min_inp_pixsize = 16,
         .min_out_pixsize = 16,
@@ -1108,7 +1099,7 @@ static struct fimc_variant fimc2_variant_s5p = {
         .pix_limit       = &s5p_pix_limit[1],
 };
 
-static struct fimc_variant fimc0_variant_s5pv210 = {
+static const struct fimc_variant fimc0_variant_s5pv210 = {
         .pix_hoff        = 1,
         .has_inp_rot     = 1,
         .has_out_rot     = 1,
@@ -1121,7 +1112,7 @@ static struct fimc_variant fimc0_variant_s5pv210 = {
         .pix_limit       = &s5p_pix_limit[1],
 };
 
-static struct fimc_variant fimc1_variant_s5pv210 = {
+static const struct fimc_variant fimc1_variant_s5pv210 = {
         .pix_hoff        = 1,
         .has_inp_rot     = 1,
         .has_out_rot     = 1,
@@ -1135,7 +1126,7 @@ static struct fimc_variant fimc1_variant_s5pv210 = {
         .pix_limit       = &s5p_pix_limit[2],
 };
 
-static struct fimc_variant fimc2_variant_s5pv210 = {
+static const struct fimc_variant fimc2_variant_s5pv210 = {
         .has_cam_if      = 1,
         .pix_hoff        = 1,
         .min_inp_pixsize = 16,
@@ -1146,7 +1137,7 @@ static struct fimc_variant fimc2_variant_s5pv210 = {
         .pix_limit       = &s5p_pix_limit[2],
 };
 
-static struct fimc_variant fimc0_variant_exynos4 = {
+static const struct fimc_variant fimc0_variant_exynos4210 = {
         .pix_hoff        = 1,
         .has_inp_rot     = 1,
         .has_out_rot     = 1,
@@ -1162,9 +1153,8 @@ static struct fimc_variant fimc0_variant_exynos4 = {
         .pix_limit       = &s5p_pix_limit[1],
 };
 
-static struct fimc_variant fimc3_variant_exynos4 = {
+static const struct fimc_variant fimc3_variant_exynos4210 = {
         .pix_hoff        = 1,
-        .has_cam_if      = 1,
         .has_cistatus2   = 1,
         .has_mainscaler_ext = 1,
         .has_alpha       = 1,
@@ -1176,8 +1166,38 @@ static struct fimc_variant fimc3_variant_exynos4 = {
         .pix_limit       = &s5p_pix_limit[3],
 };
 
+static const struct fimc_variant fimc0_variant_exynos4x12 = {
+        .pix_hoff               = 1,
+        .has_inp_rot            = 1,
+        .has_out_rot            = 1,
+        .has_cam_if             = 1,
+        .has_isp_wb             = 1,
+        .has_cistatus2          = 1,
+        .has_mainscaler_ext     = 1,
+        .has_alpha              = 1,
+        .min_inp_pixsize        = 16,
+        .min_out_pixsize        = 16,
+        .hor_offs_align         = 2,
+        .min_vsize_align        = 1,
+        .out_buf_count          = 32,
+        .pix_limit              = &s5p_pix_limit[1],
+};
+
+static const struct fimc_variant fimc3_variant_exynos4x12 = {
+        .pix_hoff               = 1,
+        .has_cistatus2          = 1,
+        .has_mainscaler_ext     = 1,
+        .has_alpha              = 1,
+        .min_inp_pixsize        = 16,
+        .min_out_pixsize        = 16,
+        .hor_offs_align         = 2,
+        .min_vsize_align        = 1,
+        .out_buf_count          = 32,
+        .pix_limit              = &s5p_pix_limit[3],
+};
+
 /* S5PC100 */
-static struct fimc_drvdata fimc_drvdata_s5p = {
+static const struct fimc_drvdata fimc_drvdata_s5p = {
         .variant = {
                 [0] = &fimc0_variant_s5p,
                 [1] = &fimc0_variant_s5p,
@@ -1188,7 +1208,7 @@ static struct fimc_drvdata fimc_drvdata_s5p = {
 };
 
 /* S5PV210, S5PC110 */
-static struct fimc_drvdata fimc_drvdata_s5pv210 = {
+static const struct fimc_drvdata fimc_drvdata_s5pv210 = {
         .variant = {
                 [0] = &fimc0_variant_s5pv210,
                 [1] = &fimc1_variant_s5pv210,
@@ -1199,18 +1219,30 @@ static struct fimc_drvdata fimc_drvdata_s5pv210 = {
 };
 
 /* EXYNOS4210, S5PV310, S5PC210 */
-static struct fimc_drvdata fimc_drvdata_exynos4 = {
+static const struct fimc_drvdata fimc_drvdata_exynos4210 = {
+        .variant = {
+                [0] = &fimc0_variant_exynos4210,
+                [1] = &fimc0_variant_exynos4210,
+                [2] = &fimc0_variant_exynos4210,
+                [3] = &fimc3_variant_exynos4210,
+        },
+        .num_entities = 4,
+        .lclk_frequency = 166000000UL,
+};
+
+/* EXYNOS4212, EXYNOS4412 */
+static const struct fimc_drvdata fimc_drvdata_exynos4x12 = {
         .variant = {
-                [0] = &fimc0_variant_exynos4,
-                [1] = &fimc0_variant_exynos4,
-                [2] = &fimc0_variant_exynos4,
-                [3] = &fimc3_variant_exynos4,
+                [0] = &fimc0_variant_exynos4x12,
+                [1] = &fimc0_variant_exynos4x12,
+                [2] = &fimc0_variant_exynos4x12,
+                [3] = &fimc3_variant_exynos4x12,
         },
         .num_entities = 4,
         .lclk_frequency = 166000000UL,
 };
 
-static struct platform_device_id fimc_driver_ids[] = {
+static const struct platform_device_id fimc_driver_ids[] = {
         {
                 .name           = "s5p-fimc",
                 .driver_data    = (unsigned long)&fimc_drvdata_s5p,
@@ -1219,7 +1251,10 @@ static struct platform_device_id fimc_driver_ids[] = {
                 .driver_data    = (unsigned long)&fimc_drvdata_s5pv210,
         }, {
                 .name           = "exynos4-fimc",
-                .driver_data    = (unsigned long)&fimc_drvdata_exynos4,
+                .driver_data    = (unsigned long)&fimc_drvdata_exynos4210,
+        }, {
+                .name           = "exynos4x12-fimc",
+                .driver_data    = (unsigned long)&fimc_drvdata_exynos4x12,
         },
         {},
 };
diff --git a/drivers/media/platform/s5p-fimc/fimc-core.h b/drivers/media/platform/s5p-fimc/fimc-core.h
index c0040d792499..412d50708f75 100644
--- a/drivers/media/platform/s5p-fimc/fimc-core.h
+++ b/drivers/media/platform/s5p-fimc/fimc-core.h
@@ -112,9 +112,7 @@ enum fimc_color_fmt {
 
 /* The hardware context state. */
 #define FIMC_PARAMS             (1 << 0)
-#define FIMC_SRC_FMT            (1 << 3)
-#define FIMC_DST_FMT            (1 << 4)
-#define FIMC_COMPOSE            (1 << 5)
+#define FIMC_COMPOSE            (1 << 1)
 #define FIMC_CTX_M2M            (1 << 16)
 #define FIMC_CTX_CAP            (1 << 17)
 #define FIMC_CTX_SHUT           (1 << 18)
@@ -265,6 +263,7 @@ struct fimc_vid_buffer {
  * @width:      image pixel width
  * @height:     image pixel weight
  * @payload:    image size in bytes (w x h x bpp)
+ * @bytesperline: bytesperline value for each plane
  * @paddr:      image frame buffer physical addresses
  * @dma_offset: DMA offset in bytes
  * @fmt:        fimc color format pointer
@@ -279,6 +278,7 @@ struct fimc_frame {
         u32     width;
         u32     height;
         unsigned int            payload[VIDEO_MAX_PLANES];
+        unsigned int            bytesperline[VIDEO_MAX_PLANES];
         struct fimc_addr        paddr;
         struct fimc_dma_offset  dma_offset;
         struct fimc_fmt         *fmt;
@@ -372,6 +372,7 @@ struct fimc_pix_limit {
  * @has_mainscaler_ext: 1 if extended mainscaler ratios in CIEXTEN register
  *                       are present in this IP revision
  * @has_cam_if: set if this instance has a camera input interface
+ * @has_isp_wb: set if this instance has ISP writeback input
  * @pix_limit: pixel size constraints for the scaler
  * @min_inp_pixsize: minimum input pixel size
  * @min_out_pixsize: minimum output pixel size
@@ -386,8 +387,9 @@ struct fimc_variant {
         unsigned int    has_cistatus2:1;
         unsigned int    has_mainscaler_ext:1;
         unsigned int    has_cam_if:1;
+        unsigned int    has_isp_wb:1;
         unsigned int    has_alpha:1;
-        struct fimc_pix_limit *pix_limit;
+        const struct fimc_pix_limit *pix_limit;
         u16             min_inp_pixsize;
         u16             min_out_pixsize;
         u16             hor_offs_align;
@@ -402,7 +404,7 @@ struct fimc_variant {
  * @lclk_frequency: local bus clock frequency
  */
 struct fimc_drvdata {
-        struct fimc_variant *variant[FIMC_MAX_DEVS];
+        const struct fimc_variant *variant[FIMC_MAX_DEVS];
         int num_entities;
         unsigned long lclk_frequency;
 };
@@ -435,7 +437,7 @@ struct fimc_dev {
         struct mutex                    lock;
         struct platform_device          *pdev;
         struct s5p_platform_fimc        *pdata;
-        struct fimc_variant             *variant;
+        const struct fimc_variant       *variant;
         u16                             id;
         struct clk                      *clock[MAX_FIMC_CLOCKS];
         void __iomem                    *regs;
@@ -635,7 +637,7 @@ int fimc_ctrls_create(struct fimc_ctx *ctx);
 void fimc_ctrls_delete(struct fimc_ctx *ctx);
 void fimc_ctrls_activate(struct fimc_ctx *ctx, bool active);
 void fimc_alpha_ctrl_update(struct fimc_ctx *ctx);
-int fimc_fill_format(struct fimc_frame *frame, struct v4l2_format *f);
+void __fimc_get_format(struct fimc_frame *frame, struct v4l2_format *f);
 void fimc_adjust_mplane_format(struct fimc_fmt *fmt, u32 width, u32 height,
                                struct v4l2_pix_format_mplane *pix);
 struct fimc_fmt *fimc_find_format(const u32 *pixelformat, const u32 *mbus_code,
@@ -650,7 +652,6 @@ int fimc_prepare_addr(struct fimc_ctx *ctx, struct vb2_buffer *vb,
                       struct fimc_frame *frame, struct fimc_addr *paddr);
 void fimc_prepare_dma_offset(struct fimc_ctx *ctx, struct fimc_frame *f);
 void fimc_set_yuv_order(struct fimc_ctx *ctx);
-void fimc_fill_frame(struct fimc_frame *frame, struct v4l2_format *f);
 void fimc_capture_irq_handler(struct fimc_dev *fimc, int deq_buf);
 
 int fimc_register_m2m_device(struct fimc_dev *fimc,
diff --git a/drivers/media/platform/s5p-fimc/fimc-lite-reg.c b/drivers/media/platform/s5p-fimc/fimc-lite-reg.c
index a22d7eb05c82..f0af0754a7b4 100644
--- a/drivers/media/platform/s5p-fimc/fimc-lite-reg.c
+++ b/drivers/media/platform/s5p-fimc/fimc-lite-reg.c
@@ -65,7 +65,7 @@ void flite_hw_set_interrupt_mask(struct fimc_lite *dev)
         u32 cfg, intsrc;
 
         /* Select interrupts to be enabled for each output mode */
-        if (dev->out_path == FIMC_IO_DMA) {
+        if (atomic_read(&dev->out_path) == FIMC_IO_DMA) {
                 intsrc = FLITE_REG_CIGCTRL_IRQ_OVFEN |
                          FLITE_REG_CIGCTRL_IRQ_LASTEN |
                          FLITE_REG_CIGCTRL_IRQ_STARTEN;
@@ -187,12 +187,12 @@ static void flite_hw_set_camera_port(struct fimc_lite *dev, int id)
 
 /* Select serial or parallel bus, camera port (A,B) and set signals polarity */
 void flite_hw_set_camera_bus(struct fimc_lite *dev,
-                             struct s5p_fimc_isp_info *s_info)
+                             struct fimc_source_info *si)
 {
         u32 cfg = readl(dev->regs + FLITE_REG_CIGCTRL);
-        unsigned int flags = s_info->flags;
+        unsigned int flags = si->flags;
 
-        if (s_info->bus_type != FIMC_MIPI_CSI2) {
+        if (si->sensor_bus_type != FIMC_BUS_TYPE_MIPI_CSI2) {
                 cfg &= ~(FLITE_REG_CIGCTRL_SELCAM_MIPI |
                          FLITE_REG_CIGCTRL_INVPOLPCLK |
                          FLITE_REG_CIGCTRL_INVPOLVSYNC |
@@ -212,7 +212,7 @@ void flite_hw_set_camera_bus(struct fimc_lite *dev,
 
         writel(cfg, dev->regs + FLITE_REG_CIGCTRL);
 
-        flite_hw_set_camera_port(dev, s_info->mux_id);
+        flite_hw_set_camera_port(dev, si->mux_id);
 }
 
 static void flite_hw_set_out_order(struct fimc_lite *dev, struct flite_frame *f)
@@ -292,9 +292,11 @@ void flite_hw_dump_regs(struct fimc_lite *dev, const char *label)
         };
         u32 i;
 
-        pr_info("--- %s ---\n", label);
+        v4l2_info(&dev->subdev, "--- %s ---\n", label);
+
         for (i = 0; i < ARRAY_SIZE(registers); i++) {
                 u32 cfg = readl(dev->regs + registers[i].offset);
-                pr_info("%s: %s:\t0x%08x\n", __func__, registers[i].name, cfg);
+                v4l2_info(&dev->subdev, "%9s: 0x%08x\n",
+                          registers[i].name, cfg);
         }
 }
diff --git a/drivers/media/platform/s5p-fimc/fimc-lite-reg.h b/drivers/media/platform/s5p-fimc/fimc-lite-reg.h
index adb9e9e6f3c2..0e345844c13a 100644
--- a/drivers/media/platform/s5p-fimc/fimc-lite-reg.h
+++ b/drivers/media/platform/s5p-fimc/fimc-lite-reg.h
@@ -131,9 +131,9 @@ void flite_hw_set_interrupt_mask(struct fimc_lite *dev);
 void flite_hw_capture_start(struct fimc_lite *dev);
 void flite_hw_capture_stop(struct fimc_lite *dev);
 void flite_hw_set_camera_bus(struct fimc_lite *dev,
-                             struct s5p_fimc_isp_info *s_info);
+                             struct fimc_source_info *s_info);
 void flite_hw_set_camera_polarity(struct fimc_lite *dev,
-                                  struct s5p_fimc_isp_info *cam);
+                                  struct fimc_source_info *cam);
 void flite_hw_set_window_offset(struct fimc_lite *dev, struct flite_frame *f);
 void flite_hw_set_source_format(struct fimc_lite *dev, struct flite_frame *f);
 
diff --git a/drivers/media/platform/s5p-fimc/fimc-lite.c b/drivers/media/platform/s5p-fimc/fimc-lite.c
index 67db9f8102e4..bfc4206935c8 100644
--- a/drivers/media/platform/s5p-fimc/fimc-lite.c
+++ b/drivers/media/platform/s5p-fimc/fimc-lite.c
@@ -120,25 +120,29 @@ static const struct fimc_fmt *fimc_lite_find_format(const u32 *pixelformat,
         return def_fmt;
 }
 
-static int fimc_lite_hw_init(struct fimc_lite *fimc)
+static int fimc_lite_hw_init(struct fimc_lite *fimc, bool isp_output)
 {
         struct fimc_pipeline *pipeline = &fimc->pipeline;
-        struct fimc_sensor_info *sensor;
+        struct v4l2_subdev *sensor;
+        struct fimc_sensor_info *si;
         unsigned long flags;
 
-        if (pipeline->subdevs[IDX_SENSOR] == NULL)
+        sensor = isp_output ? fimc->sensor : pipeline->subdevs[IDX_SENSOR];
+
+        if (sensor == NULL)
                 return -ENXIO;
 
         if (fimc->fmt == NULL)
                 return -EINVAL;
 
-        sensor = v4l2_get_subdev_hostdata(pipeline->subdevs[IDX_SENSOR]);
+        /* Get sensor configuration data from the sensor subdev */
+        si = v4l2_get_subdev_hostdata(sensor);
         spin_lock_irqsave(&fimc->slock, flags);
 
-        flite_hw_set_camera_bus(fimc, &sensor->pdata);
+        flite_hw_set_camera_bus(fimc, &si->pdata);
         flite_hw_set_source_format(fimc, &fimc->inp_frame);
         flite_hw_set_window_offset(fimc, &fimc->inp_frame);
-        flite_hw_set_output_dma(fimc, &fimc->out_frame, true);
+        flite_hw_set_output_dma(fimc, &fimc->out_frame, !isp_output);
         flite_hw_set_interrupt_mask(fimc);
         flite_hw_set_test_pattern(fimc, fimc->test_pattern->val);
 
@@ -256,7 +260,7 @@ static irqreturn_t flite_irq_handler(int irq, void *priv)
                 wake_up(&fimc->irq_queue);
         }
 
-        if (fimc->out_path != FIMC_IO_DMA)
+        if (atomic_read(&fimc->out_path) != FIMC_IO_DMA)
                 goto done;
 
         if ((intsrc & FLITE_REG_CISTATUS_IRQ_SRC_FRMSTART) &&
@@ -296,7 +300,7 @@ static int start_streaming(struct vb2_queue *q, unsigned int count)
 
         fimc->frame_count = 0;
 
-        ret = fimc_lite_hw_init(fimc);
+        ret = fimc_lite_hw_init(fimc, false);
         if (ret) {
                 fimc_lite_reinit(fimc, false);
                 return ret;
@@ -455,10 +459,16 @@ static void fimc_lite_clear_event_counters(struct fimc_lite *fimc)
 static int fimc_lite_open(struct file *file)
 {
         struct fimc_lite *fimc = video_drvdata(file);
+        struct media_entity *me = &fimc->vfd.entity;
         int ret;
 
-        if (mutex_lock_interruptible(&fimc->lock))
-                return -ERESTARTSYS;
+        mutex_lock(&me->parent->graph_mutex);
+
+        mutex_lock(&fimc->lock);
+        if (atomic_read(&fimc->out_path) != FIMC_IO_DMA) {
+                ret = -EBUSY;
+                goto done;
+        }
 
         set_bit(ST_FLITE_IN_USE, &fimc->state);
         ret = pm_runtime_get_sync(&fimc->pdev->dev);
@@ -469,7 +479,8 @@ static int fimc_lite_open(struct file *file)
         if (ret < 0)
                 goto done;
 
-        if (++fimc->ref_count == 1 && fimc->out_path == FIMC_IO_DMA) {
+        if (++fimc->ref_count == 1 &&
+            atomic_read(&fimc->out_path) == FIMC_IO_DMA) {
                 ret = fimc_pipeline_call(fimc, open, &fimc->pipeline,
                                          &fimc->vfd.entity, true);
                 if (ret < 0) {
@@ -483,6 +494,7 @@ static int fimc_lite_open(struct file *file)
         }
 done:
         mutex_unlock(&fimc->lock);
+        mutex_unlock(&me->parent->graph_mutex);
         return ret;
 }
 
@@ -493,7 +505,8 @@ static int fimc_lite_close(struct file *file)
 
         mutex_lock(&fimc->lock);
 
-        if (--fimc->ref_count == 0 && fimc->out_path == FIMC_IO_DMA) {
+        if (--fimc->ref_count == 0 &&
+            atomic_read(&fimc->out_path) == FIMC_IO_DMA) {
                 clear_bit(ST_FLITE_IN_USE, &fimc->state);
                 fimc_lite_stop_capture(fimc, false);
                 fimc_pipeline_call(fimc, close, &fimc->pipeline);
@@ -598,7 +611,7 @@ static void fimc_lite_try_crop(struct fimc_lite *fimc, struct v4l2_rect *r)
         r->left = round_down(r->left, fimc->variant->win_hor_offs_align);
         r->top  = clamp_t(u32, r->top, 0, frame->f_height - r->height);
 
-        v4l2_dbg(1, debug, &fimc->subdev, "(%d,%d)/%dx%d, sink fmt: %dx%d",
+        v4l2_dbg(1, debug, &fimc->subdev, "(%d,%d)/%dx%d, sink fmt: %dx%d\n",
                  r->left, r->top, r->width, r->height,
                  frame->f_width, frame->f_height);
 }
@@ -618,7 +631,7 @@ static void fimc_lite_try_compose(struct fimc_lite *fimc, struct v4l2_rect *r)
         r->left = round_down(r->left, fimc->variant->out_hor_offs_align);
         r->top  = clamp_t(u32, r->top, 0, fimc->out_frame.f_height - r->height);
 
-        v4l2_dbg(1, debug, &fimc->subdev, "(%d,%d)/%dx%d, source fmt: %dx%d",
+        v4l2_dbg(1, debug, &fimc->subdev, "(%d,%d)/%dx%d, source fmt: %dx%d\n",
                  r->left, r->top, r->width, r->height,
                  frame->f_width, frame->f_height);
 }
@@ -962,6 +975,29 @@ static const struct v4l2_ioctl_ops fimc_lite_ioctl_ops = {
         .vidioc_streamoff               = fimc_lite_streamoff,
 };
 
+/* Called with the media graph mutex held */
+static struct v4l2_subdev *__find_remote_sensor(struct media_entity *me)
+{
+        struct media_pad *pad = &me->pads[0];
+        struct v4l2_subdev *sd;
+
+        while (pad->flags & MEDIA_PAD_FL_SINK) {
+                /* source pad */
+                pad = media_entity_remote_source(pad);
+                if (pad == NULL ||
+                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
+                        break;
+
+                sd = media_entity_to_v4l2_subdev(pad->entity);
+
+                if (sd->grp_id == GRP_ID_FIMC_IS_SENSOR)
+                        return sd;
+                /* sink pad */
+                pad = &sd->entity.pads[0];
+        }
+        return NULL;
+}
+
 /* Capture subdev media entity operations */
 static int fimc_lite_link_setup(struct media_entity *entity,
                                 const struct media_pad *local,
@@ -970,46 +1006,60 @@ static int fimc_lite_link_setup(struct media_entity *entity,
         struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
         struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
         unsigned int remote_ent_type = media_entity_type(remote->entity);
+        int ret = 0;
 
         if (WARN_ON(fimc == NULL))
                 return 0;
 
-        v4l2_dbg(1, debug, sd, "%s: %s --> %s, flags: 0x%x. source_id: 0x%x",
-                 __func__, local->entity->name, remote->entity->name,
+        v4l2_dbg(1, debug, sd, "%s: %s --> %s, flags: 0x%x. source_id: 0x%x\n",
+                 __func__, remote->entity->name, local->entity->name,
                  flags, fimc->source_subdev_grp_id);
 
-        switch (local->index) {
-        case FIMC_SD_PAD_SINK:
-                if (remote_ent_type != MEDIA_ENT_T_V4L2_SUBDEV)
-                        return -EINVAL;
+        mutex_lock(&fimc->lock);
 
+        switch (local->index) {
+        case FLITE_SD_PAD_SINK:
+                if (remote_ent_type != MEDIA_ENT_T_V4L2_SUBDEV) {
+                        ret = -EINVAL;
+                        break;
+                }
                 if (flags & MEDIA_LNK_FL_ENABLED) {
-                        if (fimc->source_subdev_grp_id != 0)
-                                return -EBUSY;
-                        fimc->source_subdev_grp_id = sd->grp_id;
-                        return 0;
+                        if (fimc->source_subdev_grp_id == 0)
+                                fimc->source_subdev_grp_id = sd->grp_id;
+                        else
+                                ret = -EBUSY;
+                } else {
+                        fimc->source_subdev_grp_id = 0;
+                        fimc->sensor = NULL;
                 }
+                break;
 
-                fimc->source_subdev_grp_id = 0;
+        case FLITE_SD_PAD_SOURCE_DMA:
+                if (!(flags & MEDIA_LNK_FL_ENABLED))
+                        atomic_set(&fimc->out_path, FIMC_IO_NONE);
+                else if (remote_ent_type == MEDIA_ENT_T_DEVNODE)
+                        atomic_set(&fimc->out_path, FIMC_IO_DMA);
+                else
+                        ret = -EINVAL;
                 break;
 
-        case FIMC_SD_PAD_SOURCE:
-                if (!(flags & MEDIA_LNK_FL_ENABLED)) {
-                        fimc->out_path = FIMC_IO_NONE;
-                        return 0;
-                }
-                if (remote_ent_type == MEDIA_ENT_T_V4L2_SUBDEV)
-                        fimc->out_path = FIMC_IO_ISP;
+        case FLITE_SD_PAD_SOURCE_ISP:
+                if (!(flags & MEDIA_LNK_FL_ENABLED))
+                        atomic_set(&fimc->out_path, FIMC_IO_NONE);
+                else if (remote_ent_type == MEDIA_ENT_T_V4L2_SUBDEV)
+                        atomic_set(&fimc->out_path, FIMC_IO_ISP);
                 else
-                        fimc->out_path = FIMC_IO_DMA;
+                        ret = -EINVAL;
                 break;
 
         default:
                 v4l2_err(sd, "Invalid pad index\n");
-                return -EINVAL;
+                ret = -EINVAL;
         }
+        mb();
 
-        return 0;
+        mutex_unlock(&fimc->lock);
+        return ret;
 }
 
 static const struct media_entity_operations fimc_lite_subdev_media_ops = {
@@ -1070,14 +1120,16 @@ static int fimc_lite_subdev_set_fmt(struct v4l2_subdev *sd,
         struct flite_frame *source = &fimc->out_frame;
         const struct fimc_fmt *ffmt;
 
-        v4l2_dbg(1, debug, sd, "pad%d: code: 0x%x, %dx%d",
+        v4l2_dbg(1, debug, sd, "pad%d: code: 0x%x, %dx%d\n",
                  fmt->pad, mf->code, mf->width, mf->height);
 
         mf->colorspace = V4L2_COLORSPACE_JPEG;
         mutex_lock(&fimc->lock);
 
-        if ((fimc->out_path == FIMC_IO_ISP && sd->entity.stream_count > 0) ||
-            (fimc->out_path == FIMC_IO_DMA && vb2_is_busy(&fimc->vb_queue))) {
+        if ((atomic_read(&fimc->out_path) == FIMC_IO_ISP &&
+            sd->entity.stream_count > 0) ||
+            (atomic_read(&fimc->out_path) == FIMC_IO_DMA &&
+            vb2_is_busy(&fimc->vb_queue))) {
                 mutex_unlock(&fimc->lock);
                 return -EBUSY;
         }
@@ -1144,7 +1196,7 @@ static int fimc_lite_subdev_get_selection(struct v4l2_subdev *sd,
         }
         mutex_unlock(&fimc->lock);
 
-        v4l2_dbg(1, debug, sd, "%s: (%d,%d) %dx%d, f_w: %d, f_h: %d",
+        v4l2_dbg(1, debug, sd, "%s: (%d,%d) %dx%d, f_w: %d, f_h: %d\n",
                  __func__, f->rect.left, f->rect.top, f->rect.width,
                  f->rect.height, f->f_width, f->f_height);
 
@@ -1178,7 +1230,7 @@ static int fimc_lite_subdev_set_selection(struct v4l2_subdev *sd,
         }
         mutex_unlock(&fimc->lock);
 
-        v4l2_dbg(1, debug, sd, "%s: (%d,%d) %dx%d, f_w: %d, f_h: %d",
+        v4l2_dbg(1, debug, sd, "%s: (%d,%d) %dx%d, f_w: %d, f_h: %d\n",
                  __func__, f->rect.left, f->rect.top, f->rect.width,
                  f->rect.height, f->f_width, f->f_height);
 
@@ -1188,25 +1240,47 @@ static int fimc_lite_subdev_set_selection(struct v4l2_subdev *sd,
 static int fimc_lite_subdev_s_stream(struct v4l2_subdev *sd, int on)
 {
         struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
+        unsigned long flags;
+        int ret;
 
-        if (fimc->out_path == FIMC_IO_DMA)
-                return -ENOIOCTLCMD;
-
-        /* TODO: */
+        /*
+         * Find sensor subdev linked to FIMC-LITE directly or through
+         * MIPI-CSIS. This is required for configuration where FIMC-LITE
+         * is used as a subdev only and feeds data internally to FIMC-IS.
+         * The pipeline links are protected through entity.stream_count
+         * so there is no need to take the media graph mutex here.
+         */
+        fimc->sensor = __find_remote_sensor(&sd->entity);
 
-        return 0;
-}
+        if (atomic_read(&fimc->out_path) != FIMC_IO_ISP)
+                return -ENOIOCTLCMD;
 
-static int fimc_lite_subdev_s_power(struct v4l2_subdev *sd, int on)
-{
-        struct fimc_lite *fimc = v4l2_get_subdevdata(sd);
+        mutex_lock(&fimc->lock);
+        if (on) {
+                flite_hw_reset(fimc);
+                ret = fimc_lite_hw_init(fimc, true);
+                if (!ret) {
+                        spin_lock_irqsave(&fimc->slock, flags);
+                        flite_hw_capture_start(fimc);
+                        spin_unlock_irqrestore(&fimc->slock, flags);
+                }
+        } else {
+                set_bit(ST_FLITE_OFF, &fimc->state);
 
-        if (fimc->out_path == FIMC_IO_DMA)
-                return -ENOIOCTLCMD;
+                spin_lock_irqsave(&fimc->slock, flags);
+                flite_hw_capture_stop(fimc);
+                spin_unlock_irqrestore(&fimc->slock, flags);
 
-        /* TODO: */
+                ret = wait_event_timeout(fimc->irq_queue,
+                                !test_bit(ST_FLITE_OFF, &fimc->state),
+                                msecs_to_jiffies(200));
+                if (ret == 0)
+                        v4l2_err(sd, "s_stream(0) timeout\n");
+                clear_bit(ST_FLITE_RUN, &fimc->state);
+        }
 
-        return 0;
+        mutex_unlock(&fimc->lock);
+        return ret;
 }
 
 static int fimc_lite_log_status(struct v4l2_subdev *sd)
@@ -1227,7 +1301,7 @@ static int fimc_lite_subdev_registered(struct v4l2_subdev *sd)
         memset(vfd, 0, sizeof(*vfd));
 
         fimc->fmt = &fimc_lite_formats[0];
-        fimc->out_path = FIMC_IO_DMA;
+        atomic_set(&fimc->out_path, FIMC_IO_DMA);
 
         snprintf(vfd->name, sizeof(vfd->name), "fimc-lite.%d.capture",
                  fimc->index);
@@ -1308,7 +1382,6 @@ static const struct v4l2_subdev_video_ops fimc_lite_subdev_video_ops = {
 };
 
 static const struct v4l2_subdev_core_ops fimc_lite_core_ops = {
-        .s_power = fimc_lite_subdev_s_power,
         .log_status = fimc_lite_log_status,
 };
 
@@ -1347,9 +1420,10 @@ static int fimc_lite_create_capture_subdev(struct fimc_lite *fimc)
         sd->flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
         snprintf(sd->name, sizeof(sd->name), "FIMC-LITE.%d", fimc->index);
 
-        fimc->subdev_pads[FIMC_SD_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
-        fimc->subdev_pads[FIMC_SD_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
-        ret = media_entity_init(&sd->entity, FIMC_SD_PADS_NUM,
+        fimc->subdev_pads[FLITE_SD_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
+        fimc->subdev_pads[FLITE_SD_PAD_SOURCE_DMA].flags = MEDIA_PAD_FL_SOURCE;
+        fimc->subdev_pads[FLITE_SD_PAD_SOURCE_ISP].flags = MEDIA_PAD_FL_SOURCE;
+        ret = media_entity_init(&sd->entity, FLITE_SD_PADS_NUM,
                                 fimc->subdev_pads, 0);
         if (ret)
                 return ret;
@@ -1516,7 +1590,7 @@ static int fimc_lite_resume(struct device *dev)
         INIT_LIST_HEAD(&fimc->active_buf_q);
         fimc_pipeline_call(fimc, open, &fimc->pipeline,
                            &fimc->vfd.entity, false);
-        fimc_lite_hw_init(fimc);
+        fimc_lite_hw_init(fimc, atomic_read(&fimc->out_path) == FIMC_IO_ISP);
         clear_bit(ST_FLITE_SUSPENDED, &fimc->state);
 
         for (i = 0; i < fimc->reqbufs_count; i++) {
diff --git a/drivers/media/platform/s5p-fimc/fimc-lite.h b/drivers/media/platform/s5p-fimc/fimc-lite.h
index 3081db35c5b0..7085761f8c4b 100644
--- a/drivers/media/platform/s5p-fimc/fimc-lite.h
+++ b/drivers/media/platform/s5p-fimc/fimc-lite.h
@@ -45,8 +45,9 @@ enum {
 };
 
 #define FLITE_SD_PAD_SINK       0
-#define FLITE_SD_PAD_SOURCE     1
-#define FLITE_SD_PADS_NUM       2
+#define FLITE_SD_PAD_SOURCE_DMA 1
+#define FLITE_SD_PAD_SOURCE_ISP 2
+#define FLITE_SD_PADS_NUM       3
 
 struct flite_variant {
         unsigned short max_width;
@@ -104,6 +105,7 @@ struct flite_buffer {
  * @subdev: FIMC-LITE subdev
  * @vd_pad: media (sink) pad for the capture video node
  * @subdev_pads: the subdev media pads
+ * @sensor: sensor subdev attached to FIMC-LITE directly or through MIPI-CSIS
  * @ctrl_handler: v4l2 control handler
  * @test_pattern: test pattern controls
  * @index: FIMC-LITE platform device index
@@ -139,6 +141,7 @@ struct fimc_lite {
         struct v4l2_subdev      subdev;
         struct media_pad        vd_pad;
         struct media_pad        subdev_pads[FLITE_SD_PADS_NUM];
+        struct v4l2_subdev      *sensor;
         struct v4l2_ctrl_handler ctrl_handler;
         struct v4l2_ctrl        *test_pattern;
         u32                     index;
@@ -156,7 +159,7 @@ struct fimc_lite {
         unsigned long           payload[FLITE_MAX_PLANES];
         struct flite_frame      inp_frame;
         struct flite_frame      out_frame;
-        enum fimc_datapath      out_path;
+        atomic_t                out_path;
         unsigned int            source_subdev_grp_id;
 
         unsigned long           state;
diff --git a/drivers/media/platform/s5p-fimc/fimc-m2m.c b/drivers/media/platform/s5p-fimc/fimc-m2m.c
index 1d21da4bd24b..f3d535cdd87f 100644
--- a/drivers/media/platform/s5p-fimc/fimc-m2m.c
+++ b/drivers/media/platform/s5p-fimc/fimc-m2m.c
@@ -1,8 +1,8 @@
 /*
  * Samsung S5P/EXYNOS4 SoC series FIMC (video postprocessor) driver
  *
- * Copyright (C) 2012 Samsung Electronics Co., Ltd.
- * Sylwester Nawrocki, <s.nawrocki@samsung.com>
+ * Copyright (C) 2012 - 2013 Samsung Electronics Co., Ltd.
+ * Sylwester Nawrocki <s.nawrocki@samsung.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
@@ -160,8 +160,7 @@ static void fimc_device_run(void *priv)
         fimc_hw_set_output_addr(fimc, &df->paddr, -1);
 
         fimc_activate_capture(ctx);
-        ctx->state &= (FIMC_CTX_M2M | FIMC_CTX_CAP |
-                       FIMC_SRC_FMT | FIMC_DST_FMT);
+        ctx->state &= (FIMC_CTX_M2M | FIMC_CTX_CAP);
         fimc_hw_activate_input_dma(fimc, true);
 
 dma_unlock:
@@ -294,13 +293,14 @@ static int fimc_m2m_g_fmt_mplane(struct file *file, void *fh,
         if (IS_ERR(frame))
                 return PTR_ERR(frame);
 
-        return fimc_fill_format(frame, f);
+        __fimc_get_format(frame, f);
+        return 0;
 }
 
 static int fimc_try_fmt_mplane(struct fimc_ctx *ctx, struct v4l2_format *f)
 {
         struct fimc_dev *fimc = ctx->fimc_dev;
-        struct fimc_variant *variant = fimc->variant;
+        const struct fimc_variant *variant = fimc->variant;
         struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp;
         struct fimc_fmt *fmt;
         u32 max_w, mod_x, mod_y;
@@ -308,8 +308,6 @@ static int fimc_try_fmt_mplane(struct fimc_ctx *ctx, struct v4l2_format *f)
         if (!IS_M2M(f->type))
                 return -EINVAL;
 
-        dbg("w: %d, h: %d", pix->width, pix->height);
-
         fmt = fimc_find_format(&pix->pixelformat, NULL,
                                get_m2m_fmt_flags(f->type), 0);
         if (WARN(fmt == NULL, "Pixel format lookup failed"))
@@ -349,19 +347,39 @@ static int fimc_m2m_try_fmt_mplane(struct file *file, void *fh,
                                    struct v4l2_format *f)
 {
         struct fimc_ctx *ctx = fh_to_ctx(fh);
-
         return fimc_try_fmt_mplane(ctx, f);
 }
 
+static void __set_frame_format(struct fimc_frame *frame, struct fimc_fmt *fmt,
+                               struct v4l2_pix_format_mplane *pixm)
+{
+        int i;
+
+        for (i = 0; i < fmt->colplanes; i++) {
+                frame->bytesperline[i] = pixm->plane_fmt[i].bytesperline;
+                frame->payload[i] = pixm->plane_fmt[i].sizeimage;
+        }
+
+        frame->f_width = pixm->width;
+        frame->f_height = pixm->height;
+        frame->o_width = pixm->width;
+        frame->o_height = pixm->height;
+        frame->width = pixm->width;
+        frame->height = pixm->height;
+        frame->offs_h = 0;
+        frame->offs_v = 0;
+        frame->fmt = fmt;
+}
+
 static int fimc_m2m_s_fmt_mplane(struct file *file, void *fh,
                                  struct v4l2_format *f)
 {
         struct fimc_ctx *ctx = fh_to_ctx(fh);
         struct fimc_dev *fimc = ctx->fimc_dev;
+        struct fimc_fmt *fmt;
         struct vb2_queue *vq;
         struct fimc_frame *frame;
-        struct v4l2_pix_format_mplane *pix;
-        int i, ret = 0;
+        int ret;
 
         ret = fimc_try_fmt_mplane(ctx, f);
         if (ret)
@@ -379,31 +397,16 @@ static int fimc_m2m_s_fmt_mplane(struct file *file, void *fh,
         else
                 frame = &ctx->d_frame;
 
-        pix = &f->fmt.pix_mp;
-        frame->fmt = fimc_find_format(&pix->pixelformat, NULL,
-                                      get_m2m_fmt_flags(f->type), 0);
-        if (!frame->fmt)
+        fmt = fimc_find_format(&f->fmt.pix_mp.pixelformat, NULL,
+                               get_m2m_fmt_flags(f->type), 0);
+        if (!fmt)
                 return -EINVAL;
 
+        __set_frame_format(frame, fmt, &f->fmt.pix_mp);
+
         /* Update RGB Alpha control state and value range */
         fimc_alpha_ctrl_update(ctx);
 
-        for (i = 0; i < frame->fmt->colplanes; i++) {
-                frame->payload[i] =
-                        (pix->width * pix->height * frame->fmt->depth[i]) / 8;
-        }
-
-        fimc_fill_frame(frame, f);
-
-        ctx->scaler.enabled = 1;
-
-        if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
-                fimc_ctx_state_set(FIMC_PARAMS | FIMC_DST_FMT, ctx);
-        else
-                fimc_ctx_state_set(FIMC_PARAMS | FIMC_SRC_FMT, ctx);
-
-        dbg("f_w: %d, f_h: %d", frame->f_width, frame->f_height);
-
         return 0;
 }
 
@@ -411,7 +414,6 @@ static int fimc_m2m_reqbufs(struct file *file, void *fh,
                             struct v4l2_requestbuffers *reqbufs)
 {
         struct fimc_ctx *ctx = fh_to_ctx(fh);
-
         return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);
 }
 
@@ -419,7 +421,6 @@ static int fimc_m2m_querybuf(struct file *file, void *fh,
                              struct v4l2_buffer *buf)
 {
         struct fimc_ctx *ctx = fh_to_ctx(fh);
-
         return v4l2_m2m_querybuf(file, ctx->m2m_ctx, buf);
 }
 
@@ -427,7 +428,6 @@ static int fimc_m2m_qbuf(struct file *file, void *fh,
                          struct v4l2_buffer *buf)
 {
         struct fimc_ctx *ctx = fh_to_ctx(fh);
-
         return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf);
 }
 
@@ -435,7 +435,6 @@ static int fimc_m2m_dqbuf(struct file *file, void *fh,
                           struct v4l2_buffer *buf)
 {
         struct fimc_ctx *ctx = fh_to_ctx(fh);
-
         return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
 }
 
@@ -443,7 +442,6 @@ static int fimc_m2m_expbuf(struct file *file, void *fh,
                             struct v4l2_exportbuffer *eb)
 {
         struct fimc_ctx *ctx = fh_to_ctx(fh);
-
         return v4l2_m2m_expbuf(file, ctx->m2m_ctx, eb);
 }
 
@@ -452,15 +450,6 @@ static int fimc_m2m_streamon(struct file *file, void *fh,
                              enum v4l2_buf_type type)
 {
         struct fimc_ctx *ctx = fh_to_ctx(fh);
-
-        /* The source and target color format need to be set */
-        if (V4L2_TYPE_IS_OUTPUT(type)) {
-                if (!fimc_ctx_state_is_set(FIMC_SRC_FMT, ctx))
-                        return -EINVAL;
-        } else if (!fimc_ctx_state_is_set(FIMC_DST_FMT, ctx)) {
-                return -EINVAL;
-        }
-
         return v4l2_m2m_streamon(file, ctx->m2m_ctx, type);
 }
 
@@ -468,7 +457,6 @@ static int fimc_m2m_streamoff(struct file *file, void *fh,
                             enum v4l2_buf_type type)
 {
         struct fimc_ctx *ctx = fh_to_ctx(fh);
-
         return v4l2_m2m_streamoff(file, ctx->m2m_ctx, type);
 }
 
@@ -576,20 +564,18 @@ static int fimc_m2m_s_crop(struct file *file, void *fh, const struct v4l2_crop *
                 &ctx->s_frame : &ctx->d_frame;
 
         /* Check to see if scaling ratio is within supported range */
-        if (fimc_ctx_state_is_set(FIMC_DST_FMT | FIMC_SRC_FMT, ctx)) {
-                if (cr.type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
-                        ret = fimc_check_scaler_ratio(ctx, cr.c.width,
-                                        cr.c.height, ctx->d_frame.width,
-                                        ctx->d_frame.height, ctx->rotation);
-                } else {
-                        ret = fimc_check_scaler_ratio(ctx, ctx->s_frame.width,
-                                        ctx->s_frame.height, cr.c.width,
-                                        cr.c.height, ctx->rotation);
-                }
-                if (ret) {
-                        v4l2_err(&fimc->m2m.vfd, "Out of scaler range\n");
-                        return -EINVAL;
-                }
+        if (cr.type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
+                ret = fimc_check_scaler_ratio(ctx, cr.c.width,
+                                cr.c.height, ctx->d_frame.width,
+                                ctx->d_frame.height, ctx->rotation);
+        } else {
+                ret = fimc_check_scaler_ratio(ctx, ctx->s_frame.width,
+                                ctx->s_frame.height, cr.c.width,
+                                cr.c.height, ctx->rotation);
+        }
+        if (ret) {
+                v4l2_err(&fimc->m2m.vfd, "Out of scaler range\n");
+                return -EINVAL;
         }
 
         f->offs_h = cr.c.left;
@@ -652,6 +638,29 @@ static int queue_init(void *priv, struct vb2_queue *src_vq,
         return vb2_queue_init(dst_vq);
 }
 
+static int fimc_m2m_set_default_format(struct fimc_ctx *ctx)
+{
+        struct v4l2_pix_format_mplane pixm = {
+                .pixelformat    = V4L2_PIX_FMT_RGB32,
+                .width          = 800,
+                .height         = 600,
+                .plane_fmt[0]   = {
+                        .bytesperline = 800 * 4,
+                        .sizeimage = 800 * 4 * 600,
+                },
+        };
+        struct fimc_fmt *fmt;
+
+        fmt = fimc_find_format(&pixm.pixelformat, NULL, FMT_FLAGS_M2M, 0);
+        if (!fmt)
+                return -EINVAL;
+
+        __set_frame_format(&ctx->s_frame, fmt, &pixm);
+        __set_frame_format(&ctx->d_frame, fmt, &pixm);
+
+        return 0;
+}
+
 static int fimc_m2m_open(struct file *file)
 {
         struct fimc_dev *fimc = video_drvdata(file);
@@ -696,6 +705,7 @@ static int fimc_m2m_open(struct file *file)
         ctx->flags = 0;
         ctx->in_path = FIMC_IO_DMA;
         ctx->out_path = FIMC_IO_DMA;
+        ctx->scaler.enabled = 1;
 
         ctx->m2m_ctx = v4l2_m2m_ctx_init(fimc->m2m.m2m_dev, ctx, queue_init);
         if (IS_ERR(ctx->m2m_ctx)) {
@@ -706,9 +716,15 @@ static int fimc_m2m_open(struct file *file)
         if (fimc->m2m.refcnt++ == 0)
                 set_bit(ST_M2M_RUN, &fimc->state);
 
+        ret = fimc_m2m_set_default_format(ctx);
+        if (ret < 0)
+                goto error_m2m_ctx;
+
         mutex_unlock(&fimc->lock);
         return 0;
 
+error_m2m_ctx:
+        v4l2_m2m_ctx_release(ctx->m2m_ctx);
 error_c:
         fimc_ctrls_delete(ctx);
 error_fh:
diff --git a/drivers/media/platform/s5p-fimc/fimc-mdevice.c b/drivers/media/platform/s5p-fimc/fimc-mdevice.c
index b4a68ecf0ca7..a17fcb2d5d41 100644
--- a/drivers/media/platform/s5p-fimc/fimc-mdevice.c
+++ b/drivers/media/platform/s5p-fimc/fimc-mdevice.c
@@ -1,8 +1,8 @@
 /*
  * S5P/EXYNOS4 SoC series camera host interface media device driver
  *
- * Copyright (C) 2011 Samsung Electronics Co., Ltd.
- * Contact: Sylwester Nawrocki, <s.nawrocki@samsung.com>
+ * Copyright (C) 2011 - 2012 Samsung Electronics Co., Ltd.
+ * Sylwester Nawrocki <s.nawrocki@samsung.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
@@ -62,16 +62,17 @@ static void fimc_pipeline_prepare(struct fimc_pipeline *p,
                 sd = media_entity_to_v4l2_subdev(pad->entity);
 
                 switch (sd->grp_id) {
-                case SENSOR_GROUP_ID:
+                case GRP_ID_FIMC_IS_SENSOR:
+                case GRP_ID_SENSOR:
                         p->subdevs[IDX_SENSOR] = sd;
                         break;
-                case CSIS_GROUP_ID:
+                case GRP_ID_CSIS:
                         p->subdevs[IDX_CSIS] = sd;
                         break;
-                case FLITE_GROUP_ID:
+                case GRP_ID_FLITE:
                         p->subdevs[IDX_FLITE] = sd;
                         break;
-                case FIMC_GROUP_ID:
+                case GRP_ID_FIMC:
                         /* No need to control FIMC subdev through subdev ops */
                         break;
                 default:
@@ -141,7 +142,7 @@ static int fimc_pipeline_s_power(struct fimc_pipeline *p, bool state)
  * @me: media entity to start graph walk with
  * @prep: true to acquire sensor (and csis) subdevs
  *
- * This function must be called with the graph mutex held.
+ * Called with the graph mutex held.
  */
 static int __fimc_pipeline_open(struct fimc_pipeline *p,
                                 struct media_entity *me, bool prep)
@@ -161,30 +162,19 @@ static int __fimc_pipeline_open(struct fimc_pipeline *p,
         return fimc_pipeline_s_power(p, 1);
 }
 
-static int fimc_pipeline_open(struct fimc_pipeline *p,
-                              struct media_entity *me, bool prep)
-{
-        int ret;
-
-        mutex_lock(&me->parent->graph_mutex);
-        ret =  __fimc_pipeline_open(p, me, prep);
-        mutex_unlock(&me->parent->graph_mutex);
-
-        return ret;
-}
-
 /**
  * __fimc_pipeline_close - disable the sensor clock and pipeline power
  * @fimc: fimc device terminating the pipeline
  *
- * Disable power of all subdevs in the pipeline and turn off the external
- * sensor clock.
- * Called with the graph mutex held.
+ * Disable power of all subdevs and turn the external sensor clock off.
  */
 static int __fimc_pipeline_close(struct fimc_pipeline *p)
 {
         int ret = 0;
 
+        if (!p || !p->subdevs[IDX_SENSOR])
+                return -EINVAL;
+
         if (p->subdevs[IDX_SENSOR]) {
                 ret = fimc_pipeline_s_power(p, 0);
                 fimc_md_set_camclk(p->subdevs[IDX_SENSOR], false);
@@ -192,28 +182,12 @@ static int __fimc_pipeline_close(struct fimc_pipeline *p)
         return ret == -ENXIO ? 0 : ret;
 }
 
-static int fimc_pipeline_close(struct fimc_pipeline *p)
-{
-        struct media_entity *me;
-        int ret;
-
-        if (!p || !p->subdevs[IDX_SENSOR])
-                return -EINVAL;
-
-        me = &p->subdevs[IDX_SENSOR]->entity;
-        mutex_lock(&me->parent->graph_mutex);
-        ret = __fimc_pipeline_close(p);
-        mutex_unlock(&me->parent->graph_mutex);
-
-        return ret;
-}
-
 /**
- * fimc_pipeline_s_stream - invoke s_stream on pipeline subdevs
+ * __fimc_pipeline_s_stream - invoke s_stream on pipeline subdevs
  * @pipeline: video pipeline structure
  * @on: passed as the s_stream call argument
  */
-static int fimc_pipeline_s_stream(struct fimc_pipeline *p, bool on)
+static int __fimc_pipeline_s_stream(struct fimc_pipeline *p, bool on)
 {
         int i, ret;
 
@@ -235,9 +209,9 @@ static int fimc_pipeline_s_stream(struct fimc_pipeline *p, bool on)
 
 /* Media pipeline operations for the FIMC/FIMC-LITE video device driver */
 static const struct fimc_pipeline_ops fimc_pipeline_ops = {
-        .open           = fimc_pipeline_open,
-        .close          = fimc_pipeline_close,
-        .set_stream     = fimc_pipeline_s_stream,
+        .open           = __fimc_pipeline_open,
+        .close          = __fimc_pipeline_close,
+        .set_stream     = __fimc_pipeline_s_stream,
 };
 
 /*
@@ -269,7 +243,7 @@ static struct v4l2_subdev *fimc_md_register_sensor(struct fimc_md *fmd,
                 return ERR_PTR(-EPROBE_DEFER);
         }
         v4l2_set_subdev_hostdata(sd, s_info);
-        sd->grp_id = SENSOR_GROUP_ID;
+        sd->grp_id = GRP_ID_SENSOR;
 
         v4l2_info(&fmd->v4l2_dev, "Registered sensor subdevice %s\n",
                   s_info->pdata.board_info->type);
@@ -316,7 +290,7 @@ static int fimc_md_register_sensor_entities(struct fimc_md *fmd)
         for (i = 0; i < num_clients; i++) {
                 struct v4l2_subdev *sd;
 
-                fmd->sensor[i].pdata = pdata->isp_info[i];
+                fmd->sensor[i].pdata = pdata->source_info[i];
                 ret = __fimc_md_set_camclk(fmd, &fmd->sensor[i], true);
                 if (ret)
                         break;
@@ -338,138 +312,149 @@ static int fimc_md_register_sensor_entities(struct fimc_md *fmd)
 }
 
 /*
- * MIPI CSIS and FIMC platform devices registration.
+ * MIPI-CSIS, FIMC and FIMC-LITE platform devices registration.
  */
-static int fimc_register_callback(struct device *dev, void *p)
+
+static int register_fimc_lite_entity(struct fimc_md *fmd,
+                                     struct fimc_lite *fimc_lite)
 {
-        struct fimc_dev *fimc = dev_get_drvdata(dev);
         struct v4l2_subdev *sd;
-        struct fimc_md *fmd = p;
         int ret;
 
-        if (fimc == NULL || fimc->id >= FIMC_MAX_DEVS)
-                return 0;
+        if (WARN_ON(fimc_lite->index >= FIMC_LITE_MAX_DEVS ||
+                    fmd->fimc_lite[fimc_lite->index]))
+                return -EBUSY;
 
-        sd = &fimc->vid_cap.subdev;
-        sd->grp_id = FIMC_GROUP_ID;
+        sd = &fimc_lite->subdev;
+        sd->grp_id = GRP_ID_FLITE;
         v4l2_set_subdev_hostdata(sd, (void *)&fimc_pipeline_ops);
 
         ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
-        if (ret) {
-                v4l2_err(&fmd->v4l2_dev, "Failed to register FIMC.%d (%d)\n",
-                         fimc->id, ret);
-                return ret;
-        }
-
-        fmd->fimc[fimc->id] = fimc;
-        return 0;
+        if (!ret)
+                fmd->fimc_lite[fimc_lite->index] = fimc_lite;
+        else
+                v4l2_err(&fmd->v4l2_dev, "Failed to register FIMC.LITE%d\n",
+                         fimc_lite->index);
+        return ret;
 }
 
-static int fimc_lite_register_callback(struct device *dev, void *p)
+static int register_fimc_entity(struct fimc_md *fmd, struct fimc_dev *fimc)
 {
-        struct fimc_lite *fimc = dev_get_drvdata(dev);
-        struct fimc_md *fmd = p;
+        struct v4l2_subdev *sd;
         int ret;
 
-        if (fimc == NULL || fimc->index >= FIMC_LITE_MAX_DEVS)
-                return 0;
+        if (WARN_ON(fimc->id >= FIMC_MAX_DEVS || fmd->fimc[fimc->id]))
+                return -EBUSY;
 
-        fimc->subdev.grp_id = FLITE_GROUP_ID;
-        v4l2_set_subdev_hostdata(&fimc->subdev, (void *)&fimc_pipeline_ops);
+        sd = &fimc->vid_cap.subdev;
+        sd->grp_id = GRP_ID_FIMC;
+        v4l2_set_subdev_hostdata(sd, (void *)&fimc_pipeline_ops);
 
-        ret = v4l2_device_register_subdev(&fmd->v4l2_dev, &fimc->subdev);
-        if (ret) {
-                v4l2_err(&fmd->v4l2_dev,
-                         "Failed to register FIMC-LITE.%d (%d)\n",
-                         fimc->index, ret);
-                return ret;
+        ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
+        if (!ret) {
+                fmd->fimc[fimc->id] = fimc;
+                fimc->vid_cap.user_subdev_api = fmd->user_subdev_api;
+        } else {
+                v4l2_err(&fmd->v4l2_dev, "Failed to register FIMC.%d (%d)\n",
+                         fimc->id, ret);
         }
-
-        fmd->fimc_lite[fimc->index] = fimc;
-        return 0;
+        return ret;
 }
 
-static int csis_register_callback(struct device *dev, void *p)
+static int register_csis_entity(struct fimc_md *fmd,
+                                struct platform_device *pdev,
+                                struct v4l2_subdev *sd)
 {
-        struct v4l2_subdev *sd = dev_get_drvdata(dev);
-        struct platform_device *pdev;
-        struct fimc_md *fmd = p;
+        struct device_node *node = pdev->dev.of_node;
         int id, ret;
 
-        if (!sd)
-                return 0;
-        pdev = v4l2_get_subdevdata(sd);
-        if (!pdev || pdev->id < 0 || pdev->id >= CSIS_MAX_ENTITIES)
-                return 0;
-        v4l2_info(sd, "csis%d sd: %s\n", pdev->id, sd->name);
+        id = node ? of_alias_get_id(node, "csis") : max(0, pdev->id);
+
+        if (WARN_ON(id >= CSIS_MAX_ENTITIES || fmd->csis[id].sd))
+                return -EBUSY;
 
-        id = pdev->id < 0 ? 0 : pdev->id;
-        sd->grp_id = CSIS_GROUP_ID;
+        if (WARN_ON(id >= CSIS_MAX_ENTITIES))
+                return 0;
 
+        sd->grp_id = GRP_ID_CSIS;
         ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
         if (!ret)
                 fmd->csis[id].sd = sd;
         else
                 v4l2_err(&fmd->v4l2_dev,
-                         "Failed to register CSIS subdevice: %d\n", ret);
+                         "Failed to register MIPI-CSIS.%d (%d)\n", id, ret);
         return ret;
 }
 
-/**
- * fimc_md_register_platform_entities - register FIMC and CSIS media entities
- */
-static int fimc_md_register_platform_entities(struct fimc_md *fmd)
+static int fimc_md_register_platform_entity(struct fimc_md *fmd,
+                                            struct platform_device *pdev,
+                                            int plat_entity)
 {
-        struct s5p_platform_fimc *pdata = fmd->pdev->dev.platform_data;
-        struct device_driver *driver;
-        int ret, i;
-
-        driver = driver_find(FIMC_MODULE_NAME, &platform_bus_type);
-        if (!driver) {
-                v4l2_warn(&fmd->v4l2_dev,
-                         "%s driver not found, deffering probe\n",
-                         FIMC_MODULE_NAME);
-                return -EPROBE_DEFER;
-        }
-
-        ret = driver_for_each_device(driver, NULL, fmd,
-                                     fimc_register_callback);
-        if (ret)
-                return ret;
-
-        driver = driver_find(FIMC_LITE_DRV_NAME, &platform_bus_type);
-        if (driver && try_module_get(driver->owner)) {
-                ret = driver_for_each_device(driver, NULL, fmd,
-                                             fimc_lite_register_callback);
-                if (ret)
-                        return ret;
-                module_put(driver->owner);
-        }
-        /*
-         * Check if there is any sensor on the MIPI-CSI2 bus and
-         * if not skip the s5p-csis module loading.
-         */
-        if (pdata == NULL)
-                return 0;
-        for (i = 0; i < pdata->num_clients; i++) {
-                if (pdata->isp_info[i].bus_type == FIMC_MIPI_CSI2) {
-                        ret = 1;
+        struct device *dev = &pdev->dev;
+        int ret = -EPROBE_DEFER;
+        void *drvdata;
+
+        /* Lock to ensure dev->driver won't change. */
+        device_lock(dev);
+
+        if (!dev->driver || !try_module_get(dev->driver->owner))
+                goto dev_unlock;
+
+        drvdata = dev_get_drvdata(dev);
+        /* Some subdev didn't probe succesfully id drvdata is NULL */
+        if (drvdata) {
+                switch (plat_entity) {
+                case IDX_FIMC:
+                        ret = register_fimc_entity(fmd, drvdata);
                         break;
+                case IDX_FLITE:
+                        ret = register_fimc_lite_entity(fmd, drvdata);
+                        break;
+                case IDX_CSIS:
+                        ret = register_csis_entity(fmd, pdev, drvdata);
+                        break;
+                default:
+                        ret = -ENODEV;
                 }
         }
-        if (!ret)
-                return 0;
 
-        driver = driver_find(CSIS_DRIVER_NAME, &platform_bus_type);
-        if (!driver || !try_module_get(driver->owner)) {
-                v4l2_warn(&fmd->v4l2_dev,
-                         "%s driver not found, deffering probe\n",
-                         CSIS_DRIVER_NAME);
-                return -EPROBE_DEFER;
+        module_put(dev->driver->owner);
+dev_unlock:
+        device_unlock(dev);
+        if (ret == -EPROBE_DEFER)
+                dev_info(&fmd->pdev->dev, "deferring %s device registration\n",
+                        dev_name(dev));
+        else if (ret < 0)
+                dev_err(&fmd->pdev->dev, "%s device registration failed (%d)\n",
+                        dev_name(dev), ret);
+        return ret;
+}
+
+static int fimc_md_pdev_match(struct device *dev, void *data)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        int plat_entity = -1;
+        int ret;
+        char *p;
+
+        if (!get_device(dev))
+                return -ENODEV;
+
+        if (!strcmp(pdev->name, CSIS_DRIVER_NAME)) {
+                plat_entity = IDX_CSIS;
+        } else if (!strcmp(pdev->name, FIMC_LITE_DRV_NAME)) {
+                plat_entity = IDX_FLITE;
+        } else {
+                p = strstr(pdev->name, "fimc");
+                if (p && *(p + 4) == 0)
+                        plat_entity = IDX_FIMC;
         }
 
-        return driver_for_each_device(driver, NULL, fmd,
-                                      csis_register_callback);
+        if (plat_entity >= 0)
+                ret = fimc_md_register_platform_entity(data, pdev,
+                                                       plat_entity);
+        put_device(dev);
+        return 0;
 }
 
 static void fimc_md_unregister_entities(struct fimc_md *fmd)
@@ -487,7 +472,7 @@ static void fimc_md_unregister_entities(struct fimc_md *fmd)
                 if (fmd->fimc_lite[i] == NULL)
                         continue;
                 v4l2_device_unregister_subdev(&fmd->fimc_lite[i]->subdev);
-                fmd->fimc[i]->pipeline_ops = NULL;
+                fmd->fimc_lite[i]->pipeline_ops = NULL;
                 fmd->fimc_lite[i] = NULL;
         }
         for (i = 0; i < CSIS_MAX_ENTITIES; i++) {
@@ -503,6 +488,7 @@ static void fimc_md_unregister_entities(struct fimc_md *fmd)
                 fimc_md_unregister_sensor(fmd->sensor[i].subdev);
                 fmd->sensor[i].subdev = NULL;
         }
+        v4l2_info(&fmd->v4l2_dev, "Unregistered all entities\n");
 }
 
 /**
@@ -518,7 +504,7 @@ static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
                                             struct v4l2_subdev *sensor,
                                             int pad, int link_mask)
 {
-        struct fimc_sensor_info *s_info;
+        struct fimc_sensor_info *s_info = NULL;
         struct media_entity *sink;
         unsigned int flags = 0;
         int ret, i;
@@ -582,7 +568,7 @@ static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
                 if (ret)
                         break;
 
-                v4l2_info(&fmd->v4l2_dev, "created link [%s] %c> [%s]",
+                v4l2_info(&fmd->v4l2_dev, "created link [%s] %c> [%s]\n",
                           source->name, flags ? '=' : '-', sink->name);
         }
         return 0;
@@ -602,7 +588,7 @@ static int __fimc_md_create_flite_source_links(struct fimc_md *fmd)
                 source = &fimc->subdev.entity;
                 sink = &fimc->vfd.entity;
                 /* FIMC-LITE's subdev and video node */
-                ret = media_entity_create_link(source, FIMC_SD_PAD_SOURCE,
+                ret = media_entity_create_link(source, FLITE_SD_PAD_SOURCE_DMA,
                                                sink, 0, flags);
                 if (ret)
                         break;
@@ -626,9 +612,9 @@ static int __fimc_md_create_flite_source_links(struct fimc_md *fmd)
  */
 static int fimc_md_create_links(struct fimc_md *fmd)
 {
-        struct v4l2_subdev *csi_sensors[2] = { NULL };
+        struct v4l2_subdev *csi_sensors[CSIS_MAX_ENTITIES] = { NULL };
         struct v4l2_subdev *sensor, *csis;
-        struct s5p_fimc_isp_info *pdata;
+        struct fimc_source_info *pdata;
         struct fimc_sensor_info *s_info;
         struct media_entity *source, *sink;
         int i, pad, fimc_id = 0, ret = 0;
@@ -646,8 +632,8 @@ static int fimc_md_create_links(struct fimc_md *fmd)
                 source = NULL;
                 pdata = &s_info->pdata;
 
-                switch (pdata->bus_type) {
-                case FIMC_MIPI_CSI2:
+                switch (pdata->sensor_bus_type) {
+                case FIMC_BUS_TYPE_MIPI_CSI2:
                         if (WARN(pdata->mux_id >= CSIS_MAX_ENTITIES,
                                 "Wrong CSI channel id: %d\n", pdata->mux_id))
                                 return -EINVAL;
@@ -658,28 +644,29 @@ static int fimc_md_create_links(struct fimc_md *fmd)
                                  "but s5p-csis module is not loaded!\n"))
                                 return -EINVAL;
 
-                        ret = media_entity_create_link(&sensor->entity, 0,
+                        pad = sensor->entity.num_pads - 1;
+                        ret = media_entity_create_link(&sensor->entity, pad,
                                               &csis->entity, CSIS_PAD_SINK,
                                               MEDIA_LNK_FL_IMMUTABLE |
                                               MEDIA_LNK_FL_ENABLED);
                         if (ret)
                                 return ret;
 
-                        v4l2_info(&fmd->v4l2_dev, "created link [%s] => [%s]",
+                        v4l2_info(&fmd->v4l2_dev, "created link [%s] => [%s]\n",
                                   sensor->entity.name, csis->entity.name);
 
                         source = NULL;
                         csi_sensors[pdata->mux_id] = sensor;
                         break;
 
-                case FIMC_ITU_601...FIMC_ITU_656:
+                case FIMC_BUS_TYPE_ITU_601...FIMC_BUS_TYPE_ITU_656:
                         source = &sensor->entity;
                         pad = 0;
                         break;
 
                 default:
                         v4l2_err(&fmd->v4l2_dev, "Wrong bus_type: %x\n",
-                                 pdata->bus_type);
+                                 pdata->sensor_bus_type);
                         return -EINVAL;
                 }
                 if (source == NULL)
@@ -690,7 +677,7 @@ static int fimc_md_create_links(struct fimc_md *fmd)
                                                        pad, link_mask);
         }
 
-        for (i = 0; i < ARRAY_SIZE(fmd->csis); i++) {
+        for (i = 0; i < CSIS_MAX_ENTITIES; i++) {
                 if (fmd->csis[i].sd == NULL)
                         continue;
                 source = &fmd->csis[i].sd->entity;
@@ -721,42 +708,61 @@ static int fimc_md_create_links(struct fimc_md *fmd)
 /*
  * The peripheral sensor clock management.
  */
+static void fimc_md_put_clocks(struct fimc_md *fmd)
+{
+        int i = FIMC_MAX_CAMCLKS;
+
+        while (--i >= 0) {
+                if (IS_ERR(fmd->camclk[i].clock))
+                        continue;
+                clk_unprepare(fmd->camclk[i].clock);
+                clk_put(fmd->camclk[i].clock);
+                fmd->camclk[i].clock = ERR_PTR(-EINVAL);
+        }
+}
+
 static int fimc_md_get_clocks(struct fimc_md *fmd)
 {
+        struct device *dev = NULL;
         char clk_name[32];
         struct clk *clock;
-        int i;
+        int ret, i;
+
+        for (i = 0; i < FIMC_MAX_CAMCLKS; i++)
+                fmd->camclk[i].clock = ERR_PTR(-EINVAL);
+
+        if (fmd->pdev->dev.of_node)
+                dev = &fmd->pdev->dev;
 
         for (i = 0; i < FIMC_MAX_CAMCLKS; i++) {
                 snprintf(clk_name, sizeof(clk_name), "sclk_cam%u", i);
-                clock = clk_get(NULL, clk_name);
-                if (IS_ERR_OR_NULL(clock)) {
-                        v4l2_err(&fmd->v4l2_dev, "Failed to get clock: %s",
-                                  clk_name);
-                        return -ENXIO;
+                clock = clk_get(dev, clk_name);
+
+                if (IS_ERR(clock)) {
+                        dev_err(&fmd->pdev->dev, "Failed to get clock: %s\n",
+                                                                clk_name);
+                        ret = PTR_ERR(clock);
+                        break;
+                }
+                ret = clk_prepare(clock);
+                if (ret < 0) {
+                        clk_put(clock);
+                        fmd->camclk[i].clock = ERR_PTR(-EINVAL);
+                        break;
                 }
                 fmd->camclk[i].clock = clock;
         }
-        return 0;
-}
-
-static void fimc_md_put_clocks(struct fimc_md *fmd)
-{
-        int i = FIMC_MAX_CAMCLKS;
+        if (ret)
+                fimc_md_put_clocks(fmd);
 
-        while (--i >= 0) {
-                if (IS_ERR_OR_NULL(fmd->camclk[i].clock))
-                        continue;
-                clk_put(fmd->camclk[i].clock);
-                fmd->camclk[i].clock = NULL;
-        }
+        return ret;
 }
 
 static int __fimc_md_set_camclk(struct fimc_md *fmd,
                                 struct fimc_sensor_info *s_info,
                                 bool on)
 {
-        struct s5p_fimc_isp_info *pdata = &s_info->pdata;
+        struct fimc_source_info *pdata = &s_info->pdata;
         struct fimc_camclk_info *camclk;
         int ret = 0;
 
@@ -820,7 +826,9 @@ static int fimc_md_link_notify(struct media_pad *source,
         struct fimc_dev *fimc = NULL;
         struct fimc_pipeline *pipeline;
         struct v4l2_subdev *sd;
+        struct mutex *lock;
         int ret = 0;
+        int ref_count;
 
         if (media_entity_type(sink->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                 return 0;
@@ -828,28 +836,33 @@ static int fimc_md_link_notify(struct media_pad *source,
         sd = media_entity_to_v4l2_subdev(sink->entity);
 
         switch (sd->grp_id) {
-        case FLITE_GROUP_ID:
+        case GRP_ID_FLITE:
                 fimc_lite = v4l2_get_subdevdata(sd);
+                if (WARN_ON(fimc_lite == NULL))
+                        return 0;
                 pipeline = &fimc_lite->pipeline;
+                lock = &fimc_lite->lock;
                 break;
-        case FIMC_GROUP_ID:
+        case GRP_ID_FIMC:
                 fimc = v4l2_get_subdevdata(sd);
+                if (WARN_ON(fimc == NULL))
+                        return 0;
                 pipeline = &fimc->pipeline;
+                lock = &fimc->lock;
                 break;
         default:
                 return 0;
         }
 
         if (!(flags & MEDIA_LNK_FL_ENABLED)) {
+                int i;
+                mutex_lock(lock);
                 ret = __fimc_pipeline_close(pipeline);
-                pipeline->subdevs[IDX_SENSOR] = NULL;
-                pipeline->subdevs[IDX_CSIS] = NULL;
-
-                if (fimc) {
-                        mutex_lock(&fimc->lock);
+                for (i = 0; i < IDX_MAX; i++)
+                        pipeline->subdevs[i] = NULL;
+                if (fimc)
                         fimc_ctrls_delete(fimc->vid_cap.ctx);
-                        mutex_unlock(&fimc->lock);
-                }
+                mutex_unlock(lock);
                 return ret;
         }
         /*
@@ -857,23 +870,15 @@ static int fimc_md_link_notify(struct media_pad *source,
          * pipeline is already in use, i.e. its video node is opened.
          * Recreate the controls destroyed during the link deactivation.
          */
-        if (fimc) {
-                mutex_lock(&fimc->lock);
-                if (fimc->vid_cap.refcnt > 0) {
-                        ret = __fimc_pipeline_open(pipeline,
-                                                   source->entity, true);
-                if (!ret)
-                        ret = fimc_capture_ctrls_create(fimc);
-                }
-                mutex_unlock(&fimc->lock);
-        } else {
-                mutex_lock(&fimc_lite->lock);
-                if (fimc_lite->ref_count > 0) {
-                        ret = __fimc_pipeline_open(pipeline,
-                                                   source->entity, true);
-                }
-                mutex_unlock(&fimc_lite->lock);
-        }
+        mutex_lock(lock);
+
+        ref_count = fimc ? fimc->vid_cap.refcnt : fimc_lite->ref_count;
+        if (ref_count > 0)
+                ret = __fimc_pipeline_open(pipeline, source->entity, true);
+        if (!ret && fimc)
+                ret = fimc_capture_ctrls_create(fimc);
+
+        mutex_unlock(lock);
         return ret ? -EPIPE : ret;
 }
 
@@ -965,7 +970,8 @@ static int fimc_md_probe(struct platform_device *pdev)
         /* Protect the media graph while we're registering entities */
         mutex_lock(&fmd->media_dev.graph_mutex);
 
-        ret = fimc_md_register_platform_entities(fmd);
+        ret = bus_for_each_dev(&platform_bus_type, NULL, fmd,
+                                        fimc_md_pdev_match);
         if (ret)
                 goto err_unlock;
 
diff --git a/drivers/media/platform/s5p-fimc/fimc-mdevice.h b/drivers/media/platform/s5p-fimc/fimc-mdevice.h
index 2d8d41d82620..06b0d8276fd2 100644
--- a/drivers/media/platform/s5p-fimc/fimc-mdevice.h
+++ b/drivers/media/platform/s5p-fimc/fimc-mdevice.h
@@ -22,11 +22,13 @@
 #include "mipi-csis.h"
 
 /* Group IDs of sensor, MIPI-CSIS, FIMC-LITE and the writeback subdevs. */
-#define SENSOR_GROUP_ID         (1 << 8)
-#define CSIS_GROUP_ID           (1 << 9)
-#define WRITEBACK_GROUP_ID      (1 << 10)
-#define FIMC_GROUP_ID           (1 << 11)
-#define FLITE_GROUP_ID          (1 << 12)
+#define GRP_ID_SENSOR           (1 << 8)
+#define GRP_ID_FIMC_IS_SENSOR   (1 << 9)
+#define GRP_ID_WRITEBACK        (1 << 10)
+#define GRP_ID_CSIS             (1 << 11)
+#define GRP_ID_FIMC             (1 << 12)
+#define GRP_ID_FLITE            (1 << 13)
+#define GRP_ID_FIMC_IS          (1 << 14)
 
 #define FIMC_MAX_SENSORS        8
 #define FIMC_MAX_CAMCLKS        2
@@ -51,7 +53,7 @@ struct fimc_camclk_info {
  * This data structure applies to image sensor and the writeback subdevs.
  */
 struct fimc_sensor_info {
-        struct s5p_fimc_isp_info pdata;
+        struct fimc_source_info pdata;
         struct v4l2_subdev *subdev;
         struct fimc_dev *host;
 };
diff --git a/drivers/media/platform/s5p-fimc/fimc-reg.c b/drivers/media/platform/s5p-fimc/fimc-reg.c
index 2c9d0c06c9e8..50b97c75b956 100644
--- a/drivers/media/platform/s5p-fimc/fimc-reg.c
+++ b/drivers/media/platform/s5p-fimc/fimc-reg.c
@@ -44,9 +44,9 @@ static u32 fimc_hw_get_in_flip(struct fimc_ctx *ctx)
         u32 flip = FIMC_REG_MSCTRL_FLIP_NORMAL;
 
         if (ctx->hflip)
-                flip = FIMC_REG_MSCTRL_FLIP_X_MIRROR;
-        if (ctx->vflip)
                 flip = FIMC_REG_MSCTRL_FLIP_Y_MIRROR;
+        if (ctx->vflip)
+                flip = FIMC_REG_MSCTRL_FLIP_X_MIRROR;
 
         if (ctx->rotation <= 90)
                 return flip;
@@ -59,9 +59,9 @@ static u32 fimc_hw_get_target_flip(struct fimc_ctx *ctx)
         u32 flip = FIMC_REG_CITRGFMT_FLIP_NORMAL;
 
         if (ctx->hflip)
-                flip |= FIMC_REG_CITRGFMT_FLIP_X_MIRROR;
-        if (ctx->vflip)
                 flip |= FIMC_REG_CITRGFMT_FLIP_Y_MIRROR;
+        if (ctx->vflip)
+                flip |= FIMC_REG_CITRGFMT_FLIP_X_MIRROR;
 
         if (ctx->rotation <= 90)
                 return flip;
@@ -312,7 +312,7 @@ static void fimc_hw_set_scaler(struct fimc_ctx *ctx)
 void fimc_hw_set_mainscaler(struct fimc_ctx *ctx)
 {
         struct fimc_dev *dev = ctx->fimc_dev;
-        struct fimc_variant *variant = dev->variant;
+        const struct fimc_variant *variant = dev->variant;
         struct fimc_scaler *sc = &ctx->scaler;
         u32 cfg;
 
@@ -344,30 +344,31 @@ void fimc_hw_set_mainscaler(struct fimc_ctx *ctx)
         }
 }
 
-void fimc_hw_en_capture(struct fimc_ctx *ctx)
+void fimc_hw_enable_capture(struct fimc_ctx *ctx)
 {
         struct fimc_dev *dev = ctx->fimc_dev;
+        u32 cfg;
 
-        u32 cfg = readl(dev->regs + FIMC_REG_CIIMGCPT);
-
-        if (ctx->out_path == FIMC_IO_DMA) {
-                /* one shot mode */
-                cfg |= FIMC_REG_CIIMGCPT_CPT_FREN_ENABLE |
-                        FIMC_REG_CIIMGCPT_IMGCPTEN;
-        } else {
-                /* Continuous frame capture mode (freerun). */
-                cfg &= ~(FIMC_REG_CIIMGCPT_CPT_FREN_ENABLE |
-                         FIMC_REG_CIIMGCPT_CPT_FRMOD_CNT);
-                cfg |= FIMC_REG_CIIMGCPT_IMGCPTEN;
-        }
+        cfg = readl(dev->regs + FIMC_REG_CIIMGCPT);
+        cfg |= FIMC_REG_CIIMGCPT_CPT_FREN_ENABLE;
 
         if (ctx->scaler.enabled)
                 cfg |= FIMC_REG_CIIMGCPT_IMGCPTEN_SC;
+        else
+                cfg &= FIMC_REG_CIIMGCPT_IMGCPTEN_SC;
 
         cfg |= FIMC_REG_CIIMGCPT_IMGCPTEN;
         writel(cfg, dev->regs + FIMC_REG_CIIMGCPT);
 }
 
+void fimc_hw_disable_capture(struct fimc_dev *dev)
+{
+        u32 cfg = readl(dev->regs + FIMC_REG_CIIMGCPT);
+        cfg &= ~(FIMC_REG_CIIMGCPT_IMGCPTEN |
+                 FIMC_REG_CIIMGCPT_IMGCPTEN_SC);
+        writel(cfg, dev->regs + FIMC_REG_CIIMGCPT);
+}
+
 void fimc_hw_set_effect(struct fimc_ctx *ctx)
 {
         struct fimc_dev *dev = ctx->fimc_dev;
@@ -553,7 +554,7 @@ void fimc_hw_set_output_addr(struct fimc_dev *dev,
 }
 
 int fimc_hw_set_camera_polarity(struct fimc_dev *fimc,
-                                struct s5p_fimc_isp_info *cam)
+                                struct fimc_source_info *cam)
 {
         u32 cfg = readl(fimc->regs + FIMC_REG_CIGCTRL);
 
@@ -595,14 +596,15 @@ static const struct mbus_pixfmt_desc pix_desc[] = {
 };
 
 int fimc_hw_set_camera_source(struct fimc_dev *fimc,
-                              struct s5p_fimc_isp_info *cam)
+                              struct fimc_source_info *source)
 {
         struct fimc_frame *f = &fimc->vid_cap.ctx->s_frame;
-        u32 cfg = 0;
-        u32 bus_width;
+        u32 bus_width, cfg = 0;
         int i;
 
-        if (cam->bus_type == FIMC_ITU_601 || cam->bus_type == FIMC_ITU_656) {
+        switch (source->fimc_bus_type) {
+        case FIMC_BUS_TYPE_ITU_601:
+        case FIMC_BUS_TYPE_ITU_656:
                 for (i = 0; i < ARRAY_SIZE(pix_desc); i++) {
                         if (fimc->vid_cap.mf.code == pix_desc[i].pixelcode) {
                                 cfg = pix_desc[i].cisrcfmt;
@@ -618,15 +620,17 @@ int fimc_hw_set_camera_source(struct fimc_dev *fimc,
                         return -EINVAL;
                 }
 
-                if (cam->bus_type == FIMC_ITU_601) {
+                if (source->fimc_bus_type == FIMC_BUS_TYPE_ITU_601) {
                         if (bus_width == 8)
                                 cfg |= FIMC_REG_CISRCFMT_ITU601_8BIT;
                         else if (bus_width == 16)
                                 cfg |= FIMC_REG_CISRCFMT_ITU601_16BIT;
                 } /* else defaults to ITU-R BT.656 8-bit */
-        } else if (cam->bus_type == FIMC_MIPI_CSI2) {
+                break;
+        case FIMC_BUS_TYPE_MIPI_CSI2:
                 if (fimc_fmt_is_user_defined(f->fmt->color))
                         cfg |= FIMC_REG_CISRCFMT_ITU601_8BIT;
+                break;
         }
 
         cfg |= (f->o_width << 16) | f->o_height;
@@ -654,7 +658,7 @@ void fimc_hw_set_camera_offset(struct fimc_dev *fimc, struct fimc_frame *f)
 }
 
 int fimc_hw_set_camera_type(struct fimc_dev *fimc,
-                            struct s5p_fimc_isp_info *cam)
+                            struct fimc_source_info *source)
 {
         u32 cfg, tmp;
         struct fimc_vid_cap *vid_cap = &fimc->vid_cap;
@@ -667,11 +671,11 @@ int fimc_hw_set_camera_type(struct fimc_dev *fimc,
                 FIMC_REG_CIGCTRL_SELCAM_MIPI | FIMC_REG_CIGCTRL_CAMIF_SELWB |
                 FIMC_REG_CIGCTRL_SELCAM_MIPI_A | FIMC_REG_CIGCTRL_CAM_JPEG);
 
-        switch (cam->bus_type) {
-        case FIMC_MIPI_CSI2:
+        switch (source->fimc_bus_type) {
+        case FIMC_BUS_TYPE_MIPI_CSI2:
                 cfg |= FIMC_REG_CIGCTRL_SELCAM_MIPI;
 
-                if (cam->mux_id == 0)
+                if (source->mux_id == 0)
                         cfg |= FIMC_REG_CIGCTRL_SELCAM_MIPI_A;
 
                 /* TODO: add remaining supported formats. */
@@ -694,15 +698,16 @@ int fimc_hw_set_camera_type(struct fimc_dev *fimc,
 
                 writel(tmp, fimc->regs + FIMC_REG_CSIIMGFMT);
                 break;
-        case FIMC_ITU_601...FIMC_ITU_656:
-                if (cam->mux_id == 0) /* ITU-A, ITU-B: 0, 1 */
+        case FIMC_BUS_TYPE_ITU_601...FIMC_BUS_TYPE_ITU_656:
+                if (source->mux_id == 0) /* ITU-A, ITU-B: 0, 1 */
                         cfg |= FIMC_REG_CIGCTRL_SELCAM_ITU_A;
                 break;
-        case FIMC_LCD_WB:
+        case FIMC_BUS_TYPE_LCD_WRITEBACK_A:
                 cfg |= FIMC_REG_CIGCTRL_CAMIF_SELWB;
                 break;
         default:
-                v4l2_err(&vid_cap->vfd, "Invalid camera bus type selected\n");
+                v4l2_err(&vid_cap->vfd, "Invalid FIMC bus type selected: %d\n",
+                         source->fimc_bus_type);
                 return -EINVAL;
         }
         writel(cfg, fimc->regs + FIMC_REG_CIGCTRL);
@@ -737,13 +742,6 @@ void fimc_hw_activate_input_dma(struct fimc_dev *dev, bool on)
         writel(cfg, dev->regs + FIMC_REG_MSCTRL);
 }
 
-void fimc_hw_dis_capture(struct fimc_dev *dev)
-{
-        u32 cfg = readl(dev->regs + FIMC_REG_CIIMGCPT);
-        cfg &= ~(FIMC_REG_CIIMGCPT_IMGCPTEN | FIMC_REG_CIIMGCPT_IMGCPTEN_SC);
-        writel(cfg, dev->regs + FIMC_REG_CIIMGCPT);
-}
-
 /* Return an index to the buffer actually being written. */
 s32 fimc_hw_get_frame_index(struct fimc_dev *dev)
 {
@@ -776,13 +774,13 @@ s32 fimc_hw_get_prev_frame_index(struct fimc_dev *dev)
 void fimc_activate_capture(struct fimc_ctx *ctx)
 {
         fimc_hw_enable_scaler(ctx->fimc_dev, ctx->scaler.enabled);
-        fimc_hw_en_capture(ctx);
+        fimc_hw_enable_capture(ctx);
 }
 
 void fimc_deactivate_capture(struct fimc_dev *fimc)
 {
         fimc_hw_en_lastirq(fimc, true);
-        fimc_hw_dis_capture(fimc);
+        fimc_hw_disable_capture(fimc);
         fimc_hw_enable_scaler(fimc, false);
         fimc_hw_en_lastirq(fimc, false);
 }
diff --git a/drivers/media/platform/s5p-fimc/fimc-reg.h b/drivers/media/platform/s5p-fimc/fimc-reg.h
index b6abfc7b72ac..1a40df6d1a80 100644
--- a/drivers/media/platform/s5p-fimc/fimc-reg.h
+++ b/drivers/media/platform/s5p-fimc/fimc-reg.h
@@ -287,7 +287,7 @@ void fimc_hw_en_lastirq(struct fimc_dev *fimc, int enable);
 void fimc_hw_en_irq(struct fimc_dev *fimc, int enable);
 void fimc_hw_set_prescaler(struct fimc_ctx *ctx);
 void fimc_hw_set_mainscaler(struct fimc_ctx *ctx);
-void fimc_hw_en_capture(struct fimc_ctx *ctx);
+void fimc_hw_enable_capture(struct fimc_ctx *ctx);
 void fimc_hw_set_effect(struct fimc_ctx *ctx);
 void fimc_hw_set_rgb_alpha(struct fimc_ctx *ctx);
 void fimc_hw_set_in_dma(struct fimc_ctx *ctx);
@@ -297,16 +297,16 @@ void fimc_hw_set_input_addr(struct fimc_dev *fimc, struct fimc_addr *paddr);
 void fimc_hw_set_output_addr(struct fimc_dev *fimc, struct fimc_addr *paddr,
                              int index);
 int fimc_hw_set_camera_source(struct fimc_dev *fimc,
-                              struct s5p_fimc_isp_info *cam);
+                              struct fimc_source_info *cam);
 void fimc_hw_set_camera_offset(struct fimc_dev *fimc, struct fimc_frame *f);
 int fimc_hw_set_camera_polarity(struct fimc_dev *fimc,
-                                struct s5p_fimc_isp_info *cam);
+                                struct fimc_source_info *cam);
 int fimc_hw_set_camera_type(struct fimc_dev *fimc,
-                            struct s5p_fimc_isp_info *cam);
+                            struct fimc_source_info *cam);
 void fimc_hw_clear_irq(struct fimc_dev *dev);
 void fimc_hw_enable_scaler(struct fimc_dev *dev, bool on);
 void fimc_hw_activate_input_dma(struct fimc_dev *dev, bool on);
-void fimc_hw_dis_capture(struct fimc_dev *dev);
+void fimc_hw_disable_capture(struct fimc_dev *dev);
 s32 fimc_hw_get_frame_index(struct fimc_dev *dev);
 s32 fimc_hw_get_prev_frame_index(struct fimc_dev *dev);
 void fimc_activate_capture(struct fimc_ctx *ctx);
diff --git a/drivers/media/platform/s5p-fimc/mipi-csis.c b/drivers/media/platform/s5p-fimc/mipi-csis.c
index 7abae012f55e..981863d05aaa 100644
--- a/drivers/media/platform/s5p-fimc/mipi-csis.c
+++ b/drivers/media/platform/s5p-fimc/mipi-csis.c
@@ -187,7 +187,7 @@ struct csis_state {
         const struct csis_pix_format *csis_fmt;
         struct v4l2_mbus_framefmt format;
 
-        struct spinlock slock;
+        spinlock_t slock;
         struct csis_pktbuf pkt_buf;
         struct s5pcsis_event events[S5PCSIS_NUM_EVENTS];
 };
@@ -220,6 +220,18 @@ static const struct csis_pix_format s5pcsis_formats[] = {
                 .code = V4L2_MBUS_FMT_S5C_UYVY_JPEG_1X8,
                 .fmt_reg = S5PCSIS_CFG_FMT_USER(1),
                 .data_alignment = 32,
+        }, {
+                .code = V4L2_MBUS_FMT_SGRBG8_1X8,
+                .fmt_reg = S5PCSIS_CFG_FMT_RAW8,
+                .data_alignment = 24,
+        }, {
+                .code = V4L2_MBUS_FMT_SGRBG10_1X10,
+                .fmt_reg = S5PCSIS_CFG_FMT_RAW10,
+                .data_alignment = 24,
+        }, {
+                .code = V4L2_MBUS_FMT_SGRBG12_1X12,
+                .fmt_reg = S5PCSIS_CFG_FMT_RAW12,
+                .data_alignment = 24,
         }
 };
 
@@ -261,7 +273,8 @@ static void s5pcsis_reset(struct csis_state *state)
 
 static void s5pcsis_system_enable(struct csis_state *state, int on)
 {
-        u32 val;
+        struct s5p_platform_mipi_csis *pdata = state->pdev->dev.platform_data;
+        u32 val, mask;
 
         val = s5pcsis_read(state, S5PCSIS_CTRL);
         if (on)
@@ -271,10 +284,11 @@ static void s5pcsis_system_enable(struct csis_state *state, int on)
         s5pcsis_write(state, S5PCSIS_CTRL, val);
 
         val = s5pcsis_read(state, S5PCSIS_DPHYCTRL);
-        if (on)
-                val |= S5PCSIS_DPHYCTRL_ENABLE;
-        else
-                val &= ~S5PCSIS_DPHYCTRL_ENABLE;
+        val &= ~S5PCSIS_DPHYCTRL_ENABLE;
+        if (on) {
+                mask = (1 << (pdata->lanes + 1)) - 1;
+                val |= (mask & S5PCSIS_DPHYCTRL_ENABLE);
+        }
         s5pcsis_write(state, S5PCSIS_DPHYCTRL, val);
 }
 
@@ -338,11 +352,11 @@ static void s5pcsis_clk_put(struct csis_state *state)
         int i;
 
         for (i = 0; i < NUM_CSIS_CLOCKS; i++) {
-                if (IS_ERR_OR_NULL(state->clock[i]))
+                if (IS_ERR(state->clock[i]))
                         continue;
                 clk_unprepare(state->clock[i]);
                 clk_put(state->clock[i]);
-                state->clock[i] = NULL;
+                state->clock[i] = ERR_PTR(-EINVAL);
         }
 }
 
@@ -351,14 +365,19 @@ static int s5pcsis_clk_get(struct csis_state *state)
         struct device *dev = &state->pdev->dev;
         int i, ret;
 
+        for (i = 0; i < NUM_CSIS_CLOCKS; i++)
+                state->clock[i] = ERR_PTR(-EINVAL);
+
         for (i = 0; i < NUM_CSIS_CLOCKS; i++) {
                 state->clock[i] = clk_get(dev, csi_clock_name[i]);
-                if (IS_ERR(state->clock[i]))
+                if (IS_ERR(state->clock[i])) {
+                        ret = PTR_ERR(state->clock[i]);
                         goto err;
+                }
                 ret = clk_prepare(state->clock[i]);
                 if (ret < 0) {
                         clk_put(state->clock[i]);
-                        state->clock[i] = NULL;
+                        state->clock[i] = ERR_PTR(-EINVAL);
                         goto err;
                 }
         }
@@ -366,7 +385,31 @@ static int s5pcsis_clk_get(struct csis_state *state)
 err:
         s5pcsis_clk_put(state);
         dev_err(dev, "failed to get clock: %s\n", csi_clock_name[i]);
-        return -ENXIO;
+        return ret;
+}
+
+static void dump_regs(struct csis_state *state, const char *label)
+{
+        struct {
+                u32 offset;
+                const char * const name;
+        } registers[] = {
+                { 0x00, "CTRL" },
+                { 0x04, "DPHYCTRL" },
+                { 0x08, "CONFIG" },
+                { 0x0c, "DPHYSTS" },
+                { 0x10, "INTMSK" },
+                { 0x2c, "RESOL" },
+                { 0x38, "SDW_CONFIG" },
+        };
+        u32 i;
+
+        v4l2_info(&state->sd, "--- %s ---\n", label);
+
+        for (i = 0; i < ARRAY_SIZE(registers); i++) {
+                u32 cfg = s5pcsis_read(state, registers[i].offset);
+                v4l2_info(&state->sd, "%10s: 0x%08x\n", registers[i].name, cfg);
+        }
 }
 
 static void s5pcsis_start_stream(struct csis_state *state)
@@ -401,12 +444,12 @@ static void s5pcsis_log_counters(struct csis_state *state, bool non_errors)
 
         spin_lock_irqsave(&state->slock, flags);
 
-        for (i--; i >= 0; i--)
-                if (state->events[i].counter >= 0)
+        for (i--; i >= 0; i--) {
+                if (state->events[i].counter > 0 || debug)
                         v4l2_info(&state->sd, "%s events: %d\n",
                                   state->events[i].name,
                                   state->events[i].counter);
-
+        }
         spin_unlock_irqrestore(&state->slock, flags);
 }
 
@@ -569,7 +612,11 @@ static int s5pcsis_log_status(struct v4l2_subdev *sd)
 {
         struct csis_state *state = sd_to_csis_state(sd);
 
+        mutex_lock(&state->lock);
         s5pcsis_log_counters(state, true);
+        if (debug && (state->flags & ST_POWERED))
+                dump_regs(state, __func__);
+        mutex_unlock(&state->lock);
         return 0;
 }
 
@@ -699,26 +746,32 @@ static int s5pcsis_probe(struct platform_device *pdev)
         for (i = 0; i < CSIS_NUM_SUPPLIES; i++)
                 state->supplies[i].supply = csis_supply_name[i];
 
-        ret = regulator_bulk_get(&pdev->dev, CSIS_NUM_SUPPLIES,
+        ret = devm_regulator_bulk_get(&pdev->dev, CSIS_NUM_SUPPLIES,
                                  state->supplies);
         if (ret)
                 return ret;
 
         ret = s5pcsis_clk_get(state);
-        if (ret)
-                goto e_clkput;
+        if (ret < 0)
+                return ret;
 
-        clk_enable(state->clock[CSIS_CLK_MUX]);
         if (pdata->clk_rate)
-                clk_set_rate(state->clock[CSIS_CLK_MUX], pdata->clk_rate);
+                ret = clk_set_rate(state->clock[CSIS_CLK_MUX],
+                                   pdata->clk_rate);
         else
                 dev_WARN(&pdev->dev, "No clock frequency specified!\n");
+        if (ret < 0)
+                goto e_clkput;
+
+        ret = clk_enable(state->clock[CSIS_CLK_MUX]);
+        if (ret < 0)
+                goto e_clkput;
 
         ret = devm_request_irq(&pdev->dev, state->irq, s5pcsis_irq_handler,
                                0, dev_name(&pdev->dev), state);
         if (ret) {
                 dev_err(&pdev->dev, "Interrupt request failed\n");
-                goto e_regput;
+                goto e_clkdis;
         }
 
         v4l2_subdev_init(&state->sd, &s5pcsis_subdev_ops);
@@ -736,7 +789,7 @@ static int s5pcsis_probe(struct platform_device *pdev)
         ret = media_entity_init(&state->sd.entity,
                                 CSIS_PADS_NUM, state->pads, 0);
         if (ret < 0)
-                goto e_clkput;
+                goto e_clkdis;
 
         /* This allows to retrieve the platform device id by the host driver */
         v4l2_set_subdevdata(&state->sd, pdev);
@@ -749,10 +802,9 @@ static int s5pcsis_probe(struct platform_device *pdev)
         pm_runtime_enable(&pdev->dev);
         return 0;
 
-e_regput:
-        regulator_bulk_free(CSIS_NUM_SUPPLIES, state->supplies);
-e_clkput:
+e_clkdis:
         clk_disable(state->clock[CSIS_CLK_MUX]);
+e_clkput:
         s5pcsis_clk_put(state);
         return ret;
 }
@@ -859,7 +911,6 @@ static int s5pcsis_remove(struct platform_device *pdev)
         clk_disable(state->clock[CSIS_CLK_MUX]);
         pm_runtime_set_suspended(&pdev->dev);
         s5pcsis_clk_put(state);
-        regulator_bulk_free(CSIS_NUM_SUPPLIES, state->supplies);
 
         media_entity_cleanup(&state->sd.entity);
 
diff --git a/drivers/media/platform/s5p-g2d/g2d-hw.c b/drivers/media/platform/s5p-g2d/g2d-hw.c
index 5b86cbe408e2..e87bd93811d4 100644
--- a/drivers/media/platform/s5p-g2d/g2d-hw.c
+++ b/drivers/media/platform/s5p-g2d/g2d-hw.c
@@ -28,6 +28,7 @@ void g2d_set_src_size(struct g2d_dev *d, struct g2d_frame *f)
 {
         u32 n;
 
+        w(0, SRC_SELECT_REG);
         w(f->stride & 0xFFFF, SRC_STRIDE_REG);
 
         n = f->o_height & 0xFFF;
@@ -52,6 +53,7 @@ void g2d_set_dst_size(struct g2d_dev *d, struct g2d_frame *f)
 {
         u32 n;
 
+        w(0, DST_SELECT_REG);
         w(f->stride & 0xFFFF, DST_STRIDE_REG);
 
         n = f->o_height & 0xFFF;
@@ -82,10 +84,14 @@ void g2d_set_flip(struct g2d_dev *d, u32 r)
         w(r, SRC_MSK_DIRECT_REG);
 }
 
-u32 g2d_cmd_stretch(u32 e)
+void g2d_set_v41_stretch(struct g2d_dev *d, struct g2d_frame *src,
+                                        struct g2d_frame *dst)
 {
-        e &= 1;
-        return e << 4;
+        w(DEFAULT_SCALE_MODE, SRC_SCALE_CTRL_REG);
+
+        /* inversed scaling factor: src is numerator */
+        w((src->c_width << 16) / dst->c_width, SRC_XSCALE_REG);
+        w((src->c_height << 16) / dst->c_height, SRC_YSCALE_REG);
 }
 
 void g2d_set_cmd(struct g2d_dev *d, u32 c)
@@ -96,7 +102,9 @@ void g2d_set_cmd(struct g2d_dev *d, u32 c)
 void g2d_start(struct g2d_dev *d)
 {
         /* Clear cache */
-        w(0x7, CACHECTL_REG);
+        if (d->variant->hw_rev == TYPE_G2D_3X)
+                w(0x7, CACHECTL_REG);
+
         /* Enable interrupt */
         w(1, INTEN_REG);
         /* Start G2D engine */
diff --git a/drivers/media/platform/s5p-g2d/g2d-regs.h b/drivers/media/platform/s5p-g2d/g2d-regs.h
index 02e1cf50da4e..9bf31ad35d47 100644
--- a/drivers/media/platform/s5p-g2d/g2d-regs.h
+++ b/drivers/media/platform/s5p-g2d/g2d-regs.h
@@ -35,6 +35,9 @@
 #define SRC_COLOR_MODE_REG      0x030C  /* Src Image Color Mode reg */
 #define SRC_LEFT_TOP_REG        0x0310  /* Src Left Top Coordinate reg */
 #define SRC_RIGHT_BOTTOM_REG    0x0314  /* Src Right Bottom Coordinate reg */
+#define SRC_SCALE_CTRL_REG      0x0328  /* Src Scaling type select */
+#define SRC_XSCALE_REG          0x032c  /* Src X Scaling ratio */
+#define SRC_YSCALE_REG          0x0330  /* Src Y Scaling ratio */
 
 /* Parameter Setting Registers (Dest) */
 #define DST_SELECT_REG          0x0400  /* Dest Image Selection reg */
@@ -113,3 +116,7 @@
 #define DEFAULT_WIDTH           100
 #define DEFAULT_HEIGHT          100
 
+#define DEFAULT_SCALE_MODE      (2 << 0)
+
+/* Command mode register values */
+#define CMD_V3_ENABLE_STRETCH   (1 << 4)
diff --git a/drivers/media/platform/s5p-g2d/g2d.c b/drivers/media/platform/s5p-g2d/g2d.c
index 6ed259fb1046..aaaf276a5a6c 100644
--- a/drivers/media/platform/s5p-g2d/g2d.c
+++ b/drivers/media/platform/s5p-g2d/g2d.c
@@ -604,8 +604,13 @@ static void device_run(void *prv)
         g2d_set_flip(dev, ctx->flip);
 
         if (ctx->in.c_width != ctx->out.c_width ||
-                ctx->in.c_height != ctx->out.c_height)
-                cmd |= g2d_cmd_stretch(1);
+                ctx->in.c_height != ctx->out.c_height) {
+                if (dev->variant->hw_rev == TYPE_G2D_3X)
+                        cmd |= CMD_V3_ENABLE_STRETCH;
+                else
+                        g2d_set_v41_stretch(dev, &ctx->in, &ctx->out);
+        }
+
         g2d_set_cmd(dev, cmd);
         g2d_start(dev);
 
@@ -713,7 +718,7 @@ static int g2d_probe(struct platform_device *pdev)
                 return PTR_ERR(dev->regs);
 
         dev->clk = clk_get(&pdev->dev, "sclk_fimg2d");
-        if (IS_ERR_OR_NULL(dev->clk)) {
+        if (IS_ERR(dev->clk)) {
                 dev_err(&pdev->dev, "failed to get g2d clock\n");
                 return -ENXIO;
         }
@@ -725,7 +730,7 @@ static int g2d_probe(struct platform_device *pdev)
         }
 
         dev->gate = clk_get(&pdev->dev, "fimg2d");
-        if (IS_ERR_OR_NULL(dev->gate)) {
+        if (IS_ERR(dev->gate)) {
                 dev_err(&pdev->dev, "failed to get g2d clock gate\n");
                 ret = -ENXIO;
                 goto unprep_clk;
@@ -789,6 +794,7 @@ static int g2d_probe(struct platform_device *pdev)
         }
 
         def_frame.stride = (def_frame.width * def_frame.fmt->depth) >> 3;
+        dev->variant = g2d_get_drv_data(pdev);
 
         return 0;
 
@@ -828,9 +834,30 @@ static int g2d_remove(struct platform_device *pdev)
         return 0;
 }
 
+static struct g2d_variant g2d_drvdata_v3x = {
+        .hw_rev = TYPE_G2D_3X,
+};
+
+static struct g2d_variant g2d_drvdata_v4x = {
+        .hw_rev = TYPE_G2D_4X, /* Revision 4.1 for Exynos4X12 and Exynos5 */
+};
+
+static struct platform_device_id g2d_driver_ids[] = {
+        {
+                .name = "s5p-g2d",
+                .driver_data = (unsigned long)&g2d_drvdata_v3x,
+        }, {
+                .name = "s5p-g2d-v4x",
+                .driver_data = (unsigned long)&g2d_drvdata_v4x,
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(platform, g2d_driver_ids);
+
 static struct platform_driver g2d_pdrv = {
         .probe          = g2d_probe,
         .remove         = g2d_remove,
+        .id_table       = g2d_driver_ids,
         .driver         = {
                 .name = G2D_NAME,
                 .owner = THIS_MODULE,
diff --git a/drivers/media/platform/s5p-g2d/g2d.h b/drivers/media/platform/s5p-g2d/g2d.h
index 6b765b0216c5..300ca05ba404 100644
--- a/drivers/media/platform/s5p-g2d/g2d.h
+++ b/drivers/media/platform/s5p-g2d/g2d.h
@@ -10,10 +10,13 @@
  * License, or (at your option) any later version
  */
 
+#include <linux/platform_device.h>
 #include <media/v4l2-device.h>
 #include <media/v4l2-ctrls.h>
 
 #define G2D_NAME "s5p-g2d"
+#define TYPE_G2D_3X 3
+#define TYPE_G2D_4X 4
 
 struct g2d_dev {
         struct v4l2_device      v4l2_dev;
@@ -27,6 +30,7 @@ struct g2d_dev {
         struct clk              *clk;
         struct clk              *gate;
         struct g2d_ctx          *curr;
+        struct g2d_variant      *variant;
         int irq;
         wait_queue_head_t       irq_queue;
 };
@@ -53,7 +57,7 @@ struct g2d_frame {
 struct g2d_ctx {
         struct v4l2_fh fh;
         struct g2d_dev          *dev;
-        struct v4l2_m2m_ctx     *m2m_ctx;
+        struct v4l2_m2m_ctx     *m2m_ctx;
         struct g2d_frame        in;
         struct g2d_frame        out;
         struct v4l2_ctrl        *ctrl_hflip;
@@ -70,6 +74,9 @@ struct g2d_fmt {
         u32     hw;
 };
 
+struct g2d_variant {
+        unsigned short hw_rev;
+};
 
 void g2d_reset(struct g2d_dev *d);
 void g2d_set_src_size(struct g2d_dev *d, struct g2d_frame *f);
@@ -80,7 +87,11 @@ void g2d_start(struct g2d_dev *d);
 void g2d_clear_int(struct g2d_dev *d);
 void g2d_set_rop4(struct g2d_dev *d, u32 r);
 void g2d_set_flip(struct g2d_dev *d, u32 r);
-u32 g2d_cmd_stretch(u32 e);
+void g2d_set_v41_stretch(struct g2d_dev *d,
+                        struct g2d_frame *src, struct g2d_frame *dst);
 void g2d_set_cmd(struct g2d_dev *d, u32 c);
 
-
+static inline struct g2d_variant *g2d_get_drv_data(struct platform_device *pdev)
+{
+        return (struct g2d_variant *)platform_get_device_id(pdev)->driver_data;
+}
diff --git a/drivers/media/platform/s5p-jpeg/jpeg-core.h b/drivers/media/platform/s5p-jpeg/jpeg-core.h
index 022b9b9baff9..8a4013e3aee7 100644
--- a/drivers/media/platform/s5p-jpeg/jpeg-core.h
+++ b/drivers/media/platform/s5p-jpeg/jpeg-core.h
@@ -62,7 +62,7 @@
  */
 struct s5p_jpeg {
         struct mutex            lock;
-        struct spinlock         slock;
+        spinlock_t              slock;
 
         struct v4l2_device      v4l2_dev;
         struct video_device     *vfd_encoder;
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc.c b/drivers/media/platform/s5p-mfc/s5p_mfc.c
index 8b7fbc7cc04d..e84703c314ce 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc.c
@@ -21,6 +21,7 @@
 #include <linux/videodev2.h>
 #include <media/v4l2-event.h>
 #include <linux/workqueue.h>
+#include <linux/of.h>
 #include <media/videobuf2-core.h>
 #include "s5p_mfc_common.h"
 #include "s5p_mfc_ctrl.h"
@@ -273,7 +274,6 @@ static void s5p_mfc_handle_frame_new(struct s5p_mfc_ctx *ctx, unsigned int err)
         struct s5p_mfc_buf  *dst_buf;
         size_t dspl_y_addr;
         unsigned int frame_type;
-        unsigned int index;
 
         dspl_y_addr = s5p_mfc_hw_call(dev->mfc_ops, get_dspl_y_adr, dev);
         frame_type = s5p_mfc_hw_call(dev->mfc_ops, get_dec_frame_type, dev);
@@ -310,7 +310,6 @@ static void s5p_mfc_handle_frame_new(struct s5p_mfc_ctx *ctx, unsigned int err)
                         vb2_buffer_done(dst_buf->b,
                                 err ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
 
-                        index = dst_buf->b->v4l2_buf.index;
                         break;
                 }
         }
@@ -326,8 +325,6 @@ static void s5p_mfc_handle_frame(struct s5p_mfc_ctx *ctx,
         unsigned long flags;
         unsigned int res_change;
 
-        unsigned int index;
-
         dst_frame_status = s5p_mfc_hw_call(dev->mfc_ops, get_dspl_status, dev)
                                 & S5P_FIMV_DEC_STATUS_DECODING_STATUS_MASK;
         res_change = (s5p_mfc_hw_call(dev->mfc_ops, get_dspl_status, dev)
@@ -387,7 +384,6 @@ static void s5p_mfc_handle_frame(struct s5p_mfc_ctx *ctx,
                         mfc_debug(2, "Running again the same buffer\n");
                         ctx->after_packed_pb = 1;
                 } else {
-                        index = src_buf->b->v4l2_buf.index;
                         mfc_debug(2, "MFC needs next buffer\n");
                         ctx->consumed_stream = 0;
                         list_del(&src_buf->list);
@@ -586,8 +582,7 @@ static void s5p_mfc_handle_stream_complete(struct s5p_mfc_ctx *ctx,
 
         clear_work_bit(ctx);
 
-        if (test_and_clear_bit(0, &dev->hw_lock) == 0)
-                WARN_ON(1);
+        WARN_ON(test_and_clear_bit(0, &dev->hw_lock) == 0);
 
         s5p_mfc_clock_off();
         wake_up(&ctx->queue);
@@ -676,6 +671,12 @@ static irqreturn_t s5p_mfc_irq(int irq, void *priv)
                 s5p_mfc_handle_stream_complete(ctx, reason, err);
                 break;
 
+        case S5P_MFC_R2H_CMD_DPB_FLUSH_RET:
+                clear_work_bit(ctx);
+                ctx->state = MFCINST_RUNNING;
+                wake_up(&ctx->queue);
+                goto irq_cleanup_hw;
+
         default:
                 mfc_debug(2, "Unknown int reason\n");
                 s5p_mfc_hw_call(dev->mfc_ops, clear_int_flags, dev);
@@ -777,14 +778,16 @@ static int s5p_mfc_open(struct file *file)
                         goto err_pwr_enable;
                 }
                 s5p_mfc_clock_on();
-                ret = s5p_mfc_alloc_and_load_firmware(dev);
-                if (ret)
-                        goto err_alloc_fw;
+                ret = s5p_mfc_load_firmware(dev);
+                if (ret) {
+                        s5p_mfc_clock_off();
+                        goto err_load_fw;
+                }
                 /* Init the FW */
                 ret = s5p_mfc_init_hw(dev);
+                s5p_mfc_clock_off();
                 if (ret)
                         goto err_init_hw;
-                s5p_mfc_clock_off();
         }
         /* Init videobuf2 queue for CAPTURE */
         q = &ctx->vq_dst;
@@ -833,21 +836,20 @@ static int s5p_mfc_open(struct file *file)
         return ret;
         /* Deinit when failure occured */
 err_queue_init:
+        if (dev->num_inst == 1)
+                s5p_mfc_deinit_hw(dev);
 err_init_hw:
-        s5p_mfc_release_firmware(dev);
-err_alloc_fw:
-        dev->ctx[ctx->num] = NULL;
-        del_timer_sync(&dev->watchdog_timer);
-        s5p_mfc_clock_off();
+err_load_fw:
 err_pwr_enable:
         if (dev->num_inst == 1) {
                 if (s5p_mfc_power_off() < 0)
                         mfc_err("power off failed\n");
-                s5p_mfc_release_firmware(dev);
+                del_timer_sync(&dev->watchdog_timer);
         }
 err_ctrls_setup:
         s5p_mfc_dec_ctrls_delete(ctx);
 err_bad_node:
+        dev->ctx[ctx->num] = NULL;
 err_no_ctx:
         v4l2_fh_del(&ctx->fh);
         v4l2_fh_exit(&ctx->fh);
@@ -901,11 +903,8 @@ static int s5p_mfc_release(struct file *file)
                 clear_bit(0, &dev->hw_lock);
         dev->num_inst--;
         if (dev->num_inst == 0) {
-                mfc_debug(2, "Last instance - release firmware\n");
-                /* reset <-> F/W release */
-                s5p_mfc_reset(dev);
+                mfc_debug(2, "Last instance\n");
                 s5p_mfc_deinit_hw(dev);
-                s5p_mfc_release_firmware(dev);
                 del_timer_sync(&dev->watchdog_timer);
                 if (s5p_mfc_power_off() < 0)
                         mfc_err("Power off failed\n");
@@ -1013,6 +1012,48 @@ static int match_child(struct device *dev, void *data)
         return !strcmp(dev_name(dev), (char *)data);
 }
 
+static void *mfc_get_drv_data(struct platform_device *pdev);
+
+static int s5p_mfc_alloc_memdevs(struct s5p_mfc_dev *dev)
+{
+        unsigned int mem_info[2];
+
+        dev->mem_dev_l = devm_kzalloc(&dev->plat_dev->dev,
+                        sizeof(struct device), GFP_KERNEL);
+        if (!dev->mem_dev_l) {
+                mfc_err("Not enough memory\n");
+                return -ENOMEM;
+        }
+        device_initialize(dev->mem_dev_l);
+        of_property_read_u32_array(dev->plat_dev->dev.of_node,
+                        "samsung,mfc-l", mem_info, 2);
+        if (dma_declare_coherent_memory(dev->mem_dev_l, mem_info[0],
+                                mem_info[0], mem_info[1],
+                                DMA_MEMORY_MAP | DMA_MEMORY_EXCLUSIVE) == 0) {
+                mfc_err("Failed to declare coherent memory for\n"
+                "MFC device\n");
+                return -ENOMEM;
+        }
+
+        dev->mem_dev_r = devm_kzalloc(&dev->plat_dev->dev,
+                        sizeof(struct device), GFP_KERNEL);
+        if (!dev->mem_dev_r) {
+                mfc_err("Not enough memory\n");
+                return -ENOMEM;
+        }
+        device_initialize(dev->mem_dev_r);
+        of_property_read_u32_array(dev->plat_dev->dev.of_node,
+                        "samsung,mfc-r", mem_info, 2);
+        if (dma_declare_coherent_memory(dev->mem_dev_r, mem_info[0],
+                                mem_info[0], mem_info[1],
+                                DMA_MEMORY_MAP | DMA_MEMORY_EXCLUSIVE) == 0) {
+                pr_err("Failed to declare coherent memory for\n"
+                "MFC device\n");
+                return -ENOMEM;
+        }
+        return 0;
+}
+
 /* MFC probe function */
 static int s5p_mfc_probe(struct platform_device *pdev)
 {
@@ -1036,8 +1077,7 @@ static int s5p_mfc_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        dev->variant = (struct s5p_mfc_variant *)
-                platform_get_device_id(pdev)->driver_data;
+        dev->variant = mfc_get_drv_data(pdev);
 
         ret = s5p_mfc_init_pm(dev);
         if (ret < 0) {
@@ -1065,35 +1105,43 @@ static int s5p_mfc_probe(struct platform_device *pdev)
                 goto err_res;
         }
 
-        dev->mem_dev_l = device_find_child(&dev->plat_dev->dev, "s5p-mfc-l",
-                                           match_child);
-        if (!dev->mem_dev_l) {
-                mfc_err("Mem child (L) device get failed\n");
-                ret = -ENODEV;
-                goto err_res;
-        }
-
-        dev->mem_dev_r = device_find_child(&dev->plat_dev->dev, "s5p-mfc-r",
-                                           match_child);
-        if (!dev->mem_dev_r) {
-                mfc_err("Mem child (R) device get failed\n");
-                ret = -ENODEV;
-                goto err_res;
+        if (pdev->dev.of_node) {
+                if (s5p_mfc_alloc_memdevs(dev) < 0)
+                        goto err_res;
+        } else {
+                dev->mem_dev_l = device_find_child(&dev->plat_dev->dev,
+                                "s5p-mfc-l", match_child);
+                if (!dev->mem_dev_l) {
+                        mfc_err("Mem child (L) device get failed\n");
+                        ret = -ENODEV;
+                        goto err_res;
+                }
+                dev->mem_dev_r = device_find_child(&dev->plat_dev->dev,
+                                "s5p-mfc-r", match_child);
+                if (!dev->mem_dev_r) {
+                        mfc_err("Mem child (R) device get failed\n");
+                        ret = -ENODEV;
+                        goto err_res;
+                }
         }
 
         dev->alloc_ctx[0] = vb2_dma_contig_init_ctx(dev->mem_dev_l);
-        if (IS_ERR_OR_NULL(dev->alloc_ctx[0])) {
+        if (IS_ERR(dev->alloc_ctx[0])) {
                 ret = PTR_ERR(dev->alloc_ctx[0]);
                 goto err_res;
         }
         dev->alloc_ctx[1] = vb2_dma_contig_init_ctx(dev->mem_dev_r);
-        if (IS_ERR_OR_NULL(dev->alloc_ctx[1])) {
+        if (IS_ERR(dev->alloc_ctx[1])) {
                 ret = PTR_ERR(dev->alloc_ctx[1]);
                 goto err_mem_init_ctx_1;
         }
 
         mutex_init(&dev->mfc_mutex);
 
+        ret = s5p_mfc_alloc_firmware(dev);
+        if (ret)
+                goto err_alloc_fw;
+
         ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
         if (ret)
                 goto err_v4l2_dev_reg;
@@ -1175,6 +1223,8 @@ err_dec_reg:
 err_dec_alloc:
         v4l2_device_unregister(&dev->v4l2_dev);
 err_v4l2_dev_reg:
+        s5p_mfc_release_firmware(dev);
+err_alloc_fw:
         vb2_dma_contig_cleanup_ctx(dev->alloc_ctx[1]);
 err_mem_init_ctx_1:
         vb2_dma_contig_cleanup_ctx(dev->alloc_ctx[0]);
@@ -1200,8 +1250,13 @@ static int s5p_mfc_remove(struct platform_device *pdev)
         video_unregister_device(dev->vfd_enc);
         video_unregister_device(dev->vfd_dec);
         v4l2_device_unregister(&dev->v4l2_dev);
+        s5p_mfc_release_firmware(dev);
         vb2_dma_contig_cleanup_ctx(dev->alloc_ctx[0]);
         vb2_dma_contig_cleanup_ctx(dev->alloc_ctx[1]);
+        if (pdev->dev.of_node) {
+                put_device(dev->mem_dev_l);
+                put_device(dev->mem_dev_r);
+        }
 
         s5p_mfc_final_pm(dev);
         return 0;
@@ -1350,6 +1405,35 @@ static struct platform_device_id mfc_driver_ids[] = {
 };
 MODULE_DEVICE_TABLE(platform, mfc_driver_ids);
 
+static const struct of_device_id exynos_mfc_match[] = {
+        {
+                .compatible = "samsung,mfc-v5",
+                .data = &mfc_drvdata_v5,
+        }, {
+                .compatible = "samsung,mfc-v6",
+                .data = &mfc_drvdata_v6,
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, exynos_mfc_match);
+
+static void *mfc_get_drv_data(struct platform_device *pdev)
+{
+        struct s5p_mfc_variant *driver_data = NULL;
+
+        if (pdev->dev.of_node) {
+                const struct of_device_id *match;
+                match = of_match_node(of_match_ptr(exynos_mfc_match),
+                                pdev->dev.of_node);
+                if (match)
+                        driver_data = (struct s5p_mfc_variant *)match->data;
+        } else {
+                driver_data = (struct s5p_mfc_variant *)
+                        platform_get_device_id(pdev)->driver_data;
+        }
+        return driver_data;
+}
+
 static struct platform_driver s5p_mfc_driver = {
         .probe          = s5p_mfc_probe,
         .remove         = s5p_mfc_remove,
@@ -1357,7 +1441,8 @@ static struct platform_driver s5p_mfc_driver = {
         .driver = {
                 .name   = S5P_MFC_NAME,
                 .owner  = THIS_MODULE,
-                .pm     = &s5p_mfc_pm_ops
+                .pm     = &s5p_mfc_pm_ops,
+                .of_match_table = exynos_mfc_match,
         },
 };
 
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_common.h b/drivers/media/platform/s5p-mfc/s5p_mfc_common.h
index f02e0497ca98..202d1d7a37a8 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_common.h
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_common.h
@@ -145,6 +145,7 @@ enum s5p_mfc_inst_state {
         MFCINST_RETURN_INST,
         MFCINST_ERROR,
         MFCINST_ABORT,
+        MFCINST_FLUSH,
         MFCINST_RES_CHANGE_INIT,
         MFCINST_RES_CHANGE_FLUSH,
         MFCINST_RES_CHANGE_END,
@@ -277,8 +278,9 @@ struct s5p_mfc_priv_buf {
  * @int_err:            error number for last interrupt
  * @queue:              waitqueue for waiting for completion of device commands
  * @fw_size:            size of firmware
- * @bank1:              address of the beggining of bank 1 memory
- * @bank2:              address of the beggining of bank 2 memory
+ * @fw_virt_addr:       virtual firmware address
+ * @bank1:              address of the beginning of bank 1 memory
+ * @bank2:              address of the beginning of bank 2 memory
  * @hw_lock:            used for hardware locking
  * @ctx:                array of driver contexts
  * @curr_ctx:           number of the currently running context
@@ -317,8 +319,9 @@ struct s5p_mfc_dev {
         unsigned int int_err;
         wait_queue_head_t queue;
         size_t fw_size;
-        size_t bank1;
-        size_t bank2;
+        void *fw_virt_addr;
+        dma_addr_t bank1;
+        dma_addr_t bank2;
         unsigned long hw_lock;
         struct s5p_mfc_ctx *ctx[MFC_NUM_CONTEXTS];
         int curr_ctx;
@@ -493,15 +496,9 @@ struct s5p_mfc_codec_ops {
  *                      flushed
  * @head_processed:     flag mentioning whether the header data is processed
  *                      completely or not
- * @bank1_buf:          handle to memory allocated for temporary buffers from
+ * @bank1:              handle to memory allocated for temporary buffers from
  *                      memory bank 1
- * @bank1_phys:         address of the temporary buffers from memory bank 1
- * @bank1_size:         size of the memory allocated for temporary buffers from
- *                      memory bank 1
- * @bank2_buf:          handle to memory allocated for temporary buffers from
- *                      memory bank 2
- * @bank2_phys:         address of the temporary buffers from memory bank 2
- * @bank2_size:         size of the memory allocated for temporary buffers from
+ * @bank2:              handle to memory allocated for temporary buffers from
  *                      memory bank 2
  * @capture_state:      state of the capture buffers queue
  * @output_state:       state of the output buffers queue
@@ -581,14 +578,8 @@ struct s5p_mfc_ctx {
         unsigned int dpb_flush_flag;
         unsigned int head_processed;
 
-        /* Buffers */
-        void *bank1_buf;
-        size_t bank1_phys;
-        size_t bank1_size;
-
-        void *bank2_buf;
-        size_t bank2_phys;
-        size_t bank2_size;
+        struct s5p_mfc_priv_buf bank1;
+        struct s5p_mfc_priv_buf bank2;
 
         enum s5p_mfc_queue_state capture_state;
         enum s5p_mfc_queue_state output_state;
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.c b/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.c
index 585b7b0ed8ec..2e5f30b40dea 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.c
@@ -22,16 +22,64 @@
 #include "s5p_mfc_opr.h"
 #include "s5p_mfc_pm.h"
 
-static void *s5p_mfc_bitproc_buf;
-static size_t s5p_mfc_bitproc_phys;
-static unsigned char *s5p_mfc_bitproc_virt;
+/* Allocate memory for firmware */
+int s5p_mfc_alloc_firmware(struct s5p_mfc_dev *dev)
+{
+        void *bank2_virt;
+        dma_addr_t bank2_dma_addr;
+
+        dev->fw_size = dev->variant->buf_size->fw;
+
+        if (dev->fw_virt_addr) {
+                mfc_err("Attempting to allocate firmware when it seems that it is already loaded\n");
+                return -ENOMEM;
+        }
+
+        dev->fw_virt_addr = dma_alloc_coherent(dev->mem_dev_l, dev->fw_size,
+                                        &dev->bank1, GFP_KERNEL);
+
+        if (IS_ERR(dev->fw_virt_addr)) {
+                dev->fw_virt_addr = NULL;
+                mfc_err("Allocating bitprocessor buffer failed\n");
+                return -ENOMEM;
+        }
+
+        dev->bank1 = dev->bank1;
+
+        if (HAS_PORTNUM(dev) && IS_TWOPORT(dev)) {
+                bank2_virt = dma_alloc_coherent(dev->mem_dev_r, 1 << MFC_BASE_ALIGN_ORDER,
+                                        &bank2_dma_addr, GFP_KERNEL);
+
+                if (IS_ERR(dev->fw_virt_addr)) {
+                        mfc_err("Allocating bank2 base failed\n");
+                        dma_free_coherent(dev->mem_dev_l, dev->fw_size,
+                                dev->fw_virt_addr, dev->bank1);
+                        dev->fw_virt_addr = NULL;
+                        return -ENOMEM;
+                }
+
+                /* Valid buffers passed to MFC encoder with LAST_FRAME command
+                 * should not have address of bank2 - MFC will treat it as a null frame.
+                 * To avoid such situation we set bank2 address below the pool address.
+                 */
+                dev->bank2 = bank2_dma_addr - (1 << MFC_BASE_ALIGN_ORDER);
+
+                dma_free_coherent(dev->mem_dev_r, 1 << MFC_BASE_ALIGN_ORDER,
+                        bank2_virt, bank2_dma_addr);
+
+        } else {
+                /* In this case bank2 can point to the same address as bank1.
+                 * Firmware will always occupy the beggining of this area so it is
+                 * impossible having a video frame buffer with zero address. */
+                dev->bank2 = dev->bank1;
+        }
+        return 0;
+}
 
-/* Allocate and load firmware */
-int s5p_mfc_alloc_and_load_firmware(struct s5p_mfc_dev *dev)
+/* Load firmware */
+int s5p_mfc_load_firmware(struct s5p_mfc_dev *dev)
 {
         struct firmware *fw_blob;
-        size_t bank2_base_phys;
-        void *b_base;
         int err;
 
         /* Firmare has to be present as a separate file or compiled
@@ -44,77 +92,17 @@ int s5p_mfc_alloc_and_load_firmware(struct s5p_mfc_dev *dev)
                 mfc_err("Firmware is not present in the /lib/firmware directory nor compiled in kernel\n");
                 return -EINVAL;
         }
-        dev->fw_size = dev->variant->buf_size->fw;
         if (fw_blob->size > dev->fw_size) {
                 mfc_err("MFC firmware is too big to be loaded\n");
                 release_firmware(fw_blob);
                 return -ENOMEM;
         }
-        if (s5p_mfc_bitproc_buf) {
-                mfc_err("Attempting to allocate firmware when it seems that it is already loaded\n");
-                release_firmware(fw_blob);
-                return -ENOMEM;
-        }
-        s5p_mfc_bitproc_buf = vb2_dma_contig_memops.alloc(
-                dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], dev->fw_size);
-        if (IS_ERR(s5p_mfc_bitproc_buf)) {
-                s5p_mfc_bitproc_buf = NULL;
-                mfc_err("Allocating bitprocessor buffer failed\n");
+        if (!dev->fw_virt_addr) {
+                mfc_err("MFC firmware is not allocated\n");
                 release_firmware(fw_blob);
-                return -ENOMEM;
-        }
-        s5p_mfc_bitproc_phys = s5p_mfc_mem_cookie(
-                dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], s5p_mfc_bitproc_buf);
-        if (s5p_mfc_bitproc_phys & ((1 << MFC_BASE_ALIGN_ORDER) - 1)) {
-                mfc_err("The base memory for bank 1 is not aligned to 128KB\n");
-                vb2_dma_contig_memops.put(s5p_mfc_bitproc_buf);
-                s5p_mfc_bitproc_phys = 0;
-                s5p_mfc_bitproc_buf = NULL;
-                release_firmware(fw_blob);
-                return -EIO;
-        }
-        s5p_mfc_bitproc_virt = vb2_dma_contig_memops.vaddr(s5p_mfc_bitproc_buf);
-        if (!s5p_mfc_bitproc_virt) {
-                mfc_err("Bitprocessor memory remap failed\n");
-                vb2_dma_contig_memops.put(s5p_mfc_bitproc_buf);
-                s5p_mfc_bitproc_phys = 0;
-                s5p_mfc_bitproc_buf = NULL;
-                release_firmware(fw_blob);
-                return -EIO;
-        }
-        dev->bank1 = s5p_mfc_bitproc_phys;
-        if (HAS_PORTNUM(dev) && IS_TWOPORT(dev)) {
-                b_base = vb2_dma_contig_memops.alloc(
-                        dev->alloc_ctx[MFC_BANK2_ALLOC_CTX],
-                        1 << MFC_BASE_ALIGN_ORDER);
-                if (IS_ERR(b_base)) {
-                        vb2_dma_contig_memops.put(s5p_mfc_bitproc_buf);
-                        s5p_mfc_bitproc_phys = 0;
-                        s5p_mfc_bitproc_buf = NULL;
-                        mfc_err("Allocating bank2 base failed\n");
-                        release_firmware(fw_blob);
-                        return -ENOMEM;
-                }
-                bank2_base_phys = s5p_mfc_mem_cookie(
-                        dev->alloc_ctx[MFC_BANK2_ALLOC_CTX], b_base);
-                vb2_dma_contig_memops.put(b_base);
-                if (bank2_base_phys & ((1 << MFC_BASE_ALIGN_ORDER) - 1)) {
-                        mfc_err("The base memory for bank 2 is not aligned to 128KB\n");
-                        vb2_dma_contig_memops.put(s5p_mfc_bitproc_buf);
-                        s5p_mfc_bitproc_phys = 0;
-                        s5p_mfc_bitproc_buf = NULL;
-                        release_firmware(fw_blob);
-                        return -EIO;
-                }
-                /* Valid buffers passed to MFC encoder with LAST_FRAME command
-                 * should not have address of bank2 - MFC will treat it as a null frame.
-                 * To avoid such situation we set bank2 address below the pool address.
-                 */
-                dev->bank2 = bank2_base_phys - (1 << MFC_BASE_ALIGN_ORDER);
-        } else {
-                dev->bank2 = dev->bank1;
+                return -EINVAL;
         }
-        memcpy(s5p_mfc_bitproc_virt, fw_blob->data, fw_blob->size);
+        memcpy(dev->fw_virt_addr, fw_blob->data, fw_blob->size);
         wmb();
         release_firmware(fw_blob);
         mfc_debug_leave();
@@ -142,12 +130,12 @@ int s5p_mfc_reload_firmware(struct s5p_mfc_dev *dev)
                 release_firmware(fw_blob);
                 return -ENOMEM;
         }
-        if (s5p_mfc_bitproc_buf == NULL || s5p_mfc_bitproc_phys == 0) {
-                mfc_err("MFC firmware is not allocated or was not mapped correctly\n");
+        if (!dev->fw_virt_addr) {
+                mfc_err("MFC firmware is not allocated\n");
                 release_firmware(fw_blob);
                 return -EINVAL;
         }
-        memcpy(s5p_mfc_bitproc_virt, fw_blob->data, fw_blob->size);
+        memcpy(dev->fw_virt_addr, fw_blob->data, fw_blob->size);
         wmb();
         release_firmware(fw_blob);
         mfc_debug_leave();
@@ -159,12 +147,11 @@ int s5p_mfc_release_firmware(struct s5p_mfc_dev *dev)
 {
         /* Before calling this function one has to make sure
          * that MFC is no longer processing */
-        if (!s5p_mfc_bitproc_buf)
+        if (!dev->fw_virt_addr)
                 return -EINVAL;
-        vb2_dma_contig_memops.put(s5p_mfc_bitproc_buf);
-        s5p_mfc_bitproc_virt = NULL;
-        s5p_mfc_bitproc_phys = 0;
-        s5p_mfc_bitproc_buf = NULL;
+        dma_free_coherent(dev->mem_dev_l, dev->fw_size, dev->fw_virt_addr,
+                                                dev->bank1);
+        dev->fw_virt_addr = NULL;
         return 0;
 }
 
@@ -257,8 +244,10 @@ int s5p_mfc_init_hw(struct s5p_mfc_dev *dev)
         int ret;
 
         mfc_debug_enter();
-        if (!s5p_mfc_bitproc_buf)
+        if (!dev->fw_virt_addr) {
+                mfc_err("Firmware memory is not allocated.\n");
                 return -EINVAL;
+        }
 
         /* 0. MFC reset */
         mfc_debug(2, "MFC reset..\n");
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.h b/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.h
index 90aa9b9886d5..6a9b6f8606bb 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.h
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_ctrl.h
@@ -16,7 +16,8 @@
 #include "s5p_mfc_common.h"
 
 int s5p_mfc_release_firmware(struct s5p_mfc_dev *dev);
-int s5p_mfc_alloc_and_load_firmware(struct s5p_mfc_dev *dev);
+int s5p_mfc_alloc_firmware(struct s5p_mfc_dev *dev);
+int s5p_mfc_load_firmware(struct s5p_mfc_dev *dev);
 int s5p_mfc_reload_firmware(struct s5p_mfc_dev *dev);
 
 int s5p_mfc_init_hw(struct s5p_mfc_dev *dev);
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_dec.c b/drivers/media/platform/s5p-mfc/s5p_mfc_dec.c
index 6dad9a74f61c..4582473978ca 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_dec.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_dec.c
@@ -991,24 +991,35 @@ static int s5p_mfc_stop_streaming(struct vb2_queue *q)
                                         S5P_MFC_R2H_CMD_FRAME_DONE_RET, 0);
                 aborted = 1;
         }
-        spin_lock_irqsave(&dev->irqlock, flags);
         if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
+                spin_lock_irqsave(&dev->irqlock, flags);
                 s5p_mfc_hw_call(dev->mfc_ops, cleanup_queue, &ctx->dst_queue,
                                 &ctx->vq_dst);
                 INIT_LIST_HEAD(&ctx->dst_queue);
                 ctx->dst_queue_cnt = 0;
                 ctx->dpb_flush_flag = 1;
                 ctx->dec_dst_flag = 0;
+                spin_unlock_irqrestore(&dev->irqlock, flags);
+                if (IS_MFCV6(dev) && (ctx->state == MFCINST_RUNNING)) {
+                        ctx->state = MFCINST_FLUSH;
+                        set_work_bit_irqsave(ctx);
+                        s5p_mfc_clean_ctx_int_flags(ctx);
+                        s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
+                        if (s5p_mfc_wait_for_done_ctx(ctx,
+                                S5P_MFC_R2H_CMD_DPB_FLUSH_RET, 0))
+                                mfc_err("Err flushing buffers\n");
+                }
         }
         if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
+                spin_lock_irqsave(&dev->irqlock, flags);
                 s5p_mfc_hw_call(dev->mfc_ops, cleanup_queue, &ctx->src_queue,
                                 &ctx->vq_src);
                 INIT_LIST_HEAD(&ctx->src_queue);
                 ctx->src_queue_cnt = 0;
+                spin_unlock_irqrestore(&dev->irqlock, flags);
         }
         if (aborted)
                 ctx->state = MFCINST_RUNNING;
-        spin_unlock_irqrestore(&dev->irqlock, flags);
         return 0;
 }
 
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c b/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c
index f92f6ddd739f..2356fd52a169 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c
@@ -1534,6 +1534,8 @@ int vidioc_encoder_cmd(struct file *file, void *priv,
                 if (list_empty(&ctx->src_queue)) {
                         mfc_debug(2, "EOS: empty src queue, entering finishing state");
                         ctx->state = MFCINST_FINISHING;
+                        if (s5p_mfc_ctx_ready(ctx))
+                                set_work_bit_irqsave(ctx);
                         spin_unlock_irqrestore(&dev->irqlock, flags);
                         s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
                 } else {
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_opr.c b/drivers/media/platform/s5p-mfc/s5p_mfc_opr.c
index 6932e90d4065..10f8ac37cecd 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_opr.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_opr.c
@@ -12,6 +12,7 @@
  * published by the Free Software Foundation.
  */
 
+#include "s5p_mfc_debug.h"
 #include "s5p_mfc_opr.h"
 #include "s5p_mfc_opr_v5.h"
 #include "s5p_mfc_opr_v6.h"
@@ -29,3 +30,32 @@ void s5p_mfc_init_hw_ops(struct s5p_mfc_dev *dev)
         }
         dev->mfc_ops = s5p_mfc_ops;
 }
+
+int s5p_mfc_alloc_priv_buf(struct device *dev,
+                                        struct s5p_mfc_priv_buf *b)
+{
+
+        mfc_debug(3, "Allocating priv: %d\n", b->size);
+
+        b->virt = dma_alloc_coherent(dev, b->size, &b->dma, GFP_KERNEL);
+
+        if (!b->virt) {
+                mfc_err("Allocating private buffer failed\n");
+                return -ENOMEM;
+        }
+
+        mfc_debug(3, "Allocated addr %p %08x\n", b->virt, b->dma);
+        return 0;
+}
+
+void s5p_mfc_release_priv_buf(struct device *dev,
+                                                struct s5p_mfc_priv_buf *b)
+{
+        if (b->virt) {
+                dma_free_coherent(dev, b->size, b->virt, b->dma);
+                b->virt = NULL;
+                b->dma = 0;
+                b->size = 0;
+        }
+}
+
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_opr.h b/drivers/media/platform/s5p-mfc/s5p_mfc_opr.h
index 420abecafec0..754c540e7a7e 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_opr.h
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_opr.h
@@ -80,5 +80,10 @@ struct s5p_mfc_hw_ops {
 };
 
 void s5p_mfc_init_hw_ops(struct s5p_mfc_dev *dev);
+int s5p_mfc_alloc_priv_buf(struct device *dev,
+                                        struct s5p_mfc_priv_buf *b);
+void s5p_mfc_release_priv_buf(struct device *dev,
+                                        struct s5p_mfc_priv_buf *b);
+
 
 #endif /* S5P_MFC_OPR_H_ */
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v5.c b/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v5.c
index bf7d010a4107..f61dba837899 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v5.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v5.c
@@ -38,39 +38,26 @@ int s5p_mfc_alloc_dec_temp_buffers_v5(struct s5p_mfc_ctx *ctx)
 {
         struct s5p_mfc_dev *dev = ctx->dev;
         struct s5p_mfc_buf_size_v5 *buf_size = dev->variant->buf_size->priv;
+        int ret;
 
-        ctx->dsc.alloc = vb2_dma_contig_memops.alloc(
-                        dev->alloc_ctx[MFC_BANK1_ALLOC_CTX],
-                        buf_size->dsc);
-        if (IS_ERR_VALUE((int)ctx->dsc.alloc)) {
-                ctx->dsc.alloc = NULL;
-                mfc_err("Allocating DESC buffer failed\n");
-                return -ENOMEM;
+        ctx->dsc.size = buf_size->dsc;
+        ret =  s5p_mfc_alloc_priv_buf(dev->mem_dev_l, &ctx->dsc);
+        if (ret) {
+                mfc_err("Failed to allocate temporary buffer\n");
+                return ret;
         }
-        ctx->dsc.dma = s5p_mfc_mem_cookie(
-                        dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], ctx->dsc.alloc);
+
         BUG_ON(ctx->dsc.dma & ((1 << MFC_BANK1_ALIGN_ORDER) - 1));
-        ctx->dsc.virt = vb2_dma_contig_memops.vaddr(ctx->dsc.alloc);
-        if (ctx->dsc.virt == NULL) {
-                vb2_dma_contig_memops.put(ctx->dsc.alloc);
-                ctx->dsc.dma = 0;
-                ctx->dsc.alloc = NULL;
-                mfc_err("Remapping DESC buffer failed\n");
-                return -ENOMEM;
-        }
-        memset(ctx->dsc.virt, 0, buf_size->dsc);
+        memset(ctx->dsc.virt, 0, ctx->dsc.size);
         wmb();
         return 0;
 }
 
+
 /* Release temporary buffers for decoding */
 void s5p_mfc_release_dec_desc_buffer_v5(struct s5p_mfc_ctx *ctx)
 {
-        if (ctx->dsc.dma) {
-                vb2_dma_contig_memops.put(ctx->dsc.alloc);
-                ctx->dsc.alloc = NULL;
-                ctx->dsc.dma = 0;
-        }
+        s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->dsc);
 }
 
 /* Allocate codec buffers */
@@ -80,6 +67,7 @@ int s5p_mfc_alloc_codec_buffers_v5(struct s5p_mfc_ctx *ctx)
         unsigned int enc_ref_y_size = 0;
         unsigned int enc_ref_c_size = 0;
         unsigned int guard_width, guard_height;
+        int ret;
 
         if (ctx->type == MFCINST_DECODER) {
                 mfc_debug(2, "Luma size:%d Chroma size:%d MV size:%d\n",
@@ -113,100 +101,93 @@ int s5p_mfc_alloc_codec_buffers_v5(struct s5p_mfc_ctx *ctx)
         /* Codecs have different memory requirements */
         switch (ctx->codec_mode) {
         case S5P_MFC_CODEC_H264_DEC:
-                ctx->bank1_size =
+                ctx->bank1.size =
                     ALIGN(S5P_FIMV_DEC_NB_IP_SIZE +
                                         S5P_FIMV_DEC_VERT_NB_MV_SIZE,
                                         S5P_FIMV_DEC_BUF_ALIGN);
-                ctx->bank2_size = ctx->total_dpb_count * ctx->mv_size;
+                ctx->bank2.size = ctx->total_dpb_count * ctx->mv_size;
                 break;
         case S5P_MFC_CODEC_MPEG4_DEC:
-                ctx->bank1_size =
+                ctx->bank1.size =
                     ALIGN(S5P_FIMV_DEC_NB_DCAC_SIZE +
                                      S5P_FIMV_DEC_UPNB_MV_SIZE +
                                      S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE +
                                      S5P_FIMV_DEC_STX_PARSER_SIZE +
                                      S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE,
                                      S5P_FIMV_DEC_BUF_ALIGN);
-                ctx->bank2_size = 0;
+                ctx->bank2.size = 0;
                 break;
         case S5P_MFC_CODEC_VC1RCV_DEC:
         case S5P_MFC_CODEC_VC1_DEC:
-                ctx->bank1_size =
+                ctx->bank1.size =
                     ALIGN(S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE +
                              S5P_FIMV_DEC_UPNB_MV_SIZE +
                              S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE +
                              S5P_FIMV_DEC_NB_DCAC_SIZE +
                              3 * S5P_FIMV_DEC_VC1_BITPLANE_SIZE,
                              S5P_FIMV_DEC_BUF_ALIGN);
-                ctx->bank2_size = 0;
+                ctx->bank2.size = 0;
                 break;
         case S5P_MFC_CODEC_MPEG2_DEC:
-                ctx->bank1_size = 0;
-                ctx->bank2_size = 0;
+                ctx->bank1.size = 0;
+                ctx->bank2.size = 0;
                 break;
         case S5P_MFC_CODEC_H263_DEC:
-                ctx->bank1_size =
+                ctx->bank1.size =
                     ALIGN(S5P_FIMV_DEC_OVERLAP_TRANSFORM_SIZE +
                              S5P_FIMV_DEC_UPNB_MV_SIZE +
                              S5P_FIMV_DEC_SUB_ANCHOR_MV_SIZE +
                              S5P_FIMV_DEC_NB_DCAC_SIZE,
                              S5P_FIMV_DEC_BUF_ALIGN);
-                ctx->bank2_size = 0;
+                ctx->bank2.size = 0;
                 break;
         case S5P_MFC_CODEC_H264_ENC:
-                ctx->bank1_size = (enc_ref_y_size * 2) +
+                ctx->bank1.size = (enc_ref_y_size * 2) +
                                    S5P_FIMV_ENC_UPMV_SIZE +
                                    S5P_FIMV_ENC_COLFLG_SIZE +
                                    S5P_FIMV_ENC_INTRAMD_SIZE +
                                    S5P_FIMV_ENC_NBORINFO_SIZE;
-                ctx->bank2_size = (enc_ref_y_size * 2) +
+                ctx->bank2.size = (enc_ref_y_size * 2) +
                                    (enc_ref_c_size * 4) +
                                    S5P_FIMV_ENC_INTRAPRED_SIZE;
                 break;
         case S5P_MFC_CODEC_MPEG4_ENC:
-                ctx->bank1_size = (enc_ref_y_size * 2) +
+                ctx->bank1.size = (enc_ref_y_size * 2) +
                                    S5P_FIMV_ENC_UPMV_SIZE +
                                    S5P_FIMV_ENC_COLFLG_SIZE +
                                    S5P_FIMV_ENC_ACDCCOEF_SIZE;
-                ctx->bank2_size = (enc_ref_y_size * 2) +
+                ctx->bank2.size = (enc_ref_y_size * 2) +
                                    (enc_ref_c_size * 4);
                 break;
         case S5P_MFC_CODEC_H263_ENC:
-                ctx->bank1_size = (enc_ref_y_size * 2) +
+                ctx->bank1.size = (enc_ref_y_size * 2) +
                                    S5P_FIMV_ENC_UPMV_SIZE +
                                    S5P_FIMV_ENC_ACDCCOEF_SIZE;
-                ctx->bank2_size = (enc_ref_y_size * 2) +
+                ctx->bank2.size = (enc_ref_y_size * 2) +
                                    (enc_ref_c_size * 4);
                 break;
         default:
                 break;
         }
         /* Allocate only if memory from bank 1 is necessary */
-        if (ctx->bank1_size > 0) {
-                ctx->bank1_buf = vb2_dma_contig_memops.alloc(
-                dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], ctx->bank1_size);
-                if (IS_ERR(ctx->bank1_buf)) {
-                        ctx->bank1_buf = NULL;
-                        printk(KERN_ERR
-                               "Buf alloc for decoding failed (port A)\n");
-                        return -ENOMEM;
+        if (ctx->bank1.size > 0) {
+
+                ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_l, &ctx->bank1);
+                if (ret) {
+                        mfc_err("Failed to allocate Bank1 temporary buffer\n");
+                        return ret;
                 }
-                ctx->bank1_phys = s5p_mfc_mem_cookie(
-                dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], ctx->bank1_buf);
-                BUG_ON(ctx->bank1_phys & ((1 << MFC_BANK1_ALIGN_ORDER) - 1));
+                BUG_ON(ctx->bank1.dma & ((1 << MFC_BANK1_ALIGN_ORDER) - 1));
         }
         /* Allocate only if memory from bank 2 is necessary */
-        if (ctx->bank2_size > 0) {
-                ctx->bank2_buf = vb2_dma_contig_memops.alloc(
-                dev->alloc_ctx[MFC_BANK2_ALLOC_CTX], ctx->bank2_size);
-                if (IS_ERR(ctx->bank2_buf)) {
-                        ctx->bank2_buf = NULL;
-                        mfc_err("Buf alloc for decoding failed (port B)\n");
-                        return -ENOMEM;
+        if (ctx->bank2.size > 0) {
+                ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_r, &ctx->bank2);
+                if (ret) {
+                        mfc_err("Failed to allocate Bank2 temporary buffer\n");
+                s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->bank1);
+                        return ret;
                 }
-                ctx->bank2_phys = s5p_mfc_mem_cookie(
-                dev->alloc_ctx[MFC_BANK2_ALLOC_CTX], ctx->bank2_buf);
-                BUG_ON(ctx->bank2_phys & ((1 << MFC_BANK2_ALIGN_ORDER) - 1));
+                BUG_ON(ctx->bank2.dma & ((1 << MFC_BANK2_ALIGN_ORDER) - 1));
         }
         return 0;
 }
@@ -214,18 +195,8 @@ int s5p_mfc_alloc_codec_buffers_v5(struct s5p_mfc_ctx *ctx)
 /* Release buffers allocated for codec */
 void s5p_mfc_release_codec_buffers_v5(struct s5p_mfc_ctx *ctx)
 {
-        if (ctx->bank1_buf) {
-                vb2_dma_contig_memops.put(ctx->bank1_buf);
-                ctx->bank1_buf = NULL;
-                ctx->bank1_phys = 0;
-                ctx->bank1_size = 0;
-        }
-        if (ctx->bank2_buf) {
-                vb2_dma_contig_memops.put(ctx->bank2_buf);
-                ctx->bank2_buf = NULL;
-                ctx->bank2_phys = 0;
-                ctx->bank2_size = 0;
-        }
+        s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->bank1);
+        s5p_mfc_release_priv_buf(ctx->dev->mem_dev_r, &ctx->bank2);
 }
 
 /* Allocate memory for instance data buffer */
@@ -233,58 +204,38 @@ int s5p_mfc_alloc_instance_buffer_v5(struct s5p_mfc_ctx *ctx)
 {
         struct s5p_mfc_dev *dev = ctx->dev;
         struct s5p_mfc_buf_size_v5 *buf_size = dev->variant->buf_size->priv;
+        int ret;
 
         if (ctx->codec_mode == S5P_MFC_CODEC_H264_DEC ||
                 ctx->codec_mode == S5P_MFC_CODEC_H264_ENC)
                 ctx->ctx.size = buf_size->h264_ctx;
         else
                 ctx->ctx.size = buf_size->non_h264_ctx;
-        ctx->ctx.alloc = vb2_dma_contig_memops.alloc(
-                dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], ctx->ctx.size);
-        if (IS_ERR(ctx->ctx.alloc)) {
-                mfc_err("Allocating context buffer failed\n");
-                ctx->ctx.alloc = NULL;
-                return -ENOMEM;
+
+        ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_l, &ctx->ctx);
+        if (ret) {
+                mfc_err("Failed to allocate instance buffer\n");
+                return ret;
         }
-        ctx->ctx.dma = s5p_mfc_mem_cookie(
-                dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], ctx->ctx.alloc);
-        BUG_ON(ctx->ctx.dma & ((1 << MFC_BANK1_ALIGN_ORDER) - 1));
         ctx->ctx.ofs = OFFSETA(ctx->ctx.dma);
-        ctx->ctx.virt = vb2_dma_contig_memops.vaddr(ctx->ctx.alloc);
-        if (!ctx->ctx.virt) {
-                mfc_err("Remapping instance buffer failed\n");
-                vb2_dma_contig_memops.put(ctx->ctx.alloc);
-                ctx->ctx.alloc = NULL;
-                ctx->ctx.ofs = 0;
-                ctx->ctx.dma = 0;
-                return -ENOMEM;
-        }
+
         /* Zero content of the allocated memory */
         memset(ctx->ctx.virt, 0, ctx->ctx.size);
         wmb();
 
         /* Initialize shared memory */
-        ctx->shm.alloc = vb2_dma_contig_memops.alloc(
-                        dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], buf_size->shm);
-        if (IS_ERR(ctx->shm.alloc)) {
-                mfc_err("failed to allocate shared memory\n");
-                return PTR_ERR(ctx->shm.alloc);
+        ctx->shm.size = buf_size->shm;
+        ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_l, &ctx->shm);
+        if (ret) {
+                mfc_err("Failed to allocate shared memory buffer\n");
+                return ret;
         }
+
         /* shared memory offset only keeps the offset from base (port a) */
-        ctx->shm.ofs = s5p_mfc_mem_cookie(
-                        dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], ctx->shm.alloc)
-                                                                - dev->bank1;
+        ctx->shm.ofs = ctx->shm.dma - dev->bank1;
         BUG_ON(ctx->shm.ofs & ((1 << MFC_BANK1_ALIGN_ORDER) - 1));
 
-        ctx->shm.virt = vb2_dma_contig_memops.vaddr(ctx->shm.alloc);
-        if (!ctx->shm.virt) {
-                vb2_dma_contig_memops.put(ctx->shm.alloc);
-                ctx->shm.alloc = NULL;
-                ctx->shm.ofs = 0;
-                mfc_err("failed to virt addr of shared memory\n");
-                return -ENOMEM;
-        }
-        memset((void *)ctx->shm.virt, 0, buf_size->shm);
+        memset(ctx->shm.virt, 0, buf_size->shm);
         wmb();
         return 0;
 }
@@ -292,19 +243,8 @@ int s5p_mfc_alloc_instance_buffer_v5(struct s5p_mfc_ctx *ctx)
 /* Release instance buffer */
 void s5p_mfc_release_instance_buffer_v5(struct s5p_mfc_ctx *ctx)
 {
-        if (ctx->ctx.alloc) {
-                vb2_dma_contig_memops.put(ctx->ctx.alloc);
-                ctx->ctx.alloc = NULL;
-                ctx->ctx.ofs = 0;
-                ctx->ctx.virt = NULL;
-                ctx->ctx.dma = 0;
-        }
-        if (ctx->shm.alloc) {
-                vb2_dma_contig_memops.put(ctx->shm.alloc);
-                ctx->shm.alloc = NULL;
-                ctx->shm.ofs = 0;
-                ctx->shm.virt = NULL;
-        }
+        s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->ctx);
+        s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->shm);
 }
 
 int s5p_mfc_alloc_dev_context_buffer_v5(struct s5p_mfc_dev *dev)
@@ -443,10 +383,10 @@ int s5p_mfc_set_dec_frame_buffer_v5(struct s5p_mfc_ctx *ctx)
         size_t buf_addr1, buf_addr2;
         int buf_size1, buf_size2;
 
-        buf_addr1 = ctx->bank1_phys;
-        buf_size1 = ctx->bank1_size;
-        buf_addr2 = ctx->bank2_phys;
-        buf_size2 = ctx->bank2_size;
+        buf_addr1 = ctx->bank1.dma;
+        buf_size1 = ctx->bank1.size;
+        buf_addr2 = ctx->bank2.dma;
+        buf_size2 = ctx->bank2.size;
         dpb = mfc_read(dev, S5P_FIMV_SI_CH0_DPB_CONF_CTRL) &
                                                 ~S5P_FIMV_DPB_COUNT_MASK;
         mfc_write(dev, ctx->total_dpb_count | dpb,
@@ -523,7 +463,6 @@ int s5p_mfc_set_dec_frame_buffer_v5(struct s5p_mfc_ctx *ctx)
                 mfc_err("Unknown codec for decoding (%x)\n",
                         ctx->codec_mode);
                 return -EINVAL;
-                break;
         }
         frame_size = ctx->luma_size;
         frame_size_ch = ctx->chroma_size;
@@ -607,10 +546,10 @@ int s5p_mfc_set_enc_ref_buffer_v5(struct s5p_mfc_ctx *ctx)
         unsigned int guard_width, guard_height;
         int i;
 
-        buf_addr1 = ctx->bank1_phys;
-        buf_size1 = ctx->bank1_size;
-        buf_addr2 = ctx->bank2_phys;
-        buf_size2 = ctx->bank2_size;
+        buf_addr1 = ctx->bank1.dma;
+        buf_size1 = ctx->bank1.size;
+        buf_addr2 = ctx->bank2.dma;
+        buf_size2 = ctx->bank2.size;
         enc_ref_y_size = ALIGN(ctx->img_width, S5P_FIMV_NV12MT_HALIGN)
                 * ALIGN(ctx->img_height, S5P_FIMV_NV12MT_VALIGN);
         enc_ref_y_size = ALIGN(enc_ref_y_size, S5P_FIMV_NV12MT_SALIGN);
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c b/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c
index 3a8cfd9fc1bd..beb6dbacebd9 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_opr_v6.c
@@ -73,6 +73,7 @@ int s5p_mfc_alloc_codec_buffers_v6(struct s5p_mfc_ctx *ctx)
 {
         struct s5p_mfc_dev *dev = ctx->dev;
         unsigned int mb_width, mb_height;
+        int ret;
 
         mb_width = MB_WIDTH(ctx->img_width);
         mb_height = MB_HEIGHT(ctx->img_height);
@@ -112,7 +113,7 @@ int s5p_mfc_alloc_codec_buffers_v6(struct s5p_mfc_ctx *ctx)
                                         mb_height);
                 ctx->scratch_buf_size = ALIGN(ctx->scratch_buf_size,
                                 S5P_FIMV_SCRATCH_BUFFER_ALIGN_V6);
-                ctx->bank1_size =
+                ctx->bank1.size =
                         ctx->scratch_buf_size +
                         (ctx->mv_count * ctx->mv_size);
                 break;
@@ -123,7 +124,7 @@ int s5p_mfc_alloc_codec_buffers_v6(struct s5p_mfc_ctx *ctx)
                                         mb_height);
                 ctx->scratch_buf_size = ALIGN(ctx->scratch_buf_size,
                                 S5P_FIMV_SCRATCH_BUFFER_ALIGN_V6);
-                ctx->bank1_size = ctx->scratch_buf_size;
+                ctx->bank1.size = ctx->scratch_buf_size;
                 break;
         case S5P_MFC_CODEC_VC1RCV_DEC:
         case S5P_MFC_CODEC_VC1_DEC:
@@ -133,11 +134,11 @@ int s5p_mfc_alloc_codec_buffers_v6(struct s5p_mfc_ctx *ctx)
                                         mb_height);
                 ctx->scratch_buf_size = ALIGN(ctx->scratch_buf_size,
                                 S5P_FIMV_SCRATCH_BUFFER_ALIGN_V6);
-                ctx->bank1_size = ctx->scratch_buf_size;
+                ctx->bank1.size = ctx->scratch_buf_size;
                 break;
         case S5P_MFC_CODEC_MPEG2_DEC:
-                ctx->bank1_size = 0;
-                ctx->bank2_size = 0;
+                ctx->bank1.size = 0;
+                ctx->bank2.size = 0;
                 break;
         case S5P_MFC_CODEC_H263_DEC:
                 ctx->scratch_buf_size =
@@ -146,7 +147,7 @@ int s5p_mfc_alloc_codec_buffers_v6(struct s5p_mfc_ctx *ctx)
                                         mb_height);
                 ctx->scratch_buf_size = ALIGN(ctx->scratch_buf_size,
                                 S5P_FIMV_SCRATCH_BUFFER_ALIGN_V6);
-                ctx->bank1_size = ctx->scratch_buf_size;
+                ctx->bank1.size = ctx->scratch_buf_size;
                 break;
         case S5P_MFC_CODEC_VP8_DEC:
                 ctx->scratch_buf_size =
@@ -155,7 +156,7 @@ int s5p_mfc_alloc_codec_buffers_v6(struct s5p_mfc_ctx *ctx)
                                         mb_height);
                 ctx->scratch_buf_size = ALIGN(ctx->scratch_buf_size,
                                 S5P_FIMV_SCRATCH_BUFFER_ALIGN_V6);
-                ctx->bank1_size = ctx->scratch_buf_size;
+                ctx->bank1.size = ctx->scratch_buf_size;
                 break;
         case S5P_MFC_CODEC_H264_ENC:
                 ctx->scratch_buf_size =
@@ -164,11 +165,11 @@ int s5p_mfc_alloc_codec_buffers_v6(struct s5p_mfc_ctx *ctx)
                                         mb_height);
                 ctx->scratch_buf_size = ALIGN(ctx->scratch_buf_size,
                                 S5P_FIMV_SCRATCH_BUFFER_ALIGN_V6);
-                ctx->bank1_size =
+                ctx->bank1.size =
                         ctx->scratch_buf_size + ctx->tmv_buffer_size +
                         (ctx->dpb_count * (ctx->luma_dpb_size +
                         ctx->chroma_dpb_size + ctx->me_buffer_size));
-                ctx->bank2_size = 0;
+                ctx->bank2.size = 0;
                 break;
         case S5P_MFC_CODEC_MPEG4_ENC:
         case S5P_MFC_CODEC_H263_ENC:
@@ -178,28 +179,24 @@ int s5p_mfc_alloc_codec_buffers_v6(struct s5p_mfc_ctx *ctx)
                                         mb_height);
                 ctx->scratch_buf_size = ALIGN(ctx->scratch_buf_size,
                                 S5P_FIMV_SCRATCH_BUFFER_ALIGN_V6);
-                ctx->bank1_size =
+                ctx->bank1.size =
                         ctx->scratch_buf_size + ctx->tmv_buffer_size +
                         (ctx->dpb_count * (ctx->luma_dpb_size +
                         ctx->chroma_dpb_size + ctx->me_buffer_size));
-                ctx->bank2_size = 0;
+                ctx->bank2.size = 0;
                 break;
         default:
                 break;
         }
 
         /* Allocate only if memory from bank 1 is necessary */
-        if (ctx->bank1_size > 0) {
-                ctx->bank1_buf = vb2_dma_contig_memops.alloc(
-                dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], ctx->bank1_size);
-                if (IS_ERR(ctx->bank1_buf)) {
-                        ctx->bank1_buf = 0;
-                        pr_err("Buf alloc for decoding failed (port A)\n");
-                        return -ENOMEM;
+        if (ctx->bank1.size > 0) {
+                ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_l, &ctx->bank1);
+                if (ret) {
+                        mfc_err("Failed to allocate Bank1 memory\n");
+                        return ret;
                 }
-                ctx->bank1_phys = s5p_mfc_mem_cookie(
-                        dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], ctx->bank1_buf);
-                BUG_ON(ctx->bank1_phys & ((1 << MFC_BANK1_ALIGN_ORDER) - 1));
+                BUG_ON(ctx->bank1.dma & ((1 << MFC_BANK1_ALIGN_ORDER) - 1));
         }
 
         return 0;
@@ -208,12 +205,7 @@ int s5p_mfc_alloc_codec_buffers_v6(struct s5p_mfc_ctx *ctx)
 /* Release buffers allocated for codec */
 void s5p_mfc_release_codec_buffers_v6(struct s5p_mfc_ctx *ctx)
 {
-        if (ctx->bank1_buf) {
-                vb2_dma_contig_memops.put(ctx->bank1_buf);
-                ctx->bank1_buf = 0;
-                ctx->bank1_phys = 0;
-                ctx->bank1_size = 0;
-        }
+        s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->bank1);
 }
 
 /* Allocate memory for instance data buffer */
@@ -221,6 +213,7 @@ int s5p_mfc_alloc_instance_buffer_v6(struct s5p_mfc_ctx *ctx)
 {
         struct s5p_mfc_dev *dev = ctx->dev;
         struct s5p_mfc_buf_size_v6 *buf_size = dev->variant->buf_size->priv;
+        int ret;
 
         mfc_debug_enter();
 
@@ -250,25 +243,10 @@ int s5p_mfc_alloc_instance_buffer_v6(struct s5p_mfc_ctx *ctx)
                 break;
         }
 
-        ctx->ctx.alloc = vb2_dma_contig_memops.alloc(
-                dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], ctx->ctx.size);
-        if (IS_ERR(ctx->ctx.alloc)) {
-                mfc_err("Allocating context buffer failed.\n");
-                return PTR_ERR(ctx->ctx.alloc);
-        }
-
-        ctx->ctx.dma = s5p_mfc_mem_cookie(
-                dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], ctx->ctx.alloc);
-
-        ctx->ctx.virt = vb2_dma_contig_memops.vaddr(ctx->ctx.alloc);
-        if (!ctx->ctx.virt) {
-                vb2_dma_contig_memops.put(ctx->ctx.alloc);
-                ctx->ctx.alloc = NULL;
-                ctx->ctx.dma = 0;
-                ctx->ctx.virt = NULL;
-
-                mfc_err("Remapping context buffer failed.\n");
-                return -ENOMEM;
+        ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_l, &ctx->ctx);
+        if (ret) {
+                mfc_err("Failed to allocate instance buffer\n");
+                return ret;
         }
 
         memset(ctx->ctx.virt, 0, ctx->ctx.size);
@@ -282,44 +260,22 @@ int s5p_mfc_alloc_instance_buffer_v6(struct s5p_mfc_ctx *ctx)
 /* Release instance buffer */
 void s5p_mfc_release_instance_buffer_v6(struct s5p_mfc_ctx *ctx)
 {
-        mfc_debug_enter();
-
-        if (ctx->ctx.alloc) {
-                vb2_dma_contig_memops.put(ctx->ctx.alloc);
-                ctx->ctx.alloc = NULL;
-                ctx->ctx.dma = 0;
-                ctx->ctx.virt = NULL;
-        }
-
-        mfc_debug_leave();
+        s5p_mfc_release_priv_buf(ctx->dev->mem_dev_l, &ctx->ctx);
 }
 
 /* Allocate context buffers for SYS_INIT */
 int s5p_mfc_alloc_dev_context_buffer_v6(struct s5p_mfc_dev *dev)
 {
         struct s5p_mfc_buf_size_v6 *buf_size = dev->variant->buf_size->priv;
+        int ret;
 
         mfc_debug_enter();
 
-        dev->ctx_buf.alloc = vb2_dma_contig_memops.alloc(
-                        dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], buf_size->dev_ctx);
-        if (IS_ERR(dev->ctx_buf.alloc)) {
-                mfc_err("Allocating DESC buffer failed.\n");
-                return PTR_ERR(dev->ctx_buf.alloc);
-        }
-
-        dev->ctx_buf.dma = s5p_mfc_mem_cookie(
-                        dev->alloc_ctx[MFC_BANK1_ALLOC_CTX],
-                        dev->ctx_buf.alloc);
-
-        dev->ctx_buf.virt = vb2_dma_contig_memops.vaddr(dev->ctx_buf.alloc);
-        if (!dev->ctx_buf.virt) {
-                vb2_dma_contig_memops.put(dev->ctx_buf.alloc);
-                dev->ctx_buf.alloc = NULL;
-                dev->ctx_buf.dma = 0;
-
-                mfc_err("Remapping DESC buffer failed.\n");
-                return -ENOMEM;
+        dev->ctx_buf.size = buf_size->dev_ctx;
+        ret = s5p_mfc_alloc_priv_buf(dev->mem_dev_l, &dev->ctx_buf);
+        if (ret) {
+                mfc_err("Failed to allocate device context buffer\n");
+                return ret;
         }
 
         memset(dev->ctx_buf.virt, 0, buf_size->dev_ctx);
@@ -333,12 +289,7 @@ int s5p_mfc_alloc_dev_context_buffer_v6(struct s5p_mfc_dev *dev)
 /* Release context buffers for SYS_INIT */
 void s5p_mfc_release_dev_context_buffer_v6(struct s5p_mfc_dev *dev)
 {
-        if (dev->ctx_buf.alloc) {
-                vb2_dma_contig_memops.put(dev->ctx_buf.alloc);
-                dev->ctx_buf.alloc = NULL;
-                dev->ctx_buf.dma = 0;
-                dev->ctx_buf.virt = NULL;
-        }
+        s5p_mfc_release_priv_buf(dev->mem_dev_l, &dev->ctx_buf);
 }
 
 static int calc_plane(int width, int height)
@@ -417,8 +368,8 @@ int s5p_mfc_set_dec_frame_buffer_v6(struct s5p_mfc_ctx *ctx)
         int buf_size1;
         int align_gap;
 
-        buf_addr1 = ctx->bank1_phys;
-        buf_size1 = ctx->bank1_size;
+        buf_addr1 = ctx->bank1.dma;
+        buf_size1 = ctx->bank1.size;
 
         mfc_debug(2, "Buf1: %p (%d)\n", (void *)buf_addr1, buf_size1);
         mfc_debug(2, "Total DPB COUNT: %d\n", ctx->total_dpb_count);
@@ -535,13 +486,13 @@ void s5p_mfc_get_enc_frame_buffer_v6(struct s5p_mfc_ctx *ctx,
 int s5p_mfc_set_enc_ref_buffer_v6(struct s5p_mfc_ctx *ctx)
 {
         struct s5p_mfc_dev *dev = ctx->dev;
-        size_t buf_addr1, buf_size1;
-        int i;
+        size_t buf_addr1;
+        int i, buf_size1;
 
         mfc_debug_enter();
 
-        buf_addr1 = ctx->bank1_phys;
-        buf_size1 = ctx->bank1_size;
+        buf_addr1 = ctx->bank1.dma;
+        buf_size1 = ctx->bank1.size;
 
         mfc_debug(2, "Buf1: %p (%d)\n", (void *)buf_addr1, buf_size1);
 
@@ -1253,12 +1204,14 @@ int s5p_mfc_init_decode_v6(struct s5p_mfc_ctx *ctx)
 static inline void s5p_mfc_set_flush(struct s5p_mfc_ctx *ctx, int flush)
 {
         struct s5p_mfc_dev *dev = ctx->dev;
-        unsigned int dpb;
-        if (flush)
-                dpb = READL(S5P_FIMV_SI_CH0_DPB_CONF_CTRL) | (1 << 14);
-        else
-                dpb = READL(S5P_FIMV_SI_CH0_DPB_CONF_CTRL) & ~(1 << 14);
-        WRITEL(dpb, S5P_FIMV_SI_CH0_DPB_CONF_CTRL);
+
+        if (flush) {
+                dev->curr_ctx = ctx->num;
+                s5p_mfc_clean_ctx_int_flags(ctx);
+                WRITEL(ctx->inst_no, S5P_FIMV_INSTANCE_ID_V6);
+                s5p_mfc_hw_call(dev->mfc_cmds, cmd_host2risc, dev,
+                                S5P_FIMV_H2R_CMD_FLUSH_V6, NULL);
+        }
 }
 
 /* Decode a single frame */
@@ -1408,7 +1361,6 @@ static inline int s5p_mfc_run_dec_frame(struct s5p_mfc_ctx *ctx)
         struct s5p_mfc_buf *temp_vb;
         unsigned long flags;
         int last_frame = 0;
-        unsigned int index;
 
         spin_lock_irqsave(&dev->irqlock, flags);
 
@@ -1427,8 +1379,6 @@ static inline int s5p_mfc_run_dec_frame(struct s5p_mfc_ctx *ctx)
                         temp_vb->b->v4l2_planes[0].bytesused);
         spin_unlock_irqrestore(&dev->irqlock, flags);
 
-        index = temp_vb->b->v4l2_buf.index;
-
         dev->curr_ctx = ctx->num;
         s5p_mfc_clean_ctx_int_flags(ctx);
         if (temp_vb->b->v4l2_planes[0].bytesused == 0) {
@@ -1452,7 +1402,6 @@ static inline int s5p_mfc_run_enc_frame(struct s5p_mfc_ctx *ctx)
         unsigned int src_y_size, src_c_size;
         */
         unsigned int dst_size;
-        unsigned int index;
 
         spin_lock_irqsave(&dev->irqlock, flags);
 
@@ -1487,8 +1436,6 @@ static inline int s5p_mfc_run_enc_frame(struct s5p_mfc_ctx *ctx)
 
         spin_unlock_irqrestore(&dev->irqlock, flags);
 
-        index = src_mb->b->v4l2_buf.index;
-
         dev->curr_ctx = ctx->num;
         s5p_mfc_clean_ctx_int_flags(ctx);
         s5p_mfc_encode_one_frame_v6(ctx);
@@ -1656,6 +1603,9 @@ void s5p_mfc_try_run_v6(struct s5p_mfc_dev *dev)
                 case MFCINST_HEAD_PARSED:
                         ret = s5p_mfc_run_init_dec_buffers(ctx);
                         break;
+                case MFCINST_FLUSH:
+                        s5p_mfc_set_flush(ctx, ctx->dpb_flush_flag);
+                        break;
                 case MFCINST_RES_CHANGE_INIT:
                         s5p_mfc_run_dec_last_frames(ctx);
                         break;
diff --git a/drivers/media/platform/s5p-mfc/s5p_mfc_pm.c b/drivers/media/platform/s5p-mfc/s5p_mfc_pm.c
index 2895333866fc..6aa38a56aaf2 100644
--- a/drivers/media/platform/s5p-mfc/s5p_mfc_pm.c
+++ b/drivers/media/platform/s5p-mfc/s5p_mfc_pm.c
@@ -46,7 +46,7 @@ int s5p_mfc_init_pm(struct s5p_mfc_dev *dev)
 
         ret = clk_prepare(pm->clock_gate);
         if (ret) {
-                mfc_err("Failed to preapre clock-gating control\n");
+                mfc_err("Failed to prepare clock-gating control\n");
                 goto err_p_ip_clk;
         }
 
diff --git a/drivers/media/platform/s5p-tv/hdmi_drv.c b/drivers/media/platform/s5p-tv/hdmi_drv.c
index 7c1116c73bf3..8de1b3dce459 100644
--- a/drivers/media/platform/s5p-tv/hdmi_drv.c
+++ b/drivers/media/platform/s5p-tv/hdmi_drv.c
@@ -656,7 +656,7 @@ static int hdmi_g_mbus_fmt(struct v4l2_subdev *sd,
         dev_dbg(hdev->dev, "%s\n", __func__);
         if (!hdev->cur_conf)
                 return -EINVAL;
-        memset(fmt, 0, sizeof *fmt);
+        memset(fmt, 0, sizeof(*fmt));
         fmt->width = t->hact.end - t->hact.beg;
         fmt->height = t->vact[0].end - t->vact[0].beg;
         fmt->code = V4L2_MBUS_FMT_FIXED; /* means RGB888 */
@@ -760,7 +760,7 @@ static void hdmi_resources_cleanup(struct hdmi_device *hdev)
                 clk_put(res->sclk_hdmi);
         if (!IS_ERR_OR_NULL(res->hdmi))
                 clk_put(res->hdmi);
-        memset(res, 0, sizeof *res);
+        memset(res, 0, sizeof(*res));
 }
 
 static int hdmi_resources_init(struct hdmi_device *hdev)
@@ -777,31 +777,31 @@ static int hdmi_resources_init(struct hdmi_device *hdev)
 
         dev_dbg(dev, "HDMI resource init\n");
 
-        memset(res, 0, sizeof *res);
+        memset(res, 0, sizeof(*res));
         /* get clocks, power */
 
         res->hdmi = clk_get(dev, "hdmi");
-        if (IS_ERR_OR_NULL(res->hdmi)) {
+        if (IS_ERR(res->hdmi)) {
                 dev_err(dev, "failed to get clock 'hdmi'\n");
                 goto fail;
         }
         res->sclk_hdmi = clk_get(dev, "sclk_hdmi");
-        if (IS_ERR_OR_NULL(res->sclk_hdmi)) {
+        if (IS_ERR(res->sclk_hdmi)) {
                 dev_err(dev, "failed to get clock 'sclk_hdmi'\n");
                 goto fail;
         }
         res->sclk_pixel = clk_get(dev, "sclk_pixel");
-        if (IS_ERR_OR_NULL(res->sclk_pixel)) {
+        if (IS_ERR(res->sclk_pixel)) {
                 dev_err(dev, "failed to get clock 'sclk_pixel'\n");
                 goto fail;
         }
         res->sclk_hdmiphy = clk_get(dev, "sclk_hdmiphy");
-        if (IS_ERR_OR_NULL(res->sclk_hdmiphy)) {
+        if (IS_ERR(res->sclk_hdmiphy)) {
                 dev_err(dev, "failed to get clock 'sclk_hdmiphy'\n");
                 goto fail;
         }
         res->hdmiphy = clk_get(dev, "hdmiphy");
-        if (IS_ERR_OR_NULL(res->hdmiphy)) {
+        if (IS_ERR(res->hdmiphy)) {
                 dev_err(dev, "failed to get clock 'hdmiphy'\n");
                 goto fail;
         }
@@ -955,7 +955,7 @@ static int hdmi_probe(struct platform_device *pdev)
         v4l2_subdev_init(sd, &hdmi_sd_ops);
         sd->owner = THIS_MODULE;
 
-        strlcpy(sd->name, "s5p-hdmi", sizeof sd->name);
+        strlcpy(sd->name, "s5p-hdmi", sizeof(sd->name));
         hdmi_dev->cur_preset = HDMI_DEFAULT_PRESET;
         /* FIXME: missing fail preset is not supported */
         hdmi_dev->cur_conf = hdmi_preset2timings(hdmi_dev->cur_preset);
diff --git a/drivers/media/platform/s5p-tv/hdmiphy_drv.c b/drivers/media/platform/s5p-tv/hdmiphy_drv.c
index 06b5d2dbb2d9..80717cec76ae 100644
--- a/drivers/media/platform/s5p-tv/hdmiphy_drv.c
+++ b/drivers/media/platform/s5p-tv/hdmiphy_drv.c
@@ -284,7 +284,7 @@ static int hdmiphy_probe(struct i2c_client *client,
 {
         struct hdmiphy_ctx *ctx;
 
-        ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
+        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
         if (!ctx)
                 return -ENOMEM;
 
diff --git a/drivers/media/platform/s5p-tv/mixer.h b/drivers/media/platform/s5p-tv/mixer.h
index b671e20e9318..04e6490a45be 100644
--- a/drivers/media/platform/s5p-tv/mixer.h
+++ b/drivers/media/platform/s5p-tv/mixer.h
@@ -19,6 +19,7 @@
 #endif
 
 #include <linux/fb.h>
+#include <linux/irqreturn.h>
 #include <linux/kernel.h>
 #include <linux/spinlock.h>
 #include <linux/wait.h>
diff --git a/drivers/media/platform/s5p-tv/mixer_drv.c b/drivers/media/platform/s5p-tv/mixer_drv.c
index 02faea03aa7d..5733033a6ead 100644
--- a/drivers/media/platform/s5p-tv/mixer_drv.c
+++ b/drivers/media/platform/s5p-tv/mixer_drv.c
@@ -240,27 +240,27 @@ static int mxr_acquire_clocks(struct mxr_device *mdev)
         struct device *dev = mdev->dev;
 
         res->mixer = clk_get(dev, "mixer");
-        if (IS_ERR_OR_NULL(res->mixer)) {
+        if (IS_ERR(res->mixer)) {
                 mxr_err(mdev, "failed to get clock 'mixer'\n");
                 goto fail;
         }
         res->vp = clk_get(dev, "vp");
-        if (IS_ERR_OR_NULL(res->vp)) {
+        if (IS_ERR(res->vp)) {
                 mxr_err(mdev, "failed to get clock 'vp'\n");
                 goto fail;
         }
         res->sclk_mixer = clk_get(dev, "sclk_mixer");
-        if (IS_ERR_OR_NULL(res->sclk_mixer)) {
+        if (IS_ERR(res->sclk_mixer)) {
                 mxr_err(mdev, "failed to get clock 'sclk_mixer'\n");
                 goto fail;
         }
         res->sclk_hdmi = clk_get(dev, "sclk_hdmi");
-        if (IS_ERR_OR_NULL(res->sclk_hdmi)) {
+        if (IS_ERR(res->sclk_hdmi)) {
                 mxr_err(mdev, "failed to get clock 'sclk_hdmi'\n");
                 goto fail;
         }
         res->sclk_dac = clk_get(dev, "sclk_dac");
-        if (IS_ERR_OR_NULL(res->sclk_dac)) {
+        if (IS_ERR(res->sclk_dac)) {
                 mxr_err(mdev, "failed to get clock 'sclk_dac'\n");
                 goto fail;
         }
@@ -298,7 +298,7 @@ static void mxr_release_resources(struct mxr_device *mdev)
 {
         mxr_release_clocks(mdev);
         mxr_release_plat_resources(mdev);
-        memset(&mdev->res, 0, sizeof mdev->res);
+        memset(&mdev->res, 0, sizeof(mdev->res));
 }
 
 static void mxr_release_layers(struct mxr_device *mdev)
@@ -382,7 +382,7 @@ static int mxr_probe(struct platform_device *pdev)
         /* mdev does not exist yet so no mxr_dbg is used */
         dev_info(dev, "probe start\n");
 
-        mdev = kzalloc(sizeof *mdev, GFP_KERNEL);
+        mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
         if (!mdev) {
                 dev_err(dev, "not enough memory.\n");
                 ret = -ENOMEM;
diff --git a/drivers/media/platform/s5p-tv/mixer_reg.c b/drivers/media/platform/s5p-tv/mixer_reg.c
index 3b1670a045f4..b713403024ef 100644
--- a/drivers/media/platform/s5p-tv/mixer_reg.c
+++ b/drivers/media/platform/s5p-tv/mixer_reg.c
@@ -470,11 +470,11 @@ static inline void mxr_reg_vp_filter_set(struct mxr_device *mdev,
 static void mxr_reg_vp_default_filter(struct mxr_device *mdev)
 {
         mxr_reg_vp_filter_set(mdev, VP_POLY8_Y0_LL,
-                filter_y_horiz_tap8, sizeof filter_y_horiz_tap8);
+                filter_y_horiz_tap8, sizeof(filter_y_horiz_tap8));
         mxr_reg_vp_filter_set(mdev, VP_POLY4_Y0_LL,
-                filter_y_vert_tap4, sizeof filter_y_vert_tap4);
+                filter_y_vert_tap4, sizeof(filter_y_vert_tap4));
         mxr_reg_vp_filter_set(mdev, VP_POLY4_C0_LL,
-                filter_cr_horiz_tap4, sizeof filter_cr_horiz_tap4);
+                filter_cr_horiz_tap4, sizeof(filter_cr_horiz_tap4));
 }
 
 static void mxr_reg_mxr_dump(struct mxr_device *mdev)
diff --git a/drivers/media/platform/s5p-tv/mixer_video.c b/drivers/media/platform/s5p-tv/mixer_video.c
index 1f3b7436511c..82142a2d6d93 100644
--- a/drivers/media/platform/s5p-tv/mixer_video.c
+++ b/drivers/media/platform/s5p-tv/mixer_video.c
@@ -19,6 +19,7 @@
 #include <linux/videodev2.h>
 #include <linux/mm.h>
 #include <linux/module.h>
+#include <linux/platform_device.h>
 #include <linux/timer.h>
 #include <media/videobuf2-dma-contig.h>
 
@@ -95,7 +96,7 @@ int mxr_acquire_video(struct mxr_device *mdev,
                 /* trying to register next output */
                 if (sd == NULL)
                         continue;
-                out = kzalloc(sizeof *out, GFP_KERNEL);
+                out = kzalloc(sizeof(*out), GFP_KERNEL);
                 if (out == NULL) {
                         mxr_err(mdev, "no memory for '%s'\n",
                                 conf->output_name);
@@ -127,7 +128,7 @@ fail_output:
         /* kfree is NULL-safe */
         for (i = 0; i < mdev->output_cnt; ++i)
                 kfree(mdev->output[i]);
-        memset(mdev->output, 0, sizeof mdev->output);
+        memset(mdev->output, 0, sizeof(mdev->output));
 
 fail_vb2_allocator:
         /* freeing allocator context */
@@ -160,8 +161,8 @@ static int mxr_querycap(struct file *file, void *priv,
 
         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
 
-        strlcpy(cap->driver, MXR_DRIVER_NAME, sizeof cap->driver);
-        strlcpy(cap->card, layer->vfd.name, sizeof cap->card);
+        strlcpy(cap->driver, MXR_DRIVER_NAME, sizeof(cap->driver));
+        strlcpy(cap->card, layer->vfd.name, sizeof(cap->card));
         sprintf(cap->bus_info, "%d", layer->idx);
         cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_OUTPUT_MPLANE;
         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
@@ -192,7 +193,7 @@ static void mxr_layer_default_geo(struct mxr_layer *layer)
         struct mxr_device *mdev = layer->mdev;
         struct v4l2_mbus_framefmt mbus_fmt;
 
-        memset(&layer->geo, 0, sizeof layer->geo);
+        memset(&layer->geo, 0, sizeof(layer->geo));
 
         mxr_get_mbus_fmt(mdev, &mbus_fmt);
 
@@ -425,7 +426,7 @@ static int mxr_s_selection(struct file *file, void *fh,
         struct mxr_geometry tmp;
         struct v4l2_rect res;
 
-        memset(&res, 0, sizeof res);
+        memset(&res, 0, sizeof(res));
 
         mxr_dbg(layer->mdev, "%s: rect: %dx%d@%d,%d\n", __func__,
                 s->r.width, s->r.height, s->r.left, s->r.top);
@@ -464,7 +465,7 @@ static int mxr_s_selection(struct file *file, void *fh,
         /* apply change and update geometry if needed */
         if (target) {
                 /* backup current geometry if setup fails */
-                memcpy(&tmp, geo, sizeof tmp);
+                memcpy(&tmp, geo, sizeof(tmp));
 
                 /* apply requested selection */
                 target->x_offset = s->r.left;
@@ -496,7 +497,7 @@ static int mxr_s_selection(struct file *file, void *fh,
 fail:
         /* restore old geometry, which is not touched if target is NULL */
         if (target)
-                memcpy(geo, &tmp, sizeof tmp);
+                memcpy(geo, &tmp, sizeof(tmp));
         return -ERANGE;
 }
 
@@ -1071,7 +1072,7 @@ struct mxr_layer *mxr_base_layer_create(struct mxr_device *mdev,
 {
         struct mxr_layer *layer;
 
-        layer = kzalloc(sizeof *layer, GFP_KERNEL);
+        layer = kzalloc(sizeof(*layer), GFP_KERNEL);
         if (layer == NULL) {
                 mxr_err(mdev, "not enough memory for layer.\n");
                 goto fail;
diff --git a/drivers/media/platform/s5p-tv/sdo_drv.c b/drivers/media/platform/s5p-tv/sdo_drv.c
index 91a6939a270a..ab6f9ef89423 100644
--- a/drivers/media/platform/s5p-tv/sdo_drv.c
+++ b/drivers/media/platform/s5p-tv/sdo_drv.c
@@ -301,7 +301,7 @@ static int sdo_probe(struct platform_device *pdev)
         struct clk *sclk_vpll;
 
         dev_info(dev, "probe start\n");
-        sdev = devm_kzalloc(&pdev->dev, sizeof *sdev, GFP_KERNEL);
+        sdev = devm_kzalloc(&pdev->dev, sizeof(*sdev), GFP_KERNEL);
         if (!sdev) {
                 dev_err(dev, "not enough memory.\n");
                 ret = -ENOMEM;
@@ -341,47 +341,50 @@ static int sdo_probe(struct platform_device *pdev)
 
         /* acquire clocks */
         sdev->sclk_dac = clk_get(dev, "sclk_dac");
-        if (IS_ERR_OR_NULL(sdev->sclk_dac)) {
+        if (IS_ERR(sdev->sclk_dac)) {
                 dev_err(dev, "failed to get clock 'sclk_dac'\n");
-                ret = -ENXIO;
+                ret = PTR_ERR(sdev->sclk_dac);
                 goto fail;
         }
         sdev->dac = clk_get(dev, "dac");
-        if (IS_ERR_OR_NULL(sdev->dac)) {
+        if (IS_ERR(sdev->dac)) {
                 dev_err(dev, "failed to get clock 'dac'\n");
-                ret = -ENXIO;
+                ret = PTR_ERR(sdev->dac);
                 goto fail_sclk_dac;
         }
         sdev->dacphy = clk_get(dev, "dacphy");
-        if (IS_ERR_OR_NULL(sdev->dacphy)) {
+        if (IS_ERR(sdev->dacphy)) {
                 dev_err(dev, "failed to get clock 'dacphy'\n");
-                ret = -ENXIO;
+                ret = PTR_ERR(sdev->dacphy);
                 goto fail_dac;
         }
         sclk_vpll = clk_get(dev, "sclk_vpll");
-        if (IS_ERR_OR_NULL(sclk_vpll)) {
+        if (IS_ERR(sclk_vpll)) {
                 dev_err(dev, "failed to get clock 'sclk_vpll'\n");
-                ret = -ENXIO;
+                ret = PTR_ERR(sclk_vpll);
                 goto fail_dacphy;
         }
         clk_set_parent(sdev->sclk_dac, sclk_vpll);
         clk_put(sclk_vpll);
         sdev->fout_vpll = clk_get(dev, "fout_vpll");
-        if (IS_ERR_OR_NULL(sdev->fout_vpll)) {
+        if (IS_ERR(sdev->fout_vpll)) {
                 dev_err(dev, "failed to get clock 'fout_vpll'\n");
+                ret = PTR_ERR(sdev->fout_vpll);
                 goto fail_dacphy;
         }
         dev_info(dev, "fout_vpll.rate = %lu\n", clk_get_rate(sclk_vpll));
 
         /* acquire regulator */
         sdev->vdac = devm_regulator_get(dev, "vdd33a_dac");
-        if (IS_ERR_OR_NULL(sdev->vdac)) {
+        if (IS_ERR(sdev->vdac)) {
                 dev_err(dev, "failed to get regulator 'vdac'\n");
+                ret = PTR_ERR(sdev->vdac);
                 goto fail_fout_vpll;
         }
         sdev->vdet = devm_regulator_get(dev, "vdet");
-        if (IS_ERR_OR_NULL(sdev->vdet)) {
+        if (IS_ERR(sdev->vdet)) {
                 dev_err(dev, "failed to get regulator 'vdet'\n");
+                ret = PTR_ERR(sdev->vdet);
                 goto fail_fout_vpll;
         }
 
@@ -394,7 +397,7 @@ static int sdo_probe(struct platform_device *pdev)
         /* configuration of interface subdevice */
         v4l2_subdev_init(&sdev->sd, &sdo_sd_ops);
         sdev->sd.owner = THIS_MODULE;
-        strlcpy(sdev->sd.name, "s5p-sdo", sizeof sdev->sd.name);
+        strlcpy(sdev->sd.name, "s5p-sdo", sizeof(sdev->sd.name));
 
         /* set default format */
         sdev->fmt = sdo_find_format(SDO_DEFAULT_STD);
diff --git a/drivers/media/platform/s5p-tv/sii9234_drv.c b/drivers/media/platform/s5p-tv/sii9234_drv.c
index 49191aac9634..d90d2286090b 100644
--- a/drivers/media/platform/s5p-tv/sii9234_drv.c
+++ b/drivers/media/platform/s5p-tv/sii9234_drv.c
@@ -338,7 +338,7 @@ static int sii9234_probe(struct i2c_client *client,
         }
 
         ctx->gpio_n_reset = pdata->gpio_n_reset;
-        ret = gpio_request(ctx->gpio_n_reset, "MHL_RST");
+        ret = devm_gpio_request(dev, ctx->gpio_n_reset, "MHL_RST");
         if (ret) {
                 dev_err(dev, "failed to acquire MHL_RST gpio\n");
                 return ret;
@@ -370,7 +370,6 @@ fail_pm_get:
 
 fail_pm:
         pm_runtime_disable(dev);
-        gpio_free(ctx->gpio_n_reset);
 
 fail:
         dev_err(dev, "probe failed\n");
@@ -381,11 +380,8 @@ fail:
 static int sii9234_remove(struct i2c_client *client)
 {
         struct device *dev = &client->dev;
-        struct v4l2_subdev *sd = i2c_get_clientdata(client);
-        struct sii9234_context *ctx = sd_to_context(sd);
 
         pm_runtime_disable(dev);
-        gpio_free(ctx->gpio_n_reset);
 
         dev_info(dev, "remove successful\n");
 
diff --git a/drivers/media/platform/sh_veu.c b/drivers/media/platform/sh_veu.c
new file mode 100644
index 000000000000..cb54c69d5748
--- /dev/null
+++ b/drivers/media/platform/sh_veu.c
@@ -0,0 +1,1266 @@
+/*
+ * sh-mobile VEU mem2mem driver
+ *
+ * Copyright (C) 2012 Renesas Electronics Corporation
+ * Author: Guennadi Liakhovetski, <g.liakhovetski@gmx.de>
+ * Copyright (C) 2008 Magnus Damm
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the version 2 of the GNU General Public License as
+ * published by the Free Software Foundation
+ */
+
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/videodev2.h>
+
+#include <media/v4l2-dev.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-ioctl.h>
+#include <media/v4l2-mem2mem.h>
+#include <media/videobuf2-dma-contig.h>
+
+#define VEU_STR 0x00 /* start register */
+#define VEU_SWR 0x10 /* src: line length */
+#define VEU_SSR 0x14 /* src: image size */
+#define VEU_SAYR 0x18 /* src: y/rgb plane address */
+#define VEU_SACR 0x1c /* src: c plane address */
+#define VEU_BSSR 0x20 /* bundle mode register */
+#define VEU_EDWR 0x30 /* dst: line length */
+#define VEU_DAYR 0x34 /* dst: y/rgb plane address */
+#define VEU_DACR 0x38 /* dst: c plane address */
+#define VEU_TRCR 0x50 /* transform control */
+#define VEU_RFCR 0x54 /* resize scale */
+#define VEU_RFSR 0x58 /* resize clip */
+#define VEU_ENHR 0x5c /* enhance */
+#define VEU_FMCR 0x70 /* filter mode */
+#define VEU_VTCR 0x74 /* lowpass vertical */
+#define VEU_HTCR 0x78 /* lowpass horizontal */
+#define VEU_APCR 0x80 /* color match */
+#define VEU_ECCR 0x84 /* color replace */
+#define VEU_AFXR 0x90 /* fixed mode */
+#define VEU_SWPR 0x94 /* swap */
+#define VEU_EIER 0xa0 /* interrupt mask */
+#define VEU_EVTR 0xa4 /* interrupt event */
+#define VEU_STAR 0xb0 /* status */
+#define VEU_BSRR 0xb4 /* reset */
+
+#define VEU_MCR00 0x200 /* color conversion matrix coefficient 00 */
+#define VEU_MCR01 0x204 /* color conversion matrix coefficient 01 */
+#define VEU_MCR02 0x208 /* color conversion matrix coefficient 02 */
+#define VEU_MCR10 0x20c /* color conversion matrix coefficient 10 */
+#define VEU_MCR11 0x210 /* color conversion matrix coefficient 11 */
+#define VEU_MCR12 0x214 /* color conversion matrix coefficient 12 */
+#define VEU_MCR20 0x218 /* color conversion matrix coefficient 20 */
+#define VEU_MCR21 0x21c /* color conversion matrix coefficient 21 */
+#define VEU_MCR22 0x220 /* color conversion matrix coefficient 22 */
+#define VEU_COFFR 0x224 /* color conversion offset */
+#define VEU_CBR   0x228 /* color conversion clip */
+
+/*
+ * 4092x4092 max size is the normal case. In some cases it can be reduced to
+ * 2048x2048, in other cases it can be 4092x8188 or even 8188x8188.
+ */
+#define MAX_W 4092
+#define MAX_H 4092
+#define MIN_W 8
+#define MIN_H 8
+#define ALIGN_W 4
+
+/* 3 buffers of 2048 x 1536 - 3 megapixels @ 16bpp */
+#define VIDEO_MEM_LIMIT ALIGN(2048 * 1536 * 2 * 3, 1024 * 1024)
+
+#define MEM2MEM_DEF_TRANSLEN 1
+
+struct sh_veu_dev;
+
+struct sh_veu_file {
+        struct sh_veu_dev *veu_dev;
+        bool cfg_needed;
+};
+
+struct sh_veu_format {
+        char *name;
+        u32 fourcc;
+        unsigned int depth;
+        unsigned int ydepth;
+};
+
+/* video data format */
+struct sh_veu_vfmt {
+        /* Replace with v4l2_rect */
+        struct v4l2_rect                frame;
+        unsigned int                    bytesperline;
+        unsigned int                    offset_y;
+        unsigned int                    offset_c;
+        const struct sh_veu_format      *fmt;
+};
+
+struct sh_veu_dev {
+        struct v4l2_device v4l2_dev;
+        struct video_device vdev;
+        struct v4l2_m2m_dev *m2m_dev;
+        struct device *dev;
+        struct v4l2_m2m_ctx *m2m_ctx;
+        struct sh_veu_vfmt vfmt_out;
+        struct sh_veu_vfmt vfmt_in;
+        /* Only single user per direction so far */
+        struct sh_veu_file *capture;
+        struct sh_veu_file *output;
+        struct mutex fop_lock;
+        void __iomem *base;
+        struct vb2_alloc_ctx *alloc_ctx;
+        spinlock_t lock;
+        bool is_2h;
+        unsigned int xaction;
+        bool aborting;
+};
+
+enum sh_veu_fmt_idx {
+        SH_VEU_FMT_NV12,
+        SH_VEU_FMT_NV16,
+        SH_VEU_FMT_NV24,
+        SH_VEU_FMT_RGB332,
+        SH_VEU_FMT_RGB444,
+        SH_VEU_FMT_RGB565,
+        SH_VEU_FMT_RGB666,
+        SH_VEU_FMT_RGB24,
+};
+
+#define VGA_WIDTH       640
+#define VGA_HEIGHT      480
+
+#define DEFAULT_IN_WIDTH        VGA_WIDTH
+#define DEFAULT_IN_HEIGHT       VGA_HEIGHT
+#define DEFAULT_IN_FMTIDX       SH_VEU_FMT_NV12
+#define DEFAULT_OUT_WIDTH       VGA_WIDTH
+#define DEFAULT_OUT_HEIGHT      VGA_HEIGHT
+#define DEFAULT_OUT_FMTIDX      SH_VEU_FMT_RGB565
+
+/*
+ * Alignment: Y-plane should be 4-byte aligned for NV12 and NV16, and 8-byte
+ * aligned for NV24.
+ */
+static const struct sh_veu_format sh_veu_fmt[] = {
+        [SH_VEU_FMT_NV12]   = { .ydepth = 8, .depth = 12, .name = "NV12", .fourcc = V4L2_PIX_FMT_NV12 },
+        [SH_VEU_FMT_NV16]   = { .ydepth = 8, .depth = 16, .name = "NV16", .fourcc = V4L2_PIX_FMT_NV16 },
+        [SH_VEU_FMT_NV24]   = { .ydepth = 8, .depth = 24, .name = "NV24", .fourcc = V4L2_PIX_FMT_NV24 },
+        [SH_VEU_FMT_RGB332] = { .ydepth = 8, .depth = 8, .name = "RGB332", .fourcc = V4L2_PIX_FMT_RGB332 },
+        [SH_VEU_FMT_RGB444] = { .ydepth = 16, .depth = 16, .name = "RGB444", .fourcc = V4L2_PIX_FMT_RGB444 },
+        [SH_VEU_FMT_RGB565] = { .ydepth = 16, .depth = 16, .name = "RGB565", .fourcc = V4L2_PIX_FMT_RGB565 },
+        [SH_VEU_FMT_RGB666] = { .ydepth = 32, .depth = 32, .name = "BGR666", .fourcc = V4L2_PIX_FMT_BGR666 },
+        [SH_VEU_FMT_RGB24]  = { .ydepth = 24, .depth = 24, .name = "RGB24", .fourcc = V4L2_PIX_FMT_RGB24 },
+};
+
+#define DEFAULT_IN_VFMT (struct sh_veu_vfmt){                                           \
+        .frame = {                                                                      \
+                .width = VGA_WIDTH,                                                     \
+                .height = VGA_HEIGHT,                                                   \
+        },                                                                              \
+        .bytesperline = (VGA_WIDTH * sh_veu_fmt[DEFAULT_IN_FMTIDX].ydepth) >> 3,        \
+        .fmt = &sh_veu_fmt[DEFAULT_IN_FMTIDX],                                          \
+}
+
+#define DEFAULT_OUT_VFMT (struct sh_veu_vfmt){                                          \
+        .frame = {                                                                      \
+                .width = VGA_WIDTH,                                                     \
+                .height = VGA_HEIGHT,                                                   \
+        },                                                                              \
+        .bytesperline = (VGA_WIDTH * sh_veu_fmt[DEFAULT_OUT_FMTIDX].ydepth) >> 3,       \
+        .fmt = &sh_veu_fmt[DEFAULT_OUT_FMTIDX],                                         \
+}
+
+/*
+ * TODO: add support for further output formats:
+ *      SH_VEU_FMT_NV12,
+ *      SH_VEU_FMT_NV16,
+ *      SH_VEU_FMT_NV24,
+ *      SH_VEU_FMT_RGB332,
+ *      SH_VEU_FMT_RGB444,
+ *      SH_VEU_FMT_RGB666,
+ *      SH_VEU_FMT_RGB24,
+ */
+
+static const int sh_veu_fmt_out[] = {
+        SH_VEU_FMT_RGB565,
+};
+
+/*
+ * TODO: add support for further input formats:
+ *      SH_VEU_FMT_NV16,
+ *      SH_VEU_FMT_NV24,
+ *      SH_VEU_FMT_RGB565,
+ *      SH_VEU_FMT_RGB666,
+ *      SH_VEU_FMT_RGB24,
+ */
+static const int sh_veu_fmt_in[] = {
+        SH_VEU_FMT_NV12,
+};
+
+static enum v4l2_colorspace sh_veu_4cc2cspace(u32 fourcc)
+{
+        switch (fourcc) {
+        default:
+                BUG();
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV16:
+        case V4L2_PIX_FMT_NV24:
+                return V4L2_COLORSPACE_JPEG;
+        case V4L2_PIX_FMT_RGB332:
+        case V4L2_PIX_FMT_RGB444:
+        case V4L2_PIX_FMT_RGB565:
+        case V4L2_PIX_FMT_BGR666:
+        case V4L2_PIX_FMT_RGB24:
+                return V4L2_COLORSPACE_SRGB;
+        }
+}
+
+static u32 sh_veu_reg_read(struct sh_veu_dev *veu, unsigned int reg)
+{
+        return ioread32(veu->base + reg);
+}
+
+static void sh_veu_reg_write(struct sh_veu_dev *veu, unsigned int reg,
+                             u32 value)
+{
+        iowrite32(value, veu->base + reg);
+}
+
+                /* ========== mem2mem callbacks ========== */
+
+static void sh_veu_job_abort(void *priv)
+{
+        struct sh_veu_dev *veu = priv;
+
+        /* Will cancel the transaction in the next interrupt handler */
+        veu->aborting = true;
+}
+
+static void sh_veu_lock(void *priv)
+{
+        struct sh_veu_dev *veu = priv;
+
+        mutex_lock(&veu->fop_lock);
+}
+
+static void sh_veu_unlock(void *priv)
+{
+        struct sh_veu_dev *veu = priv;
+
+        mutex_unlock(&veu->fop_lock);
+}
+
+static void sh_veu_process(struct sh_veu_dev *veu,
+                           struct vb2_buffer *src_buf,
+                           struct vb2_buffer *dst_buf)
+{
+        dma_addr_t addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0);
+
+        sh_veu_reg_write(veu, VEU_DAYR, addr + veu->vfmt_out.offset_y);
+        sh_veu_reg_write(veu, VEU_DACR, veu->vfmt_out.offset_c ?
+                         addr + veu->vfmt_out.offset_c : 0);
+        dev_dbg(veu->dev, "%s(): dst base %lx, y: %x, c: %x\n", __func__,
+                (unsigned long)addr,
+                veu->vfmt_out.offset_y, veu->vfmt_out.offset_c);
+
+        addr = vb2_dma_contig_plane_dma_addr(src_buf, 0);
+        sh_veu_reg_write(veu, VEU_SAYR, addr + veu->vfmt_in.offset_y);
+        sh_veu_reg_write(veu, VEU_SACR, veu->vfmt_in.offset_c ?
+                         addr + veu->vfmt_in.offset_c : 0);
+        dev_dbg(veu->dev, "%s(): src base %lx, y: %x, c: %x\n", __func__,
+                (unsigned long)addr,
+                veu->vfmt_in.offset_y, veu->vfmt_in.offset_c);
+
+        sh_veu_reg_write(veu, VEU_STR, 1);
+
+        sh_veu_reg_write(veu, VEU_EIER, 1); /* enable interrupt in VEU */
+}
+
+/**
+ * sh_veu_device_run() - prepares and starts the device
+ *
+ * This will be called by the framework when it decides to schedule a particular
+ * instance.
+ */
+static void sh_veu_device_run(void *priv)
+{
+        struct sh_veu_dev *veu = priv;
+        struct vb2_buffer *src_buf, *dst_buf;
+
+        src_buf = v4l2_m2m_next_src_buf(veu->m2m_ctx);
+        dst_buf = v4l2_m2m_next_dst_buf(veu->m2m_ctx);
+
+        if (src_buf && dst_buf)
+                sh_veu_process(veu, src_buf, dst_buf);
+}
+
+                /* ========== video ioctls ========== */
+
+static bool sh_veu_is_streamer(struct sh_veu_dev *veu, struct sh_veu_file *veu_file,
+                               enum v4l2_buf_type type)
+{
+        return (type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
+                veu_file == veu->capture) ||
+                (type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
+                 veu_file == veu->output);
+}
+
+static int sh_veu_queue_init(void *priv, struct vb2_queue *src_vq,
+                             struct vb2_queue *dst_vq);
+
+/*
+ * It is not unusual to have video nodes open()ed multiple times. While some
+ * V4L2 operations are non-intrusive, like querying formats and various
+ * parameters, others, like setting formats, starting and stopping streaming,
+ * queuing and dequeuing buffers, directly affect hardware configuration and /
+ * or execution. This function verifies availability of the requested interface
+ * and, if available, reserves it for the requesting user.
+ */
+static int sh_veu_stream_init(struct sh_veu_dev *veu, struct sh_veu_file *veu_file,
+                              enum v4l2_buf_type type)
+{
+        struct sh_veu_file **stream;
+
+        switch (type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                stream = &veu->capture;
+                break;
+        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                stream = &veu->output;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (*stream == veu_file)
+                return 0;
+
+        if (*stream)
+                return -EBUSY;
+
+        *stream = veu_file;
+
+        return 0;
+}
+
+static int sh_veu_context_init(struct sh_veu_dev *veu)
+{
+        if (veu->m2m_ctx)
+                return 0;
+
+        veu->m2m_ctx = v4l2_m2m_ctx_init(veu->m2m_dev, veu,
+                                         sh_veu_queue_init);
+
+        if (IS_ERR(veu->m2m_ctx))
+                return PTR_ERR(veu->m2m_ctx);
+
+        return 0;
+}
+
+static int sh_veu_querycap(struct file *file, void *priv,
+                           struct v4l2_capability *cap)
+{
+        strlcpy(cap->driver, "sh-veu", sizeof(cap->driver));
+        strlcpy(cap->card, "sh-mobile VEU", sizeof(cap->card));
+        strlcpy(cap->bus_info, "platform:sh-veu", sizeof(cap->bus_info));
+        cap->device_caps = V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
+
+        return 0;
+}
+
+static int sh_veu_enum_fmt(struct v4l2_fmtdesc *f, const int *fmt, int fmt_num)
+{
+        if (f->index >= fmt_num)
+                return -EINVAL;
+
+        strlcpy(f->description, sh_veu_fmt[fmt[f->index]].name, sizeof(f->description));
+        f->pixelformat = sh_veu_fmt[fmt[f->index]].fourcc;
+        return 0;
+}
+
+static int sh_veu_enum_fmt_vid_cap(struct file *file, void *priv,
+                                   struct v4l2_fmtdesc *f)
+{
+        return sh_veu_enum_fmt(f, sh_veu_fmt_out, ARRAY_SIZE(sh_veu_fmt_out));
+}
+
+static int sh_veu_enum_fmt_vid_out(struct file *file, void *priv,
+                                   struct v4l2_fmtdesc *f)
+{
+        return sh_veu_enum_fmt(f, sh_veu_fmt_in, ARRAY_SIZE(sh_veu_fmt_in));
+}
+
+static struct sh_veu_vfmt *sh_veu_get_vfmt(struct sh_veu_dev *veu,
+                                           enum v4l2_buf_type type)
+{
+        switch (type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                return &veu->vfmt_out;
+        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                return &veu->vfmt_in;
+        default:
+                return NULL;
+        }
+}
+
+static int sh_veu_g_fmt(struct sh_veu_file *veu_file, struct v4l2_format *f)
+{
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+        struct sh_veu_dev *veu = veu_file->veu_dev;
+        struct sh_veu_vfmt *vfmt;
+
+        vfmt = sh_veu_get_vfmt(veu, f->type);
+
+        pix->width              = vfmt->frame.width;
+        pix->height             = vfmt->frame.height;
+        pix->field              = V4L2_FIELD_NONE;
+        pix->pixelformat        = vfmt->fmt->fourcc;
+        pix->colorspace         = sh_veu_4cc2cspace(pix->pixelformat);
+        pix->bytesperline       = vfmt->bytesperline;
+        pix->sizeimage          = vfmt->bytesperline * pix->height *
+                vfmt->fmt->depth / vfmt->fmt->ydepth;
+        pix->priv               = 0;
+        dev_dbg(veu->dev, "%s(): type: %d, size %u @ %ux%u, fmt %x\n", __func__,
+                f->type, pix->sizeimage, pix->width, pix->height, pix->pixelformat);
+
+        return 0;
+}
+
+static int sh_veu_g_fmt_vid_out(struct file *file, void *priv,
+                                struct v4l2_format *f)
+{
+        return sh_veu_g_fmt(priv, f);
+}
+
+static int sh_veu_g_fmt_vid_cap(struct file *file, void *priv,
+                                struct v4l2_format *f)
+{
+        return sh_veu_g_fmt(priv, f);
+}
+
+static int sh_veu_try_fmt(struct v4l2_format *f, const struct sh_veu_format *fmt)
+{
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+        unsigned int y_bytes_used;
+
+        /*
+         * V4L2 specification suggests, that the driver should correct the
+         * format struct if any of the dimensions is unsupported
+         */
+        switch (pix->field) {
+        default:
+        case V4L2_FIELD_ANY:
+                pix->field = V4L2_FIELD_NONE;
+                /* fall through: continue handling V4L2_FIELD_NONE */
+        case V4L2_FIELD_NONE:
+                break;
+        }
+
+        v4l_bound_align_image(&pix->width, MIN_W, MAX_W, ALIGN_W,
+                              &pix->height, MIN_H, MAX_H, 0, 0);
+
+        y_bytes_used = (pix->width * fmt->ydepth) >> 3;
+
+        if (pix->bytesperline < y_bytes_used)
+                pix->bytesperline = y_bytes_used;
+        pix->sizeimage = pix->height * pix->bytesperline * fmt->depth / fmt->ydepth;
+
+        pix->pixelformat        = fmt->fourcc;
+        pix->colorspace         = sh_veu_4cc2cspace(pix->pixelformat);
+        pix->priv               = 0;
+
+        pr_debug("%s(): type: %d, size %u\n", __func__, f->type, pix->sizeimage);
+
+        return 0;
+}
+
+static const struct sh_veu_format *sh_veu_find_fmt(const struct v4l2_format *f)
+{
+        const int *fmt;
+        int i, n, dflt;
+
+        pr_debug("%s(%d;%d)\n", __func__, f->type, f->fmt.pix.field);
+
+        switch (f->type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                fmt = sh_veu_fmt_out;
+                n = ARRAY_SIZE(sh_veu_fmt_out);
+                dflt = DEFAULT_OUT_FMTIDX;
+                break;
+        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+        default:
+                fmt = sh_veu_fmt_in;
+                n = ARRAY_SIZE(sh_veu_fmt_in);
+                dflt = DEFAULT_IN_FMTIDX;
+                break;
+        }
+
+        for (i = 0; i < n; i++)
+                if (sh_veu_fmt[fmt[i]].fourcc == f->fmt.pix.pixelformat)
+                        return &sh_veu_fmt[fmt[i]];
+
+        return &sh_veu_fmt[dflt];
+}
+
+static int sh_veu_try_fmt_vid_cap(struct file *file, void *priv,
+                                  struct v4l2_format *f)
+{
+        const struct sh_veu_format *fmt;
+
+        fmt = sh_veu_find_fmt(f);
+        if (!fmt)
+                /* wrong buffer type */
+                return -EINVAL;
+
+        return sh_veu_try_fmt(f, fmt);
+}
+
+static int sh_veu_try_fmt_vid_out(struct file *file, void *priv,
+                                  struct v4l2_format *f)
+{
+        const struct sh_veu_format *fmt;
+
+        fmt = sh_veu_find_fmt(f);
+        if (!fmt)
+                /* wrong buffer type */
+                return -EINVAL;
+
+        return sh_veu_try_fmt(f, fmt);
+}
+
+static void sh_veu_colour_offset(struct sh_veu_dev *veu, struct sh_veu_vfmt *vfmt)
+{
+        /* dst_left and dst_top validity will be verified in CROP / COMPOSE */
+        unsigned int left = vfmt->frame.left & ~0x03;
+        unsigned int top = vfmt->frame.top;
+        dma_addr_t offset = ((left * veu->vfmt_out.fmt->depth) >> 3) +
+                top * veu->vfmt_out.bytesperline;
+        unsigned int y_line;
+
+        vfmt->offset_y = offset;
+
+        switch (vfmt->fmt->fourcc) {
+        case V4L2_PIX_FMT_NV12:
+        case V4L2_PIX_FMT_NV16:
+        case V4L2_PIX_FMT_NV24:
+                y_line = ALIGN(vfmt->frame.width, 16);
+                vfmt->offset_c = offset + y_line * vfmt->frame.height;
+                break;
+        case V4L2_PIX_FMT_RGB332:
+        case V4L2_PIX_FMT_RGB444:
+        case V4L2_PIX_FMT_RGB565:
+        case V4L2_PIX_FMT_BGR666:
+        case V4L2_PIX_FMT_RGB24:
+                vfmt->offset_c = 0;
+                break;
+        default:
+                BUG();
+        }
+}
+
+static int sh_veu_s_fmt(struct sh_veu_file *veu_file, struct v4l2_format *f)
+{
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+        struct sh_veu_dev *veu = veu_file->veu_dev;
+        struct sh_veu_vfmt *vfmt;
+        struct vb2_queue *vq;
+        int ret = sh_veu_context_init(veu);
+        if (ret < 0)
+                return ret;
+
+        vq = v4l2_m2m_get_vq(veu->m2m_ctx, f->type);
+        if (!vq)
+                return -EINVAL;
+
+        if (vb2_is_busy(vq)) {
+                v4l2_err(&veu_file->veu_dev->v4l2_dev, "%s queue busy\n", __func__);
+                return -EBUSY;
+        }
+
+        vfmt = sh_veu_get_vfmt(veu, f->type);
+        /* called after try_fmt(), hence vfmt != NULL. Implicit BUG_ON() below */
+
+        vfmt->fmt               = sh_veu_find_fmt(f);
+        /* vfmt->fmt != NULL following the same argument as above */
+        vfmt->frame.width       = pix->width;
+        vfmt->frame.height      = pix->height;
+        vfmt->bytesperline      = pix->bytesperline;
+
+        sh_veu_colour_offset(veu, vfmt);
+
+        /*
+         * We could also verify and require configuration only if any parameters
+         * actually have changed, but it is unlikely, that the user requests the
+         * same configuration several times without closing the device.
+         */
+        veu_file->cfg_needed = true;
+
+        dev_dbg(veu->dev,
+                "Setting format for type %d, wxh: %dx%d, fmt: %x\n",
+                f->type, pix->width, pix->height, vfmt->fmt->fourcc);
+
+        return 0;
+}
+
+static int sh_veu_s_fmt_vid_cap(struct file *file, void *priv,
+                                struct v4l2_format *f)
+{
+        int ret = sh_veu_try_fmt_vid_cap(file, priv, f);
+        if (ret)
+                return ret;
+
+        return sh_veu_s_fmt(priv, f);
+}
+
+static int sh_veu_s_fmt_vid_out(struct file *file, void *priv,
+                                struct v4l2_format *f)
+{
+        int ret = sh_veu_try_fmt_vid_out(file, priv, f);
+        if (ret)
+                return ret;
+
+        return sh_veu_s_fmt(priv, f);
+}
+
+static int sh_veu_reqbufs(struct file *file, void *priv,
+                          struct v4l2_requestbuffers *reqbufs)
+{
+        struct sh_veu_file *veu_file = priv;
+        struct sh_veu_dev *veu = veu_file->veu_dev;
+        int ret = sh_veu_context_init(veu);
+        if (ret < 0)
+                return ret;
+
+        ret = sh_veu_stream_init(veu, veu_file, reqbufs->type);
+        if (ret < 0)
+                return ret;
+
+        return v4l2_m2m_reqbufs(file, veu->m2m_ctx, reqbufs);
+}
+
+static int sh_veu_querybuf(struct file *file, void *priv,
+                           struct v4l2_buffer *buf)
+{
+        struct sh_veu_file *veu_file = priv;
+
+        if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, buf->type))
+                return -EBUSY;
+
+        return v4l2_m2m_querybuf(file, veu_file->veu_dev->m2m_ctx, buf);
+}
+
+static int sh_veu_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
+{
+        struct sh_veu_file *veu_file = priv;
+
+        dev_dbg(veu_file->veu_dev->dev, "%s(%d)\n", __func__, buf->type);
+        if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, buf->type))
+                return -EBUSY;
+
+        return v4l2_m2m_qbuf(file, veu_file->veu_dev->m2m_ctx, buf);
+}
+
+static int sh_veu_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
+{
+        struct sh_veu_file *veu_file = priv;
+
+        dev_dbg(veu_file->veu_dev->dev, "%s(%d)\n", __func__, buf->type);
+        if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, buf->type))
+                return -EBUSY;
+
+        return v4l2_m2m_dqbuf(file, veu_file->veu_dev->m2m_ctx, buf);
+}
+
+static void sh_veu_calc_scale(struct sh_veu_dev *veu,
+                              int size_in, int size_out, int crop_out,
+                              u32 *mant, u32 *frac, u32 *rep)
+{
+        u32 fixpoint;
+
+        /* calculate FRAC and MANT */
+        *rep = *mant = *frac = 0;
+
+        if (size_in == size_out) {
+                if (crop_out != size_out)
+                        *mant = 1; /* needed for cropping */
+                return;
+        }
+
+        /* VEU2H special upscale */
+        if (veu->is_2h && size_out > size_in) {
+                u32 fixpoint = (4096 * size_in) / size_out;
+                *mant = fixpoint / 4096;
+                *frac = (fixpoint - (*mant * 4096)) & ~0x07;
+
+                switch (*frac) {
+                case 0x800:
+                        *rep = 1;
+                        break;
+                case 0x400:
+                        *rep = 3;
+                        break;
+                case 0x200:
+                        *rep = 7;
+                        break;
+                }
+                if (*rep)
+                        return;
+        }
+
+        fixpoint = (4096 * (size_in - 1)) / (size_out + 1);
+        *mant = fixpoint / 4096;
+        *frac = fixpoint - (*mant * 4096);
+
+        if (*frac & 0x07) {
+                /*
+                 * FIXME: do we really have to round down twice in the
+                 * up-scaling case?
+                 */
+                *frac &= ~0x07;
+                if (size_out > size_in)
+                        *frac -= 8; /* round down if scaling up */
+                else
+                        *frac += 8; /* round up if scaling down */
+        }
+}
+
+static unsigned long sh_veu_scale_v(struct sh_veu_dev *veu,
+                                    int size_in, int size_out, int crop_out)
+{
+        u32 mant, frac, value, rep;
+
+        sh_veu_calc_scale(veu, size_in, size_out, crop_out, &mant, &frac, &rep);
+
+        /* set scale */
+        value = (sh_veu_reg_read(veu, VEU_RFCR) & ~0xffff0000) |
+                (((mant << 12) | frac) << 16);
+
+        sh_veu_reg_write(veu, VEU_RFCR, value);
+
+        /* set clip */
+        value = (sh_veu_reg_read(veu, VEU_RFSR) & ~0xffff0000) |
+                (((rep << 12) | crop_out) << 16);
+
+        sh_veu_reg_write(veu, VEU_RFSR, value);
+
+        return ALIGN((size_in * crop_out) / size_out, 4);
+}
+
+static unsigned long sh_veu_scale_h(struct sh_veu_dev *veu,
+                                    int size_in, int size_out, int crop_out)
+{
+        u32 mant, frac, value, rep;
+
+        sh_veu_calc_scale(veu, size_in, size_out, crop_out, &mant, &frac, &rep);
+
+        /* set scale */
+        value = (sh_veu_reg_read(veu, VEU_RFCR) & ~0xffff) |
+                (mant << 12) | frac;
+
+        sh_veu_reg_write(veu, VEU_RFCR, value);
+
+        /* set clip */
+        value = (sh_veu_reg_read(veu, VEU_RFSR) & ~0xffff) |
+                (rep << 12) | crop_out;
+
+        sh_veu_reg_write(veu, VEU_RFSR, value);
+
+        return ALIGN((size_in * crop_out) / size_out, 4);
+}
+
+static void sh_veu_configure(struct sh_veu_dev *veu)
+{
+        u32 src_width, src_stride, src_height;
+        u32 dst_width, dst_stride, dst_height;
+        u32 real_w, real_h;
+
+        /* reset VEU */
+        sh_veu_reg_write(veu, VEU_BSRR, 0x100);
+
+        src_width = veu->vfmt_in.frame.width;
+        src_height = veu->vfmt_in.frame.height;
+        src_stride = ALIGN(veu->vfmt_in.frame.width, 16);
+
+        dst_width = real_w = veu->vfmt_out.frame.width;
+        dst_height = real_h = veu->vfmt_out.frame.height;
+        /* Datasheet is unclear - whether it's always number of bytes or not */
+        dst_stride = veu->vfmt_out.bytesperline;
+
+        /*
+         * So far real_w == dst_width && real_h == dst_height, but it wasn't
+         * necessarily the case in the original vidix driver, so, it may change
+         * here in the future too.
+         */
+        src_width = sh_veu_scale_h(veu, src_width, real_w, dst_width);
+        src_height = sh_veu_scale_v(veu, src_height, real_h, dst_height);
+
+        sh_veu_reg_write(veu, VEU_SWR, src_stride);
+        sh_veu_reg_write(veu, VEU_SSR, src_width | (src_height << 16));
+        sh_veu_reg_write(veu, VEU_BSSR, 0); /* not using bundle mode */
+
+        sh_veu_reg_write(veu, VEU_EDWR, dst_stride);
+        sh_veu_reg_write(veu, VEU_DACR, 0); /* unused for RGB */
+
+        sh_veu_reg_write(veu, VEU_SWPR, 0x67);
+        sh_veu_reg_write(veu, VEU_TRCR, (6 << 16) | (0 << 14) | 2 | 4);
+
+        if (veu->is_2h) {
+                sh_veu_reg_write(veu, VEU_MCR00, 0x0cc5);
+                sh_veu_reg_write(veu, VEU_MCR01, 0x0950);
+                sh_veu_reg_write(veu, VEU_MCR02, 0x0000);
+
+                sh_veu_reg_write(veu, VEU_MCR10, 0x397f);
+                sh_veu_reg_write(veu, VEU_MCR11, 0x0950);
+                sh_veu_reg_write(veu, VEU_MCR12, 0x3ccd);
+
+                sh_veu_reg_write(veu, VEU_MCR20, 0x0000);
+                sh_veu_reg_write(veu, VEU_MCR21, 0x0950);
+                sh_veu_reg_write(veu, VEU_MCR22, 0x1023);
+
+                sh_veu_reg_write(veu, VEU_COFFR, 0x00800010);
+        }
+}
+
+static int sh_veu_streamon(struct file *file, void *priv,
+                           enum v4l2_buf_type type)
+{
+        struct sh_veu_file *veu_file = priv;
+
+        if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, type))
+                return -EBUSY;
+
+        if (veu_file->cfg_needed) {
+                struct sh_veu_dev *veu = veu_file->veu_dev;
+                veu_file->cfg_needed = false;
+                sh_veu_configure(veu_file->veu_dev);
+                veu->xaction = 0;
+                veu->aborting = false;
+        }
+
+        return v4l2_m2m_streamon(file, veu_file->veu_dev->m2m_ctx, type);
+}
+
+static int sh_veu_streamoff(struct file *file, void *priv,
+                            enum v4l2_buf_type type)
+{
+        struct sh_veu_file *veu_file = priv;
+
+        if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, type))
+                return -EBUSY;
+
+        return v4l2_m2m_streamoff(file, veu_file->veu_dev->m2m_ctx, type);
+}
+
+static const struct v4l2_ioctl_ops sh_veu_ioctl_ops = {
+        .vidioc_querycap        = sh_veu_querycap,
+
+        .vidioc_enum_fmt_vid_cap = sh_veu_enum_fmt_vid_cap,
+        .vidioc_g_fmt_vid_cap   = sh_veu_g_fmt_vid_cap,
+        .vidioc_try_fmt_vid_cap = sh_veu_try_fmt_vid_cap,
+        .vidioc_s_fmt_vid_cap   = sh_veu_s_fmt_vid_cap,
+
+        .vidioc_enum_fmt_vid_out = sh_veu_enum_fmt_vid_out,
+        .vidioc_g_fmt_vid_out   = sh_veu_g_fmt_vid_out,
+        .vidioc_try_fmt_vid_out = sh_veu_try_fmt_vid_out,
+        .vidioc_s_fmt_vid_out   = sh_veu_s_fmt_vid_out,
+
+        .vidioc_reqbufs         = sh_veu_reqbufs,
+        .vidioc_querybuf        = sh_veu_querybuf,
+
+        .vidioc_qbuf            = sh_veu_qbuf,
+        .vidioc_dqbuf           = sh_veu_dqbuf,
+
+        .vidioc_streamon        = sh_veu_streamon,
+        .vidioc_streamoff       = sh_veu_streamoff,
+};
+
+                /* ========== Queue operations ========== */
+
+static int sh_veu_queue_setup(struct vb2_queue *vq,
+                              const struct v4l2_format *f,
+                              unsigned int *nbuffers, unsigned int *nplanes,
+                              unsigned int sizes[], void *alloc_ctxs[])
+{
+        struct sh_veu_dev *veu = vb2_get_drv_priv(vq);
+        struct sh_veu_vfmt *vfmt;
+        unsigned int size, count = *nbuffers;
+
+        if (f) {
+                const struct v4l2_pix_format *pix = &f->fmt.pix;
+                const struct sh_veu_format *fmt = sh_veu_find_fmt(f);
+                struct v4l2_format ftmp = *f;
+
+                if (fmt->fourcc != pix->pixelformat)
+                        return -EINVAL;
+                sh_veu_try_fmt(&ftmp, fmt);
+                if (ftmp.fmt.pix.width != pix->width ||
+                    ftmp.fmt.pix.height != pix->height)
+                        return -EINVAL;
+                size = pix->bytesperline ? pix->bytesperline * pix->height :
+                        pix->width * pix->height * fmt->depth >> 3;
+        } else {
+                vfmt = sh_veu_get_vfmt(veu, vq->type);
+                size = vfmt->bytesperline * vfmt->frame.height;
+        }
+
+        if (count < 2)
+                *nbuffers = count = 2;
+
+        if (size * count > VIDEO_MEM_LIMIT) {
+                count = VIDEO_MEM_LIMIT / size;
+                *nbuffers = count;
+        }
+
+        *nplanes = 1;
+        sizes[0] = size;
+        alloc_ctxs[0] = veu->alloc_ctx;
+
+        dev_dbg(veu->dev, "get %d buffer(s) of size %d each.\n", count, size);
+
+        return 0;
+}
+
+static int sh_veu_buf_prepare(struct vb2_buffer *vb)
+{
+        struct sh_veu_dev *veu = vb2_get_drv_priv(vb->vb2_queue);
+        struct sh_veu_vfmt *vfmt;
+        unsigned int sizeimage;
+
+        vfmt = sh_veu_get_vfmt(veu, vb->vb2_queue->type);
+        sizeimage = vfmt->bytesperline * vfmt->frame.height *
+                vfmt->fmt->depth / vfmt->fmt->ydepth;
+
+        if (vb2_plane_size(vb, 0) < sizeimage) {
+                dev_dbg(veu->dev, "%s data will not fit into plane (%lu < %u)\n",
+                        __func__, vb2_plane_size(vb, 0), sizeimage);
+                return -EINVAL;
+        }
+
+        vb2_set_plane_payload(vb, 0, sizeimage);
+
+        return 0;
+}
+
+static void sh_veu_buf_queue(struct vb2_buffer *vb)
+{
+        struct sh_veu_dev *veu = vb2_get_drv_priv(vb->vb2_queue);
+        dev_dbg(veu->dev, "%s(%d)\n", __func__, vb->v4l2_buf.type);
+        v4l2_m2m_buf_queue(veu->m2m_ctx, vb);
+}
+
+static void sh_veu_wait_prepare(struct vb2_queue *q)
+{
+        sh_veu_unlock(vb2_get_drv_priv(q));
+}
+
+static void sh_veu_wait_finish(struct vb2_queue *q)
+{
+        sh_veu_lock(vb2_get_drv_priv(q));
+}
+
+static const struct vb2_ops sh_veu_qops = {
+        .queue_setup     = sh_veu_queue_setup,
+        .buf_prepare     = sh_veu_buf_prepare,
+        .buf_queue       = sh_veu_buf_queue,
+        .wait_prepare    = sh_veu_wait_prepare,
+        .wait_finish     = sh_veu_wait_finish,
+};
+
+static int sh_veu_queue_init(void *priv, struct vb2_queue *src_vq,
+                             struct vb2_queue *dst_vq)
+{
+        int ret;
+
+        memset(src_vq, 0, sizeof(*src_vq));
+        src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+        src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
+        src_vq->drv_priv = priv;
+        src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
+        src_vq->ops = &sh_veu_qops;
+        src_vq->mem_ops = &vb2_dma_contig_memops;
+
+        ret = vb2_queue_init(src_vq);
+        if (ret < 0)
+                return ret;
+
+        memset(dst_vq, 0, sizeof(*dst_vq));
+        dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
+        dst_vq->drv_priv = priv;
+        dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
+        dst_vq->ops = &sh_veu_qops;
+        dst_vq->mem_ops = &vb2_dma_contig_memops;
+
+        return vb2_queue_init(dst_vq);
+}
+
+                /* ========== File operations ========== */
+
+static int sh_veu_open(struct file *file)
+{
+        struct sh_veu_dev *veu = video_drvdata(file);
+        struct sh_veu_file *veu_file;
+
+        veu_file = kzalloc(sizeof(*veu_file), GFP_KERNEL);
+        if (!veu_file)
+                return -ENOMEM;
+
+        veu_file->veu_dev = veu;
+        veu_file->cfg_needed = true;
+
+        file->private_data = veu_file;
+
+        pm_runtime_get_sync(veu->dev);
+
+        dev_dbg(veu->dev, "Created instance %p\n", veu_file);
+
+        return 0;
+}
+
+static int sh_veu_release(struct file *file)
+{
+        struct sh_veu_dev *veu = video_drvdata(file);
+        struct sh_veu_file *veu_file = file->private_data;
+
+        dev_dbg(veu->dev, "Releasing instance %p\n", veu_file);
+
+        pm_runtime_put(veu->dev);
+
+        if (veu_file == veu->capture) {
+                veu->capture = NULL;
+                vb2_queue_release(v4l2_m2m_get_vq(veu->m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE));
+        }
+
+        if (veu_file == veu->output) {
+                veu->output = NULL;
+                vb2_queue_release(v4l2_m2m_get_vq(veu->m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT));
+        }
+
+        if (!veu->output && !veu->capture && veu->m2m_ctx) {
+                v4l2_m2m_ctx_release(veu->m2m_ctx);
+                veu->m2m_ctx = NULL;
+        }
+
+        kfree(veu_file);
+
+        return 0;
+}
+
+static unsigned int sh_veu_poll(struct file *file,
+                                struct poll_table_struct *wait)
+{
+        struct sh_veu_file *veu_file = file->private_data;
+
+        return v4l2_m2m_poll(file, veu_file->veu_dev->m2m_ctx, wait);
+}
+
+static int sh_veu_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        struct sh_veu_file *veu_file = file->private_data;
+
+        return v4l2_m2m_mmap(file, veu_file->veu_dev->m2m_ctx, vma);
+}
+
+static const struct v4l2_file_operations sh_veu_fops = {
+        .owner          = THIS_MODULE,
+        .open           = sh_veu_open,
+        .release        = sh_veu_release,
+        .poll           = sh_veu_poll,
+        .unlocked_ioctl = video_ioctl2,
+        .mmap           = sh_veu_mmap,
+};
+
+static const struct video_device sh_veu_videodev = {
+        .name           = "sh-veu",
+        .fops           = &sh_veu_fops,
+        .ioctl_ops      = &sh_veu_ioctl_ops,
+        .minor          = -1,
+        .release        = video_device_release_empty,
+        .vfl_dir        = VFL_DIR_M2M,
+};
+
+static const struct v4l2_m2m_ops sh_veu_m2m_ops = {
+        .device_run     = sh_veu_device_run,
+        .job_abort      = sh_veu_job_abort,
+};
+
+static irqreturn_t sh_veu_bh(int irq, void *dev_id)
+{
+        struct sh_veu_dev *veu = dev_id;
+
+        if (veu->xaction == MEM2MEM_DEF_TRANSLEN || veu->aborting) {
+                v4l2_m2m_job_finish(veu->m2m_dev, veu->m2m_ctx);
+                veu->xaction = 0;
+        } else {
+                sh_veu_device_run(veu);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t sh_veu_isr(int irq, void *dev_id)
+{
+        struct sh_veu_dev *veu = dev_id;
+        struct vb2_buffer *dst;
+        struct vb2_buffer *src;
+        u32 status = sh_veu_reg_read(veu, VEU_EVTR);
+
+        /* bundle read mode not used */
+        if (!(status & 1))
+                return IRQ_NONE;
+
+        /* disable interrupt in VEU */
+        sh_veu_reg_write(veu, VEU_EIER, 0);
+        /* halt operation */
+        sh_veu_reg_write(veu, VEU_STR, 0);
+        /* ack int, write 0 to clear bits */
+        sh_veu_reg_write(veu, VEU_EVTR, status & ~1);
+
+        /* conversion completed */
+        dst = v4l2_m2m_dst_buf_remove(veu->m2m_ctx);
+        src = v4l2_m2m_src_buf_remove(veu->m2m_ctx);
+        if (!src || !dst)
+                return IRQ_NONE;
+
+        spin_lock(&veu->lock);
+        v4l2_m2m_buf_done(src, VB2_BUF_STATE_DONE);
+        v4l2_m2m_buf_done(dst, VB2_BUF_STATE_DONE);
+        spin_unlock(&veu->lock);
+
+        veu->xaction++;
+
+        if (!veu->aborting)
+                return IRQ_WAKE_THREAD;
+
+        return IRQ_HANDLED;
+}
+
+static int sh_veu_probe(struct platform_device *pdev)
+{
+        struct sh_veu_dev *veu;
+        struct resource *reg_res;
+        struct video_device *vdev;
+        int irq, ret;
+
+        reg_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        irq = platform_get_irq(pdev, 0);
+
+        if (!reg_res || irq <= 0) {
+                dev_err(&pdev->dev, "Insufficient VEU platform information.\n");
+                return -ENODEV;
+        }
+
+        veu = devm_kzalloc(&pdev->dev, sizeof(*veu), GFP_KERNEL);
+        if (!veu)
+                return -ENOMEM;
+
+        veu->is_2h = resource_size(reg_res) == 0x22c;
+
+        veu->base = devm_request_and_ioremap(&pdev->dev, reg_res);
+        if (!veu->base)
+                return -ENOMEM;
+
+        ret = devm_request_threaded_irq(&pdev->dev, irq, sh_veu_isr, sh_veu_bh,
+                                        0, "veu", veu);
+        if (ret < 0)
+                return ret;
+
+        ret = v4l2_device_register(&pdev->dev, &veu->v4l2_dev);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Error registering v4l2 device\n");
+                return ret;
+        }
+
+        vdev = &veu->vdev;
+
+        veu->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
+        if (IS_ERR(veu->alloc_ctx)) {
+                ret = PTR_ERR(veu->alloc_ctx);
+                goto einitctx;
+        }
+
+        *vdev = sh_veu_videodev;
+        spin_lock_init(&veu->lock);
+        mutex_init(&veu->fop_lock);
+        vdev->lock = &veu->fop_lock;
+
+        video_set_drvdata(vdev, veu);
+
+        veu->dev        = &pdev->dev;
+        veu->vfmt_out   = DEFAULT_OUT_VFMT;
+        veu->vfmt_in    = DEFAULT_IN_VFMT;
+
+        veu->m2m_dev = v4l2_m2m_init(&sh_veu_m2m_ops);
+        if (IS_ERR(veu->m2m_dev)) {
+                ret = PTR_ERR(veu->m2m_dev);
+                v4l2_err(&veu->v4l2_dev, "Failed to init mem2mem device: %d\n", ret);
+                goto em2minit;
+        }
+
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_resume(&pdev->dev);
+
+        ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
+        pm_runtime_suspend(&pdev->dev);
+        if (ret < 0)
+                goto evidreg;
+
+        return ret;
+
+evidreg:
+        pm_runtime_disable(&pdev->dev);
+        v4l2_m2m_release(veu->m2m_dev);
+em2minit:
+        vb2_dma_contig_cleanup_ctx(veu->alloc_ctx);
+einitctx:
+        v4l2_device_unregister(&veu->v4l2_dev);
+        return ret;
+}
+
+static int sh_veu_remove(struct platform_device *pdev)
+{
+        struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
+        struct sh_veu_dev *veu = container_of(v4l2_dev,
+                                              struct sh_veu_dev, v4l2_dev);
+
+        video_unregister_device(&veu->vdev);
+        pm_runtime_disable(&pdev->dev);
+        v4l2_m2m_release(veu->m2m_dev);
+        vb2_dma_contig_cleanup_ctx(veu->alloc_ctx);
+        v4l2_device_unregister(&veu->v4l2_dev);
+
+        return 0;
+}
+
+static struct platform_driver __refdata sh_veu_pdrv = {
+        .remove         = sh_veu_remove,
+        .driver         = {
+                .name   = "sh_veu",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init sh_veu_init(void)
+{
+        return platform_driver_probe(&sh_veu_pdrv, sh_veu_probe);
+}
+
+static void __exit sh_veu_exit(void)
+{
+        platform_driver_unregister(&sh_veu_pdrv);
+}
+
+module_init(sh_veu_init);
+module_exit(sh_veu_exit);
+
+MODULE_DESCRIPTION("sh-mobile VEU mem2mem driver");
+MODULE_AUTHOR("Guennadi Liakhovetski, <g.liakhovetski@gmx.de>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/media/platform/sh_vou.c b/drivers/media/platform/sh_vou.c
index f3c4571ac01e..66c8da18df84 100644
--- a/drivers/media/platform/sh_vou.c
+++ b/drivers/media/platform/sh_vou.c
@@ -207,6 +207,7 @@ static void sh_vou_stream_start(struct sh_vou_device *vou_dev,
 #endif
 
         switch (vou_dev->pix.pixelformat) {
+        default:
         case V4L2_PIX_FMT_NV12:
         case V4L2_PIX_FMT_NV16:
                 row_coeff = 1;
@@ -253,7 +254,8 @@ static int sh_vou_buf_setup(struct videobuf_queue *vq, unsigned int *count,
         if (PAGE_ALIGN(*size) * *count > 4 * 1024 * 1024)
                 *count = 4 * 1024 * 1024 / PAGE_ALIGN(*size);
 
-        dev_dbg(vq->dev, "%s(): count=%d, size=%d\n", __func__, *count, *size);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s(): count=%d, size=%d\n", __func__,
+                *count, *size);
 
         return 0;
 }
@@ -269,7 +271,7 @@ static int sh_vou_buf_prepare(struct videobuf_queue *vq,
         int bytes_per_line = vou_fmt[vou_dev->pix_idx].bpp * pix->width / 8;
         int ret;
 
-        dev_dbg(vq->dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         if (vb->width   != pix->width ||
             vb->height  != pix->height ||
@@ -299,7 +301,7 @@ static int sh_vou_buf_prepare(struct videobuf_queue *vq,
                 vb->state = VIDEOBUF_PREPARED;
         }
 
-        dev_dbg(vq->dev,
+        dev_dbg(vou_dev->v4l2_dev.dev,
                 "%s(): fmt #%d, %u bytes per line, phys 0x%x, type %d, state %d\n",
                 __func__, vou_dev->pix_idx, bytes_per_line,
                 videobuf_to_dma_contig(vb), vb->memory, vb->state);
@@ -314,7 +316,7 @@ static void sh_vou_buf_queue(struct videobuf_queue *vq,
         struct video_device *vdev = vq->priv_data;
         struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
 
-        dev_dbg(vq->dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         vb->state = VIDEOBUF_QUEUED;
         list_add_tail(&vb->queue, &vou_dev->queue);
@@ -325,8 +327,8 @@ static void sh_vou_buf_queue(struct videobuf_queue *vq,
                 vou_dev->active = vb;
                 /* Start from side A: we use mirror addresses, so, set B */
                 sh_vou_reg_a_write(vou_dev, VOURPR, 1);
-                dev_dbg(vq->dev, "%s: first buffer status 0x%x\n", __func__,
-                        sh_vou_reg_a_read(vou_dev, VOUSTR));
+                dev_dbg(vou_dev->v4l2_dev.dev, "%s: first buffer status 0x%x\n",
+                        __func__, sh_vou_reg_a_read(vou_dev, VOUSTR));
                 sh_vou_schedule_next(vou_dev, vb);
                 /* Only activate VOU after the second buffer */
         } else if (vou_dev->active->queue.next == &vb->queue) {
@@ -336,8 +338,8 @@ static void sh_vou_buf_queue(struct videobuf_queue *vq,
 
                 /* Register side switching with frame VSYNC */
                 sh_vou_reg_a_write(vou_dev, VOURCR, 5);
-                dev_dbg(vq->dev, "%s: second buffer status 0x%x\n", __func__,
-                        sh_vou_reg_a_read(vou_dev, VOUSTR));
+                dev_dbg(vou_dev->v4l2_dev.dev, "%s: second buffer status 0x%x\n",
+                        __func__, sh_vou_reg_a_read(vou_dev, VOUSTR));
 
                 /* Enable End-of-Frame (VSYNC) interrupts */
                 sh_vou_reg_a_write(vou_dev, VOUIR, 0x10004);
@@ -355,7 +357,7 @@ static void sh_vou_buf_release(struct videobuf_queue *vq,
         struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
         unsigned long flags;
 
-        dev_dbg(vq->dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         spin_lock_irqsave(&vou_dev->lock, flags);
 
@@ -388,9 +390,9 @@ static struct videobuf_queue_ops sh_vou_video_qops = {
 static int sh_vou_querycap(struct file *file, void  *priv,
                            struct v4l2_capability *cap)
 {
-        struct sh_vou_file *vou_file = priv;
+        struct sh_vou_device *vou_dev = video_drvdata(file);
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         strlcpy(cap->card, "SuperH VOU", sizeof(cap->card));
         cap->capabilities = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
@@ -401,12 +403,12 @@ static int sh_vou_querycap(struct file *file, void  *priv,
 static int sh_vou_enum_fmt_vid_out(struct file *file, void  *priv,
                                    struct v4l2_fmtdesc *fmt)
 {
-        struct sh_vou_file *vou_file = priv;
+        struct sh_vou_device *vou_dev = video_drvdata(file);
 
         if (fmt->index >= ARRAY_SIZE(vou_fmt))
                 return -EINVAL;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         fmt->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
         strlcpy(fmt->description, vou_fmt[fmt->index].desc,
@@ -419,8 +421,7 @@ static int sh_vou_enum_fmt_vid_out(struct file *file, void  *priv,
 static int sh_vou_g_fmt_vid_out(struct file *file, void *priv,
                                 struct v4l2_format *fmt)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
 
         dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
@@ -595,9 +596,9 @@ static void vou_adjust_input(struct sh_vou_geometry *geo, v4l2_std_id std)
  */
 static void vou_adjust_output(struct sh_vou_geometry *geo, v4l2_std_id std)
 {
-        unsigned int best_err = UINT_MAX, best, width_max, height_max,
-                img_height_max;
-        int i, idx;
+        unsigned int best_err = UINT_MAX, best = geo->in_width,
+                width_max, height_max, img_height_max;
+        int i, idx = 0;
 
         if (std & V4L2_STD_525_60) {
                 width_max = 858;
@@ -671,8 +672,7 @@ static void vou_adjust_output(struct sh_vou_geometry *geo, v4l2_std_id std)
 static int sh_vou_s_fmt_vid_out(struct file *file, void *priv,
                                 struct v4l2_format *fmt)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct v4l2_pix_format *pix = &fmt->fmt.pix;
         unsigned int img_height_max;
         int pix_idx;
@@ -764,11 +764,11 @@ static int sh_vou_s_fmt_vid_out(struct file *file, void *priv,
 static int sh_vou_try_fmt_vid_out(struct file *file, void *priv,
                                   struct v4l2_format *fmt)
 {
-        struct sh_vou_file *vou_file = priv;
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct v4l2_pix_format *pix = &fmt->fmt.pix;
         int i;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         fmt->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
         pix->field = V4L2_FIELD_NONE;
@@ -788,9 +788,10 @@ static int sh_vou_try_fmt_vid_out(struct file *file, void *priv,
 static int sh_vou_reqbufs(struct file *file, void *priv,
                           struct v4l2_requestbuffers *req)
 {
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct sh_vou_file *vou_file = priv;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         if (req->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
                 return -EINVAL;
@@ -801,27 +802,30 @@ static int sh_vou_reqbufs(struct file *file, void *priv,
 static int sh_vou_querybuf(struct file *file, void *priv,
                            struct v4l2_buffer *b)
 {
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct sh_vou_file *vou_file = priv;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         return videobuf_querybuf(&vou_file->vbq, b);
 }
 
 static int sh_vou_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
 {
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct sh_vou_file *vou_file = priv;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         return videobuf_qbuf(&vou_file->vbq, b);
 }
 
 static int sh_vou_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
 {
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct sh_vou_file *vou_file = priv;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         return videobuf_dqbuf(&vou_file->vbq, b, file->f_flags & O_NONBLOCK);
 }
@@ -829,12 +833,11 @@ static int sh_vou_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
 static int sh_vou_streamon(struct file *file, void *priv,
                            enum v4l2_buf_type buftype)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct sh_vou_file *vou_file = priv;
         int ret;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         ret = v4l2_device_call_until_err(&vou_dev->v4l2_dev, 0,
                                          video, s_stream, 1);
@@ -848,11 +851,10 @@ static int sh_vou_streamon(struct file *file, void *priv,
 static int sh_vou_streamoff(struct file *file, void *priv,
                             enum v4l2_buf_type buftype)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct sh_vou_file *vou_file = priv;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         /*
          * This calls buf_release from host driver's videobuf_queue_ops for all
@@ -881,13 +883,12 @@ static u32 sh_vou_ntsc_mode(enum sh_vou_bus_fmt bus_fmt)
 
 static int sh_vou_s_std(struct file *file, void *priv, v4l2_std_id *std_id)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         int ret;
 
         dev_dbg(vou_dev->v4l2_dev.dev, "%s(): 0x%llx\n", __func__, *std_id);
 
-        if (*std_id & ~vdev->tvnorms)
+        if (*std_id & ~vou_dev->vdev->tvnorms)
                 return -EINVAL;
 
         ret = v4l2_device_call_until_err(&vou_dev->v4l2_dev, 0, video,
@@ -909,8 +910,7 @@ static int sh_vou_s_std(struct file *file, void *priv, v4l2_std_id *std_id)
 
 static int sh_vou_g_std(struct file *file, void *priv, v4l2_std_id *std)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
 
         dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
@@ -921,8 +921,7 @@ static int sh_vou_g_std(struct file *file, void *priv, v4l2_std_id *std)
 
 static int sh_vou_g_crop(struct file *file, void *fh, struct v4l2_crop *a)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
 
         dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
@@ -936,8 +935,7 @@ static int sh_vou_g_crop(struct file *file, void *fh, struct v4l2_crop *a)
 static int sh_vou_s_crop(struct file *file, void *fh, const struct v4l2_crop *a)
 {
         struct v4l2_crop a_writable = *a;
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct v4l2_rect *rect = &a_writable.c;
         struct v4l2_crop sd_crop = {.type = V4L2_BUF_TYPE_VIDEO_OUTPUT};
         struct v4l2_pix_format *pix = &vou_dev->pix;
@@ -1028,9 +1026,9 @@ static int sh_vou_s_crop(struct file *file, void *fh, const struct v4l2_crop *a)
 static int sh_vou_cropcap(struct file *file, void *priv,
                           struct v4l2_cropcap *a)
 {
-        struct sh_vou_file *vou_file = priv;
+        struct sh_vou_device *vou_dev = video_drvdata(file);
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         a->type                         = V4L2_BUF_TYPE_VIDEO_OUTPUT;
         a->bounds.left                  = 0;
@@ -1091,7 +1089,7 @@ static irqreturn_t sh_vou_isr(int irq, void *dev_id)
         list_del(&vb->queue);
 
         vb->state = VIDEOBUF_DONE;
-        do_gettimeofday(&vb->ts);
+        v4l2_get_timestamp(&vb->ts);
         vb->field_count++;
         wake_up(&vb->done);
 
@@ -1160,8 +1158,7 @@ static int sh_vou_hw_init(struct sh_vou_device *vou_dev)
 /* File operations */
 static int sh_vou_open(struct file *file)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct sh_vou_file *vou_file = kzalloc(sizeof(struct sh_vou_file),
                                                GFP_KERNEL);
 
@@ -1178,11 +1175,11 @@ static int sh_vou_open(struct file *file)
                 int ret;
                 /* First open */
                 vou_dev->status = SH_VOU_INITIALISING;
-                pm_runtime_get_sync(vdev->v4l2_dev->dev);
+                pm_runtime_get_sync(vou_dev->v4l2_dev.dev);
                 ret = sh_vou_hw_init(vou_dev);
                 if (ret < 0) {
                         atomic_dec(&vou_dev->use_count);
-                        pm_runtime_put(vdev->v4l2_dev->dev);
+                        pm_runtime_put(vou_dev->v4l2_dev.dev);
                         vou_dev->status = SH_VOU_IDLE;
                         mutex_unlock(&vou_dev->fop_lock);
                         return ret;
@@ -1193,8 +1190,8 @@ static int sh_vou_open(struct file *file)
                                        vou_dev->v4l2_dev.dev, &vou_dev->lock,
                                        V4L2_BUF_TYPE_VIDEO_OUTPUT,
                                        V4L2_FIELD_NONE,
-                                       sizeof(struct videobuf_buffer), vdev,
-                                       &vou_dev->fop_lock);
+                                       sizeof(struct videobuf_buffer),
+                                       vou_dev->vdev, &vou_dev->fop_lock);
         mutex_unlock(&vou_dev->fop_lock);
 
         return 0;
@@ -1202,18 +1199,17 @@ static int sh_vou_open(struct file *file)
 
 static int sh_vou_release(struct file *file)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct sh_vou_file *vou_file = file->private_data;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         if (!atomic_dec_return(&vou_dev->use_count)) {
                 mutex_lock(&vou_dev->fop_lock);
                 /* Last close */
                 vou_dev->status = SH_VOU_IDLE;
                 sh_vou_reg_a_set(vou_dev, VOUER, 0, 0x101);
-                pm_runtime_put(vdev->v4l2_dev->dev);
+                pm_runtime_put(vou_dev->v4l2_dev.dev);
                 mutex_unlock(&vou_dev->fop_lock);
         }
 
@@ -1225,12 +1221,11 @@ static int sh_vou_release(struct file *file)
 
 static int sh_vou_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct sh_vou_file *vou_file = file->private_data;
         int ret;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         if (mutex_lock_interruptible(&vou_dev->fop_lock))
                 return -ERESTARTSYS;
@@ -1241,12 +1236,11 @@ static int sh_vou_mmap(struct file *file, struct vm_area_struct *vma)
 
 static unsigned int sh_vou_poll(struct file *file, poll_table *wait)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
         struct sh_vou_file *vou_file = file->private_data;
         unsigned int res;
 
-        dev_dbg(vou_file->vbq.dev, "%s()\n", __func__);
+        dev_dbg(vou_dev->v4l2_dev.dev, "%s()\n", __func__);
 
         mutex_lock(&vou_dev->fop_lock);
         res = videobuf_poll_stream(file, &vou_file->vbq, wait);
@@ -1257,8 +1251,7 @@ static unsigned int sh_vou_poll(struct file *file, poll_table *wait)
 static int sh_vou_g_chip_ident(struct file *file, void *fh,
                                    struct v4l2_dbg_chip_ident *id)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
 
         return v4l2_device_call_until_err(&vou_dev->v4l2_dev, 0, core, g_chip_ident, id);
 }
@@ -1267,8 +1260,7 @@ static int sh_vou_g_chip_ident(struct file *file, void *fh,
 static int sh_vou_g_register(struct file *file, void *fh,
                                  struct v4l2_dbg_register *reg)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
 
         return v4l2_device_call_until_err(&vou_dev->v4l2_dev, 0, core, g_register, reg);
 }
@@ -1276,8 +1268,7 @@ static int sh_vou_g_register(struct file *file, void *fh,
 static int sh_vou_s_register(struct file *file, void *fh,
                                  struct v4l2_dbg_register *reg)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct sh_vou_device *vou_dev = video_get_drvdata(vdev);
+        struct sh_vou_device *vou_dev = video_drvdata(file);
 
         return v4l2_device_call_until_err(&vou_dev->v4l2_dev, 0, core, s_register, reg);
 }
diff --git a/drivers/media/platform/soc_camera/Kconfig b/drivers/media/platform/soc_camera/Kconfig
index cb6791e62bd4..b139b525bb16 100644
--- a/drivers/media/platform/soc_camera/Kconfig
+++ b/drivers/media/platform/soc_camera/Kconfig
@@ -70,13 +70,12 @@ config VIDEO_MX2_HOSTSUPPORT
         bool
 
 config VIDEO_MX2
-        tristate "i.MX27/i.MX25 Camera Sensor Interface driver"
-        depends on VIDEO_DEV && SOC_CAMERA && (MACH_MX27 || (ARCH_MX25 && BROKEN))
+        tristate "i.MX27 Camera Sensor Interface driver"
+        depends on VIDEO_DEV && SOC_CAMERA && MACH_MX27
         select VIDEOBUF2_DMA_CONTIG
         select VIDEO_MX2_HOSTSUPPORT
         ---help---
-          This is a v4l2 driver for the i.MX27 and the i.MX25 Camera Sensor
-          Interface
+          This is a v4l2 driver for the i.MX27 Camera Sensor Interface
 
 config VIDEO_ATMEL_ISI
         tristate "ATMEL Image Sensor Interface (ISI) support"
diff --git a/drivers/media/platform/soc_camera/atmel-isi.c b/drivers/media/platform/soc_camera/atmel-isi.c
index d96c8c7e01d9..82dbf99d347c 100644
--- a/drivers/media/platform/soc_camera/atmel-isi.c
+++ b/drivers/media/platform/soc_camera/atmel-isi.c
@@ -166,7 +166,7 @@ static irqreturn_t atmel_isi_handle_streaming(struct atmel_isi *isi)
                 struct frame_buffer *buf = isi->active;
 
                 list_del_init(&buf->list);
-                do_gettimeofday(&vb->v4l2_buf.timestamp);
+                v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
                 vb->v4l2_buf.sequence = isi->sequence++;
                 vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
         }
@@ -745,7 +745,7 @@ static int isi_camera_get_formats(struct soc_camera_device *icd,
         return formats;
 }
 
-/* Called with .video_lock held */
+/* Called with .host_lock held */
 static int isi_camera_add_device(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
@@ -770,7 +770,7 @@ static int isi_camera_add_device(struct soc_camera_device *icd)
                  icd->devnum);
         return 0;
 }
-/* Called with .video_lock held */
+/* Called with .host_lock held */
 static void isi_camera_remove_device(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
diff --git a/drivers/media/platform/soc_camera/mx1_camera.c b/drivers/media/platform/soc_camera/mx1_camera.c
index 032b8c9097f9..25b2a285dc86 100644
--- a/drivers/media/platform/soc_camera/mx1_camera.c
+++ b/drivers/media/platform/soc_camera/mx1_camera.c
@@ -26,7 +26,6 @@
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
-#include <linux/mutex.h>
 #include <linux/platform_device.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
@@ -307,7 +306,7 @@ static void mx1_camera_wakeup(struct mx1_camera_dev *pcdev,
         /* _init is used to debug races, see comment in mx1_camera_reqbufs() */
         list_del_init(&vb->queue);
         vb->state = VIDEOBUF_DONE;
-        do_gettimeofday(&vb->ts);
+        v4l2_get_timestamp(&vb->ts);
         vb->field_count++;
         wake_up(&vb->done);
 
@@ -373,7 +372,7 @@ static void mx1_camera_init_videobuf(struct videobuf_queue *q,
         videobuf_queue_dma_contig_init(q, &mx1_videobuf_ops, icd->parent,
                                 &pcdev->lock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
                                 V4L2_FIELD_NONE,
-                                sizeof(struct mx1_buffer), icd, &icd->video_lock);
+                                sizeof(struct mx1_buffer), icd, &ici->host_lock);
 }
 
 static int mclk_get_divisor(struct mx1_camera_dev *pcdev)
diff --git a/drivers/media/platform/soc_camera/mx2_camera.c b/drivers/media/platform/soc_camera/mx2_camera.c
index 4a574f3cfb2f..ffba7d91f413 100644
--- a/drivers/media/platform/soc_camera/mx2_camera.c
+++ b/drivers/media/platform/soc_camera/mx2_camera.c
@@ -1,5 +1,5 @@
 /*
- * V4L2 Driver for i.MX27/i.MX25 camera host
+ * V4L2 Driver for i.MX27 camera host
  *
  * Copyright (C) 2008, Sascha Hauer, Pengutronix
  * Copyright (C) 2010, Baruch Siach, Orex Computed Radiography
@@ -28,7 +28,6 @@
 #include <linux/time.h>
 #include <linux/device.h>
 #include <linux/platform_device.h>
-#include <linux/mutex.h>
 #include <linux/clk.h>
 
 #include <media/v4l2-common.h>
@@ -64,9 +63,7 @@
 #define CSICR1_RF_OR_INTEN      (1 << 24)
 #define CSICR1_STATFF_LEVEL     (3 << 22)
 #define CSICR1_STATFF_INTEN     (1 << 21)
-#define CSICR1_RXFF_LEVEL(l)    (((l) & 3) << 19)       /* MX27 */
-#define CSICR1_FB2_DMA_INTEN    (1 << 20)               /* MX25 */
-#define CSICR1_FB1_DMA_INTEN    (1 << 19)               /* MX25 */
+#define CSICR1_RXFF_LEVEL(l)    (((l) & 3) << 19)
 #define CSICR1_RXFF_INTEN       (1 << 18)
 #define CSICR1_SOF_POL          (1 << 17)
 #define CSICR1_SOF_INTEN        (1 << 16)
@@ -88,45 +85,15 @@
 #define SHIFT_RXFF_LEVEL        19
 #define SHIFT_MCLKDIV           12
 
-/* control reg 3 */
-#define CSICR3_FRMCNT           (0xFFFF << 16)
-#define CSICR3_FRMCNT_RST       (1 << 15)
-#define CSICR3_DMA_REFLASH_RFF  (1 << 14)
-#define CSICR3_DMA_REFLASH_SFF  (1 << 13)
-#define CSICR3_DMA_REQ_EN_RFF   (1 << 12)
-#define CSICR3_DMA_REQ_EN_SFF   (1 << 11)
-#define CSICR3_RXFF_LEVEL(l)    (((l) & 7) << 4)        /* MX25 */
-#define CSICR3_CSI_SUP          (1 << 3)
-#define CSICR3_ZERO_PACK_EN     (1 << 2)
-#define CSICR3_ECC_INT_EN       (1 << 1)
-#define CSICR3_ECC_AUTO_EN      (1 << 0)
-
 #define SHIFT_FRMCNT            16
 
-/* csi status reg */
-#define CSISR_SFF_OR_INT        (1 << 25)
-#define CSISR_RFF_OR_INT        (1 << 24)
-#define CSISR_STATFF_INT        (1 << 21)
-#define CSISR_DMA_TSF_FB2_INT   (1 << 20)       /* MX25 */
-#define CSISR_DMA_TSF_FB1_INT   (1 << 19)       /* MX25 */
-#define CSISR_RXFF_INT          (1 << 18)
-#define CSISR_EOF_INT           (1 << 17)
-#define CSISR_SOF_INT           (1 << 16)
-#define CSISR_F2_INT            (1 << 15)
-#define CSISR_F1_INT            (1 << 14)
-#define CSISR_COF_INT           (1 << 13)
-#define CSISR_ECC_INT           (1 << 1)
-#define CSISR_DRDY              (1 << 0)
-
 #define CSICR1                  0x00
 #define CSICR2                  0x04
-#define CSISR_IMX25             0x18
-#define CSISR_IMX27             0x08
+#define CSISR                   0x08
 #define CSISTATFIFO             0x0c
 #define CSIRFIFO                0x10
 #define CSIRXCNT                0x14
-#define CSICR3_IMX25            0x08
-#define CSICR3_IMX27            0x1c
+#define CSICR3                  0x1c
 #define CSIDMASA_STATFIFO       0x20
 #define CSIDMATA_STATFIFO       0x24
 #define CSIDMASA_FB1            0x28
@@ -249,12 +216,6 @@ struct mx2_fmt_cfg {
         struct mx2_prp_cfg              cfg;
 };
 
-enum mx2_buffer_state {
-        MX2_STATE_QUEUED,
-        MX2_STATE_ACTIVE,
-        MX2_STATE_DONE,
-};
-
 struct mx2_buf_internal {
         struct list_head        queue;
         int                     bufnum;
@@ -265,12 +226,10 @@ struct mx2_buf_internal {
 struct mx2_buffer {
         /* common v4l buffer stuff -- must be first */
         struct vb2_buffer               vb;
-        enum mx2_buffer_state           state;
         struct mx2_buf_internal         internal;
 };
 
 enum mx2_camera_type {
-        IMX25_CAMERA,
         IMX27_CAMERA,
 };
 
@@ -298,8 +257,6 @@ struct mx2_camera_dev {
         struct mx2_buffer       *fb2_active;
 
         u32                     csicr1;
-        u32                     reg_csisr;
-        u32                     reg_csicr3;
         enum mx2_camera_type    devtype;
 
         struct mx2_buf_internal buf_discard[2];
@@ -315,9 +272,6 @@ struct mx2_camera_dev {
 
 static struct platform_device_id mx2_camera_devtype[] = {
         {
-                .name = "imx25-camera",
-                .driver_data = IMX25_CAMERA,
-        }, {
                 .name = "imx27-camera",
                 .driver_data = IMX27_CAMERA,
         }, {
@@ -326,16 +280,6 @@ static struct platform_device_id mx2_camera_devtype[] = {
 };
 MODULE_DEVICE_TABLE(platform, mx2_camera_devtype);
 
-static inline int is_imx25_camera(struct mx2_camera_dev *pcdev)
-{
-        return pcdev->devtype == IMX25_CAMERA;
-}
-
-static inline int is_imx27_camera(struct mx2_camera_dev *pcdev)
-{
-        return pcdev->devtype == IMX27_CAMERA;
-}
-
 static struct mx2_buffer *mx2_ibuf_to_buf(struct mx2_buf_internal *int_buf)
 {
         return container_of(int_buf, struct mx2_buffer, internal);
@@ -463,21 +407,10 @@ static void mx27_update_emma_buf(struct mx2_camera_dev *pcdev,
 
 static void mx2_camera_deactivate(struct mx2_camera_dev *pcdev)
 {
-        unsigned long flags;
-
         clk_disable_unprepare(pcdev->clk_csi_ahb);
         clk_disable_unprepare(pcdev->clk_csi_per);
         writel(0, pcdev->base_csi + CSICR1);
-        if (is_imx27_camera(pcdev)) {
-                writel(0, pcdev->base_emma + PRP_CNTL);
-        } else if (is_imx25_camera(pcdev)) {
-                spin_lock_irqsave(&pcdev->lock, flags);
-                pcdev->fb1_active = NULL;
-                pcdev->fb2_active = NULL;
-                writel(0, pcdev->base_csi + CSIDMASA_FB1);
-                writel(0, pcdev->base_csi + CSIDMASA_FB2);
-                spin_unlock_irqrestore(&pcdev->lock, flags);
-        }
+        writel(0, pcdev->base_emma + PRP_CNTL);
 }
 
 /*
@@ -502,11 +435,8 @@ static int mx2_camera_add_device(struct soc_camera_device *icd)
         if (ret < 0)
                 goto exit_csi_ahb;
 
-        csicr1 = CSICR1_MCLKEN;
-
-        if (is_imx27_camera(pcdev))
-                csicr1 |= CSICR1_PRP_IF_EN | CSICR1_FCC |
-                        CSICR1_RXFF_LEVEL(0);
+        csicr1 = CSICR1_MCLKEN | CSICR1_PRP_IF_EN | CSICR1_FCC |
+                CSICR1_RXFF_LEVEL(0);
 
         pcdev->csicr1 = csicr1;
         writel(pcdev->csicr1, pcdev->base_csi + CSICR1);
@@ -540,65 +470,6 @@ static void mx2_camera_remove_device(struct soc_camera_device *icd)
         pcdev->icd = NULL;
 }
 
-static void mx25_camera_frame_done(struct mx2_camera_dev *pcdev, int fb,
-                int state)
-{
-        struct vb2_buffer *vb;
-        struct mx2_buffer *buf;
-        struct mx2_buffer **fb_active = fb == 1 ? &pcdev->fb1_active :
-                &pcdev->fb2_active;
-        u32 fb_reg = fb == 1 ? CSIDMASA_FB1 : CSIDMASA_FB2;
-        unsigned long flags;
-
-        spin_lock_irqsave(&pcdev->lock, flags);
-
-        if (*fb_active == NULL)
-                goto out;
-
-        vb = &(*fb_active)->vb;
-        dev_dbg(pcdev->dev, "%s (vb=0x%p) 0x%p %lu\n", __func__,
-                vb, vb2_plane_vaddr(vb, 0), vb2_get_plane_payload(vb, 0));
-
-        do_gettimeofday(&vb->v4l2_buf.timestamp);
-        vb->v4l2_buf.sequence++;
-        vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
-
-        if (list_empty(&pcdev->capture)) {
-                buf = NULL;
-                writel(0, pcdev->base_csi + fb_reg);
-        } else {
-                buf = list_first_entry(&pcdev->capture, struct mx2_buffer,
-                                internal.queue);
-                vb = &buf->vb;
-                list_del(&buf->internal.queue);
-                buf->state = MX2_STATE_ACTIVE;
-                writel(vb2_dma_contig_plane_dma_addr(vb, 0),
-                       pcdev->base_csi + fb_reg);
-        }
-
-        *fb_active = buf;
-
-out:
-        spin_unlock_irqrestore(&pcdev->lock, flags);
-}
-
-static irqreturn_t mx25_camera_irq(int irq_csi, void *data)
-{
-        struct mx2_camera_dev *pcdev = data;
-        u32 status = readl(pcdev->base_csi + pcdev->reg_csisr);
-
-        if (status & CSISR_DMA_TSF_FB1_INT)
-                mx25_camera_frame_done(pcdev, 1, MX2_STATE_DONE);
-        else if (status & CSISR_DMA_TSF_FB2_INT)
-                mx25_camera_frame_done(pcdev, 2, MX2_STATE_DONE);
-
-        /* FIXME: handle CSISR_RFF_OR_INT */
-
-        writel(status, pcdev->base_csi + pcdev->reg_csisr);
-
-        return IRQ_HANDLED;
-}
-
 /*
  *  Videobuf operations
  */
@@ -676,97 +547,8 @@ static void mx2_videobuf_queue(struct vb2_buffer *vb)
 
         spin_lock_irqsave(&pcdev->lock, flags);
 
-        buf->state = MX2_STATE_QUEUED;
         list_add_tail(&buf->internal.queue, &pcdev->capture);
 
-        if (is_imx25_camera(pcdev)) {
-                u32 csicr3, dma_inten = 0;
-
-                if (pcdev->fb1_active == NULL) {
-                        writel(vb2_dma_contig_plane_dma_addr(vb, 0),
-                                        pcdev->base_csi + CSIDMASA_FB1);
-                        pcdev->fb1_active = buf;
-                        dma_inten = CSICR1_FB1_DMA_INTEN;
-                } else if (pcdev->fb2_active == NULL) {
-                        writel(vb2_dma_contig_plane_dma_addr(vb, 0),
-                                        pcdev->base_csi + CSIDMASA_FB2);
-                        pcdev->fb2_active = buf;
-                        dma_inten = CSICR1_FB2_DMA_INTEN;
-                }
-
-                if (dma_inten) {
-                        list_del(&buf->internal.queue);
-                        buf->state = MX2_STATE_ACTIVE;
-
-                        csicr3 = readl(pcdev->base_csi + pcdev->reg_csicr3);
-
-                        /* Reflash DMA */
-                        writel(csicr3 | CSICR3_DMA_REFLASH_RFF,
-                                        pcdev->base_csi + pcdev->reg_csicr3);
-
-                        /* clear & enable interrupts */
-                        writel(dma_inten, pcdev->base_csi + pcdev->reg_csisr);
-                        pcdev->csicr1 |= dma_inten;
-                        writel(pcdev->csicr1, pcdev->base_csi + CSICR1);
-
-                        /* enable DMA */
-                        csicr3 |= CSICR3_DMA_REQ_EN_RFF | CSICR3_RXFF_LEVEL(1);
-                        writel(csicr3, pcdev->base_csi + pcdev->reg_csicr3);
-                }
-        }
-
-        spin_unlock_irqrestore(&pcdev->lock, flags);
-}
-
-static void mx2_videobuf_release(struct vb2_buffer *vb)
-{
-        struct soc_camera_device *icd = soc_camera_from_vb2q(vb->vb2_queue);
-        struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-        struct mx2_camera_dev *pcdev = ici->priv;
-        struct mx2_buffer *buf = container_of(vb, struct mx2_buffer, vb);
-        unsigned long flags;
-
-#ifdef DEBUG
-        dev_dbg(icd->parent, "%s (vb=0x%p) 0x%p %lu\n", __func__,
-                vb, vb2_plane_vaddr(vb, 0), vb2_get_plane_payload(vb, 0));
-
-        switch (buf->state) {
-        case MX2_STATE_ACTIVE:
-                dev_info(icd->parent, "%s (active)\n", __func__);
-                break;
-        case MX2_STATE_QUEUED:
-                dev_info(icd->parent, "%s (queued)\n", __func__);
-                break;
-        default:
-                dev_info(icd->parent, "%s (unknown) %d\n", __func__,
-                                buf->state);
-                break;
-        }
-#endif
-
-        /*
-         * Terminate only queued but inactive buffers. Active buffers are
-         * released when they become inactive after videobuf_waiton().
-         *
-         * FIXME: implement forced termination of active buffers for mx27 and
-         * mx27 eMMA, so that the user won't get stuck in an uninterruptible
-         * state. This requires a specific handling for each of the these DMA
-         * types.
-         */
-
-        spin_lock_irqsave(&pcdev->lock, flags);
-        if (is_imx25_camera(pcdev) && buf->state == MX2_STATE_ACTIVE) {
-                if (pcdev->fb1_active == buf) {
-                        pcdev->csicr1 &= ~CSICR1_FB1_DMA_INTEN;
-                        writel(0, pcdev->base_csi + CSIDMASA_FB1);
-                        pcdev->fb1_active = NULL;
-                } else if (pcdev->fb2_active == buf) {
-                        pcdev->csicr1 &= ~CSICR1_FB2_DMA_INTEN;
-                        writel(0, pcdev->base_csi + CSIDMASA_FB2);
-                        pcdev->fb2_active = NULL;
-                }
-                writel(pcdev->csicr1, pcdev->base_csi + CSICR1);
-        }
         spin_unlock_irqrestore(&pcdev->lock, flags);
 }
 
@@ -877,91 +659,87 @@ static int mx2_start_streaming(struct vb2_queue *q, unsigned int count)
         struct mx2_buffer *buf;
         unsigned long phys;
         int bytesperline;
+        unsigned long flags;
 
-        if (is_imx27_camera(pcdev)) {
-                unsigned long flags;
-                if (count < 2)
-                        return -EINVAL;
+        if (count < 2)
+                return -EINVAL;
 
-                spin_lock_irqsave(&pcdev->lock, flags);
+        spin_lock_irqsave(&pcdev->lock, flags);
 
-                buf = list_first_entry(&pcdev->capture, struct mx2_buffer,
-                                       internal.queue);
-                buf->internal.bufnum = 0;
-                vb = &buf->vb;
-                buf->state = MX2_STATE_ACTIVE;
+        buf = list_first_entry(&pcdev->capture, struct mx2_buffer,
+                               internal.queue);
+        buf->internal.bufnum = 0;
+        vb = &buf->vb;
 
-                phys = vb2_dma_contig_plane_dma_addr(vb, 0);
-                mx27_update_emma_buf(pcdev, phys, buf->internal.bufnum);
-                list_move_tail(pcdev->capture.next, &pcdev->active_bufs);
+        phys = vb2_dma_contig_plane_dma_addr(vb, 0);
+        mx27_update_emma_buf(pcdev, phys, buf->internal.bufnum);
+        list_move_tail(pcdev->capture.next, &pcdev->active_bufs);
 
-                buf = list_first_entry(&pcdev->capture, struct mx2_buffer,
-                                       internal.queue);
-                buf->internal.bufnum = 1;
-                vb = &buf->vb;
-                buf->state = MX2_STATE_ACTIVE;
+        buf = list_first_entry(&pcdev->capture, struct mx2_buffer,
+                               internal.queue);
+        buf->internal.bufnum = 1;
+        vb = &buf->vb;
 
-                phys = vb2_dma_contig_plane_dma_addr(vb, 0);
-                mx27_update_emma_buf(pcdev, phys, buf->internal.bufnum);
-                list_move_tail(pcdev->capture.next, &pcdev->active_bufs);
-
-                bytesperline = soc_mbus_bytes_per_line(icd->user_width,
-                                icd->current_fmt->host_fmt);
-                if (bytesperline < 0) {
-                        spin_unlock_irqrestore(&pcdev->lock, flags);
-                        return bytesperline;
-                }
+        phys = vb2_dma_contig_plane_dma_addr(vb, 0);
+        mx27_update_emma_buf(pcdev, phys, buf->internal.bufnum);
+        list_move_tail(pcdev->capture.next, &pcdev->active_bufs);
 
-                /*
-                 * I didn't manage to properly enable/disable the prp
-                 * on a per frame basis during running transfers,
-                 * thus we allocate a buffer here and use it to
-                 * discard frames when no buffer is available.
-                 * Feel free to work on this ;)
-                 */
-                pcdev->discard_size = icd->user_height * bytesperline;
-                pcdev->discard_buffer = dma_alloc_coherent(ici->v4l2_dev.dev,
-                                pcdev->discard_size, &pcdev->discard_buffer_dma,
-                                GFP_KERNEL);
-                if (!pcdev->discard_buffer) {
-                        spin_unlock_irqrestore(&pcdev->lock, flags);
-                        return -ENOMEM;
-                }
+        bytesperline = soc_mbus_bytes_per_line(icd->user_width,
+                                               icd->current_fmt->host_fmt);
+        if (bytesperline < 0) {
+                spin_unlock_irqrestore(&pcdev->lock, flags);
+                return bytesperline;
+        }
 
-                pcdev->buf_discard[0].discard = true;
-                list_add_tail(&pcdev->buf_discard[0].queue,
-                                      &pcdev->discard);
+        /*
+         * I didn't manage to properly enable/disable the prp
+         * on a per frame basis during running transfers,
+         * thus we allocate a buffer here and use it to
+         * discard frames when no buffer is available.
+         * Feel free to work on this ;)
+         */
+        pcdev->discard_size = icd->user_height * bytesperline;
+        pcdev->discard_buffer = dma_alloc_coherent(ici->v4l2_dev.dev,
+                                        pcdev->discard_size,
+                                        &pcdev->discard_buffer_dma, GFP_ATOMIC);
+        if (!pcdev->discard_buffer) {
+                spin_unlock_irqrestore(&pcdev->lock, flags);
+                return -ENOMEM;
+        }
 
-                pcdev->buf_discard[1].discard = true;
-                list_add_tail(&pcdev->buf_discard[1].queue,
-                                      &pcdev->discard);
+        pcdev->buf_discard[0].discard = true;
+        list_add_tail(&pcdev->buf_discard[0].queue,
+                      &pcdev->discard);
 
-                mx2_prp_resize_commit(pcdev);
+        pcdev->buf_discard[1].discard = true;
+        list_add_tail(&pcdev->buf_discard[1].queue,
+                      &pcdev->discard);
 
-                mx27_camera_emma_buf_init(icd, bytesperline);
+        mx2_prp_resize_commit(pcdev);
 
-                if (prp->cfg.channel == 1) {
-                        writel(PRP_CNTL_CH1EN |
-                                PRP_CNTL_CSIEN |
-                                prp->cfg.in_fmt |
-                                prp->cfg.out_fmt |
-                                PRP_CNTL_CH1_LEN |
-                                PRP_CNTL_CH1BYP |
-                                PRP_CNTL_CH1_TSKIP(0) |
-                                PRP_CNTL_IN_TSKIP(0),
-                                pcdev->base_emma + PRP_CNTL);
-                } else {
-                        writel(PRP_CNTL_CH2EN |
-                                PRP_CNTL_CSIEN |
-                                prp->cfg.in_fmt |
-                                prp->cfg.out_fmt |
-                                PRP_CNTL_CH2_LEN |
-                                PRP_CNTL_CH2_TSKIP(0) |
-                                PRP_CNTL_IN_TSKIP(0),
-                                pcdev->base_emma + PRP_CNTL);
-                }
-                spin_unlock_irqrestore(&pcdev->lock, flags);
+        mx27_camera_emma_buf_init(icd, bytesperline);
+
+        if (prp->cfg.channel == 1) {
+                writel(PRP_CNTL_CH1EN |
+                       PRP_CNTL_CSIEN |
+                       prp->cfg.in_fmt |
+                       prp->cfg.out_fmt |
+                       PRP_CNTL_CH1_LEN |
+                       PRP_CNTL_CH1BYP |
+                       PRP_CNTL_CH1_TSKIP(0) |
+                       PRP_CNTL_IN_TSKIP(0),
+                       pcdev->base_emma + PRP_CNTL);
+        } else {
+                writel(PRP_CNTL_CH2EN |
+                       PRP_CNTL_CSIEN |
+                       prp->cfg.in_fmt |
+                       prp->cfg.out_fmt |
+                       PRP_CNTL_CH2_LEN |
+                       PRP_CNTL_CH2_TSKIP(0) |
+                       PRP_CNTL_IN_TSKIP(0),
+                       pcdev->base_emma + PRP_CNTL);
         }
+        spin_unlock_irqrestore(&pcdev->lock, flags);
 
         return 0;
 }
@@ -977,29 +755,27 @@ static int mx2_stop_streaming(struct vb2_queue *q)
         void *b;
         u32 cntl;
 
-        if (is_imx27_camera(pcdev)) {
-                spin_lock_irqsave(&pcdev->lock, flags);
+        spin_lock_irqsave(&pcdev->lock, flags);
 
-                cntl = readl(pcdev->base_emma + PRP_CNTL);
-                if (prp->cfg.channel == 1) {
-                        writel(cntl & ~PRP_CNTL_CH1EN,
-                               pcdev->base_emma + PRP_CNTL);
-                } else {
-                        writel(cntl & ~PRP_CNTL_CH2EN,
-                               pcdev->base_emma + PRP_CNTL);
-                }
-                INIT_LIST_HEAD(&pcdev->capture);
-                INIT_LIST_HEAD(&pcdev->active_bufs);
-                INIT_LIST_HEAD(&pcdev->discard);
+        cntl = readl(pcdev->base_emma + PRP_CNTL);
+        if (prp->cfg.channel == 1) {
+                writel(cntl & ~PRP_CNTL_CH1EN,
+                       pcdev->base_emma + PRP_CNTL);
+        } else {
+                writel(cntl & ~PRP_CNTL_CH2EN,
+                       pcdev->base_emma + PRP_CNTL);
+        }
+        INIT_LIST_HEAD(&pcdev->capture);
+        INIT_LIST_HEAD(&pcdev->active_bufs);
+        INIT_LIST_HEAD(&pcdev->discard);
 
-                b = pcdev->discard_buffer;
-                pcdev->discard_buffer = NULL;
+        b = pcdev->discard_buffer;
+        pcdev->discard_buffer = NULL;
 
-                spin_unlock_irqrestore(&pcdev->lock, flags);
+        spin_unlock_irqrestore(&pcdev->lock, flags);
 
-                dma_free_coherent(ici->v4l2_dev.dev,
-                        pcdev->discard_size, b, pcdev->discard_buffer_dma);
-        }
+        dma_free_coherent(ici->v4l2_dev.dev,
+                          pcdev->discard_size, b, pcdev->discard_buffer_dma);
 
         return 0;
 }
@@ -1008,7 +784,6 @@ static struct vb2_ops mx2_videobuf_ops = {
         .queue_setup     = mx2_videobuf_setup,
         .buf_prepare     = mx2_videobuf_prepare,
         .buf_queue       = mx2_videobuf_queue,
-        .buf_cleanup     = mx2_videobuf_release,
         .start_streaming = mx2_start_streaming,
         .stop_streaming  = mx2_stop_streaming,
 };
@@ -1129,16 +904,9 @@ static int mx2_camera_set_bus_param(struct soc_camera_device *icd)
         if (bytesperline < 0)
                 return bytesperline;
 
-        if (is_imx27_camera(pcdev)) {
-                ret = mx27_camera_emma_prp_reset(pcdev);
-                if (ret)
-                        return ret;
-        } else if (is_imx25_camera(pcdev)) {
-                writel((bytesperline * icd->user_height) >> 2,
-                                pcdev->base_csi + CSIRXCNT);
-                writel((bytesperline << 16) | icd->user_height,
-                                pcdev->base_csi + CSIIMAG_PARA);
-        }
+        ret = mx27_camera_emma_prp_reset(pcdev);
+        if (ret)
+                return ret;
 
         writel(pcdev->csicr1, pcdev->base_csi + CSICR1);
 
@@ -1425,7 +1193,6 @@ static int mx2_camera_try_fmt(struct soc_camera_device *icd,
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
         struct mx2_camera_dev *pcdev = ici->priv;
         struct mx2_fmt_cfg *emma_prp;
-        unsigned int width_limit;
         int ret;
 
         dev_dbg(icd->parent, "%s: requested params: width = %d, height = %d\n",
@@ -1437,40 +1204,11 @@ static int mx2_camera_try_fmt(struct soc_camera_device *icd,
                 return -EINVAL;
         }
 
-        /* FIXME: implement MX27 limits */
-
-        /* limit to MX25 hardware capabilities */
-        if (is_imx25_camera(pcdev)) {
-                if (xlate->host_fmt->bits_per_sample <= 8)
-                        width_limit = 0xffff * 4;
-                else
-                        width_limit = 0xffff * 2;
-                /* CSIIMAG_PARA limit */
-                if (pix->width > width_limit)
-                        pix->width = width_limit;
-                if (pix->height > 0xffff)
-                        pix->height = 0xffff;
-
-                pix->bytesperline = soc_mbus_bytes_per_line(pix->width,
-                                xlate->host_fmt);
-                if (pix->bytesperline < 0)
-                        return pix->bytesperline;
-                pix->sizeimage = soc_mbus_image_size(xlate->host_fmt,
-                                                pix->bytesperline, pix->height);
-                /* Check against the CSIRXCNT limit */
-                if (pix->sizeimage > 4 * 0x3ffff) {
-                        /* Adjust geometry, preserve aspect ratio */
-                        unsigned int new_height = int_sqrt(div_u64(0x3ffffULL *
-                                        4 * pix->height, pix->bytesperline));
-                        pix->width = new_height * pix->width / pix->height;
-                        pix->height = new_height;
-                        pix->bytesperline = soc_mbus_bytes_per_line(pix->width,
-                                                        xlate->host_fmt);
-                        BUG_ON(pix->bytesperline < 0);
-                        pix->sizeimage = soc_mbus_image_size(xlate->host_fmt,
-                                                pix->bytesperline, pix->height);
-                }
-        }
+        /*
+         * limit to MX27 hardware capabilities: width must be a multiple of 8 as
+         * requested by the CSI. (Table 39-2 in the i.MX27 Reference Manual).
+         */
+        pix->width &= ~0x7;
 
         /* limit to sensor capabilities */
         mf.width        = pix->width;
@@ -1488,7 +1226,7 @@ static int mx2_camera_try_fmt(struct soc_camera_device *icd,
 
         /* If the sensor does not support image size try PrP resizing */
         emma_prp = mx27_emma_prp_get_format(xlate->code,
-                                                   xlate->host_fmt->fourcc);
+                                            xlate->host_fmt->fourcc);
 
         if ((mf.width != pix->width || mf.height != pix->height) &&
                 emma_prp->cfg.in_fmt == PRP_CNTL_DATA_IN_YUV422) {
@@ -1600,7 +1338,7 @@ static void mx27_camera_frame_done_emma(struct mx2_camera_dev *pcdev,
                                 vb2_get_plane_payload(vb, 0));
 
                 list_del_init(&buf->internal.queue);
-                do_gettimeofday(&vb->v4l2_buf.timestamp);
+                v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
                 vb->v4l2_buf.sequence = pcdev->frame_count;
                 if (err)
                         vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
@@ -1634,7 +1372,6 @@ static void mx27_camera_frame_done_emma(struct mx2_camera_dev *pcdev,
         list_move_tail(pcdev->capture.next, &pcdev->active_bufs);
 
         vb = &buf->vb;
-        buf->state = MX2_STATE_ACTIVE;
 
         phys = vb2_dma_contig_plane_dma_addr(vb, 0);
         mx27_update_emma_buf(pcdev, phys, bufnum);
@@ -1774,20 +1511,6 @@ static int mx2_camera_probe(struct platform_device *pdev)
                 goto exit;
         }
 
-        pcdev->devtype = pdev->id_entry->driver_data;
-        switch (pcdev->devtype) {
-        case IMX25_CAMERA:
-                pcdev->reg_csisr = CSISR_IMX25;
-                pcdev->reg_csicr3 = CSICR3_IMX25;
-                break;
-        case IMX27_CAMERA:
-                pcdev->reg_csisr = CSISR_IMX27;
-                pcdev->reg_csicr3 = CSICR3_IMX27;
-                break;
-        default:
-                break;
-        }
-
         pcdev->clk_csi_ahb = devm_clk_get(&pdev->dev, "ahb");
         if (IS_ERR(pcdev->clk_csi_ahb)) {
                 dev_err(&pdev->dev, "Could not get csi ahb clock\n");
@@ -1833,20 +1556,9 @@ static int mx2_camera_probe(struct platform_device *pdev)
         pcdev->dev = &pdev->dev;
         platform_set_drvdata(pdev, pcdev);
 
-        if (is_imx25_camera(pcdev)) {
-                err = devm_request_irq(&pdev->dev, irq_csi, mx25_camera_irq, 0,
-                                       MX2_CAM_DRV_NAME, pcdev);
-                if (err) {
-                        dev_err(pcdev->dev, "Camera interrupt register failed \n");
-                        goto exit;
-                }
-        }
-
-        if (is_imx27_camera(pcdev)) {
-                err = mx27_camera_emma_init(pdev);
-                if (err)
-                        goto exit;
-        }
+        err = mx27_camera_emma_init(pdev);
+        if (err)
+                goto exit;
 
         /*
          * We're done with drvdata here.  Clear the pointer so that
@@ -1859,8 +1571,6 @@ static int mx2_camera_probe(struct platform_device *pdev)
         pcdev->soc_host.priv            = pcdev;
         pcdev->soc_host.v4l2_dev.dev    = &pdev->dev;
         pcdev->soc_host.nr              = pdev->id;
-        if (is_imx25_camera(pcdev))
-                pcdev->soc_host.capabilities = SOCAM_HOST_CAP_STRIDE;
 
         pcdev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
         if (IS_ERR(pcdev->alloc_ctx)) {
@@ -1879,10 +1589,8 @@ static int mx2_camera_probe(struct platform_device *pdev)
 exit_free_emma:
         vb2_dma_contig_cleanup_ctx(pcdev->alloc_ctx);
 eallocctx:
-        if (is_imx27_camera(pcdev)) {
-                clk_disable_unprepare(pcdev->clk_emma_ipg);
-                clk_disable_unprepare(pcdev->clk_emma_ahb);
-        }
+        clk_disable_unprepare(pcdev->clk_emma_ipg);
+        clk_disable_unprepare(pcdev->clk_emma_ahb);
 exit:
         return err;
 }
@@ -1897,10 +1605,8 @@ static int mx2_camera_remove(struct platform_device *pdev)
 
         vb2_dma_contig_cleanup_ctx(pcdev->alloc_ctx);
 
-        if (is_imx27_camera(pcdev)) {
-                clk_disable_unprepare(pcdev->clk_emma_ipg);
-                clk_disable_unprepare(pcdev->clk_emma_ahb);
-        }
+        clk_disable_unprepare(pcdev->clk_emma_ipg);
+        clk_disable_unprepare(pcdev->clk_emma_ahb);
 
         dev_info(&pdev->dev, "MX2 Camera driver unloaded\n");
 
@@ -1913,23 +1619,12 @@ static struct platform_driver mx2_camera_driver = {
         },
         .id_table       = mx2_camera_devtype,
         .remove         = mx2_camera_remove,
+        .probe          = mx2_camera_probe,
 };
 
+module_platform_driver(mx2_camera_driver);
 
-static int __init mx2_camera_init(void)
-{
-        return platform_driver_probe(&mx2_camera_driver, &mx2_camera_probe);
-}
-
-static void __exit mx2_camera_exit(void)
-{
-        return platform_driver_unregister(&mx2_camera_driver);
-}
-
-module_init(mx2_camera_init);
-module_exit(mx2_camera_exit);
-
-MODULE_DESCRIPTION("i.MX27/i.MX25 SoC Camera Host driver");
+MODULE_DESCRIPTION("i.MX27 SoC Camera Host driver");
 MODULE_AUTHOR("Sascha Hauer <sha@pengutronix.de>");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(MX2_CAM_VERSION);
diff --git a/drivers/media/platform/soc_camera/mx3_camera.c b/drivers/media/platform/soc_camera/mx3_camera.c
index 45aef1053a49..f5cbb92db545 100644
--- a/drivers/media/platform/soc_camera/mx3_camera.c
+++ b/drivers/media/platform/soc_camera/mx3_camera.c
@@ -156,7 +156,7 @@ static void mx3_cam_dma_done(void *arg)
                 struct mx3_camera_buffer *buf = to_mx3_vb(vb);
 
                 list_del_init(&buf->queue);
-                do_gettimeofday(&vb->v4l2_buf.timestamp);
+                v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
                 vb->v4l2_buf.field = mx3_cam->field;
                 vb->v4l2_buf.sequence = mx3_cam->sequence++;
                 vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
@@ -510,7 +510,7 @@ static void mx3_camera_activate(struct mx3_camera_dev *mx3_cam,
                 clk_set_rate(mx3_cam->clk, rate);
 }
 
-/* Called with .video_lock held */
+/* Called with .host_lock held */
 static int mx3_camera_add_device(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
@@ -530,7 +530,7 @@ static int mx3_camera_add_device(struct soc_camera_device *icd)
         return 0;
 }
 
-/* Called with .video_lock held */
+/* Called with .host_lock held */
 static void mx3_camera_remove_device(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
diff --git a/drivers/media/platform/soc_camera/omap1_camera.c b/drivers/media/platform/soc_camera/omap1_camera.c
index 39a77f0b8860..2547bf88f79f 100644
--- a/drivers/media/platform/soc_camera/omap1_camera.c
+++ b/drivers/media/platform/soc_camera/omap1_camera.c
@@ -592,7 +592,7 @@ static void videobuf_done(struct omap1_cam_dev *pcdev,
                         suspend_capture(pcdev);
                 }
                 vb->state = result;
-                do_gettimeofday(&vb->ts);
+                v4l2_get_timestamp(&vb->ts);
                 if (result != VIDEOBUF_ERROR)
                         vb->field_count++;
                 wake_up(&vb->done);
@@ -1383,12 +1383,12 @@ static void omap1_cam_init_videobuf(struct videobuf_queue *q,
                 videobuf_queue_dma_contig_init(q, &omap1_videobuf_ops,
                                 icd->parent, &pcdev->lock,
                                 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
-                                sizeof(struct omap1_cam_buf), icd, &icd->video_lock);
+                                sizeof(struct omap1_cam_buf), icd, &ici->host_lock);
         else
                 videobuf_queue_sg_init(q, &omap1_videobuf_ops,
                                 icd->parent, &pcdev->lock,
                                 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
-                                sizeof(struct omap1_cam_buf), icd, &icd->video_lock);
+                                sizeof(struct omap1_cam_buf), icd, &ici->host_lock);
 
         /* use videobuf mode (auto)selected with the module parameter */
         pcdev->vb_mode = sg_mode ? OMAP1_CAM_DMA_SG : OMAP1_CAM_DMA_CONTIG;
diff --git a/drivers/media/platform/soc_camera/pxa_camera.c b/drivers/media/platform/soc_camera/pxa_camera.c
index 523330d00dee..395e2e043615 100644
--- a/drivers/media/platform/soc_camera/pxa_camera.c
+++ b/drivers/media/platform/soc_camera/pxa_camera.c
@@ -681,7 +681,7 @@ static void pxa_camera_wakeup(struct pxa_camera_dev *pcdev,
         /* _init is used to debug races, see comment in pxa_camera_reqbufs() */
         list_del_init(&vb->queue);
         vb->state = VIDEOBUF_DONE;
-        do_gettimeofday(&vb->ts);
+        v4l2_get_timestamp(&vb->ts);
         vb->field_count++;
         wake_up(&vb->done);
         dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s dequeud buffer (vb=0x%p)\n",
@@ -842,7 +842,7 @@ static void pxa_camera_init_videobuf(struct videobuf_queue *q,
          */
         videobuf_queue_sg_init(q, &pxa_videobuf_ops, NULL, &pcdev->lock,
                                 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
-                                sizeof(struct pxa_buffer), icd, &icd->video_lock);
+                                sizeof(struct pxa_buffer), icd, &ici->host_lock);
 }
 
 static u32 mclk_get_divisor(struct platform_device *pdev,
@@ -958,7 +958,7 @@ static irqreturn_t pxa_camera_irq(int irq, void *data)
 /*
  * The following two functions absolutely depend on the fact, that
  * there can be only one camera on PXA quick capture interface
- * Called with .video_lock held
+ * Called with .host_lock held
  */
 static int pxa_camera_add_device(struct soc_camera_device *icd)
 {
@@ -978,7 +978,7 @@ static int pxa_camera_add_device(struct soc_camera_device *icd)
         return 0;
 }
 
-/* Called with .video_lock held */
+/* Called with .host_lock held */
 static void pxa_camera_remove_device(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
@@ -1661,23 +1661,18 @@ static int pxa_camera_probe(struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_irq(pdev, 0);
-        if (!res || irq < 0) {
-                err = -ENODEV;
-                goto exit;
-        }
+        if (!res || irq < 0)
+                return -ENODEV;
 
-        pcdev = kzalloc(sizeof(*pcdev), GFP_KERNEL);
+        pcdev = devm_kzalloc(&pdev->dev, sizeof(*pcdev), GFP_KERNEL);
         if (!pcdev) {
                 dev_err(&pdev->dev, "Could not allocate pcdev\n");
-                err = -ENOMEM;
-                goto exit;
+                return -ENOMEM;
         }
 
-        pcdev->clk = clk_get(&pdev->dev, NULL);
-        if (IS_ERR(pcdev->clk)) {
-                err = PTR_ERR(pcdev->clk);
-                goto exit_kfree;
-        }
+        pcdev->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(pcdev->clk))
+                return PTR_ERR(pcdev->clk);
 
         pcdev->res = res;
 
@@ -1715,17 +1710,9 @@ static int pxa_camera_probe(struct platform_device *pdev)
         /*
          * Request the regions.
          */
-        if (!request_mem_region(res->start, resource_size(res),
-                                PXA_CAM_DRV_NAME)) {
-                err = -EBUSY;
-                goto exit_clk;
-        }
-
-        base = ioremap(res->start, resource_size(res));
-        if (!base) {
-                err = -ENOMEM;
-                goto exit_release;
-        }
+        base = devm_request_and_ioremap(&pdev->dev, res);
+        if (!base)
+                return -ENOMEM;
         pcdev->irq = irq;
         pcdev->base = base;
 
@@ -1734,7 +1721,7 @@ static int pxa_camera_probe(struct platform_device *pdev)
                               pxa_camera_dma_irq_y, pcdev);
         if (err < 0) {
                 dev_err(&pdev->dev, "Can't request DMA for Y\n");
-                goto exit_iounmap;
+                return err;
         }
         pcdev->dma_chans[0] = err;
         dev_dbg(&pdev->dev, "got DMA channel %d\n", pcdev->dma_chans[0]);
@@ -1762,10 +1749,10 @@ static int pxa_camera_probe(struct platform_device *pdev)
         DRCMR(70) = pcdev->dma_chans[2] | DRCMR_MAPVLD;
 
         /* request irq */
-        err = request_irq(pcdev->irq, pxa_camera_irq, 0, PXA_CAM_DRV_NAME,
-                          pcdev);
+        err = devm_request_irq(&pdev->dev, pcdev->irq, pxa_camera_irq, 0,
+                               PXA_CAM_DRV_NAME, pcdev);
         if (err) {
-                dev_err(&pdev->dev, "Camera interrupt register failed \n");
+                dev_err(&pdev->dev, "Camera interrupt register failed\n");
                 goto exit_free_dma;
         }
 
@@ -1777,27 +1764,16 @@ static int pxa_camera_probe(struct platform_device *pdev)
 
         err = soc_camera_host_register(&pcdev->soc_host);
         if (err)
-                goto exit_free_irq;
+                goto exit_free_dma;
 
         return 0;
 
-exit_free_irq:
-        free_irq(pcdev->irq, pcdev);
 exit_free_dma:
         pxa_free_dma(pcdev->dma_chans[2]);
 exit_free_dma_u:
         pxa_free_dma(pcdev->dma_chans[1]);
 exit_free_dma_y:
         pxa_free_dma(pcdev->dma_chans[0]);
-exit_iounmap:
-        iounmap(base);
-exit_release:
-        release_mem_region(res->start, resource_size(res));
-exit_clk:
-        clk_put(pcdev->clk);
-exit_kfree:
-        kfree(pcdev);
-exit:
         return err;
 }
 
@@ -1806,24 +1782,13 @@ static int pxa_camera_remove(struct platform_device *pdev)
         struct soc_camera_host *soc_host = to_soc_camera_host(&pdev->dev);
         struct pxa_camera_dev *pcdev = container_of(soc_host,
                                         struct pxa_camera_dev, soc_host);
-        struct resource *res;
-
-        clk_put(pcdev->clk);
 
         pxa_free_dma(pcdev->dma_chans[0]);
         pxa_free_dma(pcdev->dma_chans[1]);
         pxa_free_dma(pcdev->dma_chans[2]);
-        free_irq(pcdev->irq, pcdev);
 
         soc_camera_host_unregister(soc_host);
 
-        iounmap(pcdev->base);
-
-        res = pcdev->res;
-        release_mem_region(res->start, resource_size(res));
-
-        kfree(pcdev);
-
         dev_info(&pdev->dev, "PXA Camera driver unloaded\n");
 
         return 0;
diff --git a/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c b/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c
index ebbc126e71a6..bb08a46432f4 100644
--- a/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c
+++ b/drivers/media/platform/soc_camera/sh_mobile_ceu_camera.c
@@ -516,7 +516,7 @@ static irqreturn_t sh_mobile_ceu_irq(int irq, void *data)
                 pcdev->active = NULL;
 
         ret = sh_mobile_ceu_capture(pcdev);
-        do_gettimeofday(&vb->v4l2_buf.timestamp);
+        v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
         if (!ret) {
                 vb->v4l2_buf.field = pcdev->field;
                 vb->v4l2_buf.sequence = pcdev->sequence++;
@@ -543,7 +543,7 @@ static struct v4l2_subdev *find_csi2(struct sh_mobile_ceu_dev *pcdev)
         return NULL;
 }
 
-/* Called with .video_lock held */
+/* Called with .host_lock held */
 static int sh_mobile_ceu_add_device(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
@@ -572,7 +572,7 @@ static int sh_mobile_ceu_add_device(struct soc_camera_device *icd)
 
         ret = v4l2_subdev_call(csi2_sd, core, s_power, 1);
         if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV) {
-                pm_runtime_put_sync(ici->v4l2_dev.dev);
+                pm_runtime_put(ici->v4l2_dev.dev);
                 return ret;
         }
 
@@ -587,7 +587,7 @@ static int sh_mobile_ceu_add_device(struct soc_camera_device *icd)
         return 0;
 }
 
-/* Called with .video_lock held */
+/* Called with .host_lock held */
 static void sh_mobile_ceu_remove_device(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
@@ -612,7 +612,7 @@ static void sh_mobile_ceu_remove_device(struct soc_camera_device *icd)
         }
         spin_unlock_irq(&pcdev->lock);
 
-        pm_runtime_put_sync(ici->v4l2_dev.dev);
+        pm_runtime_put(ici->v4l2_dev.dev);
 
         dev_info(icd->parent,
                  "SuperH Mobile CEU driver detached from camera %d\n",
@@ -1064,7 +1064,7 @@ static int sh_mobile_ceu_get_formats(struct soc_camera_device *icd, unsigned int
 
                 /* Add our control */
                 v4l2_ctrl_new_std(&icd->ctrl_handler, &sh_mobile_ceu_ctrl_ops,
-                                  V4L2_CID_SHARPNESS, 0, 1, 1, 0);
+                                  V4L2_CID_SHARPNESS, 0, 1, 1, 1);
                 if (icd->ctrl_handler.error)
                         return icd->ctrl_handler.error;
 
@@ -2088,15 +2088,13 @@ static int sh_mobile_ceu_probe(struct platform_device *pdev)
         irq = platform_get_irq(pdev, 0);
         if (!res || (int)irq <= 0) {
                 dev_err(&pdev->dev, "Not enough CEU platform resources.\n");
-                err = -ENODEV;
-                goto exit;
+                return -ENODEV;
         }
 
-        pcdev = kzalloc(sizeof(*pcdev), GFP_KERNEL);
+        pcdev = devm_kzalloc(&pdev->dev, sizeof(*pcdev), GFP_KERNEL);
         if (!pcdev) {
                 dev_err(&pdev->dev, "Could not allocate pcdev\n");
-                err = -ENOMEM;
-                goto exit;
+                return -ENOMEM;
         }
 
         INIT_LIST_HEAD(&pcdev->capture);
@@ -2105,19 +2103,17 @@ static int sh_mobile_ceu_probe(struct platform_device *pdev)
 
         pcdev->pdata = pdev->dev.platform_data;
         if (!pcdev->pdata) {
-                err = -EINVAL;
                 dev_err(&pdev->dev, "CEU platform data not set.\n");
-                goto exit_kfree;
+                return -EINVAL;
         }
 
         pcdev->max_width = pcdev->pdata->max_width ? : 2560;
         pcdev->max_height = pcdev->pdata->max_height ? : 1920;
 
-        base = ioremap_nocache(res->start, resource_size(res));
+        base = devm_request_and_ioremap(&pdev->dev, res);
         if (!base) {
-                err = -ENXIO;
                 dev_err(&pdev->dev, "Unable to ioremap CEU registers.\n");
-                goto exit_kfree;
+                return -ENXIO;
         }
 
         pcdev->irq = irq;
@@ -2133,16 +2129,15 @@ static int sh_mobile_ceu_probe(struct platform_device *pdev)
                                                   DMA_MEMORY_EXCLUSIVE);
                 if (!err) {
                         dev_err(&pdev->dev, "Unable to declare CEU memory.\n");
-                        err = -ENXIO;
-                        goto exit_iounmap;
+                        return -ENXIO;
                 }
 
                 pcdev->video_limit = resource_size(res);
         }
 
         /* request irq */
-        err = request_irq(pcdev->irq, sh_mobile_ceu_irq, IRQF_DISABLED,
-                          dev_name(&pdev->dev), pcdev);
+        err = devm_request_irq(&pdev->dev, pcdev->irq, sh_mobile_ceu_irq,
+                               IRQF_DISABLED, dev_name(&pdev->dev), pcdev);
         if (err) {
                 dev_err(&pdev->dev, "Unable to register CEU interrupt.\n");
                 goto exit_release_mem;
@@ -2246,15 +2241,9 @@ exit_free_ctx:
         vb2_dma_contig_cleanup_ctx(pcdev->alloc_ctx);
 exit_free_clk:
         pm_runtime_disable(&pdev->dev);
-        free_irq(pcdev->irq, pcdev);
 exit_release_mem:
         if (platform_get_resource(pdev, IORESOURCE_MEM, 1))
                 dma_release_declared_memory(&pdev->dev);
-exit_iounmap:
-        iounmap(base);
-exit_kfree:
-        kfree(pcdev);
-exit:
         return err;
 }
 
@@ -2267,10 +2256,8 @@ static int sh_mobile_ceu_remove(struct platform_device *pdev)
 
         soc_camera_host_unregister(soc_host);
         pm_runtime_disable(&pdev->dev);
-        free_irq(pcdev->irq, pcdev);
         if (platform_get_resource(pdev, IORESOURCE_MEM, 1))
                 dma_release_declared_memory(&pdev->dev);
-        iounmap(pcdev->base);
         vb2_dma_contig_cleanup_ctx(pcdev->alloc_ctx);
         if (csi2_pdev && csi2_pdev->dev.driver) {
                 struct module *csi2_drv = csi2_pdev->dev.driver->owner;
@@ -2279,7 +2266,6 @@ static int sh_mobile_ceu_remove(struct platform_device *pdev)
                 platform_device_put(csi2_pdev);
                 module_put(csi2_drv);
         }
-        kfree(pcdev);
 
         return 0;
 }
diff --git a/drivers/media/platform/soc_camera/sh_mobile_csi2.c b/drivers/media/platform/soc_camera/sh_mobile_csi2.c
index a17aba9a0104..42c559eb4937 100644
--- a/drivers/media/platform/soc_camera/sh_mobile_csi2.c
+++ b/drivers/media/platform/soc_camera/sh_mobile_csi2.c
@@ -318,23 +318,16 @@ static int sh_csi2_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        priv = kzalloc(sizeof(struct sh_csi2), GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(struct sh_csi2), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
 
         priv->irq = irq;
 
-        if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
-                dev_err(&pdev->dev, "CSI2 register region already claimed\n");
-                ret = -EBUSY;
-                goto ereqreg;
-        }
-
-        priv->base = ioremap(res->start, resource_size(res));
+        priv->base = devm_request_and_ioremap(&pdev->dev, res);
         if (!priv->base) {
-                ret = -ENXIO;
                 dev_err(&pdev->dev, "Unable to ioremap CSI2 registers.\n");
-                goto eremap;
+                return -ENXIO;
         }
 
         priv->pdev = pdev;
@@ -357,11 +350,7 @@ static int sh_csi2_probe(struct platform_device *pdev)
         return 0;
 
 esdreg:
-        iounmap(priv->base);
-eremap:
-        release_mem_region(res->start, resource_size(res));
-ereqreg:
-        kfree(priv);
+        platform_set_drvdata(pdev, NULL);
 
         return ret;
 }
@@ -369,14 +358,10 @@ ereqreg:
 static int sh_csi2_remove(struct platform_device *pdev)
 {
         struct sh_csi2 *priv = platform_get_drvdata(pdev);
-        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
         v4l2_device_unregister_subdev(&priv->subdev);
         pm_runtime_disable(&pdev->dev);
-        iounmap(priv->base);
-        release_mem_region(res->start, resource_size(res));
         platform_set_drvdata(pdev, NULL);
-        kfree(priv);
 
         return 0;
 }
diff --git a/drivers/media/platform/soc_camera/soc_camera.c b/drivers/media/platform/soc_camera/soc_camera.c
index 2ec90eae6ba0..8ec98051ea73 100644
--- a/drivers/media/platform/soc_camera/soc_camera.c
+++ b/drivers/media/platform/soc_camera/soc_camera.c
@@ -50,22 +50,22 @@ static LIST_HEAD(hosts);
 static LIST_HEAD(devices);
 static DEFINE_MUTEX(list_lock);         /* Protects the list of hosts */
 
-int soc_camera_power_on(struct device *dev, struct soc_camera_link *icl)
+int soc_camera_power_on(struct device *dev, struct soc_camera_subdev_desc *ssdd)
 {
-        int ret = regulator_bulk_enable(icl->num_regulators,
-                                        icl->regulators);
+        int ret = regulator_bulk_enable(ssdd->num_regulators,
+                                        ssdd->regulators);
         if (ret < 0) {
                 dev_err(dev, "Cannot enable regulators\n");
                 return ret;
         }
 
-        if (icl->power) {
-                ret = icl->power(dev, 1);
+        if (ssdd->power) {
+                ret = ssdd->power(dev, 1);
                 if (ret < 0) {
                         dev_err(dev,
                                 "Platform failed to power-on the camera.\n");
-                        regulator_bulk_disable(icl->num_regulators,
-                                               icl->regulators);
+                        regulator_bulk_disable(ssdd->num_regulators,
+                                               ssdd->regulators);
                 }
         }
 
@@ -73,13 +73,13 @@ int soc_camera_power_on(struct device *dev, struct soc_camera_link *icl)
 }
 EXPORT_SYMBOL(soc_camera_power_on);
 
-int soc_camera_power_off(struct device *dev, struct soc_camera_link *icl)
+int soc_camera_power_off(struct device *dev, struct soc_camera_subdev_desc *ssdd)
 {
         int ret = 0;
         int err;
 
-        if (icl->power) {
-                err = icl->power(dev, 0);
+        if (ssdd->power) {
+                err = ssdd->power(dev, 0);
                 if (err < 0) {
                         dev_err(dev,
                                 "Platform failed to power-off the camera.\n");
@@ -87,8 +87,8 @@ int soc_camera_power_off(struct device *dev, struct soc_camera_link *icl)
                 }
         }
 
-        err = regulator_bulk_disable(icl->num_regulators,
-                                     icl->regulators);
+        err = regulator_bulk_disable(ssdd->num_regulators,
+                                     ssdd->regulators);
         if (err < 0) {
                 dev_err(dev, "Cannot disable regulators\n");
                 ret = ret ? : err;
@@ -136,29 +136,29 @@ EXPORT_SYMBOL(soc_camera_xlate_by_fourcc);
 
 /**
  * soc_camera_apply_board_flags() - apply platform SOCAM_SENSOR_INVERT_* flags
- * @icl:        camera platform parameters
+ * @ssdd:       camera platform parameters
  * @cfg:        media bus configuration
  * @return:     resulting flags
  */
-unsigned long soc_camera_apply_board_flags(struct soc_camera_link *icl,
+unsigned long soc_camera_apply_board_flags(struct soc_camera_subdev_desc *ssdd,
                                            const struct v4l2_mbus_config *cfg)
 {
         unsigned long f, flags = cfg->flags;
 
         /* If only one of the two polarities is supported, switch to the opposite */
-        if (icl->flags & SOCAM_SENSOR_INVERT_HSYNC) {
+        if (ssdd->flags & SOCAM_SENSOR_INVERT_HSYNC) {
                 f = flags & (V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW);
                 if (f == V4L2_MBUS_HSYNC_ACTIVE_HIGH || f == V4L2_MBUS_HSYNC_ACTIVE_LOW)
                         flags ^= V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW;
         }
 
-        if (icl->flags & SOCAM_SENSOR_INVERT_VSYNC) {
+        if (ssdd->flags & SOCAM_SENSOR_INVERT_VSYNC) {
                 f = flags & (V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW);
                 if (f == V4L2_MBUS_VSYNC_ACTIVE_HIGH || f == V4L2_MBUS_VSYNC_ACTIVE_LOW)
                         flags ^= V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW;
         }
 
-        if (icl->flags & SOCAM_SENSOR_INVERT_PCLK) {
+        if (ssdd->flags & SOCAM_SENSOR_INVERT_PCLK) {
                 f = flags & (V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING);
                 if (f == V4L2_MBUS_PCLK_SAMPLE_RISING || f == V4L2_MBUS_PCLK_SAMPLE_FALLING)
                         flags ^= V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING;
@@ -383,7 +383,7 @@ static int soc_camera_prepare_buf(struct file *file, void *priv,
                 return vb2_prepare_buf(&icd->vb2_vidq, b);
 }
 
-/* Always entered with .video_lock held */
+/* Always entered with .host_lock held */
 static int soc_camera_init_user_formats(struct soc_camera_device *icd)
 {
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
@@ -450,7 +450,7 @@ egfmt:
         return ret;
 }
 
-/* Always entered with .video_lock held */
+/* Always entered with .host_lock held */
 static void soc_camera_free_user_formats(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
@@ -509,7 +509,7 @@ static int soc_camera_open(struct file *file)
 {
         struct video_device *vdev = video_devdata(file);
         struct soc_camera_device *icd = dev_get_drvdata(vdev->parent);
-        struct soc_camera_link *icl = to_soc_camera_link(icd);
+        struct soc_camera_desc *sdesc = to_soc_camera_desc(icd);
         struct soc_camera_host *ici;
         int ret;
 
@@ -517,9 +517,16 @@ static int soc_camera_open(struct file *file)
                 /* No device driver attached */
                 return -ENODEV;
 
+        /*
+         * Don't mess with the host during probe: wait until the loop in
+         * scan_add_host() completes
+         */
+        if (mutex_lock_interruptible(&list_lock))
+                return -ERESTARTSYS;
         ici = to_soc_camera_host(icd->parent);
+        mutex_unlock(&list_lock);
 
-        if (mutex_lock_interruptible(&icd->video_lock))
+        if (mutex_lock_interruptible(&ici->host_lock))
                 return -ERESTARTSYS;
         if (!try_module_get(ici->ops->owner)) {
                 dev_err(icd->pdev, "Couldn't lock capture bus driver.\n");
@@ -545,13 +552,10 @@ static int soc_camera_open(struct file *file)
                 };
 
                 /* The camera could have been already on, try to reset */
-                if (icl->reset)
-                        icl->reset(icd->pdev);
+                if (sdesc->subdev_desc.reset)
+                        sdesc->subdev_desc.reset(icd->pdev);
 
-                /* Don't mess with the host during probe */
-                mutex_lock(&ici->host_lock);
                 ret = ici->ops->add(icd);
-                mutex_unlock(&ici->host_lock);
                 if (ret < 0) {
                         dev_err(icd->pdev, "Couldn't activate the camera: %d\n", ret);
                         goto eiciadd;
@@ -570,7 +574,7 @@ static int soc_camera_open(struct file *file)
                  * Try to configure with default parameters. Notice: this is the
                  * very first open, so, we cannot race against other calls,
                  * apart from someone else calling open() simultaneously, but
-                 * .video_lock is protecting us against it.
+                 * .host_lock is protecting us against it.
                  */
                 ret = soc_camera_set_fmt(icd, &f);
                 if (ret < 0)
@@ -585,7 +589,7 @@ static int soc_camera_open(struct file *file)
                 }
                 v4l2_ctrl_handler_setup(&icd->ctrl_handler);
         }
-        mutex_unlock(&icd->video_lock);
+        mutex_unlock(&ici->host_lock);
 
         file->private_data = icd;
         dev_dbg(icd->pdev, "camera device open\n");
@@ -593,7 +597,7 @@ static int soc_camera_open(struct file *file)
         return 0;
 
         /*
-         * First four errors are entered with the .video_lock held
+         * First four errors are entered with the .host_lock held
          * and use_count == 1
          */
 einitvb:
@@ -607,7 +611,7 @@ eiciadd:
         icd->use_count--;
         module_put(ici->ops->owner);
 emodule:
-        mutex_unlock(&icd->video_lock);
+        mutex_unlock(&ici->host_lock);
 
         return ret;
 }
@@ -617,7 +621,7 @@ static int soc_camera_close(struct file *file)
         struct soc_camera_device *icd = file->private_data;
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
 
-        mutex_lock(&icd->video_lock);
+        mutex_lock(&ici->host_lock);
         icd->use_count--;
         if (!icd->use_count) {
                 pm_runtime_suspend(&icd->vdev->dev);
@@ -632,7 +636,7 @@ static int soc_camera_close(struct file *file)
 
         if (icd->streamer == file)
                 icd->streamer = NULL;
-        mutex_unlock(&icd->video_lock);
+        mutex_unlock(&ici->host_lock);
 
         module_put(ici->ops->owner);
 
@@ -669,13 +673,13 @@ static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
         if (icd->streamer != file)
                 return -EBUSY;
 
-        if (mutex_lock_interruptible(&icd->video_lock))
+        if (mutex_lock_interruptible(&ici->host_lock))
                 return -ERESTARTSYS;
         if (ici->ops->init_videobuf)
                 err = videobuf_mmap_mapper(&icd->vb_vidq, vma);
         else
                 err = vb2_mmap(&icd->vb2_vidq, vma);
-        mutex_unlock(&icd->video_lock);
+        mutex_unlock(&ici->host_lock);
 
         dev_dbg(icd->pdev, "vma start=0x%08lx, size=%ld, ret=%d\n",
                 (unsigned long)vma->vm_start,
@@ -694,26 +698,28 @@ static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
         if (icd->streamer != file)
                 return POLLERR;
 
-        mutex_lock(&icd->video_lock);
+        mutex_lock(&ici->host_lock);
         if (ici->ops->init_videobuf && list_empty(&icd->vb_vidq.stream))
                 dev_err(icd->pdev, "Trying to poll with no queued buffers!\n");
         else
                 res = ici->ops->poll(file, pt);
-        mutex_unlock(&icd->video_lock);
+        mutex_unlock(&ici->host_lock);
         return res;
 }
 
 void soc_camera_lock(struct vb2_queue *vq)
 {
         struct soc_camera_device *icd = vb2_get_drv_priv(vq);
-        mutex_lock(&icd->video_lock);
+        struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+        mutex_lock(&ici->host_lock);
 }
 EXPORT_SYMBOL(soc_camera_lock);
 
 void soc_camera_unlock(struct vb2_queue *vq)
 {
         struct soc_camera_device *icd = vb2_get_drv_priv(vq);
-        mutex_unlock(&icd->video_lock);
+        struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+        mutex_unlock(&ici->host_lock);
 }
 EXPORT_SYMBOL(soc_camera_unlock);
 
@@ -908,6 +914,8 @@ static int soc_camera_s_crop(struct file *file, void *fh,
         dev_dbg(icd->pdev, "S_CROP(%ux%u@%u:%u)\n",
                 rect->width, rect->height, rect->left, rect->top);
 
+        current_crop.type = a->type;
+
         /* If get_crop fails, we'll let host and / or client drivers decide */
         ret = ici->ops->get_crop(icd, &current_crop);
 
@@ -1050,7 +1058,7 @@ static void scan_add_host(struct soc_camera_host *ici)
 {
         struct soc_camera_device *icd;
 
-        mutex_lock(&ici->host_lock);
+        mutex_lock(&list_lock);
 
         list_for_each_entry(icd, &devices, list) {
                 if (icd->iface == ici->nr) {
@@ -1059,28 +1067,29 @@ static void scan_add_host(struct soc_camera_host *ici)
                 }
         }
 
-        mutex_unlock(&ici->host_lock);
+        mutex_unlock(&list_lock);
 }
 
 #ifdef CONFIG_I2C_BOARDINFO
 static int soc_camera_init_i2c(struct soc_camera_device *icd,
-                               struct soc_camera_link *icl)
+                               struct soc_camera_desc *sdesc)
 {
         struct i2c_client *client;
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-        struct i2c_adapter *adap = i2c_get_adapter(icl->i2c_adapter_id);
+        struct soc_camera_host_desc *shd = &sdesc->host_desc;
+        struct i2c_adapter *adap = i2c_get_adapter(shd->i2c_adapter_id);
         struct v4l2_subdev *subdev;
 
         if (!adap) {
                 dev_err(icd->pdev, "Cannot get I2C adapter #%d. No driver?\n",
-                        icl->i2c_adapter_id);
+                        shd->i2c_adapter_id);
                 goto ei2cga;
         }
 
-        icl->board_info->platform_data = icl;
+        shd->board_info->platform_data = &sdesc->subdev_desc;
 
         subdev = v4l2_i2c_new_subdev_board(&ici->v4l2_dev, adap,
-                                icl->board_info, NULL);
+                                shd->board_info, NULL);
         if (!subdev)
                 goto ei2cnd;
 
@@ -1108,7 +1117,7 @@ static void soc_camera_free_i2c(struct soc_camera_device *icd)
         i2c_put_adapter(adap);
 }
 #else
-#define soc_camera_init_i2c(icd, icl)   (-ENODEV)
+#define soc_camera_init_i2c(icd, sdesc) (-ENODEV)
 #define soc_camera_free_i2c(icd)        do {} while (0)
 #endif
 
@@ -1118,7 +1127,9 @@ static int video_dev_create(struct soc_camera_device *icd);
 static int soc_camera_probe(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
-        struct soc_camera_link *icl = to_soc_camera_link(icd);
+        struct soc_camera_desc *sdesc = to_soc_camera_desc(icd);
+        struct soc_camera_host_desc *shd = &sdesc->host_desc;
+        struct soc_camera_subdev_desc *ssdd = &sdesc->subdev_desc;
         struct device *control = NULL;
         struct v4l2_subdev *sd;
         struct v4l2_mbus_framefmt mf;
@@ -1137,16 +1148,13 @@ static int soc_camera_probe(struct soc_camera_device *icd)
         if (ret < 0)
                 return ret;
 
-        ret = regulator_bulk_get(icd->pdev, icl->num_regulators,
-                                 icl->regulators);
-        if (ret < 0)
-                goto ereg;
-
         /* The camera could have been already on, try to reset */
-        if (icl->reset)
-                icl->reset(icd->pdev);
+        if (ssdd->reset)
+                ssdd->reset(icd->pdev);
 
+        mutex_lock(&ici->host_lock);
         ret = ici->ops->add(icd);
+        mutex_unlock(&ici->host_lock);
         if (ret < 0)
                 goto eadd;
 
@@ -1156,18 +1164,18 @@ static int soc_camera_probe(struct soc_camera_device *icd)
                 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 (shd->board_info) {
+                ret = soc_camera_init_i2c(icd, sdesc);
                 if (ret < 0)
                         goto eadddev;
-        } else if (!icl->add_device || !icl->del_device) {
+        } else if (!shd->add_device || !shd->del_device) {
                 ret = -EINVAL;
                 goto eadddev;
         } else {
-                if (icl->module_name)
-                        ret = request_module(icl->module_name);
+                if (shd->module_name)
+                        ret = request_module(shd->module_name);
 
-                ret = icl->add_device(icd);
+                ret = shd->add_device(icd);
                 if (ret < 0)
                         goto eadddev;
 
@@ -1178,7 +1186,7 @@ static int soc_camera_probe(struct soc_camera_device *icd)
                 control = to_soc_camera_control(icd);
                 if (!control || !control->driver || !dev_get_drvdata(control) ||
                     !try_module_get(control->driver->owner)) {
-                        icl->del_device(icd);
+                        shd->del_device(icd);
                         ret = -ENODEV;
                         goto enodrv;
                 }
@@ -1204,7 +1212,7 @@ static int soc_camera_probe(struct soc_camera_device *icd)
          * itself is protected against concurrent open() calls, but we also have
          * to protect our data.
          */
-        mutex_lock(&icd->video_lock);
+        mutex_lock(&ici->host_lock);
 
         ret = soc_camera_video_start(icd);
         if (ret < 0)
@@ -1220,19 +1228,19 @@ static int soc_camera_probe(struct soc_camera_device *icd)
 
         ici->ops->remove(icd);
 
-        mutex_unlock(&icd->video_lock);
+        mutex_unlock(&ici->host_lock);
 
         return 0;
 
 evidstart:
-        mutex_unlock(&icd->video_lock);
+        mutex_unlock(&ici->host_lock);
         soc_camera_free_user_formats(icd);
 eiufmt:
 ectrl:
-        if (icl->board_info) {
+        if (shd->board_info) {
                 soc_camera_free_i2c(icd);
         } else {
-                icl->del_device(icd);
+                shd->del_device(icd);
                 module_put(control->driver->owner);
         }
 enodrv:
@@ -1240,10 +1248,10 @@ eadddev:
         video_device_release(icd->vdev);
         icd->vdev = NULL;
 evdc:
+        mutex_lock(&ici->host_lock);
         ici->ops->remove(icd);
+        mutex_unlock(&ici->host_lock);
 eadd:
-        regulator_bulk_free(icl->num_regulators, icl->regulators);
-ereg:
         v4l2_ctrl_handler_free(&icd->ctrl_handler);
         return ret;
 }
@@ -1254,7 +1262,7 @@ ereg:
  */
 static int soc_camera_remove(struct soc_camera_device *icd)
 {
-        struct soc_camera_link *icl = to_soc_camera_link(icd);
+        struct soc_camera_desc *sdesc = to_soc_camera_desc(icd);
         struct video_device *vdev = icd->vdev;
 
         BUG_ON(!icd->parent);
@@ -1265,19 +1273,17 @@ static int soc_camera_remove(struct soc_camera_device *icd)
                 icd->vdev = NULL;
         }
 
-        if (icl->board_info) {
+        if (sdesc->host_desc.board_info) {
                 soc_camera_free_i2c(icd);
         } else {
                 struct device_driver *drv = to_soc_camera_control(icd)->driver;
                 if (drv) {
-                        icl->del_device(icd);
+                        sdesc->host_desc.del_device(icd);
                         module_put(drv->owner);
                 }
         }
         soc_camera_free_user_formats(icd);
 
-        regulator_bulk_free(icl->num_regulators, icl->regulators);
-
         return 0;
 }
 
@@ -1442,7 +1448,6 @@ static int soc_camera_device_register(struct soc_camera_device *icd)
         icd->devnum             = num;
         icd->use_count          = 0;
         icd->host_priv          = NULL;
-        mutex_init(&icd->video_lock);
 
         list_add_tail(&icd->list, &devices);
 
@@ -1500,7 +1505,7 @@ static int video_dev_create(struct soc_camera_device *icd)
         vdev->release           = video_device_release;
         vdev->tvnorms           = V4L2_STD_UNKNOWN;
         vdev->ctrl_handler      = &icd->ctrl_handler;
-        vdev->lock              = &icd->video_lock;
+        vdev->lock              = &ici->host_lock;
 
         icd->vdev = vdev;
 
@@ -1508,7 +1513,7 @@ static int video_dev_create(struct soc_camera_device *icd)
 }
 
 /*
- * Called from soc_camera_probe() above (with .video_lock held???)
+ * Called from soc_camera_probe() above with .host_lock held
  */
 static int soc_camera_video_start(struct soc_camera_device *icd)
 {
@@ -1532,18 +1537,25 @@ static int soc_camera_video_start(struct soc_camera_device *icd)
 
 static int soc_camera_pdrv_probe(struct platform_device *pdev)
 {
-        struct soc_camera_link *icl = pdev->dev.platform_data;
+        struct soc_camera_desc *sdesc = pdev->dev.platform_data;
+        struct soc_camera_subdev_desc *ssdd = &sdesc->subdev_desc;
         struct soc_camera_device *icd;
+        int ret;
 
-        if (!icl)
+        if (!sdesc)
                 return -EINVAL;
 
         icd = devm_kzalloc(&pdev->dev, sizeof(*icd), GFP_KERNEL);
         if (!icd)
                 return -ENOMEM;
 
-        icd->iface = icl->bus_id;
-        icd->link = icl;
+        ret = devm_regulator_bulk_get(&pdev->dev, ssdd->num_regulators,
+                                      ssdd->regulators);
+        if (ret < 0)
+                return ret;
+
+        icd->iface = sdesc->host_desc.bus_id;
+        icd->sdesc = sdesc;
         icd->pdev = &pdev->dev;
         platform_set_drvdata(pdev, icd);
 
diff --git a/drivers/media/platform/soc_camera/soc_camera_platform.c b/drivers/media/platform/soc_camera/soc_camera_platform.c
index 7cf7fd16481f..ce3b1d6a4734 100644
--- a/drivers/media/platform/soc_camera/soc_camera_platform.c
+++ b/drivers/media/platform/soc_camera/soc_camera_platform.c
@@ -54,7 +54,7 @@ static int soc_camera_platform_s_power(struct v4l2_subdev *sd, int on)
 {
         struct soc_camera_platform_info *p = v4l2_get_subdevdata(sd);
 
-        return soc_camera_set_power(p->icd->control, p->icd->link, on);
+        return soc_camera_set_power(p->icd->control, &p->icd->sdesc->subdev_desc, on);
 }
 
 static struct v4l2_subdev_core_ops platform_subdev_core_ops = {
@@ -148,7 +148,7 @@ static int soc_camera_platform_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
 
@@ -173,7 +173,6 @@ static int soc_camera_platform_probe(struct platform_device *pdev)
 
 evdrs:
         platform_set_drvdata(pdev, NULL);
-        kfree(priv);
         return ret;
 }
 
@@ -185,7 +184,6 @@ static int soc_camera_platform_remove(struct platform_device *pdev)
         p->icd->control = NULL;
         v4l2_device_unregister_subdev(&priv->subdev);
         platform_set_drvdata(pdev, NULL);
-        kfree(priv);
         return 0;
 }
 
diff --git a/drivers/media/platform/soc_camera/soc_mediabus.c b/drivers/media/platform/soc_camera/soc_mediabus.c
index a397812635d6..89dce097a827 100644
--- a/drivers/media/platform/soc_camera/soc_mediabus.c
+++ b/drivers/media/platform/soc_camera/soc_mediabus.c
@@ -378,9 +378,6 @@ EXPORT_SYMBOL(soc_mbus_samples_per_pixel);
 
 s32 soc_mbus_bytes_per_line(u32 width, const struct soc_mbus_pixelfmt *mf)
 {
-        if (mf->fourcc == V4L2_PIX_FMT_JPEG)
-                return 0;
-
         if (mf->layout != SOC_MBUS_LAYOUT_PACKED)
                 return width * mf->bits_per_sample / 8;
 
@@ -403,9 +400,6 @@ EXPORT_SYMBOL(soc_mbus_bytes_per_line);
 s32 soc_mbus_image_size(const struct soc_mbus_pixelfmt *mf,
                         u32 bytes_per_line, u32 height)
 {
-        if (mf->fourcc == V4L2_PIX_FMT_JPEG)
-                return 0;
-
         if (mf->layout == SOC_MBUS_LAYOUT_PACKED)
                 return bytes_per_line * height;
 
diff --git a/drivers/media/platform/timblogiw.c b/drivers/media/platform/timblogiw.c
index d854d08a6c7f..c3a2a4484401 100644
--- a/drivers/media/platform/timblogiw.c
+++ b/drivers/media/platform/timblogiw.c
@@ -130,7 +130,7 @@ static void timblogiw_dma_cb(void *data)
 
         if (vb->state != VIDEOBUF_ERROR) {
                 list_del(&vb->queue);
-                do_gettimeofday(&vb->ts);
+                v4l2_get_timestamp(&vb->ts);
                 vb->field_count = fh->frame_count * 2;
                 vb->state = VIDEOBUF_DONE;
 
diff --git a/drivers/media/platform/via-camera.c b/drivers/media/platform/via-camera.c
index 63e8c3461239..b051c4a28554 100644
--- a/drivers/media/platform/via-camera.c
+++ b/drivers/media/platform/via-camera.c
@@ -18,6 +18,7 @@
 #include <media/v4l2-device.h>
 #include <media/v4l2-ioctl.h>
 #include <media/v4l2-chip-ident.h>
+#include <media/v4l2-ctrls.h>
 #include <media/ov7670.h>
 #include <media/videobuf-dma-sg.h>
 #include <linux/delay.h>
@@ -63,6 +64,7 @@ enum viacam_opstate { S_IDLE = 0, S_RUNNING = 1 };
 
 struct via_camera {
         struct v4l2_device v4l2_dev;
+        struct v4l2_ctrl_handler ctrl_handler;
         struct video_device vdev;
         struct v4l2_subdev *sensor;
         struct platform_device *platdev;
@@ -818,47 +820,6 @@ static int viacam_g_chip_ident(struct file *file, void *priv,
 }
 
 /*
- * Control ops are passed through to the sensor.
- */
-static int viacam_queryctrl(struct file *filp, void *priv,
-                struct v4l2_queryctrl *qc)
-{
-        struct via_camera *cam = priv;
-        int ret;
-
-        mutex_lock(&cam->lock);
-        ret = sensor_call(cam, core, queryctrl, qc);
-        mutex_unlock(&cam->lock);
-        return ret;
-}
-
-
-static int viacam_g_ctrl(struct file *filp, void *priv,
-                struct v4l2_control *ctrl)
-{
-        struct via_camera *cam = priv;
-        int ret;
-
-        mutex_lock(&cam->lock);
-        ret = sensor_call(cam, core, g_ctrl, ctrl);
-        mutex_unlock(&cam->lock);
-        return ret;
-}
-
-
-static int viacam_s_ctrl(struct file *filp, void *priv,
-                struct v4l2_control *ctrl)
-{
-        struct via_camera *cam = priv;
-        int ret;
-
-        mutex_lock(&cam->lock);
-        ret = sensor_call(cam, core, s_ctrl, ctrl);
-        mutex_unlock(&cam->lock);
-        return ret;
-}
-
-/*
  * Only one input.
  */
 static int viacam_enum_input(struct file *filp, void *priv,
@@ -1214,9 +1175,6 @@ static int viacam_enum_frameintervals(struct file *filp, void *priv,
 
 static const struct v4l2_ioctl_ops viacam_ioctl_ops = {
         .vidioc_g_chip_ident    = viacam_g_chip_ident,
-        .vidioc_queryctrl       = viacam_queryctrl,
-        .vidioc_g_ctrl          = viacam_g_ctrl,
-        .vidioc_s_ctrl          = viacam_s_ctrl,
         .vidioc_enum_input      = viacam_enum_input,
         .vidioc_g_input         = viacam_g_input,
         .vidioc_s_input         = viacam_s_input,
@@ -1418,8 +1376,12 @@ static int viacam_probe(struct platform_device *pdev)
         ret = v4l2_device_register(&pdev->dev, &cam->v4l2_dev);
         if (ret) {
                 dev_err(&pdev->dev, "Unable to register v4l2 device\n");
-                return ret;
+                goto out_free;
         }
+        ret = v4l2_ctrl_handler_init(&cam->ctrl_handler, 10);
+        if (ret)
+                goto out_unregister;
+        cam->v4l2_dev.ctrl_handler = &cam->ctrl_handler;
         /*
          * Convince the system that we can do DMA.
          */
@@ -1436,7 +1398,7 @@ static int viacam_probe(struct platform_device *pdev)
          */
         ret = via_sensor_power_setup(cam);
         if (ret)
-                goto out_unregister;
+                goto out_ctrl_hdl_free;
         via_sensor_power_up(cam);
 
         /*
@@ -1485,8 +1447,12 @@ out_irq:
         free_irq(viadev->pdev->irq, cam);
 out_power_down:
         via_sensor_power_release(cam);
+out_ctrl_hdl_free:
+        v4l2_ctrl_handler_free(&cam->ctrl_handler);
 out_unregister:
         v4l2_device_unregister(&cam->v4l2_dev);
+out_free:
+        kfree(cam);
         return ret;
 }
 
@@ -1499,6 +1465,8 @@ static int viacam_remove(struct platform_device *pdev)
         v4l2_device_unregister(&cam->v4l2_dev);
         free_irq(viadev->pdev->irq, cam);
         via_sensor_power_release(cam);
+        v4l2_ctrl_handler_free(&cam->ctrl_handler);
+        kfree(cam);
         via_cam_info = NULL;
         return 0;
 }
diff --git a/drivers/media/platform/vino.c b/drivers/media/platform/vino.c
index 70b0bf4b2900..eb5d6f955709 100644
--- a/drivers/media/platform/vino.c
+++ b/drivers/media/platform/vino.c
@@ -2474,8 +2474,8 @@ static irqreturn_t vino_interrupt(int irq, void *dev_id)
 
                 if ((!handled_a) && (done_a || skip_a)) {
                         if (!skip_a) {
-                                do_gettimeofday(&vino_drvdata->
-                                                a.int_data.timestamp);
+                                v4l2_get_timestamp(
+                                        &vino_drvdata->a.int_data.timestamp);
                                 vino_drvdata->a.int_data.frame_counter = fc_a;
                         }
                         vino_drvdata->a.int_data.skip = skip_a;
@@ -2489,8 +2489,8 @@ static irqreturn_t vino_interrupt(int irq, void *dev_id)
 
                 if ((!handled_b) && (done_b || skip_b)) {
                         if (!skip_b) {
-                                do_gettimeofday(&vino_drvdata->
-                                                b.int_data.timestamp);
+                                v4l2_get_timestamp(
+                                        &vino_drvdata->b.int_data.timestamp);
                                 vino_drvdata->b.int_data.frame_counter = fc_b;
                         }
                         vino_drvdata->b.int_data.skip = skip_b;
@@ -3410,6 +3410,9 @@ static void vino_v4l2_get_buffer_status(struct vino_channel_settings *vcs,
         if (fb->map_count > 0)
                 b->flags |= V4L2_BUF_FLAG_MAPPED;
 
+        b->flags &= ~V4L2_BUF_FLAG_TIMESTAMP_MASK;
+        b->flags |= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+
         b->index = fb->id;
         b->memory = (vcs->fb_queue.type == VINO_MEMORY_MMAP) ?
                 V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
diff --git a/drivers/media/platform/vivi.c b/drivers/media/platform/vivi.c
index 0d59b9db83cb..8a33a712f480 100644
--- a/drivers/media/platform/vivi.c
+++ b/drivers/media/platform/vivi.c
@@ -36,9 +36,17 @@
 
 #define VIVI_MODULE_NAME "vivi"
 
-/* Wake up at about 30 fps */
-#define WAKE_NUMERATOR 30
-#define WAKE_DENOMINATOR 1001
+/* Maximum allowed frame rate
+ *
+ * Vivi will allow setting timeperframe in [1/FPS_MAX - FPS_MAX/1] range.
+ *
+ * Ideally FPS_MAX should be infinity, i.e. practically UINT_MAX, but that
+ * might hit application errors when they manipulate these values.
+ *
+ * Besides, for tpf < 1ms image-generation logic should be changed, to avoid
+ * producing frames with equal content.
+ */
+#define FPS_MAX 1000
 
 #define MAX_WIDTH 1920
 #define MAX_HEIGHT 1200
@@ -69,6 +77,12 @@ MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
 /* Global font descriptor */
 static const u8 *font8x16;
 
+/* timeperframe: min/max and default */
+static const struct v4l2_fract
+        tpf_min     = {.numerator = 1,          .denominator = FPS_MAX},
+        tpf_max     = {.numerator = FPS_MAX,    .denominator = 1},
+        tpf_default = {.numerator = 1001,       .denominator = 30000};  /* NTSC */
+
 #define dprintk(dev, level, fmt, arg...) \
         v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
 
@@ -77,13 +91,13 @@ static const u8 *font8x16;
    ------------------------------------------------------------------*/
 
 struct vivi_fmt {
-        char  *name;
+        const char *name;
         u32   fourcc;          /* v4l2 format id */
         u8    depth;
         bool  is_yuv;
 };
 
-static struct vivi_fmt formats[] = {
+static const struct vivi_fmt formats[] = {
         {
                 .name     = "4:2:2, packed, YUYV",
                 .fourcc   = V4L2_PIX_FMT_YUYV,
@@ -150,14 +164,14 @@ static struct vivi_fmt formats[] = {
         },
 };
 
-static struct vivi_fmt *get_format(struct v4l2_format *f)
+static const struct vivi_fmt *__get_format(u32 pixelformat)
 {
-        struct vivi_fmt *fmt;
+        const struct vivi_fmt *fmt;
         unsigned int k;
 
         for (k = 0; k < ARRAY_SIZE(formats); k++) {
                 fmt = &formats[k];
-                if (fmt->fourcc == f->fmt.pix.pixelformat)
+                if (fmt->fourcc == pixelformat)
                         break;
         }
 
@@ -167,12 +181,17 @@ static struct vivi_fmt *get_format(struct v4l2_format *f)
         return &formats[k];
 }
 
+static const struct vivi_fmt *get_format(struct v4l2_format *f)
+{
+        return __get_format(f->fmt.pix.pixelformat);
+}
+
 /* buffer for one video frame */
 struct vivi_buffer {
         /* common v4l buffer stuff -- must be first */
         struct vb2_buffer       vb;
         struct list_head        list;
-        struct vivi_fmt        *fmt;
+        const struct vivi_fmt  *fmt;
 };
 
 struct vivi_dmaqueue {
@@ -231,15 +250,17 @@ struct vivi_dev {
         int                        input;
 
         /* video capture */
-        struct vivi_fmt            *fmt;
+        const struct vivi_fmt      *fmt;
+        struct v4l2_fract          timeperframe;
         unsigned int               width, height;
         struct vb2_queue           vb_vidq;
         unsigned int               field_count;
 
         u8                         bars[9][3];
-        u8                         line[MAX_WIDTH * 8];
+        u8                         line[MAX_WIDTH * 8] __attribute__((__aligned__(4)));
         unsigned int               pixelsize;
         u8                         alpha_component;
+        u32                        textfg, textbg;
 };
 
 /* ------------------------------------------------------------------
@@ -276,7 +297,7 @@ struct bar_std {
 
 /* Maximum number of bars are 10 - otherwise, the input print code
    should be modified */
-static struct bar_std bars[] = {
+static const struct bar_std bars[] = {
         {       /* Standard ITU-R color bar sequence */
                 { COLOR_WHITE, COLOR_AMBER, COLOR_CYAN, COLOR_GREEN,
                   COLOR_MAGENTA, COLOR_RED, COLOR_BLUE, COLOR_BLACK, COLOR_BLACK }
@@ -511,66 +532,100 @@ static void gen_twopix(struct vivi_dev *dev, u8 *buf, int colorpos, bool odd)
 
 static void precalculate_line(struct vivi_dev *dev)
 {
-        int w;
-
-        for (w = 0; w < dev->width * 2; w++) {
-                int colorpos = w / (dev->width / 8) % 8;
-
-                gen_twopix(dev, dev->line + w * dev->pixelsize, colorpos, w & 1);
+        unsigned pixsize  = dev->pixelsize;
+        unsigned pixsize2 = 2*pixsize;
+        int colorpos;
+        u8 *pos;
+
+        for (colorpos = 0; colorpos < 16; ++colorpos) {
+                u8 pix[8];
+                int wstart =  colorpos    * dev->width / 8;
+                int wend   = (colorpos+1) * dev->width / 8;
+                int w;
+
+                gen_twopix(dev, &pix[0],        colorpos % 8, 0);
+                gen_twopix(dev, &pix[pixsize],  colorpos % 8, 1);
+
+                for (w = wstart/2*2, pos = dev->line + w*pixsize; w < wend; w += 2, pos += pixsize2)
+                        memcpy(pos, pix, pixsize2);
         }
 }
 
+/* need this to do rgb24 rendering */
+typedef struct { u16 __; u8 _; } __attribute__((packed)) x24;
+
 static void gen_text(struct vivi_dev *dev, char *basep,
                                         int y, int x, char *text)
 {
         int line;
+        unsigned int width = dev->width;
 
         /* Checks if it is possible to show string */
-        if (y + 16 >= dev->height || x + strlen(text) * 8 >= dev->width)
+        if (y + 16 >= dev->height || x + strlen(text) * 8 >= width)
                 return;
 
         /* Print stream time */
-        for (line = y; line < y + 16; line++) {
-                int j = 0;
-                char *pos = basep + line * dev->width * dev->pixelsize + x * dev->pixelsize;
-                char *s;
-
-                for (s = text; *s; s++) {
-                        u8 chr = font8x16[*s * 16 + line - y];
-                        int i;
-
-                        for (i = 0; i < 7; i++, j++) {
-                                /* Draw white font on black background */
-                                if (chr & (1 << (7 - i)))
-                                        gen_twopix(dev, pos + j * dev->pixelsize, WHITE, (x+y) & 1);
-                                else
-                                        gen_twopix(dev, pos + j * dev->pixelsize, TEXT_BLACK, (x+y) & 1);
-                        }
-                }
+#define PRINTSTR(PIXTYPE) do {  \
+        PIXTYPE fg;     \
+        PIXTYPE bg;     \
+        memcpy(&fg, &dev->textfg, sizeof(PIXTYPE));     \
+        memcpy(&bg, &dev->textbg, sizeof(PIXTYPE));     \
+        \
+        for (line = 0; line < 16; line++) {     \
+                PIXTYPE *pos = (PIXTYPE *)( basep + ((y + line) * width + x) * sizeof(PIXTYPE) );       \
+                u8 *s;  \
+        \
+                for (s = text; *s; s++) {       \
+                        u8 chr = font8x16[*s * 16 + line];      \
+        \
+                        pos[0] = (chr & (0x01 << 7) ? fg : bg); \
+                        pos[1] = (chr & (0x01 << 6) ? fg : bg); \
+                        pos[2] = (chr & (0x01 << 5) ? fg : bg); \
+                        pos[3] = (chr & (0x01 << 4) ? fg : bg); \
+                        pos[4] = (chr & (0x01 << 3) ? fg : bg); \
+                        pos[5] = (chr & (0x01 << 2) ? fg : bg); \
+                        pos[6] = (chr & (0x01 << 1) ? fg : bg); \
+                        pos[7] = (chr & (0x01 << 0) ? fg : bg); \
+        \
+                        pos += 8;       \
+                }       \
+        }       \
+} while (0)
+
+        switch (dev->pixelsize) {
+        case 2:
+                PRINTSTR(u16); break;
+        case 4:
+                PRINTSTR(u32); break;
+        case 3:
+                PRINTSTR(x24); break;
         }
 }
 
 static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
 {
-        int wmax = dev->width;
+        int stride = dev->width * dev->pixelsize;
         int hmax = dev->height;
-        struct timeval ts;
         void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
         unsigned ms;
         char str[100];
         int h, line = 1;
+        u8 *linestart;
         s32 gain;
 
         if (!vbuf)
                 return;
 
+        linestart = dev->line + (dev->mv_count % dev->width) * dev->pixelsize;
+
         for (h = 0; h < hmax; h++)
-                memcpy(vbuf + h * wmax * dev->pixelsize,
-                       dev->line + (dev->mv_count % wmax) * dev->pixelsize,
-                       wmax * dev->pixelsize);
+                memcpy(vbuf + h * stride, linestart, stride);
 
         /* Updates stream time */
 
+        gen_twopix(dev, (u8 *)&dev->textbg, TEXT_BLACK, /*odd=*/ 0);
+        gen_twopix(dev, (u8 *)&dev->textfg, WHITE, /*odd=*/ 0);
+
         dev->ms += jiffies_to_msecs(jiffies - dev->jiffies);
         dev->jiffies = jiffies;
         ms = dev->ms;
@@ -622,8 +677,7 @@ static void vivi_fillbuff(struct vivi_dev *dev, struct vivi_buffer *buf)
         buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
         dev->field_count++;
         buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
-        do_gettimeofday(&ts);
-        buf->vb.v4l2_buf.timestamp = ts;
+        v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 }
 
 static void vivi_thread_tick(struct vivi_dev *dev)
@@ -645,7 +699,7 @@ static void vivi_thread_tick(struct vivi_dev *dev)
         list_del(&buf->list);
         spin_unlock_irqrestore(&dev->slock, flags);
 
-        do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
+        v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 
         /* Fill buffer */
         vivi_fillbuff(dev, buf);
@@ -655,8 +709,8 @@ static void vivi_thread_tick(struct vivi_dev *dev)
         dprintk(dev, 2, "[%p/%d] done\n", buf, buf->vb.v4l2_buf.index);
 }
 
-#define frames_to_ms(frames)                                    \
-        ((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
+#define frames_to_ms(dev, frames)                               \
+        ((frames * dev->timeperframe.numerator * 1000) / dev->timeperframe.denominator)
 
 static void vivi_sleep(struct vivi_dev *dev)
 {
@@ -672,7 +726,7 @@ static void vivi_sleep(struct vivi_dev *dev)
                 goto stop_task;
 
         /* Calculate time to wake up */
-        timeout = msecs_to_jiffies(frames_to_ms(1));
+        timeout = msecs_to_jiffies(frames_to_ms(dev, 1));
 
         vivi_thread_tick(dev);
 
@@ -872,7 +926,7 @@ static void vivi_unlock(struct vb2_queue *vq)
 }
 
 
-static struct vb2_ops vivi_video_qops = {
+static const struct vb2_ops vivi_video_qops = {
         .queue_setup            = queue_setup,
         .buf_prepare            = buffer_prepare,
         .buf_queue              = buffer_queue,
@@ -903,7 +957,7 @@ static int vidioc_querycap(struct file *file, void  *priv,
 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
                                         struct v4l2_fmtdesc *f)
 {
-        struct vivi_fmt *fmt;
+        const struct vivi_fmt *fmt;
 
         if (f->index >= ARRAY_SIZE(formats))
                 return -EINVAL;
@@ -939,7 +993,7 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                         struct v4l2_format *f)
 {
         struct vivi_dev *dev = video_drvdata(file);
-        struct vivi_fmt *fmt;
+        const struct vivi_fmt *fmt;
 
         fmt = get_format(f);
         if (!fmt) {
@@ -1044,6 +1098,70 @@ static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
         return 0;
 }
 
+/* timeperframe is arbitrary and continous */
+static int vidioc_enum_frameintervals(struct file *file, void *priv,
+                                             struct v4l2_frmivalenum *fival)
+{
+        const struct vivi_fmt *fmt;
+
+        if (fival->index)
+                return -EINVAL;
+
+        fmt = __get_format(fival->pixel_format);
+        if (!fmt)
+                return -EINVAL;
+
+        /* regarding width & height - we support any */
+
+        fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
+
+        /* fill in stepwise (step=1.0 is requred by V4L2 spec) */
+        fival->stepwise.min  = tpf_min;
+        fival->stepwise.max  = tpf_max;
+        fival->stepwise.step = (struct v4l2_fract) {1, 1};
+
+        return 0;
+}
+
+static int vidioc_g_parm(struct file *file, void *priv,
+                          struct v4l2_streamparm *parm)
+{
+        struct vivi_dev *dev = video_drvdata(file);
+
+        if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        parm->parm.capture.capability   = V4L2_CAP_TIMEPERFRAME;
+        parm->parm.capture.timeperframe = dev->timeperframe;
+        parm->parm.capture.readbuffers  = 1;
+        return 0;
+}
+
+#define FRACT_CMP(a, OP, b)     \
+        ((u64)(a).numerator * (b).denominator  OP  (u64)(b).numerator * (a).denominator)
+
+static int vidioc_s_parm(struct file *file, void *priv,
+                          struct v4l2_streamparm *parm)
+{
+        struct vivi_dev *dev = video_drvdata(file);
+        struct v4l2_fract tpf;
+
+        if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        tpf = parm->parm.capture.timeperframe;
+
+        /* tpf: {*, 0} resets timing; clip to [min, max]*/
+        tpf = tpf.denominator ? tpf : tpf_default;
+        tpf = FRACT_CMP(tpf, <, tpf_min) ? tpf_min : tpf;
+        tpf = FRACT_CMP(tpf, >, tpf_max) ? tpf_max : tpf;
+
+        dev->timeperframe = tpf;
+        parm->parm.capture.timeperframe = tpf;
+        parm->parm.capture.readbuffers  = 1;
+        return 0;
+}
+
 /* --- controls ---------------------------------------------- */
 
 static int vivi_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
@@ -1202,6 +1320,9 @@ static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
         .vidioc_enum_input    = vidioc_enum_input,
         .vidioc_g_input       = vidioc_g_input,
         .vidioc_s_input       = vidioc_s_input,
+        .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
+        .vidioc_g_parm        = vidioc_g_parm,
+        .vidioc_s_parm        = vidioc_s_parm,
         .vidioc_streamon      = vb2_ioctl_streamon,
         .vidioc_streamoff     = vb2_ioctl_streamoff,
         .vidioc_log_status    = v4l2_ctrl_log_status,
@@ -1209,7 +1330,7 @@ static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 };
 
-static struct video_device vivi_template = {
+static const struct video_device vivi_template = {
         .name           = "vivi",
         .fops           = &vivi_fops,
         .ioctl_ops      = &vivi_ioctl_ops,
@@ -1260,6 +1381,7 @@ static int __init vivi_create_instance(int inst)
                 goto free_dev;
 
         dev->fmt = &formats[0];
+        dev->timeperframe = tpf_default;
         dev->width = 640;
         dev->height = 480;
         dev->pixelsize = dev->fmt->depth / 8;