soc-camera: re-sync with -git tree

From: Mauro Carvalho Chehab <mchehab@infradead.org>

The proper fix were applied at -git. Re-apply the missing parts with the new
base.

Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

1 files changed, 88 insertions, 54 deletions

diff --git a/linux/drivers/media/video/soc_camera.c b/linux/drivers/media/video/soc_camera.c
index 124406683..91a1251d9 100644
--- a/linux/drivers/media/video/soc_camera.c
+++ b/linux/drivers/media/video/soc_camera.c
@@ -38,9 +38,9 @@ format_by_fourcc(struct soc_camera_device *icd, unsigned int fourcc)
 {
 	unsigned int i;
 
-	for (i = 0; i < icd->ops->num_formats; i++)
-		if (icd->ops->formats[i].fourcc == fourcc)
-			return icd->ops->formats + i;
+	for (i = 0; i < icd->num_formats; i++)
+		if (icd->formats[i].fourcc == fourcc)
+			return icd->formats + i;
 	return NULL;
 }
 
@@ -75,12 +75,13 @@ static int soc_camera_try_fmt_cap(struct file *file, void *priv,
 		return -EINVAL;
 	}
 
-	/* limit to host capabilities */
-	ret = ici->try_fmt_cap(ici, f);
+	/* test physical bus parameters */
+	ret = ici->ops->try_bus_param(icd, f->fmt.pix.pixelformat);
+	if (ret)
+		return ret;
 
-	/* limit to sensor capabilities */
-	if (!ret)
-		ret = icd->ops->try_fmt_cap(icd, f);
+	/* limit format to hardware capabilities */
+	ret = ici->ops->try_fmt_cap(icd, f);
 
 	/* calculate missing fields */
 	f->fmt.pix.field = field;
@@ -142,7 +143,7 @@ static int soc_camera_reqbufs(struct file *file, void *priv,
 	if (ret < 0)
 		return ret;
 
-	return ici->reqbufs(icf, p);
+	return ici->ops->reqbufs(icf, p);
 
 	return ret;
 }
@@ -183,6 +184,7 @@ static int soc_camera_open(struct inode *inode, struct file *file)
 	struct soc_camera_device *icd;
 	struct soc_camera_host *ici;
 	struct soc_camera_file *icf;
+	spinlock_t *lock;
 	int ret;
 
 	icf = vmalloc(sizeof(*icf));
@@ -202,19 +204,25 @@ static int soc_camera_open(struct inode *inode, struct file *file)
 		goto emgd;
 	}
 
