Lines Matching +full:multi +full:- +full:cluster
1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * Copyright (C) 2010-2021 Hans Verkuil <hverkuil-cisco@xs4all.nl>
8 #define pr_fmt(fmt) "v4l2-ctrls: " fmt
13 #include <media/v4l2-ctrls.h>
14 #include <media/v4l2-dev.h>
15 #include <media/v4l2-device.h>
16 #include <media/v4l2-event.h>
17 #include <media/v4l2-ioctl.h>
19 #include "v4l2-ctrls-priv.h"
29 * same cluster, or 0 if there isn't any.
46 if (ctrl->is_ptr && !ctrl->is_string)
47 return copy_to_user(c->ptr, ptr.p_const, c->size) ?
48 -EFAULT : 0;
50 switch (ctrl->type) {
53 if (c->size < len + 1) {
54 c->size = ctrl->elem_size;
55 return -ENOSPC;
57 return copy_to_user(c->string, ptr.p_char, len + 1) ?
58 -EFAULT : 0;
60 c->value64 = *ptr.p_s64;
63 c->value = *ptr.p_s32;
72 return ptr_to_user(c, ctrl, ctrl->p_cur);
79 return ptr_to_user(c, ctrl, ctrl->p_new);
86 return ptr_to_user(c, ref->ctrl, ref->p_req);
92 ctrl->type_ops->init(ctrl, 0, ctrl->p_new);
94 return ptr_to_user(c, ctrl, ctrl->p_new);
100 ctrl->type_ops->minimum(ctrl, 0, ctrl->p_new);
102 return ptr_to_user(c, ctrl, ctrl->p_new);
108 ctrl->type_ops->maximum(ctrl, 0, ctrl->p_new);
110 return ptr_to_user(c, ctrl, ctrl->p_new);
113 /* Helper function: copy the caller-provider value as the new control value */
119 ctrl->is_new = 0;
120 if (ctrl->is_dyn_array &&
121 c->size > ctrl->p_array_alloc_elems * ctrl->elem_size) {
122 void *old = ctrl->p_array;
123 void *tmp = kvzalloc(2 * c->size, GFP_KERNEL);
126 return -ENOMEM;
127 memcpy(tmp, ctrl->p_new.p, ctrl->elems * ctrl->elem_size);
128 memcpy(tmp + c->size, ctrl->p_cur.p, ctrl->elems * ctrl->elem_size);
129 ctrl->p_new.p = tmp;
130 ctrl->p_cur.p = tmp + c->size;
131 ctrl->p_array = tmp;
132 ctrl->p_array_alloc_elems = c->size / ctrl->elem_size;
136 if (ctrl->is_ptr && !ctrl->is_string) {
137 unsigned int elems = c->size / ctrl->elem_size;
139 if (copy_from_user(ctrl->p_new.p, c->ptr, c->size))
140 return -EFAULT;
141 ctrl->is_new = 1;
142 if (ctrl->is_dyn_array)
143 ctrl->new_elems = elems;
144 else if (ctrl->is_array)
145 ctrl->type_ops->init(ctrl, elems, ctrl->p_new);
149 switch (ctrl->type) {
151 *ctrl->p_new.p_s64 = c->value64;
154 size = c->size;
156 return -ERANGE;
157 if (size > ctrl->maximum + 1)
158 size = ctrl->maximum + 1;
159 ret = copy_from_user(ctrl->p_new.p_char, c->string, size) ? -EFAULT : 0;
161 char last = ctrl->p_new.p_char[size - 1];
163 ctrl->p_new.p_char[size - 1] = 0;
165 * If the string was longer than ctrl->maximum,
168 if (strlen(ctrl->p_new.p_char) == ctrl->maximum && last)
169 return -ERANGE;
170 ctrl->is_new = 1;
174 *ctrl->p_new.p_s32 = c->value;
177 ctrl->is_new = 1;
188 * It is not a fully atomic operation, just best-effort only. After all, if
199 * in case of low-level errors.
207 * after the failed one. Since if they were part of a control cluster they
208 * could have been successfully processed (if a cluster member was encountered
209 * at index < error_idx), they could have failed (if a cluster member was at
210 * error_idx), or they may not have been processed yet (if the first cluster
239 for (i = 0, h = helpers; i < cs->count; i++, h++) {
240 struct v4l2_ext_control *c = &cs->controls[i];
243 u32 id = c->id & V4L2_CTRL_ID_MASK;
245 cs->error_idx = i;
247 if (cs->which &&
248 (cs->which < V4L2_CTRL_WHICH_DEF_VAL ||
249 cs->which > V4L2_CTRL_WHICH_MAX_VAL) &&
250 V4L2_CTRL_ID2WHICH(id) != cs->which) {
253 cs->which, id);
254 return -EINVAL;
258 * Old-style private controls are not allowed for
263 "old-style private controls not allowed\n");
264 return -EINVAL;
269 return -EINVAL;
271 h->ref = ref;
272 ctrl = ref->ctrl;
273 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED) {
275 return -EINVAL;
278 if (!(ctrl->flags & V4L2_CTRL_FLAG_HAS_WHICH_MIN_MAX) &&
279 (cs->which == V4L2_CTRL_WHICH_MIN_VAL ||
280 cs->which == V4L2_CTRL_WHICH_MAX_VAL)) {
283 cs->which, id);
284 return -EINVAL;
287 if (ctrl->cluster[0]->ncontrols > 1)
289 if (ctrl->cluster[0] != ctrl)
290 ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
291 if (ctrl->is_dyn_array) {
292 unsigned int max_size = ctrl->dims[0] * ctrl->elem_size;
293 unsigned int tot_size = ctrl->elem_size;
295 if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL)
296 tot_size *= ref->p_req_elems;
298 tot_size *= ctrl->elems;
300 c->size = ctrl->elem_size * (c->size / ctrl->elem_size);
302 if (c->size < tot_size) {
303 c->size = tot_size;
304 return -ENOSPC;
306 c->size = tot_size;
308 if (c->size > max_size) {
309 c->size = max_size;
310 return -ENOSPC;
312 if (!c->size)
313 return -EFAULT;
315 } else if (ctrl->is_ptr && !ctrl->is_string) {
316 unsigned int tot_size = ctrl->elems * ctrl->elem_size;
318 if (c->size < tot_size) {
324 c->size = tot_size;
325 return -ENOSPC;
329 id, c->size, tot_size);
330 return -EFAULT;
332 c->size = tot_size;
334 /* Store the ref to the master control of the cluster */
335 h->mref = ref;
339 * cluster.
341 h->next = 0;
345 * We are done if there were no controls that belong to a multi-
346 * control cluster.
353 * belong to the same cluster.
357 mutex_lock(hdl->lock);
360 for (i = 0; i < cs->count; i++)
361 helpers[i].mref->helper = NULL;
362 for (i = 0, h = helpers; i < cs->count; i++, h++) {
363 struct v4l2_ctrl_ref *mref = h->mref;
366 * If the mref->helper is set, then it points to an earlier
367 * helper that belongs to the same cluster.
369 if (mref->helper) {
371 * Set the next field of mref->helper to the current
373 * points to the next helper in the same cluster.
375 mref->helper->next = i;
378 * cluster, clear the others.
380 h->mref = NULL;
383 mref->helper = h;
385 mutex_unlock(hdl->lock);
390 * Handles the corner case where cs->count == 0. It checks whether the
399 return find_ref_lock(hdl, which | 1) ? 0 : -EINVAL;
419 is_default = (cs->which == V4L2_CTRL_WHICH_DEF_VAL);
420 is_request = (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL);
421 is_min = (cs->which == V4L2_CTRL_WHICH_MIN_VAL);
422 is_max = (cs->which == V4L2_CTRL_WHICH_MAX_VAL);
424 cs->error_idx = cs->count;
425 cs->which = V4L2_CTRL_ID2WHICH(cs->which);
428 return -EINVAL;
430 if (cs->count == 0)
431 return class_check(hdl, cs->which);
433 if (cs->count > ARRAY_SIZE(helper)) {
434 helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
437 return -ENOMEM;
441 cs->error_idx = cs->count;
443 for (i = 0; !ret && i < cs->count; i++)
444 if (helpers[i].ref->ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
445 ret = -EACCES;
447 for (i = 0; !ret && i < cs->count; i++) {
455 master = helpers[i].mref->ctrl;
456 cs->error_idx = i;
470 ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
471 (master->has_volatiles && !is_cur_manual(master)))) {
472 for (j = 0; j < master->ncontrols; j++)
473 cur_to_new(master->cluster[j]);
493 ret = def_to_user(cs->controls + idx, ref->ctrl);
494 else if (is_request && ref->p_req_array_enomem)
495 ret = -ENOMEM;
496 else if (is_request && ref->p_req_valid)
497 ret = req_to_user(cs->controls + idx, ref);
499 ret = min_to_user(cs->controls + idx, ref->ctrl);
501 ret = max_to_user(cs->controls + idx, ref->ctrl);
503 ret = new_to_user(cs->controls + idx, ref->ctrl);
505 ret = cur_to_user(cs->controls + idx, ref->ctrl);
512 if (cs->count > ARRAY_SIZE(helper))
520 if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL)
530 return ctrl->type_ops->validate(ctrl, p_new);
542 cs->error_idx = cs->count;
543 for (i = 0; i < cs->count; i++) {
544 struct v4l2_ctrl *ctrl = helpers[i].ref->ctrl;
547 cs->error_idx = i;
549 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY) {
551 "control id 0x%x is read-only\n",
552 ctrl->id);
553 return -EACCES;
558 * but it makes sense to do an up-front check as well. Once
561 * best-effort to avoid that.
563 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)) {
566 ctrl->id);
567 return -EBUSY;
573 if (ctrl->is_ptr)
575 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
576 p_new.p_s64 = &cs->controls[i].value64;
578 p_new.p_s32 = &cs->controls[i].value;
586 /* Try or try-and-set controls */
597 cs->error_idx = cs->count;
600 if (cs->which == V4L2_CTRL_WHICH_DEF_VAL ||
601 cs->which == V4L2_CTRL_WHICH_MIN_VAL ||
602 cs->which == V4L2_CTRL_WHICH_MAX_VAL) {
605 return -EINVAL;
608 cs->which = V4L2_CTRL_ID2WHICH(cs->which);
613 return -EINVAL;
616 if (cs->count == 0)
617 return class_check(hdl, cs->which);
619 if (cs->count > ARRAY_SIZE(helper)) {
620 helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
623 return -ENOMEM;
629 cs->error_idx = cs->count;
630 for (i = 0; !ret && i < cs->count; i++) {
637 cs->error_idx = i;
638 master = helpers[i].mref->ctrl;
641 /* Reset the 'is_new' flags of the cluster */
642 for (j = 0; j < master->ncontrols; j++)
643 if (master->cluster[j])
644 master->cluster[j]->is_new = 0;
654 if (master->is_auto && master->has_volatiles &&
656 /* Pick an initial non-manual value */
657 s32 new_auto_val = master->manual_mode_value + 1;
665 if (helpers[tmp_idx].ref->ctrl == master)
666 new_auto_val = cs->controls[tmp_idx].value;
673 if (new_auto_val == master->manual_mode_value)
678 * Copy the new caller-supplied control values.
682 struct v4l2_ctrl *ctrl = helpers[idx].ref->ctrl;
684 ret = user_to_new(cs->controls + idx, ctrl);
685 if (!ret && ctrl->is_ptr) {
686 ret = validate_new(ctrl, ctrl->p_new);
690 v4l2_ctrl_get_name(ctrl->id), ret);
697 !hdl->req_obj.req && set, 0);
698 if (!ret && hdl->req_obj.req && set) {
699 for (j = 0; j < master->ncontrols; j++) {
701 find_ref(hdl, master->cluster[j]->id);
711 ret = new_to_user(cs->controls + idx,
712 helpers[idx].ref->ctrl);
719 if (cs->count > ARRAY_SIZE(helper))
732 if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL)
770 struct v4l2_ctrl *master = ctrl->cluster[0];
778 if (!ctrl->is_int && ctrl->type != V4L2_CTRL_TYPE_INTEGER64)
779 return -EINVAL;
781 if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
782 return -EACCES;
786 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
787 for (i = 0; i < master->ncontrols; i++)
788 cur_to_new(master->cluster[i]);
801 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
805 if (!ctrl || !ctrl->is_int)
806 return -EINVAL;
810 control->value = c.value;
819 struct v4l2_ctrl *master = ctrl->cluster[0];
823 /* Reset the 'is_new' flags of the cluster */
824 for (i = 0; i < master->ncontrols; i++)
825 if (master->cluster[i])
826 master->cluster[i]->is_new = 0;
828 ret = validate_new(ctrl, ctrl->p_new);
837 if (master->is_auto && master->has_volatiles && ctrl == master &&
838 !is_cur_manual(master) && ctrl->val == master->manual_mode_value)
841 ctrl->is_new = 1;
864 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
865 struct v4l2_ext_control c = { control->id };
868 if (!ctrl || !ctrl->is_int)
869 return -EINVAL;
871 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
872 return -EACCES;
874 c.value = control->value;
876 control->value = c.value;
890 if (WARN_ON(!ctrl->is_int))
903 if (WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64))
913 lockdep_assert_held(ctrl->handler->lock);
916 if (WARN_ON(!ctrl->is_int))
917 return -EINVAL;
918 ctrl->val = val;
925 lockdep_assert_held(ctrl->handler->lock);
928 if (WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64))
929 return -EINVAL;
930 *ctrl->p_new.p_s64 = val;
937 lockdep_assert_held(ctrl->handler->lock);
940 if (WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING))
941 return -EINVAL;
942 strscpy(ctrl->p_new.p_char, s, ctrl->maximum + 1);
950 lockdep_assert_held(ctrl->handler->lock);
953 if (WARN_ON(ctrl->type != type))
954 return -EINVAL;
956 if (WARN_ON(ctrl->is_dyn_array))
957 return -EINVAL;
958 memcpy(ctrl->p_new.p, p, ctrl->elems * ctrl->elem_size);
973 lockdep_assert_held(ctrl->handler->lock);
975 switch (ctrl->type) {
985 if (ctrl->is_array)
986 return -EINVAL;
987 ret = check_range(ctrl->type, min, max, step, def);
992 return -EINVAL;
994 if (ctrl->minimum != min || ctrl->maximum != max ||
995 ctrl->step != step || ctrl->default_value != def) {
997 ctrl->minimum = min;
998 ctrl->maximum = max;
999 ctrl->step = step;
1000 ctrl->default_value = def;
1003 if (validate_new(ctrl, ctrl->p_new)) {
1004 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
1005 *ctrl->p_new.p_s64 = def;
1007 *ctrl->p_new.p_s32 = def;
1010 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
1011 value_changed = *ctrl->p_new.p_s64 != *ctrl->p_cur.p_s64;
1013 value_changed = *ctrl->p_new.p_s32 != *ctrl->p_cur.p_s32;
1029 lockdep_assert_held(ctrl->handler->lock);
1031 if (!ctrl->is_array || ctrl->is_dyn_array)
1032 return -EINVAL;
1034 for (i = 0; i < ctrl->nr_of_dims; i++)
1037 return -EINVAL;
1038 p_array = kvzalloc(2 * elems * ctrl->elem_size, GFP_KERNEL);
1040 return -ENOMEM;
1041 kvfree(ctrl->p_array);
1042 ctrl->p_array_alloc_elems = elems;
1043 ctrl->elems = elems;
1044 ctrl->new_elems = elems;
1045 ctrl->p_array = p_array;
1046 ctrl->p_new.p = p_array;
1047 ctrl->p_cur.p = p_array + elems * ctrl->elem_size;
1048 for (i = 0; i < ctrl->nr_of_dims; i++)
1049 ctrl->dims[i] = dims[i];
1050 ctrl->type_ops->init(ctrl, 0, ctrl->p_cur);
1062 u32 id = qc->id & V4L2_CTRL_ID_MASK;
1067 return -EINVAL;
1069 mutex_lock(hdl->lock);
1074 if ((qc->id & next_flags) && !list_empty(&hdl->ctrl_refs)) {
1080 if ((qc->id & next_flags) == V4L2_CTRL_FLAG_NEXT_COMPOUND) {
1083 } else if ((qc->id & next_flags) == next_flags) {
1088 /* Find the next control with ID > qc->id */
1091 if (id >= node2id(hdl->ctrl_refs.prev)) {
1101 list_for_each_entry_continue(pos, &hdl->ctrl_refs, node) {
1102 is_compound = pos->ctrl->is_array ||
1103 pos->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
1104 if (id < pos->ctrl->id &&
1119 list_for_each_entry(pos, &hdl->ctrl_refs, node) {
1120 is_compound = pos->ctrl->is_array ||
1121 pos->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
1122 if (id < pos->ctrl->id &&
1130 mutex_unlock(hdl->lock);
1133 return -EINVAL;
1135 ctrl = ref->ctrl;
1138 qc->id = id;
1140 qc->id = ctrl->id;
1141 strscpy(qc->name, ctrl->name, sizeof(qc->name));
1142 qc->flags = user_flags(ctrl);
1143 qc->type = ctrl->type;
1144 qc->elem_size = ctrl->elem_size;
1145 qc->elems = ctrl->elems;
1146 qc->nr_of_dims = ctrl->nr_of_dims;
1147 memcpy(qc->dims, ctrl->dims, qc->nr_of_dims * sizeof(qc->dims[0]));
1148 qc->minimum = ctrl->minimum;
1149 qc->maximum = ctrl->maximum;
1150 qc->default_value = ctrl->default_value;
1151 if (ctrl->type == V4L2_CTRL_TYPE_MENU ||
1152 ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1153 qc->step = 1;
1155 qc->step = ctrl->step;
1163 to->id = from->id;
1164 to->type = from->type;
1165 to->flags = from->flags;
1166 strscpy(to->name, from->name, sizeof(to->name));
1168 switch (from->type) {
1175 to->minimum = from->minimum;
1176 to->maximum = from->maximum;
1177 to->step = from->step;
1178 to->default_value = from->default_value;
1181 to->minimum = 0;
1182 to->maximum = 0;
1183 to->step = 0;
1184 to->default_value = 0;
1193 struct v4l2_query_ext_ctrl qec = { qc->id };
1210 u32 i = qm->index;
1212 ctrl = v4l2_ctrl_find(hdl, qm->id);
1214 return -EINVAL;
1216 qm->reserved = 0;
1218 switch (ctrl->type) {
1220 if (!ctrl->qmenu)
1221 return -EINVAL;
1224 if (!ctrl->qmenu_int)
1225 return -EINVAL;
1228 return -EINVAL;
1231 if (i < ctrl->minimum || i > ctrl->maximum)
1232 return -EINVAL;
1235 if (i < BITS_PER_LONG_LONG && (ctrl->menu_skip_mask & BIT_ULL(i)))
1236 return -EINVAL;
1238 if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
1239 if (!ctrl->qmenu[i] || ctrl->qmenu[i][0] == '\0')
1240 return -EINVAL;
1241 strscpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
1243 qm->value = ctrl->qmenu_int[i];
1256 struct v4l2_fh *vfh = file->private_data;
1258 if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
1259 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
1260 vfd->v4l2_dev->name);
1267 v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
1279 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
1282 return -EINVAL;
1285 list_add_tail(&sev->node, &ctrl->ev_subs);
1286 if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
1287 (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL))
1288 send_initial_event(sev->fh, ctrl);
1295 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
1301 list_del(&sev->node);
1307 u32 old_changes = old->u.ctrl.changes;
1309 old->u.ctrl = new->u.ctrl;
1310 old->u.ctrl.changes |= old_changes;
1316 new->u.ctrl.changes |= old->u.ctrl.changes;
1331 if (sub->type == V4L2_EVENT_CTRL)
1333 return -EINVAL;
1340 if (!sd->ctrl_handler)
1341 return -EINVAL;
1351 struct v4l2_fh *fh = file->private_data;
1353 poll_wait(file, &fh->wait, wait);