1. Patchew
  2. linux
  3. [PATCH v2 00/10] media: Introduce video device state management
  4. View patch

[PATCH v2 05/10] media: v4l2-ioctl: Add video_device_state argument to v4l2 ioctl wrappers

Jai Luthra posted 10 patches 1 week, 5 days ago
[PATCH v2 05/10] media: v4l2-ioctl: Add video_device_state argument to v4l2 ioctl wrappers
Posted by Jai Luthra 1 week, 5 days ago 
Add a third argument to all v4l2 ioctl wrappers to pass struct
video_device_state * directly, replacing the previous opaque pointer
approach.

Currently, this argument is populated with NULL since existing driver
hooks still expect a void *priv argument. This will be addressed in a
subsequent patch.

Most changes to the ioctl wrappers were generated using the following
Coccinelle semantic patch:

@ioctl@
identifier v4l2_ioctls;
identifier ioctl;
identifier fn;
identifier debug;
expression flags;
@@
struct v4l2_ioctl_info v4l2_ioctls[] = {
	...,
	IOCTL_INFO(ioctl, fn, debug, flags),
	...,
};

@depends on ioctl@
identifier ioctl.fn;
identifier ops;
identifier file;
identifier arg;
identifier handler;
expression list args;
@@
-int fn(const struct v4l2_ioctl_ops *ops, struct file *file, void *arg)
+int fn(const struct v4l2_ioctl_ops *ops, struct file *file,
+       struct video_device_state *state, void *arg)
{
	<...
-	ops->handler(file, NULL, args)
+	ops->handler(file, state, args)
	...>
}

Manual changes were made to handle calls to v4l_[gs]_selection, update
the v4l2_ioctl_info structure definition and macros, fix argument
wrapping in some function definitions, and handle the common function
pointer in v4l2_ioctl_info.

Signed-off-by: Jai Luthra <jai.luthra@ideasonboard.com>
--
Cc: Mauro Carvalho Chehab <mchehab@kernel.org>
Cc: Hans Verkuil <hverkuil@kernel.org>
Cc: Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com>
Cc: Ricardo Ribalda <ribalda@chromium.org>
Cc: Hans de Goede <hansg@kernel.org>
Cc: Jai Luthra <jai.luthra@ideasonboard.com>
Cc: linux-media@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
---
 drivers/media/v4l2-core/v4l2-ioctl.c | 360 ++++++++++++++++++-----------------
 1 file changed, 186 insertions(+), 174 deletions(-)

diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
index 01cf52c3ea33e1a01e1b306036ba4e57ef5c95d0..644f06521673ff7ce5b194335d50f0e375ca7f51 100644
--- a/drivers/media/v4l2-core/v4l2-ioctl.c
+++ b/drivers/media/v4l2-core/v4l2-ioctl.c
@@ -1090,7 +1090,7 @@ static void v4l_sanitize_format(struct v4l2_format *fmt)
 }
 
 static int v4l_querycap(const struct v4l2_ioctl_ops *ops, struct file *file,
-			void *arg)
+			struct video_device_state *state, void *arg)
 {
 	struct v4l2_capability *cap = (struct v4l2_capability *)arg;
 	struct video_device *vfd = video_devdata(file);
@@ -1103,7 +1103,7 @@ static int v4l_querycap(const struct v4l2_ioctl_ops *ops, struct file *file,
 	media_set_bus_info(cap->bus_info, sizeof(cap->bus_info),
 			   vfd->dev_parent);
 
-	ret = ops->vidioc_querycap(file, NULL, cap);
+	ret = ops->vidioc_querycap(file, state, cap);
 
 	/*
 	 * Drivers must not change device_caps, so check for this and
@@ -1124,7 +1124,7 @@ static int v4l_querycap(const struct v4l2_ioctl_ops *ops, struct file *file,
 }
 
 static int v4l_g_input(const struct v4l2_ioctl_ops *ops, struct file *file,
-		       void *arg)
+		       struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 
@@ -1133,11 +1133,11 @@ static int v4l_g_input(const struct v4l2_ioctl_ops *ops, struct file *file,
 		return 0;
 	}
 
-	return ops->vidioc_g_input(file, NULL, arg);
+	return ops->vidioc_g_input(file, state, arg);
 }
 
 static int v4l_g_output(const struct v4l2_ioctl_ops *ops, struct file *file,
-			void *arg)
+			struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 
@@ -1146,11 +1146,11 @@ static int v4l_g_output(const struct v4l2_ioctl_ops *ops, struct file *file,
 		return 0;
 	}
 
-	return ops->vidioc_g_output(file, NULL, arg);
+	return ops->vidioc_g_output(file, state, arg);
 }
 
 static int v4l_s_input(const struct v4l2_ioctl_ops *ops, struct file *file,
-		       void *arg)
+		       struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	int ret;
@@ -1162,22 +1162,22 @@ static int v4l_s_input(const struct v4l2_ioctl_ops *ops, struct file *file,
 	if (vfd->device_caps & V4L2_CAP_IO_MC)
 		return  *(int *)arg ? -EINVAL : 0;
 
-	return ops->vidioc_s_input(file, NULL, *(unsigned int *)arg);
+	return ops->vidioc_s_input(file, state, *(unsigned int *)arg);
 }
 
 static int v4l_s_output(const struct v4l2_ioctl_ops *ops, struct file *file,
-			void *arg)
+			struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 
 	if (vfd->device_caps & V4L2_CAP_IO_MC)
 		return  *(int *)arg ? -EINVAL : 0;
 
-	return ops->vidioc_s_output(file, NULL, *(unsigned int *)arg);
+	return ops->vidioc_s_output(file, state, *(unsigned int *)arg);
 }
 
 static int v4l_g_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
-			  void *arg)
+			  struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd;
 	u32 *p = arg;
@@ -1188,7 +1188,7 @@ static int v4l_g_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
 }
 
 static int v4l_s_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
-			  void *arg)
+			  struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd;
 	struct v4l2_fh *vfh;
@@ -1200,7 +1200,7 @@ static int v4l_s_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
 }
 
 static int v4l_enuminput(const struct v4l2_ioctl_ops *ops, struct file *file,
-			 void *arg)
+			 struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_input *p = arg;
@@ -1222,11 +1222,11 @@ static int v4l_enuminput(const struct v4l2_ioctl_ops *ops, struct file *file,
 		return 0;
 	}
 
-	return ops->vidioc_enum_input(file, NULL, p);
+	return ops->vidioc_enum_input(file, state, p);
 }
 
 static int v4l_enumoutput(const struct v4l2_ioctl_ops *ops, struct file *file,
-			  void *arg)
+			  struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_output *p = arg;
@@ -1248,7 +1248,7 @@ static int v4l_enumoutput(const struct v4l2_ioctl_ops *ops, struct file *file,
 		return 0;
 	}
 
-	return ops->vidioc_enum_output(file, NULL, p);
+	return ops->vidioc_enum_output(file, state, p);
 }
 
 static void v4l_fill_fmtdesc(struct v4l2_fmtdesc *fmt)
@@ -1588,7 +1588,7 @@ static void v4l_fill_fmtdesc(struct v4l2_fmtdesc *fmt)
 }
 
 static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
-			void *arg)
+			struct video_device_state *state, void *arg)
 {
 	struct video_device *vdev = video_devdata(file);
 	struct v4l2_fmtdesc *p = arg;
@@ -1618,12 +1618,12 @@ static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 
 		if (unlikely(!ops->vidioc_enum_fmt_vid_cap))
 			break;
-		ret = ops->vidioc_enum_fmt_vid_cap(file, NULL, arg);
+		ret = ops->vidioc_enum_fmt_vid_cap(file, state, arg);
 		break;
 	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 		if (unlikely(!ops->vidioc_enum_fmt_vid_overlay))
 			break;
-		ret = ops->vidioc_enum_fmt_vid_overlay(file, NULL, arg);
+		ret = ops->vidioc_enum_fmt_vid_overlay(file, state, arg);
 		break;
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
@@ -1635,27 +1635,27 @@ static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 
 		if (unlikely(!ops->vidioc_enum_fmt_vid_out))
 			break;
-		ret = ops->vidioc_enum_fmt_vid_out(file, NULL, arg);
+		ret = ops->vidioc_enum_fmt_vid_out(file, state, arg);
 		break;
 	case V4L2_BUF_TYPE_SDR_CAPTURE:
 		if (unlikely(!ops->vidioc_enum_fmt_sdr_cap))
 			break;
-		ret = ops->vidioc_enum_fmt_sdr_cap(file, NULL, arg);
+		ret = ops->vidioc_enum_fmt_sdr_cap(file, state, arg);
 		break;
 	case V4L2_BUF_TYPE_SDR_OUTPUT:
 		if (unlikely(!ops->vidioc_enum_fmt_sdr_out))
 			break;
-		ret = ops->vidioc_enum_fmt_sdr_out(file, NULL, arg);
+		ret = ops->vidioc_enum_fmt_sdr_out(file, state, arg);
 		break;
 	case V4L2_BUF_TYPE_META_CAPTURE:
 		if (unlikely(!ops->vidioc_enum_fmt_meta_cap))
 			break;
-		ret = ops->vidioc_enum_fmt_meta_cap(file, NULL, arg);
+		ret = ops->vidioc_enum_fmt_meta_cap(file, state, arg);
 		break;
 	case V4L2_BUF_TYPE_META_OUTPUT:
 		if (unlikely(!ops->vidioc_enum_fmt_meta_out))
 			break;
-		ret = ops->vidioc_enum_fmt_meta_out(file, NULL, arg);
+		ret = ops->vidioc_enum_fmt_meta_out(file, state, arg);
 		break;
 	}
 	if (ret == 0)
@@ -1679,7 +1679,7 @@ static void v4l_pix_format_touch(struct v4l2_pix_format *p)
 }
 
 static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
-		     void *arg)
+		     struct video_device_state *state, void *arg)
 {
 	struct v4l2_format *p = arg;
 	struct video_device *vfd = video_devdata(file);
@@ -1695,50 +1695,50 @@ static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		if (unlikely(!ops->vidioc_g_fmt_vid_cap))
 			break;
 		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
-		ret = ops->vidioc_g_fmt_vid_cap(file, NULL, arg);
+		ret = ops->vidioc_g_fmt_vid_cap(file, state, arg);
 		/* just in case the driver zeroed it again */
 		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
 		if (vfd->vfl_type == VFL_TYPE_TOUCH)
 			v4l_pix_format_touch(&p->fmt.pix);
 		return ret;
 	case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
-		return ops->vidioc_g_fmt_vid_cap_mplane(file, NULL, arg);
+		return ops->vidioc_g_fmt_vid_cap_mplane(file, state, arg);
 	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
-		return ops->vidioc_g_fmt_vid_overlay(file, NULL, arg);
+		return ops->vidioc_g_fmt_vid_overlay(file, state, arg);
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
-		return ops->vidioc_g_fmt_vbi_cap(file, NULL, arg);
+		return ops->vidioc_g_fmt_vbi_cap(file, state, arg);
 	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
-		return ops->vidioc_g_fmt_sliced_vbi_cap(file, NULL, arg);
+		return ops->vidioc_g_fmt_sliced_vbi_cap(file, state, arg);
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 		if (unlikely(!ops->vidioc_g_fmt_vid_out))
 			break;
 		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
-		ret = ops->vidioc_g_fmt_vid_out(file, NULL, arg);
+		ret = ops->vidioc_g_fmt_vid_out(file, state, arg);
 		/* just in case the driver zeroed it again */
 		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
 		return ret;
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
-		return ops->vidioc_g_fmt_vid_out_mplane(file, NULL, arg);
+		return ops->vidioc_g_fmt_vid_out_mplane(file, state, arg);
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
-		return ops->vidioc_g_fmt_vid_out_overlay(file, NULL, arg);
+		return ops->vidioc_g_fmt_vid_out_overlay(file, state, arg);
 	case V4L2_BUF_TYPE_VBI_OUTPUT:
-		return ops->vidioc_g_fmt_vbi_out(file, NULL, arg);
+		return ops->vidioc_g_fmt_vbi_out(file, state, arg);
 	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
-		return ops->vidioc_g_fmt_sliced_vbi_out(file, NULL, arg);
+		return ops->vidioc_g_fmt_sliced_vbi_out(file, state, arg);
 	case V4L2_BUF_TYPE_SDR_CAPTURE:
-		return ops->vidioc_g_fmt_sdr_cap(file, NULL, arg);
+		return ops->vidioc_g_fmt_sdr_cap(file, state, arg);
 	case V4L2_BUF_TYPE_SDR_OUTPUT:
-		return ops->vidioc_g_fmt_sdr_out(file, NULL, arg);
+		return ops->vidioc_g_fmt_sdr_out(file, state, arg);
 	case V4L2_BUF_TYPE_META_CAPTURE:
-		return ops->vidioc_g_fmt_meta_cap(file, NULL, arg);
+		return ops->vidioc_g_fmt_meta_cap(file, state, arg);
 	case V4L2_BUF_TYPE_META_OUTPUT:
-		return ops->vidioc_g_fmt_meta_out(file, NULL, arg);
+		return ops->vidioc_g_fmt_meta_out(file, state, arg);
 	}
 	return -EINVAL;
 }
 
 static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
-		     void *arg)
+		     struct video_device_state *state, void *arg)
 {
 	struct v4l2_format *p = arg;
 	struct video_device *vfd = video_devdata(file);
@@ -1758,7 +1758,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		if (unlikely(!ops->vidioc_s_fmt_vid_cap))
 			break;
 		memset_after(p, 0, fmt.pix);
-		ret = ops->vidioc_s_fmt_vid_cap(file, NULL, arg);
+		ret = ops->vidioc_s_fmt_vid_cap(file, state, arg);
 		/* just in case the driver zeroed it again */
 		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
 		if (vfd->vfl_type == VFL_TYPE_TOUCH)
@@ -1771,7 +1771,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
 			memset_after(&p->fmt.pix_mp.plane_fmt[i],
 				     0, bytesperline);
-		return ops->vidioc_s_fmt_vid_cap_mplane(file, NULL, arg);
+		return ops->vidioc_s_fmt_vid_cap_mplane(file, state, arg);
 	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 		if (unlikely(!ops->vidioc_s_fmt_vid_overlay))
 			break;
@@ -1779,22 +1779,22 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		p->fmt.win.clips = NULL;
 		p->fmt.win.clipcount = 0;
 		p->fmt.win.bitmap = NULL;
-		return ops->vidioc_s_fmt_vid_overlay(file, NULL, arg);
+		return ops->vidioc_s_fmt_vid_overlay(file, state, arg);
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		if (unlikely(!ops->vidioc_s_fmt_vbi_cap))
 			break;
 		memset_after(p, 0, fmt.vbi.flags);
-		return ops->vidioc_s_fmt_vbi_cap(file, NULL, arg);
+		return ops->vidioc_s_fmt_vbi_cap(file, state, arg);
 	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 		if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_cap))
 			break;
 		memset_after(p, 0, fmt.sliced.io_size);
-		return ops->vidioc_s_fmt_sliced_vbi_cap(file, NULL, arg);
+		return ops->vidioc_s_fmt_sliced_vbi_cap(file, state, arg);
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 		if (unlikely(!ops->vidioc_s_fmt_vid_out))
 			break;
 		memset_after(p, 0, fmt.pix);
-		ret = ops->vidioc_s_fmt_vid_out(file, NULL, arg);
+		ret = ops->vidioc_s_fmt_vid_out(file, state, arg);
 		/* just in case the driver zeroed it again */
 		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
 		return ret;
@@ -1805,7 +1805,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
 			memset_after(&p->fmt.pix_mp.plane_fmt[i],
 				     0, bytesperline);
-		return ops->vidioc_s_fmt_vid_out_mplane(file, NULL, arg);
+		return ops->vidioc_s_fmt_vid_out_mplane(file, state, arg);
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 		if (unlikely(!ops->vidioc_s_fmt_vid_out_overlay))
 			break;
@@ -1813,43 +1813,43 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		p->fmt.win.clips = NULL;
 		p->fmt.win.clipcount = 0;
 		p->fmt.win.bitmap = NULL;
-		return ops->vidioc_s_fmt_vid_out_overlay(file, NULL, arg);
+		return ops->vidioc_s_fmt_vid_out_overlay(file, state, arg);
 	case V4L2_BUF_TYPE_VBI_OUTPUT:
 		if (unlikely(!ops->vidioc_s_fmt_vbi_out))
 			break;
 		memset_after(p, 0, fmt.vbi.flags);
-		return ops->vidioc_s_fmt_vbi_out(file, NULL, arg);
+		return ops->vidioc_s_fmt_vbi_out(file, state, arg);
 	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 		if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_out))
 			break;
 		memset_after(p, 0, fmt.sliced.io_size);
-		return ops->vidioc_s_fmt_sliced_vbi_out(file, NULL, arg);
+		return ops->vidioc_s_fmt_sliced_vbi_out(file, state, arg);
 	case V4L2_BUF_TYPE_SDR_CAPTURE:
 		if (unlikely(!ops->vidioc_s_fmt_sdr_cap))
 			break;
 		memset_after(p, 0, fmt.sdr.buffersize);
-		return ops->vidioc_s_fmt_sdr_cap(file, NULL, arg);
+		return ops->vidioc_s_fmt_sdr_cap(file, state, arg);
 	case V4L2_BUF_TYPE_SDR_OUTPUT:
 		if (unlikely(!ops->vidioc_s_fmt_sdr_out))
 			break;
 		memset_after(p, 0, fmt.sdr.buffersize);
-		return ops->vidioc_s_fmt_sdr_out(file, NULL, arg);
+		return ops->vidioc_s_fmt_sdr_out(file, state, arg);
 	case V4L2_BUF_TYPE_META_CAPTURE:
 		if (unlikely(!ops->vidioc_s_fmt_meta_cap))
 			break;
 		memset_after(p, 0, fmt.meta);
-		return ops->vidioc_s_fmt_meta_cap(file, NULL, arg);
+		return ops->vidioc_s_fmt_meta_cap(file, state, arg);
 	case V4L2_BUF_TYPE_META_OUTPUT:
 		if (unlikely(!ops->vidioc_s_fmt_meta_out))
 			break;
 		memset_after(p, 0, fmt.meta);
