1 files changed, 188 insertions, 51 deletions

diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
index 16bffd851bf9..d15e16737eef 100644
--- a/drivers/media/v4l2-core/v4l2-ioctl.c
+++ b/drivers/media/v4l2-core/v4l2-ioctl.c
@@ -256,7 +256,8 @@ static void v4l_print_format(const void *arg, bool write_only)
                 pix = &p->fmt.pix;
                 pr_cont(", width=%u, height=%u, "
                         "pixelformat=%c%c%c%c, field=%s, "
-                        "bytesperline=%u, sizeimage=%u, colorspace=%d\n",
+                        "bytesperline=%u, sizeimage=%u, colorspace=%d, "
+                        "flags %u\n",
                         pix->width, pix->height,
                         (pix->pixelformat & 0xff),
                         (pix->pixelformat >>  8) & 0xff,
@@ -264,7 +265,7 @@ static void v4l_print_format(const void *arg, bool write_only)
                         (pix->pixelformat >> 24) & 0xff,
                         prt_names(pix->field, v4l2_field_names),
                         pix->bytesperline, pix->sizeimage,
-                        pix->colorspace);
+                        pix->colorspace, pix->flags);
                 break;
         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
@@ -525,6 +526,20 @@ static void v4l_print_queryctrl(const void *arg, bool write_only)
                         p->step, p->default_value, p->flags);
 }
 
+static void v4l_print_query_ext_ctrl(const void *arg, bool write_only)
+{
+        const struct v4l2_query_ext_ctrl *p = arg;
+
+        pr_cont("id=0x%x, type=%d, name=%.*s, min/max=%lld/%lld, "
+                "step=%lld, default=%lld, flags=0x%08x, elem_size=%u, elems=%u, "
+                "nr_of_dims=%u, dims=%u,%u,%u,%u\n",
+                        p->id, p->type, (int)sizeof(p->name), p->name,
+                        p->minimum, p->maximum,
+                        p->step, p->default_value, p->flags,
+                        p->elem_size, p->elems, p->nr_of_dims,
+                        p->dims[0], p->dims[1], p->dims[2], p->dims[3]);
+}
+
 static void v4l_print_querymenu(const void *arg, bool write_only)
 {
         const struct v4l2_querymenu *p = arg;
@@ -959,13 +974,49 @@ static int check_fmt(struct file *file, enum v4l2_buf_type type)
         return -EINVAL;
 }
 
