1 files changed, 128 insertions, 28 deletions

diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
index a66811b43710..46284489e4eb 100644
--- a/drivers/media/video/soc_camera.c
+++ b/drivers/media/video/soc_camera.c
@@ -34,6 +34,7 @@
 #include <media/v4l2-ioctl.h>
 #include <media/v4l2-dev.h>
 #include <media/videobuf-core.h>
+#include <media/videobuf2-core.h>
 #include <media/soc_mediabus.h>
 
 /* Default to VGA resolution */
@@ -143,6 +144,10 @@ static int soc_camera_try_fmt_vid_cap(struct file *file, void *priv,
 
         WARN_ON(priv != file->private_data);
 
+        /* Only single-plane capture is supported so far */
+        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
         /* limit format to hardware capabilities */
         return ici->ops->try_fmt(icd, f);
 }
@@ -191,6 +196,15 @@ static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id *a)
         return v4l2_subdev_call(sd, core, s_std, *a);
 }
 
+static int soc_camera_enum_fsizes(struct file *file, void *fh,
+                                         struct v4l2_frmsizeenum *fsize)
+{
+        struct soc_camera_device *icd = file->private_data;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+
+        return ici->ops->enum_fsizes(icd, fsize);
+}
+
 static int soc_camera_reqbufs(struct file *file, void *priv,
                               struct v4l2_requestbuffers *p)
 {
@@ -203,11 +217,16 @@ static int soc_camera_reqbufs(struct file *file, void *priv,
         if (icd->streamer && icd->streamer != file)
                 return -EBUSY;
 
-        ret = videobuf_reqbufs(&icd->vb_vidq, p);
-        if (ret < 0)
-                return ret;
+        if (ici->ops->init_videobuf) {
+                ret = videobuf_reqbufs(&icd->vb_vidq, p);
+                if (ret < 0)
+                        return ret;
+
+                ret = ici->ops->reqbufs(icd, p);
+        } else {
+                ret = vb2_reqbufs(&icd->vb2_vidq, p);
+        }
 
-        ret = ici->ops->reqbufs(icd, p);
         if (!ret && !icd->streamer)
                 icd->streamer = file;
 
@@ -218,36 +237,48 @@ static int soc_camera_querybuf(struct file *file, void *priv,
                                struct v4l2_buffer *p)
 {
         struct soc_camera_device *icd = file->private_data;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
         WARN_ON(priv != file->private_data);
 
-        return videobuf_querybuf(&icd->vb_vidq, p);
+        if (ici->ops->init_videobuf)
+                return videobuf_querybuf(&icd->vb_vidq, p);
+        else
+                return vb2_querybuf(&icd->vb2_vidq, p);
 }
 
 static int soc_camera_qbuf(struct file *file, void *priv,
                            struct v4l2_buffer *p)
 {
         struct soc_camera_device *icd = file->private_data;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
         WARN_ON(priv != file->private_data);
 
         if (icd->streamer != file)
                 return -EBUSY;
 
-        return videobuf_qbuf(&icd->vb_vidq, p);
+        if (ici->ops->init_videobuf)
+                return videobuf_qbuf(&icd->vb_vidq, p);
+        else
+                return vb2_qbuf(&icd->vb2_vidq, p);
 }
 
 static int soc_camera_dqbuf(struct file *file, void *priv,
                             struct v4l2_buffer *p)
 {
         struct soc_camera_device *icd = file->private_data;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
         WARN_ON(priv != file->private_data);
 
         if (icd->streamer != file)
                 return -EBUSY;
 
-        return videobuf_dqbuf(&icd->vb_vidq, p, file->f_flags & O_NONBLOCK);
+        if (ici->ops->init_videobuf)
+                return videobuf_dqbuf(&icd->vb_vidq, p, file->f_flags & O_NONBLOCK);
+        else
+                return vb2_dqbuf(&icd->vb2_vidq, p, file->f_flags & O_NONBLOCK);
 }
 
 /* Always entered with .video_lock held */
@@ -362,13 +393,12 @@ static int soc_camera_set_fmt(struct soc_camera_device *icd,
 
         icd->user_width         = pix->width;
         icd->user_height        = pix->height;
+        icd->bytesperline       = pix->bytesperline;
+        icd->sizeimage          = pix->sizeimage;
         icd->colorspace         = pix->colorspace;
-        icd->vb_vidq.field      =
-                icd->field      = pix->field;
-
-        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                dev_warn(&icd->dev, "Attention! Wrong buf-type %d\n",
-                         f->type);
+        icd->field              = pix->field;
+        if (ici->ops->init_videobuf)
+                icd->vb_vidq.field = pix->field;
 
         dev_dbg(&icd->dev, "set width: %d height: %d\n",
                 icd->user_width, icd->user_height);
@@ -444,7 +474,13 @@ static int soc_camera_open(struct file *file)
                 if (ret < 0)
                         goto esfmt;
 
-                ici->ops->init_videobuf(&icd->vb_vidq, icd);
+                if (ici->ops->init_videobuf) {
+                        ici->ops->init_videobuf(&icd->vb_vidq, icd);
+                } else {
+                        ret = ici->ops->init_videobuf2(&icd->vb2_vidq, icd);
+                        if (ret < 0)
+                                goto einitvb;
+                }
         }
 
         file->private_data = icd;
@@ -456,6 +492,7 @@ static int soc_camera_open(struct file *file)
          * First four errors are entered with the .video_lock held
          * and use_count == 1
          */
+einitvb:
 esfmt:
         pm_runtime_disable(&icd->vdev->dev);
 eresume:
@@ -482,6 +519,8 @@ static int soc_camera_close(struct file *file)
                 pm_runtime_disable(&icd->vdev->dev);
 
                 ici->ops->remove(icd);
+                if (ici->ops->init_videobuf2)
+                        vb2_queue_release(&icd->vb2_vidq);
 
                 soc_camera_power_set(icd, icl, 0);
         }
@@ -510,6 +549,7 @@ static ssize_t soc_camera_read(struct file *file, char __user *buf,
 static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
 {
         struct soc_camera_device *icd = file->private_data;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         int err;
 
         dev_dbg(&icd->dev, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
@@ -517,7 +557,10 @@ static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
         if (icd->streamer != file)
                 return -EBUSY;
 
-        err = videobuf_mmap_mapper(&icd->vb_vidq, vma);
+        if (ici->ops->init_videobuf)
+                err = videobuf_mmap_mapper(&icd->vb_vidq, vma);
+        else
+                err = vb2_mmap(&icd->vb2_vidq, vma);
 
         dev_dbg(&icd->dev, "vma start=0x%08lx, size=%ld, ret=%d\n",
                 (unsigned long)vma->vm_start,
@@ -535,7 +578,7 @@ static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
         if (icd->streamer != file)
                 return -EBUSY;
 
-        if (list_empty(&icd->vb_vidq.stream)) {
+        if (ici->ops->init_videobuf && list_empty(&icd->vb_vidq.stream)) {
                 dev_err(&icd->dev, "Trying to poll with no queued buffers!\n");
                 return POLLERR;
         }
@@ -543,6 +586,20 @@ static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
         return ici->ops->poll(file, pt);
 }
 
+void soc_camera_lock(struct vb2_queue *vq)
+{
+        struct soc_camera_device *icd = vb2_get_drv_priv(vq);
+        mutex_lock(&icd->video_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);
+}
+EXPORT_SYMBOL(soc_camera_unlock);
+
 static struct v4l2_file_operations soc_camera_fops = {
         .owner          = THIS_MODULE,
         .open           = soc_camera_open,
@@ -561,6 +618,11 @@ static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
 
         WARN_ON(priv != file->private_data);
 
+        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                dev_warn(&icd->dev, "Wrong buf-type %d\n", f->type);
+                return -EINVAL;
+        }
+
         if (icd->streamer && icd->streamer != file)
                 return -EBUSY;
 
@@ -604,16 +666,16 @@ static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv,
 
         WARN_ON(priv != file->private_data);
 
+        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
         pix->width              = icd->user_width;
         pix->height             = icd->user_height;
-        pix->field              = icd->vb_vidq.field;
+        pix->bytesperline       = icd->bytesperline;
+        pix->sizeimage          = icd->sizeimage;
+        pix->field              = icd->field;
         pix->pixelformat        = icd->current_fmt->host_fmt->fourcc;
-        pix->bytesperline       = soc_mbus_bytes_per_line(pix->width,
-                                                icd->current_fmt->host_fmt);
         pix->colorspace         = icd->colorspace;
-        if (pix->bytesperline < 0)
-                return pix->bytesperline;
-        pix->sizeimage          = pix->height * pix->bytesperline;
         dev_dbg(&icd->dev, "current_fmt->fourcc: 0x%08x\n",
                 icd->current_fmt->host_fmt->fourcc);
         return 0;
@@ -635,6 +697,7 @@ static int soc_camera_streamon(struct file *file, void *priv,
                                enum v4l2_buf_type i)
 {
         struct soc_camera_device *icd = file->private_data;
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         int ret;
 
@@ -646,10 +709,14 @@ static int soc_camera_streamon(struct file *file, void *priv,
         if (icd->streamer != file)
                 return -EBUSY;
 
-        v4l2_subdev_call(sd, video, s_stream, 1);
-
         /* This calls buf_queue from host driver's videobuf_queue_ops */
-        ret = videobuf_streamon(&icd->vb_vidq);
+        if (ici->ops->init_videobuf)
+                ret = videobuf_streamon(&icd->vb_vidq);
+        else
+                ret = vb2_streamon(&icd->vb2_vidq, i);
+
+        if (!ret)
+                v4l2_subdev_call(sd, video, s_stream, 1);
 
         return ret;
 }
@@ -659,6 +726,7 @@ static int soc_camera_streamoff(struct file *file, void *priv,
 {
         struct soc_camera_device *icd = file->private_data;
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 
         WARN_ON(priv != file->private_data);
 
@@ -672,7 +740,10 @@ static int soc_camera_streamoff(struct file *file, void *priv,
          * This calls buf_release from host driver's videobuf_queue_ops for all
          * remaining buffers. When the last buffer is freed, stop capture
          */
-        videobuf_streamoff(&icd->vb_vidq);
+        if (ici->ops->init_videobuf)
+                videobuf_streamoff(&icd->vb_vidq);
+        else
+                vb2_streamoff(&icd->vb2_vidq, i);
 
         v4l2_subdev_call(sd, video, s_stream, 0);
 
@@ -1175,6 +1246,31 @@ static int default_s_parm(struct soc_camera_device *icd,
         return v4l2_subdev_call(sd, video, s_parm, parm);
 }
 
+static int default_enum_fsizes(struct soc_camera_device *icd,
+                          struct v4l2_frmsizeenum *fsize)
+{
+        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;
+
+        xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
+        if (!xlate)
+                return -EINVAL;
+        /* map xlate-code to pixel_format, sensor only handle xlate-code*/
+        fsize_mbus.pixel_format = xlate->code;
+
+        ret = v4l2_subdev_call(sd, video, enum_mbus_fsizes, &fsize_mbus);
+        if (ret < 0)
+                return ret;
+
+        *fsize = fsize_mbus;
+        fsize->pixel_format = pixfmt;
+
+        return 0;
+}
+
 static void soc_camera_device_init(struct device *dev, void *pdata)
 {
         dev->platform_data      = pdata;
@@ -1192,8 +1288,9 @@ int soc_camera_host_register(struct soc_camera_host *ici)
             !ici->ops->set_fmt ||
             !ici->ops->set_bus_param ||
             !ici->ops->querycap ||
-            !ici->ops->init_videobuf ||
-            !ici->ops->reqbufs ||
+            ((!ici->ops->init_videobuf ||
+              !ici->ops->reqbufs) &&
+             !ici->ops->init_videobuf2) ||
             !ici->ops->add ||
             !ici->ops->remove ||
             !ici->ops->poll ||
@@ -1210,6 +1307,8 @@ int soc_camera_host_register(struct soc_camera_host *ici)
                 ici->ops->set_parm = default_s_parm;
         if (!ici->ops->get_parm)
                 ici->ops->get_parm = default_g_parm;
+        if (!ici->ops->enum_fsizes)
+                ici->ops->enum_fsizes = default_enum_fsizes;
 
         mutex_lock(&list_lock);
         list_for_each_entry(ix, &hosts, list) {
@@ -1317,6 +1416,7 @@ static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
         .vidioc_g_input          = soc_camera_g_input,
         .vidioc_s_input          = soc_camera_s_input,
         .vidioc_s_std            = soc_camera_s_std,
+        .vidioc_enum_framesizes  = soc_camera_enum_fsizes,
         .vidioc_reqbufs          = soc_camera_reqbufs,
         .vidioc_try_fmt_vid_cap  = soc_camera_try_fmt_vid_cap,
         .vidioc_querybuf         = soc_camera_querybuf,