-		return ops->vidioc_s_fmt_meta_out(file, NULL, arg);
+		return ops->vidioc_s_fmt_meta_out(file, state, arg);
 	}
 	return -EINVAL;
 }
 
 static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
-		       void *arg)
+		       struct video_device_state *state, void *arg)
 {
 	struct v4l2_format *p = arg;
 	struct video_device *vfd = video_devdata(file);
@@ -1866,7 +1866,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		if (unlikely(!ops->vidioc_try_fmt_vid_cap))
 			break;
 		memset_after(p, 0, fmt.pix);
-		ret = ops->vidioc_try_fmt_vid_cap(file, NULL, arg);
+		ret = ops->vidioc_try_fmt_vid_cap(file, state, arg);
 		/* just in case the driver zeroed it again */
 		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
 		if (vfd->vfl_type == VFL_TYPE_TOUCH)
@@ -1879,7 +1879,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
 			memset_after(&p->fmt.pix_mp.plane_fmt[i],
 				     0, bytesperline);
-		return ops->vidioc_try_fmt_vid_cap_mplane(file, NULL, arg);
+		return ops->vidioc_try_fmt_vid_cap_mplane(file, state, arg);
 	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 		if (unlikely(!ops->vidioc_try_fmt_vid_overlay))
 			break;
@@ -1887,22 +1887,22 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		p->fmt.win.clips = NULL;
 		p->fmt.win.clipcount = 0;
 		p->fmt.win.bitmap = NULL;
-		return ops->vidioc_try_fmt_vid_overlay(file, NULL, arg);
+		return ops->vidioc_try_fmt_vid_overlay(file, state, arg);
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		if (unlikely(!ops->vidioc_try_fmt_vbi_cap))
 			break;
 		memset_after(p, 0, fmt.vbi.flags);
-		return ops->vidioc_try_fmt_vbi_cap(file, NULL, arg);
+		return ops->vidioc_try_fmt_vbi_cap(file, state, arg);
 	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 		if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_cap))
 			break;
 		memset_after(p, 0, fmt.sliced.io_size);
-		return ops->vidioc_try_fmt_sliced_vbi_cap(file, NULL, arg);
+		return ops->vidioc_try_fmt_sliced_vbi_cap(file, state, arg);
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 		if (unlikely(!ops->vidioc_try_fmt_vid_out))
 			break;
 		memset_after(p, 0, fmt.pix);
-		ret = ops->vidioc_try_fmt_vid_out(file, NULL, arg);
+		ret = ops->vidioc_try_fmt_vid_out(file, state, arg);
 		/* just in case the driver zeroed it again */
 		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
 		return ret;
@@ -1913,7 +1913,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
 			memset_after(&p->fmt.pix_mp.plane_fmt[i],
 				     0, bytesperline);
-		return ops->vidioc_try_fmt_vid_out_mplane(file, NULL, arg);
+		return ops->vidioc_try_fmt_vid_out_mplane(file, state, arg);
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 		if (unlikely(!ops->vidioc_try_fmt_vid_out_overlay))
 			break;
@@ -1921,55 +1921,55 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
 		p->fmt.win.clips = NULL;
 		p->fmt.win.clipcount = 0;
 		p->fmt.win.bitmap = NULL;
-		return ops->vidioc_try_fmt_vid_out_overlay(file, NULL, arg);
+		return ops->vidioc_try_fmt_vid_out_overlay(file, state, arg);
 	case V4L2_BUF_TYPE_VBI_OUTPUT:
 		if (unlikely(!ops->vidioc_try_fmt_vbi_out))
 			break;
 		memset_after(p, 0, fmt.vbi.flags);
-		return ops->vidioc_try_fmt_vbi_out(file, NULL, arg);
+		return ops->vidioc_try_fmt_vbi_out(file, state, arg);
 	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 		if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_out))
 			break;
 		memset_after(p, 0, fmt.sliced.io_size);
-		return ops->vidioc_try_fmt_sliced_vbi_out(file, NULL, arg);
+		return ops->vidioc_try_fmt_sliced_vbi_out(file, state, arg);
 	case V4L2_BUF_TYPE_SDR_CAPTURE:
 		if (unlikely(!ops->vidioc_try_fmt_sdr_cap))
 			break;
 		memset_after(p, 0, fmt.sdr.buffersize);
-		return ops->vidioc_try_fmt_sdr_cap(file, NULL, arg);
+		return ops->vidioc_try_fmt_sdr_cap(file, state, arg);
 	case V4L2_BUF_TYPE_SDR_OUTPUT:
 		if (unlikely(!ops->vidioc_try_fmt_sdr_out))
 			break;
 		memset_after(p, 0, fmt.sdr.buffersize);
-		return ops->vidioc_try_fmt_sdr_out(file, NULL, arg);
+		return ops->vidioc_try_fmt_sdr_out(file, state, arg);
 	case V4L2_BUF_TYPE_META_CAPTURE:
 		if (unlikely(!ops->vidioc_try_fmt_meta_cap))
 			break;
 		memset_after(p, 0, fmt.meta);
-		return ops->vidioc_try_fmt_meta_cap(file, NULL, arg);
+		return ops->vidioc_try_fmt_meta_cap(file, state, arg);
 	case V4L2_BUF_TYPE_META_OUTPUT:
 		if (unlikely(!ops->vidioc_try_fmt_meta_out))
 			break;
 		memset_after(p, 0, fmt.meta);
-		return ops->vidioc_try_fmt_meta_out(file, NULL, arg);
+		return ops->vidioc_try_fmt_meta_out(file, state, arg);
 	}
 	return -EINVAL;
 }
 
 static int v4l_streamon(const struct v4l2_ioctl_ops *ops, struct file *file,
-			void *arg)
+			struct video_device_state *state, void *arg)
 {
-	return ops->vidioc_streamon(file, NULL, *(unsigned int *)arg);
+	return ops->vidioc_streamon(file, state, *(unsigned int *)arg);
 }
 
 static int v4l_streamoff(const struct v4l2_ioctl_ops *ops, struct file *file,
-			 void *arg)
+			 struct video_device_state *state, void *arg)
 {
-	return ops->vidioc_streamoff(file, NULL, *(unsigned int *)arg);
+	return ops->vidioc_streamoff(file, state, *(unsigned int *)arg);
 }
 
 static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
-		       void *arg)
+		       struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_tuner *p = arg;
@@ -1977,14 +1977,14 @@ static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
 
 	p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
 			V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
-	err = ops->vidioc_g_tuner(file, NULL, p);
+	err = ops->vidioc_g_tuner(file, state, p);
 	if (!err)
 		p->capability |= V4L2_TUNER_CAP_FREQ_BANDS;
 	return err;
 }
 
 static int v4l_s_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
-		       void *arg)
+		       struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_tuner *p = arg;
@@ -1995,11 +1995,11 @@ static int v4l_s_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
 		return ret;
 	p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
 			V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
-	return ops->vidioc_s_tuner(file, NULL, p);
+	return ops->vidioc_s_tuner(file, state, p);
 }
 
-static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_modulator *p = arg;
@@ -2008,14 +2008,14 @@ static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops,
 	if (vfd->vfl_type == VFL_TYPE_RADIO)
 		p->type = V4L2_TUNER_RADIO;
 
-	err = ops->vidioc_g_modulator(file, NULL, p);
+	err = ops->vidioc_g_modulator(file, state, p);
 	if (!err)
 		p->capability |= V4L2_TUNER_CAP_FREQ_BANDS;
 	return err;
 }
 
-static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_modulator *p = arg;
@@ -2023,11 +2023,11 @@ static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops,
 	if (vfd->vfl_type == VFL_TYPE_RADIO)
 		p->type = V4L2_TUNER_RADIO;
 
-	return ops->vidioc_s_modulator(file, NULL, p);
+	return ops->vidioc_s_modulator(file, state, p);
 }
 
-static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_frequency *p = arg;
@@ -2037,11 +2037,11 @@ static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops,
 	else
 		p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
 				V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
-	return ops->vidioc_g_frequency(file, NULL, p);
+	return ops->vidioc_g_frequency(file, state, p);
 }
 
-static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	const struct v4l2_frequency *p = arg;
@@ -2060,11 +2060,11 @@ static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops,
 		if (type != p->type)
 			return -EINVAL;
 	}
-	return ops->vidioc_s_frequency(file, NULL, p);
+	return ops->vidioc_s_frequency(file, state, p);
 }
 
 static int v4l_enumstd(const struct v4l2_ioctl_ops *ops, struct file *file,
-		       void *arg)
+		       struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_standard *p = arg;
@@ -2073,7 +2073,7 @@ static int v4l_enumstd(const struct v4l2_ioctl_ops *ops, struct file *file,
 }
 
 static int v4l_s_std(const struct v4l2_ioctl_ops *ops, struct file *file,
-		     void *arg)
+		     struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	v4l2_std_id id = *(v4l2_std_id *)arg, norm;
@@ -2087,11 +2087,11 @@ static int v4l_s_std(const struct v4l2_ioctl_ops *ops, struct file *file,
 		return -EINVAL;
 
 	/* Calls the specific handler */
-	return ops->vidioc_s_std(file, NULL, norm);
+	return ops->vidioc_s_std(file, state, norm);
 }
 
 static int v4l_querystd(const struct v4l2_ioctl_ops *ops, struct file *file,
-			void *arg)
+			struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	v4l2_std_id *p = arg;
@@ -2109,11 +2109,12 @@ static int v4l_querystd(const struct v4l2_ioctl_ops *ops, struct file *file,
 	 * their efforts to improve the standards detection.
 	 */
 	*p = vfd->tvnorms;
-	return ops->vidioc_querystd(file, NULL, arg);
+	return ops->vidioc_querystd(file, state, arg);
 }
 
 static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops *ops,
-			      struct file *file, void *arg)
+			      struct file *file,
+			      struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_hw_freq_seek *p = arg;
@@ -2131,26 +2132,26 @@ static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops *ops,
 		V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
 	if (p->type != type)
 		return -EINVAL;
-	return ops->vidioc_s_hw_freq_seek(file, NULL, p);
+	return ops->vidioc_s_hw_freq_seek(file, state, p);
 }
 
 static int v4l_s_fbuf(const struct v4l2_ioctl_ops *ops, struct file *file,
-		      void *arg)
+		      struct video_device_state *state, void *arg)
 {
 	struct v4l2_framebuffer *p = arg;
 
 	p->base = NULL;
-	return ops->vidioc_s_fbuf(file, NULL, p);
+	return ops->vidioc_s_fbuf(file, state, p);
 }
 
 static int v4l_overlay(const struct v4l2_ioctl_ops *ops, struct file *file,
-		       void *arg)
+		       struct video_device_state *state, void *arg)
 {
-	return ops->vidioc_overlay(file, NULL, *(unsigned int *)arg);
+	return ops->vidioc_overlay(file, state, *(unsigned int *)arg);
 }
 
 static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops, struct file *file,
-		       void *arg)
+		       struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_requestbuffers *p = arg;
@@ -2165,38 +2166,38 @@ static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops, struct file *file,
 	if (is_valid_ioctl(vfd, VIDIOC_REMOVE_BUFS))
 		p->capabilities = V4L2_BUF_CAP_SUPPORTS_REMOVE_BUFS;
 
-	return ops->vidioc_reqbufs(file, NULL, p);
+	return ops->vidioc_reqbufs(file, state, p);
 }
 
 static int v4l_querybuf(const struct v4l2_ioctl_ops *ops, struct file *file,
-			void *arg)
+			struct video_device_state *state, void *arg)
 {
 	struct v4l2_buffer *p = arg;
 	int ret = check_fmt(file, p->type);
 
-	return ret ? ret : ops->vidioc_querybuf(file, NULL, p);
+	return ret ? ret : ops->vidioc_querybuf(file, state, p);
 }
 
 static int v4l_qbuf(const struct v4l2_ioctl_ops *ops, struct file *file,
-		    void *arg)
+		    struct video_device_state *state, void *arg)
 {
 	struct v4l2_buffer *p = arg;
 	int ret = check_fmt(file, p->type);
 
-	return ret ? ret : ops->vidioc_qbuf(file, NULL, p);
+	return ret ? ret : ops->vidioc_qbuf(file, state, p);
 }
 
 static int v4l_dqbuf(const struct v4l2_ioctl_ops *ops, struct file *file,
-		     void *arg)
+		     struct video_device_state *state, void *arg)
 {
 	struct v4l2_buffer *p = arg;
 	int ret = check_fmt(file, p->type);
 
-	return ret ? ret : ops->vidioc_dqbuf(file, NULL, p);
+	return ret ? ret : ops->vidioc_dqbuf(file, state, p);
 }
 
-static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_create_buffers *create = arg;
@@ -2213,7 +2214,7 @@ static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
 	if (is_valid_ioctl(vfd, VIDIOC_REMOVE_BUFS))
 		create->capabilities = V4L2_BUF_CAP_SUPPORTS_REMOVE_BUFS;
 
-	ret = ops->vidioc_create_bufs(file, NULL, create);
+	ret = ops->vidioc_create_bufs(file, state, create);
 
 	if (create->format.type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
 	    create->format.type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
@@ -2222,28 +2223,28 @@ static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
 	return ret;
 }
 
-static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct v4l2_buffer *b = arg;
 	int ret = check_fmt(file, b->type);
 
-	return ret ? ret : ops->vidioc_prepare_buf(file, NULL, b);
+	return ret ? ret : ops->vidioc_prepare_buf(file, state, b);
 }
 
-static int v4l_remove_bufs(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_remove_bufs(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct v4l2_remove_buffers *remove = arg;
 
 	if (ops->vidioc_remove_bufs)
-		return ops->vidioc_remove_bufs(file, NULL, remove);
+		return ops->vidioc_remove_bufs(file, state, remove);
 
 	return -ENOTTY;
 }
 
 static int v4l_g_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
-		      void *arg)
+		      struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_streamparm *p = arg;
@@ -2253,20 +2254,20 @@ static int v4l_g_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
 	if (ret)
 		return ret;
 	if (ops->vidioc_g_parm)
-		return ops->vidioc_g_parm(file, NULL, p);
+		return ops->vidioc_g_parm(file, state, p);
 	if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 	    p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
 		return -EINVAL;
 	if (vfd->device_caps & V4L2_CAP_READWRITE)
 		p->parm.capture.readbuffers = 2;
-	ret = ops->vidioc_g_std(file, NULL, &std);
+	ret = ops->vidioc_g_std(file, state, &std);
 	if (ret == 0)
 		v4l2_video_std_frame_period(std, &p->parm.capture.timeperframe);
 	return ret;
 }
 
 static int v4l_s_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
-		      void *arg)
+		      struct video_device_state *state, void *arg)
 {
 	struct v4l2_streamparm *p = arg;
 	int ret = check_fmt(file, p->type);
@@ -2286,11 +2287,11 @@ static int v4l_s_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
 		p->parm.capture.extendedmode = 0;
 		p->parm.capture.capturemode &= V4L2_MODE_HIGHQUALITY;
 	}
-	return ops->vidioc_s_parm(file, NULL, p);
+	return ops->vidioc_s_parm(file, state, p);
 }
 
 static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
-			 void *arg)
+			 struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_query_ext_ctrl qec = {};
@@ -2307,7 +2308,7 @@ static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
 
 	/* Simulate query_ext_ctr using query_ctrl. */
 	qec.id = p->id;
-	ret = ops->vidioc_query_ext_ctrl(file, NULL, &qec);
+	ret = ops->vidioc_query_ext_ctrl(file, state, &qec);
 	if (ret)
 		return ret;
 	v4l2_query_ext_ctrl_to_v4l2_queryctrl(p, &qec);
@@ -2315,7 +2316,8 @@ static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
 }
 
 static int v4l_query_ext_ctrl(const struct v4l2_ioctl_ops *ops,
-			      struct file *file, void *arg)
+			      struct file *file,
+			      struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_query_ext_ctrl *p = arg;
@@ -2326,12 +2328,12 @@ static int v4l_query_ext_ctrl(const struct v4l2_ioctl_ops *ops,
 	if (vfd->ctrl_handler)
 		return v4l2_query_ext_ctrl(vfd->ctrl_handler, p);
 	if (ops->vidioc_query_ext_ctrl)
-		return ops->vidioc_query_ext_ctrl(file, NULL, p);
+		return ops->vidioc_query_ext_ctrl(file, state, p);
 	return -ENOTTY;
 }
 
 static int v4l_querymenu(const struct v4l2_ioctl_ops *ops, struct file *file,
-			 void *arg)
+			 struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_querymenu *p = arg;
@@ -2342,12 +2344,12 @@ static int v4l_querymenu(const struct v4l2_ioctl_ops *ops, struct file *file,
 	if (vfd->ctrl_handler)
 		return v4l2_querymenu(vfd->ctrl_handler, p);
 	if (ops->vidioc_querymenu)
-		return ops->vidioc_querymenu(file, NULL, p);
+		return ops->vidioc_querymenu(file, state, p);
 	return -ENOTTY;
 }
 
 static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
-		      void *arg)
+		      struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_control *p = arg;
@@ -2368,7 +2370,7 @@ static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
 	ctrl.id = p->id;
 	ctrl.value = p->value;
 	if (check_ext_ctrls(&ctrls, VIDIOC_G_CTRL)) {
-		int ret = ops->vidioc_g_ext_ctrls(file, NULL, &ctrls);
+		int ret = ops->vidioc_g_ext_ctrls(file, state, &ctrls);
 
 		if (ret == 0)
 			p->value = ctrl.value;
@@ -2378,7 +2380,7 @@ static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
 }
 
 static int v4l_s_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
-		      void *arg)
+		      struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_control *p = arg;
@@ -2401,13 +2403,13 @@ static int v4l_s_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
 	ctrl.value = p->value;
 	if (!check_ext_ctrls(&ctrls, VIDIOC_S_CTRL))
 		return -EINVAL;
