Merge branch 'patchwork' into v4l_for_linus

* patchwork: (404 commits)
  [media] uvcvideo: add support for VIDIOC_QUERY_EXT_CTRL
  [media] uvcvideo: fix cropcap v4l2-compliance failure
  [media] media: omap3isp: remove unused clkdev
  [media] coda: Add tracing support
  [media] coda: drop dma_sync_single_for_device in coda_bitstream_queue
  [media] coda: fix fill bitstream errors in nonstreaming case
  [media] coda: call SEQ_END when the first queue is stopped
  [media] coda: fail to start streaming if userspace set invalid formats
  [media] coda: remove duplicate error messages for buffer allocations
  [media] coda: move parameter buffer in together with context buffer allocation
  [media] coda: allocate bitstream buffer from REQBUFS, size depends on the format
  [media] coda: allocate per-context buffers from REQBUFS
  [media] coda: use strlcpy instead of snprintf
  [media] coda: bitstream payload is unsigned
  [media] coda: fix double call to debugfs_remove
  [media] coda: check kasprintf return value in coda_open
  [media] coda: bitrate can only be set in kbps steps
  [media] v4l2-mem2mem: no need to initialize b in v4l2_m2m_next_buf and v4l2_m2m_buf_remove
  [media] s5p-mfc: set allow_zero_bytesused flag for vb2_queue_init
  [media] coda: set allow_zero_bytesused flag for vb2_queue_init
  ...

3 files changed, 64 insertions, 60 deletions

diff --git a/drivers/media/platform/soc_camera/rcar_vin.c b/drivers/media/platform/soc_camera/rcar_vin.c
index 279ab9f6ae38..9351f64dee7b 100644
--- a/drivers/media/platform/soc_camera/rcar_vin.c
+++ b/drivers/media/platform/soc_camera/rcar_vin.c
@@ -977,19 +977,6 @@ static void rcar_vin_remove_device(struct soc_camera_device *icd)
                 icd->devnum);
 }
 
-/* Called with .host_lock held */
-static int rcar_vin_clock_start(struct soc_camera_host *ici)
-{
-        /* VIN does not have "mclk" */
-        return 0;
-}
-
-/* Called with .host_lock held */
-static void rcar_vin_clock_stop(struct soc_camera_host *ici)
-{
-        /* VIN does not have "mclk" */
-}
-
 static void set_coeff(struct rcar_vin_priv *priv, unsigned short xs)
 {
         int i;
@@ -1803,8 +1790,6 @@ static struct soc_camera_host_ops rcar_vin_host_ops = {
         .owner          = THIS_MODULE,
         .add            = rcar_vin_add_device,
         .remove         = rcar_vin_remove_device,
-        .clock_start    = rcar_vin_clock_start,
-        .clock_stop     = rcar_vin_clock_stop,
         .get_formats    = rcar_vin_get_formats,
         .put_formats    = rcar_vin_put_formats,
         .get_crop       = rcar_vin_get_crop,
diff --git a/drivers/media/platform/soc_camera/sh_mobile_csi2.c b/drivers/media/platform/soc_camera/sh_mobile_csi2.c
index c4e7aa0ee7e1..cd93241eb497 100644
--- a/drivers/media/platform/soc_camera/sh_mobile_csi2.c
+++ b/drivers/media/platform/soc_camera/sh_mobile_csi2.c
@@ -380,7 +380,6 @@ static int sh_csi2_remove(struct platform_device *pdev)
         struct sh_csi2 *priv = container_of(subdev, struct sh_csi2, subdev);
 
         v4l2_async_unregister_subdev(&priv->subdev);
-        v4l2_device_unregister_subdev(subdev);
         pm_runtime_disable(&pdev->dev);
 
         return 0;
diff --git a/drivers/media/platform/soc_camera/soc_camera.c b/drivers/media/platform/soc_camera/soc_camera.c
index 66634b469c98..55370d74ff57 100644
--- a/drivers/media/platform/soc_camera/soc_camera.c
+++ b/drivers/media/platform/soc_camera/soc_camera.c
@@ -177,6 +177,30 @@ static int __soc_camera_power_off(struct soc_camera_device *icd)
         return 0;
 }
 
+static int soc_camera_clock_start(struct soc_camera_host *ici)
+{
+        int ret;
+
+        if (!ici->ops->clock_start)
+                return 0;
+
+        mutex_lock(&ici->clk_lock);
+        ret = ici->ops->clock_start(ici);
+        mutex_unlock(&ici->clk_lock);
+
+        return ret;
+}
+
+static void soc_camera_clock_stop(struct soc_camera_host *ici)
+{
+        if (!ici->ops->clock_stop)
+                return;
+
+        mutex_lock(&ici->clk_lock);
+        ici->ops->clock_stop(ici);
+        mutex_unlock(&ici->clk_lock);
+}
+
 const struct soc_camera_format_xlate *soc_camera_xlate_by_fourcc(
         struct soc_camera_device *icd, unsigned int fourcc)
 {
@@ -584,9 +608,7 @@ static int soc_camera_add_device(struct soc_camera_device *icd)
                 return -EBUSY;
 
         if (!icd->clk) {
-                mutex_lock(&ici->clk_lock);
-                ret = ici->ops->clock_start(ici);
-                mutex_unlock(&ici->clk_lock);
+                ret = soc_camera_clock_start(ici);
                 if (ret < 0)
                         return ret;
         }
@@ -602,11 +624,8 @@ static int soc_camera_add_device(struct soc_camera_device *icd)
         return 0;
 
 eadd:
-        if (!icd->clk) {
-                mutex_lock(&ici->clk_lock);
-                ici->ops->clock_stop(ici);
-                mutex_unlock(&ici->clk_lock);
-        }
+        if (!icd->clk)
+                soc_camera_clock_stop(ici);
         return ret;
 }
 
@@ -619,11 +638,8 @@ static void soc_camera_remove_device(struct soc_camera_device *icd)
 
         if (ici->ops->remove)
                 ici->ops->remove(icd);
-        if (!icd->clk) {
-                mutex_lock(&ici->clk_lock);
-                ici->ops->clock_stop(ici);
-                mutex_unlock(&ici->clk_lock);
-        }
+        if (!icd->clk)
+                soc_camera_clock_stop(ici);
         ici->icd = NULL;
 }
 
