1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * V4L2 controls framework core implementation.
4 *
5 * Copyright (C) 2010-2021 Hans Verkuil <hverkuil-cisco@xs4all.nl>
6 */
7
8 #include <linux/export.h>
9 #include <linux/mm.h>
10 #include <linux/slab.h>
11 #include <media/v4l2-ctrls.h>
12 #include <media/v4l2-event.h>
13 #include <media/v4l2-fwnode.h>
14
15 #include "v4l2-ctrls-priv.h"
16
17 static const union v4l2_ctrl_ptr ptr_null;
18
fill_event(struct v4l2_event * ev,struct v4l2_ctrl * ctrl,u32 changes)19 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl,
20 u32 changes)
21 {
22 memset(ev, 0, sizeof(*ev));
23 ev->type = V4L2_EVENT_CTRL;
24 ev->id = ctrl->id;
25 ev->u.ctrl.changes = changes;
26 ev->u.ctrl.type = ctrl->type;
27 ev->u.ctrl.flags = user_flags(ctrl);
28 if (ctrl->is_ptr)
29 ev->u.ctrl.value64 = 0;
30 else
31 ev->u.ctrl.value64 = *ctrl->p_cur.p_s64;
32 ev->u.ctrl.minimum = ctrl->minimum;
33 ev->u.ctrl.maximum = ctrl->maximum;
34 if (ctrl->type == V4L2_CTRL_TYPE_MENU
35 || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
36 ev->u.ctrl.step = 1;
37 else
38 ev->u.ctrl.step = ctrl->step;
39 ev->u.ctrl.default_value = ctrl->default_value;
40 }
41
send_initial_event(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl)42 void send_initial_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl)
43 {
44 struct v4l2_event ev;
45 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
46
47 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
48 changes |= V4L2_EVENT_CTRL_CH_VALUE;
49 fill_event(&ev, ctrl, changes);
50 v4l2_event_queue_fh(fh, &ev);
51 }
52
send_event(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,u32 changes)53 void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
54 {
55 struct v4l2_event ev;
56 struct v4l2_subscribed_event *sev;
57
58 if (list_empty(&ctrl->ev_subs))
59 return;
60 fill_event(&ev, ctrl, changes);
61
62 list_for_each_entry(sev, &ctrl->ev_subs, node)
63 if (sev->fh != fh ||
64 (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
65 v4l2_event_queue_fh(sev->fh, &ev);
66 }
67
std_equal(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr1,union v4l2_ctrl_ptr ptr2)68 static bool std_equal(const struct v4l2_ctrl *ctrl, u32 idx,
69 union v4l2_ctrl_ptr ptr1,
70 union v4l2_ctrl_ptr ptr2)
71 {
72 switch (ctrl->type) {
73 case V4L2_CTRL_TYPE_BUTTON:
74 return false;
75 case V4L2_CTRL_TYPE_STRING:
76 idx *= ctrl->elem_size;
77 /* strings are always 0-terminated */
78 return !strcmp(ptr1.p_char + idx, ptr2.p_char + idx);
79 case V4L2_CTRL_TYPE_INTEGER64:
80 return ptr1.p_s64[idx] == ptr2.p_s64[idx];
81 case V4L2_CTRL_TYPE_U8:
82 return ptr1.p_u8[idx] == ptr2.p_u8[idx];
83 case V4L2_CTRL_TYPE_U16:
84 return ptr1.p_u16[idx] == ptr2.p_u16[idx];
85 case V4L2_CTRL_TYPE_U32:
86 return ptr1.p_u32[idx] == ptr2.p_u32[idx];
87 default:
88 if (ctrl->is_int)
89 return ptr1.p_s32[idx] == ptr2.p_s32[idx];
90 idx *= ctrl->elem_size;
91 return !memcmp(ptr1.p_const + idx, ptr2.p_const + idx,
92 ctrl->elem_size);
93 }
94 }
95
96 /* Default intra MPEG-2 quantisation coefficients, from the specification. */
97 static const u8 mpeg2_intra_quant_matrix[64] = {
98 8, 16, 16, 19, 16, 19, 22, 22,
99 22, 22, 22, 22, 26, 24, 26, 27,
100 27, 27, 26, 26, 26, 26, 27, 27,
101 27, 29, 29, 29, 34, 34, 34, 29,
102 29, 29, 27, 27, 29, 29, 32, 32,
103 34, 34, 37, 38, 37, 35, 35, 34,
104 35, 38, 38, 40, 40, 40, 48, 48,
105 46, 46, 56, 56, 58, 69, 69, 83
106 };
107
std_init_compound(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr)108 static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx,
109 union v4l2_ctrl_ptr ptr)
110 {
111 struct v4l2_ctrl_mpeg2_sequence *p_mpeg2_sequence;
112 struct v4l2_ctrl_mpeg2_picture *p_mpeg2_picture;
113 struct v4l2_ctrl_mpeg2_quantisation *p_mpeg2_quant;
114 struct v4l2_ctrl_vp8_frame *p_vp8_frame;
115 struct v4l2_ctrl_vp9_frame *p_vp9_frame;
116 struct v4l2_ctrl_fwht_params *p_fwht_params;
117 struct v4l2_ctrl_h264_scaling_matrix *p_h264_scaling_matrix;
118 void *p = ptr.p + idx * ctrl->elem_size;
119
120 if (ctrl->p_def.p_const)
121 memcpy(p, ctrl->p_def.p_const, ctrl->elem_size);
122 else
123 memset(p, 0, ctrl->elem_size);
124
125 switch ((u32)ctrl->type) {
126 case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
127 p_mpeg2_sequence = p;
128
129 /* 4:2:0 */
130 p_mpeg2_sequence->chroma_format = 1;
131 break;
132 case V4L2_CTRL_TYPE_MPEG2_PICTURE:
133 p_mpeg2_picture = p;
134
135 /* interlaced top field */
136 p_mpeg2_picture->picture_structure = V4L2_MPEG2_PIC_TOP_FIELD;
137 p_mpeg2_picture->picture_coding_type =
138 V4L2_MPEG2_PIC_CODING_TYPE_I;
139 break;
140 case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
141 p_mpeg2_quant = p;
142
143 memcpy(p_mpeg2_quant->intra_quantiser_matrix,
144 mpeg2_intra_quant_matrix,
145 ARRAY_SIZE(mpeg2_intra_quant_matrix));
146 /*
147 * The default non-intra MPEG-2 quantisation
148 * coefficients are all 16, as per the specification.
149 */
150 memset(p_mpeg2_quant->non_intra_quantiser_matrix, 16,
151 sizeof(p_mpeg2_quant->non_intra_quantiser_matrix));
152 break;
153 case V4L2_CTRL_TYPE_VP8_FRAME:
154 p_vp8_frame = p;
155 p_vp8_frame->num_dct_parts = 1;
156 break;
157 case V4L2_CTRL_TYPE_VP9_FRAME:
158 p_vp9_frame = p;
159 p_vp9_frame->profile = 0;
160 p_vp9_frame->bit_depth = 8;
161 p_vp9_frame->flags |= V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING |
162 V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING;
163 break;
164 case V4L2_CTRL_TYPE_FWHT_PARAMS:
165 p_fwht_params = p;
166 p_fwht_params->version = V4L2_FWHT_VERSION;
167 p_fwht_params->width = 1280;
168 p_fwht_params->height = 720;
169 p_fwht_params->flags = V4L2_FWHT_FL_PIXENC_YUV |
170 (2 << V4L2_FWHT_FL_COMPONENTS_NUM_OFFSET);
171 break;
172 case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
173 p_h264_scaling_matrix = p;
174 /*
175 * The default (flat) H.264 scaling matrix when none are
176 * specified in the bitstream, this is according to formulas
177 * (7-8) and (7-9) of the specification.
178 */
179 memset(p_h264_scaling_matrix, 16, sizeof(*p_h264_scaling_matrix));
180 break;
181 }
182 }
183
std_init(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr)184 static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
185 union v4l2_ctrl_ptr ptr)
186 {
187 switch (ctrl->type) {
188 case V4L2_CTRL_TYPE_STRING:
189 idx *= ctrl->elem_size;
190 memset(ptr.p_char + idx, ' ', ctrl->minimum);
191 ptr.p_char[idx + ctrl->minimum] = '\0';
192 break;
193 case V4L2_CTRL_TYPE_INTEGER64:
194 ptr.p_s64[idx] = ctrl->default_value;
195 break;
196 case V4L2_CTRL_TYPE_INTEGER:
197 case V4L2_CTRL_TYPE_INTEGER_MENU:
198 case V4L2_CTRL_TYPE_MENU:
199 case V4L2_CTRL_TYPE_BITMASK:
200 case V4L2_CTRL_TYPE_BOOLEAN:
201 ptr.p_s32[idx] = ctrl->default_value;
202 break;
203 case V4L2_CTRL_TYPE_BUTTON:
204 case V4L2_CTRL_TYPE_CTRL_CLASS:
205 ptr.p_s32[idx] = 0;
206 break;
207 case V4L2_CTRL_TYPE_U8:
208 ptr.p_u8[idx] = ctrl->default_value;
209 break;
210 case V4L2_CTRL_TYPE_U16:
211 ptr.p_u16[idx] = ctrl->default_value;
212 break;
213 case V4L2_CTRL_TYPE_U32:
214 ptr.p_u32[idx] = ctrl->default_value;
215 break;
216 default:
217 std_init_compound(ctrl, idx, ptr);
218 break;
219 }
220 }
221
std_log(const struct v4l2_ctrl * ctrl)222 static void std_log(const struct v4l2_ctrl *ctrl)
223 {
224 union v4l2_ctrl_ptr ptr = ctrl->p_cur;
225
226 if (ctrl->is_array) {
227 unsigned i;
228
229 for (i = 0; i < ctrl->nr_of_dims; i++)
230 pr_cont("[%u]", ctrl->dims[i]);
231 pr_cont(" ");
232 }
233
234 switch (ctrl->type) {
235 case V4L2_CTRL_TYPE_INTEGER:
236 pr_cont("%d", *ptr.p_s32);
237 break;
238 case V4L2_CTRL_TYPE_BOOLEAN:
239 pr_cont("%s", *ptr.p_s32 ? "true" : "false");
240 break;
241 case V4L2_CTRL_TYPE_MENU:
242 pr_cont("%s", ctrl->qmenu[*ptr.p_s32]);
243 break;
244 case V4L2_CTRL_TYPE_INTEGER_MENU:
245 pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]);
246 break;
247 case V4L2_CTRL_TYPE_BITMASK:
248 pr_cont("0x%08x", *ptr.p_s32);
249 break;
250 case V4L2_CTRL_TYPE_INTEGER64:
251 pr_cont("%lld", *ptr.p_s64);
252 break;
253 case V4L2_CTRL_TYPE_STRING:
254 pr_cont("%s", ptr.p_char);
255 break;
256 case V4L2_CTRL_TYPE_U8:
257 pr_cont("%u", (unsigned)*ptr.p_u8);
258 break;
259 case V4L2_CTRL_TYPE_U16:
260 pr_cont("%u", (unsigned)*ptr.p_u16);
261 break;
262 case V4L2_CTRL_TYPE_U32:
263 pr_cont("%u", (unsigned)*ptr.p_u32);
264 break;
265 case V4L2_CTRL_TYPE_H264_SPS:
266 pr_cont("H264_SPS");
267 break;
268 case V4L2_CTRL_TYPE_H264_PPS:
269 pr_cont("H264_PPS");
270 break;
271 case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
272 pr_cont("H264_SCALING_MATRIX");
273 break;
274 case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
275 pr_cont("H264_SLICE_PARAMS");
276 break;
277 case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
278 pr_cont("H264_DECODE_PARAMS");
279 break;
280 case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
281 pr_cont("H264_PRED_WEIGHTS");
282 break;
283 case V4L2_CTRL_TYPE_FWHT_PARAMS:
284 pr_cont("FWHT_PARAMS");
285 break;
286 case V4L2_CTRL_TYPE_VP8_FRAME:
287 pr_cont("VP8_FRAME");
288 break;
289 case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
290 pr_cont("HDR10_CLL_INFO");
291 break;
292 case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
293 pr_cont("HDR10_MASTERING_DISPLAY");
294 break;
295 case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
296 pr_cont("MPEG2_QUANTISATION");
297 break;
298 case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
299 pr_cont("MPEG2_SEQUENCE");
300 break;
301 case V4L2_CTRL_TYPE_MPEG2_PICTURE:
302 pr_cont("MPEG2_PICTURE");
303 break;
304 case V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR:
305 pr_cont("VP9_COMPRESSED_HDR");
306 break;
307 case V4L2_CTRL_TYPE_VP9_FRAME:
308 pr_cont("VP9_FRAME");
309 break;
310 default:
311 pr_cont("unknown type %d", ctrl->type);
312 break;
313 }
314 }
315
316 /*
317 * Round towards the closest legal value. Be careful when we are
318 * close to the maximum range of the control type to prevent
319 * wrap-arounds.
320 */
321 #define ROUND_TO_RANGE(val, offset_type, ctrl) \
322 ({ \
323 offset_type offset; \
324 if ((ctrl)->maximum >= 0 && \
325 val >= (ctrl)->maximum - (s32)((ctrl)->step / 2)) \
326 val = (ctrl)->maximum; \
327 else \
328 val += (s32)((ctrl)->step / 2); \
329 val = clamp_t(typeof(val), val, \
330 (ctrl)->minimum, (ctrl)->maximum); \
331 offset = (val) - (ctrl)->minimum; \
332 offset = (ctrl)->step * (offset / (u32)(ctrl)->step); \
333 val = (ctrl)->minimum + offset; \
334 0; \
335 })
336
337 /* Validate a new control */
338
339 #define zero_padding(s) \
340 memset(&(s).padding, 0, sizeof((s).padding))
341 #define zero_reserved(s) \
342 memset(&(s).reserved, 0, sizeof((s).reserved))
343
344 static int
validate_vp9_lf_params(struct v4l2_vp9_loop_filter * lf)345 validate_vp9_lf_params(struct v4l2_vp9_loop_filter *lf)
346 {
347 unsigned int i;
348
349 if (lf->flags & ~(V4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLED |
350 V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE))
351 return -EINVAL;
352
353 /* That all values are in the accepted range. */
354 if (lf->level > GENMASK(5, 0))
355 return -EINVAL;
356
357 if (lf->sharpness > GENMASK(2, 0))
358 return -EINVAL;
359
360 for (i = 0; i < ARRAY_SIZE(lf->ref_deltas); i++)
361 if (lf->ref_deltas[i] < -63 || lf->ref_deltas[i] > 63)
362 return -EINVAL;
363
364 for (i = 0; i < ARRAY_SIZE(lf->mode_deltas); i++)
365 if (lf->mode_deltas[i] < -63 || lf->mode_deltas[i] > 63)
366 return -EINVAL;
367
368 zero_reserved(*lf);
369 return 0;
370 }
371
372 static int
validate_vp9_quant_params(struct v4l2_vp9_quantization * quant)373 validate_vp9_quant_params(struct v4l2_vp9_quantization *quant)
374 {
375 if (quant->delta_q_y_dc < -15 || quant->delta_q_y_dc > 15 ||
376 quant->delta_q_uv_dc < -15 || quant->delta_q_uv_dc > 15 ||
377 quant->delta_q_uv_ac < -15 || quant->delta_q_uv_ac > 15)
378 return -EINVAL;
379
380 zero_reserved(*quant);
381 return 0;
382 }
383
384 static int
validate_vp9_seg_params(struct v4l2_vp9_segmentation * seg)385 validate_vp9_seg_params(struct v4l2_vp9_segmentation *seg)
386 {
387 unsigned int i, j;
388
389 if (seg->flags & ~(V4L2_VP9_SEGMENTATION_FLAG_ENABLED |
390 V4L2_VP9_SEGMENTATION_FLAG_UPDATE_MAP |
391 V4L2_VP9_SEGMENTATION_FLAG_TEMPORAL_UPDATE |
392 V4L2_VP9_SEGMENTATION_FLAG_UPDATE_DATA |
393 V4L2_VP9_SEGMENTATION_FLAG_ABS_OR_DELTA_UPDATE))
394 return -EINVAL;
395
396 for (i = 0; i < ARRAY_SIZE(seg->feature_enabled); i++) {
397 if (seg->feature_enabled[i] &
398 ~V4L2_VP9_SEGMENT_FEATURE_ENABLED_MASK)
399 return -EINVAL;
400 }
401
402 for (i = 0; i < ARRAY_SIZE(seg->feature_data); i++) {
403 static const int range[] = { 255, 63, 3, 0 };
404
405 for (j = 0; j < ARRAY_SIZE(seg->feature_data[j]); j++) {
406 if (seg->feature_data[i][j] < -range[j] ||
407 seg->feature_data[i][j] > range[j])
408 return -EINVAL;
409 }
410 }
411
412 zero_reserved(*seg);
413 return 0;
414 }
415
416 static int
validate_vp9_compressed_hdr(struct v4l2_ctrl_vp9_compressed_hdr * hdr)417 validate_vp9_compressed_hdr(struct v4l2_ctrl_vp9_compressed_hdr *hdr)
418 {
419 if (hdr->tx_mode > V4L2_VP9_TX_MODE_SELECT)
420 return -EINVAL;
421
422 return 0;
423 }
424
425 static int
validate_vp9_frame(struct v4l2_ctrl_vp9_frame * frame)426 validate_vp9_frame(struct v4l2_ctrl_vp9_frame *frame)
427 {
428 int ret;
429
430 /* Make sure we're not passed invalid flags. */
431 if (frame->flags & ~(V4L2_VP9_FRAME_FLAG_KEY_FRAME |
432 V4L2_VP9_FRAME_FLAG_SHOW_FRAME |
433 V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT |
434 V4L2_VP9_FRAME_FLAG_INTRA_ONLY |
435 V4L2_VP9_FRAME_FLAG_ALLOW_HIGH_PREC_MV |
436 V4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTX |
437 V4L2_VP9_FRAME_FLAG_PARALLEL_DEC_MODE |
438 V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING |
439 V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING |
440 V4L2_VP9_FRAME_FLAG_COLOR_RANGE_FULL_SWING))
441 return -EINVAL;
442
443 if (frame->flags & V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT &&
444 frame->flags & V4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTX)
445 return -EINVAL;
446
447 if (frame->profile > V4L2_VP9_PROFILE_MAX)
448 return -EINVAL;
449
450 if (frame->reset_frame_context > V4L2_VP9_RESET_FRAME_CTX_ALL)
451 return -EINVAL;
452
453 if (frame->frame_context_idx >= V4L2_VP9_NUM_FRAME_CTX)
454 return -EINVAL;
455
456 /*
457 * Profiles 0 and 1 only support 8-bit depth, profiles 2 and 3 only 10
458 * and 12 bit depths.
459 */
460 if ((frame->profile < 2 && frame->bit_depth != 8) ||
461 (frame->profile >= 2 &&
462 (frame->bit_depth != 10 && frame->bit_depth != 12)))
463 return -EINVAL;
464
465 /* Profile 0 and 2 only accept YUV 4:2:0. */
466 if ((frame->profile == 0 || frame->profile == 2) &&
467 (!(frame->flags & V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING) ||
468 !(frame->flags & V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING)))
469 return -EINVAL;
470
471 /* Profile 1 and 3 only accept YUV 4:2:2, 4:4:0 and 4:4:4. */
472 if ((frame->profile == 1 || frame->profile == 3) &&
473 ((frame->flags & V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING) &&
474 (frame->flags & V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING)))
475 return -EINVAL;
476
477 if (frame->interpolation_filter > V4L2_VP9_INTERP_FILTER_SWITCHABLE)
478 return -EINVAL;
479
480 /*
481 * According to the spec, tile_cols_log2 shall be less than or equal
482 * to 6.
483 */
484 if (frame->tile_cols_log2 > 6)
485 return -EINVAL;
486
487 if (frame->reference_mode > V4L2_VP9_REFERENCE_MODE_SELECT)
488 return -EINVAL;
489
490 ret = validate_vp9_lf_params(&frame->lf);
491 if (ret)
492 return ret;
493
494 ret = validate_vp9_quant_params(&frame->quant);
495 if (ret)
496 return ret;
497
498 ret = validate_vp9_seg_params(&frame->seg);
499 if (ret)
500 return ret;
501
502 zero_reserved(*frame);
503 return 0;
504 }
505
506 /*
507 * Compound controls validation requires setting unused fields/flags to zero
508 * in order to properly detect unchanged controls with std_equal's memcmp.
509 */
std_validate_compound(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr)510 static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx,
511 union v4l2_ctrl_ptr ptr)
512 {
513 struct v4l2_ctrl_mpeg2_sequence *p_mpeg2_sequence;
514 struct v4l2_ctrl_mpeg2_picture *p_mpeg2_picture;
515 struct v4l2_ctrl_vp8_frame *p_vp8_frame;
516 struct v4l2_ctrl_fwht_params *p_fwht_params;
517 struct v4l2_ctrl_h264_sps *p_h264_sps;
518 struct v4l2_ctrl_h264_pps *p_h264_pps;
519 struct v4l2_ctrl_h264_pred_weights *p_h264_pred_weights;
520 struct v4l2_ctrl_h264_slice_params *p_h264_slice_params;
521 struct v4l2_ctrl_h264_decode_params *p_h264_dec_params;
522 struct v4l2_ctrl_hevc_sps *p_hevc_sps;
523 struct v4l2_ctrl_hevc_pps *p_hevc_pps;
524 struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params;
525 struct v4l2_ctrl_hdr10_mastering_display *p_hdr10_mastering;
526 struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params;
527 struct v4l2_area *area;
528 void *p = ptr.p + idx * ctrl->elem_size;
529 unsigned int i;
530
531 switch ((u32)ctrl->type) {
532 case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
533 p_mpeg2_sequence = p;
534
535 switch (p_mpeg2_sequence->chroma_format) {
536 case 1: /* 4:2:0 */
537 case 2: /* 4:2:2 */
538 case 3: /* 4:4:4 */
539 break;
540 default:
541 return -EINVAL;
542 }
543 break;
544
545 case V4L2_CTRL_TYPE_MPEG2_PICTURE:
546 p_mpeg2_picture = p;
547
548 switch (p_mpeg2_picture->intra_dc_precision) {
549 case 0: /* 8 bits */
550 case 1: /* 9 bits */
551 case 2: /* 10 bits */
552 case 3: /* 11 bits */
553 break;
554 default:
555 return -EINVAL;
556 }
557
558 switch (p_mpeg2_picture->picture_structure) {
559 case V4L2_MPEG2_PIC_TOP_FIELD:
560 case V4L2_MPEG2_PIC_BOTTOM_FIELD:
561 case V4L2_MPEG2_PIC_FRAME:
562 break;
563 default:
564 return -EINVAL;
565 }
566
567 switch (p_mpeg2_picture->picture_coding_type) {
568 case V4L2_MPEG2_PIC_CODING_TYPE_I:
569 case V4L2_MPEG2_PIC_CODING_TYPE_P:
570 case V4L2_MPEG2_PIC_CODING_TYPE_B:
571 break;
572 default:
573 return -EINVAL;
574 }
575 zero_reserved(*p_mpeg2_picture);
576 break;
577
578 case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
579 break;
580
581 case V4L2_CTRL_TYPE_FWHT_PARAMS:
582 p_fwht_params = p;
583 if (p_fwht_params->version < V4L2_FWHT_VERSION)
584 return -EINVAL;
585 if (!p_fwht_params->width || !p_fwht_params->height)
586 return -EINVAL;
587 break;
588
589 case V4L2_CTRL_TYPE_H264_SPS:
590 p_h264_sps = p;
591
592 /* Some syntax elements are only conditionally valid */
593 if (p_h264_sps->pic_order_cnt_type != 0) {
594 p_h264_sps->log2_max_pic_order_cnt_lsb_minus4 = 0;
595 } else if (p_h264_sps->pic_order_cnt_type != 1) {
596 p_h264_sps->num_ref_frames_in_pic_order_cnt_cycle = 0;
597 p_h264_sps->offset_for_non_ref_pic = 0;
598 p_h264_sps->offset_for_top_to_bottom_field = 0;
599 memset(&p_h264_sps->offset_for_ref_frame, 0,
600 sizeof(p_h264_sps->offset_for_ref_frame));
601 }
602
603 if (!V4L2_H264_SPS_HAS_CHROMA_FORMAT(p_h264_sps)) {
604 p_h264_sps->chroma_format_idc = 1;
605 p_h264_sps->bit_depth_luma_minus8 = 0;
606 p_h264_sps->bit_depth_chroma_minus8 = 0;
607
608 p_h264_sps->flags &=
609 ~V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS;
610
611 if (p_h264_sps->chroma_format_idc < 3)
612 p_h264_sps->flags &=
613 ~V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE;
614 }
615
616 if (p_h264_sps->flags & V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY)
617 p_h264_sps->flags &=
618 ~V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD;
619
620 /*
621 * Chroma 4:2:2 format require at least High 4:2:2 profile.
622 *
623 * The H264 specification and well-known parser implementations
624 * use profile-idc values directly, as that is clearer and
625 * less ambiguous. We do the same here.
626 */
627 if (p_h264_sps->profile_idc < 122 &&
628 p_h264_sps->chroma_format_idc > 1)
629 return -EINVAL;
630 /* Chroma 4:4:4 format require at least High 4:2:2 profile */
631 if (p_h264_sps->profile_idc < 244 &&
632 p_h264_sps->chroma_format_idc > 2)
633 return -EINVAL;
634 if (p_h264_sps->chroma_format_idc > 3)
635 return -EINVAL;
636
637 if (p_h264_sps->bit_depth_luma_minus8 > 6)
638 return -EINVAL;
639 if (p_h264_sps->bit_depth_chroma_minus8 > 6)
640 return -EINVAL;
641 if (p_h264_sps->log2_max_frame_num_minus4 > 12)
642 return -EINVAL;
643 if (p_h264_sps->pic_order_cnt_type > 2)
644 return -EINVAL;
645 if (p_h264_sps->log2_max_pic_order_cnt_lsb_minus4 > 12)
646 return -EINVAL;
647 if (p_h264_sps->max_num_ref_frames > V4L2_H264_REF_LIST_LEN)
648 return -EINVAL;
649 break;
650
651 case V4L2_CTRL_TYPE_H264_PPS:
652 p_h264_pps = p;
653
654 if (p_h264_pps->num_slice_groups_minus1 > 7)
655 return -EINVAL;
656 if (p_h264_pps->num_ref_idx_l0_default_active_minus1 >
657 (V4L2_H264_REF_LIST_LEN - 1))
658 return -EINVAL;
659 if (p_h264_pps->num_ref_idx_l1_default_active_minus1 >
660 (V4L2_H264_REF_LIST_LEN - 1))
661 return -EINVAL;
662 if (p_h264_pps->weighted_bipred_idc > 2)
663 return -EINVAL;
664 /*
665 * pic_init_qp_minus26 shall be in the range of
666 * -(26 + QpBdOffset_y) to +25, inclusive,
667 * where QpBdOffset_y is 6 * bit_depth_luma_minus8
668 */
669 if (p_h264_pps->pic_init_qp_minus26 < -62 ||
670 p_h264_pps->pic_init_qp_minus26 > 25)
671 return -EINVAL;
672 if (p_h264_pps->pic_init_qs_minus26 < -26 ||
673 p_h264_pps->pic_init_qs_minus26 > 25)
674 return -EINVAL;
675 if (p_h264_pps->chroma_qp_index_offset < -12 ||
676 p_h264_pps->chroma_qp_index_offset > 12)
677 return -EINVAL;
678 if (p_h264_pps->second_chroma_qp_index_offset < -12 ||
679 p_h264_pps->second_chroma_qp_index_offset > 12)
680 return -EINVAL;
681 break;
682
683 case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
684 break;
685
686 case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
687 p_h264_pred_weights = p;
688
689 if (p_h264_pred_weights->luma_log2_weight_denom > 7)
690 return -EINVAL;
691 if (p_h264_pred_weights->chroma_log2_weight_denom > 7)
692 return -EINVAL;
693 break;
694
695 case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
696 p_h264_slice_params = p;
697
698 if (p_h264_slice_params->slice_type != V4L2_H264_SLICE_TYPE_B)
699 p_h264_slice_params->flags &=
700 ~V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED;
701
702 if (p_h264_slice_params->colour_plane_id > 2)
703 return -EINVAL;
704 if (p_h264_slice_params->cabac_init_idc > 2)
705 return -EINVAL;
706 if (p_h264_slice_params->disable_deblocking_filter_idc > 2)
707 return -EINVAL;
708 if (p_h264_slice_params->slice_alpha_c0_offset_div2 < -6 ||
709 p_h264_slice_params->slice_alpha_c0_offset_div2 > 6)
710 return -EINVAL;
711 if (p_h264_slice_params->slice_beta_offset_div2 < -6 ||
712 p_h264_slice_params->slice_beta_offset_div2 > 6)
713 return -EINVAL;
714
715 if (p_h264_slice_params->slice_type == V4L2_H264_SLICE_TYPE_I ||
716 p_h264_slice_params->slice_type == V4L2_H264_SLICE_TYPE_SI)
717 p_h264_slice_params->num_ref_idx_l0_active_minus1 = 0;
718 if (p_h264_slice_params->slice_type != V4L2_H264_SLICE_TYPE_B)
719 p_h264_slice_params->num_ref_idx_l1_active_minus1 = 0;
720
721 if (p_h264_slice_params->num_ref_idx_l0_active_minus1 >
722 (V4L2_H264_REF_LIST_LEN - 1))
723 return -EINVAL;
724 if (p_h264_slice_params->num_ref_idx_l1_active_minus1 >
725 (V4L2_H264_REF_LIST_LEN - 1))
726 return -EINVAL;
727 zero_reserved(*p_h264_slice_params);
728 break;
729
730 case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
731 p_h264_dec_params = p;
732
733 if (p_h264_dec_params->nal_ref_idc > 3)
734 return -EINVAL;
735 for (i = 0; i < V4L2_H264_NUM_DPB_ENTRIES; i++) {
736 struct v4l2_h264_dpb_entry *dpb_entry =
737 &p_h264_dec_params->dpb[i];
738
739 zero_reserved(*dpb_entry);
740 }
741 zero_reserved(*p_h264_dec_params);
742 break;
743
744 case V4L2_CTRL_TYPE_VP8_FRAME:
745 p_vp8_frame = p;
746
747 switch (p_vp8_frame->num_dct_parts) {
748 case 1:
749 case 2:
750 case 4:
751 case 8:
752 break;
753 default:
754 return -EINVAL;
755 }
756 zero_padding(p_vp8_frame->segment);
757 zero_padding(p_vp8_frame->lf);
758 zero_padding(p_vp8_frame->quant);
759 zero_padding(p_vp8_frame->entropy);
760 zero_padding(p_vp8_frame->coder_state);
761 break;
762
763 case V4L2_CTRL_TYPE_HEVC_SPS:
764 p_hevc_sps = p;
765
766 if (!(p_hevc_sps->flags & V4L2_HEVC_SPS_FLAG_PCM_ENABLED)) {
767 p_hevc_sps->pcm_sample_bit_depth_luma_minus1 = 0;
768 p_hevc_sps->pcm_sample_bit_depth_chroma_minus1 = 0;
769 p_hevc_sps->log2_min_pcm_luma_coding_block_size_minus3 = 0;
770 p_hevc_sps->log2_diff_max_min_pcm_luma_coding_block_size = 0;
771 }
772
773 if (!(p_hevc_sps->flags &
774 V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT))
775 p_hevc_sps->num_long_term_ref_pics_sps = 0;
776 break;
777
778 case V4L2_CTRL_TYPE_HEVC_PPS:
779 p_hevc_pps = p;
780
781 if (!(p_hevc_pps->flags &
782 V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED))
783 p_hevc_pps->diff_cu_qp_delta_depth = 0;
784
785 if (!(p_hevc_pps->flags & V4L2_HEVC_PPS_FLAG_TILES_ENABLED)) {
786 p_hevc_pps->num_tile_columns_minus1 = 0;
787 p_hevc_pps->num_tile_rows_minus1 = 0;
788 memset(&p_hevc_pps->column_width_minus1, 0,
789 sizeof(p_hevc_pps->column_width_minus1));
790 memset(&p_hevc_pps->row_height_minus1, 0,
791 sizeof(p_hevc_pps->row_height_minus1));
792
793 p_hevc_pps->flags &=
794 ~V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED;
795 }
796
797 if (p_hevc_pps->flags &
798 V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER) {
799 p_hevc_pps->pps_beta_offset_div2 = 0;
800 p_hevc_pps->pps_tc_offset_div2 = 0;
801 }
802
803 zero_padding(*p_hevc_pps);
804 break;
805
806 case V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS:
807 p_hevc_decode_params = p;
808
809 if (p_hevc_decode_params->num_active_dpb_entries >
810 V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
811 return -EINVAL;
812
813 for (i = 0; i < p_hevc_decode_params->num_active_dpb_entries;
814 i++) {
815 struct v4l2_hevc_dpb_entry *dpb_entry =
816 &p_hevc_decode_params->dpb[i];
817
818 zero_padding(*dpb_entry);
819 }
820 break;
821
822 case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
823 p_hevc_slice_params = p;
824
825 zero_padding(p_hevc_slice_params->pred_weight_table);
826 zero_padding(*p_hevc_slice_params);
827 break;
828
829 case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
830 break;
831
832 case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
833 p_hdr10_mastering = p;
834
835 for (i = 0; i < 3; ++i) {
836 if (p_hdr10_mastering->display_primaries_x[i] <
837 V4L2_HDR10_MASTERING_PRIMARIES_X_LOW ||
838 p_hdr10_mastering->display_primaries_x[i] >
839 V4L2_HDR10_MASTERING_PRIMARIES_X_HIGH ||
840 p_hdr10_mastering->display_primaries_y[i] <
841 V4L2_HDR10_MASTERING_PRIMARIES_Y_LOW ||
842 p_hdr10_mastering->display_primaries_y[i] >
843 V4L2_HDR10_MASTERING_PRIMARIES_Y_HIGH)
844 return -EINVAL;
845 }
846
847 if (p_hdr10_mastering->white_point_x <
848 V4L2_HDR10_MASTERING_WHITE_POINT_X_LOW ||
849 p_hdr10_mastering->white_point_x >
850 V4L2_HDR10_MASTERING_WHITE_POINT_X_HIGH ||
851 p_hdr10_mastering->white_point_y <
852 V4L2_HDR10_MASTERING_WHITE_POINT_Y_LOW ||
853 p_hdr10_mastering->white_point_y >
854 V4L2_HDR10_MASTERING_WHITE_POINT_Y_HIGH)
855 return -EINVAL;
856
857 if (p_hdr10_mastering->max_display_mastering_luminance <
858 V4L2_HDR10_MASTERING_MAX_LUMA_LOW ||
859 p_hdr10_mastering->max_display_mastering_luminance >
860 V4L2_HDR10_MASTERING_MAX_LUMA_HIGH ||
861 p_hdr10_mastering->min_display_mastering_luminance <
862 V4L2_HDR10_MASTERING_MIN_LUMA_LOW ||
863 p_hdr10_mastering->min_display_mastering_luminance >
864 V4L2_HDR10_MASTERING_MIN_LUMA_HIGH)
865 return -EINVAL;
866
867 /* The following restriction comes from ITU-T Rec. H.265 spec */
868 if (p_hdr10_mastering->max_display_mastering_luminance ==
869 V4L2_HDR10_MASTERING_MAX_LUMA_LOW &&
870 p_hdr10_mastering->min_display_mastering_luminance ==
871 V4L2_HDR10_MASTERING_MIN_LUMA_HIGH)
872 return -EINVAL;
873
874 break;
875
876 case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX:
877 break;
878
879 case V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR:
880 return validate_vp9_compressed_hdr(p);
881
882 case V4L2_CTRL_TYPE_VP9_FRAME:
883 return validate_vp9_frame(p);
884
885 case V4L2_CTRL_TYPE_AREA:
886 area = p;
887 if (!area->width || !area->height)
888 return -EINVAL;
889 break;
890
891 default:
892 return -EINVAL;
893 }
894
895 return 0;
896 }
897
std_validate(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr)898 static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
899 union v4l2_ctrl_ptr ptr)
900 {
901 size_t len;
902 u64 offset;
903 s64 val;
904
905 switch ((u32)ctrl->type) {
906 case V4L2_CTRL_TYPE_INTEGER:
907 return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
908 case V4L2_CTRL_TYPE_INTEGER64:
909 /*
910 * We can't use the ROUND_TO_RANGE define here due to
911 * the u64 divide that needs special care.
912 */
913 val = ptr.p_s64[idx];
914 if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2))
915 val = ctrl->maximum;
916 else
917 val += (s64)(ctrl->step / 2);
918 val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum);
919 offset = val - ctrl->minimum;
920 do_div(offset, ctrl->step);
921 ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step;
922 return 0;
923 case V4L2_CTRL_TYPE_U8:
924 return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl);
925 case V4L2_CTRL_TYPE_U16:
926 return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl);
927 case V4L2_CTRL_TYPE_U32:
928 return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl);
929
930 case V4L2_CTRL_TYPE_BOOLEAN:
931 ptr.p_s32[idx] = !!ptr.p_s32[idx];
932 return 0;
933
934 case V4L2_CTRL_TYPE_MENU:
935 case V4L2_CTRL_TYPE_INTEGER_MENU:
936 if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum)
937 return -ERANGE;
938 if (ptr.p_s32[idx] < BITS_PER_LONG_LONG &&
939 (ctrl->menu_skip_mask & BIT_ULL(ptr.p_s32[idx])))
940 return -EINVAL;
941 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
942 ctrl->qmenu[ptr.p_s32[idx]][0] == '\0')
943 return -EINVAL;
944 return 0;
945
946 case V4L2_CTRL_TYPE_BITMASK:
947 ptr.p_s32[idx] &= ctrl->maximum;
948 return 0;
949
950 case V4L2_CTRL_TYPE_BUTTON:
951 case V4L2_CTRL_TYPE_CTRL_CLASS:
952 ptr.p_s32[idx] = 0;
953 return 0;
954
955 case V4L2_CTRL_TYPE_STRING:
956 idx *= ctrl->elem_size;
957 len = strlen(ptr.p_char + idx);
958 if (len < ctrl->minimum)
959 return -ERANGE;
960 if ((len - (u32)ctrl->minimum) % (u32)ctrl->step)
961 return -ERANGE;
962 return 0;
963
964 default:
965 return std_validate_compound(ctrl, idx, ptr);
966 }
967 }
968
969 static const struct v4l2_ctrl_type_ops std_type_ops = {
970 .equal = std_equal,
971 .init = std_init,
972 .log = std_log,
973 .validate = std_validate,
974 };
975
v4l2_ctrl_notify(struct v4l2_ctrl * ctrl,v4l2_ctrl_notify_fnc notify,void * priv)976 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
977 {
978 if (!ctrl)
979 return;
980 if (!notify) {
981 ctrl->call_notify = 0;
982 return;
983 }
984 if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
985 return;
986 ctrl->handler->notify = notify;
987 ctrl->handler->notify_priv = priv;
988 ctrl->call_notify = 1;
989 }
990 EXPORT_SYMBOL(v4l2_ctrl_notify);
991
992 /* Copy the one value to another. */
ptr_to_ptr(struct v4l2_ctrl * ctrl,union v4l2_ctrl_ptr from,union v4l2_ctrl_ptr to)993 static void ptr_to_ptr(struct v4l2_ctrl *ctrl,
994 union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to)
995 {
996 if (ctrl == NULL)
997 return;
998 memcpy(to.p, from.p_const, ctrl->elems * ctrl->elem_size);
999 }
1000
1001 /* Copy the new value to the current value. */
new_to_cur(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,u32 ch_flags)1002 void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
1003 {
1004 bool changed;
1005
1006 if (ctrl == NULL)
1007 return;
1008
1009 /* has_changed is set by cluster_changed */
1010 changed = ctrl->has_changed;
1011 if (changed)
1012 ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur);
1013
1014 if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
1015 /* Note: CH_FLAGS is only set for auto clusters. */
1016 ctrl->flags &=
1017 ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1018 if (!is_cur_manual(ctrl->cluster[0])) {
1019 ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1020 if (ctrl->cluster[0]->has_volatiles)
1021 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1022 }
1023 fh = NULL;
1024 }
1025 if (changed || ch_flags) {
1026 /* If a control was changed that was not one of the controls
1027 modified by the application, then send the event to all. */
1028 if (!ctrl->is_new)
1029 fh = NULL;
1030 send_event(fh, ctrl,
1031 (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
1032 if (ctrl->call_notify && changed && ctrl->handler->notify)
1033 ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
1034 }
1035 }
1036
1037 /* Copy the current value to the new value */
cur_to_new(struct v4l2_ctrl * ctrl)1038 void cur_to_new(struct v4l2_ctrl *ctrl)
1039 {
1040 if (ctrl == NULL)
1041 return;
1042 ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
1043 }
1044
1045 /* Copy the new value to the request value */
new_to_req(struct v4l2_ctrl_ref * ref)1046 void new_to_req(struct v4l2_ctrl_ref *ref)
1047 {
1048 if (!ref)
1049 return;
1050 ptr_to_ptr(ref->ctrl, ref->ctrl->p_new, ref->p_req);
1051 ref->valid_p_req = true;
1052 }
1053
1054 /* Copy the current value to the request value */
cur_to_req(struct v4l2_ctrl_ref * ref)1055 void cur_to_req(struct v4l2_ctrl_ref *ref)
1056 {
1057 if (!ref)
1058 return;
1059 ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->p_req);
1060 ref->valid_p_req = true;
1061 }
1062
1063 /* Copy the request value to the new value */
req_to_new(struct v4l2_ctrl_ref * ref)1064 void req_to_new(struct v4l2_ctrl_ref *ref)
1065 {
1066 if (!ref)
1067 return;
1068 if (ref->valid_p_req)
1069 ptr_to_ptr(ref->ctrl, ref->p_req, ref->ctrl->p_new);
1070 else
1071 ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->ctrl->p_new);
1072 }
1073
1074 /* Control range checking */
check_range(enum v4l2_ctrl_type type,s64 min,s64 max,u64 step,s64 def)1075 int check_range(enum v4l2_ctrl_type type,
1076 s64 min, s64 max, u64 step, s64 def)
1077 {
1078 switch (type) {
1079 case V4L2_CTRL_TYPE_BOOLEAN:
1080 if (step != 1 || max > 1 || min < 0)
1081 return -ERANGE;
1082 fallthrough;
1083 case V4L2_CTRL_TYPE_U8:
1084 case V4L2_CTRL_TYPE_U16:
1085 case V4L2_CTRL_TYPE_U32:
1086 case V4L2_CTRL_TYPE_INTEGER:
1087 case V4L2_CTRL_TYPE_INTEGER64:
1088 if (step == 0 || min > max || def < min || def > max)
1089 return -ERANGE;
1090 return 0;
1091 case V4L2_CTRL_TYPE_BITMASK:
1092 if (step || min || !max || (def & ~max))
1093 return -ERANGE;
1094 return 0;
1095 case V4L2_CTRL_TYPE_MENU:
1096 case V4L2_CTRL_TYPE_INTEGER_MENU:
1097 if (min > max || def < min || def > max)
1098 return -ERANGE;
1099 /* Note: step == menu_skip_mask for menu controls.
1100 So here we check if the default value is masked out. */
1101 if (step && ((1 << def) & step))
1102 return -EINVAL;
1103 return 0;
1104 case V4L2_CTRL_TYPE_STRING:
1105 if (min > max || min < 0 || step < 1 || def)
1106 return -ERANGE;
1107 return 0;
1108 default:
1109 return 0;
1110 }
1111 }
1112
1113 /* Validate a new control */
validate_new(const struct v4l2_ctrl * ctrl,union v4l2_ctrl_ptr p_new)1114 int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
1115 {
1116 unsigned idx;
1117 int err = 0;
1118
1119 for (idx = 0; !err && idx < ctrl->elems; idx++)
1120 err = ctrl->type_ops->validate(ctrl, idx, p_new);
1121 return err;
1122 }
1123
1124 /* Set the handler's error code if it wasn't set earlier already */
handler_set_err(struct v4l2_ctrl_handler * hdl,int err)1125 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1126 {
1127 if (hdl->error == 0)
1128 hdl->error = err;
1129 return err;
1130 }
1131
1132 /* Initialize the handler */
v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler * hdl,unsigned nr_of_controls_hint,struct lock_class_key * key,const char * name)1133 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
1134 unsigned nr_of_controls_hint,
1135 struct lock_class_key *key, const char *name)
1136 {
1137 mutex_init(&hdl->_lock);
1138 hdl->lock = &hdl->_lock;
1139 lockdep_set_class_and_name(hdl->lock, key, name);
1140 INIT_LIST_HEAD(&hdl->ctrls);
1141 INIT_LIST_HEAD(&hdl->ctrl_refs);
1142 hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1143 hdl->buckets = kvcalloc(hdl->nr_of_buckets, sizeof(hdl->buckets[0]),
1144 GFP_KERNEL);
1145 hdl->error = hdl->buckets ? 0 : -ENOMEM;
1146 v4l2_ctrl_handler_init_request(hdl);
1147 return hdl->error;
1148 }
1149 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
1150
1151 /* Free all controls and control refs */
v4l2_ctrl_handler_free(struct v4l2_ctrl_handler * hdl)1152 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1153 {
1154 struct v4l2_ctrl_ref *ref, *next_ref;
1155 struct v4l2_ctrl *ctrl, *next_ctrl;
1156 struct v4l2_subscribed_event *sev, *next_sev;
1157
1158 if (hdl == NULL || hdl->buckets == NULL)
1159 return;
1160
1161 v4l2_ctrl_handler_free_request(hdl);
1162
1163 mutex_lock(hdl->lock);
1164 /* Free all nodes */
1165 list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1166 list_del(&ref->node);
1167 kfree(ref);
1168 }
1169 /* Free all controls owned by the handler */
1170 list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1171 list_del(&ctrl->node);
1172 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1173 list_del(&sev->node);
1174 kvfree(ctrl);
1175 }
1176 kvfree(hdl->buckets);
1177 hdl->buckets = NULL;
1178 hdl->cached = NULL;
1179 hdl->error = 0;
1180 mutex_unlock(hdl->lock);
1181 mutex_destroy(&hdl->_lock);
1182 }
1183 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1184
1185 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1186 be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1187 with applications that do not use the NEXT_CTRL flag.
1188
1189 We just find the n-th private user control. It's O(N), but that should not
1190 be an issue in this particular case. */
find_private_ref(struct v4l2_ctrl_handler * hdl,u32 id)1191 static struct v4l2_ctrl_ref *find_private_ref(
1192 struct v4l2_ctrl_handler *hdl, u32 id)
1193 {
1194 struct v4l2_ctrl_ref *ref;
1195
1196 id -= V4L2_CID_PRIVATE_BASE;
1197 list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1198 /* Search for private user controls that are compatible with
1199 VIDIOC_G/S_CTRL. */
1200 if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1201 V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1202 if (!ref->ctrl->is_int)
1203 continue;
1204 if (id == 0)
1205 return ref;
1206 id--;
1207 }
1208 }
1209 return NULL;
1210 }
1211
1212 /* Find a control with the given ID. */
find_ref(struct v4l2_ctrl_handler * hdl,u32 id)1213 struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1214 {
1215 struct v4l2_ctrl_ref *ref;
1216 int bucket;
1217
1218 id &= V4L2_CTRL_ID_MASK;
1219
1220 /* Old-style private controls need special handling */
1221 if (id >= V4L2_CID_PRIVATE_BASE)
1222 return find_private_ref(hdl, id);
1223 bucket = id % hdl->nr_of_buckets;
1224
1225 /* Simple optimization: cache the last control found */
1226 if (hdl->cached && hdl->cached->ctrl->id == id)
1227 return hdl->cached;
1228
1229 /* Not in cache, search the hash */
1230 ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1231 while (ref && ref->ctrl->id != id)
1232 ref = ref->next;
1233
1234 if (ref)
1235 hdl->cached = ref; /* cache it! */
1236 return ref;
1237 }
1238
1239 /* Find a control with the given ID. Take the handler's lock first. */
find_ref_lock(struct v4l2_ctrl_handler * hdl,u32 id)1240 struct v4l2_ctrl_ref *find_ref_lock(struct v4l2_ctrl_handler *hdl, u32 id)
1241 {
1242 struct v4l2_ctrl_ref *ref = NULL;
1243
1244 if (hdl) {
1245 mutex_lock(hdl->lock);
1246 ref = find_ref(hdl, id);
1247 mutex_unlock(hdl->lock);
1248 }
1249 return ref;
1250 }
1251
1252 /* Find a control with the given ID. */
v4l2_ctrl_find(struct v4l2_ctrl_handler * hdl,u32 id)1253 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1254 {
1255 struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1256
1257 return ref ? ref->ctrl : NULL;
1258 }
1259 EXPORT_SYMBOL(v4l2_ctrl_find);
1260
1261 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
handler_new_ref(struct v4l2_ctrl_handler * hdl,struct v4l2_ctrl * ctrl,struct v4l2_ctrl_ref ** ctrl_ref,bool from_other_dev,bool allocate_req)1262 int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1263 struct v4l2_ctrl *ctrl,
1264 struct v4l2_ctrl_ref **ctrl_ref,
1265 bool from_other_dev, bool allocate_req)
1266 {
1267 struct v4l2_ctrl_ref *ref;
1268 struct v4l2_ctrl_ref *new_ref;
1269 u32 id = ctrl->id;
1270 u32 class_ctrl = V4L2_CTRL_ID2WHICH(id) | 1;
1271 int bucket = id % hdl->nr_of_buckets; /* which bucket to use */
1272 unsigned int size_extra_req = 0;
1273
1274 if (ctrl_ref)
1275 *ctrl_ref = NULL;
1276
1277 /*
1278 * Automatically add the control class if it is not yet present and
1279 * the new control is not a compound control.
1280 */
1281 if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES &&
1282 id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1283 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1284 return hdl->error;
1285
1286 if (hdl->error)
1287 return hdl->error;
1288
1289 if (allocate_req)
1290 size_extra_req = ctrl->elems * ctrl->elem_size;
1291 new_ref = kzalloc(sizeof(*new_ref) + size_extra_req, GFP_KERNEL);
1292 if (!new_ref)
1293 return handler_set_err(hdl, -ENOMEM);
1294 new_ref->ctrl = ctrl;
1295 new_ref->from_other_dev = from_other_dev;
1296 if (size_extra_req)
1297 new_ref->p_req.p = &new_ref[1];
1298
1299 INIT_LIST_HEAD(&new_ref->node);
1300
1301 mutex_lock(hdl->lock);
1302
1303 /* Add immediately at the end of the list if the list is empty, or if
1304 the last element in the list has a lower ID.
1305 This ensures that when elements are added in ascending order the
1306 insertion is an O(1) operation. */
1307 if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1308 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1309 goto insert_in_hash;
1310 }
1311
1312 /* Find insert position in sorted list */
1313 list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1314 if (ref->ctrl->id < id)
1315 continue;
1316 /* Don't add duplicates */
1317 if (ref->ctrl->id == id) {
1318 kfree(new_ref);
1319 goto unlock;
1320 }
1321 list_add(&new_ref->node, ref->node.prev);
1322 break;
1323 }
1324
1325 insert_in_hash:
1326 /* Insert the control node in the hash */
1327 new_ref->next = hdl->buckets[bucket];
1328 hdl->buckets[bucket] = new_ref;
1329 if (ctrl_ref)
1330 *ctrl_ref = new_ref;
1331 if (ctrl->handler == hdl) {
1332 /* By default each control starts in a cluster of its own.
1333 * new_ref->ctrl is basically a cluster array with one
1334 * element, so that's perfect to use as the cluster pointer.
1335 * But only do this for the handler that owns the control.
1336 */
1337 ctrl->cluster = &new_ref->ctrl;
1338 ctrl->ncontrols = 1;
1339 }
1340
1341 unlock:
1342 mutex_unlock(hdl->lock);
1343 return 0;
1344 }
1345
1346 /* Add a new control */
v4l2_ctrl_new(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,const struct v4l2_ctrl_type_ops * type_ops,u32 id,const char * name,enum v4l2_ctrl_type type,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,void * priv)1347 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1348 const struct v4l2_ctrl_ops *ops,
1349 const struct v4l2_ctrl_type_ops *type_ops,
1350 u32 id, const char *name, enum v4l2_ctrl_type type,
1351 s64 min, s64 max, u64 step, s64 def,
1352 const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
1353 u32 flags, const char * const *qmenu,
1354 const s64 *qmenu_int, const union v4l2_ctrl_ptr p_def,
1355 void *priv)
1356 {
1357 struct v4l2_ctrl *ctrl;
1358 unsigned sz_extra;
1359 unsigned nr_of_dims = 0;
1360 unsigned elems = 1;
1361 bool is_array;
1362 unsigned tot_ctrl_size;
1363 unsigned idx;
1364 void *data;
1365 int err;
1366
1367 if (hdl->error)
1368 return NULL;
1369
1370 while (dims && dims[nr_of_dims]) {
1371 elems *= dims[nr_of_dims];
1372 nr_of_dims++;
1373 if (nr_of_dims == V4L2_CTRL_MAX_DIMS)
1374 break;
1375 }
1376 is_array = nr_of_dims > 0;
1377
1378 /* Prefill elem_size for all types handled by std_type_ops */
1379 switch ((u32)type) {
1380 case V4L2_CTRL_TYPE_INTEGER64:
1381 elem_size = sizeof(s64);
1382 break;
1383 case V4L2_CTRL_TYPE_STRING:
1384 elem_size = max + 1;
1385 break;
1386 case V4L2_CTRL_TYPE_U8:
1387 elem_size = sizeof(u8);
1388 break;
1389 case V4L2_CTRL_TYPE_U16:
1390 elem_size = sizeof(u16);
1391 break;
1392 case V4L2_CTRL_TYPE_U32:
1393 elem_size = sizeof(u32);
1394 break;
1395 case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
1396 elem_size = sizeof(struct v4l2_ctrl_mpeg2_sequence);
1397 break;
1398 case V4L2_CTRL_TYPE_MPEG2_PICTURE:
1399 elem_size = sizeof(struct v4l2_ctrl_mpeg2_picture);
1400 break;
1401 case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
1402 elem_size = sizeof(struct v4l2_ctrl_mpeg2_quantisation);
1403 break;
1404 case V4L2_CTRL_TYPE_FWHT_PARAMS:
1405 elem_size = sizeof(struct v4l2_ctrl_fwht_params);
1406 break;
1407 case V4L2_CTRL_TYPE_H264_SPS:
1408 elem_size = sizeof(struct v4l2_ctrl_h264_sps);
1409 break;
1410 case V4L2_CTRL_TYPE_H264_PPS:
1411 elem_size = sizeof(struct v4l2_ctrl_h264_pps);
1412 break;
1413 case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
1414 elem_size = sizeof(struct v4l2_ctrl_h264_scaling_matrix);
1415 break;
1416 case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
1417 elem_size = sizeof(struct v4l2_ctrl_h264_slice_params);
1418 break;
1419 case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
1420 elem_size = sizeof(struct v4l2_ctrl_h264_decode_params);
1421 break;
1422 case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
1423 elem_size = sizeof(struct v4l2_ctrl_h264_pred_weights);
1424 break;
1425 case V4L2_CTRL_TYPE_VP8_FRAME:
1426 elem_size = sizeof(struct v4l2_ctrl_vp8_frame);
1427 break;
1428 case V4L2_CTRL_TYPE_HEVC_SPS:
1429 elem_size = sizeof(struct v4l2_ctrl_hevc_sps);
1430 break;
1431 case V4L2_CTRL_TYPE_HEVC_PPS:
1432 elem_size = sizeof(struct v4l2_ctrl_hevc_pps);
1433 break;
1434 case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
1435 elem_size = sizeof(struct v4l2_ctrl_hevc_slice_params);
1436 break;
1437 case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX:
1438 elem_size = sizeof(struct v4l2_ctrl_hevc_scaling_matrix);
1439 break;
1440 case V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS:
1441 elem_size = sizeof(struct v4l2_ctrl_hevc_decode_params);
1442 break;
1443 case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
1444 elem_size = sizeof(struct v4l2_ctrl_hdr10_cll_info);
1445 break;
1446 case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
1447 elem_size = sizeof(struct v4l2_ctrl_hdr10_mastering_display);
1448 break;
1449 case V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR:
1450 elem_size = sizeof(struct v4l2_ctrl_vp9_compressed_hdr);
1451 break;
1452 case V4L2_CTRL_TYPE_VP9_FRAME:
1453 elem_size = sizeof(struct v4l2_ctrl_vp9_frame);
1454 break;
1455 case V4L2_CTRL_TYPE_AREA:
1456 elem_size = sizeof(struct v4l2_area);
1457 break;
1458 default:
1459 if (type < V4L2_CTRL_COMPOUND_TYPES)
1460 elem_size = sizeof(s32);
1461 break;
1462 }
1463 tot_ctrl_size = elem_size * elems;
1464
1465 /* Sanity checks */
1466 if (id == 0 || name == NULL || !elem_size ||
1467 id >= V4L2_CID_PRIVATE_BASE ||
1468 (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1469 (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
1470 handler_set_err(hdl, -ERANGE);
1471 return NULL;
1472 }
1473 err = check_range(type, min, max, step, def);
1474 if (err) {
1475 handler_set_err(hdl, err);
1476 return NULL;
1477 }
1478 if (is_array &&
1479 (type == V4L2_CTRL_TYPE_BUTTON ||
1480 type == V4L2_CTRL_TYPE_CTRL_CLASS)) {
1481 handler_set_err(hdl, -EINVAL);
1482 return NULL;
1483 }
1484
1485 sz_extra = 0;
1486 if (type == V4L2_CTRL_TYPE_BUTTON)
1487 flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1488 V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1489 else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1490 flags |= V4L2_CTRL_FLAG_READ_ONLY;
1491 else if (type == V4L2_CTRL_TYPE_INTEGER64 ||
1492 type == V4L2_CTRL_TYPE_STRING ||
1493 type >= V4L2_CTRL_COMPOUND_TYPES ||
1494 is_array)
1495 sz_extra += 2 * tot_ctrl_size;
1496
1497 if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const)
1498 sz_extra += elem_size;
1499
1500 ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
1501 if (ctrl == NULL) {
1502 handler_set_err(hdl, -ENOMEM);
1503 return NULL;
1504 }
1505
1506 INIT_LIST_HEAD(&ctrl->node);
1507 INIT_LIST_HEAD(&ctrl->ev_subs);
1508 ctrl->handler = hdl;
1509 ctrl->ops = ops;
1510 ctrl->type_ops = type_ops ? type_ops : &std_type_ops;
1511 ctrl->id = id;
1512 ctrl->name = name;
1513 ctrl->type = type;
1514 ctrl->flags = flags;
1515 ctrl->minimum = min;
1516 ctrl->maximum = max;
1517 ctrl->step = step;
1518 ctrl->default_value = def;
1519 ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING;
1520 ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string;
1521 ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64;
1522 ctrl->is_array = is_array;
1523 ctrl->elems = elems;
1524 ctrl->nr_of_dims = nr_of_dims;
1525 if (nr_of_dims)
1526 memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0]));
1527 ctrl->elem_size = elem_size;
1528 if (type == V4L2_CTRL_TYPE_MENU)
1529 ctrl->qmenu = qmenu;
1530 else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1531 ctrl->qmenu_int = qmenu_int;
1532 ctrl->priv = priv;
1533 ctrl->cur.val = ctrl->val = def;
1534 data = &ctrl[1];
1535
1536 if (!ctrl->is_int) {
1537 ctrl->p_new.p = data;
1538 ctrl->p_cur.p = data + tot_ctrl_size;
1539 } else {
1540 ctrl->p_new.p = &ctrl->val;
1541 ctrl->p_cur.p = &ctrl->cur.val;
1542 }
1543
1544 if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const) {
1545 ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size;
1546 memcpy(ctrl->p_def.p, p_def.p_const, elem_size);
1547 }
1548
1549 for (idx = 0; idx < elems; idx++) {
1550 ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
1551 ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
1552 }
1553
1554 if (handler_new_ref(hdl, ctrl, NULL, false, false)) {
1555 kvfree(ctrl);
1556 return NULL;
1557 }
1558 mutex_lock(hdl->lock);
1559 list_add_tail(&ctrl->node, &hdl->ctrls);
1560 mutex_unlock(hdl->lock);
1561 return ctrl;
1562 }
1563
v4l2_ctrl_new_custom(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_config * cfg,void * priv)1564 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
1565 const struct v4l2_ctrl_config *cfg, void *priv)
1566 {
1567 bool is_menu;
1568 struct v4l2_ctrl *ctrl;
1569 const char *name = cfg->name;
1570 const char * const *qmenu = cfg->qmenu;
1571 const s64 *qmenu_int = cfg->qmenu_int;
1572 enum v4l2_ctrl_type type = cfg->type;
1573 u32 flags = cfg->flags;
1574 s64 min = cfg->min;
1575 s64 max = cfg->max;
1576 u64 step = cfg->step;
1577 s64 def = cfg->def;
1578
1579 if (name == NULL)
1580 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
1581 &def, &flags);
1582
1583 is_menu = (type == V4L2_CTRL_TYPE_MENU ||
1584 type == V4L2_CTRL_TYPE_INTEGER_MENU);
1585 if (is_menu)
1586 WARN_ON(step);
1587 else
1588 WARN_ON(cfg->menu_skip_mask);
1589 if (type == V4L2_CTRL_TYPE_MENU && !qmenu) {
1590 qmenu = v4l2_ctrl_get_menu(cfg->id);
1591 } else if (type == V4L2_CTRL_TYPE_INTEGER_MENU && !qmenu_int) {
1592 handler_set_err(hdl, -EINVAL);
1593 return NULL;
1594 }
1595
1596 ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name,
1597 type, min, max,
1598 is_menu ? cfg->menu_skip_mask : step, def,
1599 cfg->dims, cfg->elem_size,
1600 flags, qmenu, qmenu_int, cfg->p_def, priv);
1601 if (ctrl)
1602 ctrl->is_private = cfg->is_private;
1603 return ctrl;
1604 }
1605 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
1606
1607 /* Helper function for standard non-menu controls */
v4l2_ctrl_new_std(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,s64 min,s64 max,u64 step,s64 def)1608 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
1609 const struct v4l2_ctrl_ops *ops,
1610 u32 id, s64 min, s64 max, u64 step, s64 def)
1611 {
1612 const char *name;
1613 enum v4l2_ctrl_type type;
1614 u32 flags;
1615
1616 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1617 if (type == V4L2_CTRL_TYPE_MENU ||
1618 type == V4L2_CTRL_TYPE_INTEGER_MENU ||
1619 type >= V4L2_CTRL_COMPOUND_TYPES) {
1620 handler_set_err(hdl, -EINVAL);
1621 return NULL;
1622 }
1623 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1624 min, max, step, def, NULL, 0,
1625 flags, NULL, NULL, ptr_null, NULL);
1626 }
1627 EXPORT_SYMBOL(v4l2_ctrl_new_std);
1628
1629 /* Helper function for standard menu controls */
v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,u8 _max,u64 mask,u8 _def)1630 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
1631 const struct v4l2_ctrl_ops *ops,
1632 u32 id, u8 _max, u64 mask, u8 _def)
1633 {
1634 const char * const *qmenu = NULL;
1635 const s64 *qmenu_int = NULL;
1636 unsigned int qmenu_int_len = 0;
1637 const char *name;
1638 enum v4l2_ctrl_type type;
1639 s64 min;
1640 s64 max = _max;
1641 s64 def = _def;
1642 u64 step;
1643 u32 flags;
1644
1645 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1646
1647 if (type == V4L2_CTRL_TYPE_MENU)
1648 qmenu = v4l2_ctrl_get_menu(id);
1649 else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1650 qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
1651
1652 if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
1653 handler_set_err(hdl, -EINVAL);
1654 return NULL;
1655 }
1656 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1657 0, max, mask, def, NULL, 0,
1658 flags, qmenu, qmenu_int, ptr_null, NULL);
1659 }
1660 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
1661
1662 /* Helper function for standard menu controls with driver defined menu */
v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,u8 _max,u64 mask,u8 _def,const char * const * qmenu)1663 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
1664 const struct v4l2_ctrl_ops *ops, u32 id, u8 _max,
1665 u64 mask, u8 _def, const char * const *qmenu)
1666 {
1667 enum v4l2_ctrl_type type;
1668 const char *name;
1669 u32 flags;
1670 u64 step;
1671 s64 min;
1672 s64 max = _max;
1673 s64 def = _def;
1674
1675 /* v4l2_ctrl_new_std_menu_items() should only be called for
1676 * standard controls without a standard menu.
1677 */
1678 if (v4l2_ctrl_get_menu(id)) {
1679 handler_set_err(hdl, -EINVAL);
1680 return NULL;
1681 }
1682
1683 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1684 if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
1685 handler_set_err(hdl, -EINVAL);
1686 return NULL;
1687 }
1688 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1689 0, max, mask, def, NULL, 0,
1690 flags, qmenu, NULL, ptr_null, NULL);
1691
1692 }
1693 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
1694
1695 /* Helper function for standard compound controls */
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)1696 struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl,
1697 const struct v4l2_ctrl_ops *ops, u32 id,
1698 const union v4l2_ctrl_ptr p_def)
1699 {
1700 const char *name;
1701 enum v4l2_ctrl_type type;
1702 u32 flags;
1703 s64 min, max, step, def;
1704
1705 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1706 if (type < V4L2_CTRL_COMPOUND_TYPES) {
1707 handler_set_err(hdl, -EINVAL);
1708 return NULL;
1709 }
1710 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1711 min, max, step, def, NULL, 0,
1712 flags, NULL, NULL, p_def, NULL);
1713 }
1714 EXPORT_SYMBOL(v4l2_ctrl_new_std_compound);
1715
1716 /* Helper function for standard integer menu controls */
v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,u8 _max,u8 _def,const s64 * qmenu_int)1717 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
1718 const struct v4l2_ctrl_ops *ops,
1719 u32 id, u8 _max, u8 _def, const s64 *qmenu_int)
1720 {
1721 const char *name;
1722 enum v4l2_ctrl_type type;
1723 s64 min;
1724 u64 step;
1725 s64 max = _max;
1726 s64 def = _def;
1727 u32 flags;
1728
1729 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1730 if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
1731 handler_set_err(hdl, -EINVAL);
1732 return NULL;
1733 }
1734 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1735 0, max, 0, def, NULL, 0,
1736 flags, NULL, qmenu_int, ptr_null, NULL);
1737 }
1738 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
1739
1740 /* Add the controls from another handler to our own. */
v4l2_ctrl_add_handler(struct v4l2_ctrl_handler * hdl,struct v4l2_ctrl_handler * add,bool (* filter)(const struct v4l2_ctrl * ctrl),bool from_other_dev)1741 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
1742 struct v4l2_ctrl_handler *add,
1743 bool (*filter)(const struct v4l2_ctrl *ctrl),
1744 bool from_other_dev)
1745 {
1746 struct v4l2_ctrl_ref *ref;
1747 int ret = 0;
1748
1749 /* Do nothing if either handler is NULL or if they are the same */
1750 if (!hdl || !add || hdl == add)
1751 return 0;
1752 if (hdl->error)
1753 return hdl->error;
1754 mutex_lock(add->lock);
1755 list_for_each_entry(ref, &add->ctrl_refs, node) {
1756 struct v4l2_ctrl *ctrl = ref->ctrl;
1757
1758 /* Skip handler-private controls. */
1759 if (ctrl->is_private)
1760 continue;
1761 /* And control classes */
1762 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1763 continue;
1764 /* Filter any unwanted controls */
1765 if (filter && !filter(ctrl))
1766 continue;
1767 ret = handler_new_ref(hdl, ctrl, NULL, from_other_dev, false);
1768 if (ret)
1769 break;
1770 }
1771 mutex_unlock(add->lock);
1772 return ret;
1773 }
1774 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
1775
v4l2_ctrl_radio_filter(const struct v4l2_ctrl * ctrl)1776 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
1777 {
1778 if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
1779 return true;
1780 if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
1781 return true;
1782 switch (ctrl->id) {
1783 case V4L2_CID_AUDIO_MUTE:
1784 case V4L2_CID_AUDIO_VOLUME:
1785 case V4L2_CID_AUDIO_BALANCE:
1786 case V4L2_CID_AUDIO_BASS:
1787 case V4L2_CID_AUDIO_TREBLE:
1788 case V4L2_CID_AUDIO_LOUDNESS:
1789 return true;
1790 default:
1791 break;
1792 }
1793 return false;
1794 }
1795 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
1796
1797 /* Cluster controls */
v4l2_ctrl_cluster(unsigned ncontrols,struct v4l2_ctrl ** controls)1798 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
1799 {
1800 bool has_volatiles = false;
1801 int i;
1802
1803 /* The first control is the master control and it must not be NULL */
1804 if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
1805 return;
1806
1807 for (i = 0; i < ncontrols; i++) {
1808 if (controls[i]) {
1809 controls[i]->cluster = controls;
1810 controls[i]->ncontrols = ncontrols;
1811 if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
1812 has_volatiles = true;
1813 }
1814 }
1815 controls[0]->has_volatiles = has_volatiles;
1816 }
1817 EXPORT_SYMBOL(v4l2_ctrl_cluster);
1818
v4l2_ctrl_auto_cluster(unsigned ncontrols,struct v4l2_ctrl ** controls,u8 manual_val,bool set_volatile)1819 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
1820 u8 manual_val, bool set_volatile)
1821 {
1822 struct v4l2_ctrl *master = controls[0];
1823 u32 flag = 0;
1824 int i;
1825
1826 v4l2_ctrl_cluster(ncontrols, controls);
1827 WARN_ON(ncontrols <= 1);
1828 WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
1829 WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
1830 master->is_auto = true;
1831 master->has_volatiles = set_volatile;
1832 master->manual_mode_value = manual_val;
1833 master->flags |= V4L2_CTRL_FLAG_UPDATE;
1834
1835 if (!is_cur_manual(master))
1836 flag = V4L2_CTRL_FLAG_INACTIVE |
1837 (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
1838
1839 for (i = 1; i < ncontrols; i++)
1840 if (controls[i])
1841 controls[i]->flags |= flag;
1842 }
1843 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
1844
1845 /*
1846 * Obtain the current volatile values of an autocluster and mark them
1847 * as new.
1848 */
update_from_auto_cluster(struct v4l2_ctrl * master)1849 void update_from_auto_cluster(struct v4l2_ctrl *master)
1850 {
1851 int i;
1852
1853 for (i = 1; i < master->ncontrols; i++)
1854 cur_to_new(master->cluster[i]);
1855 if (!call_op(master, g_volatile_ctrl))
1856 for (i = 1; i < master->ncontrols; i++)
1857 if (master->cluster[i])
1858 master->cluster[i]->is_new = 1;
1859 }
1860
1861 /*
1862 * Return non-zero if one or more of the controls in the cluster has a new
1863 * value that differs from the current value.
1864 */
cluster_changed(struct v4l2_ctrl * master)1865 static int cluster_changed(struct v4l2_ctrl *master)
1866 {
1867 bool changed = false;
1868 unsigned int idx;
1869 int i;
1870
1871 for (i = 0; i < master->ncontrols; i++) {
1872 struct v4l2_ctrl *ctrl = master->cluster[i];
1873 bool ctrl_changed = false;
1874
1875 if (!ctrl)
1876 continue;
1877
1878 if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE) {
1879 changed = true;
1880 ctrl_changed = true;
1881 }
1882
1883 /*
1884 * Set has_changed to false to avoid generating
1885 * the event V4L2_EVENT_CTRL_CH_VALUE
1886 */
1887 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
1888 ctrl->has_changed = false;
1889 continue;
1890 }
1891
1892 for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++)
1893 ctrl_changed = !ctrl->type_ops->equal(ctrl, idx,
1894 ctrl->p_cur, ctrl->p_new);
1895 ctrl->has_changed = ctrl_changed;
1896 changed |= ctrl->has_changed;
1897 }
1898 return changed;
1899 }
1900
1901 /*
1902 * Core function that calls try/s_ctrl and ensures that the new value is
1903 * copied to the current value on a set.
1904 * Must be called with ctrl->handler->lock held.
1905 */
try_or_set_cluster(struct v4l2_fh * fh,struct v4l2_ctrl * master,bool set,u32 ch_flags)1906 int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
1907 bool set, u32 ch_flags)
1908 {
1909 bool update_flag;
1910 int ret;
1911 int i;
1912
1913 /*
1914 * Go through the cluster and either validate the new value or
1915 * (if no new value was set), copy the current value to the new
1916 * value, ensuring a consistent view for the control ops when
1917 * called.
1918 */
1919 for (i = 0; i < master->ncontrols; i++) {
1920 struct v4l2_ctrl *ctrl = master->cluster[i];
1921
1922 if (!ctrl)
1923 continue;
1924
1925 if (!ctrl->is_new) {
1926 cur_to_new(ctrl);
1927 continue;
1928 }
1929 /*
1930 * Check again: it may have changed since the
1931 * previous check in try_or_set_ext_ctrls().
1932 */
1933 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
1934 return -EBUSY;
1935 }
1936
1937 ret = call_op(master, try_ctrl);
1938
1939 /* Don't set if there is no change */
1940 if (ret || !set || !cluster_changed(master))
1941 return ret;
1942 ret = call_op(master, s_ctrl);
1943 if (ret)
1944 return ret;
1945
1946 /* If OK, then make the new values permanent. */
1947 update_flag = is_cur_manual(master) != is_new_manual(master);
1948
1949 for (i = 0; i < master->ncontrols; i++) {
1950 /*
1951 * If we switch from auto to manual mode, and this cluster
1952 * contains volatile controls, then all non-master controls
1953 * have to be marked as changed. The 'new' value contains
1954 * the volatile value (obtained by update_from_auto_cluster),
1955 * which now has to become the current value.
1956 */
1957 if (i && update_flag && is_new_manual(master) &&
1958 master->has_volatiles && master->cluster[i])
1959 master->cluster[i]->has_changed = true;
1960
1961 new_to_cur(fh, master->cluster[i], ch_flags |
1962 ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
1963 }
1964 return 0;
1965 }
1966
1967 /* Activate/deactivate a control. */
v4l2_ctrl_activate(struct v4l2_ctrl * ctrl,bool active)1968 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
1969 {
1970 /* invert since the actual flag is called 'inactive' */
1971 bool inactive = !active;
1972 bool old;
1973
1974 if (ctrl == NULL)
1975 return;
1976
1977 if (inactive)
1978 /* set V4L2_CTRL_FLAG_INACTIVE */
1979 old = test_and_set_bit(4, &ctrl->flags);
1980 else
1981 /* clear V4L2_CTRL_FLAG_INACTIVE */
1982 old = test_and_clear_bit(4, &ctrl->flags);
1983 if (old != inactive)
1984 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1985 }
1986 EXPORT_SYMBOL(v4l2_ctrl_activate);
1987
__v4l2_ctrl_grab(struct v4l2_ctrl * ctrl,bool grabbed)1988 void __v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
1989 {
1990 bool old;
1991
1992 if (ctrl == NULL)
1993 return;
1994
1995 lockdep_assert_held(ctrl->handler->lock);
1996
1997 if (grabbed)
1998 /* set V4L2_CTRL_FLAG_GRABBED */
1999 old = test_and_set_bit(1, &ctrl->flags);
2000 else
2001 /* clear V4L2_CTRL_FLAG_GRABBED */
2002 old = test_and_clear_bit(1, &ctrl->flags);
2003 if (old != grabbed)
2004 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2005 }
2006 EXPORT_SYMBOL(__v4l2_ctrl_grab);
2007
2008 /* Call s_ctrl for all controls owned by the handler */
__v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler * hdl)2009 int __v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2010 {
2011 struct v4l2_ctrl *ctrl;
2012 int ret = 0;
2013
2014 if (hdl == NULL)
2015 return 0;
2016
2017 lockdep_assert_held(hdl->lock);
2018
2019 list_for_each_entry(ctrl, &hdl->ctrls, node)
2020 ctrl->done = false;
2021
2022 list_for_each_entry(ctrl, &hdl->ctrls, node) {
2023 struct v4l2_ctrl *master = ctrl->cluster[0];
2024 int i;
2025
2026 /* Skip if this control was already handled by a cluster. */
2027 /* Skip button controls and read-only controls. */
2028 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2029 (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2030 continue;
2031
2032 for (i = 0; i < master->ncontrols; i++) {
2033 if (master->cluster[i]) {
2034 cur_to_new(master->cluster[i]);
2035 master->cluster[i]->is_new = 1;
2036 master->cluster[i]->done = true;
2037 }
2038 }
2039 ret = call_op(master, s_ctrl);
2040 if (ret)
2041 break;
2042 }
2043
2044 return ret;
2045 }
2046 EXPORT_SYMBOL_GPL(__v4l2_ctrl_handler_setup);
2047
v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler * hdl)2048 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2049 {
2050 int ret;
2051
2052 if (hdl == NULL)
2053 return 0;
2054
2055 mutex_lock(hdl->lock);
2056 ret = __v4l2_ctrl_handler_setup(hdl);
2057 mutex_unlock(hdl->lock);
2058
2059 return ret;
2060 }
2061 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2062
2063 /* Log the control name and value */
log_ctrl(const struct v4l2_ctrl * ctrl,const char * prefix,const char * colon)2064 static void log_ctrl(const struct v4l2_ctrl *ctrl,
2065 const char *prefix, const char *colon)
2066 {
2067 if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
2068 return;
2069 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2070 return;
2071
2072 pr_info("%s%s%s: ", prefix, colon, ctrl->name);
2073
2074 ctrl->type_ops->log(ctrl);
2075
2076 if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
2077 V4L2_CTRL_FLAG_GRABBED |
2078 V4L2_CTRL_FLAG_VOLATILE)) {
2079 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
2080 pr_cont(" inactive");
2081 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
2082 pr_cont(" grabbed");
2083 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
2084 pr_cont(" volatile");
2085 }
2086 pr_cont("\n");
2087 }
2088
2089 /* Log all controls owned by the handler */
v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler * hdl,const char * prefix)2090 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
2091 const char *prefix)
2092 {
2093 struct v4l2_ctrl *ctrl;
2094 const char *colon = "";
2095 int len;
2096
2097 if (!hdl)
2098 return;
2099 if (!prefix)
2100 prefix = "";
2101 len = strlen(prefix);
2102 if (len && prefix[len - 1] != ' ')
2103 colon = ": ";
2104 mutex_lock(hdl->lock);
2105 list_for_each_entry(ctrl, &hdl->ctrls, node)
2106 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2107 log_ctrl(ctrl, prefix, colon);
2108 mutex_unlock(hdl->lock);
2109 }
2110 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2111
v4l2_ctrl_new_fwnode_properties(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ctrl_ops,const struct v4l2_fwnode_device_properties * p)2112 int v4l2_ctrl_new_fwnode_properties(struct v4l2_ctrl_handler *hdl,
2113 const struct v4l2_ctrl_ops *ctrl_ops,
2114 const struct v4l2_fwnode_device_properties *p)
2115 {
2116 if (p->orientation != V4L2_FWNODE_PROPERTY_UNSET) {
2117 u32 orientation_ctrl;
2118
2119 switch (p->orientation) {
2120 case V4L2_FWNODE_ORIENTATION_FRONT:
2121 orientation_ctrl = V4L2_CAMERA_ORIENTATION_FRONT;
2122 break;
2123 case V4L2_FWNODE_ORIENTATION_BACK:
2124 orientation_ctrl = V4L2_CAMERA_ORIENTATION_BACK;
2125 break;
2126 case V4L2_FWNODE_ORIENTATION_EXTERNAL:
2127 orientation_ctrl = V4L2_CAMERA_ORIENTATION_EXTERNAL;
2128 break;
2129 default:
2130 return -EINVAL;
2131 }
2132 if (!v4l2_ctrl_new_std_menu(hdl, ctrl_ops,
2133 V4L2_CID_CAMERA_ORIENTATION,
2134 V4L2_CAMERA_ORIENTATION_EXTERNAL, 0,
2135 orientation_ctrl))
2136 return hdl->error;
2137 }
2138
2139 if (p->rotation != V4L2_FWNODE_PROPERTY_UNSET) {
2140 if (!v4l2_ctrl_new_std(hdl, ctrl_ops,
2141 V4L2_CID_CAMERA_SENSOR_ROTATION,
2142 p->rotation, p->rotation, 1,
2143 p->rotation))
2144 return hdl->error;
2145 }
2146
2147 return hdl->error;
2148 }
2149 EXPORT_SYMBOL(v4l2_ctrl_new_fwnode_properties);
2150