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