@@ -688,7 +704,8 @@ static int soc_camera_open(struct file *file)
 
                 /* The camera could have been already on, try to reset */
                 if (sdesc->subdev_desc.reset)
-                        sdesc->subdev_desc.reset(icd->pdev);
+                        if (icd->control)
+                                sdesc->subdev_desc.reset(icd->control);
 
                 ret = soc_camera_add_device(icd);
                 if (ret < 0) {
@@ -1159,7 +1176,8 @@ static void scan_add_host(struct soc_camera_host *ici)
 
                         /* The camera could have been already on, try to reset */
                         if (ssdd->reset)
-                                ssdd->reset(icd->pdev);
+                                if (icd->control)
+                                        ssdd->reset(icd->control);
 
                         icd->parent = ici->v4l2_dev.dev;
 
@@ -1178,7 +1196,6 @@ static int soc_camera_clk_enable(struct v4l2_clk *clk)
 {
         struct soc_camera_device *icd = clk->priv;
         struct soc_camera_host *ici;
-        int ret;
 
         if (!icd || !icd->parent)
                 return -ENODEV;
@@ -1192,10 +1209,7 @@ static int soc_camera_clk_enable(struct v4l2_clk *clk)
          * If a different client is currently being probed, the host will tell
          * you to go
          */
-        mutex_lock(&ici->clk_lock);
-        ret = ici->ops->clock_start(ici);
-        mutex_unlock(&ici->clk_lock);
-        return ret;
+        return soc_camera_clock_start(ici);
 }
 
 static void soc_camera_clk_disable(struct v4l2_clk *clk)
@@ -1208,9 +1222,7 @@ static void soc_camera_clk_disable(struct v4l2_clk *clk)
 
         ici = to_soc_camera_host(icd->parent);
 
-        mutex_lock(&ici->clk_lock);
-        ici->ops->clock_stop(ici);
-        mutex_unlock(&ici->clk_lock);
+        soc_camera_clock_stop(ici);
 
         module_put(ici->ops->owner);
 }