+static void v4l_sanitize_format(struct v4l2_format *fmt)
+{
+        unsigned int offset;
+
+        /*
+         * The v4l2_pix_format structure has been extended with fields that were
+         * not previously required to be set to zero by applications. The priv
+         * field, when set to a magic value, indicates the the extended fields
+         * are valid. Otherwise they will contain undefined values. To simplify
+         * the API towards drivers zero the extended fields and set the priv
+         * field to the magic value when the extended pixel format structure
+         * isn't used by applications.
+         */
+
+        if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
+            fmt->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
+                return;
+
+        if (fmt->fmt.pix.priv == V4L2_PIX_FMT_PRIV_MAGIC)
+                return;
+
+        fmt->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
+
+        offset = offsetof(struct v4l2_pix_format, priv)
+               + sizeof(fmt->fmt.pix.priv);
+        memset(((void *)&fmt->fmt.pix) + offset, 0,
+               sizeof(fmt->fmt.pix) - offset);
+}
+
 static int v4l_querycap(const struct v4l2_ioctl_ops *ops,
                                 struct file *file, void *fh, void *arg)
 {
         struct v4l2_capability *cap = (struct v4l2_capability *)arg;
+        int ret;
 
         cap->version = LINUX_VERSION_CODE;
-        return ops->vidioc_querycap(file, fh, cap);
+
+        ret = ops->vidioc_querycap(file, fh, cap);
+
+        cap->capabilities |= V4L2_CAP_EXT_PIX_FORMAT;
+        cap->device_caps |= V4L2_CAP_EXT_PIX_FORMAT;
+
+        return ret;
 }
 
 static int v4l_s_input(const struct v4l2_ioctl_ops *ops,
@@ -1048,32 +1099,34 @@ static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops,
 {
         struct v4l2_fmtdesc *p = arg;
         struct video_device *vfd = video_devdata(file);
+        bool is_vid = vfd->vfl_type == VFL_TYPE_GRABBER;
+        bool is_sdr = vfd->vfl_type == VFL_TYPE_SDR;
         bool is_rx = vfd->vfl_dir != VFL_DIR_TX;
         bool is_tx = vfd->vfl_dir != VFL_DIR_RX;
 
         switch (p->type) {
         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-                if (unlikely(!is_rx || !ops->vidioc_enum_fmt_vid_cap))
+                if (unlikely(!is_rx || !is_vid || !ops->vidioc_enum_fmt_vid_cap))
                         break;
                 return ops->vidioc_enum_fmt_vid_cap(file, fh, arg);
         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
-                if (unlikely(!is_rx || !ops->vidioc_enum_fmt_vid_cap_mplane))
+                if (unlikely(!is_rx || !is_vid || !ops->vidioc_enum_fmt_vid_cap_mplane))
                         break;
                 return ops->vidioc_enum_fmt_vid_cap_mplane(file, fh, arg);
         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
-                if (unlikely(!is_rx || !ops->vidioc_enum_fmt_vid_overlay))
+                if (unlikely(!is_rx || !is_vid || !ops->vidioc_enum_fmt_vid_overlay))
                         break;
                 return ops->vidioc_enum_fmt_vid_overlay(file, fh, arg);
         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
-                if (unlikely(!is_tx || !ops->vidioc_enum_fmt_vid_out))
+                if (unlikely(!is_tx || !is_vid || !ops->vidioc_enum_fmt_vid_out))
                         break;
                 return ops->vidioc_enum_fmt_vid_out(file, fh, arg);
         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
-                if (unlikely(!is_tx || !ops->vidioc_enum_fmt_vid_out_mplane))
+                if (unlikely(!is_tx || !is_vid || !ops->vidioc_enum_fmt_vid_out_mplane))
                         break;
                 return ops->vidioc_enum_fmt_vid_out_mplane(file, fh, arg);
         case V4L2_BUF_TYPE_SDR_CAPTURE:
-                if (unlikely(!is_rx || !ops->vidioc_enum_fmt_sdr_cap))
+                if (unlikely(!is_rx || !is_sdr || !ops->vidioc_enum_fmt_sdr_cap))
                         break;
                 return ops->vidioc_enum_fmt_sdr_cap(file, fh, arg);
         }
@@ -1089,12 +1142,41 @@ static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops,
         bool is_sdr = vfd->vfl_type == VFL_TYPE_SDR;
         bool is_rx = vfd->vfl_dir != VFL_DIR_TX;
         bool is_tx = vfd->vfl_dir != VFL_DIR_RX;
+        int ret;
+
+        /*
+         * fmt can't be cleared for these overlay types due to the 'clips'
+         * 'clipcount' and 'bitmap' pointers in struct v4l2_window.
+         * Those are provided by the user. So handle these two overlay types
+         * first, and then just do a simple memset for the other types.
+         */
+        switch (p->type) {
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+        case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: {
+                struct v4l2_clip *clips = p->fmt.win.clips;
+                u32 clipcount = p->fmt.win.clipcount;
+                void *bitmap = p->fmt.win.bitmap;
+
+                memset(&p->fmt, 0, sizeof(p->fmt));
+                p->fmt.win.clips = clips;
+                p->fmt.win.clipcount = clipcount;
+                p->fmt.win.bitmap = bitmap;
+                break;
+        }
+        default:
+                memset(&p->fmt, 0, sizeof(p->fmt));
+                break;
+        }
 
         switch (p->type) {
         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
                 if (unlikely(!is_rx || !is_vid || !ops->vidioc_g_fmt_vid_cap))
                         break;
-                return ops->vidioc_g_fmt_vid_cap(file, fh, arg);
+                p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
+                ret = ops->vidioc_g_fmt_vid_cap(file, fh, 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_CAPTURE_MPLANE:
                 if (unlikely(!is_rx || !is_vid || !ops->vidioc_g_fmt_vid_cap_mplane))
                         break;
@@ -1114,7 +1196,11 @@ static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops,
         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
                 if (unlikely(!is_tx || !is_vid || !ops->vidioc_g_fmt_vid_out))
                         break;
-                return ops->vidioc_g_fmt_vid_out(file, fh, arg);
+                p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
+                ret = ops->vidioc_g_fmt_vid_out(file, fh, 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:
                 if (unlikely(!is_tx || !is_vid || !ops->vidioc_g_fmt_vid_out_mplane))
                         break;
@@ -1148,13 +1234,19 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops,
         bool is_sdr = vfd->vfl_type == VFL_TYPE_SDR;
         bool is_rx = vfd->vfl_dir != VFL_DIR_TX;
         bool is_tx = vfd->vfl_dir != VFL_DIR_RX;
+        int ret;
+
+        v4l_sanitize_format(p);
 
         switch (p->type) {
         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
                 if (unlikely(!is_rx || !is_vid || !ops->vidioc_s_fmt_vid_cap))
                         break;
                 CLEAR_AFTER_FIELD(p, fmt.pix);
-                return ops->vidioc_s_fmt_vid_cap(file, fh, arg);
+                ret = ops->vidioc_s_fmt_vid_cap(file, fh, 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_CAPTURE_MPLANE:
                 if (unlikely(!is_rx || !is_vid || !ops->vidioc_s_fmt_vid_cap_mplane))
                         break;
@@ -1179,7 +1271,10 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops,
                 if (unlikely(!is_tx || !is_vid || !ops->vidioc_s_fmt_vid_out))
                         break;
                 CLEAR_AFTER_FIELD(p, fmt.pix);
-                return ops->vidioc_s_fmt_vid_out(file, fh, arg);
+                ret = ops->vidioc_s_fmt_vid_out(file, fh, 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:
                 if (unlikely(!is_tx || !is_vid || !ops->vidioc_s_fmt_vid_out_mplane))
                         break;
@@ -1218,13 +1313,19 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops,
         bool is_sdr = vfd->vfl_type == VFL_TYPE_SDR;
         bool is_rx = vfd->vfl_dir != VFL_DIR_TX;
         bool is_tx = vfd->vfl_dir != VFL_DIR_RX;
+        int ret;
+
+        v4l_sanitize_format(p);
 
         switch (p->type) {
         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
                 if (unlikely(!is_rx || !is_vid || !ops->vidioc_try_fmt_vid_cap))
                         break;
                 CLEAR_AFTER_FIELD(p, fmt.pix);
-                return ops->vidioc_try_fmt_vid_cap(file, fh, arg);
+                ret = ops->vidioc_try_fmt_vid_cap(file, fh, 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_CAPTURE_MPLANE:
                 if (unlikely(!is_rx || !is_vid || !ops->vidioc_try_fmt_vid_cap_mplane))
                         break;
@@ -1249,7 +1350,10 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops,
                 if (unlikely(!is_tx || !is_vid || !ops->vidioc_try_fmt_vid_out))
                         break;
                 CLEAR_AFTER_FIELD(p, fmt.pix);
-                return ops->vidioc_try_fmt_vid_out(file, fh, arg);
+                ret = ops->vidioc_try_fmt_vid_out(file, fh, 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:
                 if (unlikely(!is_tx || !is_vid || !ops->vidioc_try_fmt_vid_out_mplane))
                         break;
@@ -1502,7 +1606,18 @@ static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
         struct v4l2_create_buffers *create = arg;
         int ret = check_fmt(file, create->format.type);
 
-        return ret ? ret : ops->vidioc_create_bufs(file, fh, create);
+        if (ret)
+                return ret;
+
+        v4l_sanitize_format(&create->format);
+
+        ret = ops->vidioc_create_bufs(file, fh, create);
+
+        if (create->format.type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+            create->format.type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+                create->format.fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
+
+        return ret;
 }
 
 static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops,
@@ -1561,6 +1676,23 @@ static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops,
         return -ENOTTY;
 }
 
+static int v4l_query_ext_ctrl(const struct v4l2_ioctl_ops *ops,
+                                struct file *file, void *fh, void *arg)
+{
+        struct video_device *vfd = video_devdata(file);
+        struct v4l2_query_ext_ctrl *p = arg;
+        struct v4l2_fh *vfh =
+                test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
+
+        if (vfh && vfh->ctrl_handler)
+                return v4l2_query_ext_ctrl(vfh->ctrl_handler, p);
+        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, fh, p);
+        return -ENOTTY;
+}
+
 static int v4l_querymenu(const struct v4l2_ioctl_ops *ops,
                                 struct file *file, void *fh, void *arg)
 {
@@ -1751,37 +1883,41 @@ static int v4l_cropcap(const struct v4l2_ioctl_ops *ops,
                                 struct file *file, void *fh, void *arg)
 {
         struct v4l2_cropcap *p = arg;
-        struct v4l2_selection s = { .type = p->type };
-        int ret;
 
-        if (ops->vidioc_cropcap)
-                return ops->vidioc_cropcap(file, fh, p);
+        if (ops->vidioc_g_selection) {
+                struct v4l2_selection s = { .type = p->type };
+                int ret;
 
-        /* obtaining bounds */
-        if (V4L2_TYPE_IS_OUTPUT(p->type))
-                s.target = V4L2_SEL_TGT_COMPOSE_BOUNDS;
-        else
-                s.target = V4L2_SEL_TGT_CROP_BOUNDS;
+                /* obtaining bounds */
+                if (V4L2_TYPE_IS_OUTPUT(p->type))
+                        s.target = V4L2_SEL_TGT_COMPOSE_BOUNDS;
+                else
+                        s.target = V4L2_SEL_TGT_CROP_BOUNDS;
 
-        ret = ops->vidioc_g_selection(file, fh, &s);
-        if (ret)
-                return ret;
-        p->bounds = s.r;
+                ret = ops->vidioc_g_selection(file, fh, &s);
+                if (ret)
+                        return ret;
+                p->bounds = s.r;
 
-        /* obtaining defrect */
-        if (V4L2_TYPE_IS_OUTPUT(p->type))
-                s.target = V4L2_SEL_TGT_COMPOSE_DEFAULT;
-        else
-                s.target = V4L2_SEL_TGT_CROP_DEFAULT;
+                /* obtaining defrect */
+                if (V4L2_TYPE_IS_OUTPUT(p->type))
+                        s.target = V4L2_SEL_TGT_COMPOSE_DEFAULT;
+                else
+                        s.target = V4L2_SEL_TGT_CROP_DEFAULT;
 
-        ret = ops->vidioc_g_selection(file, fh, &s);
-        if (ret)
-                return ret;
-        p->defrect = s.r;
+                ret = ops->vidioc_g_selection(file, fh, &s);
+                if (ret)
+                        return ret;
+                p->defrect = s.r;
+        }
 
         /* setting trivial pixelaspect */
         p->pixelaspect.numerator = 1;
         p->pixelaspect.denominator = 1;
+
+        if (ops->vidioc_cropcap)
+                return ops->vidioc_cropcap(file, fh, p);
+
         return 0;
 }
 
@@ -1951,8 +2087,11 @@ static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
                 if (type != p->type)
                         return -EINVAL;
         }
-        if (ops->vidioc_enum_freq_bands)
-                return ops->vidioc_enum_freq_bands(file, fh, p);
+        if (ops->vidioc_enum_freq_bands) {
+                err = ops->vidioc_enum_freq_bands(file, fh, p);
+                if (err != -ENOTTY)
+                        return err;
+        }
         if (is_valid_ioctl(vfd, VIDIOC_G_TUNER)) {
                 struct v4l2_tuner t = {
                         .index = p->tuner,
@@ -2042,7 +2181,7 @@ struct v4l2_ioctl_info {
 static struct v4l2_ioctl_info v4l2_ioctls[] = {
         IOCTL_INFO_FNC(VIDIOC_QUERYCAP, v4l_querycap, v4l_print_querycap, 0),
         IOCTL_INFO_FNC(VIDIOC_ENUM_FMT, v4l_enum_fmt, v4l_print_fmtdesc, INFO_FL_CLEAR(v4l2_fmtdesc, type)),
-        IOCTL_INFO_FNC(VIDIOC_G_FMT, v4l_g_fmt, v4l_print_format, INFO_FL_CLEAR(v4l2_format, type)),
+        IOCTL_INFO_FNC(VIDIOC_G_FMT, v4l_g_fmt, v4l_print_format, 0),
         IOCTL_INFO_FNC(VIDIOC_S_FMT, v4l_s_fmt, v4l_print_format, INFO_FL_PRIO),
         IOCTL_INFO_FNC(VIDIOC_REQBUFS, v4l_reqbufs, v4l_print_requestbuffers, INFO_FL_PRIO | INFO_FL_QUEUE),
         IOCTL_INFO_FNC(VIDIOC_QUERYBUF, v4l_querybuf, v4l_print_buffer, INFO_FL_QUEUE | INFO_FL_CLEAR(v4l2_buffer, length)),
@@ -2070,8 +2209,8 @@ static struct v4l2_ioctl_info v4l2_ioctls[] = {
         IOCTL_INFO_FNC(VIDIOC_QUERYMENU, v4l_querymenu, v4l_print_querymenu, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_querymenu, index)),
         IOCTL_INFO_STD(VIDIOC_G_INPUT, vidioc_g_input, v4l_print_u32, 0),
         IOCTL_INFO_FNC(VIDIOC_S_INPUT, v4l_s_input, v4l_print_u32, INFO_FL_PRIO),
-        IOCTL_INFO_STD(VIDIOC_G_EDID, vidioc_g_edid, v4l_print_edid, INFO_FL_CLEAR(v4l2_edid, edid)),
-        IOCTL_INFO_STD(VIDIOC_S_EDID, vidioc_s_edid, v4l_print_edid, INFO_FL_PRIO | INFO_FL_CLEAR(v4l2_edid, edid)),
+        IOCTL_INFO_STD(VIDIOC_G_EDID, vidioc_g_edid, v4l_print_edid, 0),
+        IOCTL_INFO_STD(VIDIOC_S_EDID, vidioc_s_edid, v4l_print_edid, INFO_FL_PRIO),
         IOCTL_INFO_STD(VIDIOC_G_OUTPUT, vidioc_g_output, v4l_print_u32, 0),
         IOCTL_INFO_FNC(VIDIOC_S_OUTPUT, v4l_s_output, v4l_print_u32, INFO_FL_PRIO),
         IOCTL_INFO_FNC(VIDIOC_ENUMOUTPUT, v4l_enumoutput, v4l_print_enumoutput, INFO_FL_CLEAR(v4l2_output, index)),
@@ -2084,8 +2223,8 @@ static struct v4l2_ioctl_info v4l2_ioctls[] = {
         IOCTL_INFO_FNC(VIDIOC_CROPCAP, v4l_cropcap, v4l_print_cropcap, INFO_FL_CLEAR(v4l2_cropcap, type)),
         IOCTL_INFO_FNC(VIDIOC_G_CROP, v4l_g_crop, v4l_print_crop, INFO_FL_CLEAR(v4l2_crop, type)),
         IOCTL_INFO_FNC(VIDIOC_S_CROP, v4l_s_crop, v4l_print_crop, INFO_FL_PRIO),
-        IOCTL_INFO_STD(VIDIOC_G_SELECTION, vidioc_g_selection, v4l_print_selection, 0),
-        IOCTL_INFO_STD(VIDIOC_S_SELECTION, vidioc_s_selection, v4l_print_selection, INFO_FL_PRIO),
+        IOCTL_INFO_STD(VIDIOC_G_SELECTION, vidioc_g_selection, v4l_print_selection, INFO_FL_CLEAR(v4l2_selection, r)),
+        IOCTL_INFO_STD(VIDIOC_S_SELECTION, vidioc_s_selection, v4l_print_selection, INFO_FL_PRIO | INFO_FL_CLEAR(v4l2_selection, r)),
         IOCTL_INFO_STD(VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp, v4l_print_jpegcompression, 0),
         IOCTL_INFO_STD(VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp, v4l_print_jpegcompression, INFO_FL_PRIO),
         IOCTL_INFO_FNC(VIDIOC_QUERYSTD, v4l_querystd, v4l_print_std, 0),
@@ -2121,6 +2260,7 @@ static struct v4l2_ioctl_info v4l2_ioctls[] = {
         IOCTL_INFO_STD(VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap, v4l_print_dv_timings_cap, INFO_FL_CLEAR(v4l2_dv_timings_cap, type)),
         IOCTL_INFO_FNC(VIDIOC_ENUM_FREQ_BANDS, v4l_enum_freq_bands, v4l_print_freq_band, 0),
         IOCTL_INFO_FNC(VIDIOC_DBG_G_CHIP_INFO, v4l_dbg_g_chip_info, v4l_print_dbg_chip_info, INFO_FL_CLEAR(v4l2_dbg_chip_info, match)),
+        IOCTL_INFO_FNC(VIDIOC_QUERY_EXT_CTRL, v4l_query_ext_ctrl, v4l_print_query_ext_ctrl, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_query_ext_ctrl, id)),
 };
 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
 
@@ -2190,7 +2330,6 @@ static long __video_do_ioctl(struct file *file,
         const struct v4l2_ioctl_info *info;
         void *fh = file->private_data;
         struct v4l2_fh *vfh = NULL;
-        int use_fh_prio = 0;
         int debug = vfd->debug;
         long ret = -ENOTTY;
 
@@ -2200,10 +2339,8 @@ static long __video_do_ioctl(struct file *file,
                 return ret;
         }
 
-        if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags)) {
+        if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags))
                 vfh = file->private_data;
-                use_fh_prio = test_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
-        }
 
         if (v4l2_is_known_ioctl(cmd)) {
                 info = &v4l2_ioctls[_IOC_NR(cmd)];
@@ -2212,7 +2349,7 @@ static long __video_do_ioctl(struct file *file,
                     !((info->flags & INFO_FL_CTRL) && vfh && vfh->ctrl_handler))
                         goto done;
 
-                if (use_fh_prio && (info->flags & INFO_FL_PRIO)) {
+                if (vfh && (info->flags & INFO_FL_PRIO)) {
                         ret = v4l2_prio_check(vfd->prio, vfh->prio);
                         if (ret)
                                 goto done;
@@ -2237,7 +2374,7 @@ static long __video_do_ioctl(struct file *file,
                 ret = -ENOTTY;
         } else {
                 ret = ops->vidioc_default(file, fh,
-                        use_fh_prio ? v4l2_prio_check(vfd->prio, vfh->prio) >= 0 : 0,
+                        vfh ? v4l2_prio_check(vfd->prio, vfh->prio) >= 0 : 0,
                         cmd, arg);
         }