tmakin/ack-tegra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

UPSTREAM: media: v4l2-ctrls: add support for V4L2_CTRL_WHICH_MIN/MAX_VAL

Browse Source 
Add the capability of retrieving the min and max values of a
compound control.

[Ricardo: Added static to v4l2_ctrl_type_op_(maximum|minimum) proto]
[Ricardo: Fix documentation]

Signed-off-by: Yunke Cao <yunkec@google.com>
Tested-by: Yunke Cao <yunkec@google.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
Link: https://lore.kernel.org/r/20250203-uvc-roi-v17-2-5900a9fed613@chromium.org
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>
[hverkuil: fix small alignment checkpatch warning]
(cherry picked from commit a5bd42aafb068427ecf4d6d34fa023944f211922)

Bug: 381493003
Bug: 408968367
Change-Id: I7dba61a9bc9fcf43efa26026f8a770042eb7e82f
Signed-off-by: Ricardo Ribalda <ribalda@google.com>
This commit is contained in:
Hans Verkuil
2025-02-03 11:55:38 +00:00
committed by Carlos Llamas
parent c3a37d931d
commit 6190e818c6
10 changed files with 248 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Documentation/userspace-api/media/v4l/vidioc-g-ext-ctrls.rst
+17 -5
View File
@@ -338,14 +338,26 @@ still cause this situation.
- Which value of the control to get/set/try.
* - :cspan:`2` ``V4L2_CTRL_WHICH_CUR_VAL`` will return the current value of
the control, ``V4L2_CTRL_WHICH_DEF_VAL`` will return the default
value of the control and ``V4L2_CTRL_WHICH_REQUEST_VAL`` indicates that
these controls have to be retrieved from a request or tried/set for
a request. In the latter case the ``request_fd`` field contains the
value of the control, ``V4L2_CTRL_WHICH_MIN_VAL`` will return the minimum
value of the control, and ``V4L2_CTRL_WHICH_MAX_VAL`` will return the maximum
value of the control. ``V4L2_CTRL_WHICH_REQUEST_VAL`` indicates that
the control value has to be retrieved from a request or tried/set for
a request. In that case the ``request_fd`` field contains the
file descriptor of the request that should be used. If the device
does not support requests, then ``EACCES`` will be returned.
When using ``V4L2_CTRL_WHICH_DEF_VAL`` be aware that you can only
get the default value of the control, you cannot set or try it.
When using ``V4L2_CTRL_WHICH_DEF_VAL``, ``V4L2_CTRL_WHICH_MIN_VAL``
or ``V4L2_CTRL_WHICH_MAX_VAL`` be aware that you can only get the
default/minimum/maximum value of the control, you cannot set or try it.
Whether a control supports querying the minimum and maximum values using
``V4L2_CTRL_WHICH_MIN_VAL`` and ``V4L2_CTRL_WHICH_MAX_VAL`` is indicated
by the ``V4L2_CTRL_FLAG_HAS_WHICH_MIN_MAX`` flag. Most non-compound
control types support this. For controls with compound types, the
definition of minimum/maximum values are provided by
the control documentation. If a compound control does not document the
meaning of minimum/maximum value, then querying the minimum or maximum
value will result in the error code -EINVAL.
For backwards compatibility you can also use a control class here
(see :ref:`ctrl-class`). In that case all controls have to
Documentation/userspace-api/media/v4l/vidioc-queryctrl.rst
+8 -1
View File
@@ -447,7 +447,10 @@ See also the examples in :ref:`control`.
- n/a
- A struct :c:type:`v4l2_rect`, containing a rectangle described by
the position of its top-left corner, the width and the height. Units
depend on the use case.
depend on the use case. Support for ``V4L2_CTRL_WHICH_MIN_VAL`` and
``V4L2_CTRL_WHICH_MAX_VAL`` is optional and depends on the
``V4L2_CTRL_FLAG_HAS_WHICH_MIN_MAX`` flag. See the documentation of
the specific control on how to interpret the minimum and maximum values.
* - ``V4L2_CTRL_TYPE_H264_SPS``
- n/a
- n/a
@@ -664,6 +667,10 @@ See also the examples in :ref:`control`.
``dims[0]``. So setting the control with a differently sized
array will change the ``elems`` field when the control is
queried afterwards.
* - ``V4L2_CTRL_FLAG_HAS_WHICH_MIN_MAX``
- 0x1000
- This control supports getting minimum and maximum values using
vidioc_g_ext_ctrls with V4L2_CTRL_WHICH_MIN/MAX_VAL.
Return Value
============
Documentation/userspace-api/media/videodev2.h.rst.exceptions
+3
View File
@@ -395,6 +395,7 @@ replace define V4L2_CTRL_FLAG_HAS_PAYLOAD control-flags
replace define V4L2_CTRL_FLAG_EXECUTE_ON_WRITE control-flags
replace define V4L2_CTRL_FLAG_MODIFY_LAYOUT control-flags
replace define V4L2_CTRL_FLAG_DYNAMIC_ARRAY control-flags
replace define V4L2_CTRL_FLAG_HAS_WHICH_MIN_MAX control-flags
replace define V4L2_CTRL_FLAG_NEXT_CTRL control
replace define V4L2_CTRL_FLAG_NEXT_COMPOUND control
@@ -569,6 +570,8 @@ ignore define V4L2_CTRL_DRIVER_PRIV
ignore define V4L2_CTRL_MAX_DIMS
ignore define V4L2_CTRL_WHICH_CUR_VAL
ignore define V4L2_CTRL_WHICH_DEF_VAL
ignore define V4L2_CTRL_WHICH_MIN_VAL
ignore define V4L2_CTRL_WHICH_MAX_VAL
ignore define V4L2_CTRL_WHICH_REQUEST_VAL
ignore define V4L2_OUT_CAP_CUSTOM_TIMINGS
ignore define V4L2_CID_MAX_CTRLS
drivers/media/i2c/imx214.c
+3 -1
View File
@@ -774,7 +774,9 @@ static int imx214_ctrls_init(struct imx214 *imx214)
imx214->unit_size = v4l2_ctrl_new_std_compound(ctrl_hdlr,
NULL,
V4L2_CID_UNIT_CELL_SIZE,
v4l2_ctrl_ptr_create((void *)&unit_size));
v4l2_ctrl_ptr_create((void *)&unit_size),
v4l2_ctrl_ptr_create(NULL),
v4l2_ctrl_ptr_create(NULL));
v4l2_ctrl_new_fwnode_properties(ctrl_hdlr, &imx214_ctrl_ops, &props);
drivers/media/platform/qcom/venus/venc_ctrls.c
+7 -2
View File
@@ -607,11 +607,16 @@ int venc_ctrl_init(struct venus_inst *inst)
v4l2_ctrl_new_std_compound(&inst->ctrl_handler, &venc_ctrl_ops,
V4L2_CID_COLORIMETRY_HDR10_CLL_INFO,
v4l2_ctrl_ptr_create(&p_hdr10_cll));
v4l2_ctrl_ptr_create(&p_hdr10_cll),
v4l2_ctrl_ptr_create(NULL),
v4l2_ctrl_ptr_create(NULL));
v4l2_ctrl_new_std_compound(&inst->ctrl_handler, &venc_ctrl_ops,
V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY,
v4l2_ctrl_ptr_create((void *)&p_hdr10_mastering));
v4l2_ctrl_ptr_create((void *)&p_hdr10_mastering),
v4l2_ctrl_ptr_create(NULL),
v4l2_ctrl_ptr_create(NULL));
v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE,
drivers/media/v4l2-core/v4l2-ctrls-api.c
+44 -10
View File
@@ -94,6 +94,22 @@ static int def_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
return ptr_to_user(c, ctrl, ctrl->p_new);
}
/* Helper function: copy the minimum control value back to the caller */
static int min_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
{
ctrl->type_ops->minimum(ctrl, 0, ctrl->p_new);
return ptr_to_user(c, ctrl, ctrl->p_new);
}
/* Helper function: copy the maximum control value back to the caller */
static int max_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
{
ctrl->type_ops->maximum(ctrl, 0, ctrl->p_new);
return ptr_to_user(c, ctrl, ctrl->p_new);
}
/* Helper function: copy the caller-provider value as the new control value */
static int user_to_new(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
{
@@ -229,8 +245,8 @@ static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
cs->error_idx = i;
if (cs->which &&
cs->which != V4L2_CTRL_WHICH_DEF_VAL &&
cs->which != V4L2_CTRL_WHICH_REQUEST_VAL &&
(cs->which < V4L2_CTRL_WHICH_DEF_VAL ||
cs->which > V4L2_CTRL_WHICH_MAX_VAL) &&
V4L2_CTRL_ID2WHICH(id) != cs->which) {
dprintk(vdev,
"invalid which 0x%x or control id 0x%x\n",
@@ -259,6 +275,15 @@ static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
return -EINVAL;
}
if (!(ctrl->flags & V4L2_CTRL_FLAG_HAS_WHICH_MIN_MAX) &&
(cs->which == V4L2_CTRL_WHICH_MIN_VAL ||
cs->which == V4L2_CTRL_WHICH_MAX_VAL)) {
dprintk(vdev,
"invalid which 0x%x or control id 0x%x\n",
cs->which, id);
return -EINVAL;
}
if (ctrl->cluster[0]->ncontrols > 1)
have_clusters = true;
if (ctrl->cluster[0] != ctrl)
@@ -368,8 +393,8 @@ static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
*/
static int class_check(struct v4l2_ctrl_handler *hdl, u32 which)
{
if (which == 0 || which == V4L2_CTRL_WHICH_DEF_VAL ||
which == V4L2_CTRL_WHICH_REQUEST_VAL)
if (which == 0 || (which >= V4L2_CTRL_WHICH_DEF_VAL &&
which <= V4L2_CTRL_WHICH_MAX_VAL))
return 0;
return find_ref_lock(hdl, which | 1) ? 0 : -EINVAL;
}
@@ -389,10 +414,12 @@ int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
struct v4l2_ctrl_helper *helpers = helper;
int ret;
int i, j;
bool is_default, is_request;
bool is_default, is_request, is_min, is_max;
is_default = (cs->which == V4L2_CTRL_WHICH_DEF_VAL);
is_request = (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL);
is_min = (cs->which == V4L2_CTRL_WHICH_MIN_VAL);
is_max = (cs->which == V4L2_CTRL_WHICH_MAX_VAL);
cs->error_idx = cs->count;
cs->which = V4L2_CTRL_ID2WHICH(cs->which);
@@ -432,13 +459,14 @@ int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
/*
* g_volatile_ctrl will update the new control values.
* This makes no sense for V4L2_CTRL_WHICH_DEF_VAL and
* This makes no sense for V4L2_CTRL_WHICH_DEF_VAL,
* V4L2_CTRL_WHICH_MIN_VAL, V4L2_CTRL_WHICH_MAX_VAL and
* V4L2_CTRL_WHICH_REQUEST_VAL. In the case of requests
* it is v4l2_ctrl_request_complete() that copies the
* volatile controls at the time of request completion
* to the request, so you don't want to do that again.
*/
if (!is_default && !is_request &&
if (!is_default && !is_request && !is_min && !is_max &&
((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
(master->has_volatiles && !is_cur_manual(master)))) {
for (j = 0; j < master->ncontrols; j++)
@@ -467,6 +495,10 @@ int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
ret = -ENOMEM;
else if (is_request && ref->p_req_valid)
ret = req_to_user(cs->controls + idx, ref);
else if (is_min)
ret = min_to_user(cs->controls + idx, ref->ctrl);
else if (is_max)
ret = max_to_user(cs->controls + idx, ref->ctrl);
else if (is_volatile)
ret = new_to_user(cs->controls + idx, ref->ctrl);
else
@@ -564,9 +596,11 @@ int try_set_ext_ctrls_common(struct v4l2_fh *fh,
cs->error_idx = cs->count;
/* Default value cannot be changed */
if (cs->which == V4L2_CTRL_WHICH_DEF_VAL) {
dprintk(vdev, "%s: cannot change default value\n",
/* Default/minimum/maximum values cannot be changed */
if (cs->which == V4L2_CTRL_WHICH_DEF_VAL ||
cs->which == V4L2_CTRL_WHICH_MIN_VAL ||
cs->which == V4L2_CTRL_WHICH_MAX_VAL) {
dprintk(vdev, "%s: cannot change default/min/max value\n",
video_device_node_name(vdev));
return -EINVAL;
}
drivers/media/v4l2-core/v4l2-ctrls-core.c
+129 -24
View File
@@ -182,29 +182,66 @@ static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx,
}
}
void v4l2_ctrl_type_op_init(const struct v4l2_ctrl *ctrl, u32 from_idx,
union v4l2_ctrl_ptr ptr)
static void std_min_compound(const struct v4l2_ctrl *ctrl, u32 idx,
union v4l2_ctrl_ptr ptr)
{
void *p = ptr.p + idx * ctrl->elem_size;
if (ctrl->p_min.p_const)
memcpy(p, ctrl->p_min.p_const, ctrl->elem_size);
else
memset(p, 0, ctrl->elem_size);
}
static void std_max_compound(const struct v4l2_ctrl *ctrl, u32 idx,
union v4l2_ctrl_ptr ptr)
{
void *p = ptr.p + idx * ctrl->elem_size;
if (ctrl->p_max.p_const)
memcpy(p, ctrl->p_max.p_const, ctrl->elem_size);
else
memset(p, 0, ctrl->elem_size);
}
static void __v4l2_ctrl_type_op_init(const struct v4l2_ctrl *ctrl, u32 from_idx,
u32 which, union v4l2_ctrl_ptr ptr)
{
unsigned int i;
u32 tot_elems = ctrl->elems;
u32 elems = tot_elems - from_idx;
s64 value;
if (from_idx >= tot_elems)
switch (which) {
case V4L2_CTRL_WHICH_DEF_VAL:
value = ctrl->default_value;
break;
case V4L2_CTRL_WHICH_MAX_VAL:
value = ctrl->maximum;
break;
case V4L2_CTRL_WHICH_MIN_VAL:
value = ctrl->minimum;
break;
default:
return;
}
switch (ctrl->type) {
case V4L2_CTRL_TYPE_STRING:
if (which == V4L2_CTRL_WHICH_DEF_VAL)
value = ctrl->minimum;
for (i = from_idx; i < tot_elems; i++) {
unsigned int offset = i * ctrl->elem_size;
memset(ptr.p_char + offset, ' ', ctrl->minimum);
ptr.p_char[offset + ctrl->minimum] = '\0';
memset(ptr.p_char + offset, ' ', value);
ptr.p_char[offset + value] = '\0';
}
break;
case V4L2_CTRL_TYPE_INTEGER64:
if (ctrl->default_value) {
if (value) {
for (i = from_idx; i < tot_elems; i++)
ptr.p_s64[i] = ctrl->default_value;
ptr.p_s64[i] = value;
} else {
memset(ptr.p_s64 + from_idx, 0, elems * sizeof(s64));
}
@@ -214,9 +251,9 @@ void v4l2_ctrl_type_op_init(const struct v4l2_ctrl *ctrl, u32 from_idx,
case V4L2_CTRL_TYPE_MENU:
case V4L2_CTRL_TYPE_BITMASK:
case V4L2_CTRL_TYPE_BOOLEAN:
if (ctrl->default_value) {
if (value) {
for (i = from_idx; i < tot_elems; i++)
ptr.p_s32[i] = ctrl->default_value;
ptr.p_s32[i] = value;
} else {
memset(ptr.p_s32 + from_idx, 0, elems * sizeof(s32));
}
@@ -226,32 +263,61 @@ void v4l2_ctrl_type_op_init(const struct v4l2_ctrl *ctrl, u32 from_idx,
memset(ptr.p_s32 + from_idx, 0, elems * sizeof(s32));
break;
case V4L2_CTRL_TYPE_U8:
memset(ptr.p_u8 + from_idx, ctrl->default_value, elems);
memset(ptr.p_u8 + from_idx, value, elems);
break;
case V4L2_CTRL_TYPE_U16:
if (ctrl->default_value) {
if (value) {
for (i = from_idx; i < tot_elems; i++)
ptr.p_u16[i] = ctrl->default_value;
ptr.p_u16[i] = value;
} else {
memset(ptr.p_u16 + from_idx, 0, elems * sizeof(u16));
}
break;
case V4L2_CTRL_TYPE_U32:
if (ctrl->default_value) {
if (value) {
for (i = from_idx; i < tot_elems; i++)
ptr.p_u32[i] = ctrl->default_value;
ptr.p_u32[i] = value;
} else {
memset(ptr.p_u32 + from_idx, 0, elems * sizeof(u32));
}
break;
default:
for (i = from_idx; i < tot_elems; i++)
std_init_compound(ctrl, i, ptr);
for (i = from_idx; i < tot_elems; i++) {
switch (which) {
case V4L2_CTRL_WHICH_DEF_VAL:
std_init_compound(ctrl, i, ptr);
break;
case V4L2_CTRL_WHICH_MAX_VAL:
std_max_compound(ctrl, i, ptr);
break;
case V4L2_CTRL_WHICH_MIN_VAL:
std_min_compound(ctrl, i, ptr);
break;
}
}
break;
}
}
void v4l2_ctrl_type_op_init(const struct v4l2_ctrl *ctrl, u32 from_idx,
union v4l2_ctrl_ptr ptr)
{
__v4l2_ctrl_type_op_init(ctrl, from_idx, V4L2_CTRL_WHICH_DEF_VAL, ptr);
}
EXPORT_SYMBOL(v4l2_ctrl_type_op_init);
static void v4l2_ctrl_type_op_minimum(const struct v4l2_ctrl *ctrl,
u32 from_idx, union v4l2_ctrl_ptr ptr)
{
__v4l2_ctrl_type_op_init(ctrl, from_idx, V4L2_CTRL_WHICH_MIN_VAL, ptr);
}
static void v4l2_ctrl_type_op_maximum(const struct v4l2_ctrl *ctrl,
u32 from_idx, union v4l2_ctrl_ptr ptr)
{
__v4l2_ctrl_type_op_init(ctrl, from_idx, V4L2_CTRL_WHICH_MAX_VAL, ptr);
}
void v4l2_ctrl_type_op_log(const struct v4l2_ctrl *ctrl)
{
union v4l2_ctrl_ptr ptr = ctrl->p_cur;
@@ -1296,6 +1362,8 @@ EXPORT_SYMBOL(v4l2_ctrl_type_op_validate);
static const struct v4l2_ctrl_type_ops std_type_ops = {
.equal = v4l2_ctrl_type_op_equal,
.init = v4l2_ctrl_type_op_init,
.minimum = v4l2_ctrl_type_op_minimum,
.maximum = v4l2_ctrl_type_op_maximum,
.log = v4l2_ctrl_type_op_log,
.validate = v4l2_ctrl_type_op_validate,
};
@@ -1768,7 +1836,10 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
s64 min, s64 max, u64 step, s64 def,
const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
u32 flags, const char * const *qmenu,
const s64 *qmenu_int, const union v4l2_ctrl_ptr p_def,
const s64 *qmenu_int,
const union v4l2_ctrl_ptr p_def,
const union v4l2_ctrl_ptr p_min,
const union v4l2_ctrl_ptr p_max,
void *priv)
{
struct v4l2_ctrl *ctrl;
@@ -1892,6 +1963,12 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
break;
}
if (type < V4L2_CTRL_COMPOUND_TYPES &&
type != V4L2_CTRL_TYPE_BUTTON &&
type != V4L2_CTRL_TYPE_CTRL_CLASS &&
type != V4L2_CTRL_TYPE_STRING)
flags |= V4L2_CTRL_FLAG_HAS_WHICH_MIN_MAX;
/* Sanity checks */
if (id == 0 || name == NULL || !elem_size ||
id >= V4L2_CID_PRIVATE_BASE ||
@@ -1900,6 +1977,7 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
handler_set_err(hdl, -ERANGE);
return NULL;
}
err = check_range(type, min, max, step, def);
if (err) {
handler_set_err(hdl, err);
@@ -1941,6 +2019,10 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const)
sz_extra += elem_size;
if (type >= V4L2_CTRL_COMPOUND_TYPES && p_min.p_const)
sz_extra += elem_size;
if (type >= V4L2_CTRL_COMPOUND_TYPES && p_max.p_const)
sz_extra += elem_size;
ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
if (ctrl == NULL) {
@@ -2006,6 +2088,22 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
memcpy(ctrl->p_def.p, p_def.p_const, elem_size);
}
if (flags & V4L2_CTRL_FLAG_HAS_WHICH_MIN_MAX) {
void *ptr = ctrl->p_def.p;
if (p_min.p_const) {
ptr += elem_size;
ctrl->p_min.p = ptr;
memcpy(ctrl->p_min.p, p_min.p_const, elem_size);
}
if (p_max.p_const) {
ptr += elem_size;
ctrl->p_max.p = ptr;
memcpy(ctrl->p_max.p, p_max.p_const, elem_size);
}
}
ctrl->type_ops->init(ctrl, 0, ctrl->p_cur);
cur_to_new(ctrl);
@@ -2056,7 +2154,8 @@ struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
type, min, max,
is_menu ? cfg->menu_skip_mask : step, def,
cfg->dims, cfg->elem_size,
flags, qmenu, qmenu_int, cfg->p_def, priv);
flags, qmenu, qmenu_int, cfg->p_def, cfg->p_min,
cfg->p_max, priv);
if (ctrl)
ctrl->is_private = cfg->is_private;
return ctrl;
@@ -2081,7 +2180,8 @@ struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
}
return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
min, max, step, def, NULL, 0,
flags, NULL, NULL, ptr_null, NULL);
flags, NULL, NULL, ptr_null, ptr_null,
ptr_null, NULL);
}
EXPORT_SYMBOL(v4l2_ctrl_new_std);
@@ -2114,7 +2214,8 @@ struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
}
return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
0, max, mask, def, NULL, 0,
flags, qmenu, qmenu_int, ptr_null, NULL);
flags, qmenu, qmenu_int, ptr_null, ptr_null,
ptr_null, NULL);
}
EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
@@ -2146,7 +2247,8 @@ struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
}
return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
0, max, mask, def, NULL, 0,
flags, qmenu, NULL, ptr_null, NULL);
flags, qmenu, NULL, ptr_null, ptr_null,
ptr_null, NULL);
}
EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
@@ -2154,7 +2256,9 @@ EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
/* Helper function for standard compound controls */
struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl,
const struct v4l2_ctrl_ops *ops, u32 id,
const union v4l2_ctrl_ptr p_def)
const union v4l2_ctrl_ptr p_def,
const union v4l2_ctrl_ptr p_min,
const union v4l2_ctrl_ptr p_max)
{
const char *name;
enum v4l2_ctrl_type type;
@@ -2168,7 +2272,7 @@ struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl,
}
return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
min, max, step, def, NULL, 0,
flags, NULL, NULL, p_def, NULL);
flags, NULL, NULL, p_def, p_min, p_max, NULL);
}
EXPORT_SYMBOL(v4l2_ctrl_new_std_compound);
@@ -2192,7 +2296,8 @@ struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
}
return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
0, max, 0, def, NULL, 0,
flags, NULL, qmenu_int, ptr_null, NULL);
flags, NULL, qmenu_int, ptr_null, ptr_null,
ptr_null, NULL);
}
EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
drivers/media/v4l2-core/v4l2-ioctl.c
+3 -1
View File
@@ -893,7 +893,9 @@ static bool check_ext_ctrls(struct v4l2_ext_controls *c, unsigned long ioctl)
return false;
break;
case V4L2_CTRL_WHICH_DEF_VAL:
/* Default value cannot be changed */
case V4L2_CTRL_WHICH_MIN_VAL:
case V4L2_CTRL_WHICH_MAX_VAL:
/* Default, minimum or maximum value cannot be changed */
if (ioctl == VIDIOC_S_EXT_CTRLS ||
ioctl == VIDIOC_TRY_EXT_CTRLS) {
c->error_idx = c->count;
include/media/v4l2-ctrls.h
+31 -5
View File
@@ -133,6 +133,8 @@ struct v4l2_ctrl_ops {
*
* @equal: return true if all ctrl->elems array elements are equal.
* @init: initialize the value for array elements from from_idx to ctrl->elems.
* @minimum: set the value to the minimum value of the control.
* @maximum: set the value to the maximum value of the control.
* @log: log the value.
* @validate: validate the value for ctrl->new_elems array elements.
* Return 0 on success and a negative value otherwise.
@@ -142,6 +144,10 @@ struct v4l2_ctrl_type_ops {
union v4l2_ctrl_ptr ptr1, union v4l2_ctrl_ptr ptr2);
void (*init)(const struct v4l2_ctrl *ctrl, u32 from_idx,
union v4l2_ctrl_ptr ptr);
void (*minimum)(const struct v4l2_ctrl *ctrl, u32 idx,
union v4l2_ctrl_ptr ptr);
void (*maximum)(const struct v4l2_ctrl *ctrl, u32 idx,
union v4l2_ctrl_ptr ptr);
void (*log)(const struct v4l2_ctrl *ctrl);
int (*validate)(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr ptr);
};
@@ -247,6 +253,12 @@ typedef void (*v4l2_ctrl_notify_fnc)(struct v4l2_ctrl *ctrl, void *priv);
* @p_def: The control's default value represented via a union which
* provides a standard way of accessing control types
* through a pointer (for compound controls only).
* @p_min: The control's minimum value represented via a union which
* provides a standard way of accessing control types
* through a pointer (for compound controls only).
* @p_max: The control's maximum value represented via a union which
* provides a standard way of accessing control types
* through a pointer (for compound controls only).
* @p_cur: The control's current value represented via a union which
* provides a standard way of accessing control types
* through a pointer.
@@ -306,6 +318,8 @@ struct v4l2_ctrl {
} cur;
union v4l2_ctrl_ptr p_def;
union v4l2_ctrl_ptr p_min;
union v4l2_ctrl_ptr p_max;
union v4l2_ctrl_ptr p_new;
union v4l2_ctrl_ptr p_cur;
};
@@ -425,6 +439,8 @@ struct v4l2_ctrl_handler {
* @step: The control's step value for non-menu controls.
* @def: The control's default value.
* @p_def: The control's default value for compound controls.
* @p_min: The control's minimum value for compound controls.
* @p_max: The control's maximum value for compound controls.
* @dims: The size of each dimension.
* @elem_size: The size in bytes of the control.
* @flags: The control's flags.
@@ -454,6 +470,8 @@ struct v4l2_ctrl_config {
u64 step;
s64 def;
union v4l2_ctrl_ptr p_def;
union v4l2_ctrl_ptr p_min;
union v4l2_ctrl_ptr p_max;
u32 dims[V4L2_CTRL_MAX_DIMS];
u32 elem_size;
u32 flags;
@@ -723,17 +741,25 @@ struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
* @ops: The control ops.
* @id: The control ID.
* @p_def: The control's default value.
* @p_min: The control's minimum value.
* @p_max: The control's maximum value.
*
* Sames as v4l2_ctrl_new_std(), but with support to compound controls, thanks
* to the @p_def field. Use v4l2_ctrl_ptr_create() to create @p_def from a
* pointer. Use v4l2_ctrl_ptr_create(NULL) if the default value of the
* compound control should be all zeroes.
* Same as v4l2_ctrl_new_std(), but with support for compound controls.
* To fill in the @p_def, @p_min and @p_max fields, use v4l2_ctrl_ptr_create()
* to convert a pointer to a const union v4l2_ctrl_ptr.
* Use v4l2_ctrl_ptr_create(NULL) if you want the default, minimum or maximum
* value of the compound control to be all zeroes.
* If the compound control does not set the ``V4L2_CTRL_FLAG_HAS_WHICH_MIN_MAX``
* flag, then it does not has minimum and maximum values. In that case just use
* v4l2_ctrl_ptr_create(NULL) for the @p_min and @p_max arguments.
*
*/
struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl,
const struct v4l2_ctrl_ops *ops,
u32 id,
const union v4l2_ctrl_ptr p_def);
const union v4l2_ctrl_ptr p_def,
const union v4l2_ctrl_ptr p_min,
const union v4l2_ctrl_ptr p_max);
/**
* v4l2_ctrl_new_int_menu() - Create a new standard V4L2 integer menu control.
include/uapi/linux/videodev2.h
+3
View File
@@ -1906,6 +1906,8 @@ struct v4l2_ext_controls {
#define V4L2_CTRL_WHICH_CUR_VAL 0
#define V4L2_CTRL_WHICH_DEF_VAL 0x0f000000
#define V4L2_CTRL_WHICH_REQUEST_VAL 0x0f010000
#define V4L2_CTRL_WHICH_MIN_VAL 0x0f020000
#define V4L2_CTRL_WHICH_MAX_VAL 0x0f030000
enum v4l2_ctrl_type {
V4L2_CTRL_TYPE_INTEGER = 1,
@@ -2013,6 +2015,7 @@ struct v4l2_querymenu {
#define V4L2_CTRL_FLAG_EXECUTE_ON_WRITE 0x0200
#define V4L2_CTRL_FLAG_MODIFY_LAYOUT 0x0400
#define V4L2_CTRL_FLAG_DYNAMIC_ARRAY 0x0800
#define V4L2_CTRL_FLAG_HAS_WHICH_MIN_MAX 0x1000
/* Query flags, to be ORed with the control ID */
#define V4L2_CTRL_FLAG_NEXT_CTRL 0x80000000