@@ -1364,7 +1376,7 @@ static int soc_camera_i2c_init(struct soc_camera_device *icd,
         snprintf(clk_name, sizeof(clk_name), "%d-%04x",
                  shd->i2c_adapter_id, shd->board_info->addr);
 
-        icd->clk = v4l2_clk_register(&soc_camera_clk_ops, clk_name, "mclk", icd);
+        icd->clk = v4l2_clk_register(&soc_camera_clk_ops, clk_name, icd);
         if (IS_ERR(icd->clk)) {
                 ret = PTR_ERR(icd->clk);
                 goto eclkreg;
@@ -1445,7 +1457,7 @@ static int soc_camera_async_bound(struct v4l2_async_notifier *notifier,
                                 memcpy(&sdesc->subdev_desc, ssdd,
                                        sizeof(sdesc->subdev_desc));
                                 if (ssdd->reset)
-                                        ssdd->reset(icd->pdev);
+                                        ssdd->reset(&client->dev);
                         }
 
                         icd->control = &client->dev;
@@ -1545,7 +1557,7 @@ static int scan_async_group(struct soc_camera_host *ici,
         snprintf(clk_name, sizeof(clk_name), "%d-%04x",
                  sasd->asd.match.i2c.adapter_id, sasd->asd.match.i2c.address);
 
-        icd->clk = v4l2_clk_register(&soc_camera_clk_ops, clk_name, "mclk", icd);
+        icd->clk = v4l2_clk_register(&soc_camera_clk_ops, clk_name, icd);
         if (IS_ERR(icd->clk)) {
                 ret = PTR_ERR(icd->clk);
                 goto eclkreg;
@@ -1650,7 +1662,7 @@ static int soc_of_bind(struct soc_camera_host *ici,
                 snprintf(clk_name, sizeof(clk_name), "of-%s",
                          of_node_full_name(remote));
 
-        icd->clk = v4l2_clk_register(&soc_camera_clk_ops, clk_name, "mclk", icd);
+        icd->clk = v4l2_clk_register(&soc_camera_clk_ops, clk_name, icd);
         if (IS_ERR(icd->clk)) {
                 ret = PTR_ERR(icd->clk);
                 goto eclkreg;
@@ -1659,6 +1671,8 @@ static int soc_of_bind(struct soc_camera_host *ici,
         ret = v4l2_async_notifier_register(&ici->v4l2_dev, &sasc->notifier);
         if (!ret)
                 return 0;
+
+        v4l2_clk_unregister(icd->clk);
 eclkreg:
         icd->clk = NULL;
         platform_device_del(sasc->pdev);
@@ -1750,9 +1764,7 @@ static int soc_camera_probe(struct soc_camera_host *ici,
                 ret = -EINVAL;
                 goto eadd;
         } else {
-                mutex_lock(&ici->clk_lock);
-                ret = ici->ops->clock_start(ici);
-                mutex_unlock(&ici->clk_lock);
+                ret = soc_camera_clock_start(ici);
                 if (ret < 0)
                         goto eadd;
 
@@ -1792,9 +1804,7 @@ efinish:
                 module_put(control->driver->owner);
 enodrv:
 eadddev:
-                mutex_lock(&ici->clk_lock);
-                ici->ops->clock_stop(ici);
-                mutex_unlock(&ici->clk_lock);
+                soc_camera_clock_stop(ici);
         }
 eadd:
         if (icd->vdev) {
@@ -1888,22 +1898,34 @@ static int default_enum_framesizes(struct soc_camera_device *icd,
         int ret;
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         const struct soc_camera_format_xlate *xlate;
-        __u32 pixfmt = fsize->pixel_format;
-        struct v4l2_frmsizeenum fsize_mbus = *fsize;
+        struct v4l2_subdev_frame_size_enum fse = {
+                .index = fsize->index,
+                .which = V4L2_SUBDEV_FORMAT_ACTIVE,
+        };
 
-        xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
+        xlate = soc_camera_xlate_by_fourcc(icd, fsize->pixel_format);
         if (!xlate)
                 return -EINVAL;
-        /* map xlate-code to pixel_format, sensor only handle xlate-code*/
-        fsize_mbus.pixel_format = xlate->code;
+        fse.code = xlate->code;
 
-        ret = v4l2_subdev_call(sd, video, enum_framesizes, &fsize_mbus);
+        ret = v4l2_subdev_call(sd, pad, enum_frame_size, NULL, &fse);
         if (ret < 0)
                 return ret;
 
-        *fsize = fsize_mbus;
-        fsize->pixel_format = pixfmt;
-
+        if (fse.min_width == fse.max_width &&
+            fse.min_height == fse.max_height) {
+                fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
+                fsize->discrete.width = fse.min_width;
+                fsize->discrete.height = fse.min_height;
+                return 0;
+        }
+        fsize->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
+        fsize->stepwise.min_width = fse.min_width;
+        fsize->stepwise.max_width = fse.max_width;
+        fsize->stepwise.min_height = fse.min_height;
+        fsize->stepwise.max_height = fse.max_height;
+        fsize->stepwise.step_width = 1;
+        fsize->stepwise.step_height = 1;
         return 0;
 }
 
@@ -1920,8 +1942,6 @@ int soc_camera_host_register(struct soc_camera_host *ici)
             ((!ici->ops->init_videobuf ||
               !ici->ops->reqbufs) &&
              !ici->ops->init_videobuf2) ||
-            !ici->ops->clock_start ||
-            !ici->ops->clock_stop ||
             !ici->ops->poll ||
             !ici->v4l2_dev.dev)
                 return -EINVAL;