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:
 - V4L2 API additions to better support JPEG compression control
 - media API additions to properly support MPEG decoders
 - V4L2 API additions for image crop/scaling
 - a few other V4L2 API DocBook fixes/improvements
 - two new DVB frontend drivers: m88rs2000 and rtl2830
 - two new DVB drivers: az6007 and rtl28xxu
 - a framework for ISA drivers, that removed lots of common code found
   at the ISA radio drivers
 - a new FM transmitter driver (radio-keene)
 - a GPIO-based IR receiver driver
 - a new sensor driver: mt9m032
 - some new video drivers: adv7183, blackfin, mx2_emmaprp, sii9234_drv,
   vs6624
 - several new board additions, driver fixes, improvements and cleanups.

* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (295 commits)
  [media] update CARDLIST.em28xx
  [media] partially reverts changeset fa5527c
  [media] stb0899: fix the limits for signal strength values
  [media] em28xx: support for 2304:0242 PCTV QuatroStick (510e)
  [media] em28xx: support for 2013:0251 PCTV QuatroStick nano (520e)
  [media] -EINVAL -> -ENOTTY
  [media] gspca - sn9c20x: Cleanup source
  [media] gspca - sn9c20x: Simplify register write for capture start/stop
  [media] gspca - sn9c20x: Add automatic JPEG compression mechanism
  [media] gspca - sn9c20x: Greater delay in case of sensor no response
  [media] gspca - sn9c20x: Optimize the code of write sequences
  [media] gspca - sn9c20x: Add the JPEG compression quality control
  [media] gspca - sn9c20x: Add a delay after Omnivision sensor reset
  [media] gspca - sn9c20x: Propagate USB errors to higher level
  [media] gspca - sn9c20x: Use the new video control mechanism
  [media] gspca - sn9c20x: Fix loss of frame start
  [media] gspca - zc3xx: Lack of register 08 value for sensor cs2102k
  [media] gspca - ov534_9: Add brightness to OmniVision 5621 sensor
  [media] gspca - zc3xx: Add V4L2_CID_JPEG_COMPRESSION_QUALITY control support
  [media] pvrusb2: fix 7MHz & 8MHz DVB-T tuner support for HVR1900 rev D1F5
  ...

5 files changed, 172 insertions, 154 deletions

diff --git a/drivers/media/video/s5p-fimc/fimc-capture.c b/drivers/media/video/s5p-fimc/fimc-capture.c
index a9e9653beeb4..b06efd208328 100644
--- a/drivers/media/video/s5p-fimc/fimc-capture.c
+++ b/drivers/media/video/s5p-fimc/fimc-capture.c
@@ -1019,52 +1019,117 @@ static int fimc_cap_dqbuf(struct file *file, void *priv,
         return vb2_dqbuf(&fimc->vid_cap.vbq, buf, file->f_flags & O_NONBLOCK);
 }
 