-	if (!try_module_get(ici->owner)) {
+	if (!try_module_get(ici->ops->owner)) {
 		dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
 		ret = -EINVAL;
 		goto emgi;
 	}
 
-	icd->use_count++;
-
 	icf->icd = icd;
 
+	icf->lock = ici->ops->spinlock_alloc(icf);
+	if (!icf->lock) {
+		ret = -ENOMEM;
+		goto esla;
+	}
+
+	icd->use_count++;
+
 	/* Now we really have to activate the camera */
 	if (icd->use_count == 1) {
-		ret = ici->add(icd);
+		ret = ici->ops->add(icd);
 		if (ret < 0) {
 			dev_err(&icd->dev, "Couldn't activate the camera: %d\n", ret);
 			icd->use_count--;
@@ -228,8 +236,8 @@ static int soc_camera_open(struct inode *inode, struct file *file)
 	dev_dbg(&icd->dev, "camera device open\n");
 
 	/* We must pass NULL as dev pointer, then all pci_* dma operations
-	 * transform to normal dma_* ones. Do we need an irqlock? */
-	videobuf_queue_sg_init(&icf->vb_vidq, ici->vbq_ops, NULL, NULL,
+	 * transform to normal dma_* ones. */
+	videobuf_queue_sg_init(&icf->vb_vidq, ici->vbq_ops, NULL, icf->lock,
 				V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
 				ici->msize, icd);
 
@@ -237,7 +245,12 @@ static int soc_camera_open(struct inode *inode, struct file *file)
 
 	/* All errors are entered with the video_lock held */
 eiciadd:
-	module_put(ici->owner);
+	lock = icf->lock;
+	icf->lock = NULL;
+	if (ici->ops->spinlock_free)
+		ici->ops->spinlock_free(lock);
+esla:
+	module_put(ici->ops->owner);
 emgi:
 	module_put(icd->ops->owner);
 emgd:
@@ -252,16 +265,20 @@ static int soc_camera_close(struct inode *inode, struct file *file)
 	struct soc_camera_device *icd = icf->icd;
 	struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
 	struct video_device *vdev = icd->vdev;
+	spinlock_t *lock = icf->lock;
 
 	mutex_lock(&video_lock);
 	icd->use_count--;
 	if (!icd->use_count)
-		ici->remove(icd);
+		ici->ops->remove(icd);
+	icf->lock = NULL;
+	if (ici->ops->spinlock_free)
+		ici->ops->spinlock_free(lock);
 	module_put(icd->ops->owner);
-	module_put(ici->owner);
+	module_put(ici->ops->owner);
 	mutex_unlock(&video_lock);
 
-	vfree(file->private_data);
+	vfree(icf);
 
 	dev_dbg(vdev->dev, "camera device close\n");
 
@@ -311,7 +328,7 @@ static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
 		return POLLERR;
 	}
 
-	return ici->poll(file, pt);
+	return ici->ops->poll(file, pt);
 }
 
 
@@ -344,8 +361,8 @@ static int soc_camera_s_fmt_cap(struct file *file, void *priv,
 	if (!data_fmt)
 		return -EINVAL;
 
-	/* cached_datawidth may be further adjusted by the ici */
-	icd->cached_datawidth = data_fmt->depth;
+	/* buswidth may be further adjusted by the ici */
+	icd->buswidth = data_fmt->depth;
 
 	ret = soc_camera_try_fmt_cap(file, icf, f);
 	if (ret < 0)
@@ -355,22 +372,23 @@ static int soc_camera_s_fmt_cap(struct file *file, void *priv,
 	rect.top	= icd->y_current;
 	rect.width	= f->fmt.pix.width;
 	rect.height	= f->fmt.pix.height;
-	ret = ici->set_capture_format(icd, f->fmt.pix.pixelformat, &rect);
+	ret = ici->ops->set_fmt_cap(icd, f->fmt.pix.pixelformat, &rect);
+	if (ret < 0)
+		return ret;
 
-	if (!ret) {
-		icd->current_fmt	= data_fmt;
-		icd->width		= rect.width;
-		icd->height		= rect.height;
-		icf->vb_vidq.field	= f->fmt.pix.field;
-		if (V4L2_BUF_TYPE_VIDEO_CAPTURE != f->type)
-			dev_warn(&icd->dev, "Attention! Wrong buf-type %d\n",
-				 f->type);
-
-		dev_dbg(&icd->dev, "set width: %d height: %d\n",
-		       icd->width, icd->height);
-	}
+	icd->current_fmt	= data_fmt;
+	icd->width		= rect.width;
+	icd->height		= rect.height;
+	icf->vb_vidq.field	= f->fmt.pix.field;
+	if (V4L2_BUF_TYPE_VIDEO_CAPTURE != f->type)
+		dev_warn(&icd->dev, "Attention! Wrong buf-type %d\n",
+			 f->type);
 
-	return ret;
+	dev_dbg(&icd->dev, "set width: %d height: %d\n",
+		icd->width, icd->height);
+
+	/* set physical bus parameters */
+	return ici->ops->set_bus_param(icd, f->fmt.pix.pixelformat);
 }
 
 static int soc_camera_enum_fmt_cap(struct file *file, void  *priv,
@@ -382,10 +400,10 @@ static int soc_camera_enum_fmt_cap(struct file *file, void  *priv,
 
 	WARN_ON(priv != file->private_data);
 
-	if (f->index >= icd->ops->num_formats)
+	if (f->index >= icd->num_formats)
 		return -EINVAL;
 
-	format = &icd->ops->formats[f->index];
+	format = &icd->formats[f->index];
 
 	strlcpy(f->description, format->name, sizeof(f->description));
 	f->pixelformat = format->fourcc;
@@ -424,7 +442,7 @@ static int soc_camera_querycap(struct file *file, void  *priv,
 	WARN_ON(priv != file->private_data);
 
 	strlcpy(cap->driver, ici->drv_name, sizeof(cap->driver));
-	return ici->querycap(ici, cap);
+	return ici->ops->querycap(ici, cap);
 }
 
 static int soc_camera_streamon(struct file *file, void *priv,
@@ -577,7 +595,7 @@ static int soc_camera_s_crop(struct file *file, void *fh,
 	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 		return -EINVAL;
 
-	ret = ici->set_capture_format(icd, 0, &a->c);
+	ret = ici->ops->set_fmt_cap(icd, 0, &a->c);
 	if (!ret) {
 		icd->width	= a->c.width;
 		icd->height	= a->c.height;
@@ -699,16 +717,16 @@ static int soc_camera_probe(struct device *dev)
 		to_soc_camera_host(icd->dev.parent);
 	int ret;
 
-	if (!icd->probe)
+	if (!icd->ops->probe)
 		return -ENODEV;
 
 	/* We only call ->add() here to activate and probe the camera.
 	 * We shall ->remove() and deactivate it immediately afterwards. */
-	ret = ici->add(icd);
+	ret = ici->ops->add(icd);
 	if (ret < 0)
 		return ret;
 
-	ret = icd->probe(icd);
+	ret = icd->ops->probe(icd);
 	if (ret >= 0) {
 		const struct v4l2_queryctrl *qctrl;
 
@@ -718,7 +736,7 @@ static int soc_camera_probe(struct device *dev)
 		icd->exposure = qctrl ? qctrl->default_value :
 			(unsigned short)~0;
 	}
-	ici->remove(icd);
+	ici->ops->remove(icd);
 
 	return ret;
 }
@@ -729,8 +747,8 @@ static int soc_camera_remove(struct device *dev)
 {
 	struct soc_camera_device *icd = to_soc_camera_dev(dev);
 
-	if (icd->remove)
-		icd->remove(icd);
+	if (icd->ops->remove)
+		icd->ops->remove(icd);
 
 	return 0;
 }
@@ -760,12 +778,27 @@ static void dummy_release(struct device *dev)
 {
 }
 
-int soc_camera_host_register(struct soc_camera_host *ici, struct module *owner)
+static spinlock_t *spinlock_alloc(struct soc_camera_file *icf)
+{
+	spinlock_t *lock = kmalloc(sizeof(spinlock_t), GFP_KERNEL);
+
+	if (lock)
+		spin_lock_init(lock);
+
+	return lock;
+}
+
+static void spinlock_free(spinlock_t *lock)
+{
+	kfree(lock);
+}
+
+int soc_camera_host_register(struct soc_camera_host *ici)
 {
 	int ret;
 	struct soc_camera_host *ix;
 
-	if (!ici->vbq_ops || !ici->add || !ici->remove || !owner)
+	if (!ici->vbq_ops || !ici->ops->add || !ici->ops->remove)
 		return -EINVAL;
 
 	/* Number might be equal to the platform device ID */
@@ -783,7 +816,6 @@ int soc_camera_host_register(struct soc_camera_host *ici, struct module *owner)
 	list_add_tail(&ici->list, &hosts);
 	mutex_unlock(&list_lock);
 
-	ici->owner = owner;
 	ici->dev.release = dummy_release;
 
 	ret = device_register(&ici->dev);
@@ -791,6 +823,11 @@ int soc_camera_host_register(struct soc_camera_host *ici, struct module *owner)
 	if (ret)
 		goto edevr;
 
+	if (!ici->ops->spinlock_alloc) {
+		ici->ops->spinlock_alloc = spinlock_alloc;
+		ici->ops->spinlock_free = spinlock_free;
+	}
+
 	scan_add_host(ici);
 
 	return 0;
@@ -817,7 +854,7 @@ void soc_camera_host_unregister(struct soc_camera_host *ici)
 		if (icd->dev.parent == &ici->dev) {
 			device_unregister(&icd->dev);
 			/* Not before device_unregister(), .remove
-			 * needs parent to call ici->remove() */
+			 * needs parent to call ici->ops->remove() */
 			icd->dev.parent = NULL;
 			memset(&icd->dev.kobj, 0, sizeof(icd->dev.kobj));
 		}
@@ -860,9 +897,6 @@ int soc_camera_device_register(struct soc_camera_device *icd)
 
 	icd->dev.release = dummy_release;
 
-	if (icd->ops->get_datawidth)
-		icd->cached_datawidth = icd->ops->get_datawidth(icd);
-
 	return scan_add_device(icd);
 }
 EXPORT_SYMBOL(soc_camera_device_register);
@@ -929,7 +963,7 @@ int soc_camera_video_start(struct soc_camera_device *icd)
 	vdev->vidioc_s_register	= soc_camera_s_register;
 #endif
 
-	icd->current_fmt = &icd->ops->formats[0];
+	icd->current_fmt = &icd->formats[0];
 
 	err = video_register_device(vdev, VFL_TYPE_GRABBER, vdev->minor);
 	if (err < 0) {