1
2
3
4
5
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
17static const union v4l2_ctrl_ptr ptr_null;
18
19static 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
42void 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
53void 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
68static 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
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
97static 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
108static 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_fwht_params *p_fwht_params;
116 void *p = ptr.p + idx * ctrl->elem_size;
117
118 if (ctrl->p_def.p_const)
119 memcpy(p, ctrl->p_def.p_const, ctrl->elem_size);
120 else
121 memset(p, 0, ctrl->elem_size);
122
123 switch ((u32)ctrl->type) {
124 case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
125 p_mpeg2_sequence = p;
126
127
128 p_mpeg2_sequence->chroma_format = 1;
129 break;
130 case V4L2_CTRL_TYPE_MPEG2_PICTURE:
131 p_mpeg2_picture = p;
132
133
134 p_mpeg2_picture->picture_structure = V4L2_MPEG2_PIC_TOP_FIELD;
135 p_mpeg2_picture->picture_coding_type =
136 V4L2_MPEG2_PIC_CODING_TYPE_I;
137 break;
138 case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
139 p_mpeg2_quant = p;
140
141 memcpy(p_mpeg2_quant->intra_quantiser_matrix,
142 mpeg2_intra_quant_matrix,
143 ARRAY_SIZE(mpeg2_intra_quant_matrix));
144
145
146
147
148 memset(p_mpeg2_quant->non_intra_quantiser_matrix, 16,
149 sizeof(p_mpeg2_quant->non_intra_quantiser_matrix));
150 break;
151 case V4L2_CTRL_TYPE_VP8_FRAME:
152 p_vp8_frame = p;
153 p_vp8_frame->num_dct_parts = 1;
154 break;
155 case V4L2_CTRL_TYPE_FWHT_PARAMS:
156 p_fwht_params = p;
157 p_fwht_params->version = V4L2_FWHT_VERSION;
158 p_fwht_params->width = 1280;
159 p_fwht_params->height = 720;
160 p_fwht_params->flags = V4L2_FWHT_FL_PIXENC_YUV |
161 (2 << V4L2_FWHT_FL_COMPONENTS_NUM_OFFSET);
162 break;
163 }
164}
165
166static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
167 union v4l2_ctrl_ptr ptr)
168{
169 switch (ctrl->type) {
170 case V4L2_CTRL_TYPE_STRING:
171 idx *= ctrl->elem_size;
172 memset(ptr.p_char + idx, ' ', ctrl->minimum);
173 ptr.p_char[idx + ctrl->minimum] = '\0';
174 break;
175 case V4L2_CTRL_TYPE_INTEGER64:
176 ptr.p_s64[idx] = ctrl->default_value;
177 break;
178 case V4L2_CTRL_TYPE_INTEGER:
179 case V4L2_CTRL_TYPE_INTEGER_MENU:
180 case V4L2_CTRL_TYPE_MENU:
181 case V4L2_CTRL_TYPE_BITMASK:
182 case V4L2_CTRL_TYPE_BOOLEAN:
183 ptr.p_s32[idx] = ctrl->default_value;
184 break;
185 case V4L2_CTRL_TYPE_BUTTON:
186 case V4L2_CTRL_TYPE_CTRL_CLASS:
187 ptr.p_s32[idx] = 0;
188 break;
189 case V4L2_CTRL_TYPE_U8:
190 ptr.p_u8[idx] = ctrl->default_value;
191 break;
192 case V4L2_CTRL_TYPE_U16:
193 ptr.p_u16[idx] = ctrl->default_value;
194 break;
195 case V4L2_CTRL_TYPE_U32:
196 ptr.p_u32[idx] = ctrl->default_value;
197 break;
198 default:
199 std_init_compound(ctrl, idx, ptr);
200 break;
201 }
202}
203
204static void std_log(const struct v4l2_ctrl *ctrl)
205{
206 union v4l2_ctrl_ptr ptr = ctrl->p_cur;
207
208 if (ctrl->is_array) {
209 unsigned i;
210
211 for (i = 0; i < ctrl->nr_of_dims; i++)
212 pr_cont("[%u]", ctrl->dims[i]);
213 pr_cont(" ");
214 }
215
216 switch (ctrl->type) {
217 case V4L2_CTRL_TYPE_INTEGER:
218 pr_cont("%d", *ptr.p_s32);
219 break;
220 case V4L2_CTRL_TYPE_BOOLEAN:
221 pr_cont("%s", *ptr.p_s32 ? "true" : "false");
222 break;
223 case V4L2_CTRL_TYPE_MENU:
224 pr_cont("%s", ctrl->qmenu[*ptr.p_s32]);
225 break;
226 case V4L2_CTRL_TYPE_INTEGER_MENU:
227 pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]);
228 break;
229 case V4L2_CTRL_TYPE_BITMASK:
230 pr_cont("0x%08x", *ptr.p_s32);
231 break;
232 case V4L2_CTRL_TYPE_INTEGER64:
233 pr_cont("%lld", *ptr.p_s64);
234 break;
235 case V4L2_CTRL_TYPE_STRING:
236 pr_cont("%s", ptr.p_char);
237 break;
238 case V4L2_CTRL_TYPE_U8:
239 pr_cont("%u", (unsigned)*ptr.p_u8);
240 break;
241 case V4L2_CTRL_TYPE_U16:
242 pr_cont("%u", (unsigned)*ptr.p_u16);
243 break;
244 case V4L2_CTRL_TYPE_U32:
245 pr_cont("%u", (unsigned)*ptr.p_u32);
246 break;
247 case V4L2_CTRL_TYPE_H264_SPS:
248 pr_cont("H264_SPS");
249 break;
250 case V4L2_CTRL_TYPE_H264_PPS:
251 pr_cont("H264_PPS");
252 break;
253 case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
254 pr_cont("H264_SCALING_MATRIX");
255 break;
256 case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
257 pr_cont("H264_SLICE_PARAMS");
258 break;
259 case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
260 pr_cont("H264_DECODE_PARAMS");
261 break;
262 case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
263 pr_cont("H264_PRED_WEIGHTS");
264 break;
265 case V4L2_CTRL_TYPE_FWHT_PARAMS:
266 pr_cont("FWHT_PARAMS");
267 break;
268 case V4L2_CTRL_TYPE_VP8_FRAME:
269 pr_cont("VP8_FRAME");
270 break;
271 case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
272 pr_cont("HDR10_CLL_INFO");
273 break;
274 case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
275 pr_cont("HDR10_MASTERING_DISPLAY");
276 break;
277 case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
278 pr_cont("MPEG2_QUANTISATION");
279 break;
280 case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
281 pr_cont("MPEG2_SEQUENCE");
282 break;
283 case V4L2_CTRL_TYPE_MPEG2_PICTURE:
284 pr_cont("MPEG2_PICTURE");
285 break;
286 default:
287 pr_cont("unknown type %d", ctrl->type);
288 break;
289 }
290}
291
292
293
294
295
296
297#define ROUND_TO_RANGE(val, offset_type, ctrl) \
298({ \
299 offset_type offset; \
300 if ((ctrl)->maximum >= 0 && \
301 val >= (ctrl)->maximum - (s32)((ctrl)->step / 2)) \
302 val = (ctrl)->maximum; \
303 else \
304 val += (s32)((ctrl)->step / 2); \
305 val = clamp_t(typeof(val), val, \
306 (ctrl)->minimum, (ctrl)->maximum); \
307 offset = (val) - (ctrl)->minimum; \
308 offset = (ctrl)->step * (offset / (u32)(ctrl)->step); \
309 val = (ctrl)->minimum + offset; \
310 0; \
311})
312
313
314
315#define zero_padding(s) \
316 memset(&(s).padding, 0, sizeof((s).padding))
317#define zero_reserved(s) \
318 memset(&(s).reserved, 0, sizeof((s).reserved))
319
320
321
322
323
324static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx,
325 union v4l2_ctrl_ptr ptr)
326{
327 struct v4l2_ctrl_mpeg2_sequence *p_mpeg2_sequence;
328 struct v4l2_ctrl_mpeg2_picture *p_mpeg2_picture;
329 struct v4l2_ctrl_vp8_frame *p_vp8_frame;
330 struct v4l2_ctrl_fwht_params *p_fwht_params;
331 struct v4l2_ctrl_h264_sps *p_h264_sps;
332 struct v4l2_ctrl_h264_pps *p_h264_pps;
333 struct v4l2_ctrl_h264_pred_weights *p_h264_pred_weights;
334 struct v4l2_ctrl_h264_slice_params *p_h264_slice_params;
335 struct v4l2_ctrl_h264_decode_params *p_h264_dec_params;
336 struct v4l2_ctrl_hevc_sps *p_hevc_sps;
337 struct v4l2_ctrl_hevc_pps *p_hevc_pps;
338 struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params;
339 struct v4l2_ctrl_hdr10_mastering_display *p_hdr10_mastering;
340 struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params;
341 struct v4l2_area *area;
342 void *p = ptr.p + idx * ctrl->elem_size;
343 unsigned int i;
344
345 switch ((u32)ctrl->type) {
346 case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
347 p_mpeg2_sequence = p;
348
349 switch (p_mpeg2_sequence->chroma_format) {
350 case 1:
351 case 2:
352 case 3:
353 break;
354 default:
355 return -EINVAL;
356 }
357 break;
358
359 case V4L2_CTRL_TYPE_MPEG2_PICTURE:
360 p_mpeg2_picture = p;
361
362 switch (p_mpeg2_picture->intra_dc_precision) {
363 case 0:
364 case 1:
365 case 2:
366 case 3:
367 break;
368 default:
369 return -EINVAL;
370 }
371
372 switch (p_mpeg2_picture->picture_structure) {
373 case V4L2_MPEG2_PIC_TOP_FIELD:
374 case V4L2_MPEG2_PIC_BOTTOM_FIELD:
375 case V4L2_MPEG2_PIC_FRAME:
376 break;
377 default:
378 return -EINVAL;
379 }
380
381 switch (p_mpeg2_picture->picture_coding_type) {
382 case V4L2_MPEG2_PIC_CODING_TYPE_I:
383 case V4L2_MPEG2_PIC_CODING_TYPE_P:
384 case V4L2_MPEG2_PIC_CODING_TYPE_B:
385 break;
386 default:
387 return -EINVAL;
388 }
389 zero_reserved(*p_mpeg2_picture);
390 break;
391
392 case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
393 break;
394
395 case V4L2_CTRL_TYPE_FWHT_PARAMS:
396 p_fwht_params = p;
397 if (p_fwht_params->version < V4L2_FWHT_VERSION)
398 return -EINVAL;
399 if (!p_fwht_params->width || !p_fwht_params->height)
400 return -EINVAL;
401 break;
402
403 case V4L2_CTRL_TYPE_H264_SPS:
404 p_h264_sps = p;
405
406
407 if (p_h264_sps->pic_order_cnt_type != 0) {
408 p_h264_sps->log2_max_pic_order_cnt_lsb_minus4 = 0;
409 } else if (p_h264_sps->pic_order_cnt_type != 1) {
410 p_h264_sps->num_ref_frames_in_pic_order_cnt_cycle = 0;
411 p_h264_sps->offset_for_non_ref_pic = 0;
412 p_h264_sps->offset_for_top_to_bottom_field = 0;
413 memset(&p_h264_sps->offset_for_ref_frame, 0,
414 sizeof(p_h264_sps->offset_for_ref_frame));
415 }
416
417 if (!V4L2_H264_SPS_HAS_CHROMA_FORMAT(p_h264_sps)) {
418 p_h264_sps->chroma_format_idc = 1;
419 p_h264_sps->bit_depth_luma_minus8 = 0;
420 p_h264_sps->bit_depth_chroma_minus8 = 0;
421
422 p_h264_sps->flags &=
423 ~V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS;
424
425 if (p_h264_sps->chroma_format_idc < 3)
426 p_h264_sps->flags &=
427 ~V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE;
428 }
429
430 if (p_h264_sps->flags & V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY)
431 p_h264_sps->flags &=
432 ~V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD;
433
434
435
436
437
438
439
440
441 if (p_h264_sps->profile_idc < 122 &&
442 p_h264_sps->chroma_format_idc > 1)
443 return -EINVAL;
444
445 if (p_h264_sps->profile_idc < 244 &&
446 p_h264_sps->chroma_format_idc > 2)
447 return -EINVAL;
448 if (p_h264_sps->chroma_format_idc > 3)
449 return -EINVAL;
450
451 if (p_h264_sps->bit_depth_luma_minus8 > 6)
452 return -EINVAL;
453 if (p_h264_sps->bit_depth_chroma_minus8 > 6)
454 return -EINVAL;
455 if (p_h264_sps->log2_max_frame_num_minus4 > 12)
456 return -EINVAL;
457 if (p_h264_sps->pic_order_cnt_type > 2)
458 return -EINVAL;
459 if (p_h264_sps->log2_max_pic_order_cnt_lsb_minus4 > 12)
460 return -EINVAL;
461 if (p_h264_sps->max_num_ref_frames > V4L2_H264_REF_LIST_LEN)
462 return -EINVAL;
463 break;
464
465 case V4L2_CTRL_TYPE_H264_PPS:
466 p_h264_pps = p;
467
468 if (p_h264_pps->num_slice_groups_minus1 > 7)
469 return -EINVAL;
470 if (p_h264_pps->num_ref_idx_l0_default_active_minus1 >
471 (V4L2_H264_REF_LIST_LEN - 1))
472 return -EINVAL;
473 if (p_h264_pps->num_ref_idx_l1_default_active_minus1 >
474 (V4L2_H264_REF_LIST_LEN - 1))
475 return -EINVAL;
476 if (p_h264_pps->weighted_bipred_idc > 2)
477 return -EINVAL;
478
479
480
481
482
483 if (p_h264_pps->pic_init_qp_minus26 < -62 ||
484 p_h264_pps->pic_init_qp_minus26 > 25)
485 return -EINVAL;
486 if (p_h264_pps->pic_init_qs_minus26 < -26 ||
487 p_h264_pps->pic_init_qs_minus26 > 25)
488 return -EINVAL;
489 if (p_h264_pps->chroma_qp_index_offset < -12 ||
490 p_h264_pps->chroma_qp_index_offset > 12)
491 return -EINVAL;
492 if (p_h264_pps->second_chroma_qp_index_offset < -12 ||
493 p_h264_pps->second_chroma_qp_index_offset > 12)
494 return -EINVAL;
495 break;
496
497 case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
498 break;
499
500 case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
501 p_h264_pred_weights = p;
502
503 if (p_h264_pred_weights->luma_log2_weight_denom > 7)
504 return -EINVAL;
505 if (p_h264_pred_weights->chroma_log2_weight_denom > 7)
506 return -EINVAL;
507 break;
508
509 case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
510 p_h264_slice_params = p;
511
512 if (p_h264_slice_params->slice_type != V4L2_H264_SLICE_TYPE_B)
513 p_h264_slice_params->flags &=
514 ~V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED;
515
516 if (p_h264_slice_params->colour_plane_id > 2)
517 return -EINVAL;
518 if (p_h264_slice_params->cabac_init_idc > 2)
519 return -EINVAL;
520 if (p_h264_slice_params->disable_deblocking_filter_idc > 2)
521 return -EINVAL;
522 if (p_h264_slice_params->slice_alpha_c0_offset_div2 < -6 ||
523 p_h264_slice_params->slice_alpha_c0_offset_div2 > 6)
524 return -EINVAL;
525 if (p_h264_slice_params->slice_beta_offset_div2 < -6 ||
526 p_h264_slice_params->slice_beta_offset_div2 > 6)
527 return -EINVAL;
528
529 if (p_h264_slice_params->slice_type == V4L2_H264_SLICE_TYPE_I ||
530 p_h264_slice_params->slice_type == V4L2_H264_SLICE_TYPE_SI)
531 p_h264_slice_params->num_ref_idx_l0_active_minus1 = 0;
532 if (p_h264_slice_params->slice_type != V4L2_H264_SLICE_TYPE_B)
533 p_h264_slice_params->num_ref_idx_l1_active_minus1 = 0;
534
535 if (p_h264_slice_params->num_ref_idx_l0_active_minus1 >
536 (V4L2_H264_REF_LIST_LEN - 1))
537 return -EINVAL;
538 if (p_h264_slice_params->num_ref_idx_l1_active_minus1 >
539 (V4L2_H264_REF_LIST_LEN - 1))
540 return -EINVAL;
541 zero_reserved(*p_h264_slice_params);
542 break;
543
544 case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
545 p_h264_dec_params = p;
546
547 if (p_h264_dec_params->nal_ref_idc > 3)
548 return -EINVAL;
549 for (i = 0; i < V4L2_H264_NUM_DPB_ENTRIES; i++) {
550 struct v4l2_h264_dpb_entry *dpb_entry =
551 &p_h264_dec_params->dpb[i];
552
553 zero_reserved(*dpb_entry);
554 }
555 zero_reserved(*p_h264_dec_params);
556 break;
557
558 case V4L2_CTRL_TYPE_VP8_FRAME:
559 p_vp8_frame = p;
560
561 switch (p_vp8_frame->num_dct_parts) {
562 case 1:
563 case 2:
564 case 4:
565 case 8:
566 break;
567 default:
568 return -EINVAL;
569 }
570 zero_padding(p_vp8_frame->segment);
571 zero_padding(p_vp8_frame->lf);
572 zero_padding(p_vp8_frame->quant);
573 zero_padding(p_vp8_frame->entropy);
574 zero_padding(p_vp8_frame->coder_state);
575 break;
576
577 case V4L2_CTRL_TYPE_HEVC_SPS:
578 p_hevc_sps = p;
579
580 if (!(p_hevc_sps->flags & V4L2_HEVC_SPS_FLAG_PCM_ENABLED)) {
581 p_hevc_sps->pcm_sample_bit_depth_luma_minus1 = 0;
582 p_hevc_sps->pcm_sample_bit_depth_chroma_minus1 = 0;
583 p_hevc_sps->log2_min_pcm_luma_coding_block_size_minus3 = 0;
584 p_hevc_sps->log2_diff_max_min_pcm_luma_coding_block_size = 0;
585 }
586
587 if (!(p_hevc_sps->flags &
588 V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT))
589 p_hevc_sps->num_long_term_ref_pics_sps = 0;
590 break;
591
592 case V4L2_CTRL_TYPE_HEVC_PPS:
593 p_hevc_pps = p;
594
595 if (!(p_hevc_pps->flags &
596 V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED))
597 p_hevc_pps->diff_cu_qp_delta_depth = 0;
598
599 if (!(p_hevc_pps->flags & V4L2_HEVC_PPS_FLAG_TILES_ENABLED)) {
600 p_hevc_pps->num_tile_columns_minus1 = 0;
601 p_hevc_pps->num_tile_rows_minus1 = 0;
602 memset(&p_hevc_pps->column_width_minus1, 0,
603 sizeof(p_hevc_pps->column_width_minus1));
604 memset(&p_hevc_pps->row_height_minus1, 0,
605 sizeof(p_hevc_pps->row_height_minus1));
606
607 p_hevc_pps->flags &=
608 ~V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED;
609 }
610
611 if (p_hevc_pps->flags &
612 V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER) {
613 p_hevc_pps->pps_beta_offset_div2 = 0;
614 p_hevc_pps->pps_tc_offset_div2 = 0;
615 }
616
617 zero_padding(*p_hevc_pps);
618 break;
619
620 case V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS:
621 p_hevc_decode_params = p;
622
623 if (p_hevc_decode_params->num_active_dpb_entries >
624 V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
625 return -EINVAL;
626
627 for (i = 0; i < p_hevc_decode_params->num_active_dpb_entries;
628 i++) {
629 struct v4l2_hevc_dpb_entry *dpb_entry =
630 &p_hevc_decode_params->dpb[i];
631
632 zero_padding(*dpb_entry);
633 }
634 break;
635
636 case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
637 p_hevc_slice_params = p;
638
639 zero_padding(p_hevc_slice_params->pred_weight_table);
640 zero_padding(*p_hevc_slice_params);
641 break;
642
643 case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
644 break;
645
646 case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
647 p_hdr10_mastering = p;
648
649 for (i = 0; i < 3; ++i) {
650 if (p_hdr10_mastering->display_primaries_x[i] <
651 V4L2_HDR10_MASTERING_PRIMARIES_X_LOW ||
652 p_hdr10_mastering->display_primaries_x[i] >
653 V4L2_HDR10_MASTERING_PRIMARIES_X_HIGH ||
654 p_hdr10_mastering->display_primaries_y[i] <
655 V4L2_HDR10_MASTERING_PRIMARIES_Y_LOW ||
656 p_hdr10_mastering->display_primaries_y[i] >
657 V4L2_HDR10_MASTERING_PRIMARIES_Y_HIGH)
658 return -EINVAL;
659 }
660
661 if (p_hdr10_mastering->white_point_x <
662 V4L2_HDR10_MASTERING_WHITE_POINT_X_LOW ||
663 p_hdr10_mastering->white_point_x >
664 V4L2_HDR10_MASTERING_WHITE_POINT_X_HIGH ||
665 p_hdr10_mastering->white_point_y <
666 V4L2_HDR10_MASTERING_WHITE_POINT_Y_LOW ||
667 p_hdr10_mastering->white_point_y >
668 V4L2_HDR10_MASTERING_WHITE_POINT_Y_HIGH)
669 return -EINVAL;
670
671 if (p_hdr10_mastering->max_display_mastering_luminance <
672 V4L2_HDR10_MASTERING_MAX_LUMA_LOW ||
673 p_hdr10_mastering->max_display_mastering_luminance >
674 V4L2_HDR10_MASTERING_MAX_LUMA_HIGH ||
675 p_hdr10_mastering->min_display_mastering_luminance <
676 V4L2_HDR10_MASTERING_MIN_LUMA_LOW ||
677 p_hdr10_mastering->min_display_mastering_luminance >
678 V4L2_HDR10_MASTERING_MIN_LUMA_HIGH)
679 return -EINVAL;
680
681
682 if (p_hdr10_mastering->max_display_mastering_luminance ==
683 V4L2_HDR10_MASTERING_MAX_LUMA_LOW &&
684 p_hdr10_mastering->min_display_mastering_luminance ==
685 V4L2_HDR10_MASTERING_MIN_LUMA_HIGH)
686 return -EINVAL;
687
688 break;
689
690 case V4L2_CTRL_TYPE_AREA:
691 area = p;
692 if (!area->width || !area->height)
693 return -EINVAL;
694 break;
695
696 default:
697 return -EINVAL;
698 }
699
700 return 0;
701}
702
703static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
704 union v4l2_ctrl_ptr ptr)
705{
706 size_t len;
707 u64 offset;
708 s64 val;
709
710 switch ((u32)ctrl->type) {
711 case V4L2_CTRL_TYPE_INTEGER:
712 return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
713 case V4L2_CTRL_TYPE_INTEGER64:
714
715
716
717
718 val = ptr.p_s64[idx];
719 if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2))
720 val = ctrl->maximum;
721 else
722 val += (s64)(ctrl->step / 2);
723 val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum);
724 offset = val - ctrl->minimum;
725 do_div(offset, ctrl->step);
726 ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step;
727 return 0;
728 case V4L2_CTRL_TYPE_U8:
729 return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl);
730 case V4L2_CTRL_TYPE_U16:
731 return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl);
732 case V4L2_CTRL_TYPE_U32:
733 return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl);
734
735 case V4L2_CTRL_TYPE_BOOLEAN:
736 ptr.p_s32[idx] = !!ptr.p_s32[idx];
737 return 0;
738
739 case V4L2_CTRL_TYPE_MENU:
740 case V4L2_CTRL_TYPE_INTEGER_MENU:
741 if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum)
742 return -ERANGE;
743 if (ptr.p_s32[idx] < BITS_PER_LONG_LONG &&
744 (ctrl->menu_skip_mask & BIT_ULL(ptr.p_s32[idx])))
745 return -EINVAL;
746 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
747 ctrl->qmenu[ptr.p_s32[idx]][0] == '\0')
748 return -EINVAL;
749 return 0;
750
751 case V4L2_CTRL_TYPE_BITMASK:
752 ptr.p_s32[idx] &= ctrl->maximum;
753 return 0;
754
755 case V4L2_CTRL_TYPE_BUTTON:
756 case V4L2_CTRL_TYPE_CTRL_CLASS:
757 ptr.p_s32[idx] = 0;
758 return 0;
759
760 case V4L2_CTRL_TYPE_STRING:
761 idx *= ctrl->elem_size;
762 len = strlen(ptr.p_char + idx);
763 if (len < ctrl->minimum)
764 return -ERANGE;
765 if ((len - (u32)ctrl->minimum) % (u32)ctrl->step)
766 return -ERANGE;
767 return 0;
768
769 default:
770 return std_validate_compound(ctrl, idx, ptr);
771 }
772}
773
774static const struct v4l2_ctrl_type_ops std_type_ops = {
775 .equal = std_equal,
776 .init = std_init,
777 .log = std_log,
778 .validate = std_validate,
779};
780
781void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
782{
783 if (!ctrl)
784 return;
785 if (!notify) {
786 ctrl->call_notify = 0;
787 return;
788 }
789 if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
790 return;
791 ctrl->handler->notify = notify;
792 ctrl->handler->notify_priv = priv;
793 ctrl->call_notify = 1;
794}
795EXPORT_SYMBOL(v4l2_ctrl_notify);
796
797
798static void ptr_to_ptr(struct v4l2_ctrl *ctrl,
799 union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to)
800{
801 if (ctrl == NULL)
802 return;
803 memcpy(to.p, from.p_const, ctrl->elems * ctrl->elem_size);
804}
805
806
807void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
808{
809 bool changed;
810
811 if (ctrl == NULL)
812 return;
813
814
815 changed = ctrl->has_changed;
816 if (changed)
817 ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur);
818
819 if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
820
821 ctrl->flags &=
822 ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
823 if (!is_cur_manual(ctrl->cluster[0])) {
824 ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
825 if (ctrl->cluster[0]->has_volatiles)
826 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
827 }
828 fh = NULL;
829 }
830 if (changed || ch_flags) {
831
832
833 if (!ctrl->is_new)
834 fh = NULL;
835 send_event(fh, ctrl,
836 (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
837 if (ctrl->call_notify && changed && ctrl->handler->notify)
838 ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
839 }
840}
841
842
843void cur_to_new(struct v4l2_ctrl *ctrl)
844{
845 if (ctrl == NULL)
846 return;
847 ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
848}
849
850
851void new_to_req(struct v4l2_ctrl_ref *ref)
852{
853 if (!ref)
854 return;
855 ptr_to_ptr(ref->ctrl, ref->ctrl->p_new, ref->p_req);
856 ref->valid_p_req = true;
857}
858
859
860void cur_to_req(struct v4l2_ctrl_ref *ref)
861{
862 if (!ref)
863 return;
864 ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->p_req);
865 ref->valid_p_req = true;
866}
867
868
869void req_to_new(struct v4l2_ctrl_ref *ref)
870{
871 if (!ref)
872 return;
873 if (ref->valid_p_req)
874 ptr_to_ptr(ref->ctrl, ref->p_req, ref->ctrl->p_new);
875 else
876 ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->ctrl->p_new);
877}
878
879
880int check_range(enum v4l2_ctrl_type type,
881 s64 min, s64 max, u64 step, s64 def)
882{
883 switch (type) {
884 case V4L2_CTRL_TYPE_BOOLEAN:
885 if (step != 1 || max > 1 || min < 0)
886 return -ERANGE;
887 fallthrough;
888 case V4L2_CTRL_TYPE_U8:
889 case V4L2_CTRL_TYPE_U16:
890 case V4L2_CTRL_TYPE_U32:
891 case V4L2_CTRL_TYPE_INTEGER:
892 case V4L2_CTRL_TYPE_INTEGER64:
893 if (step == 0 || min > max || def < min || def > max)
894 return -ERANGE;
895 return 0;
896 case V4L2_CTRL_TYPE_BITMASK:
897 if (step || min || !max || (def & ~max))
898 return -ERANGE;
899 return 0;
900 case V4L2_CTRL_TYPE_MENU:
901 case V4L2_CTRL_TYPE_INTEGER_MENU:
902 if (min > max || def < min || def > max)
903 return -ERANGE;
904
905
906 if (step && ((1 << def) & step))
907 return -EINVAL;
908 return 0;
909 case V4L2_CTRL_TYPE_STRING:
910 if (min > max || min < 0 || step < 1 || def)
911 return -ERANGE;
912 return 0;
913 default:
914 return 0;
915 }
916}
917
918
919int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
920{
921 unsigned idx;
922 int err = 0;
923
924 for (idx = 0; !err && idx < ctrl->elems; idx++)
925 err = ctrl->type_ops->validate(ctrl, idx, p_new);
926 return err;
927}
928
929
930static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
931{
932 if (hdl->error == 0)
933 hdl->error = err;
934 return err;
935}
936
937
938int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
939 unsigned nr_of_controls_hint,
940 struct lock_class_key *key, const char *name)
941{
942 mutex_init(&hdl->_lock);
943 hdl->lock = &hdl->_lock;
944 lockdep_set_class_and_name(hdl->lock, key, name);
945 INIT_LIST_HEAD(&hdl->ctrls);
946 INIT_LIST_HEAD(&hdl->ctrl_refs);
947 hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
948 hdl->buckets = kvmalloc_array(hdl->nr_of_buckets,
949 sizeof(hdl->buckets[0]),
950 GFP_KERNEL | __GFP_ZERO);
951 hdl->error = hdl->buckets ? 0 : -ENOMEM;
952 v4l2_ctrl_handler_init_request(hdl);
953 return hdl->error;
954}
955EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
956
957
958void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
959{
960 struct v4l2_ctrl_ref *ref, *next_ref;
961 struct v4l2_ctrl *ctrl, *next_ctrl;
962 struct v4l2_subscribed_event *sev, *next_sev;
963
964 if (hdl == NULL || hdl->buckets == NULL)
965 return;
966
967 v4l2_ctrl_handler_free_request(hdl);
968
969 mutex_lock(hdl->lock);
970
971 list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
972 list_del(&ref->node);
973 kfree(ref);
974 }
975
976 list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
977 list_del(&ctrl->node);
978 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
979 list_del(&sev->node);
980 kvfree(ctrl);
981 }
982 kvfree(hdl->buckets);
983 hdl->buckets = NULL;
984 hdl->cached = NULL;
985 hdl->error = 0;
986 mutex_unlock(hdl->lock);
987 mutex_destroy(&hdl->_lock);
988}
989EXPORT_SYMBOL(v4l2_ctrl_handler_free);
990
991
992
993
994
995
996
997static struct v4l2_ctrl_ref *find_private_ref(
998 struct v4l2_ctrl_handler *hdl, u32 id)
999{
1000 struct v4l2_ctrl_ref *ref;
1001
1002 id -= V4L2_CID_PRIVATE_BASE;
1003 list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1004
1005
1006 if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1007 V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1008 if (!ref->ctrl->is_int)
1009 continue;
1010 if (id == 0)
1011 return ref;
1012 id--;
1013 }
1014 }
1015 return NULL;
1016}
1017
1018
1019struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1020{
1021 struct v4l2_ctrl_ref *ref;
1022 int bucket;
1023
1024 id &= V4L2_CTRL_ID_MASK;
1025
1026
1027 if (id >= V4L2_CID_PRIVATE_BASE)
1028 return find_private_ref(hdl, id);
1029 bucket = id % hdl->nr_of_buckets;
1030
1031
1032 if (hdl->cached && hdl->cached->ctrl->id == id)
1033 return hdl->cached;
1034
1035
1036 ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1037 while (ref && ref->ctrl->id != id)
1038 ref = ref->next;
1039
1040 if (ref)
1041 hdl->cached = ref;
1042 return ref;
1043}
1044
1045
1046struct v4l2_ctrl_ref *find_ref_lock(struct v4l2_ctrl_handler *hdl, u32 id)
1047{
1048 struct v4l2_ctrl_ref *ref = NULL;
1049
1050 if (hdl) {
1051 mutex_lock(hdl->lock);
1052 ref = find_ref(hdl, id);
1053 mutex_unlock(hdl->lock);
1054 }
1055 return ref;
1056}
1057
1058
1059struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1060{
1061 struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1062
1063 return ref ? ref->ctrl : NULL;
1064}
1065EXPORT_SYMBOL(v4l2_ctrl_find);
1066
1067
1068int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1069 struct v4l2_ctrl *ctrl,
1070 struct v4l2_ctrl_ref **ctrl_ref,
1071 bool from_other_dev, bool allocate_req)
1072{
1073 struct v4l2_ctrl_ref *ref;
1074 struct v4l2_ctrl_ref *new_ref;
1075 u32 id = ctrl->id;
1076 u32 class_ctrl = V4L2_CTRL_ID2WHICH(id) | 1;
1077 int bucket = id % hdl->nr_of_buckets;
1078 unsigned int size_extra_req = 0;
1079
1080 if (ctrl_ref)
1081 *ctrl_ref = NULL;
1082
1083
1084
1085
1086
1087 if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES &&
1088 id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1089 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1090 return hdl->error;
1091
1092 if (hdl->error)
1093 return hdl->error;
1094
1095 if (allocate_req)
1096 size_extra_req = ctrl->elems * ctrl->elem_size;
1097 new_ref = kzalloc(sizeof(*new_ref) + size_extra_req, GFP_KERNEL);
1098 if (!new_ref)
1099 return handler_set_err(hdl, -ENOMEM);
1100 new_ref->ctrl = ctrl;
1101 new_ref->from_other_dev = from_other_dev;
1102 if (size_extra_req)
1103 new_ref->p_req.p = &new_ref[1];
1104
1105 INIT_LIST_HEAD(&new_ref->node);
1106
1107 mutex_lock(hdl->lock);
1108
1109
1110
1111
1112
1113 if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1114 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1115 goto insert_in_hash;
1116 }
1117
1118
1119 list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1120 if (ref->ctrl->id < id)
1121 continue;
1122
1123 if (ref->ctrl->id == id) {
1124 kfree(new_ref);
1125 goto unlock;
1126 }
1127 list_add(&new_ref->node, ref->node.prev);
1128 break;
1129 }
1130
1131insert_in_hash:
1132
1133 new_ref->next = hdl->buckets[bucket];
1134 hdl->buckets[bucket] = new_ref;
1135 if (ctrl_ref)
1136 *ctrl_ref = new_ref;
1137 if (ctrl->handler == hdl) {
1138
1139
1140
1141
1142
1143 ctrl->cluster = &new_ref->ctrl;
1144 ctrl->ncontrols = 1;
1145 }
1146
1147unlock:
1148 mutex_unlock(hdl->lock);
1149 return 0;
1150}
1151
1152
1153static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1154 const struct v4l2_ctrl_ops *ops,
1155 const struct v4l2_ctrl_type_ops *type_ops,
1156 u32 id, const char *name, enum v4l2_ctrl_type type,
1157 s64 min, s64 max, u64 step, s64 def,
1158 const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
1159 u32 flags, const char * const *qmenu,
1160 const s64 *qmenu_int, const union v4l2_ctrl_ptr p_def,
1161 void *priv)
1162{
1163 struct v4l2_ctrl *ctrl;
1164 unsigned sz_extra;
1165 unsigned nr_of_dims = 0;
1166 unsigned elems = 1;
1167 bool is_array;
1168 unsigned tot_ctrl_size;
1169 unsigned idx;
1170 void *data;
1171 int err;
1172
1173 if (hdl->error)
1174 return NULL;
1175
1176 while (dims && dims[nr_of_dims]) {
1177 elems *= dims[nr_of_dims];
1178 nr_of_dims++;
1179 if (nr_of_dims == V4L2_CTRL_MAX_DIMS)
1180 break;
1181 }
1182 is_array = nr_of_dims > 0;
1183
1184
1185 switch ((u32)type) {
1186 case V4L2_CTRL_TYPE_INTEGER64:
1187 elem_size = sizeof(s64);
1188 break;
1189 case V4L2_CTRL_TYPE_STRING:
1190 elem_size = max + 1;
1191 break;
1192 case V4L2_CTRL_TYPE_U8:
1193 elem_size = sizeof(u8);
1194 break;
1195 case V4L2_CTRL_TYPE_U16:
1196 elem_size = sizeof(u16);
1197 break;
1198 case V4L2_CTRL_TYPE_U32:
1199 elem_size = sizeof(u32);
1200 break;
1201 case V4L2_CTRL_TYPE_MPEG2_SEQUENCE:
1202 elem_size = sizeof(struct v4l2_ctrl_mpeg2_sequence);
1203 break;
1204 case V4L2_CTRL_TYPE_MPEG2_PICTURE:
1205 elem_size = sizeof(struct v4l2_ctrl_mpeg2_picture);
1206 break;
1207 case V4L2_CTRL_TYPE_MPEG2_QUANTISATION:
1208 elem_size = sizeof(struct v4l2_ctrl_mpeg2_quantisation);
1209 break;
1210 case V4L2_CTRL_TYPE_FWHT_PARAMS:
1211 elem_size = sizeof(struct v4l2_ctrl_fwht_params);
1212 break;
1213 case V4L2_CTRL_TYPE_H264_SPS:
1214 elem_size = sizeof(struct v4l2_ctrl_h264_sps);
1215 break;
1216 case V4L2_CTRL_TYPE_H264_PPS:
1217 elem_size = sizeof(struct v4l2_ctrl_h264_pps);
1218 break;
1219 case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
1220 elem_size = sizeof(struct v4l2_ctrl_h264_scaling_matrix);
1221 break;
1222 case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
1223 elem_size = sizeof(struct v4l2_ctrl_h264_slice_params);
1224 break;
1225 case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
1226 elem_size = sizeof(struct v4l2_ctrl_h264_decode_params);
1227 break;
1228 case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
1229 elem_size = sizeof(struct v4l2_ctrl_h264_pred_weights);
1230 break;
1231 case V4L2_CTRL_TYPE_VP8_FRAME:
1232 elem_size = sizeof(struct v4l2_ctrl_vp8_frame);
1233 break;
1234 case V4L2_CTRL_TYPE_HEVC_SPS:
1235 elem_size = sizeof(struct v4l2_ctrl_hevc_sps);
1236 break;
1237 case V4L2_CTRL_TYPE_HEVC_PPS:
1238 elem_size = sizeof(struct v4l2_ctrl_hevc_pps);
1239 break;
1240 case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
1241 elem_size = sizeof(struct v4l2_ctrl_hevc_slice_params);
1242 break;
1243 case V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS:
1244 elem_size = sizeof(struct v4l2_ctrl_hevc_decode_params);
1245 break;
1246 case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
1247 elem_size = sizeof(struct v4l2_ctrl_hdr10_cll_info);
1248 break;
1249 case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
1250 elem_size = sizeof(struct v4l2_ctrl_hdr10_mastering_display);
1251 break;
1252 case V4L2_CTRL_TYPE_AREA:
1253 elem_size = sizeof(struct v4l2_area);
1254 break;
1255 default:
1256 if (type < V4L2_CTRL_COMPOUND_TYPES)
1257 elem_size = sizeof(s32);
1258 break;
1259 }
1260 tot_ctrl_size = elem_size * elems;
1261
1262
1263 if (id == 0 || name == NULL || !elem_size ||
1264 id >= V4L2_CID_PRIVATE_BASE ||
1265 (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1266 (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
1267 handler_set_err(hdl, -ERANGE);
1268 return NULL;
1269 }
1270 err = check_range(type, min, max, step, def);
1271 if (err) {
1272 handler_set_err(hdl, err);
1273 return NULL;
1274 }
1275 if (is_array &&
1276 (type == V4L2_CTRL_TYPE_BUTTON ||
1277 type == V4L2_CTRL_TYPE_CTRL_CLASS)) {
1278 handler_set_err(hdl, -EINVAL);
1279 return NULL;
1280 }
1281
1282 sz_extra = 0;
1283 if (type == V4L2_CTRL_TYPE_BUTTON)
1284 flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1285 V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1286 else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1287 flags |= V4L2_CTRL_FLAG_READ_ONLY;
1288 else if (type == V4L2_CTRL_TYPE_INTEGER64 ||
1289 type == V4L2_CTRL_TYPE_STRING ||
1290 type >= V4L2_CTRL_COMPOUND_TYPES ||
1291 is_array)
1292 sz_extra += 2 * tot_ctrl_size;
1293
1294 if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const)
1295 sz_extra += elem_size;
1296
1297 ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
1298 if (ctrl == NULL) {
1299 handler_set_err(hdl, -ENOMEM);
1300 return NULL;
1301 }
1302
1303 INIT_LIST_HEAD(&ctrl->node);
1304 INIT_LIST_HEAD(&ctrl->ev_subs);
1305 ctrl->handler = hdl;
1306 ctrl->ops = ops;
1307 ctrl->type_ops = type_ops ? type_ops : &std_type_ops;
1308 ctrl->id = id;
1309 ctrl->name = name;
1310 ctrl->type = type;
1311 ctrl->flags = flags;
1312 ctrl->minimum = min;
1313 ctrl->maximum = max;
1314 ctrl->step = step;
1315 ctrl->default_value = def;
1316 ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING;
1317 ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string;
1318 ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64;
1319 ctrl->is_array = is_array;
1320 ctrl->elems = elems;
1321 ctrl->nr_of_dims = nr_of_dims;
1322 if (nr_of_dims)
1323 memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0]));
1324 ctrl->elem_size = elem_size;
1325 if (type == V4L2_CTRL_TYPE_MENU)
1326 ctrl->qmenu = qmenu;
1327 else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1328 ctrl->qmenu_int = qmenu_int;
1329 ctrl->priv = priv;
1330 ctrl->cur.val = ctrl->val = def;
1331 data = &ctrl[1];
1332
1333 if (!ctrl->is_int) {
1334 ctrl->p_new.p = data;
1335 ctrl->p_cur.p = data + tot_ctrl_size;
1336 } else {
1337 ctrl->p_new.p = &ctrl->val;
1338 ctrl->p_cur.p = &ctrl->cur.val;
1339 }
1340
1341 if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const) {
1342 ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size;
1343 memcpy(ctrl->p_def.p, p_def.p_const, elem_size);
1344 }
1345
1346 for (idx = 0; idx < elems; idx++) {
1347 ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
1348 ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
1349 }
1350
1351 if (handler_new_ref(hdl, ctrl, NULL, false, false)) {
1352 kvfree(ctrl);
1353 return NULL;
1354 }
1355 mutex_lock(hdl->lock);
1356 list_add_tail(&ctrl->node, &hdl->ctrls);
1357 mutex_unlock(hdl->lock);
1358 return ctrl;
1359}
1360
1361struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
1362 const struct v4l2_ctrl_config *cfg, void *priv)
1363{
1364 bool is_menu;
1365 struct v4l2_ctrl *ctrl;
1366 const char *name = cfg->name;
1367 const char * const *qmenu = cfg->qmenu;
1368 const s64 *qmenu_int = cfg->qmenu_int;
1369 enum v4l2_ctrl_type type = cfg->type;
1370 u32 flags = cfg->flags;
1371 s64 min = cfg->min;
1372 s64 max = cfg->max;
1373 u64 step = cfg->step;
1374 s64 def = cfg->def;
1375
1376 if (name == NULL)
1377 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
1378 &def, &flags);
1379
1380 is_menu = (type == V4L2_CTRL_TYPE_MENU ||
1381 type == V4L2_CTRL_TYPE_INTEGER_MENU);
1382 if (is_menu)
1383 WARN_ON(step);
1384 else
1385 WARN_ON(cfg->menu_skip_mask);
1386 if (type == V4L2_CTRL_TYPE_MENU && !qmenu) {
1387 qmenu = v4l2_ctrl_get_menu(cfg->id);
1388 } else if (type == V4L2_CTRL_TYPE_INTEGER_MENU && !qmenu_int) {
1389 handler_set_err(hdl, -EINVAL);
1390 return NULL;
1391 }
1392
1393 ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name,
1394 type, min, max,
1395 is_menu ? cfg->menu_skip_mask : step, def,
1396 cfg->dims, cfg->elem_size,
1397 flags, qmenu, qmenu_int, cfg->p_def, priv);
1398 if (ctrl)
1399 ctrl->is_private = cfg->is_private;
1400 return ctrl;
1401}
1402EXPORT_SYMBOL(v4l2_ctrl_new_custom);
1403
1404
1405struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
1406 const struct v4l2_ctrl_ops *ops,
1407 u32 id, s64 min, s64 max, u64 step, s64 def)
1408{
1409 const char *name;
1410 enum v4l2_ctrl_type type;
1411 u32 flags;
1412
1413 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1414 if (type == V4L2_CTRL_TYPE_MENU ||
1415 type == V4L2_CTRL_TYPE_INTEGER_MENU ||
1416 type >= V4L2_CTRL_COMPOUND_TYPES) {
1417 handler_set_err(hdl, -EINVAL);
1418 return NULL;
1419 }
1420 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1421 min, max, step, def, NULL, 0,
1422 flags, NULL, NULL, ptr_null, NULL);
1423}
1424EXPORT_SYMBOL(v4l2_ctrl_new_std);
1425
1426
1427struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
1428 const struct v4l2_ctrl_ops *ops,
1429 u32 id, u8 _max, u64 mask, u8 _def)
1430{
1431 const char * const *qmenu = NULL;
1432 const s64 *qmenu_int = NULL;
1433 unsigned int qmenu_int_len = 0;
1434 const char *name;
1435 enum v4l2_ctrl_type type;
1436 s64 min;
1437 s64 max = _max;
1438 s64 def = _def;
1439 u64 step;
1440 u32 flags;
1441
1442 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1443
1444 if (type == V4L2_CTRL_TYPE_MENU)
1445 qmenu = v4l2_ctrl_get_menu(id);
1446 else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1447 qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
1448
1449 if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
1450 handler_set_err(hdl, -EINVAL);
1451 return NULL;
1452 }
1453 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1454 0, max, mask, def, NULL, 0,
1455 flags, qmenu, qmenu_int, ptr_null, NULL);
1456}
1457EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
1458
1459
1460struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
1461 const struct v4l2_ctrl_ops *ops, u32 id, u8 _max,
1462 u64 mask, u8 _def, const char * const *qmenu)
1463{
1464 enum v4l2_ctrl_type type;
1465 const char *name;
1466 u32 flags;
1467 u64 step;
1468 s64 min;
1469 s64 max = _max;
1470 s64 def = _def;
1471
1472
1473
1474
1475 if (v4l2_ctrl_get_menu(id)) {
1476 handler_set_err(hdl, -EINVAL);
1477 return NULL;
1478 }
1479
1480 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1481 if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
1482 handler_set_err(hdl, -EINVAL);
1483 return NULL;
1484 }
1485 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1486 0, max, mask, def, NULL, 0,
1487 flags, qmenu, NULL, ptr_null, NULL);
1488
1489}
1490EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
1491
1492
1493struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl,
1494 const struct v4l2_ctrl_ops *ops, u32 id,
1495 const union v4l2_ctrl_ptr p_def)
1496{
1497 const char *name;
1498 enum v4l2_ctrl_type type;
1499 u32 flags;
1500 s64 min, max, step, def;
1501
1502 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1503 if (type < V4L2_CTRL_COMPOUND_TYPES) {
1504 handler_set_err(hdl, -EINVAL);
1505 return NULL;
1506 }
1507 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1508 min, max, step, def, NULL, 0,
1509 flags, NULL, NULL, p_def, NULL);
1510}
1511EXPORT_SYMBOL(v4l2_ctrl_new_std_compound);
1512
1513
1514struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
1515 const struct v4l2_ctrl_ops *ops,
1516 u32 id, u8 _max, u8 _def, const s64 *qmenu_int)
1517{
1518 const char *name;
1519 enum v4l2_ctrl_type type;
1520 s64 min;
1521 u64 step;
1522 s64 max = _max;
1523 s64 def = _def;
1524 u32 flags;
1525
1526 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1527 if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
1528 handler_set_err(hdl, -EINVAL);
1529 return NULL;
1530 }
1531 return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
1532 0, max, 0, def, NULL, 0,
1533 flags, NULL, qmenu_int, ptr_null, NULL);
1534}
1535EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
1536
1537
1538int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
1539 struct v4l2_ctrl_handler *add,
1540 bool (*filter)(const struct v4l2_ctrl *ctrl),
1541 bool from_other_dev)
1542{
1543 struct v4l2_ctrl_ref *ref;
1544 int ret = 0;
1545
1546
1547 if (!hdl || !add || hdl == add)
1548 return 0;
1549 if (hdl->error)
1550 return hdl->error;
1551 mutex_lock(add->lock);
1552 list_for_each_entry(ref, &add->ctrl_refs, node) {
1553 struct v4l2_ctrl *ctrl = ref->ctrl;
1554
1555
1556 if (ctrl->is_private)
1557 continue;
1558
1559 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1560 continue;
1561
1562 if (filter && !filter(ctrl))
1563 continue;
1564 ret = handler_new_ref(hdl, ctrl, NULL, from_other_dev, false);
1565 if (ret)
1566 break;
1567 }
1568 mutex_unlock(add->lock);
1569 return ret;
1570}
1571EXPORT_SYMBOL(v4l2_ctrl_add_handler);
1572
1573bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
1574{
1575 if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
1576 return true;
1577 if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
1578 return true;
1579 switch (ctrl->id) {
1580 case V4L2_CID_AUDIO_MUTE:
1581 case V4L2_CID_AUDIO_VOLUME:
1582 case V4L2_CID_AUDIO_BALANCE:
1583 case V4L2_CID_AUDIO_BASS:
1584 case V4L2_CID_AUDIO_TREBLE:
1585 case V4L2_CID_AUDIO_LOUDNESS:
1586 return true;
1587 default:
1588 break;
1589 }
1590 return false;
1591}
1592EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
1593
1594
1595void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
1596{
1597 bool has_volatiles = false;
1598 int i;
1599
1600
1601 if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
1602 return;
1603
1604 for (i = 0; i < ncontrols; i++) {
1605 if (controls[i]) {
1606 controls[i]->cluster = controls;
1607 controls[i]->ncontrols = ncontrols;
1608 if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
1609 has_volatiles = true;
1610 }
1611 }
1612 controls[0]->has_volatiles = has_volatiles;
1613}
1614EXPORT_SYMBOL(v4l2_ctrl_cluster);
1615
1616void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
1617 u8 manual_val, bool set_volatile)
1618{
1619 struct v4l2_ctrl *master = controls[0];
1620 u32 flag = 0;
1621 int i;
1622
1623 v4l2_ctrl_cluster(ncontrols, controls);
1624 WARN_ON(ncontrols <= 1);
1625 WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
1626 WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
1627 master->is_auto = true;
1628 master->has_volatiles = set_volatile;
1629 master->manual_mode_value = manual_val;
1630 master->flags |= V4L2_CTRL_FLAG_UPDATE;
1631
1632 if (!is_cur_manual(master))
1633 flag = V4L2_CTRL_FLAG_INACTIVE |
1634 (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
1635
1636 for (i = 1; i < ncontrols; i++)
1637 if (controls[i])
1638 controls[i]->flags |= flag;
1639}
1640EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
1641
1642
1643
1644
1645
1646void update_from_auto_cluster(struct v4l2_ctrl *master)
1647{
1648 int i;
1649
1650 for (i = 1; i < master->ncontrols; i++)
1651 cur_to_new(master->cluster[i]);
1652 if (!call_op(master, g_volatile_ctrl))
1653 for (i = 1; i < master->ncontrols; i++)
1654 if (master->cluster[i])
1655 master->cluster[i]->is_new = 1;
1656}
1657
1658
1659
1660
1661
1662static int cluster_changed(struct v4l2_ctrl *master)
1663{
1664 bool changed = false;
1665 unsigned int idx;
1666 int i;
1667
1668 for (i = 0; i < master->ncontrols; i++) {
1669 struct v4l2_ctrl *ctrl = master->cluster[i];
1670 bool ctrl_changed = false;
1671
1672 if (!ctrl)
1673 continue;
1674
1675 if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE) {
1676 changed = true;
1677 ctrl_changed = true;
1678 }
1679
1680
1681
1682
1683
1684 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
1685 ctrl->has_changed = false;
1686 continue;
1687 }
1688
1689 for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++)
1690 ctrl_changed = !ctrl->type_ops->equal(ctrl, idx,
1691 ctrl->p_cur, ctrl->p_new);
1692 ctrl->has_changed = ctrl_changed;
1693 changed |= ctrl->has_changed;
1694 }
1695 return changed;
1696}
1697
1698
1699
1700
1701
1702
1703int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
1704 bool set, u32 ch_flags)
1705{
1706 bool update_flag;
1707 int ret;
1708 int i;
1709
1710
1711
1712
1713
1714
1715
1716 for (i = 0; i < master->ncontrols; i++) {
1717 struct v4l2_ctrl *ctrl = master->cluster[i];
1718
1719 if (!ctrl)
1720 continue;
1721
1722 if (!ctrl->is_new) {
1723 cur_to_new(ctrl);
1724 continue;
1725 }
1726
1727
1728
1729
1730 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
1731 return -EBUSY;
1732 }
1733
1734 ret = call_op(master, try_ctrl);
1735
1736
1737 if (ret || !set || !cluster_changed(master))
1738 return ret;
1739 ret = call_op(master, s_ctrl);
1740 if (ret)
1741 return ret;
1742
1743
1744 update_flag = is_cur_manual(master) != is_new_manual(master);
1745
1746 for (i = 0; i < master->ncontrols; i++) {
1747
1748
1749
1750
1751
1752
1753
1754 if (i && update_flag && is_new_manual(master) &&
1755 master->has_volatiles && master->cluster[i])
1756 master->cluster[i]->has_changed = true;
1757
1758 new_to_cur(fh, master->cluster[i], ch_flags |
1759 ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
1760 }
1761 return 0;
1762}
1763
1764
1765void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
1766{
1767
1768 bool inactive = !active;
1769 bool old;
1770
1771 if (ctrl == NULL)
1772 return;
1773
1774 if (inactive)
1775
1776 old = test_and_set_bit(4, &ctrl->flags);
1777 else
1778
1779 old = test_and_clear_bit(4, &ctrl->flags);
1780 if (old != inactive)
1781 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1782}
1783EXPORT_SYMBOL(v4l2_ctrl_activate);
1784
1785void __v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
1786{
1787 bool old;
1788
1789 if (ctrl == NULL)
1790 return;
1791
1792 lockdep_assert_held(ctrl->handler->lock);
1793
1794 if (grabbed)
1795
1796 old = test_and_set_bit(1, &ctrl->flags);
1797 else
1798
1799 old = test_and_clear_bit(1, &ctrl->flags);
1800 if (old != grabbed)
1801 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1802}
1803EXPORT_SYMBOL(__v4l2_ctrl_grab);
1804
1805
1806int __v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
1807{
1808 struct v4l2_ctrl *ctrl;
1809 int ret = 0;
1810
1811 if (hdl == NULL)
1812 return 0;
1813
1814 lockdep_assert_held(hdl->lock);
1815
1816 list_for_each_entry(ctrl, &hdl->ctrls, node)
1817 ctrl->done = false;
1818
1819 list_for_each_entry(ctrl, &hdl->ctrls, node) {
1820 struct v4l2_ctrl *master = ctrl->cluster[0];
1821 int i;
1822
1823
1824
1825 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
1826 (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
1827 continue;
1828
1829 for (i = 0; i < master->ncontrols; i++) {
1830 if (master->cluster[i]) {
1831 cur_to_new(master->cluster[i]);
1832 master->cluster[i]->is_new = 1;
1833 master->cluster[i]->done = true;
1834 }
1835 }
1836 ret = call_op(master, s_ctrl);
1837 if (ret)
1838 break;
1839 }
1840
1841 return ret;
1842}
1843EXPORT_SYMBOL_GPL(__v4l2_ctrl_handler_setup);
1844
1845int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
1846{
1847 int ret;
1848
1849 if (hdl == NULL)
1850 return 0;
1851
1852 mutex_lock(hdl->lock);
1853 ret = __v4l2_ctrl_handler_setup(hdl);
1854 mutex_unlock(hdl->lock);
1855
1856 return ret;
1857}
1858EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
1859
1860
1861static void log_ctrl(const struct v4l2_ctrl *ctrl,
1862 const char *prefix, const char *colon)
1863{
1864 if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
1865 return;
1866 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1867 return;
1868
1869 pr_info("%s%s%s: ", prefix, colon, ctrl->name);
1870
1871 ctrl->type_ops->log(ctrl);
1872
1873 if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
1874 V4L2_CTRL_FLAG_GRABBED |
1875 V4L2_CTRL_FLAG_VOLATILE)) {
1876 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
1877 pr_cont(" inactive");
1878 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
1879 pr_cont(" grabbed");
1880 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
1881 pr_cont(" volatile");
1882 }
1883 pr_cont("\n");
1884}
1885
1886
1887void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
1888 const char *prefix)
1889{
1890 struct v4l2_ctrl *ctrl;
1891 const char *colon = "";
1892 int len;
1893
1894 if (!hdl)
1895 return;
1896 if (!prefix)
1897 prefix = "";
1898 len = strlen(prefix);
1899 if (len && prefix[len - 1] != ' ')
1900 colon = ": ";
1901 mutex_lock(hdl->lock);
1902 list_for_each_entry(ctrl, &hdl->ctrls, node)
1903 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
1904 log_ctrl(ctrl, prefix, colon);
1905 mutex_unlock(hdl->lock);
1906}
1907EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
1908
1909int v4l2_ctrl_new_fwnode_properties(struct v4l2_ctrl_handler *hdl,
1910 const struct v4l2_ctrl_ops *ctrl_ops,
1911 const struct v4l2_fwnode_device_properties *p)
1912{
1913 if (p->orientation != V4L2_FWNODE_PROPERTY_UNSET) {
1914 u32 orientation_ctrl;
1915
1916 switch (p->orientation) {
1917 case V4L2_FWNODE_ORIENTATION_FRONT:
1918 orientation_ctrl = V4L2_CAMERA_ORIENTATION_FRONT;
1919 break;
1920 case V4L2_FWNODE_ORIENTATION_BACK:
1921 orientation_ctrl = V4L2_CAMERA_ORIENTATION_BACK;
1922 break;
1923 case V4L2_FWNODE_ORIENTATION_EXTERNAL:
1924 orientation_ctrl = V4L2_CAMERA_ORIENTATION_EXTERNAL;
1925 break;
1926 default:
1927 return -EINVAL;
1928 }
1929 if (!v4l2_ctrl_new_std_menu(hdl, ctrl_ops,
1930 V4L2_CID_CAMERA_ORIENTATION,
1931 V4L2_CAMERA_ORIENTATION_EXTERNAL, 0,
1932 orientation_ctrl))
1933 return hdl->error;
1934 }
1935
1936 if (p->rotation != V4L2_FWNODE_PROPERTY_UNSET) {
1937 if (!v4l2_ctrl_new_std(hdl, ctrl_ops,
1938 V4L2_CID_CAMERA_SENSOR_ROTATION,
1939 p->rotation, p->rotation, 1,
1940 p->rotation))
1941 return hdl->error;
1942 }
1943
1944 return hdl->error;
1945}
1946EXPORT_SYMBOL(v4l2_ctrl_new_fwnode_properties);
1947