-static int fimc_cap_cropcap(struct file *file, void *fh,
-                            struct v4l2_cropcap *cr)
+static int fimc_cap_create_bufs(struct file *file, void *priv,
+                                struct v4l2_create_buffers *create)
 {
         struct fimc_dev *fimc = video_drvdata(file);
-        struct fimc_frame *f = &fimc->vid_cap.ctx->s_frame;
 
-        if (cr->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
-                return -EINVAL;
+        return vb2_create_bufs(&fimc->vid_cap.vbq, create);
+}
 
-        cr->bounds.left         = 0;
-        cr->bounds.top          = 0;
-        cr->bounds.width        = f->o_width;
-        cr->bounds.height       = f->o_height;
-        cr->defrect             = cr->bounds;
+static int fimc_cap_prepare_buf(struct file *file, void *priv,
+                                struct v4l2_buffer *b)
+{
+        struct fimc_dev *fimc = video_drvdata(file);
 
-        return 0;
+        return vb2_prepare_buf(&fimc->vid_cap.vbq, b);
 }
 
-static int fimc_cap_g_crop(struct file *file, void *fh, struct v4l2_crop *cr)
+static int fimc_cap_g_selection(struct file *file, void *fh,
+                                struct v4l2_selection *s)
 {
         struct fimc_dev *fimc = video_drvdata(file);
-        struct fimc_frame *f = &fimc->vid_cap.ctx->s_frame;
+        struct fimc_ctx *ctx = fimc->vid_cap.ctx;
+        struct fimc_frame *f = &ctx->s_frame;
 
-        cr->c.left      = f->offs_h;
-        cr->c.top       = f->offs_v;
-        cr->c.width     = f->width;
-        cr->c.height    = f->height;
+        if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
+                return -EINVAL;
 
-        return 0;
+        switch (s->target) {
+        case V4L2_SEL_TGT_COMPOSE_DEFAULT:
+        case V4L2_SEL_TGT_COMPOSE_BOUNDS:
+                f = &ctx->d_frame;
+        case V4L2_SEL_TGT_CROP_BOUNDS:
+        case V4L2_SEL_TGT_CROP_DEFAULT:
+                s->r.left = 0;
+                s->r.top = 0;
+                s->r.width = f->o_width;
+                s->r.height = f->o_height;
+                return 0;
+
+        case V4L2_SEL_TGT_COMPOSE_ACTIVE:
+                f = &ctx->d_frame;
+        case V4L2_SEL_TGT_CROP_ACTIVE:
+                s->r.left = f->offs_h;
+                s->r.top = f->offs_v;
+                s->r.width = f->width;
+                s->r.height = f->height;
+                return 0;
+        }
+
+        return -EINVAL;
 }
 
-static int fimc_cap_s_crop(struct file *file, void *fh, struct v4l2_crop *cr)
+/* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
+int enclosed_rectangle(struct v4l2_rect *a, struct v4l2_rect *b)
+{
+        if (a->left < b->left || a->top < b->top)
+                return 0;
+        if (a->left + a->width > b->left + b->width)
+                return 0;
+        if (a->top + a->height > b->top + b->height)
+                return 0;
+
+        return 1;
+}
+
+static int fimc_cap_s_selection(struct file *file, void *fh,
+                                struct v4l2_selection *s)
 {
         struct fimc_dev *fimc = video_drvdata(file);
         struct fimc_ctx *ctx = fimc->vid_cap.ctx;
-        struct fimc_frame *ff;
+        struct v4l2_rect rect = s->r;
+        struct fimc_frame *f;
         unsigned long flags;
+        unsigned int pad;
 
-        fimc_capture_try_crop(ctx, &cr->c, FIMC_SD_PAD_SINK);
-        ff = &ctx->s_frame;
+        if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
+                return -EINVAL;
 
+        switch (s->target) {
+        case V4L2_SEL_TGT_COMPOSE_DEFAULT:
+        case V4L2_SEL_TGT_COMPOSE_BOUNDS:
+        case V4L2_SEL_TGT_COMPOSE_ACTIVE:
+                f = &ctx->d_frame;
+                pad = FIMC_SD_PAD_SOURCE;
+                break;
+        case V4L2_SEL_TGT_CROP_BOUNDS:
+        case V4L2_SEL_TGT_CROP_DEFAULT:
+        case V4L2_SEL_TGT_CROP_ACTIVE:
+                f = &ctx->s_frame;
+                pad = FIMC_SD_PAD_SINK;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        fimc_capture_try_crop(ctx, &rect, pad);
+
+        if (s->flags & V4L2_SEL_FLAG_LE &&
+            !enclosed_rectangle(&rect, &s->r))
+                return -ERANGE;
+
+        if (s->flags & V4L2_SEL_FLAG_GE &&
+            !enclosed_rectangle(&s->r, &rect))
+                return -ERANGE;
+
+        s->r = rect;
         spin_lock_irqsave(&fimc->slock, flags);
-        set_frame_crop(ff, cr->c.left, cr->c.top, cr->c.width, cr->c.height);
-        set_bit(ST_CAPT_APPLY_CFG, &fimc->state);
+        set_frame_crop(f, s->r.left, s->r.top, s->r.width,
+                       s->r.height);
         spin_unlock_irqrestore(&fimc->slock, flags);
 
+        set_bit(ST_CAPT_APPLY_CFG, &fimc->state);
         return 0;
 }
 
@@ -1082,12 +1147,14 @@ static const struct v4l2_ioctl_ops fimc_capture_ioctl_ops = {
         .vidioc_qbuf                    = fimc_cap_qbuf,
         .vidioc_dqbuf                   = fimc_cap_dqbuf,
 
+        .vidioc_prepare_buf             = fimc_cap_prepare_buf,
+        .vidioc_create_bufs             = fimc_cap_create_bufs,
+
         .vidioc_streamon                = fimc_cap_streamon,
         .vidioc_streamoff               = fimc_cap_streamoff,
 
-        .vidioc_g_crop                  = fimc_cap_g_crop,
-        .vidioc_s_crop                  = fimc_cap_s_crop,
-        .vidioc_cropcap                 = fimc_cap_cropcap,
+        .vidioc_g_selection             = fimc_cap_g_selection,
+        .vidioc_s_selection             = fimc_cap_s_selection,
 
         .vidioc_enum_input              = fimc_cap_enum_input,
         .vidioc_s_input                 = fimc_cap_s_input,
diff --git a/drivers/media/video/s5p-fimc/fimc-core.c b/drivers/media/video/s5p-fimc/fimc-core.c
index 81bcbb9492ea..e184e650022a 100644
--- a/drivers/media/video/s5p-fimc/fimc-core.c
+++ b/drivers/media/video/s5p-fimc/fimc-core.c
@@ -1602,24 +1602,35 @@ static void fimc_clk_put(struct fimc_dev *fimc)
 {
         int i;
         for (i = 0; i < fimc->num_clocks; i++) {
-                if (fimc->clock[i])
-                        clk_put(fimc->clock[i]);
+                if (IS_ERR_OR_NULL(fimc->clock[i]))
+                        continue;
+                clk_unprepare(fimc->clock[i]);
+                clk_put(fimc->clock[i]);
+                fimc->clock[i] = NULL;
         }
 }
 
 static int fimc_clk_get(struct fimc_dev *fimc)
 {
-        int i;
+        int i, ret;
+
         for (i = 0; i < fimc->num_clocks; i++) {
                 fimc->clock[i] = clk_get(&fimc->pdev->dev, fimc_clocks[i]);
-                if (!IS_ERR_OR_NULL(fimc->clock[i]))
-                        continue;
-                dev_err(&fimc->pdev->dev, "failed to get fimc clock: %s\n",
-                        fimc_clocks[i]);
-                return -ENXIO;
+                if (IS_ERR(fimc->clock[i]))
+                        goto err;
+                ret = clk_prepare(fimc->clock[i]);
+                if (ret < 0) {
+                        clk_put(fimc->clock[i]);
+                        fimc->clock[i] = NULL;
+                        goto err;
+                }
         }
-
         return 0;
+err:
+        fimc_clk_put(fimc);
+        dev_err(&fimc->pdev->dev, "failed to get clock: %s\n",
+                fimc_clocks[i]);
+        return -ENXIO;
 }
 
 static int fimc_m2m_suspend(struct fimc_dev *fimc)
@@ -1667,8 +1678,6 @@ static int fimc_probe(struct platform_device *pdev)
         struct s5p_platform_fimc *pdata;
         int ret = 0;
 
-        dev_dbg(&pdev->dev, "%s():\n", __func__);
-
         drv_data = (struct samsung_fimc_driverdata *)
                 platform_get_device_id(pdev)->driver_data;
 
@@ -1678,7 +1687,7 @@ static int fimc_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        fimc = kzalloc(sizeof(struct fimc_dev), GFP_KERNEL);
+        fimc = devm_kzalloc(&pdev->dev, sizeof(*fimc), GFP_KERNEL);
         if (!fimc)
                 return -ENOMEM;
 
@@ -1689,51 +1698,35 @@ static int fimc_probe(struct platform_device *pdev)
         pdata = pdev->dev.platform_data;
         fimc->pdata = pdata;
 
-
         init_waitqueue_head(&fimc->irq_queue);
         spin_lock_init(&fimc->slock);
         mutex_init(&fimc->lock);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(&pdev->dev, "failed to find the registers\n");
-                ret = -ENOENT;
-                goto err_info;
-        }
-
-        fimc->regs_res = request_mem_region(res->start, resource_size(res),
-                        dev_name(&pdev->dev));
-        if (!fimc->regs_res) {
-                dev_err(&pdev->dev, "failed to obtain register region\n");
-                ret = -ENOENT;
-                goto err_info;
-        }
-
-        fimc->regs = ioremap(res->start, resource_size(res));
-        if (!fimc->regs) {
-                dev_err(&pdev->dev, "failed to map registers\n");
-                ret = -ENXIO;
-                goto err_req_region;
+        fimc->regs = devm_request_and_ioremap(&pdev->dev, res);
+        if (fimc->regs == NULL) {
+                dev_err(&pdev->dev, "Failed to obtain io memory\n");
+                return -ENOENT;
         }
 
         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
-        if (!res) {
-                dev_err(&pdev->dev, "failed to get IRQ resource\n");
-                ret = -ENXIO;
-                goto err_regs_unmap;
+        if (res == NULL) {
+                dev_err(&pdev->dev, "Failed to get IRQ resource\n");
+                return -ENXIO;
         }
         fimc->irq = res->start;
 
         fimc->num_clocks = MAX_FIMC_CLOCKS;
         ret = fimc_clk_get(fimc);
         if (ret)
-                goto err_regs_unmap;
+                return ret;
         clk_set_rate(fimc->clock[CLK_BUS], drv_data->lclk_frequency);
         clk_enable(fimc->clock[CLK_BUS]);
 
         platform_set_drvdata(pdev, fimc);
 
-        ret = request_irq(fimc->irq, fimc_irq_handler, 0, pdev->name, fimc);
+        ret = devm_request_irq(&pdev->dev, fimc->irq, fimc_irq_handler,
+                               0, pdev->name, fimc);
         if (ret) {
                 dev_err(&pdev->dev, "failed to install irq (%d)\n", ret);
                 goto err_clk;
@@ -1742,7 +1735,7 @@ static int fimc_probe(struct platform_device *pdev)
         pm_runtime_enable(&pdev->dev);
         ret = pm_runtime_get_sync(&pdev->dev);
         if (ret < 0)
-                goto err_irq;
+                goto err_clk;
         /* Initialize contiguous memory allocator */
         fimc->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
         if (IS_ERR(fimc->alloc_ctx)) {
@@ -1757,17 +1750,8 @@ static int fimc_probe(struct platform_device *pdev)
 
 err_pm:
         pm_runtime_put(&pdev->dev);
-err_irq:
-        free_irq(fimc->irq, fimc);
 err_clk:
         fimc_clk_put(fimc);
-err_regs_unmap:
-        iounmap(fimc->regs);
-err_req_region:
-        release_resource(fimc->regs_res);
-        kfree(fimc->regs_res);
-err_info:
-        kfree(fimc);
         return ret;
 }
 
@@ -1854,11 +1838,6 @@ static int __devexit fimc_remove(struct platform_device *pdev)
 
         clk_disable(fimc->clock[CLK_BUS]);
         fimc_clk_put(fimc);
-        free_irq(fimc->irq, fimc);
-        iounmap(fimc->regs);
-        release_resource(fimc->regs_res);
-        kfree(fimc->regs_res);
-        kfree(fimc);
 
         dev_info(&pdev->dev, "driver unloaded\n");
         return 0;
diff --git a/drivers/media/video/s5p-fimc/fimc-core.h b/drivers/media/video/s5p-fimc/fimc-core.h
index 4e20560c73d4..a18291e648e2 100644
--- a/drivers/media/video/s5p-fimc/fimc-core.h
+++ b/drivers/media/video/s5p-fimc/fimc-core.h
@@ -434,7 +434,6 @@ struct fimc_ctx;
  * @num_clocks: the number of clocks managed by this device instance
  * @clock:      clocks required for FIMC operation
  * @regs:       the mapped hardware registers
- * @regs_res:   the resource claimed for IO registers
  * @irq:        FIMC interrupt number
  * @irq_queue:  interrupt handler waitqueue
  * @v4l2_dev:   root v4l2_device
@@ -454,7 +453,6 @@ struct fimc_dev {
         u16                             num_clocks;
         struct clk                      *clock[MAX_FIMC_CLOCKS];
         void __iomem                    *regs;
-        struct resource                 *regs_res;
         int                             irq;
         wait_queue_head_t               irq_queue;
         struct v4l2_device              *v4l2_dev;
diff --git a/drivers/media/video/s5p-fimc/fimc-mdevice.c b/drivers/media/video/s5p-fimc/fimc-mdevice.c
index 63eccb55728f..62ed37e40149 100644
--- a/drivers/media/video/s5p-fimc/fimc-mdevice.c
+++ b/drivers/media/video/s5p-fimc/fimc-mdevice.c
@@ -750,7 +750,7 @@ static int __devinit fimc_md_probe(struct platform_device *pdev)
         struct fimc_md *fmd;
         int ret;
 
-        fmd = kzalloc(sizeof(struct fimc_md), GFP_KERNEL);
+        fmd = devm_kzalloc(&pdev->dev, sizeof(*fmd), GFP_KERNEL);
         if (!fmd)
                 return -ENOMEM;
 
@@ -771,7 +771,7 @@ static int __devinit fimc_md_probe(struct platform_device *pdev)
         ret = v4l2_device_register(&pdev->dev, &fmd->v4l2_dev);
         if (ret < 0) {
                 v4l2_err(v4l2_dev, "Failed to register v4l2_device: %d\n", ret);
-                goto err1;
+                return ret;
         }
         ret = media_device_register(&fmd->media_dev);
         if (ret < 0) {
@@ -813,8 +813,6 @@ err3:
         fimc_md_unregister_entities(fmd);
 err2:
         v4l2_device_unregister(&fmd->v4l2_dev);
-err1:
-        kfree(fmd);
         return ret;
 }
 
@@ -828,7 +826,6 @@ static int __devexit fimc_md_remove(struct platform_device *pdev)
         fimc_md_unregister_entities(fmd);
         media_device_unregister(&fmd->media_dev);
         fimc_md_put_clocks(fmd);
-        kfree(fmd);
         return 0;
 }
 
diff --git a/drivers/media/video/s5p-fimc/mipi-csis.c b/drivers/media/video/s5p-fimc/mipi-csis.c
index 130335cf62fd..f44f690397f7 100644
--- a/drivers/media/video/s5p-fimc/mipi-csis.c
+++ b/drivers/media/video/s5p-fimc/mipi-csis.c
@@ -1,8 +1,8 @@
 /*
  * Samsung S5P/EXYNOS4 SoC series MIPI-CSI receiver 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 version 2 as
@@ -100,7 +100,6 @@ enum {
  * @pads: CSIS pads array
  * @sd: v4l2_subdev associated with CSIS device instance
  * @pdev: CSIS platform device
- * @regs_res: requested I/O register memory resource
  * @regs: mmaped I/O registers memory
  * @clock: CSIS clocks
  * @irq: requested s5p-mipi-csis irq number
@@ -113,7 +112,6 @@ struct csis_state {
         struct media_pad pads[CSIS_PADS_NUM];
         struct v4l2_subdev sd;
         struct platform_device *pdev;
-        struct resource *regs_res;
         void __iomem *regs;
         struct regulator_bulk_data supplies[CSIS_NUM_SUPPLIES];
         struct clk *clock[NUM_CSIS_CLOCKS];
@@ -258,26 +256,36 @@ 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]))
-                        clk_put(state->clock[i]);
+        for (i = 0; i < NUM_CSIS_CLOCKS; i++) {
+                if (IS_ERR_OR_NULL(state->clock[i]))
+                        continue;
+                clk_unprepare(state->clock[i]);
+                clk_put(state->clock[i]);
+                state->clock[i] = NULL;
+        }
 }
 
 static int s5pcsis_clk_get(struct csis_state *state)
 {
         struct device *dev = &state->pdev->dev;
-        int i;
+        int i, ret;
 
         for (i = 0; i < NUM_CSIS_CLOCKS; i++) {
                 state->clock[i] = clk_get(dev, csi_clock_name[i]);
-                if (IS_ERR(state->clock[i])) {
-                        s5pcsis_clk_put(state);
-                        dev_err(dev, "failed to get clock: %s\n",
-                                csi_clock_name[i]);
-                        return -ENXIO;
+                if (IS_ERR(state->clock[i]))
+                        goto err;
+                ret = clk_prepare(state->clock[i]);
+                if (ret < 0) {
+                        clk_put(state->clock[i]);
+                        state->clock[i] = NULL;
+                        goto err;
                 }
         }
         return 0;
+err:
+        s5pcsis_clk_put(state);
+        dev_err(dev, "failed to get clock: %s\n", csi_clock_name[i]);
+        return -ENXIO;
 }
 
 static int s5pcsis_s_power(struct v4l2_subdev *sd, int on)
@@ -480,12 +488,11 @@ static int __devinit s5pcsis_probe(struct platform_device *pdev)
 {
         struct s5p_platform_mipi_csis *pdata;
         struct resource *mem_res;
-        struct resource *regs_res;
         struct csis_state *state;
         int ret = -ENOMEM;
         int i;
 
-        state = kzalloc(sizeof(*state), GFP_KERNEL);
+        state = devm_kzalloc(&pdev->dev, sizeof(*state), GFP_KERNEL);
         if (!state)
                 return -ENOMEM;
 
@@ -495,52 +502,27 @@ static int __devinit s5pcsis_probe(struct platform_device *pdev)
         pdata = pdev->dev.platform_data;
         if (pdata == NULL || pdata->phy_enable == NULL) {
                 dev_err(&pdev->dev, "Platform data not fully specified\n");
-                goto e_free;
+                return -EINVAL;
         }
 
         if ((pdev->id == 1 && pdata->lanes > CSIS1_MAX_LANES) ||
             pdata->lanes > CSIS0_MAX_LANES) {
-                ret = -EINVAL;
                 dev_err(&pdev->dev, "Unsupported number of data lanes: %d\n",
                         pdata->lanes);
-                goto e_free;
+                return -EINVAL;
         }
 
         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!mem_res) {
-                dev_err(&pdev->dev, "Failed to get IO memory region\n");
-                goto e_free;
+        state->regs = devm_request_and_ioremap(&pdev->dev, mem_res);
+        if (state->regs == NULL) {
+                dev_err(&pdev->dev, "Failed to request and remap io memory\n");
+                return -ENXIO;
         }
 
-        regs_res = request_mem_region(mem_res->start, resource_size(mem_res),
-                                      pdev->name);
-        if (!regs_res) {
-                dev_err(&pdev->dev, "Failed to request IO memory region\n");
-                goto e_free;
-        }
-        state->regs_res = regs_res;
-
-        state->regs = ioremap(mem_res->start, resource_size(mem_res));
-        if (!state->regs) {
-                dev_err(&pdev->dev, "Failed to remap IO region\n");
-                goto e_reqmem;
-        }
-
-        ret = s5pcsis_clk_get(state);
-        if (ret)
-                goto e_unmap;
-
-        clk_enable(state->clock[CSIS_CLK_MUX]);
-        if (pdata->clk_rate)
-                clk_set_rate(state->clock[CSIS_CLK_MUX], pdata->clk_rate);
-        else
-                dev_WARN(&pdev->dev, "No clock frequency specified!\n");
-
         state->irq = platform_get_irq(pdev, 0);
         if (state->irq < 0) {
-                ret = state->irq;
                 dev_err(&pdev->dev, "Failed to get irq\n");
-                goto e_clkput;
+                return state->irq;
         }
 
         for (i = 0; i < CSIS_NUM_SUPPLIES; i++)
@@ -549,12 +531,22 @@ static int __devinit s5pcsis_probe(struct platform_device *pdev)
         ret = regulator_bulk_get(&pdev->dev, CSIS_NUM_SUPPLIES,
                                  state->supplies);
         if (ret)
+                return ret;
+
+        ret = s5pcsis_clk_get(state);
+        if (ret)
                 goto e_clkput;
 
-        ret = request_irq(state->irq, s5pcsis_irq_handler, 0,
-                          dev_name(&pdev->dev), state);
+        clk_enable(state->clock[CSIS_CLK_MUX]);
+        if (pdata->clk_rate)
+                clk_set_rate(state->clock[CSIS_CLK_MUX], pdata->clk_rate);
+        else
+                dev_WARN(&pdev->dev, "No clock frequency specified!\n");
+
+        ret = devm_request_irq(&pdev->dev, state->irq, s5pcsis_irq_handler,
+                               0, dev_name(&pdev->dev), state);
         if (ret) {
-                dev_err(&pdev->dev, "request_irq failed\n");
+                dev_err(&pdev->dev, "Interrupt request failed\n");
                 goto e_regput;
         }
 
@@ -573,7 +565,7 @@ static int __devinit s5pcsis_probe(struct platform_device *pdev)
         ret = media_entity_init(&state->sd.entity,
                                 CSIS_PADS_NUM, state->pads, 0);
         if (ret < 0)
-                goto e_irqfree;
+                goto e_clkput;
 
         /* This allows to retrieve the platform device id by the host driver */
         v4l2_set_subdevdata(&state->sd, pdev);
@@ -582,22 +574,13 @@ static int __devinit s5pcsis_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, &state->sd);
 
         pm_runtime_enable(&pdev->dev);
-
         return 0;
 
-e_irqfree:
-        free_irq(state->irq, state);
 e_regput:
         regulator_bulk_free(CSIS_NUM_SUPPLIES, state->supplies);
 e_clkput:
         clk_disable(state->clock[CSIS_CLK_MUX]);
         s5pcsis_clk_put(state);
-e_unmap:
-        iounmap(state->regs);
-e_reqmem:
-        release_mem_region(regs_res->start, resource_size(regs_res));
-e_free:
-        kfree(state);
         return ret;
 }
 
@@ -699,21 +682,15 @@ static int __devexit s5pcsis_remove(struct platform_device *pdev)
 {
         struct v4l2_subdev *sd = platform_get_drvdata(pdev);
         struct csis_state *state = sd_to_csis_state(sd);
-        struct resource *res = state->regs_res;
 
         pm_runtime_disable(&pdev->dev);
-        s5pcsis_suspend(&pdev->dev);
+        s5pcsis_pm_suspend(&pdev->dev, false);
         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);
-        free_irq(state->irq, state);
-        iounmap(state->regs);
-        release_mem_region(res->start, resource_size(res));
-        kfree(state);
 
         return 0;
 }