-	ret = ops->vidioc_s_ext_ctrls(file, NULL, &ctrls);
+	ret = ops->vidioc_s_ext_ctrls(file, state, &ctrls);
 	p->value = ctrl.value;
 	return ret;
 }
 
-static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_ext_controls *p = arg;
@@ -2423,11 +2425,11 @@ static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops,
 	if (ops->vidioc_g_ext_ctrls == NULL)
 		return -ENOTTY;
 	return check_ext_ctrls(p, VIDIOC_G_EXT_CTRLS) ?
-				ops->vidioc_g_ext_ctrls(file, NULL, p) : -EINVAL;
+				ops->vidioc_g_ext_ctrls(file, state, p) : -EINVAL;
 }
 
-static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_ext_controls *p = arg;
@@ -2443,11 +2445,12 @@ static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops,
 	if (ops->vidioc_s_ext_ctrls == NULL)
 		return -ENOTTY;
 	return check_ext_ctrls(p, VIDIOC_S_EXT_CTRLS) ?
-				ops->vidioc_s_ext_ctrls(file, NULL, p) : -EINVAL;
+				ops->vidioc_s_ext_ctrls(file, state, p) : -EINVAL;
 }
 
 static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
-			     struct file *file, void *arg)
+			     struct file *file,
+			     struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_ext_controls *p = arg;
@@ -2463,7 +2466,7 @@ static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
 	if (ops->vidioc_try_ext_ctrls == NULL)
 		return -ENOTTY;
 	return check_ext_ctrls(p, VIDIOC_TRY_EXT_CTRLS) ?
-			ops->vidioc_try_ext_ctrls(file, NULL, p) : -EINVAL;
+			ops->vidioc_try_ext_ctrls(file, state, p) : -EINVAL;
 }
 
 /*
@@ -2475,8 +2478,8 @@ static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
  * restore it afterwards. This way applications can use either buffer
  * type and drivers don't need to check for both.
  */
-static int v4l_g_selection(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_g_selection(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct v4l2_selection *p = arg;
 	u32 old_type = p->type;
@@ -2486,13 +2489,13 @@ static int v4l_g_selection(const struct v4l2_ioctl_ops *ops,
 		p->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 	else if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
 		p->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
-	ret = ops->vidioc_g_selection(file, NULL, p);
+	ret = ops->vidioc_g_selection(file, state, p);
 	p->type = old_type;
 	return ret;
 }
 
-static int v4l_s_selection(const struct v4l2_ioctl_ops *ops,
-			   struct file *file, void *arg)
+static int v4l_s_selection(const struct v4l2_ioctl_ops *ops, struct file *file,
+			   struct video_device_state *state, void *arg)
 {
 	struct v4l2_selection *p = arg;
 	u32 old_type = p->type;
@@ -2502,13 +2505,13 @@ static int v4l_s_selection(const struct v4l2_ioctl_ops *ops,
 		p->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 	else if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
 		p->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
-	ret = ops->vidioc_s_selection(file, NULL, p);
+	ret = ops->vidioc_s_selection(file, state, p);
 	p->type = old_type;
 	return ret;
 }
 
 static int v4l_g_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
-		      void *arg)
+		      struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_crop *p = arg;
@@ -2529,7 +2532,7 @@ static int v4l_g_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
 		s.target = s.target == V4L2_SEL_TGT_COMPOSE ?
 			V4L2_SEL_TGT_CROP : V4L2_SEL_TGT_COMPOSE;
 
-	ret = v4l_g_selection(ops, file, &s);
+	ret = v4l_g_selection(ops, file, state, &s);
 
 	/* copying results to old structure on success */
 	if (!ret)
@@ -2538,7 +2541,7 @@ static int v4l_g_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
 }
 
 static int v4l_s_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
-		      void *arg)
+		      struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_crop *p = arg;
@@ -2559,11 +2562,11 @@ static int v4l_s_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
 		s.target = s.target == V4L2_SEL_TGT_COMPOSE ?
 			V4L2_SEL_TGT_CROP : V4L2_SEL_TGT_COMPOSE;
 
-	return v4l_s_selection(ops, file, &s);
+	return v4l_s_selection(ops, file, state, &s);
 }
 
 static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
-		       void *arg)
+		       struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_cropcap *p = arg;
@@ -2587,7 +2590,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
 		return -ENOTTY;
 
 	if (ops->vidioc_g_pixelaspect)
-		ret = ops->vidioc_g_pixelaspect(file, NULL, s.type,
+		ret = ops->vidioc_g_pixelaspect(file, state, s.type,
 						&p->pixelaspect);
 
 	/*
@@ -2609,7 +2612,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
 		s.target = s.target == V4L2_SEL_TGT_COMPOSE_BOUNDS ?
 			V4L2_SEL_TGT_CROP_BOUNDS : V4L2_SEL_TGT_COMPOSE_BOUNDS;
 
-	ret = v4l_g_selection(ops, file, &s);
+	ret = v4l_g_selection(ops, file, state, &s);
 	if (ret)
 		return ret;
 	p->bounds = s.r;
@@ -2620,7 +2623,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
 	else
 		s.target = V4L2_SEL_TGT_CROP_DEFAULT;
 
-	ret = v4l_g_selection(ops, file, &s);
+	ret = v4l_g_selection(ops, file, state, &s);
 	if (ret)
 		return ret;
 	p->defrect = s.r;
@@ -2629,7 +2632,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
 }
 
 static int v4l_log_status(const struct v4l2_ioctl_ops *ops, struct file *file,
-			  void *arg)
+			  struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	int ret;
@@ -2637,7 +2640,7 @@ static int v4l_log_status(const struct v4l2_ioctl_ops *ops, struct file *file,
 	if (vfd->v4l2_dev)
 		pr_info("%s: =================  START STATUS  =================\n",
 			vfd->v4l2_dev->name);
-	ret = ops->vidioc_log_status(file, NULL);
+	ret = ops->vidioc_log_status(file, state);
 	if (vfd->v4l2_dev)
 		pr_info("%s: ==================  END STATUS  ==================\n",
 			vfd->v4l2_dev->name);
@@ -2645,7 +2648,8 @@ static int v4l_log_status(const struct v4l2_ioctl_ops *ops, struct file *file,
 }
 
 static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
-			      struct file *file, void *arg)
+			      struct file *file,
+			      struct video_device_state *state, void *arg)
 {
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 	struct v4l2_dbg_register *p = arg;
@@ -2665,7 +2669,7 @@ static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
 	}
 	if (ops->vidioc_g_register && p->match.type == V4L2_CHIP_MATCH_BRIDGE &&
 	    (ops->vidioc_g_chip_info || p->match.addr == 0))
-		return ops->vidioc_g_register(file, NULL, p);
+		return ops->vidioc_g_register(file, state, p);
 	return -EINVAL;
 #else
 	return -ENOTTY;
@@ -2673,7 +2677,8 @@ static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
 }
 
 static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
-			      struct file *file, void *arg)
+			      struct file *file,
+			      struct video_device_state *state, void *arg)
 {
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 	const struct v4l2_dbg_register *p = arg;
@@ -2693,7 +2698,7 @@ static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
 	}
 	if (ops->vidioc_s_register && p->match.type == V4L2_CHIP_MATCH_BRIDGE &&
 	    (ops->vidioc_g_chip_info || p->match.addr == 0))
-		return ops->vidioc_s_register(file, NULL, p);
+		return ops->vidioc_s_register(file, state, p);
 	return -EINVAL;
 #else
 	return -ENOTTY;
@@ -2701,7 +2706,8 @@ static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
 }
 
 static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops,
-			       struct file *file, void *arg)
+			       struct file *file,
+			       struct video_device_state *state, void *arg)
 {
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 	struct video_device *vfd = video_devdata(file);
@@ -2717,7 +2723,7 @@ static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops,
 			p->flags |= V4L2_CHIP_FL_READABLE;
 		strscpy(p->name, vfd->v4l2_dev->name, sizeof(p->name));
 		if (ops->vidioc_g_chip_info)
-			return ops->vidioc_g_chip_info(file, NULL, arg);
+			return ops->vidioc_g_chip_info(file, state, arg);
 		if (p->match.addr)
 			return -EINVAL;
 		return 0;
@@ -2744,7 +2750,7 @@ static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops,
 }
 
 static int v4l_dqevent(const struct v4l2_ioctl_ops *ops, struct file *file,
-		       void *arg)
+		       struct video_device_state *state, void *arg)
 {
 	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
 
@@ -2752,7 +2758,8 @@ static int v4l_dqevent(const struct v4l2_ioctl_ops *ops, struct file *file,
 }
 
 static int v4l_subscribe_event(const struct v4l2_ioctl_ops *ops,
-			       struct file *file, void *arg)
+			       struct file *file,
+			       struct video_device_state *state, void *arg)
 {
 	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
 
@@ -2760,7 +2767,8 @@ static int v4l_subscribe_event(const struct v4l2_ioctl_ops *ops,
 }
 
 static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops *ops,
-				 struct file *file, void *arg)
+				 struct file *file,
+				 struct video_device_state *state, void *arg)
 {
 	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
 
@@ -2768,7 +2776,8 @@ static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops *ops,
 }
 
 static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops *ops,
-				struct file *file, void *arg)
+				struct file *file,
+				struct video_device_state *state, void *arg)
 {
 	struct v4l2_sliced_vbi_cap *p = arg;
 	int ret = check_fmt(file, p->type);
@@ -2779,11 +2788,12 @@ static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops *ops,
 	/* Clear up to type, everything after type is zeroed already */
 	memset(p, 0, offsetof(struct v4l2_sliced_vbi_cap, type));
 
-	return ops->vidioc_g_sliced_vbi_cap(file, NULL, p);
+	return ops->vidioc_g_sliced_vbi_cap(file, state, p);
 }
 
 static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
-			       struct file *file, void *arg)
+			       struct file *file,
+			       struct video_device_state *state, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	struct v4l2_frequency_band *p = arg;
@@ -2801,7 +2811,7 @@ static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
 			return -EINVAL;
 	}
 	if (ops->vidioc_enum_freq_bands) {
-		err = ops->vidioc_enum_freq_bands(file, NULL, p);
+		err = ops->vidioc_enum_freq_bands(file, state, p);
 		if (err != -ENOTTY)
 			return err;
 	}
@@ -2813,7 +2823,7 @@ static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
 
 		if (p->index)
 			return -EINVAL;
-		err = ops->vidioc_g_tuner(file, NULL, &t);
+		err = ops->vidioc_g_tuner(file, state, &t);
 		if (err)
 			return err;
 		p->capability = t.capability | V4L2_TUNER_CAP_FREQ_BANDS;
@@ -2832,7 +2842,7 @@ static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
 			return -EINVAL;
 		if (p->index)
 			return -EINVAL;
-		err = ops->vidioc_g_modulator(file, NULL, &m);
+		err = ops->vidioc_g_modulator(file, state, &m);
 		if (err)
 			return err;
 		p->capability = m.capability | V4L2_TUNER_CAP_FREQ_BANDS;
@@ -2849,7 +2859,7 @@ struct v4l2_ioctl_info {
 	u32 flags;
 	const char * const name;
 	int (*func)(const struct v4l2_ioctl_ops *ops, struct file *file,
-		    void *p);
+		    struct video_device_state *state, void *p);
 	void (*debug)(const void *arg, bool write_only);
 };
 
@@ -2870,7 +2880,9 @@ struct v4l2_ioctl_info {
 #define DEFINE_V4L_STUB_FUNC(_vidioc)				\
 	static int v4l_stub_ ## _vidioc(			\
 			const struct v4l2_ioctl_ops *ops,	\
-			struct file *file, void *p)		\
+			struct file *file,			\
+			struct video_device_state *state,	\
+			void *p)				\
 	{							\
 		return ops->vidioc_ ## _vidioc(file, NULL, p);	\
 	}
