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