V4L/DVB (12510): soc-camera: (partially) convert to v4l2-(sub)dev API

Convert the soc-camera framework to use the v4l2-(sub)dev API. Start using
v4l2-subdev operations. Only a part of the interface between the
soc_camera core, soc_camera host drivers on one side and soc_camera device
drivers on the other side is replaced so far. The rest of the interface
will be replaced in incremental steps, and will require extensions and,
possibly, modifications to the v4l2-subdev code.

Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

1 files changed, 148 insertions, 102 deletions

diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
index 20ef5c773fae..0a1cb40bfbf6 100644
--- a/drivers/media/video/soc_camera.c
+++ b/drivers/media/video/soc_camera.c
@@ -170,8 +170,6 @@ static int soc_camera_reqbufs(struct file *file, void *priv,
 
         WARN_ON(priv != file->private_data);
 
-        dev_dbg(&icd->dev, "%s: %d\n", __func__, p->memory);
-
         ret = videobuf_reqbufs(&icf->vb_vidq, p);
         if (ret < 0)
                 return ret;
@@ -285,7 +283,7 @@ static int soc_camera_set_fmt(struct soc_camera_file *icf,
                 return ret;
         } else if (!icd->current_fmt ||
                    icd->current_fmt->fourcc != pix->pixelformat) {
-                dev_err(ici->dev,
+                dev_err(ici->v4l2_dev.dev,
                         "Host driver hasn't set up current format correctly!\n");
                 return -EINVAL;
         }
@@ -308,20 +306,13 @@ static int soc_camera_set_fmt(struct soc_camera_file *icf,
 
 static int soc_camera_open(struct file *file)
 {
-        struct video_device *vdev;
-        struct soc_camera_device *icd;
+        struct video_device *vdev = video_devdata(file);
+        struct soc_camera_device *icd = container_of(vdev->parent, struct soc_camera_device, dev);
+        struct soc_camera_link *icl = to_soc_camera_link(icd);
         struct soc_camera_host *ici;
         struct soc_camera_file *icf;
         int ret;
 
-        /*
-         * It is safe to dereference these pointers now as long as a user has
-         * the video device open - we are protected by the held cdev reference.
-         */
-
-        vdev = video_devdata(file);
-        icd = container_of(vdev->parent, struct soc_camera_device, dev);
-
         if (!icd->ops)
                 /* No device driver attached */
                 return -ENODEV;
@@ -332,12 +323,6 @@ static int soc_camera_open(struct file *file)
         if (!icf)
                 return -ENOMEM;
 
-        if (!try_module_get(icd->ops->owner)) {
-                dev_err(&icd->dev, "Couldn't lock sensor driver.\n");
-                ret = -EINVAL;
-                goto emgd;
-        }
-
         if (!try_module_get(ici->ops->owner)) {
                 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
                 ret = -EINVAL;
@@ -366,47 +351,65 @@ static int soc_camera_open(struct file *file)
                 if (ret < 0)
                         goto eiufmt;
 
-                dev_dbg(&icd->dev, "Using fmt %x\n", icd->current_fmt->fourcc);
-
                 f.fmt.pix.pixelformat   = icd->current_fmt->fourcc;
                 f.fmt.pix.colorspace    = icd->current_fmt->colorspace;
 
+                if (icl->power) {
+                        ret = icl->power(icd->pdev, 1);
+                        if (ret < 0)
+                                goto epower;
+                }
+
+                /* The camera could have been already on, try to reset */
+                if (icl->reset)
+                        icl->reset(icd->pdev);
+
                 ret = ici->ops->add(icd);
                 if (ret < 0) {
                         dev_err(&icd->dev, "Couldn't activate the camera: %d\n", ret);
                         goto eiciadd;
                 }
 
+                if (icd->ops->init) {
+                        ret = icd->ops->init(icd);
+                        if (ret < 0)
+                                goto einit;
+                }
+
                 /* Try to configure with default parameters */
                 ret = soc_camera_set_fmt(icf, &f);
                 if (ret < 0)
                         goto esfmt;
         }
 
-        mutex_unlock(&icd->video_lock);
-
         file->private_data = icf;
         dev_dbg(&icd->dev, "camera device open\n");
 
         ici->ops->init_videobuf(&icf->vb_vidq, icd);
 
+        mutex_unlock(&icd->video_lock);
+
         return 0;
 
         /*
-         * First three errors are entered with the .video_lock held
+         * First five errors are entered with the .video_lock held
          * and use_count == 1
          */
 esfmt:
+        if (icd->ops->release)
+                icd->ops->release(icd);
+einit:
         ici->ops->remove(icd);
 eiciadd:
+        if (icl->power)
+                icl->power(icd->pdev, 0);
+epower:
         soc_camera_free_user_formats(icd);
 eiufmt:
         icd->use_count--;
         mutex_unlock(&icd->video_lock);
         module_put(ici->ops->owner);
 emgi:
-        module_put(icd->ops->owner);
-emgd:
         vfree(icf);
         return ret;
 }
@@ -421,13 +424,18 @@ static int soc_camera_close(struct file *file)
         mutex_lock(&icd->video_lock);
         icd->use_count--;
         if (!icd->use_count) {
+                struct soc_camera_link *icl = to_soc_camera_link(icd);
+
+                if (icd->ops->release)
+                        icd->ops->release(icd);
                 ici->ops->remove(icd);
+                if (icl->power)
+                        icl->power(icd->pdev, 0);
                 soc_camera_free_user_formats(icd);
         }
 
         mutex_unlock(&icd->video_lock);
 
-        module_put(icd->ops->owner);
         module_put(ici->ops->owner);
 
         vfree(icf);
@@ -575,18 +583,17 @@ static int soc_camera_streamon(struct file *file, void *priv,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         int ret;
 
         WARN_ON(priv != file->private_data);
 
-        dev_dbg(&icd->dev, "%s\n", __func__);
-
         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
 
         mutex_lock(&icd->video_lock);
 
-        icd->ops->start_capture(icd);
+        v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, video, s_stream, 1);
 
         /* This calls buf_queue from host driver's videobuf_queue_ops */
         ret = videobuf_streamon(&icf->vb_vidq);
@@ -601,11 +608,10 @@ static int soc_camera_streamoff(struct file *file, void *priv,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
         WARN_ON(priv != file->private_data);
 
-        dev_dbg(&icd->dev, "%s\n", __func__);
-
         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
 
@@ -615,7 +621,7 @@ static int soc_camera_streamoff(struct file *file, void *priv,
          * remaining buffers. When the last buffer is freed, stop capture */
         videobuf_streamoff(&icf->vb_vidq);
 
-        icd->ops->stop_capture(icd);
+        v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, video, s_stream, 0);
 
         mutex_unlock(&icd->video_lock);
 
@@ -649,6 +655,7 @@ static int soc_camera_g_ctrl(struct file *file, void *priv,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
         WARN_ON(priv != file->private_data);
 
@@ -665,9 +672,7 @@ static int soc_camera_g_ctrl(struct file *file, void *priv,
                 return 0;
         }
 
-        if (icd->ops->get_control)
-                return icd->ops->get_control(icd, ctrl);
-        return -EINVAL;
+        return v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, core, g_ctrl, ctrl);
 }
 
 static int soc_camera_s_ctrl(struct file *file, void *priv,
@@ -675,12 +680,11 @@ static int soc_camera_s_ctrl(struct file *file, void *priv,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
         WARN_ON(priv != file->private_data);
 
-        if (icd->ops->set_control)
-                return icd->ops->set_control(icd, ctrl);
-        return -EINVAL;
+        return v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, core, s_ctrl, ctrl);
 }
 
 static int soc_camera_cropcap(struct file *file, void *fh,
@@ -751,11 +755,9 @@ static int soc_camera_g_chip_ident(struct file *file, void *fh,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
-        if (!icd->ops->get_chip_id)
-                return -EINVAL;
-
-        return icd->ops->get_chip_id(icd, id);
+        return v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, core, g_chip_ident, id);
 }
 
 #ifdef CONFIG_VIDEO_ADV_DEBUG
@@ -764,11 +766,9 @@ static int soc_camera_g_register(struct file *file, void *fh,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
-        if (!icd->ops->get_register)
-                return -EINVAL;
-
-        return icd->ops->get_register(icd, reg);
+        return v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, core, g_register, reg);
 }
 
 static int soc_camera_s_register(struct file *file, void *fh,
@@ -776,11 +776,9 @@ static int soc_camera_s_register(struct file *file, void *fh,
 {
         struct soc_camera_file *icf = file->private_data;
         struct soc_camera_device *icd = icf->icd;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
-        if (!icd->ops->set_register)
-                return -EINVAL;
-
-        return icd->ops->set_register(icd, reg);
+        return v4l2_device_call_until_err(&ici->v4l2_dev, (__u32)icd, core, s_register, reg);
 }
 #endif
 
@@ -794,7 +792,7 @@ static void scan_add_host(struct soc_camera_host *ici)
         list_for_each_entry(icd, &devices, list) {
                 if (icd->iface == ici->nr) {
                         int ret;
-                        icd->dev.parent = ici->dev;
+                        icd->dev.parent = ici->v4l2_dev.dev;
                         dev_set_name(&icd->dev, "%u-%u", icd->iface,
                                      icd->devnum);
                         ret = device_register(&icd->dev);
@@ -814,7 +812,9 @@ static int soc_camera_init_i2c(struct soc_camera_device *icd,
                                struct soc_camera_link *icl)
 {
         struct i2c_client *client;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct i2c_adapter *adap = i2c_get_adapter(icl->i2c_adapter_id);
+        struct v4l2_subdev *subdev;
         int ret;
 
         if (!adap) {
@@ -826,17 +826,16 @@ static int soc_camera_init_i2c(struct soc_camera_device *icd,
 
         icl->board_info->platform_data = icd;
 
-        client = i2c_new_device(adap, icl->board_info);
-        if (!client) {
+        subdev = v4l2_i2c_new_subdev_board(&ici->v4l2_dev, adap,
+                                icl->module_name, icl->board_info, NULL);
+        if (!subdev) {
                 ret = -ENOMEM;
                 goto ei2cnd;
         }
 
-        /*
-         * We set icd drvdata at two locations - here and in
-         * soc_camera_video_start(). Depending on the module loading /
-         * initialisation order one of these locations will be entered first
-         */
+        subdev->grp_id = (__u32)icd;
+        client = subdev->priv;
+
         /* Use to_i2c_client(dev) to recover the i2c client */
         dev_set_drvdata(&icd->dev, &client->dev);
 
@@ -852,6 +851,7 @@ static void soc_camera_free_i2c(struct soc_camera_device *icd)
         struct i2c_client *client =
                 to_i2c_client(to_soc_camera_control(icd));
         dev_set_drvdata(&icd->dev, NULL);
+        v4l2_device_unregister_subdev(i2c_get_clientdata(client));
         i2c_unregister_device(client);
         i2c_put_adapter(client->adapter);
 }
@@ -860,16 +860,37 @@ static void soc_camera_free_i2c(struct soc_camera_device *icd)
 #define soc_camera_free_i2c(icd)        do {} while (0)
 #endif
 
+static int soc_camera_video_start(struct soc_camera_device *icd);
 static int video_dev_create(struct soc_camera_device *icd);
 /* Called during host-driver probe */
 static int soc_camera_probe(struct device *dev)
 {
         struct soc_camera_device *icd = to_soc_camera_dev(dev);
+        struct soc_camera_host *ici = to_soc_camera_host(dev->parent);
         struct soc_camera_link *icl = to_soc_camera_link(icd);
+        struct device *control = NULL;
         int ret;
 
         dev_info(dev, "Probing %s\n", dev_name(dev));
 
+        if (icl->power) {
+                ret = icl->power(icd->pdev, 1);
+                if (ret < 0) {
+                        dev_err(dev,
+                                "Platform failed to power-on the camera.\n");
+                        goto epower;
+                }
+        }
+
+        /* The camera could have been already on, try to reset */
+        if (icl->reset)
+                icl->reset(icd->pdev);
+
+        ret = ici->ops->add(icd);
+        if (ret < 0)
+                goto eadd;
+
+        /* Must have icd->vdev before registering the device */
         ret = video_dev_create(icd);
         if (ret < 0)
                 goto evdc;
@@ -883,34 +904,61 @@ static int soc_camera_probe(struct device *dev)
                 ret = -EINVAL;
                 goto eadddev;
         } else {
+                if (icl->module_name)
+                        ret = request_module(icl->module_name);
+
                 ret = icl->add_device(icl, &icd->dev);
                 if (ret < 0)
                         goto eadddev;
-        }
 
-        ret = video_register_device(icd->vdev, VFL_TYPE_GRABBER, icd->vdev->minor);
-        if (ret < 0) {
-                dev_err(&icd->dev, "video_register_device failed: %d\n", ret);
-                goto evidregd;
+                /* FIXME: this is racy, have to use driver-binding notification */
+                control = to_soc_camera_control(icd);
+                if (!control || !control->driver ||
+                    !try_module_get(control->driver->owner)) {
+                        icl->del_device(icl);
+                        goto enodrv;
+                }
         }
 
+        /* ..._video_start() will create a device node, so we have to protect */
+        mutex_lock(&icd->video_lock);
+
+        ret = soc_camera_video_start(icd);
+        if (ret < 0)
+                goto evidstart;
+
         /* Do we have to sysfs_remove_link() before device_unregister()? */
         if (to_soc_camera_control(icd) &&
             sysfs_create_link(&icd->dev.kobj, &to_soc_camera_control(icd)->kobj,
                               "control"))
                 dev_warn(&icd->dev, "Failed creating the control symlink\n");
 
+        ici->ops->remove(icd);
+
+        if (icl->power)
+                icl->power(icd->pdev, 0);
+
+        mutex_unlock(&icd->video_lock);
 
         return 0;
 
-evidregd:
-        if (icl->board_info)
+evidstart:
+        mutex_unlock(&icd->video_lock);
+        if (icl->board_info) {
                 soc_camera_free_i2c(icd);
-        else
+        } else {
                 icl->del_device(icl);
+                module_put(control->driver->owner);
+        }
+enodrv:
 eadddev:
         video_device_release(icd->vdev);
 evdc:
+        ici->ops->remove(icd);
+eadd:
+        if (icl->power)
+                icl->power(icd->pdev, 0);
+epower:
         return ret;
 }
 
@@ -931,10 +979,16 @@ static int soc_camera_remove(struct device *dev)
                 mutex_unlock(&icd->video_lock);
         }
 
-        if (icl->board_info)
+        if (icl->board_info) {
                 soc_camera_free_i2c(icd);
-        else
-                icl->del_device(icl);
+        } else {
+                struct device_driver *drv = to_soc_camera_control(icd) ?
+                        to_soc_camera_control(icd)->driver : NULL;
+                if (drv) {
+                        icl->del_device(icl);
+                        module_put(drv->owner);
+                }
+        }
 
         return 0;
 }
@@ -984,6 +1038,7 @@ static void dummy_release(struct device *dev)
 int soc_camera_host_register(struct soc_camera_host *ici)
 {
         struct soc_camera_host *ix;
+        int ret;
 
         if (!ici || !ici->ops ||
             !ici->ops->try_fmt ||
@@ -996,18 +1051,20 @@ int soc_camera_host_register(struct soc_camera_host *ici)
             !ici->ops->add ||
             !ici->ops->remove ||
             !ici->ops->poll ||
-            !ici->dev)
+            !ici->v4l2_dev.dev)
                 return -EINVAL;
 
         mutex_lock(&list_lock);
         list_for_each_entry(ix, &hosts, list) {
                 if (ix->nr == ici->nr) {
-                        mutex_unlock(&list_lock);
-                        return -EBUSY;
+                        ret = -EBUSY;
+                        goto edevreg;
                 }
         }
 
-        dev_set_drvdata(ici->dev, ici);
+        ret = v4l2_device_register(ici->v4l2_dev.dev, &ici->v4l2_dev);
+        if (ret < 0)
+                goto edevreg;
 
         list_add_tail(&ici->list, &hosts);
         mutex_unlock(&list_lock);
@@ -1015,6 +1072,10 @@ int soc_camera_host_register(struct soc_camera_host *ici)
         scan_add_host(ici);
 
         return 0;
+
+edevreg:
+        mutex_unlock(&list_lock);
+        return ret;
 }
 EXPORT_SYMBOL(soc_camera_host_register);
 
@@ -1028,7 +1089,7 @@ void soc_camera_host_unregister(struct soc_camera_host *ici)
         list_del(&ici->list);
 
         list_for_each_entry(icd, &devices, list) {
-                if (icd->dev.parent == ici->dev) {
+                if (icd->iface == ici->nr) {
                         /* The bus->remove will be called */
                         device_unregister(&icd->dev);
                         /* Not before device_unregister(), .remove
@@ -1043,7 +1104,7 @@ void soc_camera_host_unregister(struct soc_camera_host *ici)
 
         mutex_unlock(&list_lock);
 
-        dev_set_drvdata(ici->dev, NULL);
+        v4l2_device_unregister(&ici->v4l2_dev);
 }
 EXPORT_SYMBOL(soc_camera_host_unregister);
 
@@ -1123,7 +1184,6 @@ static int video_dev_create(struct soc_camera_device *icd)
 
         if (!vdev)
                 return -ENOMEM;
-        dev_dbg(ici->dev, "Allocated video_device %p\n", vdev);
 
         strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
 
@@ -1141,50 +1201,35 @@ static int video_dev_create(struct soc_camera_device *icd)
 }
 
 /*
- * Usually called from the struct soc_camera_ops .probe() method, i.e., from
- * soc_camera_probe() above with .video_lock held
+ * Called from soc_camera_probe() above (with .video_lock held???)
  */
-int soc_camera_video_start(struct soc_camera_device *icd, struct device *dev)
+static int soc_camera_video_start(struct soc_camera_device *icd)
 {
-        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         const struct v4l2_queryctrl *qctrl;
+        int ret;
 
         if (!icd->dev.parent)
                 return -ENODEV;
 
         if (!icd->ops ||
-            !icd->ops->init ||
-            !icd->ops->release ||
-            !icd->ops->start_capture ||
-            !icd->ops->stop_capture ||
-            !icd->ops->set_fmt ||
-            !icd->ops->try_fmt ||
             !icd->ops->query_bus_param ||
             !icd->ops->set_bus_param)
                 return -EINVAL;
 
-        /* See comment in soc_camera_probe() */
-        dev_set_drvdata(&icd->dev, dev);
+        ret = video_register_device(icd->vdev, VFL_TYPE_GRABBER,
+                                    icd->vdev->minor);
+        if (ret < 0) {
+                dev_err(&icd->dev, "video_register_device failed: %d\n", ret);
+                return ret;
+        }
 
         qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_GAIN);
         icd->gain = qctrl ? qctrl->default_value : (unsigned short)~0;
         qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
         icd->exposure = qctrl ? qctrl->default_value : (unsigned short)~0;
 
-        return ici->ops->add(icd);
-}
-EXPORT_SYMBOL(soc_camera_video_start);
-
-/* Called from client .remove() methods with .video_lock held */
-void soc_camera_video_stop(struct soc_camera_device *icd)
-{
-        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
-
-        dev_dbg(&icd->dev, "%s\n", __func__);
-
-        ici->ops->remove(icd);
+        return 0;
 }
-EXPORT_SYMBOL(soc_camera_video_stop);
 
 static int __devinit soc_camera_pdrv_probe(struct platform_device *pdev)
 {
@@ -1200,6 +1245,7 @@ static int __devinit soc_camera_pdrv_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         icd->iface = icl->bus_id;
+        icd->pdev = &pdev->dev;
         platform_set_drvdata(pdev, icd);
         icd->dev.platform_data = icl;