@@ -3126,7 +3138,7 @@ static long __video_do_ioctl(struct file *file,
 
 	write_only = _IOC_DIR(cmd) == _IOC_WRITE;
 	if (info != &default_info) {
-		ret = info->func(ops, file, arg);
+		ret = info->func(ops, file, NULL, arg);
 	} else if (!ops->vidioc_default) {
 		ret = -ENOTTY;
 	} else {

-- 
2.51.0
Re: [PATCH v2 05/10] media: v4l2-ioctl: Add video_device_state argument to v4l2 ioctl wrappers
Posted by Hans Verkuil 1 week, 2 days ago 
On 19/09/2025 11:55, Jai Luthra wrote:
> Add a third argument to all v4l2 ioctl wrappers to pass struct
> video_device_state * directly, replacing the previous opaque pointer
> approach.
> 
> Currently, this argument is populated with NULL since existing driver
> hooks still expect a void *priv argument. This will be addressed in a
> subsequent patch.

There is one more occurrance of this in v4l2_compat_ioctl32.c in function
ctrl_is_pointer() where vidioc_query_ext_ctrl is called.

Regards,

	Hans

> 
> Most changes to the ioctl wrappers were generated using the following
> Coccinelle semantic patch:
> 
> @ioctl@
> identifier v4l2_ioctls;
> identifier ioctl;
> identifier fn;
> identifier debug;
> expression flags;
> @@
> struct v4l2_ioctl_info v4l2_ioctls[] = {
> 	...,
> 	IOCTL_INFO(ioctl, fn, debug, flags),
> 	...,
> };
> 
> @depends on ioctl@
> identifier ioctl.fn;
> identifier ops;
> identifier file;
> identifier arg;
> identifier handler;
> expression list args;
> @@
> -int fn(const struct v4l2_ioctl_ops *ops, struct file *file, void *arg)
> +int fn(const struct v4l2_ioctl_ops *ops, struct file *file,
> +       struct video_device_state *state, void *arg)
> {
> 	<...
> -	ops->handler(file, NULL, args)
> +	ops->handler(file, state, args)
> 	...>
> }
> 
> Manual changes were made to handle calls to v4l_[gs]_selection, update
> the v4l2_ioctl_info structure definition and macros, fix argument
> wrapping in some function definitions, and handle the common function
> pointer in v4l2_ioctl_info.
> 
> Signed-off-by: Jai Luthra <jai.luthra@ideasonboard.com>
> --
> Cc: Mauro Carvalho Chehab <mchehab@kernel.org>
> Cc: Hans Verkuil <hverkuil@kernel.org>
> Cc: Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com>
> Cc: Ricardo Ribalda <ribalda@chromium.org>
> Cc: Hans de Goede <hansg@kernel.org>
> Cc: Jai Luthra <jai.luthra@ideasonboard.com>
> Cc: linux-media@vger.kernel.org
> Cc: linux-kernel@vger.kernel.org
> ---
>  drivers/media/v4l2-core/v4l2-ioctl.c | 360 ++++++++++++++++++-----------------
>  1 file changed, 186 insertions(+), 174 deletions(-)
> 
> diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
> index 01cf52c3ea33e1a01e1b306036ba4e57ef5c95d0..644f06521673ff7ce5b194335d50f0e375ca7f51 100644
> --- a/drivers/media/v4l2-core/v4l2-ioctl.c
> +++ b/drivers/media/v4l2-core/v4l2-ioctl.c
> @@ -1090,7 +1090,7 @@ static void v4l_sanitize_format(struct v4l2_format *fmt)
>  }
>  
>  static int v4l_querycap(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			void *arg)
> +			struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_capability *cap = (struct v4l2_capability *)arg;
>  	struct video_device *vfd = video_devdata(file);
> @@ -1103,7 +1103,7 @@ static int v4l_querycap(const struct v4l2_ioctl_ops *ops, struct file *file,
>  	media_set_bus_info(cap->bus_info, sizeof(cap->bus_info),
>  			   vfd->dev_parent);
>  
> -	ret = ops->vidioc_querycap(file, NULL, cap);
> +	ret = ops->vidioc_querycap(file, state, cap);
>  
>  	/*
>  	 * Drivers must not change device_caps, so check for this and
> @@ -1124,7 +1124,7 @@ static int v4l_querycap(const struct v4l2_ioctl_ops *ops, struct file *file,
>  }
>  
>  static int v4l_g_input(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		       void *arg)
> +		       struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  
> @@ -1133,11 +1133,11 @@ static int v4l_g_input(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		return 0;
>  	}
>  
> -	return ops->vidioc_g_input(file, NULL, arg);
> +	return ops->vidioc_g_input(file, state, arg);
>  }
>  
>  static int v4l_g_output(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			void *arg)
> +			struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  
> @@ -1146,11 +1146,11 @@ static int v4l_g_output(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		return 0;
>  	}
>  
> -	return ops->vidioc_g_output(file, NULL, arg);
> +	return ops->vidioc_g_output(file, state, arg);
>  }
>  
>  static int v4l_s_input(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		       void *arg)
> +		       struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	int ret;
> @@ -1162,22 +1162,22 @@ static int v4l_s_input(const struct v4l2_ioctl_ops *ops, struct file *file,
>  	if (vfd->device_caps & V4L2_CAP_IO_MC)
>  		return  *(int *)arg ? -EINVAL : 0;
>  
> -	return ops->vidioc_s_input(file, NULL, *(unsigned int *)arg);
> +	return ops->vidioc_s_input(file, state, *(unsigned int *)arg);
>  }
>  
>  static int v4l_s_output(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			void *arg)
> +			struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  
>  	if (vfd->device_caps & V4L2_CAP_IO_MC)
>  		return  *(int *)arg ? -EINVAL : 0;
>  
> -	return ops->vidioc_s_output(file, NULL, *(unsigned int *)arg);
> +	return ops->vidioc_s_output(file, state, *(unsigned int *)arg);
>  }
>  
>  static int v4l_g_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			  void *arg)
> +			  struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd;
>  	u32 *p = arg;
> @@ -1188,7 +1188,7 @@ static int v4l_g_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
>  }
>  
>  static int v4l_s_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			  void *arg)
> +			  struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd;
>  	struct v4l2_fh *vfh;
> @@ -1200,7 +1200,7 @@ static int v4l_s_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
>  }
>  
>  static int v4l_enuminput(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			 void *arg)
> +			 struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_input *p = arg;
> @@ -1222,11 +1222,11 @@ static int v4l_enuminput(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		return 0;
>  	}
>  
> -	return ops->vidioc_enum_input(file, NULL, p);
> +	return ops->vidioc_enum_input(file, state, p);
>  }
>  
>  static int v4l_enumoutput(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			  void *arg)
> +			  struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_output *p = arg;
> @@ -1248,7 +1248,7 @@ static int v4l_enumoutput(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		return 0;
>  	}
>  
> -	return ops->vidioc_enum_output(file, NULL, p);
> +	return ops->vidioc_enum_output(file, state, p);
>  }
>  
>  static void v4l_fill_fmtdesc(struct v4l2_fmtdesc *fmt)
> @@ -1588,7 +1588,7 @@ static void v4l_fill_fmtdesc(struct v4l2_fmtdesc *fmt)
>  }
>  
>  static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			void *arg)
> +			struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vdev = video_devdata(file);
>  	struct v4l2_fmtdesc *p = arg;
> @@ -1618,12 +1618,12 @@ static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  
>  		if (unlikely(!ops->vidioc_enum_fmt_vid_cap))
>  			break;
> -		ret = ops->vidioc_enum_fmt_vid_cap(file, NULL, arg);
> +		ret = ops->vidioc_enum_fmt_vid_cap(file, state, arg);
>  		break;
>  	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
>  		if (unlikely(!ops->vidioc_enum_fmt_vid_overlay))
>  			break;
> -		ret = ops->vidioc_enum_fmt_vid_overlay(file, NULL, arg);
> +		ret = ops->vidioc_enum_fmt_vid_overlay(file, state, arg);
>  		break;
>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
> @@ -1635,27 +1635,27 @@ static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  
>  		if (unlikely(!ops->vidioc_enum_fmt_vid_out))
>  			break;
> -		ret = ops->vidioc_enum_fmt_vid_out(file, NULL, arg);
> +		ret = ops->vidioc_enum_fmt_vid_out(file, state, arg);
>  		break;
>  	case V4L2_BUF_TYPE_SDR_CAPTURE:
>  		if (unlikely(!ops->vidioc_enum_fmt_sdr_cap))
>  			break;
> -		ret = ops->vidioc_enum_fmt_sdr_cap(file, NULL, arg);
> +		ret = ops->vidioc_enum_fmt_sdr_cap(file, state, arg);
>  		break;
>  	case V4L2_BUF_TYPE_SDR_OUTPUT:
>  		if (unlikely(!ops->vidioc_enum_fmt_sdr_out))
>  			break;
> -		ret = ops->vidioc_enum_fmt_sdr_out(file, NULL, arg);
> +		ret = ops->vidioc_enum_fmt_sdr_out(file, state, arg);
>  		break;
>  	case V4L2_BUF_TYPE_META_CAPTURE:
>  		if (unlikely(!ops->vidioc_enum_fmt_meta_cap))
>  			break;
> -		ret = ops->vidioc_enum_fmt_meta_cap(file, NULL, arg);
> +		ret = ops->vidioc_enum_fmt_meta_cap(file, state, arg);
>  		break;
>  	case V4L2_BUF_TYPE_META_OUTPUT:
>  		if (unlikely(!ops->vidioc_enum_fmt_meta_out))
>  			break;
> -		ret = ops->vidioc_enum_fmt_meta_out(file, NULL, arg);
> +		ret = ops->vidioc_enum_fmt_meta_out(file, state, arg);
>  		break;
>  	}
>  	if (ret == 0)
> @@ -1679,7 +1679,7 @@ static void v4l_pix_format_touch(struct v4l2_pix_format *p)
>  }
>  
>  static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		     void *arg)
> +		     struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_format *p = arg;
>  	struct video_device *vfd = video_devdata(file);
> @@ -1695,50 +1695,50 @@ static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		if (unlikely(!ops->vidioc_g_fmt_vid_cap))
>  			break;
>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
> -		ret = ops->vidioc_g_fmt_vid_cap(file, NULL, arg);
> +		ret = ops->vidioc_g_fmt_vid_cap(file, state, arg);
>  		/* just in case the driver zeroed it again */
>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>  		if (vfd->vfl_type == VFL_TYPE_TOUCH)
>  			v4l_pix_format_touch(&p->fmt.pix);
>  		return ret;
>  	case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
> -		return ops->vidioc_g_fmt_vid_cap_mplane(file, NULL, arg);
> +		return ops->vidioc_g_fmt_vid_cap_mplane(file, state, arg);
>  	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
> -		return ops->vidioc_g_fmt_vid_overlay(file, NULL, arg);
> +		return ops->vidioc_g_fmt_vid_overlay(file, state, arg);
>  	case V4L2_BUF_TYPE_VBI_CAPTURE:
> -		return ops->vidioc_g_fmt_vbi_cap(file, NULL, arg);
> +		return ops->vidioc_g_fmt_vbi_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
> -		return ops->vidioc_g_fmt_sliced_vbi_cap(file, NULL, arg);
> +		return ops->vidioc_g_fmt_sliced_vbi_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
>  		if (unlikely(!ops->vidioc_g_fmt_vid_out))
>  			break;
>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
> -		ret = ops->vidioc_g_fmt_vid_out(file, NULL, arg);
> +		ret = ops->vidioc_g_fmt_vid_out(file, state, arg);
>  		/* just in case the driver zeroed it again */
>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>  		return ret;
>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
> -		return ops->vidioc_g_fmt_vid_out_mplane(file, NULL, arg);
> +		return ops->vidioc_g_fmt_vid_out_mplane(file, state, arg);
>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
> -		return ops->vidioc_g_fmt_vid_out_overlay(file, NULL, arg);
> +		return ops->vidioc_g_fmt_vid_out_overlay(file, state, arg);
>  	case V4L2_BUF_TYPE_VBI_OUTPUT:
> -		return ops->vidioc_g_fmt_vbi_out(file, NULL, arg);
> +		return ops->vidioc_g_fmt_vbi_out(file, state, arg);
>  	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
> -		return ops->vidioc_g_fmt_sliced_vbi_out(file, NULL, arg);
> +		return ops->vidioc_g_fmt_sliced_vbi_out(file, state, arg);
>  	case V4L2_BUF_TYPE_SDR_CAPTURE:
> -		return ops->vidioc_g_fmt_sdr_cap(file, NULL, arg);
> +		return ops->vidioc_g_fmt_sdr_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_SDR_OUTPUT:
> -		return ops->vidioc_g_fmt_sdr_out(file, NULL, arg);
> +		return ops->vidioc_g_fmt_sdr_out(file, state, arg);
>  	case V4L2_BUF_TYPE_META_CAPTURE:
> -		return ops->vidioc_g_fmt_meta_cap(file, NULL, arg);
> +		return ops->vidioc_g_fmt_meta_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_META_OUTPUT:
> -		return ops->vidioc_g_fmt_meta_out(file, NULL, arg);
> +		return ops->vidioc_g_fmt_meta_out(file, state, arg);
>  	}
>  	return -EINVAL;
>  }
>  
>  static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		     void *arg)
> +		     struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_format *p = arg;
>  	struct video_device *vfd = video_devdata(file);
> @@ -1758,7 +1758,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		if (unlikely(!ops->vidioc_s_fmt_vid_cap))
>  			break;
>  		memset_after(p, 0, fmt.pix);
> -		ret = ops->vidioc_s_fmt_vid_cap(file, NULL, arg);
> +		ret = ops->vidioc_s_fmt_vid_cap(file, state, arg);
>  		/* just in case the driver zeroed it again */
>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>  		if (vfd->vfl_type == VFL_TYPE_TOUCH)
> @@ -1771,7 +1771,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
>  			memset_after(&p->fmt.pix_mp.plane_fmt[i],
>  				     0, bytesperline);
> -		return ops->vidioc_s_fmt_vid_cap_mplane(file, NULL, arg);
> +		return ops->vidioc_s_fmt_vid_cap_mplane(file, state, arg);
>  	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
>  		if (unlikely(!ops->vidioc_s_fmt_vid_overlay))
>  			break;
> @@ -1779,22 +1779,22 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		p->fmt.win.clips = NULL;
>  		p->fmt.win.clipcount = 0;
>  		p->fmt.win.bitmap = NULL;
> -		return ops->vidioc_s_fmt_vid_overlay(file, NULL, arg);
> +		return ops->vidioc_s_fmt_vid_overlay(file, state, arg);
>  	case V4L2_BUF_TYPE_VBI_CAPTURE:
>  		if (unlikely(!ops->vidioc_s_fmt_vbi_cap))
>  			break;
>  		memset_after(p, 0, fmt.vbi.flags);
> -		return ops->vidioc_s_fmt_vbi_cap(file, NULL, arg);
> +		return ops->vidioc_s_fmt_vbi_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
>  		if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_cap))
>  			break;
>  		memset_after(p, 0, fmt.sliced.io_size);
> -		return ops->vidioc_s_fmt_sliced_vbi_cap(file, NULL, arg);
> +		return ops->vidioc_s_fmt_sliced_vbi_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
>  		if (unlikely(!ops->vidioc_s_fmt_vid_out))
>  			break;
>  		memset_after(p, 0, fmt.pix);
> -		ret = ops->vidioc_s_fmt_vid_out(file, NULL, arg);
> +		ret = ops->vidioc_s_fmt_vid_out(file, state, arg);
>  		/* just in case the driver zeroed it again */
>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>  		return ret;
> @@ -1805,7 +1805,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
>  			memset_after(&p->fmt.pix_mp.plane_fmt[i],
>  				     0, bytesperline);
> -		return ops->vidioc_s_fmt_vid_out_mplane(file, NULL, arg);
> +		return ops->vidioc_s_fmt_vid_out_mplane(file, state, arg);
>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
>  		if (unlikely(!ops->vidioc_s_fmt_vid_out_overlay))
>  			break;
> @@ -1813,43 +1813,43 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		p->fmt.win.clips = NULL;
>  		p->fmt.win.clipcount = 0;
>  		p->fmt.win.bitmap = NULL;
> -		return ops->vidioc_s_fmt_vid_out_overlay(file, NULL, arg);
> +		return ops->vidioc_s_fmt_vid_out_overlay(file, state, arg);
>  	case V4L2_BUF_TYPE_VBI_OUTPUT:
>  		if (unlikely(!ops->vidioc_s_fmt_vbi_out))
>  			break;
>  		memset_after(p, 0, fmt.vbi.flags);
> -		return ops->vidioc_s_fmt_vbi_out(file, NULL, arg);
> +		return ops->vidioc_s_fmt_vbi_out(file, state, arg);
>  	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
>  		if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_out))
>  			break;
>  		memset_after(p, 0, fmt.sliced.io_size);
> -		return ops->vidioc_s_fmt_sliced_vbi_out(file, NULL, arg);
> +		return ops->vidioc_s_fmt_sliced_vbi_out(file, state, arg);
>  	case V4L2_BUF_TYPE_SDR_CAPTURE:
>  		if (unlikely(!ops->vidioc_s_fmt_sdr_cap))
>  			break;
>  		memset_after(p, 0, fmt.sdr.buffersize);
> -		return ops->vidioc_s_fmt_sdr_cap(file, NULL, arg);
> +		return ops->vidioc_s_fmt_sdr_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_SDR_OUTPUT:
>  		if (unlikely(!ops->vidioc_s_fmt_sdr_out))
>  			break;
>  		memset_after(p, 0, fmt.sdr.buffersize);
> -		return ops->vidioc_s_fmt_sdr_out(file, NULL, arg);
> +		return ops->vidioc_s_fmt_sdr_out(file, state, arg);
>  	case V4L2_BUF_TYPE_META_CAPTURE:
>  		if (unlikely(!ops->vidioc_s_fmt_meta_cap))
>  			break;
>  		memset_after(p, 0, fmt.meta);
> -		return ops->vidioc_s_fmt_meta_cap(file, NULL, arg);
> +		return ops->vidioc_s_fmt_meta_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_META_OUTPUT:
>  		if (unlikely(!ops->vidioc_s_fmt_meta_out))
>  			break;
>  		memset_after(p, 0, fmt.meta);
> -		return ops->vidioc_s_fmt_meta_out(file, NULL, arg);
> +		return ops->vidioc_s_fmt_meta_out(file, state, arg);
>  	}
>  	return -EINVAL;
>  }
>  
>  static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		       void *arg)
> +		       struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_format *p = arg;
>  	struct video_device *vfd = video_devdata(file);
> @@ -1866,7 +1866,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		if (unlikely(!ops->vidioc_try_fmt_vid_cap))
>  			break;
>  		memset_after(p, 0, fmt.pix);
> -		ret = ops->vidioc_try_fmt_vid_cap(file, NULL, arg);
> +		ret = ops->vidioc_try_fmt_vid_cap(file, state, arg);
>  		/* just in case the driver zeroed it again */
>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>  		if (vfd->vfl_type == VFL_TYPE_TOUCH)
> @@ -1879,7 +1879,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
>  			memset_after(&p->fmt.pix_mp.plane_fmt[i],
>  				     0, bytesperline);
> -		return ops->vidioc_try_fmt_vid_cap_mplane(file, NULL, arg);
> +		return ops->vidioc_try_fmt_vid_cap_mplane(file, state, arg);
>  	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
>  		if (unlikely(!ops->vidioc_try_fmt_vid_overlay))
>  			break;
> @@ -1887,22 +1887,22 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		p->fmt.win.clips = NULL;
>  		p->fmt.win.clipcount = 0;
>  		p->fmt.win.bitmap = NULL;
> -		return ops->vidioc_try_fmt_vid_overlay(file, NULL, arg);
> +		return ops->vidioc_try_fmt_vid_overlay(file, state, arg);
>  	case V4L2_BUF_TYPE_VBI_CAPTURE:
>  		if (unlikely(!ops->vidioc_try_fmt_vbi_cap))
>  			break;
>  		memset_after(p, 0, fmt.vbi.flags);
> -		return ops->vidioc_try_fmt_vbi_cap(file, NULL, arg);
> +		return ops->vidioc_try_fmt_vbi_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
>  		if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_cap))
>  			break;
>  		memset_after(p, 0, fmt.sliced.io_size);
> -		return ops->vidioc_try_fmt_sliced_vbi_cap(file, NULL, arg);
> +		return ops->vidioc_try_fmt_sliced_vbi_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
>  		if (unlikely(!ops->vidioc_try_fmt_vid_out))
>  			break;
>  		memset_after(p, 0, fmt.pix);
> -		ret = ops->vidioc_try_fmt_vid_out(file, NULL, arg);
> +		ret = ops->vidioc_try_fmt_vid_out(file, state, arg);
>  		/* just in case the driver zeroed it again */
>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>  		return ret;
> @@ -1913,7 +1913,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
>  			memset_after(&p->fmt.pix_mp.plane_fmt[i],
>  				     0, bytesperline);
> -		return ops->vidioc_try_fmt_vid_out_mplane(file, NULL, arg);
> +		return ops->vidioc_try_fmt_vid_out_mplane(file, state, arg);
>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
>  		if (unlikely(!ops->vidioc_try_fmt_vid_out_overlay))
>  			break;
> @@ -1921,55 +1921,55 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		p->fmt.win.clips = NULL;
>  		p->fmt.win.clipcount = 0;
>  		p->fmt.win.bitmap = NULL;
> -		return ops->vidioc_try_fmt_vid_out_overlay(file, NULL, arg);
> +		return ops->vidioc_try_fmt_vid_out_overlay(file, state, arg);
>  	case V4L2_BUF_TYPE_VBI_OUTPUT:
>  		if (unlikely(!ops->vidioc_try_fmt_vbi_out))
>  			break;
>  		memset_after(p, 0, fmt.vbi.flags);
> -		return ops->vidioc_try_fmt_vbi_out(file, NULL, arg);
> +		return ops->vidioc_try_fmt_vbi_out(file, state, arg);
>  	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
>  		if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_out))
>  			break;
>  		memset_after(p, 0, fmt.sliced.io_size);
> -		return ops->vidioc_try_fmt_sliced_vbi_out(file, NULL, arg);
> +		return ops->vidioc_try_fmt_sliced_vbi_out(file, state, arg);
>  	case V4L2_BUF_TYPE_SDR_CAPTURE:
>  		if (unlikely(!ops->vidioc_try_fmt_sdr_cap))
>  			break;
>  		memset_after(p, 0, fmt.sdr.buffersize);
> -		return ops->vidioc_try_fmt_sdr_cap(file, NULL, arg);
> +		return ops->vidioc_try_fmt_sdr_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_SDR_OUTPUT:
>  		if (unlikely(!ops->vidioc_try_fmt_sdr_out))
>  			break;
>  		memset_after(p, 0, fmt.sdr.buffersize);
> -		return ops->vidioc_try_fmt_sdr_out(file, NULL, arg);
> +		return ops->vidioc_try_fmt_sdr_out(file, state, arg);
>  	case V4L2_BUF_TYPE_META_CAPTURE:
>  		if (unlikely(!ops->vidioc_try_fmt_meta_cap))
>  			break;
>  		memset_after(p, 0, fmt.meta);
> -		return ops->vidioc_try_fmt_meta_cap(file, NULL, arg);
> +		return ops->vidioc_try_fmt_meta_cap(file, state, arg);
>  	case V4L2_BUF_TYPE_META_OUTPUT:
>  		if (unlikely(!ops->vidioc_try_fmt_meta_out))
>  			break;
>  		memset_after(p, 0, fmt.meta);
> -		return ops->vidioc_try_fmt_meta_out(file, NULL, arg);
> +		return ops->vidioc_try_fmt_meta_out(file, state, arg);
>  	}
>  	return -EINVAL;
>  }
>  
>  static int v4l_streamon(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			void *arg)
> +			struct video_device_state *state, void *arg)
>  {
> -	return ops->vidioc_streamon(file, NULL, *(unsigned int *)arg);
> +	return ops->vidioc_streamon(file, state, *(unsigned int *)arg);
>  }
>  
>  static int v4l_streamoff(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			 void *arg)
> +			 struct video_device_state *state, void *arg)
>  {
> -	return ops->vidioc_streamoff(file, NULL, *(unsigned int *)arg);
> +	return ops->vidioc_streamoff(file, state, *(unsigned int *)arg);
>  }
>  
>  static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		       void *arg)
> +		       struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_tuner *p = arg;
> @@ -1977,14 +1977,14 @@ static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
>  
>  	p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
>  			V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
> -	err = ops->vidioc_g_tuner(file, NULL, p);
> +	err = ops->vidioc_g_tuner(file, state, p);
>  	if (!err)
>  		p->capability |= V4L2_TUNER_CAP_FREQ_BANDS;
>  	return err;
>  }
>  
>  static int v4l_s_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		       void *arg)
> +		       struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_tuner *p = arg;
> @@ -1995,11 +1995,11 @@ static int v4l_s_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		return ret;
>  	p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
>  			V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
> -	return ops->vidioc_s_tuner(file, NULL, p);
> +	return ops->vidioc_s_tuner(file, state, p);
>  }
>  
> -static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_modulator *p = arg;
> @@ -2008,14 +2008,14 @@ static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops,
>  	if (vfd->vfl_type == VFL_TYPE_RADIO)
>  		p->type = V4L2_TUNER_RADIO;
>  
> -	err = ops->vidioc_g_modulator(file, NULL, p);
> +	err = ops->vidioc_g_modulator(file, state, p);
>  	if (!err)
>  		p->capability |= V4L2_TUNER_CAP_FREQ_BANDS;
>  	return err;
>  }
>  
> -static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_modulator *p = arg;
> @@ -2023,11 +2023,11 @@ static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops,
>  	if (vfd->vfl_type == VFL_TYPE_RADIO)
>  		p->type = V4L2_TUNER_RADIO;
>  
> -	return ops->vidioc_s_modulator(file, NULL, p);
> +	return ops->vidioc_s_modulator(file, state, p);
>  }
>  
> -static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_frequency *p = arg;
> @@ -2037,11 +2037,11 @@ static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops,
>  	else
>  		p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
>  				V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
> -	return ops->vidioc_g_frequency(file, NULL, p);
> +	return ops->vidioc_g_frequency(file, state, p);
>  }
>  
> -static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	const struct v4l2_frequency *p = arg;
> @@ -2060,11 +2060,11 @@ static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops,
>  		if (type != p->type)
>  			return -EINVAL;
>  	}
> -	return ops->vidioc_s_frequency(file, NULL, p);
> +	return ops->vidioc_s_frequency(file, state, p);
>  }
>  
>  static int v4l_enumstd(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		       void *arg)
> +		       struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_standard *p = arg;
> @@ -2073,7 +2073,7 @@ static int v4l_enumstd(const struct v4l2_ioctl_ops *ops, struct file *file,
>  }
>  
>  static int v4l_s_std(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		     void *arg)
> +		     struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	v4l2_std_id id = *(v4l2_std_id *)arg, norm;
> @@ -2087,11 +2087,11 @@ static int v4l_s_std(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		return -EINVAL;
>  
>  	/* Calls the specific handler */
> -	return ops->vidioc_s_std(file, NULL, norm);
> +	return ops->vidioc_s_std(file, state, norm);
>  }
>  
>  static int v4l_querystd(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			void *arg)
> +			struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	v4l2_std_id *p = arg;
> @@ -2109,11 +2109,12 @@ static int v4l_querystd(const struct v4l2_ioctl_ops *ops, struct file *file,
>  	 * their efforts to improve the standards detection.
>  	 */
>  	*p = vfd->tvnorms;
> -	return ops->vidioc_querystd(file, NULL, arg);
> +	return ops->vidioc_querystd(file, state, arg);
>  }
>  
>  static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops *ops,
> -			      struct file *file, void *arg)
> +			      struct file *file,
> +			      struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_hw_freq_seek *p = arg;
> @@ -2131,26 +2132,26 @@ static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops *ops,
>  		V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
>  	if (p->type != type)
>  		return -EINVAL;
> -	return ops->vidioc_s_hw_freq_seek(file, NULL, p);
> +	return ops->vidioc_s_hw_freq_seek(file, state, p);
>  }
>  
>  static int v4l_s_fbuf(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		      void *arg)
> +		      struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_framebuffer *p = arg;
>  
>  	p->base = NULL;
> -	return ops->vidioc_s_fbuf(file, NULL, p);
> +	return ops->vidioc_s_fbuf(file, state, p);
>  }
>  
>  static int v4l_overlay(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		       void *arg)
> +		       struct video_device_state *state, void *arg)
>  {
> -	return ops->vidioc_overlay(file, NULL, *(unsigned int *)arg);
> +	return ops->vidioc_overlay(file, state, *(unsigned int *)arg);
>  }
>  
>  static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		       void *arg)
> +		       struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_requestbuffers *p = arg;
> @@ -2165,38 +2166,38 @@ static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops, struct file *file,
>  	if (is_valid_ioctl(vfd, VIDIOC_REMOVE_BUFS))
>  		p->capabilities = V4L2_BUF_CAP_SUPPORTS_REMOVE_BUFS;
>  
> -	return ops->vidioc_reqbufs(file, NULL, p);
> +	return ops->vidioc_reqbufs(file, state, p);
>  }
>  
>  static int v4l_querybuf(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			void *arg)
> +			struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_buffer *p = arg;
>  	int ret = check_fmt(file, p->type);
>  
> -	return ret ? ret : ops->vidioc_querybuf(file, NULL, p);
> +	return ret ? ret : ops->vidioc_querybuf(file, state, p);
>  }
>  
>  static int v4l_qbuf(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		    void *arg)
> +		    struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_buffer *p = arg;
>  	int ret = check_fmt(file, p->type);
>  
> -	return ret ? ret : ops->vidioc_qbuf(file, NULL, p);
> +	return ret ? ret : ops->vidioc_qbuf(file, state, p);
>  }
>  
>  static int v4l_dqbuf(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		     void *arg)
> +		     struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_buffer *p = arg;
>  	int ret = check_fmt(file, p->type);
>  
> -	return ret ? ret : ops->vidioc_dqbuf(file, NULL, p);
> +	return ret ? ret : ops->vidioc_dqbuf(file, state, p);
>  }
>  
> -static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_create_buffers *create = arg;
> @@ -2213,7 +2214,7 @@ static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
>  	if (is_valid_ioctl(vfd, VIDIOC_REMOVE_BUFS))
>  		create->capabilities = V4L2_BUF_CAP_SUPPORTS_REMOVE_BUFS;
>  
> -	ret = ops->vidioc_create_bufs(file, NULL, create);
> +	ret = ops->vidioc_create_bufs(file, state, create);
>  
>  	if (create->format.type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
>  	    create->format.type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> @@ -2222,28 +2223,28 @@ static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
>  	return ret;
>  }
>  
> -static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_buffer *b = arg;
>  	int ret = check_fmt(file, b->type);
>  
> -	return ret ? ret : ops->vidioc_prepare_buf(file, NULL, b);
> +	return ret ? ret : ops->vidioc_prepare_buf(file, state, b);
>  }
>  
> -static int v4l_remove_bufs(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_remove_bufs(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_remove_buffers *remove = arg;
>  
>  	if (ops->vidioc_remove_bufs)
> -		return ops->vidioc_remove_bufs(file, NULL, remove);
> +		return ops->vidioc_remove_bufs(file, state, remove);
>  
>  	return -ENOTTY;
>  }
>  
>  static int v4l_g_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		      void *arg)
> +		      struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_streamparm *p = arg;
> @@ -2253,20 +2254,20 @@ static int v4l_g_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
>  	if (ret)
>  		return ret;
>  	if (ops->vidioc_g_parm)
> -		return ops->vidioc_g_parm(file, NULL, p);
> +		return ops->vidioc_g_parm(file, state, p);
>  	if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
>  	    p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
>  		return -EINVAL;
>  	if (vfd->device_caps & V4L2_CAP_READWRITE)
>  		p->parm.capture.readbuffers = 2;
> -	ret = ops->vidioc_g_std(file, NULL, &std);
> +	ret = ops->vidioc_g_std(file, state, &std);
>  	if (ret == 0)
>  		v4l2_video_std_frame_period(std, &p->parm.capture.timeperframe);
>  	return ret;
>  }
>  
>  static int v4l_s_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		      void *arg)
> +		      struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_streamparm *p = arg;
>  	int ret = check_fmt(file, p->type);
> @@ -2286,11 +2287,11 @@ static int v4l_s_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		p->parm.capture.extendedmode = 0;
>  		p->parm.capture.capturemode &= V4L2_MODE_HIGHQUALITY;
>  	}
> -	return ops->vidioc_s_parm(file, NULL, p);
> +	return ops->vidioc_s_parm(file, state, p);
>  }
>  
>  static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			 void *arg)
> +			 struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_query_ext_ctrl qec = {};
> @@ -2307,7 +2308,7 @@ static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>  
>  	/* Simulate query_ext_ctr using query_ctrl. */
>  	qec.id = p->id;
> -	ret = ops->vidioc_query_ext_ctrl(file, NULL, &qec);
> +	ret = ops->vidioc_query_ext_ctrl(file, state, &qec);
>  	if (ret)
>  		return ret;
>  	v4l2_query_ext_ctrl_to_v4l2_queryctrl(p, &qec);
> @@ -2315,7 +2316,8 @@ static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>  }
>  
>  static int v4l_query_ext_ctrl(const struct v4l2_ioctl_ops *ops,
> -			      struct file *file, void *arg)
> +			      struct file *file,
> +			      struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_query_ext_ctrl *p = arg;
> @@ -2326,12 +2328,12 @@ static int v4l_query_ext_ctrl(const struct v4l2_ioctl_ops *ops,
>  	if (vfd->ctrl_handler)
>  		return v4l2_query_ext_ctrl(vfd->ctrl_handler, p);
>  	if (ops->vidioc_query_ext_ctrl)
> -		return ops->vidioc_query_ext_ctrl(file, NULL, p);
> +		return ops->vidioc_query_ext_ctrl(file, state, p);
>  	return -ENOTTY;
>  }
>  
>  static int v4l_querymenu(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			 void *arg)
> +			 struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_querymenu *p = arg;
> @@ -2342,12 +2344,12 @@ static int v4l_querymenu(const struct v4l2_ioctl_ops *ops, struct file *file,
>  	if (vfd->ctrl_handler)
>  		return v4l2_querymenu(vfd->ctrl_handler, p);
>  	if (ops->vidioc_querymenu)
> -		return ops->vidioc_querymenu(file, NULL, p);
> +		return ops->vidioc_querymenu(file, state, p);
>  	return -ENOTTY;
>  }
>  
>  static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		      void *arg)
> +		      struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_control *p = arg;
> @@ -2368,7 +2370,7 @@ static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>  	ctrl.id = p->id;
>  	ctrl.value = p->value;
>  	if (check_ext_ctrls(&ctrls, VIDIOC_G_CTRL)) {
> -		int ret = ops->vidioc_g_ext_ctrls(file, NULL, &ctrls);
> +		int ret = ops->vidioc_g_ext_ctrls(file, state, &ctrls);
>  
>  		if (ret == 0)
>  			p->value = ctrl.value;
> @@ -2378,7 +2380,7 @@ static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>  }
>  
>  static int v4l_s_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		      void *arg)
> +		      struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_control *p = arg;
> @@ -2401,13 +2403,13 @@ static int v4l_s_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>  	ctrl.value = p->value;
>  	if (!check_ext_ctrls(&ctrls, VIDIOC_S_CTRL))
>  		return -EINVAL;
> -	ret = ops->vidioc_s_ext_ctrls(file, NULL, &ctrls);
> +	ret = ops->vidioc_s_ext_ctrls(file, state, &ctrls);
>  	p->value = ctrl.value;
>  	return ret;
>  }
>  
> -static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_ext_controls *p = arg;
> @@ -2423,11 +2425,11 @@ static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>  	if (ops->vidioc_g_ext_ctrls == NULL)
>  		return -ENOTTY;
>  	return check_ext_ctrls(p, VIDIOC_G_EXT_CTRLS) ?
> -				ops->vidioc_g_ext_ctrls(file, NULL, p) : -EINVAL;
> +				ops->vidioc_g_ext_ctrls(file, state, p) : -EINVAL;
>  }
>  
> -static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_ext_controls *p = arg;
> @@ -2443,11 +2445,12 @@ static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>  	if (ops->vidioc_s_ext_ctrls == NULL)
>  		return -ENOTTY;
>  	return check_ext_ctrls(p, VIDIOC_S_EXT_CTRLS) ?
> -				ops->vidioc_s_ext_ctrls(file, NULL, p) : -EINVAL;
> +				ops->vidioc_s_ext_ctrls(file, state, p) : -EINVAL;
>  }
>  
>  static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
> -			     struct file *file, void *arg)
> +			     struct file *file,
> +			     struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_ext_controls *p = arg;
> @@ -2463,7 +2466,7 @@ static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>  	if (ops->vidioc_try_ext_ctrls == NULL)
>  		return -ENOTTY;
>  	return check_ext_ctrls(p, VIDIOC_TRY_EXT_CTRLS) ?
> -			ops->vidioc_try_ext_ctrls(file, NULL, p) : -EINVAL;
> +			ops->vidioc_try_ext_ctrls(file, state, p) : -EINVAL;
>  }
>  
>  /*
> @@ -2475,8 +2478,8 @@ static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>   * restore it afterwards. This way applications can use either buffer
>   * type and drivers don't need to check for both.
>   */
> -static int v4l_g_selection(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_g_selection(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_selection *p = arg;
>  	u32 old_type = p->type;
> @@ -2486,13 +2489,13 @@ static int v4l_g_selection(const struct v4l2_ioctl_ops *ops,
>  		p->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
>  	else if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
>  		p->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
> -	ret = ops->vidioc_g_selection(file, NULL, p);
> +	ret = ops->vidioc_g_selection(file, state, p);
>  	p->type = old_type;
>  	return ret;
>  }
>  
> -static int v4l_s_selection(const struct v4l2_ioctl_ops *ops,
> -			   struct file *file, void *arg)
> +static int v4l_s_selection(const struct v4l2_ioctl_ops *ops, struct file *file,
> +			   struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_selection *p = arg;
>  	u32 old_type = p->type;
> @@ -2502,13 +2505,13 @@ static int v4l_s_selection(const struct v4l2_ioctl_ops *ops,
>  		p->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
>  	else if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
>  		p->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
> -	ret = ops->vidioc_s_selection(file, NULL, p);
> +	ret = ops->vidioc_s_selection(file, state, p);
>  	p->type = old_type;
>  	return ret;
>  }
>  
>  static int v4l_g_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		      void *arg)
> +		      struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_crop *p = arg;
> @@ -2529,7 +2532,7 @@ static int v4l_g_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		s.target = s.target == V4L2_SEL_TGT_COMPOSE ?
>  			V4L2_SEL_TGT_CROP : V4L2_SEL_TGT_COMPOSE;
>  
> -	ret = v4l_g_selection(ops, file, &s);
> +	ret = v4l_g_selection(ops, file, state, &s);
>  
>  	/* copying results to old structure on success */
>  	if (!ret)
> @@ -2538,7 +2541,7 @@ static int v4l_g_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
>  }
>  
>  static int v4l_s_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		      void *arg)
> +		      struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_crop *p = arg;
> @@ -2559,11 +2562,11 @@ static int v4l_s_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		s.target = s.target == V4L2_SEL_TGT_COMPOSE ?
>  			V4L2_SEL_TGT_CROP : V4L2_SEL_TGT_COMPOSE;
>  
> -	return v4l_s_selection(ops, file, &s);
> +	return v4l_s_selection(ops, file, state, &s);
>  }
>  
>  static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		       void *arg)
> +		       struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_cropcap *p = arg;
> @@ -2587,7 +2590,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		return -ENOTTY;
>  
>  	if (ops->vidioc_g_pixelaspect)
> -		ret = ops->vidioc_g_pixelaspect(file, NULL, s.type,
> +		ret = ops->vidioc_g_pixelaspect(file, state, s.type,
>  						&p->pixelaspect);
>  
>  	/*
> @@ -2609,7 +2612,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
>  		s.target = s.target == V4L2_SEL_TGT_COMPOSE_BOUNDS ?
>  			V4L2_SEL_TGT_CROP_BOUNDS : V4L2_SEL_TGT_COMPOSE_BOUNDS;
>  
> -	ret = v4l_g_selection(ops, file, &s);
> +	ret = v4l_g_selection(ops, file, state, &s);
>  	if (ret)
>  		return ret;
>  	p->bounds = s.r;
> @@ -2620,7 +2623,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
>  	else
>  		s.target = V4L2_SEL_TGT_CROP_DEFAULT;
>  
> -	ret = v4l_g_selection(ops, file, &s);
> +	ret = v4l_g_selection(ops, file, state, &s);
>  	if (ret)
>  		return ret;
>  	p->defrect = s.r;
> @@ -2629,7 +2632,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
>  }
>  
>  static int v4l_log_status(const struct v4l2_ioctl_ops *ops, struct file *file,
> -			  void *arg)
> +			  struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	int ret;
> @@ -2637,7 +2640,7 @@ static int v4l_log_status(const struct v4l2_ioctl_ops *ops, struct file *file,
>  	if (vfd->v4l2_dev)
>  		pr_info("%s: =================  START STATUS  =================\n",
>  			vfd->v4l2_dev->name);
> -	ret = ops->vidioc_log_status(file, NULL);
> +	ret = ops->vidioc_log_status(file, state);
>  	if (vfd->v4l2_dev)
>  		pr_info("%s: ==================  END STATUS  ==================\n",
>  			vfd->v4l2_dev->name);
> @@ -2645,7 +2648,8 @@ static int v4l_log_status(const struct v4l2_ioctl_ops *ops, struct file *file,
>  }
>  
>  static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
> -			      struct file *file, void *arg)
> +			      struct file *file,
> +			      struct video_device_state *state, void *arg)
>  {
>  #ifdef CONFIG_VIDEO_ADV_DEBUG
>  	struct v4l2_dbg_register *p = arg;
> @@ -2665,7 +2669,7 @@ static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
>  	}
>  	if (ops->vidioc_g_register && p->match.type == V4L2_CHIP_MATCH_BRIDGE &&
>  	    (ops->vidioc_g_chip_info || p->match.addr == 0))
> -		return ops->vidioc_g_register(file, NULL, p);
> +		return ops->vidioc_g_register(file, state, p);
>  	return -EINVAL;
>  #else
>  	return -ENOTTY;
> @@ -2673,7 +2677,8 @@ static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
>  }
>  
>  static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
> -			      struct file *file, void *arg)
> +			      struct file *file,
> +			      struct video_device_state *state, void *arg)
>  {
>  #ifdef CONFIG_VIDEO_ADV_DEBUG
>  	const struct v4l2_dbg_register *p = arg;
> @@ -2693,7 +2698,7 @@ static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
>  	}
>  	if (ops->vidioc_s_register && p->match.type == V4L2_CHIP_MATCH_BRIDGE &&
>  	    (ops->vidioc_g_chip_info || p->match.addr == 0))
> -		return ops->vidioc_s_register(file, NULL, p);
> +		return ops->vidioc_s_register(file, state, p);
>  	return -EINVAL;
>  #else
>  	return -ENOTTY;
> @@ -2701,7 +2706,8 @@ static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
>  }
>  
>  static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops,
> -			       struct file *file, void *arg)
> +			       struct file *file,
> +			       struct video_device_state *state, void *arg)
>  {
>  #ifdef CONFIG_VIDEO_ADV_DEBUG
>  	struct video_device *vfd = video_devdata(file);
> @@ -2717,7 +2723,7 @@ static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops,
>  			p->flags |= V4L2_CHIP_FL_READABLE;
>  		strscpy(p->name, vfd->v4l2_dev->name, sizeof(p->name));
>  		if (ops->vidioc_g_chip_info)
> -			return ops->vidioc_g_chip_info(file, NULL, arg);
> +			return ops->vidioc_g_chip_info(file, state, arg);
>  		if (p->match.addr)
>  			return -EINVAL;
>  		return 0;
> @@ -2744,7 +2750,7 @@ static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops,
>  }
>  
>  static int v4l_dqevent(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		       void *arg)
> +		       struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
>  
> @@ -2752,7 +2758,8 @@ static int v4l_dqevent(const struct v4l2_ioctl_ops *ops, struct file *file,
>  }
>  
>  static int v4l_subscribe_event(const struct v4l2_ioctl_ops *ops,
> -			       struct file *file, void *arg)
> +			       struct file *file,
> +			       struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
>  
> @@ -2760,7 +2767,8 @@ static int v4l_subscribe_event(const struct v4l2_ioctl_ops *ops,
>  }
>  
>  static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops *ops,
> -				 struct file *file, void *arg)
> +				 struct file *file,
> +				 struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
>  
> @@ -2768,7 +2776,8 @@ static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops *ops,
>  }
>  
>  static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops *ops,
> -				struct file *file, void *arg)
> +				struct file *file,
> +				struct video_device_state *state, void *arg)
>  {
>  	struct v4l2_sliced_vbi_cap *p = arg;
>  	int ret = check_fmt(file, p->type);
> @@ -2779,11 +2788,12 @@ static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops *ops,
>  	/* Clear up to type, everything after type is zeroed already */
>  	memset(p, 0, offsetof(struct v4l2_sliced_vbi_cap, type));
>  
> -	return ops->vidioc_g_sliced_vbi_cap(file, NULL, p);
> +	return ops->vidioc_g_sliced_vbi_cap(file, state, p);
>  }
>  
>  static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
> -			       struct file *file, void *arg)
> +			       struct file *file,
> +			       struct video_device_state *state, void *arg)
>  {
>  	struct video_device *vfd = video_devdata(file);
>  	struct v4l2_frequency_band *p = arg;
> @@ -2801,7 +2811,7 @@ static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
>  			return -EINVAL;
>  	}
>  	if (ops->vidioc_enum_freq_bands) {
> -		err = ops->vidioc_enum_freq_bands(file, NULL, p);
> +		err = ops->vidioc_enum_freq_bands(file, state, p);
>  		if (err != -ENOTTY)
>  			return err;
>  	}
> @@ -2813,7 +2823,7 @@ static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
>  
>  		if (p->index)
>  			return -EINVAL;
> -		err = ops->vidioc_g_tuner(file, NULL, &t);
> +		err = ops->vidioc_g_tuner(file, state, &t);
>  		if (err)
>  			return err;
>  		p->capability = t.capability | V4L2_TUNER_CAP_FREQ_BANDS;
> @@ -2832,7 +2842,7 @@ static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
>  			return -EINVAL;
>  		if (p->index)
>  			return -EINVAL;
> -		err = ops->vidioc_g_modulator(file, NULL, &m);
> +		err = ops->vidioc_g_modulator(file, state, &m);
>  		if (err)
>  			return err;
>  		p->capability = m.capability | V4L2_TUNER_CAP_FREQ_BANDS;
> @@ -2849,7 +2859,7 @@ struct v4l2_ioctl_info {
>  	u32 flags;
>  	const char * const name;
>  	int (*func)(const struct v4l2_ioctl_ops *ops, struct file *file,
> -		    void *p);
> +		    struct video_device_state *state, void *p);
>  	void (*debug)(const void *arg, bool write_only);
>  };
>  
> @@ -2870,7 +2880,9 @@ struct v4l2_ioctl_info {
>  #define DEFINE_V4L_STUB_FUNC(_vidioc)				\
>  	static int v4l_stub_ ## _vidioc(			\
>  			const struct v4l2_ioctl_ops *ops,	\
> -			struct file *file, void *p)		\
> +			struct file *file,			\
> +			struct video_device_state *state,	\
> +			void *p)				\
>  	{							\
>  		return ops->vidioc_ ## _vidioc(file, NULL, p);	\
>  	}
> @@ -3126,7 +3138,7 @@ static long __video_do_ioctl(struct file *file,
>  
>  	write_only = _IOC_DIR(cmd) == _IOC_WRITE;
>  	if (info != &default_info) {
> -		ret = info->func(ops, file, arg);
> +		ret = info->func(ops, file, NULL, arg);
>  	} else if (!ops->vidioc_default) {
>  		ret = -ENOTTY;
>  	} else {
>
Re: [PATCH v2 05/10] media: v4l2-ioctl: Add video_device_state argument to v4l2 ioctl wrappers
Posted by Hans Verkuil 1 week, 2 days ago 
On 22/09/2025 10:09, Hans Verkuil wrote:
> On 19/09/2025 11:55, Jai Luthra wrote:
>> Add a third argument to all v4l2 ioctl wrappers to pass struct
>> video_device_state * directly, replacing the previous opaque pointer
>> approach.
>>
>> Currently, this argument is populated with NULL since existing driver
>> hooks still expect a void *priv argument. This will be addressed in a
>> subsequent patch.
> 
> There is one more occurrance of this in v4l2_compat_ioctl32.c in function
> ctrl_is_pointer() where vidioc_query_ext_ctrl is called.

Ignore this, this doesn't apply to this patch.

> 
> Regards,
> 
> 	Hans
> 
>>
>> Most changes to the ioctl wrappers were generated using the following
>> Coccinelle semantic patch:
>>
>> @ioctl@
>> identifier v4l2_ioctls;
>> identifier ioctl;
>> identifier fn;
>> identifier debug;
>> expression flags;
>> @@
>> struct v4l2_ioctl_info v4l2_ioctls[] = {
>> 	...,
>> 	IOCTL_INFO(ioctl, fn, debug, flags),
>> 	...,
>> };
>>
>> @depends on ioctl@
>> identifier ioctl.fn;
>> identifier ops;
>> identifier file;
>> identifier arg;
>> identifier handler;
>> expression list args;
>> @@
>> -int fn(const struct v4l2_ioctl_ops *ops, struct file *file, void *arg)
>> +int fn(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +       struct video_device_state *state, void *arg)
>> {
>> 	<...
>> -	ops->handler(file, NULL, args)
>> +	ops->handler(file, state, args)
>> 	...>
>> }
>>
>> Manual changes were made to handle calls to v4l_[gs]_selection, update
>> the v4l2_ioctl_info structure definition and macros, fix argument
>> wrapping in some function definitions, and handle the common function
>> pointer in v4l2_ioctl_info.
>>
>> Signed-off-by: Jai Luthra <jai.luthra@ideasonboard.com>
>> --
>> Cc: Mauro Carvalho Chehab <mchehab@kernel.org>
>> Cc: Hans Verkuil <hverkuil@kernel.org>
>> Cc: Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com>
>> Cc: Ricardo Ribalda <ribalda@chromium.org>
>> Cc: Hans de Goede <hansg@kernel.org>
>> Cc: Jai Luthra <jai.luthra@ideasonboard.com>
>> Cc: linux-media@vger.kernel.org
>> Cc: linux-kernel@vger.kernel.org
>> ---
>>  drivers/media/v4l2-core/v4l2-ioctl.c | 360 ++++++++++++++++++-----------------
>>  1 file changed, 186 insertions(+), 174 deletions(-)
>>
>> diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
>> index 01cf52c3ea33e1a01e1b306036ba4e57ef5c95d0..644f06521673ff7ce5b194335d50f0e375ca7f51 100644
>> --- a/drivers/media/v4l2-core/v4l2-ioctl.c
>> +++ b/drivers/media/v4l2-core/v4l2-ioctl.c
>> @@ -1090,7 +1090,7 @@ static void v4l_sanitize_format(struct v4l2_format *fmt)
>>  }
>>  
>>  static int v4l_querycap(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			void *arg)
>> +			struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_capability *cap = (struct v4l2_capability *)arg;
>>  	struct video_device *vfd = video_devdata(file);
>> @@ -1103,7 +1103,7 @@ static int v4l_querycap(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  	media_set_bus_info(cap->bus_info, sizeof(cap->bus_info),
>>  			   vfd->dev_parent);
>>  
>> -	ret = ops->vidioc_querycap(file, NULL, cap);
>> +	ret = ops->vidioc_querycap(file, state, cap);
>>  
>>  	/*
>>  	 * Drivers must not change device_caps, so check for this and
>> @@ -1124,7 +1124,7 @@ static int v4l_querycap(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  }
>>  
>>  static int v4l_g_input(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		       void *arg)
>> +		       struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  
>> @@ -1133,11 +1133,11 @@ static int v4l_g_input(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		return 0;
>>  	}
>>  
>> -	return ops->vidioc_g_input(file, NULL, arg);
>> +	return ops->vidioc_g_input(file, state, arg);
>>  }
>>  
>>  static int v4l_g_output(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			void *arg)
>> +			struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  
>> @@ -1146,11 +1146,11 @@ static int v4l_g_output(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		return 0;
>>  	}
>>  
>> -	return ops->vidioc_g_output(file, NULL, arg);
>> +	return ops->vidioc_g_output(file, state, arg);
>>  }
>>  
>>  static int v4l_s_input(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		       void *arg)
>> +		       struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	int ret;
>> @@ -1162,22 +1162,22 @@ static int v4l_s_input(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  	if (vfd->device_caps & V4L2_CAP_IO_MC)
>>  		return  *(int *)arg ? -EINVAL : 0;
>>  
>> -	return ops->vidioc_s_input(file, NULL, *(unsigned int *)arg);
>> +	return ops->vidioc_s_input(file, state, *(unsigned int *)arg);
>>  }
>>  
>>  static int v4l_s_output(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			void *arg)
>> +			struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  
>>  	if (vfd->device_caps & V4L2_CAP_IO_MC)
>>  		return  *(int *)arg ? -EINVAL : 0;
>>  
>> -	return ops->vidioc_s_output(file, NULL, *(unsigned int *)arg);
>> +	return ops->vidioc_s_output(file, state, *(unsigned int *)arg);
>>  }
>>  
>>  static int v4l_g_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			  void *arg)
>> +			  struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd;
>>  	u32 *p = arg;
>> @@ -1188,7 +1188,7 @@ static int v4l_g_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  }
>>  
>>  static int v4l_s_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			  void *arg)
>> +			  struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd;
>>  	struct v4l2_fh *vfh;
>> @@ -1200,7 +1200,7 @@ static int v4l_s_priority(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  }
>>  
>>  static int v4l_enuminput(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			 void *arg)
>> +			 struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_input *p = arg;
>> @@ -1222,11 +1222,11 @@ static int v4l_enuminput(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		return 0;
>>  	}
>>  
>> -	return ops->vidioc_enum_input(file, NULL, p);
>> +	return ops->vidioc_enum_input(file, state, p);
>>  }
>>  
>>  static int v4l_enumoutput(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			  void *arg)
>> +			  struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_output *p = arg;
>> @@ -1248,7 +1248,7 @@ static int v4l_enumoutput(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		return 0;
>>  	}
>>  
>> -	return ops->vidioc_enum_output(file, NULL, p);
>> +	return ops->vidioc_enum_output(file, state, p);
>>  }
>>  
>>  static void v4l_fill_fmtdesc(struct v4l2_fmtdesc *fmt)
>> @@ -1588,7 +1588,7 @@ static void v4l_fill_fmtdesc(struct v4l2_fmtdesc *fmt)
>>  }
>>  
>>  static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			void *arg)
>> +			struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vdev = video_devdata(file);
>>  	struct v4l2_fmtdesc *p = arg;
>> @@ -1618,12 +1618,12 @@ static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  
>>  		if (unlikely(!ops->vidioc_enum_fmt_vid_cap))
>>  			break;
>> -		ret = ops->vidioc_enum_fmt_vid_cap(file, NULL, arg);
>> +		ret = ops->vidioc_enum_fmt_vid_cap(file, state, arg);
>>  		break;
>>  	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
>>  		if (unlikely(!ops->vidioc_enum_fmt_vid_overlay))
>>  			break;
>> -		ret = ops->vidioc_enum_fmt_vid_overlay(file, NULL, arg);
>> +		ret = ops->vidioc_enum_fmt_vid_overlay(file, state, arg);
>>  		break;
>>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
>>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
>> @@ -1635,27 +1635,27 @@ static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  
>>  		if (unlikely(!ops->vidioc_enum_fmt_vid_out))
>>  			break;
>> -		ret = ops->vidioc_enum_fmt_vid_out(file, NULL, arg);
>> +		ret = ops->vidioc_enum_fmt_vid_out(file, state, arg);
>>  		break;
>>  	case V4L2_BUF_TYPE_SDR_CAPTURE:
>>  		if (unlikely(!ops->vidioc_enum_fmt_sdr_cap))
>>  			break;
>> -		ret = ops->vidioc_enum_fmt_sdr_cap(file, NULL, arg);
>> +		ret = ops->vidioc_enum_fmt_sdr_cap(file, state, arg);
>>  		break;
>>  	case V4L2_BUF_TYPE_SDR_OUTPUT:
>>  		if (unlikely(!ops->vidioc_enum_fmt_sdr_out))
>>  			break;
>> -		ret = ops->vidioc_enum_fmt_sdr_out(file, NULL, arg);
>> +		ret = ops->vidioc_enum_fmt_sdr_out(file, state, arg);
>>  		break;
>>  	case V4L2_BUF_TYPE_META_CAPTURE:
>>  		if (unlikely(!ops->vidioc_enum_fmt_meta_cap))
>>  			break;
>> -		ret = ops->vidioc_enum_fmt_meta_cap(file, NULL, arg);
>> +		ret = ops->vidioc_enum_fmt_meta_cap(file, state, arg);
>>  		break;
>>  	case V4L2_BUF_TYPE_META_OUTPUT:
>>  		if (unlikely(!ops->vidioc_enum_fmt_meta_out))
>>  			break;
>> -		ret = ops->vidioc_enum_fmt_meta_out(file, NULL, arg);
>> +		ret = ops->vidioc_enum_fmt_meta_out(file, state, arg);
>>  		break;
>>  	}
>>  	if (ret == 0)
>> @@ -1679,7 +1679,7 @@ static void v4l_pix_format_touch(struct v4l2_pix_format *p)
>>  }
>>  
>>  static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		     void *arg)
>> +		     struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_format *p = arg;
>>  	struct video_device *vfd = video_devdata(file);
>> @@ -1695,50 +1695,50 @@ static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		if (unlikely(!ops->vidioc_g_fmt_vid_cap))
>>  			break;
>>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>> -		ret = ops->vidioc_g_fmt_vid_cap(file, NULL, arg);
>> +		ret = ops->vidioc_g_fmt_vid_cap(file, state, arg);
>>  		/* just in case the driver zeroed it again */
>>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>>  		if (vfd->vfl_type == VFL_TYPE_TOUCH)
>>  			v4l_pix_format_touch(&p->fmt.pix);
>>  		return ret;
>>  	case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
>> -		return ops->vidioc_g_fmt_vid_cap_mplane(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_vid_cap_mplane(file, state, arg);
>>  	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
>> -		return ops->vidioc_g_fmt_vid_overlay(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_vid_overlay(file, state, arg);
>>  	case V4L2_BUF_TYPE_VBI_CAPTURE:
>> -		return ops->vidioc_g_fmt_vbi_cap(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_vbi_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
>> -		return ops->vidioc_g_fmt_sliced_vbi_cap(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_sliced_vbi_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
>>  		if (unlikely(!ops->vidioc_g_fmt_vid_out))
>>  			break;
>>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>> -		ret = ops->vidioc_g_fmt_vid_out(file, NULL, arg);
>> +		ret = ops->vidioc_g_fmt_vid_out(file, state, arg);
>>  		/* just in case the driver zeroed it again */
>>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>>  		return ret;
>>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
>> -		return ops->vidioc_g_fmt_vid_out_mplane(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_vid_out_mplane(file, state, arg);
>>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
>> -		return ops->vidioc_g_fmt_vid_out_overlay(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_vid_out_overlay(file, state, arg);
>>  	case V4L2_BUF_TYPE_VBI_OUTPUT:
>> -		return ops->vidioc_g_fmt_vbi_out(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_vbi_out(file, state, arg);
>>  	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
>> -		return ops->vidioc_g_fmt_sliced_vbi_out(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_sliced_vbi_out(file, state, arg);
>>  	case V4L2_BUF_TYPE_SDR_CAPTURE:
>> -		return ops->vidioc_g_fmt_sdr_cap(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_sdr_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_SDR_OUTPUT:
>> -		return ops->vidioc_g_fmt_sdr_out(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_sdr_out(file, state, arg);
>>  	case V4L2_BUF_TYPE_META_CAPTURE:
>> -		return ops->vidioc_g_fmt_meta_cap(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_meta_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_META_OUTPUT:
>> -		return ops->vidioc_g_fmt_meta_out(file, NULL, arg);
>> +		return ops->vidioc_g_fmt_meta_out(file, state, arg);
>>  	}
>>  	return -EINVAL;
>>  }
>>  
>>  static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		     void *arg)
>> +		     struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_format *p = arg;
>>  	struct video_device *vfd = video_devdata(file);
>> @@ -1758,7 +1758,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		if (unlikely(!ops->vidioc_s_fmt_vid_cap))
>>  			break;
>>  		memset_after(p, 0, fmt.pix);
>> -		ret = ops->vidioc_s_fmt_vid_cap(file, NULL, arg);
>> +		ret = ops->vidioc_s_fmt_vid_cap(file, state, arg);
>>  		/* just in case the driver zeroed it again */
>>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>>  		if (vfd->vfl_type == VFL_TYPE_TOUCH)
>> @@ -1771,7 +1771,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
>>  			memset_after(&p->fmt.pix_mp.plane_fmt[i],
>>  				     0, bytesperline);
>> -		return ops->vidioc_s_fmt_vid_cap_mplane(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_vid_cap_mplane(file, state, arg);
>>  	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
>>  		if (unlikely(!ops->vidioc_s_fmt_vid_overlay))
>>  			break;
>> @@ -1779,22 +1779,22 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		p->fmt.win.clips = NULL;
>>  		p->fmt.win.clipcount = 0;
>>  		p->fmt.win.bitmap = NULL;
>> -		return ops->vidioc_s_fmt_vid_overlay(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_vid_overlay(file, state, arg);
>>  	case V4L2_BUF_TYPE_VBI_CAPTURE:
>>  		if (unlikely(!ops->vidioc_s_fmt_vbi_cap))
>>  			break;
>>  		memset_after(p, 0, fmt.vbi.flags);
>> -		return ops->vidioc_s_fmt_vbi_cap(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_vbi_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
>>  		if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_cap))
>>  			break;
>>  		memset_after(p, 0, fmt.sliced.io_size);
>> -		return ops->vidioc_s_fmt_sliced_vbi_cap(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_sliced_vbi_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
>>  		if (unlikely(!ops->vidioc_s_fmt_vid_out))
>>  			break;
>>  		memset_after(p, 0, fmt.pix);
>> -		ret = ops->vidioc_s_fmt_vid_out(file, NULL, arg);
>> +		ret = ops->vidioc_s_fmt_vid_out(file, state, arg);
>>  		/* just in case the driver zeroed it again */
>>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>>  		return ret;
>> @@ -1805,7 +1805,7 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
>>  			memset_after(&p->fmt.pix_mp.plane_fmt[i],
>>  				     0, bytesperline);
>> -		return ops->vidioc_s_fmt_vid_out_mplane(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_vid_out_mplane(file, state, arg);
>>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
>>  		if (unlikely(!ops->vidioc_s_fmt_vid_out_overlay))
>>  			break;
>> @@ -1813,43 +1813,43 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		p->fmt.win.clips = NULL;
>>  		p->fmt.win.clipcount = 0;
>>  		p->fmt.win.bitmap = NULL;
>> -		return ops->vidioc_s_fmt_vid_out_overlay(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_vid_out_overlay(file, state, arg);
>>  	case V4L2_BUF_TYPE_VBI_OUTPUT:
>>  		if (unlikely(!ops->vidioc_s_fmt_vbi_out))
>>  			break;
>>  		memset_after(p, 0, fmt.vbi.flags);
>> -		return ops->vidioc_s_fmt_vbi_out(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_vbi_out(file, state, arg);
>>  	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
>>  		if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_out))
>>  			break;
>>  		memset_after(p, 0, fmt.sliced.io_size);
>> -		return ops->vidioc_s_fmt_sliced_vbi_out(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_sliced_vbi_out(file, state, arg);
>>  	case V4L2_BUF_TYPE_SDR_CAPTURE:
>>  		if (unlikely(!ops->vidioc_s_fmt_sdr_cap))
>>  			break;
>>  		memset_after(p, 0, fmt.sdr.buffersize);
>> -		return ops->vidioc_s_fmt_sdr_cap(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_sdr_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_SDR_OUTPUT:
>>  		if (unlikely(!ops->vidioc_s_fmt_sdr_out))
>>  			break;
>>  		memset_after(p, 0, fmt.sdr.buffersize);
>> -		return ops->vidioc_s_fmt_sdr_out(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_sdr_out(file, state, arg);
>>  	case V4L2_BUF_TYPE_META_CAPTURE:
>>  		if (unlikely(!ops->vidioc_s_fmt_meta_cap))
>>  			break;
>>  		memset_after(p, 0, fmt.meta);
>> -		return ops->vidioc_s_fmt_meta_cap(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_meta_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_META_OUTPUT:
>>  		if (unlikely(!ops->vidioc_s_fmt_meta_out))
>>  			break;
>>  		memset_after(p, 0, fmt.meta);
>> -		return ops->vidioc_s_fmt_meta_out(file, NULL, arg);
>> +		return ops->vidioc_s_fmt_meta_out(file, state, arg);
>>  	}
>>  	return -EINVAL;
>>  }
>>  
>>  static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		       void *arg)
>> +		       struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_format *p = arg;
>>  	struct video_device *vfd = video_devdata(file);
>> @@ -1866,7 +1866,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		if (unlikely(!ops->vidioc_try_fmt_vid_cap))
>>  			break;
>>  		memset_after(p, 0, fmt.pix);
>> -		ret = ops->vidioc_try_fmt_vid_cap(file, NULL, arg);
>> +		ret = ops->vidioc_try_fmt_vid_cap(file, state, arg);
>>  		/* just in case the driver zeroed it again */
>>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>>  		if (vfd->vfl_type == VFL_TYPE_TOUCH)
>> @@ -1879,7 +1879,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
>>  			memset_after(&p->fmt.pix_mp.plane_fmt[i],
>>  				     0, bytesperline);
>> -		return ops->vidioc_try_fmt_vid_cap_mplane(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_vid_cap_mplane(file, state, arg);
>>  	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
>>  		if (unlikely(!ops->vidioc_try_fmt_vid_overlay))
>>  			break;
>> @@ -1887,22 +1887,22 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		p->fmt.win.clips = NULL;
>>  		p->fmt.win.clipcount = 0;
>>  		p->fmt.win.bitmap = NULL;
>> -		return ops->vidioc_try_fmt_vid_overlay(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_vid_overlay(file, state, arg);
>>  	case V4L2_BUF_TYPE_VBI_CAPTURE:
>>  		if (unlikely(!ops->vidioc_try_fmt_vbi_cap))
>>  			break;
>>  		memset_after(p, 0, fmt.vbi.flags);
>> -		return ops->vidioc_try_fmt_vbi_cap(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_vbi_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
>>  		if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_cap))
>>  			break;
>>  		memset_after(p, 0, fmt.sliced.io_size);
>> -		return ops->vidioc_try_fmt_sliced_vbi_cap(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_sliced_vbi_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
>>  		if (unlikely(!ops->vidioc_try_fmt_vid_out))
>>  			break;
>>  		memset_after(p, 0, fmt.pix);
>> -		ret = ops->vidioc_try_fmt_vid_out(file, NULL, arg);
>> +		ret = ops->vidioc_try_fmt_vid_out(file, state, arg);
>>  		/* just in case the driver zeroed it again */
>>  		p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
>>  		return ret;
>> @@ -1913,7 +1913,7 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
>>  			memset_after(&p->fmt.pix_mp.plane_fmt[i],
>>  				     0, bytesperline);
>> -		return ops->vidioc_try_fmt_vid_out_mplane(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_vid_out_mplane(file, state, arg);
>>  	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
>>  		if (unlikely(!ops->vidioc_try_fmt_vid_out_overlay))
>>  			break;
>> @@ -1921,55 +1921,55 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		p->fmt.win.clips = NULL;
>>  		p->fmt.win.clipcount = 0;
>>  		p->fmt.win.bitmap = NULL;
>> -		return ops->vidioc_try_fmt_vid_out_overlay(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_vid_out_overlay(file, state, arg);
>>  	case V4L2_BUF_TYPE_VBI_OUTPUT:
>>  		if (unlikely(!ops->vidioc_try_fmt_vbi_out))
>>  			break;
>>  		memset_after(p, 0, fmt.vbi.flags);
>> -		return ops->vidioc_try_fmt_vbi_out(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_vbi_out(file, state, arg);
>>  	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
>>  		if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_out))
>>  			break;
>>  		memset_after(p, 0, fmt.sliced.io_size);
>> -		return ops->vidioc_try_fmt_sliced_vbi_out(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_sliced_vbi_out(file, state, arg);
>>  	case V4L2_BUF_TYPE_SDR_CAPTURE:
>>  		if (unlikely(!ops->vidioc_try_fmt_sdr_cap))
>>  			break;
>>  		memset_after(p, 0, fmt.sdr.buffersize);
>> -		return ops->vidioc_try_fmt_sdr_cap(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_sdr_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_SDR_OUTPUT:
>>  		if (unlikely(!ops->vidioc_try_fmt_sdr_out))
>>  			break;
>>  		memset_after(p, 0, fmt.sdr.buffersize);
>> -		return ops->vidioc_try_fmt_sdr_out(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_sdr_out(file, state, arg);
>>  	case V4L2_BUF_TYPE_META_CAPTURE:
>>  		if (unlikely(!ops->vidioc_try_fmt_meta_cap))
>>  			break;
>>  		memset_after(p, 0, fmt.meta);
>> -		return ops->vidioc_try_fmt_meta_cap(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_meta_cap(file, state, arg);
>>  	case V4L2_BUF_TYPE_META_OUTPUT:
>>  		if (unlikely(!ops->vidioc_try_fmt_meta_out))
>>  			break;
>>  		memset_after(p, 0, fmt.meta);
>> -		return ops->vidioc_try_fmt_meta_out(file, NULL, arg);
>> +		return ops->vidioc_try_fmt_meta_out(file, state, arg);
>>  	}
>>  	return -EINVAL;
>>  }
>>  
>>  static int v4l_streamon(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			void *arg)
>> +			struct video_device_state *state, void *arg)
>>  {
>> -	return ops->vidioc_streamon(file, NULL, *(unsigned int *)arg);
>> +	return ops->vidioc_streamon(file, state, *(unsigned int *)arg);
>>  }
>>  
>>  static int v4l_streamoff(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			 void *arg)
>> +			 struct video_device_state *state, void *arg)
>>  {
>> -	return ops->vidioc_streamoff(file, NULL, *(unsigned int *)arg);
>> +	return ops->vidioc_streamoff(file, state, *(unsigned int *)arg);
>>  }
>>  
>>  static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		       void *arg)
>> +		       struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_tuner *p = arg;
>> @@ -1977,14 +1977,14 @@ static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  
>>  	p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
>>  			V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
>> -	err = ops->vidioc_g_tuner(file, NULL, p);
>> +	err = ops->vidioc_g_tuner(file, state, p);
>>  	if (!err)
>>  		p->capability |= V4L2_TUNER_CAP_FREQ_BANDS;
>>  	return err;
>>  }
>>  
>>  static int v4l_s_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		       void *arg)
>> +		       struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_tuner *p = arg;
>> @@ -1995,11 +1995,11 @@ static int v4l_s_tuner(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		return ret;
>>  	p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
>>  			V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
>> -	return ops->vidioc_s_tuner(file, NULL, p);
>> +	return ops->vidioc_s_tuner(file, state, p);
>>  }
>>  
>> -static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_modulator *p = arg;
>> @@ -2008,14 +2008,14 @@ static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops,
>>  	if (vfd->vfl_type == VFL_TYPE_RADIO)
>>  		p->type = V4L2_TUNER_RADIO;
>>  
>> -	err = ops->vidioc_g_modulator(file, NULL, p);
>> +	err = ops->vidioc_g_modulator(file, state, p);
>>  	if (!err)
>>  		p->capability |= V4L2_TUNER_CAP_FREQ_BANDS;
>>  	return err;
>>  }
>>  
>> -static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_modulator *p = arg;
>> @@ -2023,11 +2023,11 @@ static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops,
>>  	if (vfd->vfl_type == VFL_TYPE_RADIO)
>>  		p->type = V4L2_TUNER_RADIO;
>>  
>> -	return ops->vidioc_s_modulator(file, NULL, p);
>> +	return ops->vidioc_s_modulator(file, state, p);
>>  }
>>  
>> -static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_frequency *p = arg;
>> @@ -2037,11 +2037,11 @@ static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops,
>>  	else
>>  		p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
>>  				V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
>> -	return ops->vidioc_g_frequency(file, NULL, p);
>> +	return ops->vidioc_g_frequency(file, state, p);
>>  }
>>  
>> -static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	const struct v4l2_frequency *p = arg;
>> @@ -2060,11 +2060,11 @@ static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops,
>>  		if (type != p->type)
>>  			return -EINVAL;
>>  	}
>> -	return ops->vidioc_s_frequency(file, NULL, p);
>> +	return ops->vidioc_s_frequency(file, state, p);
>>  }
>>  
>>  static int v4l_enumstd(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		       void *arg)
>> +		       struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_standard *p = arg;
>> @@ -2073,7 +2073,7 @@ static int v4l_enumstd(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  }
>>  
>>  static int v4l_s_std(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		     void *arg)
>> +		     struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	v4l2_std_id id = *(v4l2_std_id *)arg, norm;
>> @@ -2087,11 +2087,11 @@ static int v4l_s_std(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		return -EINVAL;
>>  
>>  	/* Calls the specific handler */
>> -	return ops->vidioc_s_std(file, NULL, norm);
>> +	return ops->vidioc_s_std(file, state, norm);
>>  }
>>  
>>  static int v4l_querystd(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			void *arg)
>> +			struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	v4l2_std_id *p = arg;
>> @@ -2109,11 +2109,12 @@ static int v4l_querystd(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  	 * their efforts to improve the standards detection.
>>  	 */
>>  	*p = vfd->tvnorms;
>> -	return ops->vidioc_querystd(file, NULL, arg);
>> +	return ops->vidioc_querystd(file, state, arg);
>>  }
>>  
>>  static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops *ops,
>> -			      struct file *file, void *arg)
>> +			      struct file *file,
>> +			      struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_hw_freq_seek *p = arg;
>> @@ -2131,26 +2132,26 @@ static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops *ops,
>>  		V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
>>  	if (p->type != type)
>>  		return -EINVAL;
>> -	return ops->vidioc_s_hw_freq_seek(file, NULL, p);
>> +	return ops->vidioc_s_hw_freq_seek(file, state, p);
>>  }
>>  
>>  static int v4l_s_fbuf(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		      void *arg)
>> +		      struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_framebuffer *p = arg;
>>  
>>  	p->base = NULL;
>> -	return ops->vidioc_s_fbuf(file, NULL, p);
>> +	return ops->vidioc_s_fbuf(file, state, p);
>>  }
>>  
>>  static int v4l_overlay(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		       void *arg)
>> +		       struct video_device_state *state, void *arg)
>>  {
>> -	return ops->vidioc_overlay(file, NULL, *(unsigned int *)arg);
>> +	return ops->vidioc_overlay(file, state, *(unsigned int *)arg);
>>  }
>>  
>>  static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		       void *arg)
>> +		       struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_requestbuffers *p = arg;
>> @@ -2165,38 +2166,38 @@ static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  	if (is_valid_ioctl(vfd, VIDIOC_REMOVE_BUFS))
>>  		p->capabilities = V4L2_BUF_CAP_SUPPORTS_REMOVE_BUFS;
>>  
>> -	return ops->vidioc_reqbufs(file, NULL, p);
>> +	return ops->vidioc_reqbufs(file, state, p);
>>  }
>>  
>>  static int v4l_querybuf(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			void *arg)
>> +			struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_buffer *p = arg;
>>  	int ret = check_fmt(file, p->type);
>>  
>> -	return ret ? ret : ops->vidioc_querybuf(file, NULL, p);
>> +	return ret ? ret : ops->vidioc_querybuf(file, state, p);
>>  }
>>  
>>  static int v4l_qbuf(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		    void *arg)
>> +		    struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_buffer *p = arg;
>>  	int ret = check_fmt(file, p->type);
>>  
>> -	return ret ? ret : ops->vidioc_qbuf(file, NULL, p);
>> +	return ret ? ret : ops->vidioc_qbuf(file, state, p);
>>  }
>>  
>>  static int v4l_dqbuf(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		     void *arg)
>> +		     struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_buffer *p = arg;
>>  	int ret = check_fmt(file, p->type);
>>  
>> -	return ret ? ret : ops->vidioc_dqbuf(file, NULL, p);
>> +	return ret ? ret : ops->vidioc_dqbuf(file, state, p);
>>  }
>>  
>> -static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_create_buffers *create = arg;
>> @@ -2213,7 +2214,7 @@ static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
>>  	if (is_valid_ioctl(vfd, VIDIOC_REMOVE_BUFS))
>>  		create->capabilities = V4L2_BUF_CAP_SUPPORTS_REMOVE_BUFS;
>>  
>> -	ret = ops->vidioc_create_bufs(file, NULL, create);
>> +	ret = ops->vidioc_create_bufs(file, state, create);
>>  
>>  	if (create->format.type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
>>  	    create->format.type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
>> @@ -2222,28 +2223,28 @@ static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
>>  	return ret;
>>  }
>>  
>> -static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_buffer *b = arg;
>>  	int ret = check_fmt(file, b->type);
>>  
>> -	return ret ? ret : ops->vidioc_prepare_buf(file, NULL, b);
>> +	return ret ? ret : ops->vidioc_prepare_buf(file, state, b);
>>  }
>>  
>> -static int v4l_remove_bufs(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_remove_bufs(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_remove_buffers *remove = arg;
>>  
>>  	if (ops->vidioc_remove_bufs)
>> -		return ops->vidioc_remove_bufs(file, NULL, remove);
>> +		return ops->vidioc_remove_bufs(file, state, remove);
>>  
>>  	return -ENOTTY;
>>  }
>>  
>>  static int v4l_g_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		      void *arg)
>> +		      struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_streamparm *p = arg;
>> @@ -2253,20 +2254,20 @@ static int v4l_g_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  	if (ret)
>>  		return ret;
>>  	if (ops->vidioc_g_parm)
>> -		return ops->vidioc_g_parm(file, NULL, p);
>> +		return ops->vidioc_g_parm(file, state, p);
>>  	if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
>>  	    p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
>>  		return -EINVAL;
>>  	if (vfd->device_caps & V4L2_CAP_READWRITE)
>>  		p->parm.capture.readbuffers = 2;
>> -	ret = ops->vidioc_g_std(file, NULL, &std);
>> +	ret = ops->vidioc_g_std(file, state, &std);
>>  	if (ret == 0)
>>  		v4l2_video_std_frame_period(std, &p->parm.capture.timeperframe);
>>  	return ret;
>>  }
>>  
>>  static int v4l_s_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		      void *arg)
>> +		      struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_streamparm *p = arg;
>>  	int ret = check_fmt(file, p->type);
>> @@ -2286,11 +2287,11 @@ static int v4l_s_parm(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		p->parm.capture.extendedmode = 0;
>>  		p->parm.capture.capturemode &= V4L2_MODE_HIGHQUALITY;
>>  	}
>> -	return ops->vidioc_s_parm(file, NULL, p);
>> +	return ops->vidioc_s_parm(file, state, p);
>>  }
>>  
>>  static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			 void *arg)
>> +			 struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_query_ext_ctrl qec = {};
>> @@ -2307,7 +2308,7 @@ static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  
>>  	/* Simulate query_ext_ctr using query_ctrl. */
>>  	qec.id = p->id;
>> -	ret = ops->vidioc_query_ext_ctrl(file, NULL, &qec);
>> +	ret = ops->vidioc_query_ext_ctrl(file, state, &qec);
>>  	if (ret)
>>  		return ret;
>>  	v4l2_query_ext_ctrl_to_v4l2_queryctrl(p, &qec);
>> @@ -2315,7 +2316,8 @@ static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  }
>>  
>>  static int v4l_query_ext_ctrl(const struct v4l2_ioctl_ops *ops,
>> -			      struct file *file, void *arg)
>> +			      struct file *file,
>> +			      struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_query_ext_ctrl *p = arg;
>> @@ -2326,12 +2328,12 @@ static int v4l_query_ext_ctrl(const struct v4l2_ioctl_ops *ops,
>>  	if (vfd->ctrl_handler)
>>  		return v4l2_query_ext_ctrl(vfd->ctrl_handler, p);
>>  	if (ops->vidioc_query_ext_ctrl)
>> -		return ops->vidioc_query_ext_ctrl(file, NULL, p);
>> +		return ops->vidioc_query_ext_ctrl(file, state, p);
>>  	return -ENOTTY;
>>  }
>>  
>>  static int v4l_querymenu(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			 void *arg)
>> +			 struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_querymenu *p = arg;
>> @@ -2342,12 +2344,12 @@ static int v4l_querymenu(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  	if (vfd->ctrl_handler)
>>  		return v4l2_querymenu(vfd->ctrl_handler, p);
>>  	if (ops->vidioc_querymenu)
>> -		return ops->vidioc_querymenu(file, NULL, p);
>> +		return ops->vidioc_querymenu(file, state, p);
>>  	return -ENOTTY;
>>  }
>>  
>>  static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		      void *arg)
>> +		      struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_control *p = arg;
>> @@ -2368,7 +2370,7 @@ static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  	ctrl.id = p->id;
>>  	ctrl.value = p->value;
>>  	if (check_ext_ctrls(&ctrls, VIDIOC_G_CTRL)) {
>> -		int ret = ops->vidioc_g_ext_ctrls(file, NULL, &ctrls);
>> +		int ret = ops->vidioc_g_ext_ctrls(file, state, &ctrls);
>>  
>>  		if (ret == 0)
>>  			p->value = ctrl.value;
>> @@ -2378,7 +2380,7 @@ static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  }
>>  
>>  static int v4l_s_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		      void *arg)
>> +		      struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_control *p = arg;
>> @@ -2401,13 +2403,13 @@ static int v4l_s_ctrl(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  	ctrl.value = p->value;
>>  	if (!check_ext_ctrls(&ctrls, VIDIOC_S_CTRL))
>>  		return -EINVAL;
>> -	ret = ops->vidioc_s_ext_ctrls(file, NULL, &ctrls);
>> +	ret = ops->vidioc_s_ext_ctrls(file, state, &ctrls);
>>  	p->value = ctrl.value;
>>  	return ret;
>>  }
>>  
>> -static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_ext_controls *p = arg;
>> @@ -2423,11 +2425,11 @@ static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>>  	if (ops->vidioc_g_ext_ctrls == NULL)
>>  		return -ENOTTY;
>>  	return check_ext_ctrls(p, VIDIOC_G_EXT_CTRLS) ?
>> -				ops->vidioc_g_ext_ctrls(file, NULL, p) : -EINVAL;
>> +				ops->vidioc_g_ext_ctrls(file, state, p) : -EINVAL;
>>  }
>>  
>> -static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_ext_controls *p = arg;
>> @@ -2443,11 +2445,12 @@ static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>>  	if (ops->vidioc_s_ext_ctrls == NULL)
>>  		return -ENOTTY;
>>  	return check_ext_ctrls(p, VIDIOC_S_EXT_CTRLS) ?
>> -				ops->vidioc_s_ext_ctrls(file, NULL, p) : -EINVAL;
>> +				ops->vidioc_s_ext_ctrls(file, state, p) : -EINVAL;
>>  }
>>  
>>  static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>> -			     struct file *file, void *arg)
>> +			     struct file *file,
>> +			     struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_ext_controls *p = arg;
>> @@ -2463,7 +2466,7 @@ static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>>  	if (ops->vidioc_try_ext_ctrls == NULL)
>>  		return -ENOTTY;
>>  	return check_ext_ctrls(p, VIDIOC_TRY_EXT_CTRLS) ?
>> -			ops->vidioc_try_ext_ctrls(file, NULL, p) : -EINVAL;
>> +			ops->vidioc_try_ext_ctrls(file, state, p) : -EINVAL;
>>  }
>>  
>>  /*
>> @@ -2475,8 +2478,8 @@ static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
>>   * restore it afterwards. This way applications can use either buffer
>>   * type and drivers don't need to check for both.
>>   */
>> -static int v4l_g_selection(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_g_selection(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_selection *p = arg;
>>  	u32 old_type = p->type;
>> @@ -2486,13 +2489,13 @@ static int v4l_g_selection(const struct v4l2_ioctl_ops *ops,
>>  		p->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
>>  	else if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
>>  		p->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
>> -	ret = ops->vidioc_g_selection(file, NULL, p);
>> +	ret = ops->vidioc_g_selection(file, state, p);
>>  	p->type = old_type;
>>  	return ret;
>>  }
>>  
>> -static int v4l_s_selection(const struct v4l2_ioctl_ops *ops,
>> -			   struct file *file, void *arg)
>> +static int v4l_s_selection(const struct v4l2_ioctl_ops *ops, struct file *file,
>> +			   struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_selection *p = arg;
>>  	u32 old_type = p->type;
>> @@ -2502,13 +2505,13 @@ static int v4l_s_selection(const struct v4l2_ioctl_ops *ops,
>>  		p->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
>>  	else if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
>>  		p->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
>> -	ret = ops->vidioc_s_selection(file, NULL, p);
>> +	ret = ops->vidioc_s_selection(file, state, p);
>>  	p->type = old_type;
>>  	return ret;
>>  }
>>  
>>  static int v4l_g_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		      void *arg)
>> +		      struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_crop *p = arg;
>> @@ -2529,7 +2532,7 @@ static int v4l_g_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		s.target = s.target == V4L2_SEL_TGT_COMPOSE ?
>>  			V4L2_SEL_TGT_CROP : V4L2_SEL_TGT_COMPOSE;
>>  
>> -	ret = v4l_g_selection(ops, file, &s);
>> +	ret = v4l_g_selection(ops, file, state, &s);
>>  
>>  	/* copying results to old structure on success */
>>  	if (!ret)
>> @@ -2538,7 +2541,7 @@ static int v4l_g_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  }
>>  
>>  static int v4l_s_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		      void *arg)
>> +		      struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_crop *p = arg;
>> @@ -2559,11 +2562,11 @@ static int v4l_s_crop(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		s.target = s.target == V4L2_SEL_TGT_COMPOSE ?
>>  			V4L2_SEL_TGT_CROP : V4L2_SEL_TGT_COMPOSE;
>>  
>> -	return v4l_s_selection(ops, file, &s);
>> +	return v4l_s_selection(ops, file, state, &s);
>>  }
>>  
>>  static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		       void *arg)
>> +		       struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_cropcap *p = arg;
>> @@ -2587,7 +2590,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		return -ENOTTY;
>>  
>>  	if (ops->vidioc_g_pixelaspect)
>> -		ret = ops->vidioc_g_pixelaspect(file, NULL, s.type,
>> +		ret = ops->vidioc_g_pixelaspect(file, state, s.type,
>>  						&p->pixelaspect);
>>  
>>  	/*
>> @@ -2609,7 +2612,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  		s.target = s.target == V4L2_SEL_TGT_COMPOSE_BOUNDS ?
>>  			V4L2_SEL_TGT_CROP_BOUNDS : V4L2_SEL_TGT_COMPOSE_BOUNDS;
>>  
>> -	ret = v4l_g_selection(ops, file, &s);
>> +	ret = v4l_g_selection(ops, file, state, &s);
>>  	if (ret)
>>  		return ret;
>>  	p->bounds = s.r;
>> @@ -2620,7 +2623,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  	else
>>  		s.target = V4L2_SEL_TGT_CROP_DEFAULT;
>>  
>> -	ret = v4l_g_selection(ops, file, &s);
>> +	ret = v4l_g_selection(ops, file, state, &s);
>>  	if (ret)
>>  		return ret;
>>  	p->defrect = s.r;
>> @@ -2629,7 +2632,7 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  }
>>  
>>  static int v4l_log_status(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -			  void *arg)
>> +			  struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	int ret;
>> @@ -2637,7 +2640,7 @@ static int v4l_log_status(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  	if (vfd->v4l2_dev)
>>  		pr_info("%s: =================  START STATUS  =================\n",
>>  			vfd->v4l2_dev->name);
>> -	ret = ops->vidioc_log_status(file, NULL);
>> +	ret = ops->vidioc_log_status(file, state);
>>  	if (vfd->v4l2_dev)
>>  		pr_info("%s: ==================  END STATUS  ==================\n",
>>  			vfd->v4l2_dev->name);
>> @@ -2645,7 +2648,8 @@ static int v4l_log_status(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  }
>>  
>>  static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
>> -			      struct file *file, void *arg)
>> +			      struct file *file,
>> +			      struct video_device_state *state, void *arg)
>>  {
>>  #ifdef CONFIG_VIDEO_ADV_DEBUG
>>  	struct v4l2_dbg_register *p = arg;
>> @@ -2665,7 +2669,7 @@ static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
>>  	}
>>  	if (ops->vidioc_g_register && p->match.type == V4L2_CHIP_MATCH_BRIDGE &&
>>  	    (ops->vidioc_g_chip_info || p->match.addr == 0))
>> -		return ops->vidioc_g_register(file, NULL, p);
>> +		return ops->vidioc_g_register(file, state, p);
>>  	return -EINVAL;
>>  #else
>>  	return -ENOTTY;
>> @@ -2673,7 +2677,8 @@ static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
>>  }
>>  
>>  static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
>> -			      struct file *file, void *arg)
>> +			      struct file *file,
>> +			      struct video_device_state *state, void *arg)
>>  {
>>  #ifdef CONFIG_VIDEO_ADV_DEBUG
>>  	const struct v4l2_dbg_register *p = arg;
>> @@ -2693,7 +2698,7 @@ static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
>>  	}
>>  	if (ops->vidioc_s_register && p->match.type == V4L2_CHIP_MATCH_BRIDGE &&
>>  	    (ops->vidioc_g_chip_info || p->match.addr == 0))
>> -		return ops->vidioc_s_register(file, NULL, p);
>> +		return ops->vidioc_s_register(file, state, p);
>>  	return -EINVAL;
>>  #else
>>  	return -ENOTTY;
>> @@ -2701,7 +2706,8 @@ static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
>>  }
>>  
>>  static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops,
>> -			       struct file *file, void *arg)
>> +			       struct file *file,
>> +			       struct video_device_state *state, void *arg)
>>  {
>>  #ifdef CONFIG_VIDEO_ADV_DEBUG
>>  	struct video_device *vfd = video_devdata(file);
>> @@ -2717,7 +2723,7 @@ static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops,
>>  			p->flags |= V4L2_CHIP_FL_READABLE;
>>  		strscpy(p->name, vfd->v4l2_dev->name, sizeof(p->name));
>>  		if (ops->vidioc_g_chip_info)
>> -			return ops->vidioc_g_chip_info(file, NULL, arg);
>> +			return ops->vidioc_g_chip_info(file, state, arg);
>>  		if (p->match.addr)
>>  			return -EINVAL;
>>  		return 0;
>> @@ -2744,7 +2750,7 @@ static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops,
>>  }
>>  
>>  static int v4l_dqevent(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		       void *arg)
>> +		       struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
>>  
>> @@ -2752,7 +2758,8 @@ static int v4l_dqevent(const struct v4l2_ioctl_ops *ops, struct file *file,
>>  }
>>  
>>  static int v4l_subscribe_event(const struct v4l2_ioctl_ops *ops,
>> -			       struct file *file, void *arg)
>> +			       struct file *file,
>> +			       struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
>>  
>> @@ -2760,7 +2767,8 @@ static int v4l_subscribe_event(const struct v4l2_ioctl_ops *ops,
>>  }
>>  
>>  static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops *ops,
>> -				 struct file *file, void *arg)
>> +				 struct file *file,
>> +				 struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_fh *vfh = file_to_v4l2_fh(file);
>>  
>> @@ -2768,7 +2776,8 @@ static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops *ops,
>>  }
>>  
>>  static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops *ops,
>> -				struct file *file, void *arg)
>> +				struct file *file,
>> +				struct video_device_state *state, void *arg)
>>  {
>>  	struct v4l2_sliced_vbi_cap *p = arg;
>>  	int ret = check_fmt(file, p->type);
>> @@ -2779,11 +2788,12 @@ static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops *ops,
>>  	/* Clear up to type, everything after type is zeroed already */
>>  	memset(p, 0, offsetof(struct v4l2_sliced_vbi_cap, type));
>>  
>> -	return ops->vidioc_g_sliced_vbi_cap(file, NULL, p);
>> +	return ops->vidioc_g_sliced_vbi_cap(file, state, p);
>>  }
>>  
>>  static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
>> -			       struct file *file, void *arg)
>> +			       struct file *file,
>> +			       struct video_device_state *state, void *arg)
>>  {
>>  	struct video_device *vfd = video_devdata(file);
>>  	struct v4l2_frequency_band *p = arg;
>> @@ -2801,7 +2811,7 @@ static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
>>  			return -EINVAL;
>>  	}
>>  	if (ops->vidioc_enum_freq_bands) {
>> -		err = ops->vidioc_enum_freq_bands(file, NULL, p);
>> +		err = ops->vidioc_enum_freq_bands(file, state, p);
>>  		if (err != -ENOTTY)
>>  			return err;
>>  	}
>> @@ -2813,7 +2823,7 @@ static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
>>  
>>  		if (p->index)
>>  			return -EINVAL;
>> -		err = ops->vidioc_g_tuner(file, NULL, &t);
>> +		err = ops->vidioc_g_tuner(file, state, &t);
>>  		if (err)
>>  			return err;
>>  		p->capability = t.capability | V4L2_TUNER_CAP_FREQ_BANDS;
>> @@ -2832,7 +2842,7 @@ static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
>>  			return -EINVAL;
>>  		if (p->index)
>>  			return -EINVAL;
>> -		err = ops->vidioc_g_modulator(file, NULL, &m);
>> +		err = ops->vidioc_g_modulator(file, state, &m);
>>  		if (err)
>>  			return err;
>>  		p->capability = m.capability | V4L2_TUNER_CAP_FREQ_BANDS;
>> @@ -2849,7 +2859,7 @@ struct v4l2_ioctl_info {
>>  	u32 flags;
>>  	const char * const name;
>>  	int (*func)(const struct v4l2_ioctl_ops *ops, struct file *file,
>> -		    void *p);
>> +		    struct video_device_state *state, void *p);
>>  	void (*debug)(const void *arg, bool write_only);
>>  };
>>  
>> @@ -2870,7 +2880,9 @@ struct v4l2_ioctl_info {
>>  #define DEFINE_V4L_STUB_FUNC(_vidioc)				\
>>  	static int v4l_stub_ ## _vidioc(			\
>>  			const struct v4l2_ioctl_ops *ops,	\
>> -			struct file *file, void *p)		\
>> +			struct file *file,			\
>> +			struct video_device_state *state,	\
>> +			void *p)				\
>>  	{							\
>>  		return ops->vidioc_ ## _vidioc(file, NULL, p);	\
>>  	}
>> @@ -3126,7 +3138,7 @@ static long __video_do_ioctl(struct file *file,
>>  
>>  	write_only = _IOC_DIR(cmd) == _IOC_WRITE;
>>  	if (info != &default_info) {
>> -		ret = info->func(ops, file, arg);
>> +		ret = info->func(ops, file, NULL, arg);
>>  	} else if (!ops->vidioc_default) {
>>  		ret = -ENOTTY;
>>  	} else {
>>
> 
>

Patchew 2.1-devel-b67e4c2

© 2016 - 2025 Red Hat, Inc.