Lines Matching full:ctrl
19 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, in fill_event() argument
24 ev->id = ctrl->id; in fill_event()
25 ev->u.ctrl.changes = changes; in fill_event()
26 ev->u.ctrl.type = ctrl->type; in fill_event()
27 ev->u.ctrl.flags = user_flags(ctrl); in fill_event()
28 if (ctrl->is_ptr) in fill_event()
29 ev->u.ctrl.value64 = 0; in fill_event()
31 ev->u.ctrl.value64 = *ctrl->p_cur.p_s64; in fill_event()
32 ev->u.ctrl.minimum = ctrl->minimum; in fill_event()
33 ev->u.ctrl.maximum = ctrl->maximum; in fill_event()
34 if (ctrl->type == V4L2_CTRL_TYPE_MENU in fill_event()
35 || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU) in fill_event()
36 ev->u.ctrl.step = 1; in fill_event()
38 ev->u.ctrl.step = ctrl->step; in fill_event()
39 ev->u.ctrl.default_value = ctrl->default_value; in fill_event()
42 void send_initial_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl) in send_initial_event() argument
47 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)) in send_initial_event()
49 fill_event(&ev, ctrl, changes); in send_initial_event()
53 void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes) in send_event() argument
58 if (list_empty(&ctrl->ev_subs)) in send_event()
60 fill_event(&ev, ctrl, changes); in send_event()
62 list_for_each_entry(sev, &ctrl->ev_subs, node) in send_event()
68 bool v4l2_ctrl_type_op_equal(const struct v4l2_ctrl *ctrl, in v4l2_ctrl_type_op_equal() argument
73 switch (ctrl->type) { in v4l2_ctrl_type_op_equal()
77 for (i = 0; i < ctrl->elems; i++) { in v4l2_ctrl_type_op_equal()
78 unsigned int idx = i * ctrl->elem_size; in v4l2_ctrl_type_op_equal()
87 ctrl->elems * ctrl->elem_size); in v4l2_ctrl_type_op_equal()
104 static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx, in std_init_compound() argument
115 void *p = ptr.p + idx * ctrl->elem_size; in std_init_compound()
117 if (ctrl->p_def.p_const) in std_init_compound()
118 memcpy(p, ctrl->p_def.p_const, ctrl->elem_size); in std_init_compound()
120 memset(p, 0, ctrl->elem_size); in std_init_compound()
122 switch ((u32)ctrl->type) { in std_init_compound()
185 static void std_min_compound(const struct v4l2_ctrl *ctrl, u32 idx, in std_min_compound() argument
188 void *p = ptr.p + idx * ctrl->elem_size; in std_min_compound()
190 if (ctrl->p_min.p_const) in std_min_compound()
191 memcpy(p, ctrl->p_min.p_const, ctrl->elem_size); in std_min_compound()
193 memset(p, 0, ctrl->elem_size); in std_min_compound()
196 static void std_max_compound(const struct v4l2_ctrl *ctrl, u32 idx, in std_max_compound() argument
199 void *p = ptr.p + idx * ctrl->elem_size; in std_max_compound()
201 if (ctrl->p_max.p_const) in std_max_compound()
202 memcpy(p, ctrl->p_max.p_const, ctrl->elem_size); in std_max_compound()
204 memset(p, 0, ctrl->elem_size); in std_max_compound()
207 static void __v4l2_ctrl_type_op_init(const struct v4l2_ctrl *ctrl, u32 from_idx, in __v4l2_ctrl_type_op_init() argument
211 u32 tot_elems = ctrl->elems; in __v4l2_ctrl_type_op_init()
217 value = ctrl->default_value; in __v4l2_ctrl_type_op_init()
220 value = ctrl->maximum; in __v4l2_ctrl_type_op_init()
223 value = ctrl->minimum; in __v4l2_ctrl_type_op_init()
229 switch (ctrl->type) { in __v4l2_ctrl_type_op_init()
232 value = ctrl->minimum; in __v4l2_ctrl_type_op_init()
235 unsigned int offset = i * ctrl->elem_size; in __v4l2_ctrl_type_op_init()
288 std_init_compound(ctrl, i, ptr); in __v4l2_ctrl_type_op_init()
291 std_max_compound(ctrl, i, ptr); in __v4l2_ctrl_type_op_init()
294 std_min_compound(ctrl, i, ptr); in __v4l2_ctrl_type_op_init()
302 void v4l2_ctrl_type_op_init(const struct v4l2_ctrl *ctrl, u32 from_idx, in v4l2_ctrl_type_op_init() argument
305 __v4l2_ctrl_type_op_init(ctrl, from_idx, V4L2_CTRL_WHICH_DEF_VAL, ptr); in v4l2_ctrl_type_op_init()
309 static void v4l2_ctrl_type_op_minimum(const struct v4l2_ctrl *ctrl, in v4l2_ctrl_type_op_minimum() argument
312 __v4l2_ctrl_type_op_init(ctrl, from_idx, V4L2_CTRL_WHICH_MIN_VAL, ptr); in v4l2_ctrl_type_op_minimum()
315 static void v4l2_ctrl_type_op_maximum(const struct v4l2_ctrl *ctrl, in v4l2_ctrl_type_op_maximum() argument
318 __v4l2_ctrl_type_op_init(ctrl, from_idx, V4L2_CTRL_WHICH_MAX_VAL, ptr); in v4l2_ctrl_type_op_maximum()
321 void v4l2_ctrl_type_op_log(const struct v4l2_ctrl *ctrl) in v4l2_ctrl_type_op_log() argument
323 union v4l2_ctrl_ptr ptr = ctrl->p_cur; in v4l2_ctrl_type_op_log()
325 if (ctrl->is_array) { in v4l2_ctrl_type_op_log()
328 for (i = 0; i < ctrl->nr_of_dims; i++) in v4l2_ctrl_type_op_log()
329 pr_cont("[%u]", ctrl->dims[i]); in v4l2_ctrl_type_op_log()
333 switch (ctrl->type) { in v4l2_ctrl_type_op_log()
341 pr_cont("%s", ctrl->qmenu[*ptr.p_s32]); in v4l2_ctrl_type_op_log()
344 pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]); in v4l2_ctrl_type_op_log()
445 pr_cont("unknown type %d", ctrl->type); in v4l2_ctrl_type_op_log()
456 #define ROUND_TO_RANGE(val, offset_type, ctrl) \ argument
459 if ((ctrl)->maximum >= 0 && \
460 val >= (ctrl)->maximum - (s32)((ctrl)->step / 2)) \
461 val = (ctrl)->maximum; \
463 val += (s32)((ctrl)->step / 2); \
465 (ctrl)->minimum, (ctrl)->maximum); \
466 offset = (val) - (ctrl)->minimum; \
467 offset = (ctrl)->step * (offset / (u32)(ctrl)->step); \
468 val = (ctrl)->minimum + offset; \
871 static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx, in std_validate_compound() argument
889 void *p = ptr.p + idx * ctrl->elem_size; in std_validate_compound()
892 switch ((u32)ctrl->type) { in std_validate_compound()
1259 static int std_validate_elem(const struct v4l2_ctrl *ctrl, u32 idx, in std_validate_elem() argument
1266 switch ((u32)ctrl->type) { in std_validate_elem()
1268 return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl); in std_validate_elem()
1275 if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2)) in std_validate_elem()
1276 val = ctrl->maximum; in std_validate_elem()
1278 val += (s64)(ctrl->step / 2); in std_validate_elem()
1279 val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum); in std_validate_elem()
1280 offset = val - ctrl->minimum; in std_validate_elem()
1281 do_div(offset, ctrl->step); in std_validate_elem()
1282 ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step; in std_validate_elem()
1285 return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl); in std_validate_elem()
1287 return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl); in std_validate_elem()
1289 return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl); in std_validate_elem()
1297 if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum) in std_validate_elem()
1300 (ctrl->menu_skip_mask & BIT_ULL(ptr.p_s32[idx]))) in std_validate_elem()
1302 if (ctrl->type == V4L2_CTRL_TYPE_MENU && in std_validate_elem()
1303 ctrl->qmenu[ptr.p_s32[idx]][0] == '\0') in std_validate_elem()
1308 ptr.p_s32[idx] &= ctrl->maximum; in std_validate_elem()
1317 idx *= ctrl->elem_size; in std_validate_elem()
1319 if (len < ctrl->minimum) in std_validate_elem()
1321 if ((len - (u32)ctrl->minimum) % (u32)ctrl->step) in std_validate_elem()
1326 return std_validate_compound(ctrl, idx, ptr); in std_validate_elem()
1330 int v4l2_ctrl_type_op_validate(const struct v4l2_ctrl *ctrl, in v4l2_ctrl_type_op_validate() argument
1336 switch ((u32)ctrl->type) { in v4l2_ctrl_type_op_validate()
1338 if (ctrl->maximum == 0xff && ctrl->minimum == 0 && ctrl->step == 1) in v4l2_ctrl_type_op_validate()
1342 if (ctrl->maximum == 0xffff && ctrl->minimum == 0 && ctrl->step == 1) in v4l2_ctrl_type_op_validate()
1346 if (ctrl->maximum == 0xffffffff && ctrl->minimum == 0 && ctrl->step == 1) in v4l2_ctrl_type_op_validate()
1352 memset(ptr.p_s32, 0, ctrl->new_elems * sizeof(s32)); in v4l2_ctrl_type_op_validate()
1356 for (i = 0; !ret && i < ctrl->new_elems; i++) in v4l2_ctrl_type_op_validate()
1357 ret = std_validate_elem(ctrl, i, ptr); in v4l2_ctrl_type_op_validate()
1371 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv) in v4l2_ctrl_notify() argument
1373 if (!ctrl) in v4l2_ctrl_notify()
1376 ctrl->call_notify = 0; in v4l2_ctrl_notify()
1379 if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify)) in v4l2_ctrl_notify()
1381 ctrl->handler->notify = notify; in v4l2_ctrl_notify()
1382 ctrl->handler->notify_priv = priv; in v4l2_ctrl_notify()
1383 ctrl->call_notify = 1; in v4l2_ctrl_notify()
1388 static void ptr_to_ptr(struct v4l2_ctrl *ctrl, in ptr_to_ptr() argument
1392 if (ctrl == NULL) in ptr_to_ptr()
1394 memcpy(to.p, from.p_const, elems * ctrl->elem_size); in ptr_to_ptr()
1398 void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags) in new_to_cur() argument
1402 if (ctrl == NULL) in new_to_cur()
1406 changed = ctrl->has_changed; in new_to_cur()
1408 if (ctrl->is_dyn_array) in new_to_cur()
1409 ctrl->elems = ctrl->new_elems; in new_to_cur()
1410 ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur, ctrl->elems); in new_to_cur()
1415 ctrl->flags &= in new_to_cur()
1417 if (!is_cur_manual(ctrl->cluster[0])) { in new_to_cur()
1418 ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE; in new_to_cur()
1419 if (ctrl->cluster[0]->has_volatiles) in new_to_cur()
1420 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE; in new_to_cur()
1427 if (!ctrl->is_new) in new_to_cur()
1429 send_event(fh, ctrl, in new_to_cur()
1431 if (ctrl->call_notify && changed && ctrl->handler->notify) in new_to_cur()
1432 ctrl->handler->notify(ctrl, ctrl->handler->notify_priv); in new_to_cur()
1437 void cur_to_new(struct v4l2_ctrl *ctrl) in cur_to_new() argument
1439 if (ctrl == NULL) in cur_to_new()
1441 if (ctrl->is_dyn_array) in cur_to_new()
1442 ctrl->new_elems = ctrl->elems; in cur_to_new()
1443 ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new, ctrl->new_elems); in cur_to_new()
1452 if (ref->ctrl->is_dyn_array && in req_alloc_array()
1456 tmp = kvmalloc(elems * ref->ctrl->elem_size, GFP_KERNEL); in req_alloc_array()
1472 struct v4l2_ctrl *ctrl; in new_to_req() local
1477 ctrl = ref->ctrl; in new_to_req()
1478 if (ctrl->is_array && !req_alloc_array(ref, ctrl->new_elems)) in new_to_req()
1481 ref->p_req_elems = ctrl->new_elems; in new_to_req()
1482 ptr_to_ptr(ctrl, ctrl->p_new, ref->p_req, ref->p_req_elems); in new_to_req()
1489 struct v4l2_ctrl *ctrl; in cur_to_req() local
1494 ctrl = ref->ctrl; in cur_to_req()
1495 if (ctrl->is_array && !req_alloc_array(ref, ctrl->elems)) in cur_to_req()
1498 ref->p_req_elems = ctrl->elems; in cur_to_req()
1499 ptr_to_ptr(ctrl, ctrl->p_cur, ref->p_req, ctrl->elems); in cur_to_req()
1506 struct v4l2_ctrl *ctrl; in req_to_new() local
1511 ctrl = ref->ctrl; in req_to_new()
1518 if (ctrl->is_dyn_array) in req_to_new()
1519 ctrl->new_elems = ctrl->elems; in req_to_new()
1520 ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new, ctrl->new_elems); in req_to_new()
1525 if (!ctrl->is_array) { in req_to_new()
1526 ptr_to_ptr(ctrl, ref->p_req, ctrl->p_new, ctrl->new_elems); in req_to_new()
1534 if (!ctrl->is_dyn_array && in req_to_new()
1535 ref->p_req_elems != ctrl->p_array_alloc_elems) in req_to_new()
1540 * elements in ctrl->p_array. If so, attempt to realloc ctrl->p_array. in req_to_new()
1545 if (ref->p_req_elems > ctrl->p_array_alloc_elems) { in req_to_new()
1546 unsigned int sz = ref->p_req_elems * ctrl->elem_size; in req_to_new()
1547 void *old = ctrl->p_array; in req_to_new()
1552 memcpy(tmp, ctrl->p_new.p, ctrl->elems * ctrl->elem_size); in req_to_new()
1553 memcpy(tmp + sz, ctrl->p_cur.p, ctrl->elems * ctrl->elem_size); in req_to_new()
1554 ctrl->p_new.p = tmp; in req_to_new()
1555 ctrl->p_cur.p = tmp + sz; in req_to_new()
1556 ctrl->p_array = tmp; in req_to_new()
1557 ctrl->p_array_alloc_elems = ref->p_req_elems; in req_to_new()
1561 ctrl->new_elems = ref->p_req_elems; in req_to_new()
1562 ptr_to_ptr(ctrl, ref->p_req, ctrl->p_new, ctrl->new_elems); in req_to_new()
1637 struct v4l2_ctrl *ctrl, *next_ctrl; in v4l2_ctrl_handler_free() local
1654 list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) { in v4l2_ctrl_handler_free()
1655 list_del(&ctrl->node); in v4l2_ctrl_handler_free()
1656 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node) in v4l2_ctrl_handler_free()
1658 kvfree(ctrl->p_array); in v4l2_ctrl_handler_free()
1659 kvfree(ctrl); in v4l2_ctrl_handler_free()
1685 if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER && in find_private_ref()
1686 V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) { in find_private_ref()
1687 if (!ref->ctrl->is_int) in find_private_ref()
1711 if (hdl->cached && hdl->cached->ctrl->id == id) in find_ref()
1716 while (ref && ref->ctrl->id != id) in find_ref()
1742 return ref ? ref->ctrl : NULL; in v4l2_ctrl_find()
1748 struct v4l2_ctrl *ctrl, in handler_new_ref() argument
1754 u32 id = ctrl->id; in handler_new_ref()
1766 if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES && in handler_new_ref()
1774 if (allocate_req && !ctrl->is_array) in handler_new_ref()
1775 size_extra_req = ctrl->elems * ctrl->elem_size; in handler_new_ref()
1779 new_ref->ctrl = ctrl; in handler_new_ref()
1799 if (ref->ctrl->id < id) in handler_new_ref()
1802 if (ref->ctrl->id == id) { in handler_new_ref()
1816 if (ctrl->handler == hdl) { in handler_new_ref()
1818 * new_ref->ctrl is basically a cluster array with one in handler_new_ref()
1822 ctrl->cluster = &new_ref->ctrl; in handler_new_ref()
1823 ctrl->ncontrols = 1; in handler_new_ref()
1845 struct v4l2_ctrl *ctrl; in v4l2_ctrl_new() local
2027 ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL); in v4l2_ctrl_new()
2028 if (ctrl == NULL) { in v4l2_ctrl_new()
2033 INIT_LIST_HEAD(&ctrl->node); in v4l2_ctrl_new()
2034 INIT_LIST_HEAD(&ctrl->ev_subs); in v4l2_ctrl_new()
2035 ctrl->handler = hdl; in v4l2_ctrl_new()
2036 ctrl->ops = ops; in v4l2_ctrl_new()
2037 ctrl->type_ops = type_ops ? type_ops : &std_type_ops; in v4l2_ctrl_new()
2038 ctrl->id = id; in v4l2_ctrl_new()
2039 ctrl->name = name; in v4l2_ctrl_new()
2040 ctrl->type = type; in v4l2_ctrl_new()
2041 ctrl->flags = flags; in v4l2_ctrl_new()
2042 ctrl->minimum = min; in v4l2_ctrl_new()
2043 ctrl->maximum = max; in v4l2_ctrl_new()
2044 ctrl->step = step; in v4l2_ctrl_new()
2045 ctrl->default_value = def; in v4l2_ctrl_new()
2046 ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING; in v4l2_ctrl_new()
2047 ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string; in v4l2_ctrl_new()
2048 ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64; in v4l2_ctrl_new()
2049 ctrl->is_array = is_array; in v4l2_ctrl_new()
2050 ctrl->is_dyn_array = !!(flags & V4L2_CTRL_FLAG_DYNAMIC_ARRAY); in v4l2_ctrl_new()
2051 ctrl->elems = elems; in v4l2_ctrl_new()
2052 ctrl->new_elems = elems; in v4l2_ctrl_new()
2053 ctrl->nr_of_dims = nr_of_dims; in v4l2_ctrl_new()
2055 memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0])); in v4l2_ctrl_new()
2056 ctrl->elem_size = elem_size; in v4l2_ctrl_new()
2058 ctrl->qmenu = qmenu; in v4l2_ctrl_new()
2060 ctrl->qmenu_int = qmenu_int; in v4l2_ctrl_new()
2061 ctrl->priv = priv; in v4l2_ctrl_new()
2062 ctrl->cur.val = ctrl->val = def; in v4l2_ctrl_new()
2063 data = &ctrl[1]; in v4l2_ctrl_new()
2065 if (ctrl->is_array) { in v4l2_ctrl_new()
2066 ctrl->p_array_alloc_elems = elems; in v4l2_ctrl_new()
2067 ctrl->p_array = kvzalloc(2 * elems * elem_size, GFP_KERNEL); in v4l2_ctrl_new()
2068 if (!ctrl->p_array) { in v4l2_ctrl_new()
2069 kvfree(ctrl); in v4l2_ctrl_new()
2072 data = ctrl->p_array; in v4l2_ctrl_new()
2075 if (!ctrl->is_int) { in v4l2_ctrl_new()
2076 ctrl->p_new.p = data; in v4l2_ctrl_new()
2077 ctrl->p_cur.p = data + tot_ctrl_size; in v4l2_ctrl_new()
2079 ctrl->p_new.p = &ctrl->val; in v4l2_ctrl_new()
2080 ctrl->p_cur.p = &ctrl->cur.val; in v4l2_ctrl_new()
2084 if (ctrl->is_array) in v4l2_ctrl_new()
2085 ctrl->p_def.p = &ctrl[1]; in v4l2_ctrl_new()
2087 ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size; in v4l2_ctrl_new()
2088 memcpy(ctrl->p_def.p, p_def.p_const, elem_size); in v4l2_ctrl_new()
2092 void *ptr = ctrl->p_def.p; in v4l2_ctrl_new()
2096 ctrl->p_min.p = ptr; in v4l2_ctrl_new()
2097 memcpy(ctrl->p_min.p, p_min.p_const, elem_size); in v4l2_ctrl_new()
2102 ctrl->p_max.p = ptr; in v4l2_ctrl_new()
2103 memcpy(ctrl->p_max.p, p_max.p_const, elem_size); in v4l2_ctrl_new()
2107 ctrl->type_ops->init(ctrl, 0, ctrl->p_cur); in v4l2_ctrl_new()
2108 cur_to_new(ctrl); in v4l2_ctrl_new()
2110 if (handler_new_ref(hdl, ctrl, NULL, false, false)) { in v4l2_ctrl_new()
2111 kvfree(ctrl->p_array); in v4l2_ctrl_new()
2112 kvfree(ctrl); in v4l2_ctrl_new()
2116 list_add_tail(&ctrl->node, &hdl->ctrls); in v4l2_ctrl_new()
2118 return ctrl; in v4l2_ctrl_new()
2125 struct v4l2_ctrl *ctrl; in v4l2_ctrl_new_custom() local
2153 ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name, in v4l2_ctrl_new_custom()
2159 if (ctrl) in v4l2_ctrl_new_custom()
2160 ctrl->is_private = cfg->is_private; in v4l2_ctrl_new_custom()
2161 return ctrl; in v4l2_ctrl_new_custom()
2307 bool (*filter)(const struct v4l2_ctrl *ctrl), in v4l2_ctrl_add_handler() argument
2320 struct v4l2_ctrl *ctrl = ref->ctrl; in v4l2_ctrl_add_handler() local
2323 if (ctrl->is_private) in v4l2_ctrl_add_handler()
2326 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS) in v4l2_ctrl_add_handler()
2329 if (filter && !filter(ctrl)) in v4l2_ctrl_add_handler()
2331 ret = handler_new_ref(hdl, ctrl, NULL, from_other_dev, false); in v4l2_ctrl_add_handler()
2340 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl) in v4l2_ctrl_radio_filter() argument
2342 if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX) in v4l2_ctrl_radio_filter()
2344 if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX) in v4l2_ctrl_radio_filter()
2346 switch (ctrl->id) { in v4l2_ctrl_radio_filter()
2435 struct v4l2_ctrl *ctrl = master->cluster[i]; in cluster_changed() local
2438 if (!ctrl) in cluster_changed()
2441 if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE) { in cluster_changed()
2450 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) { in cluster_changed()
2451 ctrl->has_changed = false; in cluster_changed()
2455 if (ctrl->elems != ctrl->new_elems) in cluster_changed()
2458 ctrl_changed = !ctrl->type_ops->equal(ctrl, in cluster_changed()
2459 ctrl->p_cur, ctrl->p_new); in cluster_changed()
2460 ctrl->has_changed = ctrl_changed; in cluster_changed()
2461 changed |= ctrl->has_changed; in cluster_changed()
2469 * Must be called with ctrl->handler->lock held.
2485 struct v4l2_ctrl *ctrl = master->cluster[i]; in try_or_set_cluster() local
2487 if (!ctrl) in try_or_set_cluster()
2490 if (!ctrl->is_new) { in try_or_set_cluster()
2491 cur_to_new(ctrl); in try_or_set_cluster()
2498 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)) in try_or_set_cluster()
2533 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active) in v4l2_ctrl_activate() argument
2539 if (ctrl == NULL) in v4l2_ctrl_activate()
2544 old = test_and_set_bit(4, &ctrl->flags); in v4l2_ctrl_activate()
2547 old = test_and_clear_bit(4, &ctrl->flags); in v4l2_ctrl_activate()
2549 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS); in v4l2_ctrl_activate()
2553 void __v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed) in __v4l2_ctrl_grab() argument
2557 if (ctrl == NULL) in __v4l2_ctrl_grab()
2560 lockdep_assert_held(ctrl->handler->lock); in __v4l2_ctrl_grab()
2564 old = test_and_set_bit(1, &ctrl->flags); in __v4l2_ctrl_grab()
2567 old = test_and_clear_bit(1, &ctrl->flags); in __v4l2_ctrl_grab()
2569 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS); in __v4l2_ctrl_grab()
2576 struct v4l2_ctrl *ctrl; in __v4l2_ctrl_handler_setup() local
2584 list_for_each_entry(ctrl, &hdl->ctrls, node) in __v4l2_ctrl_handler_setup()
2585 ctrl->done = false; in __v4l2_ctrl_handler_setup()
2587 list_for_each_entry(ctrl, &hdl->ctrls, node) { in __v4l2_ctrl_handler_setup()
2588 struct v4l2_ctrl *master = ctrl->cluster[0]; in __v4l2_ctrl_handler_setup()
2593 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON || in __v4l2_ctrl_handler_setup()
2594 (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)) in __v4l2_ctrl_handler_setup()
2629 static void log_ctrl(const struct v4l2_ctrl *ctrl, in log_ctrl() argument
2632 if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY)) in log_ctrl()
2634 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS) in log_ctrl()
2637 pr_info("%s%s%s: ", prefix, colon, ctrl->name); in log_ctrl()
2639 ctrl->type_ops->log(ctrl); in log_ctrl()
2641 if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE | in log_ctrl()
2644 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE) in log_ctrl()
2646 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED) in log_ctrl()
2648 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) in log_ctrl()
2658 struct v4l2_ctrl *ctrl; in v4l2_ctrl_handler_log_status() local
2670 list_for_each_entry(ctrl, &hdl->ctrls, node) in v4l2_ctrl_handler_log_status()
2671 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED)) in v4l2_ctrl_handler_log_status()
2672 log_ctrl(ctrl, prefix, colon); in v4l2_ctrl_handler_log_status()