[v4,2/4] media: v4l2_ctrl: Add V4L2_CTRL_WHICH_MIN/MAX_VAL
Commit Message
Added V4L2_CTRL_WHICH_MIN/MAX_VAL and basic support in v4l2-core.
Mostly reusing a previous attempt:
https://lore.kernel.org/all/20191220134843.25977-1-m.tretter@pengutronix.de/T/#m5c83970af8b774a4b1ea5f2dca4c0a534da4ccbe
Signed-off-by: Yunke Cao <yunkec@google.com>
---
.../media/v4l/vidioc-g-ext-ctrls.rst | 8 +-
.../media/videodev2.h.rst.exceptions | 2 +
drivers/media/i2c/imx214.c | 4 +-
drivers/media/v4l2-core/v4l2-ctrls-api.c | 51 +++++--
drivers/media/v4l2-core/v4l2-ctrls-core.c | 135 ++++++++++++++++--
drivers/media/v4l2-core/v4l2-ioctl.c | 4 +-
include/media/v4l2-ctrls.h | 30 +++-
include/uapi/linux/videodev2.h | 2 +
8 files changed, 209 insertions(+), 27 deletions(-)
Comments
Hi Yunke
On Tue, 24 May 2022 at 06:45, Yunke Cao <yunkec@google.com> wrote:
>
> Added V4L2_CTRL_WHICH_MIN/MAX_VAL and basic support in v4l2-core.
>
> Mostly reusing a previous attempt:
> https://lore.kernel.org/all/20191220134843.25977-1-m.tretter@pengutronix.de/T/#m5c83970af8b774a4b1ea5f2dca4c0a534da4ccbe
maybe: https://lore.kernel.org/all/20191119113457.57833-3-hverkuil-cisco@xs4all.nl/
>
> Signed-off-by: Yunke Cao <yunkec@google.com>
I think it is not official, but I like the tag:
Credit-to:
Instead of sending your version. Could you cherry-pick Hans patch?
You could add after the
====
how did you solve the conflicts
(if it is too different from Hans, please disregard this message)
> ---
> .../media/v4l/vidioc-g-ext-ctrls.rst | 8 +-
> .../media/videodev2.h.rst.exceptions | 2 +
> drivers/media/i2c/imx214.c | 4 +-
> drivers/media/v4l2-core/v4l2-ctrls-api.c | 51 +++++--
> drivers/media/v4l2-core/v4l2-ctrls-core.c | 135 ++++++++++++++++--
> drivers/media/v4l2-core/v4l2-ioctl.c | 4 +-
> include/media/v4l2-ctrls.h | 30 +++-
> include/uapi/linux/videodev2.h | 2 +
> 8 files changed, 209 insertions(+), 27 deletions(-)
>
> diff --git a/Documentation/userspace-api/media/v4l/vidioc-g-ext-ctrls.rst b/Documentation/userspace-api/media/v4l/vidioc-g-ext-ctrls.rst
> index f4e205ead0a2..a89577726efa 100644
> --- a/Documentation/userspace-api/media/v4l/vidioc-g-ext-ctrls.rst
> +++ b/Documentation/userspace-api/media/v4l/vidioc-g-ext-ctrls.rst
> @@ -284,14 +284,18 @@ 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, ``V4L2_CTRL_WHICH_MIN_VAL`` will return the minimum
> + value of the control, ``V4L2_CTRL_WHICH_MAX_VAL`` will return the maximum
> 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
> 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.
>
> For backwards compatibility you can also use a control class here
> (see :ref:`ctrl-class`). In that case all controls have to
> diff --git a/Documentation/userspace-api/media/videodev2.h.rst.exceptions b/Documentation/userspace-api/media/videodev2.h.rst.exceptions
> index 7b423475281d..e2dde31d76df 100644
> --- a/Documentation/userspace-api/media/videodev2.h.rst.exceptions
> +++ b/Documentation/userspace-api/media/videodev2.h.rst.exceptions
> @@ -553,6 +553,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
> diff --git a/drivers/media/i2c/imx214.c b/drivers/media/i2c/imx214.c
> index 83c1737abeec..1541a81dcd46 100644
> --- a/drivers/media/i2c/imx214.c
> +++ b/drivers/media/i2c/imx214.c
> @@ -1037,7 +1037,9 @@ static int imx214_probe(struct i2c_client *client)
> imx214->unit_size = v4l2_ctrl_new_std_compound(&imx214->ctrls,
> 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));
> ret = imx214->ctrls.error;
> if (ret) {
> dev_err(&client->dev, "%s control init failed (%d)\n",
> diff --git a/drivers/media/v4l2-core/v4l2-ctrls-api.c b/drivers/media/v4l2-core/v4l2-ctrls-api.c
> index db9baa0bd05f..8a9c816b0dab 100644
> --- a/drivers/media/v4l2-core/v4l2-ctrls-api.c
> +++ b/drivers/media/v4l2-core/v4l2-ctrls-api.c
> @@ -97,6 +97,28 @@ 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)
> +{
> + int idx;
> +
> + for (idx = 0; idx < ctrl->elems; idx++)
> + ctrl->type_ops->minimum(ctrl, idx, 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)
> +{
> + int idx;
> +
> + for (idx = 0; idx < ctrl->elems; idx++)
> + ctrl->type_ops->maximum(ctrl, idx, ctrl->p_new);
> +
> + return ptr_to_user(c, ctrl, ctrl->p_new);
> +}
> +
> /* Helper function: copy the caller-provider value to the given control value */
> static int user_to_ptr(struct v4l2_ext_control *c,
> struct v4l2_ctrl *ctrl,
> @@ -220,8 +242,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",
> @@ -335,8 +357,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;
> }
> @@ -356,10 +378,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);
> @@ -399,13 +423,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++)
> @@ -432,6 +457,10 @@ int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
> ret = def_to_user(cs->controls + idx, ref->ctrl);
> else if (is_request && ref->valid_p_req)
> 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
> @@ -523,9 +552,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;
> }
> diff --git a/drivers/media/v4l2-core/v4l2-ctrls-core.c b/drivers/media/v4l2-core/v4l2-ctrls-core.c
> index 384d12a9638b..7b6bf85814fe 100644
> --- a/drivers/media/v4l2-core/v4l2-ctrls-core.c
> +++ b/drivers/media/v4l2-core/v4l2-ctrls-core.c
> @@ -186,6 +186,28 @@ static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx,
> }
> }
>
> +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 std_init(const struct v4l2_ctrl *ctrl, u32 idx,
> union v4l2_ctrl_ptr ptr)
> {
> @@ -224,6 +246,82 @@ static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
> }
> }
>
> +static void std_minimum(const struct v4l2_ctrl *ctrl, u32 idx,
> + union v4l2_ctrl_ptr ptr)
> +{
> + switch (ctrl->type) {
> + case V4L2_CTRL_TYPE_STRING:
> + idx *= ctrl->elem_size;
> + memset(ptr.p_char + idx, ' ', ctrl->minimum);
> + ptr.p_char[idx + ctrl->minimum] = '\0';
> + break;
> + case V4L2_CTRL_TYPE_INTEGER64:
> + ptr.p_s64[idx] = ctrl->minimum;
> + break;
> + case V4L2_CTRL_TYPE_INTEGER:
> + case V4L2_CTRL_TYPE_INTEGER_MENU:
> + case V4L2_CTRL_TYPE_MENU:
> + case V4L2_CTRL_TYPE_BITMASK:
> + case V4L2_CTRL_TYPE_BOOLEAN:
> + ptr.p_s32[idx] = ctrl->minimum;
> + break;
> + case V4L2_CTRL_TYPE_BUTTON:
> + case V4L2_CTRL_TYPE_CTRL_CLASS:
> + ptr.p_s32[idx] = 0;
> + break;
> + case V4L2_CTRL_TYPE_U8:
> + ptr.p_u8[idx] = ctrl->minimum;
> + break;
> + case V4L2_CTRL_TYPE_U16:
> + ptr.p_u16[idx] = ctrl->minimum;
> + break;
> + case V4L2_CTRL_TYPE_U32:
> + ptr.p_u32[idx] = ctrl->minimum;
> + break;
> + default:
> + std_min_compound(ctrl, idx, ptr);
> + break;
> + }
> +}
> +
> +static void std_maximum(const struct v4l2_ctrl *ctrl, u32 idx,
> + union v4l2_ctrl_ptr ptr)
> +{
> + switch (ctrl->type) {
> + case V4L2_CTRL_TYPE_STRING:
> + idx *= ctrl->elem_size;
> + memset(ptr.p_char + idx, ' ', ctrl->maximum);
> + ptr.p_char[idx + ctrl->maximum] = '\0';
> + break;
> + case V4L2_CTRL_TYPE_INTEGER64:
> + ptr.p_s64[idx] = ctrl->maximum;
> + break;
> + case V4L2_CTRL_TYPE_INTEGER:
> + case V4L2_CTRL_TYPE_INTEGER_MENU:
> + case V4L2_CTRL_TYPE_MENU:
> + case V4L2_CTRL_TYPE_BITMASK:
> + case V4L2_CTRL_TYPE_BOOLEAN:
> + ptr.p_s32[idx] = ctrl->maximum;
> + break;
> + case V4L2_CTRL_TYPE_BUTTON:
> + case V4L2_CTRL_TYPE_CTRL_CLASS:
> + ptr.p_s32[idx] = 0;
> + break;
> + case V4L2_CTRL_TYPE_U8:
> + ptr.p_u8[idx] = ctrl->maximum;
> + break;
> + case V4L2_CTRL_TYPE_U16:
> + ptr.p_u16[idx] = ctrl->maximum;
> + break;
> + case V4L2_CTRL_TYPE_U32:
> + ptr.p_u32[idx] = ctrl->maximum;
> + break;
> + default:
> + std_max_compound(ctrl, idx, ptr);
> + break;
> + }
> +}
> +
> static void std_log(const struct v4l2_ctrl *ctrl)
> {
> union v4l2_ctrl_ptr ptr = ctrl->p_cur;
> @@ -986,6 +1084,8 @@ static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
> static const struct v4l2_ctrl_type_ops std_type_ops = {
> .equal = std_equal,
> .init = std_init,
> + .minimum = std_minimum,
> + .maximum = std_maximum,
> .log = std_log,
> .validate = std_validate,
> };
> @@ -1369,7 +1469,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;
> @@ -1516,7 +1619,7 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
> sz_extra += 2 * tot_ctrl_size;
>
> if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const)
> - sz_extra += elem_size;
> + sz_extra += elem_size * 3;
>
> ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
> if (ctrl == NULL) {
> @@ -1566,6 +1669,13 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
> ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size;
> memcpy(ctrl->p_def.p, p_def.p_const, elem_size);
> }
> + if (type >= V4L2_CTRL_COMPOUND_TYPES &&
> + p_min.p_const && p_max.p_const) {
> + ctrl->p_min.p = ctrl->p_cur.p + 2 * tot_ctrl_size;
> + memcpy(ctrl->p_min.p, p_min.p_const, elem_size);
> + ctrl->p_max.p = ctrl->p_cur.p + 3 * tot_ctrl_size;
> + memcpy(ctrl->p_max.p, p_max.p_const, elem_size);
> + }
>
> for (idx = 0; idx < elems; idx++) {
> ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
> @@ -1618,7 +1728,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;
> @@ -1643,7 +1754,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);
>
> @@ -1676,7 +1788,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);
>
> @@ -1708,7 +1821,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);
> @@ -1716,7 +1830,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;
> @@ -1730,7 +1846,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);
>
> @@ -1754,7 +1870,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);
>
> diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
> index 96e307fe3aab..6ed6ef87c7ff 100644
> --- a/drivers/media/v4l2-core/v4l2-ioctl.c
> +++ b/drivers/media/v4l2-core/v4l2-ioctl.c
> @@ -892,7 +892,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;
> diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h
> index 919e104de50b..25378304b2fb 100644
> --- a/include/media/v4l2-ctrls.h
> +++ b/include/media/v4l2-ctrls.h
> @@ -131,6 +131,8 @@ struct v4l2_ctrl_ops {
> *
> * @equal: return true if both values are equal.
> * @init: initialize the value.
> + * @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. Return 0 on success and a negative value
> * otherwise.
> @@ -141,6 +143,10 @@ struct v4l2_ctrl_type_ops {
> union v4l2_ctrl_ptr ptr2);
> void (*init)(const struct v4l2_ctrl *ctrl, u32 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, u32 idx,
> union v4l2_ctrl_ptr ptr);
> @@ -237,6 +243,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.
> @@ -292,6 +304,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;
> };
> @@ -398,6 +412,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.
> @@ -427,6 +443,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;
> @@ -696,17 +714,21 @@ 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 default value.
> + * @p_max: The control's default 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.
> + * to the @p_def/min/max field. Use v4l2_ctrl_ptr_create() to create
> + * @p_def/min/max from a pointer. Use v4l2_ctrl_ptr_create(NULL) if the default
> + * value of the compound control should be all zeroes.
> *
> */
> 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.
> diff --git a/include/uapi/linux/videodev2.h b/include/uapi/linux/videodev2.h
> index b712412cf763..d22ebb0102d4 100644
> --- a/include/uapi/linux/videodev2.h
> +++ b/include/uapi/linux/videodev2.h
> @@ -1793,6 +1793,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,
> --
> 2.36.1.124.g0e6072fb45-goog
>
Hi Yunke,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on media-tree/master]
[also build test ERROR on linus/master v5.18 next-20220525]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/intel-lab-lkp/linux/commits/Yunke-Cao/media-Implement-UVC-v1-5-ROI/20220524-124718
base: git://linuxtv.org/media_tree.git master
config: hexagon-randconfig-r041-20220524 (https://download.01.org/0day-ci/archive/20220526/202205260458.5bfyANVz-lkp@intel.com/config)
compiler: clang version 15.0.0 (https://github.com/llvm/llvm-project d52a6e75b0c402c7f3b42a2b1b2873f151220947)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/25bdce0e26cdd486b08cbca11412dbfc5a1469eb
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Yunke-Cao/media-Implement-UVC-v1-5-ROI/20220524-124718
git checkout 25bdce0e26cdd486b08cbca11412dbfc5a1469eb
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=hexagon SHELL=/bin/bash drivers/media/platform/qcom/venus/
If you fix the issue, kindly add following tag where applicable
Reported-by: kernel test robot <lkp@intel.com>
All errors (new ones prefixed by >>):
>> drivers/media/platform/qcom/venus/venc_ctrls.c:582:34: error: too few arguments to function call, expected 6, have 4
v4l2_ctrl_ptr_create(NULL));
^
include/media/v4l2-ctrls.h:726:19: note: 'v4l2_ctrl_new_std_compound' declared here
struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl,
^
drivers/media/platform/qcom/venus/venc_ctrls.c:586:34: error: too few arguments to function call, expected 6, have 4
v4l2_ctrl_ptr_create(NULL));
^
include/media/v4l2-ctrls.h:726:19: note: 'v4l2_ctrl_new_std_compound' declared here
struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl,
^
2 errors generated.
vim +582 drivers/media/platform/qcom/venus/venc_ctrls.c
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 354
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 355 int venc_ctrl_init(struct venus_inst *inst)
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 356 {
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 357 int ret;
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 358
bfee75f73c37a2 Mansur Alisha Shaik 2021-07-29 359 ret = v4l2_ctrl_handler_init(&inst->ctrl_handler, 58);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 360 if (ret)
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 361 return ret;
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 362
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 363 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 364 V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 365 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 366 ~((1 << V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) |
69ff4b2caa95e1 Stanimir Varbanov 2020-06-16 367 (1 << V4L2_MPEG_VIDEO_BITRATE_MODE_CBR) |
69ff4b2caa95e1 Stanimir Varbanov 2020-06-16 368 (1 << V4L2_MPEG_VIDEO_BITRATE_MODE_CQ)),
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 369 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 370
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 371 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 372 V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 373 V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 374 0, V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 375
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 376 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 377 V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 378 V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 379 ~((1 << V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE) |
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 380 (1 << V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE)),
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 381 V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 382
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 383 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 384 V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 385 V4L2_MPEG_VIDEO_MPEG4_LEVEL_5,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 386 0, V4L2_MPEG_VIDEO_MPEG4_LEVEL_0);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 387
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 388 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 389 V4L2_CID_MPEG_VIDEO_HEVC_PROFILE,
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 390 V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10,
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 391 ~((1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN) |
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 392 (1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE) |
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 393 (1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10)),
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 394 V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN);
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 395
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 396 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 397 V4L2_CID_MPEG_VIDEO_HEVC_LEVEL,
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 398 V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2,
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 399 0, V4L2_MPEG_VIDEO_HEVC_LEVEL_1);
cd396c8cbfcdd7 Kelvin Lawson 2018-12-10 400
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 401 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 402 V4L2_CID_MPEG_VIDEO_H264_PROFILE,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 403 V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 404 ~((1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 405 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) |
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 406 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 407 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH) |
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 408 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH) |
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 409 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH)),
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 410 V4L2_MPEG_VIDEO_H264_PROFILE_HIGH);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 411
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 412 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 413 V4L2_CID_MPEG_VIDEO_H264_LEVEL,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 414 V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 415 0, V4L2_MPEG_VIDEO_H264_LEVEL_1_0);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 416
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 417 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 418 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 419 AT_SLICE_BOUNDARY,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 420 0, V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 421
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 422 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 423 V4L2_CID_MPEG_VIDEO_HEADER_MODE,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 424 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,
002c22bd360e07 Dikshita Agarwal 2021-01-08 425 ~((1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE) |
002c22bd360e07 Dikshita Agarwal 2021-01-08 426 (1 << V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME)),
39a6b9185d305d Stanimir Varbanov 2021-03-06 427 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 428
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 429 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 430 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE,
4914425e28fb90 Hans Verkuil 2019-04-24 431 V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_BYTES,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 432 0, V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 433
5520b9467a39d5 Keiichi Watanabe 2018-06-18 434 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
5520b9467a39d5 Keiichi Watanabe 2018-06-18 435 V4L2_CID_MPEG_VIDEO_VP8_PROFILE,
5520b9467a39d5 Keiichi Watanabe 2018-06-18 436 V4L2_MPEG_VIDEO_VP8_PROFILE_3,
5520b9467a39d5 Keiichi Watanabe 2018-06-18 437 0, V4L2_MPEG_VIDEO_VP8_PROFILE_0);
5520b9467a39d5 Keiichi Watanabe 2018-06-18 438
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 439 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 440 V4L2_CID_MPEG_VIDEO_BITRATE, BITRATE_MIN, BITRATE_MAX,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 441 BITRATE_STEP, BITRATE_DEFAULT);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 442
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 443 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 444 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK, BITRATE_MIN, BITRATE_MAX,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 445 BITRATE_STEP, BITRATE_DEFAULT_PEAK);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 446
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 447 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 448 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP, 1, 51, 1, 26);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 449
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 450 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 451 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP, 1, 51, 1, 28);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 452
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 453 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 454 V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP, 1, 51, 1, 30);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 455
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 456 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 457 V4L2_CID_MPEG_VIDEO_H264_MIN_QP, 1, 51, 1, 1);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 458
74c895974fd356 Dikshita Agarwal 2020-12-24 459 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 460 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP, 1, 51, 1, 1);
74c895974fd356 Dikshita Agarwal 2020-12-24 461
bfee75f73c37a2 Mansur Alisha Shaik 2021-07-29 462 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
61b3317dd424a3 Stanimir Varbanov 2022-02-08 463 V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM, 0, 1, 1, 1);
bfee75f73c37a2 Mansur Alisha Shaik 2021-07-29 464
74c895974fd356 Dikshita Agarwal 2020-12-24 465 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 466 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP, 1, 51, 1, 1);
74c895974fd356 Dikshita Agarwal 2020-12-24 467
74c895974fd356 Dikshita Agarwal 2020-12-24 468 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 469 V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MIN_QP, 1, 51, 1, 1);
74c895974fd356 Dikshita Agarwal 2020-12-24 470
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 471 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 472 V4L2_CID_MPEG_VIDEO_H264_MAX_QP, 1, 51, 1, 51);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 473
74c895974fd356 Dikshita Agarwal 2020-12-24 474 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 475 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP, 1, 51, 1, 51);
74c895974fd356 Dikshita Agarwal 2020-12-24 476
74c895974fd356 Dikshita Agarwal 2020-12-24 477 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 478 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP, 1, 51, 1, 51);
74c895974fd356 Dikshita Agarwal 2020-12-24 479
74c895974fd356 Dikshita Agarwal 2020-12-24 480 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 481 V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MAX_QP, 1, 51, 1, 51);
74c895974fd356 Dikshita Agarwal 2020-12-24 482
74c895974fd356 Dikshita Agarwal 2020-12-24 483 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 484 V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP, 1, 63, 1, 26);
74c895974fd356 Dikshita Agarwal 2020-12-24 485
74c895974fd356 Dikshita Agarwal 2020-12-24 486 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 487 V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP, 1, 63, 1, 28);
74c895974fd356 Dikshita Agarwal 2020-12-24 488
74c895974fd356 Dikshita Agarwal 2020-12-24 489 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 490 V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP, 1, 63, 1, 30);
74c895974fd356 Dikshita Agarwal 2020-12-24 491
74c895974fd356 Dikshita Agarwal 2020-12-24 492 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 493 V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP, 1, 63, 1, 1);
74c895974fd356 Dikshita Agarwal 2020-12-24 494
74c895974fd356 Dikshita Agarwal 2020-12-24 495 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 496 V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MIN_QP, 1, 63, 1, 1);
74c895974fd356 Dikshita Agarwal 2020-12-24 497
74c895974fd356 Dikshita Agarwal 2020-12-24 498 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 499 V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MIN_QP, 1, 63, 1, 1);
74c895974fd356 Dikshita Agarwal 2020-12-24 500
74c895974fd356 Dikshita Agarwal 2020-12-24 501 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 502 V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MIN_QP, 1, 63, 1, 1);
74c895974fd356 Dikshita Agarwal 2020-12-24 503
74c895974fd356 Dikshita Agarwal 2020-12-24 504 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 505 V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP, 1, 63, 1, 63);
74c895974fd356 Dikshita Agarwal 2020-12-24 506
74c895974fd356 Dikshita Agarwal 2020-12-24 507 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 508 V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MAX_QP, 1, 63, 1, 63);
74c895974fd356 Dikshita Agarwal 2020-12-24 509
74c895974fd356 Dikshita Agarwal 2020-12-24 510 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 511 V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MAX_QP, 1, 63, 1, 63);
74c895974fd356 Dikshita Agarwal 2020-12-24 512
74c895974fd356 Dikshita Agarwal 2020-12-24 513 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
74c895974fd356 Dikshita Agarwal 2020-12-24 514 V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MAX_QP, 1, 63, 1, 63);
74c895974fd356 Dikshita Agarwal 2020-12-24 515
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 516 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 517 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES, SLICE_BYTE_SIZE_MIN,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 518 SLICE_BYTE_SIZE_MAX, 1, SLICE_BYTE_SIZE_MIN);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 519
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 520 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 521 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB, 1,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 522 SLICE_MB_SIZE_MAX, 1, 1);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 523
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 524 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 525 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA, -6, 6, 1, 0);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 526
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 527 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 528 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA, -6, 6, 1, 0);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 529
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 530 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
f8e5b2f3903ce1 Malathi Gottam 2018-11-12 531 V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, (1 << 16) - 1, 1, 30);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 532
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 533 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 534 V4L2_CID_MPEG_VIDEO_VPX_MIN_QP, 1, 128, 1, 1);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 535
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 536 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 537 V4L2_CID_MPEG_VIDEO_VPX_MAX_QP, 1, 128, 1, 128);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 538
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 539 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 540 V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 4, 1, 0);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 541
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 542 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 543 V4L2_CID_MPEG_VIDEO_H264_I_PERIOD, 0, (1 << 16) - 1, 1, 0);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 544
c35f0b16537c15 Malathi Gottam 2018-11-02 545 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
c35f0b16537c15 Malathi Gottam 2018-11-02 546 V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME, 0, 0, 0, 0);
c35f0b16537c15 Malathi Gottam 2018-11-02 547
6f704b2fbbde0c Jeffrey Kardatzke 2020-02-22 548 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
6f704b2fbbde0c Jeffrey Kardatzke 2020-02-22 549 V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE, 0, 1, 1, 1);
6f704b2fbbde0c Jeffrey Kardatzke 2020-02-22 550
69ff4b2caa95e1 Stanimir Varbanov 2020-06-16 551 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
69ff4b2caa95e1 Stanimir Varbanov 2020-06-16 552 V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY, 0, 100, 1, 0);
69ff4b2caa95e1 Stanimir Varbanov 2020-06-16 553
94dfb1689c25ed Stanimir Varbanov 2020-07-05 554 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
94dfb1689c25ed Stanimir Varbanov 2020-07-05 555 V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE,
94dfb1689c25ed Stanimir Varbanov 2020-07-05 556 V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT,
94dfb1689c25ed Stanimir Varbanov 2020-07-05 557 ~((1 << V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED) |
94dfb1689c25ed Stanimir Varbanov 2020-07-05 558 (1 << V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT)),
94dfb1689c25ed Stanimir Varbanov 2020-07-05 559 V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED);
94dfb1689c25ed Stanimir Varbanov 2020-07-05 560
e98ce77b57530a Dikshita Agarwal 2021-01-04 561 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
e98ce77b57530a Dikshita Agarwal 2021-01-04 562 V4L2_CID_MPEG_VIDEO_BASELAYER_PRIORITY_ID, 0,
e98ce77b57530a Dikshita Agarwal 2021-01-04 563 6, 1, 0);
e98ce77b57530a Dikshita Agarwal 2021-01-04 564
08c06797627935 Stanimir Varbanov 2020-11-24 565 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
08c06797627935 Stanimir Varbanov 2020-11-24 566 V4L2_CID_MPEG_VIDEO_AU_DELIMITER, 0, 1, 1, 0);
08c06797627935 Stanimir Varbanov 2020-11-24 567
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 568 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 569 V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES, 0,
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 570 ((1 << MAX_LTR_FRAME_COUNT) - 1), 0, 0);
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 571
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 572 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 573 V4L2_CID_MPEG_VIDEO_LTR_COUNT, 0,
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 574 MAX_LTR_FRAME_COUNT, 1, 0);
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 575
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 576 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 577 V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX, 0,
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 578 (MAX_LTR_FRAME_COUNT - 1), 1, 0);
f2fb3f02abe2e6 Dikshita Agarwal 2021-03-24 579
9172652d72f8e9 Stanimir Varbanov 2020-04-23 580 v4l2_ctrl_new_std_compound(&inst->ctrl_handler, &venc_ctrl_ops,
9172652d72f8e9 Stanimir Varbanov 2020-04-23 581 V4L2_CID_COLORIMETRY_HDR10_CLL_INFO,
9172652d72f8e9 Stanimir Varbanov 2020-04-23 @582 v4l2_ctrl_ptr_create(NULL));
9172652d72f8e9 Stanimir Varbanov 2020-04-23 583
9172652d72f8e9 Stanimir Varbanov 2020-04-23 584 v4l2_ctrl_new_std_compound(&inst->ctrl_handler, &venc_ctrl_ops,
9172652d72f8e9 Stanimir Varbanov 2020-04-23 585 V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY,
9172652d72f8e9 Stanimir Varbanov 2020-04-23 586 v4l2_ctrl_ptr_create(NULL));
9172652d72f8e9 Stanimir Varbanov 2020-04-23 587
fc503c8a3f12af Dikshita Agarwal 2022-04-19 588 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
fc503c8a3f12af Dikshita Agarwal 2022-04-19 589 V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE,
fc503c8a3f12af Dikshita Agarwal 2022-04-19 590 V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE_CYCLIC,
fc503c8a3f12af Dikshita Agarwal 2022-04-19 591 0, V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE_RANDOM);
fc503c8a3f12af Dikshita Agarwal 2022-04-19 592
f7a3d3dc5831df Stanimir Varbanov 2021-06-22 593 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
f7a3d3dc5831df Stanimir Varbanov 2021-06-22 594 V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD, 0,
f7a3d3dc5831df Stanimir Varbanov 2021-06-22 595 ((4096 * 2304) >> 8), 1, 0);
f7a3d3dc5831df Stanimir Varbanov 2021-06-22 596
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 597 ret = inst->ctrl_handler.error;
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 598 if (ret)
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 599 goto err;
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 600
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 601 ret = v4l2_ctrl_handler_setup(&inst->ctrl_handler);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 602 if (ret)
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 603 goto err;
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 604
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 605 return 0;
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 606 err:
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 607 v4l2_ctrl_handler_free(&inst->ctrl_handler);
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 608 return ret;
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 609 }
aaaa93eda64b00 Stanimir Varbanov 2017-06-15 610
Hi Ricardo,
Thanks for the review.
On Tue, May 24, 2022 at 6:38 PM Ricardo Ribalda <ribalda@chromium.org> wrote:
>
> Hi Yunke
>
> On Tue, 24 May 2022 at 06:45, Yunke Cao <yunkec@google.com> wrote:
> >
> > Added V4L2_CTRL_WHICH_MIN/MAX_VAL and basic support in v4l2-core.
> >
> > Mostly reusing a previous attempt:
> > https://lore.kernel.org/all/20191220134843.25977-1-m.tretter@pengutronix.de/T/#m5c83970af8b774a4b1ea5f2dca4c0a534da4ccbe
> maybe: https://lore.kernel.org/all/20191119113457.57833-3-hverkuil-cisco@xs4all.nl/
>
>
> >
> > Signed-off-by: Yunke Cao <yunkec@google.com>
> I think it is not official, but I like the tag:
> Credit-to:
>
> Instead of sending your version. Could you cherry-pick Hans patch?
>
> You could add after the
> ====
> how did you solve the conflicts
>
> (if it is too different from Hans, please disregard this message)
>
It's not different from Hans's patch at all. I will cherry-pick in v5.
Best,
Yunke
> > ---
> > .../media/v4l/vidioc-g-ext-ctrls.rst | 8 +-
> > .../media/videodev2.h.rst.exceptions | 2 +
> > drivers/media/i2c/imx214.c | 4 +-
> > drivers/media/v4l2-core/v4l2-ctrls-api.c | 51 +++++--
> > drivers/media/v4l2-core/v4l2-ctrls-core.c | 135 ++++++++++++++++--
> > drivers/media/v4l2-core/v4l2-ioctl.c | 4 +-
> > include/media/v4l2-ctrls.h | 30 +++-
> > include/uapi/linux/videodev2.h | 2 +
> > 8 files changed, 209 insertions(+), 27 deletions(-)
> >
> > diff --git a/Documentation/userspace-api/media/v4l/vidioc-g-ext-ctrls.rst b/Documentation/userspace-api/media/v4l/vidioc-g-ext-ctrls.rst
> > index f4e205ead0a2..a89577726efa 100644
> > --- a/Documentation/userspace-api/media/v4l/vidioc-g-ext-ctrls.rst
> > +++ b/Documentation/userspace-api/media/v4l/vidioc-g-ext-ctrls.rst
> > @@ -284,14 +284,18 @@ 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, ``V4L2_CTRL_WHICH_MIN_VAL`` will return the minimum
> > + value of the control, ``V4L2_CTRL_WHICH_MAX_VAL`` will return the maximum
> > 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
> > 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.
> >
> > For backwards compatibility you can also use a control class here
> > (see :ref:`ctrl-class`). In that case all controls have to
> > diff --git a/Documentation/userspace-api/media/videodev2.h.rst.exceptions b/Documentation/userspace-api/media/videodev2.h.rst.exceptions
> > index 7b423475281d..e2dde31d76df 100644
> > --- a/Documentation/userspace-api/media/videodev2.h.rst.exceptions
> > +++ b/Documentation/userspace-api/media/videodev2.h.rst.exceptions
> > @@ -553,6 +553,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
> > diff --git a/drivers/media/i2c/imx214.c b/drivers/media/i2c/imx214.c
> > index 83c1737abeec..1541a81dcd46 100644
> > --- a/drivers/media/i2c/imx214.c
> > +++ b/drivers/media/i2c/imx214.c
> > @@ -1037,7 +1037,9 @@ static int imx214_probe(struct i2c_client *client)
> > imx214->unit_size = v4l2_ctrl_new_std_compound(&imx214->ctrls,
> > 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));
> > ret = imx214->ctrls.error;
> > if (ret) {
> > dev_err(&client->dev, "%s control init failed (%d)\n",
> > diff --git a/drivers/media/v4l2-core/v4l2-ctrls-api.c b/drivers/media/v4l2-core/v4l2-ctrls-api.c
> > index db9baa0bd05f..8a9c816b0dab 100644
> > --- a/drivers/media/v4l2-core/v4l2-ctrls-api.c
> > +++ b/drivers/media/v4l2-core/v4l2-ctrls-api.c
> > @@ -97,6 +97,28 @@ 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)
> > +{
> > + int idx;
> > +
> > + for (idx = 0; idx < ctrl->elems; idx++)
> > + ctrl->type_ops->minimum(ctrl, idx, 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)
> > +{
> > + int idx;
> > +
> > + for (idx = 0; idx < ctrl->elems; idx++)
> > + ctrl->type_ops->maximum(ctrl, idx, ctrl->p_new);
> > +
> > + return ptr_to_user(c, ctrl, ctrl->p_new);
> > +}
> > +
> > /* Helper function: copy the caller-provider value to the given control value */
> > static int user_to_ptr(struct v4l2_ext_control *c,
> > struct v4l2_ctrl *ctrl,
> > @@ -220,8 +242,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",
> > @@ -335,8 +357,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;
> > }
> > @@ -356,10 +378,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);
> > @@ -399,13 +423,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++)
> > @@ -432,6 +457,10 @@ int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
> > ret = def_to_user(cs->controls + idx, ref->ctrl);
> > else if (is_request && ref->valid_p_req)
> > 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
> > @@ -523,9 +552,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;
> > }
> > diff --git a/drivers/media/v4l2-core/v4l2-ctrls-core.c b/drivers/media/v4l2-core/v4l2-ctrls-core.c
> > index 384d12a9638b..7b6bf85814fe 100644
> > --- a/drivers/media/v4l2-core/v4l2-ctrls-core.c
> > +++ b/drivers/media/v4l2-core/v4l2-ctrls-core.c
> > @@ -186,6 +186,28 @@ static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx,
> > }
> > }
> >
> > +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 std_init(const struct v4l2_ctrl *ctrl, u32 idx,
> > union v4l2_ctrl_ptr ptr)
> > {
> > @@ -224,6 +246,82 @@ static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
> > }
> > }
> >
> > +static void std_minimum(const struct v4l2_ctrl *ctrl, u32 idx,
> > + union v4l2_ctrl_ptr ptr)
> > +{
> > + switch (ctrl->type) {
> > + case V4L2_CTRL_TYPE_STRING:
> > + idx *= ctrl->elem_size;
> > + memset(ptr.p_char + idx, ' ', ctrl->minimum);
> > + ptr.p_char[idx + ctrl->minimum] = '\0';
> > + break;
> > + case V4L2_CTRL_TYPE_INTEGER64:
> > + ptr.p_s64[idx] = ctrl->minimum;
> > + break;
> > + case V4L2_CTRL_TYPE_INTEGER:
> > + case V4L2_CTRL_TYPE_INTEGER_MENU:
> > + case V4L2_CTRL_TYPE_MENU:
> > + case V4L2_CTRL_TYPE_BITMASK:
> > + case V4L2_CTRL_TYPE_BOOLEAN:
> > + ptr.p_s32[idx] = ctrl->minimum;
> > + break;
> > + case V4L2_CTRL_TYPE_BUTTON:
> > + case V4L2_CTRL_TYPE_CTRL_CLASS:
> > + ptr.p_s32[idx] = 0;
> > + break;
> > + case V4L2_CTRL_TYPE_U8:
> > + ptr.p_u8[idx] = ctrl->minimum;
> > + break;
> > + case V4L2_CTRL_TYPE_U16:
> > + ptr.p_u16[idx] = ctrl->minimum;
> > + break;
> > + case V4L2_CTRL_TYPE_U32:
> > + ptr.p_u32[idx] = ctrl->minimum;
> > + break;
> > + default:
> > + std_min_compound(ctrl, idx, ptr);
> > + break;
> > + }
> > +}
> > +
> > +static void std_maximum(const struct v4l2_ctrl *ctrl, u32 idx,
> > + union v4l2_ctrl_ptr ptr)
> > +{
> > + switch (ctrl->type) {
> > + case V4L2_CTRL_TYPE_STRING:
> > + idx *= ctrl->elem_size;
> > + memset(ptr.p_char + idx, ' ', ctrl->maximum);
> > + ptr.p_char[idx + ctrl->maximum] = '\0';
> > + break;
> > + case V4L2_CTRL_TYPE_INTEGER64:
> > + ptr.p_s64[idx] = ctrl->maximum;
> > + break;
> > + case V4L2_CTRL_TYPE_INTEGER:
> > + case V4L2_CTRL_TYPE_INTEGER_MENU:
> > + case V4L2_CTRL_TYPE_MENU:
> > + case V4L2_CTRL_TYPE_BITMASK:
> > + case V4L2_CTRL_TYPE_BOOLEAN:
> > + ptr.p_s32[idx] = ctrl->maximum;
> > + break;
> > + case V4L2_CTRL_TYPE_BUTTON:
> > + case V4L2_CTRL_TYPE_CTRL_CLASS:
> > + ptr.p_s32[idx] = 0;
> > + break;
> > + case V4L2_CTRL_TYPE_U8:
> > + ptr.p_u8[idx] = ctrl->maximum;
> > + break;
> > + case V4L2_CTRL_TYPE_U16:
> > + ptr.p_u16[idx] = ctrl->maximum;
> > + break;
> > + case V4L2_CTRL_TYPE_U32:
> > + ptr.p_u32[idx] = ctrl->maximum;
> > + break;
> > + default:
> > + std_max_compound(ctrl, idx, ptr);
> > + break;
> > + }
> > +}
> > +
> > static void std_log(const struct v4l2_ctrl *ctrl)
> > {
> > union v4l2_ctrl_ptr ptr = ctrl->p_cur;
> > @@ -986,6 +1084,8 @@ static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
> > static const struct v4l2_ctrl_type_ops std_type_ops = {
> > .equal = std_equal,
> > .init = std_init,
> > + .minimum = std_minimum,
> > + .maximum = std_maximum,
> > .log = std_log,
> > .validate = std_validate,
> > };
> > @@ -1369,7 +1469,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;
> > @@ -1516,7 +1619,7 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
> > sz_extra += 2 * tot_ctrl_size;
> >
> > if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const)
> > - sz_extra += elem_size;
> > + sz_extra += elem_size * 3;
> >
> > ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
> > if (ctrl == NULL) {
> > @@ -1566,6 +1669,13 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
> > ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size;
> > memcpy(ctrl->p_def.p, p_def.p_const, elem_size);
> > }
> > + if (type >= V4L2_CTRL_COMPOUND_TYPES &&
> > + p_min.p_const && p_max.p_const) {
> > + ctrl->p_min.p = ctrl->p_cur.p + 2 * tot_ctrl_size;
> > + memcpy(ctrl->p_min.p, p_min.p_const, elem_size);
> > + ctrl->p_max.p = ctrl->p_cur.p + 3 * tot_ctrl_size;
> > + memcpy(ctrl->p_max.p, p_max.p_const, elem_size);
> > + }
> >
> > for (idx = 0; idx < elems; idx++) {
> > ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
> > @@ -1618,7 +1728,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;
> > @@ -1643,7 +1754,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);
> >
> > @@ -1676,7 +1788,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);
> >
> > @@ -1708,7 +1821,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);
> > @@ -1716,7 +1830,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;
> > @@ -1730,7 +1846,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);
> >
> > @@ -1754,7 +1870,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);
> >
> > diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
> > index 96e307fe3aab..6ed6ef87c7ff 100644
> > --- a/drivers/media/v4l2-core/v4l2-ioctl.c
> > +++ b/drivers/media/v4l2-core/v4l2-ioctl.c
> > @@ -892,7 +892,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;
> > diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h
> > index 919e104de50b..25378304b2fb 100644
> > --- a/include/media/v4l2-ctrls.h
> > +++ b/include/media/v4l2-ctrls.h
> > @@ -131,6 +131,8 @@ struct v4l2_ctrl_ops {
> > *
> > * @equal: return true if both values are equal.
> > * @init: initialize the value.
> > + * @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. Return 0 on success and a negative value
> > * otherwise.
> > @@ -141,6 +143,10 @@ struct v4l2_ctrl_type_ops {
> > union v4l2_ctrl_ptr ptr2);
> > void (*init)(const struct v4l2_ctrl *ctrl, u32 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, u32 idx,
> > union v4l2_ctrl_ptr ptr);
> > @@ -237,6 +243,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.
> > @@ -292,6 +304,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;
> > };
> > @@ -398,6 +412,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.
> > @@ -427,6 +443,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;
> > @@ -696,17 +714,21 @@ 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 default value.
> > + * @p_max: The control's default 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.
> > + * to the @p_def/min/max field. Use v4l2_ctrl_ptr_create() to create
> > + * @p_def/min/max from a pointer. Use v4l2_ctrl_ptr_create(NULL) if the default
> > + * value of the compound control should be all zeroes.
> > *
> > */
> > 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.
> > diff --git a/include/uapi/linux/videodev2.h b/include/uapi/linux/videodev2.h
> > index b712412cf763..d22ebb0102d4 100644
> > --- a/include/uapi/linux/videodev2.h
> > +++ b/include/uapi/linux/videodev2.h
> > @@ -1793,6 +1793,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,
> > --
> > 2.36.1.124.g0e6072fb45-goog
> >
>
>
> --
> Ricardo Ribalda
@@ -284,14 +284,18 @@ 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, ``V4L2_CTRL_WHICH_MIN_VAL`` will return the minimum
+ value of the control, ``V4L2_CTRL_WHICH_MAX_VAL`` will return the maximum
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
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.
For backwards compatibility you can also use a control class here
(see :ref:`ctrl-class`). In that case all controls have to
@@ -553,6 +553,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
@@ -1037,7 +1037,9 @@ static int imx214_probe(struct i2c_client *client)
imx214->unit_size = v4l2_ctrl_new_std_compound(&imx214->ctrls,
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));
ret = imx214->ctrls.error;
if (ret) {
dev_err(&client->dev, "%s control init failed (%d)\n",
@@ -97,6 +97,28 @@ 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)
+{
+ int idx;
+
+ for (idx = 0; idx < ctrl->elems; idx++)
+ ctrl->type_ops->minimum(ctrl, idx, 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)
+{
+ int idx;
+
+ for (idx = 0; idx < ctrl->elems; idx++)
+ ctrl->type_ops->maximum(ctrl, idx, ctrl->p_new);
+
+ return ptr_to_user(c, ctrl, ctrl->p_new);
+}
+
/* Helper function: copy the caller-provider value to the given control value */
static int user_to_ptr(struct v4l2_ext_control *c,
struct v4l2_ctrl *ctrl,
@@ -220,8 +242,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",
@@ -335,8 +357,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;
}
@@ -356,10 +378,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);
@@ -399,13 +423,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++)
@@ -432,6 +457,10 @@ int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
ret = def_to_user(cs->controls + idx, ref->ctrl);
else if (is_request && ref->valid_p_req)
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
@@ -523,9 +552,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;
}
@@ -186,6 +186,28 @@ static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx,
}
}
+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 std_init(const struct v4l2_ctrl *ctrl, u32 idx,
union v4l2_ctrl_ptr ptr)
{
@@ -224,6 +246,82 @@ static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
}
}
+static void std_minimum(const struct v4l2_ctrl *ctrl, u32 idx,
+ union v4l2_ctrl_ptr ptr)
+{
+ switch (ctrl->type) {
+ case V4L2_CTRL_TYPE_STRING:
+ idx *= ctrl->elem_size;
+ memset(ptr.p_char + idx, ' ', ctrl->minimum);
+ ptr.p_char[idx + ctrl->minimum] = '\0';
+ break;
+ case V4L2_CTRL_TYPE_INTEGER64:
+ ptr.p_s64[idx] = ctrl->minimum;
+ break;
+ case V4L2_CTRL_TYPE_INTEGER:
+ case V4L2_CTRL_TYPE_INTEGER_MENU:
+ case V4L2_CTRL_TYPE_MENU:
+ case V4L2_CTRL_TYPE_BITMASK:
+ case V4L2_CTRL_TYPE_BOOLEAN:
+ ptr.p_s32[idx] = ctrl->minimum;
+ break;
+ case V4L2_CTRL_TYPE_BUTTON:
+ case V4L2_CTRL_TYPE_CTRL_CLASS:
+ ptr.p_s32[idx] = 0;
+ break;
+ case V4L2_CTRL_TYPE_U8:
+ ptr.p_u8[idx] = ctrl->minimum;
+ break;
+ case V4L2_CTRL_TYPE_U16:
+ ptr.p_u16[idx] = ctrl->minimum;
+ break;
+ case V4L2_CTRL_TYPE_U32:
+ ptr.p_u32[idx] = ctrl->minimum;
+ break;
+ default:
+ std_min_compound(ctrl, idx, ptr);
+ break;
+ }
+}
+
+static void std_maximum(const struct v4l2_ctrl *ctrl, u32 idx,
+ union v4l2_ctrl_ptr ptr)
+{
+ switch (ctrl->type) {
+ case V4L2_CTRL_TYPE_STRING:
+ idx *= ctrl->elem_size;
+ memset(ptr.p_char + idx, ' ', ctrl->maximum);
+ ptr.p_char[idx + ctrl->maximum] = '\0';
+ break;
+ case V4L2_CTRL_TYPE_INTEGER64:
+ ptr.p_s64[idx] = ctrl->maximum;
+ break;
+ case V4L2_CTRL_TYPE_INTEGER:
+ case V4L2_CTRL_TYPE_INTEGER_MENU:
+ case V4L2_CTRL_TYPE_MENU:
+ case V4L2_CTRL_TYPE_BITMASK:
+ case V4L2_CTRL_TYPE_BOOLEAN:
+ ptr.p_s32[idx] = ctrl->maximum;
+ break;
+ case V4L2_CTRL_TYPE_BUTTON:
+ case V4L2_CTRL_TYPE_CTRL_CLASS:
+ ptr.p_s32[idx] = 0;
+ break;
+ case V4L2_CTRL_TYPE_U8:
+ ptr.p_u8[idx] = ctrl->maximum;
+ break;
+ case V4L2_CTRL_TYPE_U16:
+ ptr.p_u16[idx] = ctrl->maximum;
+ break;
+ case V4L2_CTRL_TYPE_U32:
+ ptr.p_u32[idx] = ctrl->maximum;
+ break;
+ default:
+ std_max_compound(ctrl, idx, ptr);
+ break;
+ }
+}
+
static void std_log(const struct v4l2_ctrl *ctrl)
{
union v4l2_ctrl_ptr ptr = ctrl->p_cur;
@@ -986,6 +1084,8 @@ static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
static const struct v4l2_ctrl_type_ops std_type_ops = {
.equal = std_equal,
.init = std_init,
+ .minimum = std_minimum,
+ .maximum = std_maximum,
.log = std_log,
.validate = std_validate,
};
@@ -1369,7 +1469,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;
@@ -1516,7 +1619,7 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
sz_extra += 2 * tot_ctrl_size;
if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const)
- sz_extra += elem_size;
+ sz_extra += elem_size * 3;
ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
if (ctrl == NULL) {
@@ -1566,6 +1669,13 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size;
memcpy(ctrl->p_def.p, p_def.p_const, elem_size);
}
+ if (type >= V4L2_CTRL_COMPOUND_TYPES &&
+ p_min.p_const && p_max.p_const) {
+ ctrl->p_min.p = ctrl->p_cur.p + 2 * tot_ctrl_size;
+ memcpy(ctrl->p_min.p, p_min.p_const, elem_size);
+ ctrl->p_max.p = ctrl->p_cur.p + 3 * tot_ctrl_size;
+ memcpy(ctrl->p_max.p, p_max.p_const, elem_size);
+ }
for (idx = 0; idx < elems; idx++) {
ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
@@ -1618,7 +1728,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;
@@ -1643,7 +1754,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);
@@ -1676,7 +1788,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);
@@ -1708,7 +1821,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);
@@ -1716,7 +1830,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;
@@ -1730,7 +1846,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);
@@ -1754,7 +1870,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);
@@ -892,7 +892,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;
@@ -131,6 +131,8 @@ struct v4l2_ctrl_ops {
*
* @equal: return true if both values are equal.
* @init: initialize the value.
+ * @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. Return 0 on success and a negative value
* otherwise.
@@ -141,6 +143,10 @@ struct v4l2_ctrl_type_ops {
union v4l2_ctrl_ptr ptr2);
void (*init)(const struct v4l2_ctrl *ctrl, u32 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, u32 idx,
union v4l2_ctrl_ptr ptr);
@@ -237,6 +243,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.
@@ -292,6 +304,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;
};
@@ -398,6 +412,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.
@@ -427,6 +443,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;
@@ -696,17 +714,21 @@ 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 default value.
+ * @p_max: The control's default 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.
+ * to the @p_def/min/max field. Use v4l2_ctrl_ptr_create() to create
+ * @p_def/min/max from a pointer. Use v4l2_ctrl_ptr_create(NULL) if the default
+ * value of the compound control should be all zeroes.
*
*/
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.
@@ -1793,6 +1793,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,