redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

media: v4l: ctrls: Add debug messages 

Currently, the v4l2 control code is a bit silent on errors.
Add debug messages on (hopefully) most of the error paths.

Signed-off-by: Ezequiel Garcia <ezequiel@collabora.com>
Signed-off-by: Hans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
alistair/sunxi64-5.4-dsi
Ezequiel Garcia 2019-07-20 07:47:07 -04:00 committed by Mauro Carvalho Chehab
parent d4a6a9537b
commit 173f6eacc8
7 changed files with 127 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Documentation/media/kapi/v4l2-dev.rst
View File

@ -288,6 +288,7 @@ Mask Description
0x08 Log the read and write file operations and the VIDIOC_QBUF and 0x08 Log the read and write file operations and the VIDIOC_QBUF and
VIDIOC_DQBUF ioctls. VIDIOC_DQBUF ioctls.
0x10 Log the poll file operation. 0x10 Log the poll file operation.
0x20 Log error and messages in the control operations.
===== ================================================================ ===== ================================================================
Video device cleanup Video device cleanup

4
drivers/media/platform/omap3isp/ispvideo.c
View File

@ -1020,8 +1020,8 @@ static int isp_video_check_external_subdevs(struct isp_video *video,
ctrls.count = 1; ctrls.count = 1;
ctrls.controls = &ctrl; ctrls.controls = &ctrl;
ret = v4l2_g_ext_ctrls(pipe->external->ctrl_handler, &video->video,
ret = v4l2_g_ext_ctrls(pipe->external->ctrl_handler, NULL, &ctrls); NULL, &ctrls);
if (ret < 0) { if (ret < 0) {
dev_warn(isp->dev, "no pixel rate control in subdev %s\n", dev_warn(isp->dev, "no pixel rate control in subdev %s\n",
pipe->external->name); pipe->external->name);

126
drivers/media/v4l2-core/v4l2-ctrls.c
View File

@ -6,6 +6,8 @@
*/ */
#define pr_fmt(fmt) "v4l2-ctrls: " fmt
#include <linux/ctype.h> #include <linux/ctype.h>
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/slab.h> #include <linux/slab.h>
@ -16,6 +18,12 @@
#include <media/v4l2-event.h> #include <media/v4l2-event.h>
#include <media/v4l2-dev.h> #include <media/v4l2-dev.h>
#define dprintk(vdev, fmt, arg...) do { \
if (!WARN_ON(!(vdev)) && ((vdev)->dev_debug & V4L2_DEV_DEBUG_CTRL)) \
printk(KERN_DEBUG pr_fmt("%s: %s: " fmt), \
__func__, video_device_node_name(vdev), ##arg); \
} while (0)
#define has_op(master, op) \ #define has_op(master, op) \
(master->ops && master->ops->op) (master->ops && master->ops->op)
#define call_op(master, op) \ #define call_op(master, op) \
@ -3260,6 +3268,7 @@ static int v4l2_ctrl_request_bind(struct media_request *req,
static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl, static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
struct v4l2_ext_controls *cs, struct v4l2_ext_controls *cs,
struct v4l2_ctrl_helper *helpers, struct v4l2_ctrl_helper *helpers,
struct video_device *vdev,
bool get) bool get)
{ {
struct v4l2_ctrl_helper *h; struct v4l2_ctrl_helper *h;
@ -3277,20 +3286,31 @@ static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
if (cs->which && if (cs->which &&
cs->which != V4L2_CTRL_WHICH_DEF_VAL && cs->which != V4L2_CTRL_WHICH_DEF_VAL &&
cs->which != V4L2_CTRL_WHICH_REQUEST_VAL && cs->which != V4L2_CTRL_WHICH_REQUEST_VAL &&
V4L2_CTRL_ID2WHICH(id) != cs->which) V4L2_CTRL_ID2WHICH(id) != cs->which) {
dprintk(vdev,
"invalid which 0x%x or control id 0x%x\n",
cs->which, id);
return -EINVAL; return -EINVAL;
}
/* Old-style private controls are not allowed for /* Old-style private controls are not allowed for
extended controls */ extended controls */
if (id >= V4L2_CID_PRIVATE_BASE) if (id >= V4L2_CID_PRIVATE_BASE) {
dprintk(vdev,
"old-style private controls not allowed\n");
return -EINVAL; return -EINVAL;
}
ref = find_ref_lock(hdl, id); ref = find_ref_lock(hdl, id);
if (ref == NULL) if (ref == NULL) {
dprintk(vdev, "cannot find control id 0x%x\n", id);
return -EINVAL; return -EINVAL;
}
h->ref = ref; h->ref = ref;
ctrl = ref->ctrl; ctrl = ref->ctrl;
if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED) if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED) {
dprintk(vdev, "control id 0x%x is disabled\n", id);
return -EINVAL; return -EINVAL;
}
if (ctrl->cluster[0]->ncontrols > 1) if (ctrl->cluster[0]->ncontrols > 1)
have_clusters = true; have_clusters = true;
@ -3300,10 +3320,17 @@ static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
unsigned tot_size = ctrl->elems * ctrl->elem_size; unsigned tot_size = ctrl->elems * ctrl->elem_size;
if (c->size < tot_size) { if (c->size < tot_size) {
/*
* In the get case the application first
* queries to obtain the size of the control.
*/
if (get) { if (get) {
c->size = tot_size; c->size = tot_size;
return -ENOSPC; return -ENOSPC;
} }
dprintk(vdev,
"pointer control id 0x%x size too small, %d bytes but %d bytes needed\n",
id, c->size, tot_size);
return -EFAULT; return -EFAULT;
} }
c->size = tot_size; c->size = tot_size;
@ -3364,7 +3391,8 @@ static int class_check(struct v4l2_ctrl_handler *hdl, u32 which)
/* Get extended controls. Allocates the helpers array if needed. */ /* Get extended controls. Allocates the helpers array if needed. */
static int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl, static int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
struct v4l2_ext_controls *cs) struct v4l2_ext_controls *cs,
struct video_device *vdev)
{ {
struct v4l2_ctrl_helper helper[4]; struct v4l2_ctrl_helper helper[4];
struct v4l2_ctrl_helper *helpers = helper; struct v4l2_ctrl_helper *helpers = helper;
@ -3390,7 +3418,7 @@ static int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
return -ENOMEM; return -ENOMEM;
} }
ret = prepare_ext_ctrls(hdl, cs, helpers, true); ret = prepare_ext_ctrls(hdl, cs, helpers, vdev, true);
cs->error_idx = cs->count; cs->error_idx = cs->count;
for (i = 0; !ret && i < cs->count; i++) for (i = 0; !ret && i < cs->count; i++)
@ -3483,8 +3511,8 @@ v4l2_ctrls_find_req_obj(struct v4l2_ctrl_handler *hdl,
return obj; return obj;
} }
int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct media_device *mdev, int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct video_device *vdev,
struct v4l2_ext_controls *cs) struct media_device *mdev, struct v4l2_ext_controls *cs)
{ {
struct media_request_object *obj = NULL; struct media_request_object *obj = NULL;
struct media_request *req = NULL; struct media_request *req = NULL;
@ -3520,7 +3548,7 @@ int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct media_device *mdev,
req_obj); req_obj);
} }
ret = v4l2_g_ext_ctrls_common(hdl, cs); ret = v4l2_g_ext_ctrls_common(hdl, cs, vdev);
if (obj) { if (obj) {
media_request_unlock_for_access(req); media_request_unlock_for_access(req);
@ -3663,7 +3691,9 @@ static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
/* Validate controls. */ /* Validate controls. */
static int validate_ctrls(struct v4l2_ext_controls *cs, static int validate_ctrls(struct v4l2_ext_controls *cs,
struct v4l2_ctrl_helper *helpers, bool set) struct v4l2_ctrl_helper *helpers,
struct video_device *vdev,
bool set)
{ {
unsigned i; unsigned i;
int ret = 0; int ret = 0;
@ -3675,16 +3705,24 @@ static int validate_ctrls(struct v4l2_ext_controls *cs,
cs->error_idx = i; cs->error_idx = i;
if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY) if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY) {
dprintk(vdev,
"control id 0x%x is read-only\n",
ctrl->id);
return -EACCES; return -EACCES;
}
/* This test is also done in try_set_control_cluster() which /* This test is also done in try_set_control_cluster() which
is called in atomic context, so that has the final say, is called in atomic context, so that has the final say,
but it makes sense to do an up-front check as well. Once but it makes sense to do an up-front check as well. Once
an error occurs in try_set_control_cluster() some other an error occurs in try_set_control_cluster() some other
controls may have been set already and we want to do a controls may have been set already and we want to do a
best-effort to avoid that. */ best-effort to avoid that. */
if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)) if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)) {
dprintk(vdev,
"control id 0x%x is grabbed, cannot set\n",
ctrl->id);
return -EBUSY; return -EBUSY;
}
/* /*
* Skip validation for now if the payload needs to be copied * Skip validation for now if the payload needs to be copied
* from userspace into kernelspace. We'll validate those later. * from userspace into kernelspace. We'll validate those later.
@ -3719,7 +3757,8 @@ static void update_from_auto_cluster(struct v4l2_ctrl *master)
/* Try or try-and-set controls */ /* Try or try-and-set controls */
static int try_set_ext_ctrls_common(struct v4l2_fh *fh, static int try_set_ext_ctrls_common(struct v4l2_fh *fh,
struct v4l2_ctrl_handler *hdl, struct v4l2_ctrl_handler *hdl,
struct v4l2_ext_controls *cs, bool set) struct v4l2_ext_controls *cs,
struct video_device *vdev, bool set)
{ {
struct v4l2_ctrl_helper helper[4]; struct v4l2_ctrl_helper helper[4];
struct v4l2_ctrl_helper *helpers = helper; struct v4l2_ctrl_helper *helpers = helper;
@ -3729,13 +3768,19 @@ static int try_set_ext_ctrls_common(struct v4l2_fh *fh,
cs->error_idx = cs->count; cs->error_idx = cs->count;
/* Default value cannot be changed */ /* Default value cannot be changed */
if (cs->which == V4L2_CTRL_WHICH_DEF_VAL) if (cs->which == V4L2_CTRL_WHICH_DEF_VAL) {
dprintk(vdev, "%s: cannot change default value\n",
video_device_node_name(vdev));
return -EINVAL; return -EINVAL;
}
cs->which = V4L2_CTRL_ID2WHICH(cs->which); cs->which = V4L2_CTRL_ID2WHICH(cs->which);
if (hdl == NULL) if (hdl == NULL) {
dprintk(vdev, "%s: invalid null control handler\n",
video_device_node_name(vdev));
return -EINVAL; return -EINVAL;
}
if (cs->count == 0) if (cs->count == 0)
return class_check(hdl, cs->which); return class_check(hdl, cs->which);
@ -3746,9 +3791,9 @@ static int try_set_ext_ctrls_common(struct v4l2_fh *fh,
if (!helpers) if (!helpers)
return -ENOMEM; return -ENOMEM;
} }
ret = prepare_ext_ctrls(hdl, cs, helpers, false); ret = prepare_ext_ctrls(hdl, cs, helpers, vdev, false);
if (!ret) if (!ret)
ret = validate_ctrls(cs, helpers, set); ret = validate_ctrls(cs, helpers, vdev, set);
if (ret && set) if (ret && set)
cs->error_idx = cs->count; cs->error_idx = cs->count;
for (i = 0; !ret && i < cs->count; i++) { for (i = 0; !ret && i < cs->count; i++) {
@ -3833,7 +3878,9 @@ static int try_set_ext_ctrls_common(struct v4l2_fh *fh,
} }
static int try_set_ext_ctrls(struct v4l2_fh *fh, static int try_set_ext_ctrls(struct v4l2_fh *fh,
struct v4l2_ctrl_handler *hdl, struct media_device *mdev, struct v4l2_ctrl_handler *hdl,
struct video_device *vdev,
struct media_device *mdev,
struct v4l2_ext_controls *cs, bool set) struct v4l2_ext_controls *cs, bool set)
{ {
struct media_request_object *obj = NULL; struct media_request_object *obj = NULL;
@ -3841,21 +3888,39 @@ static int try_set_ext_ctrls(struct v4l2_fh *fh,
int ret; int ret;
if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL) { if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL) {
if (!mdev || cs->request_fd < 0) if (!mdev) {
dprintk(vdev, "%s: missing media device\n",
video_device_node_name(vdev));
return -EINVAL; return -EINVAL;
}
if (cs->request_fd < 0) {
dprintk(vdev, "%s: invalid request fd %d\n",
video_device_node_name(vdev), cs->request_fd);
return -EINVAL;
}
req = media_request_get_by_fd(mdev, cs->request_fd); req = media_request_get_by_fd(mdev, cs->request_fd);
if (IS_ERR(req)) if (IS_ERR(req)) {
dprintk(vdev, "%s: cannot find request fd %d\n",
video_device_node_name(vdev), cs->request_fd);
return PTR_ERR(req); return PTR_ERR(req);
}
ret = media_request_lock_for_update(req); ret = media_request_lock_for_update(req);
if (ret) { if (ret) {
dprintk(vdev, "%s: cannot lock request fd %d\n",
video_device_node_name(vdev), cs->request_fd);
media_request_put(req); media_request_put(req);
return ret; return ret;
} }
obj = v4l2_ctrls_find_req_obj(hdl, req, set); obj = v4l2_ctrls_find_req_obj(hdl, req, set);
if (IS_ERR(obj)) { if (IS_ERR(obj)) {
dprintk(vdev,
"%s: cannot find request object for request fd %d\n",
video_device_node_name(vdev),
cs->request_fd);
media_request_unlock_for_update(req); media_request_unlock_for_update(req);
media_request_put(req); media_request_put(req);
return PTR_ERR(obj); return PTR_ERR(obj);
@ -3864,7 +3929,11 @@ static int try_set_ext_ctrls(struct v4l2_fh *fh,
req_obj); req_obj);
} }
ret = try_set_ext_ctrls_common(fh, hdl, cs, set); ret = try_set_ext_ctrls_common(fh, hdl, cs, vdev, set);
if (ret)
dprintk(vdev,
"%s: try_set_ext_ctrls_common failed (%d)\n",
video_device_node_name(vdev), ret);
if (obj) { if (obj) {
media_request_unlock_for_update(req); media_request_unlock_for_update(req);
@ -3875,17 +3944,22 @@ static int try_set_ext_ctrls(struct v4l2_fh *fh,
return ret; return ret;
} }
int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct media_device *mdev, int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl,
struct video_device *vdev,
struct media_device *mdev,
struct v4l2_ext_controls *cs) struct v4l2_ext_controls *cs)
{ {
return try_set_ext_ctrls(NULL, hdl, mdev, cs, false); return try_set_ext_ctrls(NULL, hdl, vdev, mdev, cs, false);
} }
EXPORT_SYMBOL(v4l2_try_ext_ctrls); EXPORT_SYMBOL(v4l2_try_ext_ctrls);
int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl, int v4l2_s_ext_ctrls(struct v4l2_fh *fh,
struct media_device *mdev, struct v4l2_ext_controls *cs) struct v4l2_ctrl_handler *hdl,
struct video_device *vdev,
struct media_device *mdev,
struct v4l2_ext_controls *cs)
{ {
return try_set_ext_ctrls(fh, hdl, mdev, cs, true); return try_set_ext_ctrls(fh, hdl, vdev, mdev, cs, true);
} }
EXPORT_SYMBOL(v4l2_s_ext_ctrls); EXPORT_SYMBOL(v4l2_s_ext_ctrls);

18
drivers/media/v4l2-core/v4l2-ioctl.c
View File

@ -2186,9 +2186,11 @@ static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops,
p->error_idx = p->count; p->error_idx = p->count;
if (vfh && vfh->ctrl_handler) if (vfh && vfh->ctrl_handler)
return v4l2_g_ext_ctrls(vfh->ctrl_handler, vfd->v4l2_dev->mdev, p); return v4l2_g_ext_ctrls(vfh->ctrl_handler,
vfd, vfd->v4l2_dev->mdev, p);
if (vfd->ctrl_handler) if (vfd->ctrl_handler)
return v4l2_g_ext_ctrls(vfd->ctrl_handler, vfd->v4l2_dev->mdev, p); return v4l2_g_ext_ctrls(vfd->ctrl_handler,
vfd, vfd->v4l2_dev->mdev, p);
if (ops->vidioc_g_ext_ctrls == NULL) if (ops->vidioc_g_ext_ctrls == NULL)
return -ENOTTY; return -ENOTTY;
return check_ext_ctrls(p, 0) ? ops->vidioc_g_ext_ctrls(file, fh, p) : return check_ext_ctrls(p, 0) ? ops->vidioc_g_ext_ctrls(file, fh, p) :
@ -2205,9 +2207,11 @@ static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops,
p->error_idx = p->count; p->error_idx = p->count;
if (vfh && vfh->ctrl_handler) if (vfh && vfh->ctrl_handler)
return v4l2_s_ext_ctrls(vfh, vfh->ctrl_handler, vfd->v4l2_dev->mdev, p); return v4l2_s_ext_ctrls(vfh, vfh->ctrl_handler,
vfd, vfd->v4l2_dev->mdev, p);
if (vfd->ctrl_handler) if (vfd->ctrl_handler)
return v4l2_s_ext_ctrls(NULL, vfd->ctrl_handler, vfd->v4l2_dev->mdev, p); return v4l2_s_ext_ctrls(NULL, vfd->ctrl_handler,
vfd, vfd->v4l2_dev->mdev, p);
if (ops->vidioc_s_ext_ctrls == NULL) if (ops->vidioc_s_ext_ctrls == NULL)
return -ENOTTY; return -ENOTTY;
return check_ext_ctrls(p, 0) ? ops->vidioc_s_ext_ctrls(file, fh, p) : return check_ext_ctrls(p, 0) ? ops->vidioc_s_ext_ctrls(file, fh, p) :
@ -2224,9 +2228,11 @@ static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
p->error_idx = p->count; p->error_idx = p->count;
if (vfh && vfh->ctrl_handler) if (vfh && vfh->ctrl_handler)
return v4l2_try_ext_ctrls(vfh->ctrl_handler, vfd->v4l2_dev->mdev, p); return v4l2_try_ext_ctrls(vfh->ctrl_handler,
vfd, vfd->v4l2_dev->mdev, p);
if (vfd->ctrl_handler) if (vfd->ctrl_handler)
return v4l2_try_ext_ctrls(vfd->ctrl_handler, vfd->v4l2_dev->mdev, p); return v4l2_try_ext_ctrls(vfd->ctrl_handler,
vfd, vfd->v4l2_dev->mdev, p);
if (ops->vidioc_try_ext_ctrls == NULL) if (ops->vidioc_try_ext_ctrls == NULL)
return -ENOTTY; return -ENOTTY;
return check_ext_ctrls(p, 0) ? ops->vidioc_try_ext_ctrls(file, fh, p) : return check_ext_ctrls(p, 0) ? ops->vidioc_try_ext_ctrls(file, fh, p) :

6
drivers/media/v4l2-core/v4l2-subdev.c
View File

@ -372,19 +372,19 @@ static long subdev_do_ioctl(struct file *file, unsigned int cmd, void *arg)
if (!vfh->ctrl_handler) if (!vfh->ctrl_handler)
return -ENOTTY; return -ENOTTY;
return v4l2_g_ext_ctrls(vfh->ctrl_handler, return v4l2_g_ext_ctrls(vfh->ctrl_handler,
sd->v4l2_dev->mdev, arg); vdev, sd->v4l2_dev->mdev, arg);
case VIDIOC_S_EXT_CTRLS: case VIDIOC_S_EXT_CTRLS:
if (!vfh->ctrl_handler) if (!vfh->ctrl_handler)
return -ENOTTY; return -ENOTTY;
return v4l2_s_ext_ctrls(vfh, vfh->ctrl_handler, return v4l2_s_ext_ctrls(vfh, vfh->ctrl_handler,
sd->v4l2_dev->mdev, arg); vdev, sd->v4l2_dev->mdev, arg);
case VIDIOC_TRY_EXT_CTRLS: case VIDIOC_TRY_EXT_CTRLS:
if (!vfh->ctrl_handler) if (!vfh->ctrl_handler)
return -ENOTTY; return -ENOTTY;
return v4l2_try_ext_ctrls(vfh->ctrl_handler, return v4l2_try_ext_ctrls(vfh->ctrl_handler,
sd->v4l2_dev->mdev, arg); vdev, sd->v4l2_dev->mdev, arg);
case VIDIOC_DQEVENT: case VIDIOC_DQEVENT:
if (!(sd->flags & V4L2_SUBDEV_FL_HAS_EVENTS)) if (!(sd->flags & V4L2_SUBDEV_FL_HAS_EVENTS))

9
include/media/v4l2-ctrls.h
View File

@ -1268,25 +1268,28 @@ int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
* :ref:`VIDIOC_G_EXT_CTRLS <vidioc_g_ext_ctrls>` ioctl * :ref:`VIDIOC_G_EXT_CTRLS <vidioc_g_ext_ctrls>` ioctl
* *
* @hdl: pointer to &struct v4l2_ctrl_handler * @hdl: pointer to &struct v4l2_ctrl_handler
* @vdev: pointer to &struct video_device
* @mdev: pointer to &struct media_device * @mdev: pointer to &struct media_device
* @c: pointer to &struct v4l2_ext_controls * @c: pointer to &struct v4l2_ext_controls
* *
* If hdl == NULL then they will all return -EINVAL. * If hdl == NULL then they will all return -EINVAL.
*/ */
int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct media_device *mdev, int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct video_device *vdev,
struct v4l2_ext_controls *c); struct media_device *mdev, struct v4l2_ext_controls *c);
/** /**
* v4l2_try_ext_ctrls - Helper function to implement * v4l2_try_ext_ctrls - Helper function to implement
* :ref:`VIDIOC_TRY_EXT_CTRLS <vidioc_g_ext_ctrls>` ioctl * :ref:`VIDIOC_TRY_EXT_CTRLS <vidioc_g_ext_ctrls>` ioctl
* *
* @hdl: pointer to &struct v4l2_ctrl_handler * @hdl: pointer to &struct v4l2_ctrl_handler
* @vdev: pointer to &struct video_device
* @mdev: pointer to &struct media_device * @mdev: pointer to &struct media_device
* @c: pointer to &struct v4l2_ext_controls * @c: pointer to &struct v4l2_ext_controls
* *
* If hdl == NULL then they will all return -EINVAL. * If hdl == NULL then they will all return -EINVAL.
*/ */
int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl,
struct video_device *vdev,
struct media_device *mdev, struct media_device *mdev,
struct v4l2_ext_controls *c); struct v4l2_ext_controls *c);
@ -1296,12 +1299,14 @@ int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl,
* *
* @fh: pointer to &struct v4l2_fh * @fh: pointer to &struct v4l2_fh
* @hdl: pointer to &struct v4l2_ctrl_handler * @hdl: pointer to &struct v4l2_ctrl_handler
* @vdev: pointer to &struct video_device
* @mdev: pointer to &struct media_device * @mdev: pointer to &struct media_device
* @c: pointer to &struct v4l2_ext_controls * @c: pointer to &struct v4l2_ext_controls
* *
* If hdl == NULL then they will all return -EINVAL. * If hdl == NULL then they will all return -EINVAL.
*/ */
int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl, int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
struct video_device *vdev,
struct media_device *mdev, struct media_device *mdev,
struct v4l2_ext_controls *c); struct v4l2_ext_controls *c);

2
include/media/v4l2-ioctl.h
View File

@ -602,6 +602,8 @@ struct v4l2_ioctl_ops {
#define V4L2_DEV_DEBUG_STREAMING 0x08 #define V4L2_DEV_DEBUG_STREAMING 0x08
/* Log poll() */ /* Log poll() */
#define V4L2_DEV_DEBUG_POLL 0x10 #define V4L2_DEV_DEBUG_POLL 0x10
/* Log controls */
#define V4L2_DEV_DEBUG_CTRL 0x20
/* Video standard functions */ /* Video standard functions */