projects / openwrt / openwrt.git / blob
? search:


8a1c24f6cd9f39dae03d98053c5e2218a3b509e4
[openwrt/openwrt.git] / target / linux / bcm27xx / patches-5.15 / 950-0460-media-v4l2-Remove-v4l2-ctrls.c.patch
1 From 95280e5163ea457ccb442bc9d6c003c803d13894 Mon Sep 17 00:00:00 2001
2 From: John Cox <jc@kynesim.co.uk>
3 Date: Fri, 6 Aug 2021 10:47:11 +0100
4 Subject: [PATCH] media: v4l2: Remove v4l2-ctrls.c
5
6 v4l2-ctrls.c has been split into 4 files v4l2-ctrls-*.c, the original
7 is redundant, confusing and probably should have been removed by a
8 previous patch.
9
10 Signed-off-by: John Cox <jc@kynesim.co.uk>
11 ---
12 drivers/media/v4l2-core/v4l2-ctrls.c | 5046 --------------------------
13 1 file changed, 5046 deletions(-)
14 delete mode 100644 drivers/media/v4l2-core/v4l2-ctrls.c
15
16 --- a/drivers/media/v4l2-core/v4l2-ctrls.c
17 +++ /dev/null
18 @@ -1,5046 +0,0 @@
19 -// SPDX-License-Identifier: GPL-2.0-or-later
20 -/*
21 - V4L2 controls framework implementation.
22 -
23 - Copyright (C) 2010 Hans Verkuil <hverkuil@xs4all.nl>
24 -
25 - */
26 -
27 -#define pr_fmt(fmt) "v4l2-ctrls: " fmt
28 -
29 -#include <linux/ctype.h>
30 -#include <linux/export.h>
31 -#include <linux/mm.h>
32 -#include <linux/slab.h>
33 -#include <media/v4l2-ctrls.h>
34 -#include <media/v4l2-dev.h>
35 -#include <media/v4l2-device.h>
36 -#include <media/v4l2-event.h>
37 -#include <media/v4l2-fwnode.h>
38 -#include <media/v4l2-ioctl.h>
39 -
40 -#define dprintk(vdev, fmt, arg...) do { \
41 - if (!WARN_ON(!(vdev)) && ((vdev)->dev_debug & V4L2_DEV_DEBUG_CTRL)) \
42 - printk(KERN_DEBUG pr_fmt("%s: %s: " fmt), \
43 - __func__, video_device_node_name(vdev), ##arg); \
44 -} while (0)
45 -
46 -#define has_op(master, op) \
47 - (master->ops && master->ops->op)
48 -#define call_op(master, op) \
49 - (has_op(master, op) ? master->ops->op(master) : 0)
50 -
51 -static const union v4l2_ctrl_ptr ptr_null;
52 -
53 -/* Internal temporary helper struct, one for each v4l2_ext_control */
54 -struct v4l2_ctrl_helper {
55 - /* Pointer to the control reference of the master control */
56 - struct v4l2_ctrl_ref *mref;
57 - /* The control ref corresponding to the v4l2_ext_control ID field. */
58 - struct v4l2_ctrl_ref *ref;
59 - /* v4l2_ext_control index of the next control belonging to the
60 - same cluster, or 0 if there isn't any. */
61 - u32 next;
62 -};
63 -
64 -/* Small helper function to determine if the autocluster is set to manual
65 - mode. */
66 -static bool is_cur_manual(const struct v4l2_ctrl *master)
67 -{
68 - return master->is_auto && master->cur.val == master->manual_mode_value;
69 -}
70 -
71 -/* Same as above, but this checks the against the new value instead of the
72 - current value. */
73 -static bool is_new_manual(const struct v4l2_ctrl *master)
74 -{
75 - return master->is_auto && master->val == master->manual_mode_value;
76 -}
77 -
78 -/* Returns NULL or a character pointer array containing the menu for
79 - the given control ID. The pointer array ends with a NULL pointer.
80 - An empty string signifies a menu entry that is invalid. This allows
81 - drivers to disable certain options if it is not supported. */
82 -const char * const *v4l2_ctrl_get_menu(u32 id)
83 -{
84 - static const char * const mpeg_audio_sampling_freq[] = {
85 - "44.1 kHz",
86 - "48 kHz",
87 - "32 kHz",
88 - NULL
89 - };
90 - static const char * const mpeg_audio_encoding[] = {
91 - "MPEG-1/2 Layer I",
92 - "MPEG-1/2 Layer II",
93 - "MPEG-1/2 Layer III",
94 - "MPEG-2/4 AAC",
95 - "AC-3",
96 - NULL
97 - };
98 - static const char * const mpeg_audio_l1_bitrate[] = {
99 - "32 kbps",
100 - "64 kbps",
101 - "96 kbps",
102 - "128 kbps",
103 - "160 kbps",
104 - "192 kbps",
105 - "224 kbps",
106 - "256 kbps",
107 - "288 kbps",
108 - "320 kbps",
109 - "352 kbps",
110 - "384 kbps",
111 - "416 kbps",
112 - "448 kbps",
113 - NULL
114 - };
115 - static const char * const mpeg_audio_l2_bitrate[] = {
116 - "32 kbps",
117 - "48 kbps",
118 - "56 kbps",
119 - "64 kbps",
120 - "80 kbps",
121 - "96 kbps",
122 - "112 kbps",
123 - "128 kbps",
124 - "160 kbps",
125 - "192 kbps",
126 - "224 kbps",
127 - "256 kbps",
128 - "320 kbps",
129 - "384 kbps",
130 - NULL
131 - };
132 - static const char * const mpeg_audio_l3_bitrate[] = {
133 - "32 kbps",
134 - "40 kbps",
135 - "48 kbps",
136 - "56 kbps",
137 - "64 kbps",
138 - "80 kbps",
139 - "96 kbps",
140 - "112 kbps",
141 - "128 kbps",
142 - "160 kbps",
143 - "192 kbps",
144 - "224 kbps",
145 - "256 kbps",
146 - "320 kbps",
147 - NULL
148 - };
149 - static const char * const mpeg_audio_ac3_bitrate[] = {
150 - "32 kbps",
151 - "40 kbps",
152 - "48 kbps",
153 - "56 kbps",
154 - "64 kbps",
155 - "80 kbps",
156 - "96 kbps",
157 - "112 kbps",
158 - "128 kbps",
159 - "160 kbps",
160 - "192 kbps",
161 - "224 kbps",
162 - "256 kbps",
163 - "320 kbps",
164 - "384 kbps",
165 - "448 kbps",
166 - "512 kbps",
167 - "576 kbps",
168 - "640 kbps",
169 - NULL
170 - };
171 - static const char * const mpeg_audio_mode[] = {
172 - "Stereo",
173 - "Joint Stereo",
174 - "Dual",
175 - "Mono",
176 - NULL
177 - };
178 - static const char * const mpeg_audio_mode_extension[] = {
179 - "Bound 4",
180 - "Bound 8",
181 - "Bound 12",
182 - "Bound 16",
183 - NULL
184 - };
185 - static const char * const mpeg_audio_emphasis[] = {
186 - "No Emphasis",
187 - "50/15 us",
188 - "CCITT J17",
189 - NULL
190 - };
191 - static const char * const mpeg_audio_crc[] = {
192 - "No CRC",
193 - "16-bit CRC",
194 - NULL
195 - };
196 - static const char * const mpeg_audio_dec_playback[] = {
197 - "Auto",
198 - "Stereo",
199 - "Left",
200 - "Right",
201 - "Mono",
202 - "Swapped Stereo",
203 - NULL
204 - };
205 - static const char * const mpeg_video_encoding[] = {
206 - "MPEG-1",
207 - "MPEG-2",
208 - "MPEG-4 AVC",
209 - NULL
210 - };
211 - static const char * const mpeg_video_aspect[] = {
212 - "1x1",
213 - "4x3",
214 - "16x9",
215 - "2.21x1",
216 - NULL
217 - };
218 - static const char * const mpeg_video_bitrate_mode[] = {
219 - "Variable Bitrate",
220 - "Constant Bitrate",
221 - "Constant Quality",
222 - NULL
223 - };
224 - static const char * const mpeg_stream_type[] = {
225 - "MPEG-2 Program Stream",
226 - "MPEG-2 Transport Stream",
227 - "MPEG-1 System Stream",
228 - "MPEG-2 DVD-compatible Stream",
229 - "MPEG-1 VCD-compatible Stream",
230 - "MPEG-2 SVCD-compatible Stream",
231 - NULL
232 - };
233 - static const char * const mpeg_stream_vbi_fmt[] = {
234 - "No VBI",
235 - "Private Packet, IVTV Format",
236 - NULL
237 - };
238 - static const char * const camera_power_line_frequency[] = {
239 - "Disabled",
240 - "50 Hz",
241 - "60 Hz",
242 - "Auto",
243 - NULL
244 - };
245 - static const char * const camera_exposure_auto[] = {
246 - "Auto Mode",
247 - "Manual Mode",
248 - "Shutter Priority Mode",
249 - "Aperture Priority Mode",
250 - NULL
251 - };
252 - static const char * const camera_exposure_metering[] = {
253 - "Average",
254 - "Center Weighted",
255 - "Spot",
256 - "Matrix",
257 - NULL
258 - };
259 - static const char * const camera_auto_focus_range[] = {
260 - "Auto",
261 - "Normal",
262 - "Macro",
263 - "Infinity",
264 - NULL
265 - };
266 - static const char * const colorfx[] = {
267 - "None",
268 - "Black & White",
269 - "Sepia",
270 - "Negative",
271 - "Emboss",
272 - "Sketch",
273 - "Sky Blue",
274 - "Grass Green",
275 - "Skin Whiten",
276 - "Vivid",
277 - "Aqua",
278 - "Art Freeze",
279 - "Silhouette",
280 - "Solarization",
281 - "Antique",
282 - "Set Cb/Cr",
283 - NULL
284 - };
285 - static const char * const auto_n_preset_white_balance[] = {
286 - "Manual",
287 - "Auto",
288 - "Incandescent",
289 - "Fluorescent",
290 - "Fluorescent H",
291 - "Horizon",
292 - "Daylight",
293 - "Flash",
294 - "Cloudy",
295 - "Shade",
296 - "Greyworld",
297 - NULL,
298 - };
299 - static const char * const camera_iso_sensitivity_auto[] = {
300 - "Manual",
301 - "Auto",
302 - NULL
303 - };
304 - static const char * const scene_mode[] = {
305 - "None",
306 - "Backlight",
307 - "Beach/Snow",
308 - "Candle Light",
309 - "Dusk/Dawn",
310 - "Fall Colors",
311 - "Fireworks",
312 - "Landscape",
313 - "Night",
314 - "Party/Indoor",
315 - "Portrait",
316 - "Sports",
317 - "Sunset",
318 - "Text",
319 - NULL
320 - };
321 - static const char * const tune_emphasis[] = {
322 - "None",
323 - "50 Microseconds",
324 - "75 Microseconds",
325 - NULL,
326 - };
327 - static const char * const header_mode[] = {
328 - "Separate Buffer",
329 - "Joined With 1st Frame",
330 - NULL,
331 - };
332 - static const char * const multi_slice[] = {
333 - "Single",
334 - "Max Macroblocks",
335 - "Max Bytes",
336 - NULL,
337 - };
338 - static const char * const entropy_mode[] = {
339 - "CAVLC",
340 - "CABAC",
341 - NULL,
342 - };
343 - static const char * const mpeg_h264_level[] = {
344 - "1",
345 - "1b",
346 - "1.1",
347 - "1.2",
348 - "1.3",
349 - "2",
350 - "2.1",
351 - "2.2",
352 - "3",
353 - "3.1",
354 - "3.2",
355 - "4",
356 - "4.1",
357 - "4.2",
358 - "5",
359 - "5.1",
360 - "5.2",
361 - "6.0",
362 - "6.1",
363 - "6.2",
364 - NULL,
365 - };
366 - static const char * const h264_loop_filter[] = {
367 - "Enabled",
368 - "Disabled",
369 - "Disabled at Slice Boundary",
370 - NULL,
371 - };
372 - static const char * const h264_profile[] = {
373 - "Baseline",
374 - "Constrained Baseline",
375 - "Main",
376 - "Extended",
377 - "High",
378 - "High 10",
379 - "High 422",
380 - "High 444 Predictive",
381 - "High 10 Intra",
382 - "High 422 Intra",
383 - "High 444 Intra",
384 - "CAVLC 444 Intra",
385 - "Scalable Baseline",
386 - "Scalable High",
387 - "Scalable High Intra",
388 - "Stereo High",
389 - "Multiview High",
390 - "Constrained High",
391 - NULL,
392 - };
393 - static const char * const vui_sar_idc[] = {
394 - "Unspecified",
395 - "1:1",
396 - "12:11",
397 - "10:11",
398 - "16:11",
399 - "40:33",
400 - "24:11",
401 - "20:11",
402 - "32:11",
403 - "80:33",
404 - "18:11",
405 - "15:11",
406 - "64:33",
407 - "160:99",
408 - "4:3",
409 - "3:2",
410 - "2:1",
411 - "Extended SAR",
412 - NULL,
413 - };
414 - static const char * const h264_fp_arrangement_type[] = {
415 - "Checkerboard",
416 - "Column",
417 - "Row",
418 - "Side by Side",
419 - "Top Bottom",
420 - "Temporal",
421 - NULL,
422 - };
423 - static const char * const h264_fmo_map_type[] = {
424 - "Interleaved Slices",
425 - "Scattered Slices",
426 - "Foreground with Leftover",
427 - "Box Out",
428 - "Raster Scan",
429 - "Wipe Scan",
430 - "Explicit",
431 - NULL,
432 - };
433 - static const char * const h264_decode_mode[] = {
434 - "Slice-Based",
435 - "Frame-Based",
436 - NULL,
437 - };
438 - static const char * const h264_start_code[] = {
439 - "No Start Code",
440 - "Annex B Start Code",
441 - NULL,
442 - };
443 - static const char * const h264_hierarchical_coding_type[] = {
444 - "Hier Coding B",
445 - "Hier Coding P",
446 - NULL,
447 - };
448 - static const char * const mpeg_mpeg2_level[] = {
449 - "Low",
450 - "Main",
451 - "High 1440",
452 - "High",
453 - NULL,
454 - };
455 - static const char * const mpeg2_profile[] = {
456 - "Simple",
457 - "Main",
458 - "SNR Scalable",
459 - "Spatially Scalable",
460 - "High",
461 - NULL,
462 - };
463 - static const char * const mpeg_mpeg4_level[] = {
464 - "0",
465 - "0b",
466 - "1",
467 - "2",
468 - "3",
469 - "3b",
470 - "4",
471 - "5",
472 - NULL,
473 - };
474 - static const char * const mpeg4_profile[] = {
475 - "Simple",
476 - "Advanced Simple",
477 - "Core",
478 - "Simple Scalable",
479 - "Advanced Coding Efficiency",
480 - NULL,
481 - };
482 -
483 - static const char * const vpx_golden_frame_sel[] = {
484 - "Use Previous Frame",
485 - "Use Previous Specific Frame",
486 - NULL,
487 - };
488 - static const char * const vp8_profile[] = {
489 - "0",
490 - "1",
491 - "2",
492 - "3",
493 - NULL,
494 - };
495 - static const char * const vp9_profile[] = {
496 - "0",
497 - "1",
498 - "2",
499 - "3",
500 - NULL,
501 - };
502 - static const char * const vp9_level[] = {
503 - "1",
504 - "1.1",
505 - "2",
506 - "2.1",
507 - "3",
508 - "3.1",
509 - "4",
510 - "4.1",
511 - "5",
512 - "5.1",
513 - "5.2",
514 - "6",
515 - "6.1",
516 - "6.2",
517 - NULL,
518 - };
519 -
520 - static const char * const flash_led_mode[] = {
521 - "Off",
522 - "Flash",
523 - "Torch",
524 - NULL,
525 - };
526 - static const char * const flash_strobe_source[] = {
527 - "Software",
528 - "External",
529 - NULL,
530 - };
531 -
532 - static const char * const jpeg_chroma_subsampling[] = {
533 - "4:4:4",
534 - "4:2:2",
535 - "4:2:0",
536 - "4:1:1",
537 - "4:1:0",
538 - "Gray",
539 - NULL,
540 - };
541 - static const char * const dv_tx_mode[] = {
542 - "DVI-D",
543 - "HDMI",
544 - NULL,
545 - };
546 - static const char * const dv_rgb_range[] = {
547 - "Automatic",
548 - "RGB Limited Range (16-235)",
549 - "RGB Full Range (0-255)",
550 - NULL,
551 - };
552 - static const char * const dv_it_content_type[] = {
553 - "Graphics",
554 - "Photo",
555 - "Cinema",
556 - "Game",
557 - "No IT Content",
558 - NULL,
559 - };
560 - static const char * const detect_md_mode[] = {
561 - "Disabled",
562 - "Global",
563 - "Threshold Grid",
564 - "Region Grid",
565 - NULL,
566 - };
567 -
568 - static const char * const hevc_profile[] = {
569 - "Main",
570 - "Main Still Picture",
571 - "Main 10",
572 - NULL,
573 - };
574 - static const char * const hevc_level[] = {
575 - "1",
576 - "2",
577 - "2.1",
578 - "3",
579 - "3.1",
580 - "4",
581 - "4.1",
582 - "5",
583 - "5.1",
584 - "5.2",
585 - "6",
586 - "6.1",
587 - "6.2",
588 - NULL,
589 - };
590 - static const char * const hevc_hierarchial_coding_type[] = {
591 - "B",
592 - "P",
593 - NULL,
594 - };
595 - static const char * const hevc_refresh_type[] = {
596 - "None",
597 - "CRA",
598 - "IDR",
599 - NULL,
600 - };
601 - static const char * const hevc_size_of_length_field[] = {
602 - "0",
603 - "1",
604 - "2",
605 - "4",
606 - NULL,
607 - };
608 - static const char * const hevc_tier[] = {
609 - "Main",
610 - "High",
611 - NULL,
612 - };
613 - static const char * const hevc_loop_filter_mode[] = {
614 - "Disabled",
615 - "Enabled",
616 - "Disabled at slice boundary",
617 - "NULL",
618 - };
619 - static const char * const hevc_decode_mode[] = {
620 - "Slice-Based",
621 - "Frame-Based",
622 - NULL,
623 - };
624 - static const char * const hevc_start_code[] = {
625 - "No Start Code",
626 - "Annex B Start Code",
627 - NULL,
628 - };
629 - static const char * const camera_orientation[] = {
630 - "Front",
631 - "Back",
632 - "External",
633 - NULL,
634 - };
635 - static const char * const mpeg_video_frame_skip[] = {
636 - "Disabled",
637 - "Level Limit",
638 - "VBV/CPB Limit",
639 - NULL,
640 - };
641 -
642 - switch (id) {
643 - case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
644 - return mpeg_audio_sampling_freq;
645 - case V4L2_CID_MPEG_AUDIO_ENCODING:
646 - return mpeg_audio_encoding;
647 - case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
648 - return mpeg_audio_l1_bitrate;
649 - case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
650 - return mpeg_audio_l2_bitrate;
651 - case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
652 - return mpeg_audio_l3_bitrate;
653 - case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
654 - return mpeg_audio_ac3_bitrate;
655 - case V4L2_CID_MPEG_AUDIO_MODE:
656 - return mpeg_audio_mode;
657 - case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
658 - return mpeg_audio_mode_extension;
659 - case V4L2_CID_MPEG_AUDIO_EMPHASIS:
660 - return mpeg_audio_emphasis;
661 - case V4L2_CID_MPEG_AUDIO_CRC:
662 - return mpeg_audio_crc;
663 - case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
664 - case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
665 - return mpeg_audio_dec_playback;
666 - case V4L2_CID_MPEG_VIDEO_ENCODING:
667 - return mpeg_video_encoding;
668 - case V4L2_CID_MPEG_VIDEO_ASPECT:
669 - return mpeg_video_aspect;
670 - case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
671 - return mpeg_video_bitrate_mode;
672 - case V4L2_CID_MPEG_STREAM_TYPE:
673 - return mpeg_stream_type;
674 - case V4L2_CID_MPEG_STREAM_VBI_FMT:
675 - return mpeg_stream_vbi_fmt;
676 - case V4L2_CID_POWER_LINE_FREQUENCY:
677 - return camera_power_line_frequency;
678 - case V4L2_CID_EXPOSURE_AUTO:
679 - return camera_exposure_auto;
680 - case V4L2_CID_EXPOSURE_METERING:
681 - return camera_exposure_metering;
682 - case V4L2_CID_AUTO_FOCUS_RANGE:
683 - return camera_auto_focus_range;
684 - case V4L2_CID_COLORFX:
685 - return colorfx;
686 - case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
687 - return auto_n_preset_white_balance;
688 - case V4L2_CID_ISO_SENSITIVITY_AUTO:
689 - return camera_iso_sensitivity_auto;
690 - case V4L2_CID_SCENE_MODE:
691 - return scene_mode;
692 - case V4L2_CID_TUNE_PREEMPHASIS:
693 - return tune_emphasis;
694 - case V4L2_CID_TUNE_DEEMPHASIS:
695 - return tune_emphasis;
696 - case V4L2_CID_FLASH_LED_MODE:
697 - return flash_led_mode;
698 - case V4L2_CID_FLASH_STROBE_SOURCE:
699 - return flash_strobe_source;
700 - case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
701 - return header_mode;
702 - case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE:
703 - return mpeg_video_frame_skip;
704 - case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
705 - return multi_slice;
706 - case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
707 - return entropy_mode;
708 - case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
709 - return mpeg_h264_level;
710 - case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
711 - return h264_loop_filter;
712 - case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
713 - return h264_profile;
714 - case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
715 - return vui_sar_idc;
716 - case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
717 - return h264_fp_arrangement_type;
718 - case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
719 - return h264_fmo_map_type;
720 - case V4L2_CID_STATELESS_H264_DECODE_MODE:
721 - return h264_decode_mode;
722 - case V4L2_CID_STATELESS_H264_START_CODE:
723 - return h264_start_code;
724 - case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE:
725 - return h264_hierarchical_coding_type;
726 - case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:
727 - return mpeg_mpeg2_level;
728 - case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE:
729 - return mpeg2_profile;
730 - case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
731 - return mpeg_mpeg4_level;
732 - case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
733 - return mpeg4_profile;
734 - case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
735 - return vpx_golden_frame_sel;
736 - case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
737 - return vp8_profile;
738 - case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:
739 - return vp9_profile;
740 - case V4L2_CID_MPEG_VIDEO_VP9_LEVEL:
741 - return vp9_level;
742 - case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
743 - return jpeg_chroma_subsampling;
744 - case V4L2_CID_DV_TX_MODE:
745 - return dv_tx_mode;
746 - case V4L2_CID_DV_TX_RGB_RANGE:
747 - case V4L2_CID_DV_RX_RGB_RANGE:
748 - return dv_rgb_range;
749 - case V4L2_CID_DV_TX_IT_CONTENT_TYPE:
750 - case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
751 - return dv_it_content_type;
752 - case V4L2_CID_DETECT_MD_MODE:
753 - return detect_md_mode;
754 - case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
755 - return hevc_profile;
756 - case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
757 - return hevc_level;
758 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:
759 - return hevc_hierarchial_coding_type;
760 - case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE:
761 - return hevc_refresh_type;
762 - case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:
763 - return hevc_size_of_length_field;
764 - case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
765 - return hevc_tier;
766 - case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:
767 - return hevc_loop_filter_mode;
768 - case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE:
769 - return hevc_decode_mode;
770 - case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE:
771 - return hevc_start_code;
772 - case V4L2_CID_CAMERA_ORIENTATION:
773 - return camera_orientation;
774 - default:
775 - return NULL;
776 - }
777 -}
778 -EXPORT_SYMBOL(v4l2_ctrl_get_menu);
779 -
780 -#define __v4l2_qmenu_int_len(arr, len) ({ *(len) = ARRAY_SIZE(arr); arr; })
781 -/*
782 - * Returns NULL or an s64 type array containing the menu for given
783 - * control ID. The total number of the menu items is returned in @len.
784 - */
785 -const s64 *v4l2_ctrl_get_int_menu(u32 id, u32 *len)
786 -{
787 - static const s64 qmenu_int_vpx_num_partitions[] = {
788 - 1, 2, 4, 8,
789 - };
790 -
791 - static const s64 qmenu_int_vpx_num_ref_frames[] = {
792 - 1, 2, 3,
793 - };
794 -
795 - switch (id) {
796 - case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
797 - return __v4l2_qmenu_int_len(qmenu_int_vpx_num_partitions, len);
798 - case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
799 - return __v4l2_qmenu_int_len(qmenu_int_vpx_num_ref_frames, len);
800 - default:
801 - *len = 0;
802 - return NULL;
803 - }
804 -}
805 -EXPORT_SYMBOL(v4l2_ctrl_get_int_menu);
806 -
807 -/* Return the control name. */
808 -const char *v4l2_ctrl_get_name(u32 id)
809 -{
810 - switch (id) {
811 - /* USER controls */
812 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
813 - case V4L2_CID_USER_CLASS: return "User Controls";
814 - case V4L2_CID_BRIGHTNESS: return "Brightness";
815 - case V4L2_CID_CONTRAST: return "Contrast";
816 - case V4L2_CID_SATURATION: return "Saturation";
817 - case V4L2_CID_HUE: return "Hue";
818 - case V4L2_CID_AUDIO_VOLUME: return "Volume";
819 - case V4L2_CID_AUDIO_BALANCE: return "Balance";
820 - case V4L2_CID_AUDIO_BASS: return "Bass";
821 - case V4L2_CID_AUDIO_TREBLE: return "Treble";
822 - case V4L2_CID_AUDIO_MUTE: return "Mute";
823 - case V4L2_CID_AUDIO_LOUDNESS: return "Loudness";
824 - case V4L2_CID_BLACK_LEVEL: return "Black Level";
825 - case V4L2_CID_AUTO_WHITE_BALANCE: return "White Balance, Automatic";
826 - case V4L2_CID_DO_WHITE_BALANCE: return "Do White Balance";
827 - case V4L2_CID_RED_BALANCE: return "Red Balance";
828 - case V4L2_CID_BLUE_BALANCE: return "Blue Balance";
829 - case V4L2_CID_GAMMA: return "Gamma";
830 - case V4L2_CID_EXPOSURE: return "Exposure";
831 - case V4L2_CID_AUTOGAIN: return "Gain, Automatic";
832 - case V4L2_CID_GAIN: return "Gain";
833 - case V4L2_CID_HFLIP: return "Horizontal Flip";
834 - case V4L2_CID_VFLIP: return "Vertical Flip";
835 - case V4L2_CID_POWER_LINE_FREQUENCY: return "Power Line Frequency";
836 - case V4L2_CID_HUE_AUTO: return "Hue, Automatic";
837 - case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
838 - case V4L2_CID_SHARPNESS: return "Sharpness";
839 - case V4L2_CID_BACKLIGHT_COMPENSATION: return "Backlight Compensation";
840 - case V4L2_CID_CHROMA_AGC: return "Chroma AGC";
841 - case V4L2_CID_COLOR_KILLER: return "Color Killer";
842 - case V4L2_CID_COLORFX: return "Color Effects";
843 - case V4L2_CID_AUTOBRIGHTNESS: return "Brightness, Automatic";
844 - case V4L2_CID_BAND_STOP_FILTER: return "Band-Stop Filter";
845 - case V4L2_CID_ROTATE: return "Rotate";
846 - case V4L2_CID_BG_COLOR: return "Background Color";
847 - case V4L2_CID_CHROMA_GAIN: return "Chroma Gain";
848 - case V4L2_CID_ILLUMINATORS_1: return "Illuminator 1";
849 - case V4L2_CID_ILLUMINATORS_2: return "Illuminator 2";
850 - case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE: return "Min Number of Capture Buffers";
851 - case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT: return "Min Number of Output Buffers";
852 - case V4L2_CID_ALPHA_COMPONENT: return "Alpha Component";
853 - case V4L2_CID_COLORFX_CBCR: return "Color Effects, CbCr";
854 -
855 - /* Codec controls */
856 - /* The MPEG controls are applicable to all codec controls
857 - * and the 'MPEG' part of the define is historical */
858 - /* Keep the order of the 'case's the same as in videodev2.h! */
859 - case V4L2_CID_CODEC_CLASS: return "Codec Controls";
860 - case V4L2_CID_MPEG_STREAM_TYPE: return "Stream Type";
861 - case V4L2_CID_MPEG_STREAM_PID_PMT: return "Stream PMT Program ID";
862 - case V4L2_CID_MPEG_STREAM_PID_AUDIO: return "Stream Audio Program ID";
863 - case V4L2_CID_MPEG_STREAM_PID_VIDEO: return "Stream Video Program ID";
864 - case V4L2_CID_MPEG_STREAM_PID_PCR: return "Stream PCR Program ID";
865 - case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
866 - case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
867 - case V4L2_CID_MPEG_STREAM_VBI_FMT: return "Stream VBI Format";
868 - case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
869 - case V4L2_CID_MPEG_AUDIO_ENCODING: return "Audio Encoding";
870 - case V4L2_CID_MPEG_AUDIO_L1_BITRATE: return "Audio Layer I Bitrate";
871 - case V4L2_CID_MPEG_AUDIO_L2_BITRATE: return "Audio Layer II Bitrate";
872 - case V4L2_CID_MPEG_AUDIO_L3_BITRATE: return "Audio Layer III Bitrate";
873 - case V4L2_CID_MPEG_AUDIO_MODE: return "Audio Stereo Mode";
874 - case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
875 - case V4L2_CID_MPEG_AUDIO_EMPHASIS: return "Audio Emphasis";
876 - case V4L2_CID_MPEG_AUDIO_CRC: return "Audio CRC";
877 - case V4L2_CID_MPEG_AUDIO_MUTE: return "Audio Mute";
878 - case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate";
879 - case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: return "Audio AC-3 Bitrate";
880 - case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK: return "Audio Playback";
881 - case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: return "Audio Multilingual Playback";
882 - case V4L2_CID_MPEG_VIDEO_ENCODING: return "Video Encoding";
883 - case V4L2_CID_MPEG_VIDEO_ASPECT: return "Video Aspect";
884 - case V4L2_CID_MPEG_VIDEO_B_FRAMES: return "Video B Frames";
885 - case V4L2_CID_MPEG_VIDEO_GOP_SIZE: return "Video GOP Size";
886 - case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: return "Video GOP Closure";
887 - case V4L2_CID_MPEG_VIDEO_PULLDOWN: return "Video Pulldown";
888 - case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: return "Video Bitrate Mode";
889 - case V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY: return "Constant Quality";
890 - case V4L2_CID_MPEG_VIDEO_BITRATE: return "Video Bitrate";
891 - case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: return "Video Peak Bitrate";
892 - case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
893 - case V4L2_CID_MPEG_VIDEO_MUTE: return "Video Mute";
894 - case V4L2_CID_MPEG_VIDEO_MUTE_YUV: return "Video Mute YUV";
895 - case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE: return "Decoder Slice Interface";
896 - case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER: return "MPEG4 Loop Filter Enable";
897 - case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB: return "Number of Intra Refresh MBs";
898 - case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE: return "Frame Level Rate Control Enable";
899 - case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE: return "H264 MB Level Rate Control";
900 - case V4L2_CID_MPEG_VIDEO_HEADER_MODE: return "Sequence Header Mode";
901 - case V4L2_CID_MPEG_VIDEO_MAX_REF_PIC: return "Max Number of Reference Pics";
902 - case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE: return "Frame Skip Mode";
903 - case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY: return "Display Delay";
904 - case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE: return "Display Delay Enable";
905 - case V4L2_CID_MPEG_VIDEO_AU_DELIMITER: return "Generate Access Unit Delimiters";
906 - case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP: return "H263 I-Frame QP Value";
907 - case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP: return "H263 P-Frame QP Value";
908 - case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP: return "H263 B-Frame QP Value";
909 - case V4L2_CID_MPEG_VIDEO_H263_MIN_QP: return "H263 Minimum QP Value";
910 - case V4L2_CID_MPEG_VIDEO_H263_MAX_QP: return "H263 Maximum QP Value";
911 - case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP: return "H264 I-Frame QP Value";
912 - case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP: return "H264 P-Frame QP Value";
913 - case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP: return "H264 B-Frame QP Value";
914 - case V4L2_CID_MPEG_VIDEO_H264_MAX_QP: return "H264 Maximum QP Value";
915 - case V4L2_CID_MPEG_VIDEO_H264_MIN_QP: return "H264 Minimum QP Value";
916 - case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM: return "H264 8x8 Transform Enable";
917 - case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE: return "H264 CPB Buffer Size";
918 - case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE: return "H264 Entropy Mode";
919 - case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD: return "H264 I-Frame Period";
920 - case V4L2_CID_MPEG_VIDEO_H264_LEVEL: return "H264 Level";
921 - case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA: return "H264 Loop Filter Alpha Offset";
922 - case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA: return "H264 Loop Filter Beta Offset";
923 - case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE: return "H264 Loop Filter Mode";
924 - case V4L2_CID_MPEG_VIDEO_H264_PROFILE: return "H264 Profile";
925 - case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT: return "Vertical Size of SAR";
926 - case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH: return "Horizontal Size of SAR";
927 - case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE: return "Aspect Ratio VUI Enable";
928 - case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC: return "VUI Aspect Ratio IDC";
929 - case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING: return "H264 Enable Frame Packing SEI";
930 - case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0: return "H264 Set Curr. Frame as Frame0";
931 - case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE: return "H264 FP Arrangement Type";
932 - case V4L2_CID_MPEG_VIDEO_H264_FMO: return "H264 Flexible MB Ordering";
933 - case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE: return "H264 Map Type for FMO";
934 - case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP: return "H264 FMO Number of Slice Groups";
935 - case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION: return "H264 FMO Direction of Change";
936 - case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE: return "H264 FMO Size of 1st Slice Grp";
937 - case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH: return "H264 FMO No. of Consecutive MBs";
938 - case V4L2_CID_MPEG_VIDEO_H264_ASO: return "H264 Arbitrary Slice Ordering";
939 - case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER: return "H264 ASO Slice Order";
940 - case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING: return "Enable H264 Hierarchical Coding";
941 - case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE: return "H264 Hierarchical Coding Type";
942 - case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:return "H264 Number of HC Layers";
943 - case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP:
944 - return "H264 Set QP Value for HC Layers";
945 - case V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION:
946 - return "H264 Constrained Intra Pred";
947 - case V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET: return "H264 Chroma QP Index Offset";
948 - case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP: return "H264 I-Frame Minimum QP Value";
949 - case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP: return "H264 I-Frame Maximum QP Value";
950 - case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP: return "H264 P-Frame Minimum QP Value";
951 - case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP: return "H264 P-Frame Maximum QP Value";
952 - case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MIN_QP: return "H264 B-Frame Minimum QP Value";
953 - case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MAX_QP: return "H264 B-Frame Maximum QP Value";
954 - case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L0_BR: return "H264 Hierarchical Lay 0 Bitrate";
955 - case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L1_BR: return "H264 Hierarchical Lay 1 Bitrate";
956 - case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L2_BR: return "H264 Hierarchical Lay 2 Bitrate";
957 - case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L3_BR: return "H264 Hierarchical Lay 3 Bitrate";
958 - case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L4_BR: return "H264 Hierarchical Lay 4 Bitrate";
959 - case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L5_BR: return "H264 Hierarchical Lay 5 Bitrate";
960 - case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L6_BR: return "H264 Hierarchical Lay 6 Bitrate";
961 - case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL: return "MPEG2 Level";
962 - case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE: return "MPEG2 Profile";
963 - case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP: return "MPEG4 I-Frame QP Value";
964 - case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP: return "MPEG4 P-Frame QP Value";
965 - case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP: return "MPEG4 B-Frame QP Value";
966 - case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP: return "MPEG4 Minimum QP Value";
967 - case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP: return "MPEG4 Maximum QP Value";
968 - case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL: return "MPEG4 Level";
969 - case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE: return "MPEG4 Profile";
970 - case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL: return "Quarter Pixel Search Enable";
971 - case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES: return "Maximum Bytes in a Slice";
972 - case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB: return "Number of MBs in a Slice";
973 - case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: return "Slice Partitioning Method";
974 - case V4L2_CID_MPEG_VIDEO_VBV_SIZE: return "VBV Buffer Size";
975 - case V4L2_CID_MPEG_VIDEO_DEC_PTS: return "Video Decoder PTS";
976 - case V4L2_CID_MPEG_VIDEO_DEC_FRAME: return "Video Decoder Frame Count";
977 - case V4L2_CID_MPEG_VIDEO_DEC_CONCEAL_COLOR: return "Video Decoder Conceal Color";
978 - case V4L2_CID_MPEG_VIDEO_VBV_DELAY: return "Initial Delay for VBV Control";
979 - case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE: return "Horizontal MV Search Range";
980 - case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE: return "Vertical MV Search Range";
981 - case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER: return "Repeat Sequence Header";
982 - case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME: return "Force Key Frame";
983 - case V4L2_CID_MPEG_VIDEO_BASELAYER_PRIORITY_ID: return "Base Layer Priority ID";
984 - case V4L2_CID_MPEG_VIDEO_LTR_COUNT: return "LTR Count";
985 - case V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX: return "Frame LTR Index";
986 - case V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES: return "Use LTR Frames";
987 - case V4L2_CID_MPEG_VIDEO_MPEG2_SLICE_PARAMS: return "MPEG-2 Slice Parameters";
988 - case V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION: return "MPEG-2 Quantization Matrices";
989 - case V4L2_CID_FWHT_I_FRAME_QP: return "FWHT I-Frame QP Value";
990 - case V4L2_CID_FWHT_P_FRAME_QP: return "FWHT P-Frame QP Value";
991 -
992 - /* VPX controls */
993 - case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS: return "VPX Number of Partitions";
994 - case V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4: return "VPX Intra Mode Decision Disable";
995 - case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES: return "VPX No. of Refs for P Frame";
996 - case V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL: return "VPX Loop Filter Level Range";
997 - case V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS: return "VPX Deblocking Effect Control";
998 - case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD: return "VPX Golden Frame Refresh Period";
999 - case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL: return "VPX Golden Frame Indicator";
1000 - case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP: return "VPX Minimum QP Value";
1001 - case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP: return "VPX Maximum QP Value";
1002 - case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP: return "VPX I-Frame QP Value";
1003 - case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP: return "VPX P-Frame QP Value";
1004 - case V4L2_CID_MPEG_VIDEO_VP8_PROFILE: return "VP8 Profile";
1005 - case V4L2_CID_MPEG_VIDEO_VP9_PROFILE: return "VP9 Profile";
1006 - case V4L2_CID_MPEG_VIDEO_VP9_LEVEL: return "VP9 Level";
1007 -
1008 - /* HEVC controls */
1009 - case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP: return "HEVC I-Frame QP Value";
1010 - case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP: return "HEVC P-Frame QP Value";
1011 - case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP: return "HEVC B-Frame QP Value";
1012 - case V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP: return "HEVC Minimum QP Value";
1013 - case V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP: return "HEVC Maximum QP Value";
1014 - case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MIN_QP: return "HEVC I-Frame Minimum QP Value";
1015 - case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MAX_QP: return "HEVC I-Frame Maximum QP Value";
1016 - case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MIN_QP: return "HEVC P-Frame Minimum QP Value";
1017 - case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MAX_QP: return "HEVC P-Frame Maximum QP Value";
1018 - case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MIN_QP: return "HEVC B-Frame Minimum QP Value";
1019 - case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MAX_QP: return "HEVC B-Frame Maximum QP Value";
1020 - case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE: return "HEVC Profile";
1021 - case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL: return "HEVC Level";
1022 - case V4L2_CID_MPEG_VIDEO_HEVC_TIER: return "HEVC Tier";
1023 - case V4L2_CID_MPEG_VIDEO_HEVC_FRAME_RATE_RESOLUTION: return "HEVC Frame Rate Resolution";
1024 - case V4L2_CID_MPEG_VIDEO_HEVC_MAX_PARTITION_DEPTH: return "HEVC Maximum Coding Unit Depth";
1025 - case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE: return "HEVC Refresh Type";
1026 - case V4L2_CID_MPEG_VIDEO_HEVC_CONST_INTRA_PRED: return "HEVC Constant Intra Prediction";
1027 - case V4L2_CID_MPEG_VIDEO_HEVC_LOSSLESS_CU: return "HEVC Lossless Encoding";
1028 - case V4L2_CID_MPEG_VIDEO_HEVC_WAVEFRONT: return "HEVC Wavefront";
1029 - case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE: return "HEVC Loop Filter";
1030 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_QP: return "HEVC QP Values";
1031 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE: return "HEVC Hierarchical Coding Type";
1032 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER: return "HEVC Hierarchical Coding Layer";
1033 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_QP: return "HEVC Hierarchical Layer 0 QP";
1034 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_QP: return "HEVC Hierarchical Layer 1 QP";
1035 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_QP: return "HEVC Hierarchical Layer 2 QP";
1036 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_QP: return "HEVC Hierarchical Layer 3 QP";
1037 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_QP: return "HEVC Hierarchical Layer 4 QP";
1038 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_QP: return "HEVC Hierarchical Layer 5 QP";
1039 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_QP: return "HEVC Hierarchical Layer 6 QP";
1040 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_BR: return "HEVC Hierarchical Lay 0 BitRate";
1041 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_BR: return "HEVC Hierarchical Lay 1 BitRate";
1042 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_BR: return "HEVC Hierarchical Lay 2 BitRate";
1043 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_BR: return "HEVC Hierarchical Lay 3 BitRate";
1044 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_BR: return "HEVC Hierarchical Lay 4 BitRate";
1045 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_BR: return "HEVC Hierarchical Lay 5 BitRate";
1046 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_BR: return "HEVC Hierarchical Lay 6 BitRate";
1047 - case V4L2_CID_MPEG_VIDEO_HEVC_GENERAL_PB: return "HEVC General PB";
1048 - case V4L2_CID_MPEG_VIDEO_HEVC_TEMPORAL_ID: return "HEVC Temporal ID";
1049 - case V4L2_CID_MPEG_VIDEO_HEVC_STRONG_SMOOTHING: return "HEVC Strong Intra Smoothing";
1050 - case V4L2_CID_MPEG_VIDEO_HEVC_INTRA_PU_SPLIT: return "HEVC Intra PU Split";
1051 - case V4L2_CID_MPEG_VIDEO_HEVC_TMV_PREDICTION: return "HEVC TMV Prediction";
1052 - case V4L2_CID_MPEG_VIDEO_HEVC_MAX_NUM_MERGE_MV_MINUS1: return "HEVC Max Num of Candidate MVs";
1053 - case V4L2_CID_MPEG_VIDEO_HEVC_WITHOUT_STARTCODE: return "HEVC ENC Without Startcode";
1054 - case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_PERIOD: return "HEVC Num of I-Frame b/w 2 IDR";
1055 - case V4L2_CID_MPEG_VIDEO_HEVC_LF_BETA_OFFSET_DIV2: return "HEVC Loop Filter Beta Offset";
1056 - case V4L2_CID_MPEG_VIDEO_HEVC_LF_TC_OFFSET_DIV2: return "HEVC Loop Filter TC Offset";
1057 - case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD: return "HEVC Size of Length Field";
1058 - case V4L2_CID_MPEG_VIDEO_REF_NUMBER_FOR_PFRAMES: return "Reference Frames for a P-Frame";
1059 - case V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR: return "Prepend SPS and PPS to IDR";
1060 - case V4L2_CID_MPEG_VIDEO_HEVC_SPS: return "HEVC Sequence Parameter Set";
1061 - case V4L2_CID_MPEG_VIDEO_HEVC_PPS: return "HEVC Picture Parameter Set";
1062 - case V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS: return "HEVC Slice Parameters";
1063 - case V4L2_CID_MPEG_VIDEO_HEVC_SCALING_MATRIX: return "HEVC Scaling Matrix";
1064 - case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE: return "HEVC Decode Mode";
1065 - case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE: return "HEVC Start Code";
1066 -
1067 - /* CAMERA controls */
1068 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1069 - case V4L2_CID_CAMERA_CLASS: return "Camera Controls";
1070 - case V4L2_CID_EXPOSURE_AUTO: return "Auto Exposure";
1071 - case V4L2_CID_EXPOSURE_ABSOLUTE: return "Exposure Time, Absolute";
1072 - case V4L2_CID_EXPOSURE_AUTO_PRIORITY: return "Exposure, Dynamic Framerate";
1073 - case V4L2_CID_PAN_RELATIVE: return "Pan, Relative";
1074 - case V4L2_CID_TILT_RELATIVE: return "Tilt, Relative";
1075 - case V4L2_CID_PAN_RESET: return "Pan, Reset";
1076 - case V4L2_CID_TILT_RESET: return "Tilt, Reset";
1077 - case V4L2_CID_PAN_ABSOLUTE: return "Pan, Absolute";
1078 - case V4L2_CID_TILT_ABSOLUTE: return "Tilt, Absolute";
1079 - case V4L2_CID_FOCUS_ABSOLUTE: return "Focus, Absolute";
1080 - case V4L2_CID_FOCUS_RELATIVE: return "Focus, Relative";
1081 - case V4L2_CID_FOCUS_AUTO: return "Focus, Automatic Continuous";
1082 - case V4L2_CID_ZOOM_ABSOLUTE: return "Zoom, Absolute";
1083 - case V4L2_CID_ZOOM_RELATIVE: return "Zoom, Relative";
1084 - case V4L2_CID_ZOOM_CONTINUOUS: return "Zoom, Continuous";
1085 - case V4L2_CID_PRIVACY: return "Privacy";
1086 - case V4L2_CID_IRIS_ABSOLUTE: return "Iris, Absolute";
1087 - case V4L2_CID_IRIS_RELATIVE: return "Iris, Relative";
1088 - case V4L2_CID_AUTO_EXPOSURE_BIAS: return "Auto Exposure, Bias";
1089 - case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset";
1090 - case V4L2_CID_WIDE_DYNAMIC_RANGE: return "Wide Dynamic Range";
1091 - case V4L2_CID_IMAGE_STABILIZATION: return "Image Stabilization";
1092 - case V4L2_CID_ISO_SENSITIVITY: return "ISO Sensitivity";
1093 - case V4L2_CID_ISO_SENSITIVITY_AUTO: return "ISO Sensitivity, Auto";
1094 - case V4L2_CID_EXPOSURE_METERING: return "Exposure, Metering Mode";
1095 - case V4L2_CID_SCENE_MODE: return "Scene Mode";
1096 - case V4L2_CID_3A_LOCK: return "3A Lock";
1097 - case V4L2_CID_AUTO_FOCUS_START: return "Auto Focus, Start";
1098 - case V4L2_CID_AUTO_FOCUS_STOP: return "Auto Focus, Stop";
1099 - case V4L2_CID_AUTO_FOCUS_STATUS: return "Auto Focus, Status";
1100 - case V4L2_CID_AUTO_FOCUS_RANGE: return "Auto Focus, Range";
1101 - case V4L2_CID_PAN_SPEED: return "Pan, Speed";
1102 - case V4L2_CID_TILT_SPEED: return "Tilt, Speed";
1103 - case V4L2_CID_UNIT_CELL_SIZE: return "Unit Cell Size";
1104 - case V4L2_CID_CAMERA_ORIENTATION: return "Camera Orientation";
1105 - case V4L2_CID_CAMERA_SENSOR_ROTATION: return "Camera Sensor Rotation";
1106 -
1107 - /* FM Radio Modulator controls */
1108 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1109 - case V4L2_CID_FM_TX_CLASS: return "FM Radio Modulator Controls";
1110 - case V4L2_CID_RDS_TX_DEVIATION: return "RDS Signal Deviation";
1111 - case V4L2_CID_RDS_TX_PI: return "RDS Program ID";
1112 - case V4L2_CID_RDS_TX_PTY: return "RDS Program Type";
1113 - case V4L2_CID_RDS_TX_PS_NAME: return "RDS PS Name";
1114 - case V4L2_CID_RDS_TX_RADIO_TEXT: return "RDS Radio Text";
1115 - case V4L2_CID_RDS_TX_MONO_STEREO: return "RDS Stereo";
1116 - case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD: return "RDS Artificial Head";
1117 - case V4L2_CID_RDS_TX_COMPRESSED: return "RDS Compressed";
1118 - case V4L2_CID_RDS_TX_DYNAMIC_PTY: return "RDS Dynamic PTY";
1119 - case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
1120 - case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM: return "RDS Traffic Program";
1121 - case V4L2_CID_RDS_TX_MUSIC_SPEECH: return "RDS Music";
1122 - case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE: return "RDS Enable Alt Frequencies";
1123 - case V4L2_CID_RDS_TX_ALT_FREQS: return "RDS Alternate Frequencies";
1124 - case V4L2_CID_AUDIO_LIMITER_ENABLED: return "Audio Limiter Feature Enabled";
1125 - case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
1126 - case V4L2_CID_AUDIO_LIMITER_DEVIATION: return "Audio Limiter Deviation";
1127 - case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled";
1128 - case V4L2_CID_AUDIO_COMPRESSION_GAIN: return "Audio Compression Gain";
1129 - case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
1130 - case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
1131 - case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
1132 - case V4L2_CID_PILOT_TONE_ENABLED: return "Pilot Tone Feature Enabled";
1133 - case V4L2_CID_PILOT_TONE_DEVIATION: return "Pilot Tone Deviation";
1134 - case V4L2_CID_PILOT_TONE_FREQUENCY: return "Pilot Tone Frequency";
1135 - case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-Emphasis";
1136 - case V4L2_CID_TUNE_POWER_LEVEL: return "Tune Power Level";
1137 - case V4L2_CID_TUNE_ANTENNA_CAPACITOR: return "Tune Antenna Capacitor";
1138 -
1139 - /* Flash controls */
1140 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1141 - case V4L2_CID_FLASH_CLASS: return "Flash Controls";
1142 - case V4L2_CID_FLASH_LED_MODE: return "LED Mode";
1143 - case V4L2_CID_FLASH_STROBE_SOURCE: return "Strobe Source";
1144 - case V4L2_CID_FLASH_STROBE: return "Strobe";
1145 - case V4L2_CID_FLASH_STROBE_STOP: return "Stop Strobe";
1146 - case V4L2_CID_FLASH_STROBE_STATUS: return "Strobe Status";
1147 - case V4L2_CID_FLASH_TIMEOUT: return "Strobe Timeout";
1148 - case V4L2_CID_FLASH_INTENSITY: return "Intensity, Flash Mode";
1149 - case V4L2_CID_FLASH_TORCH_INTENSITY: return "Intensity, Torch Mode";
1150 - case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator";
1151 - case V4L2_CID_FLASH_FAULT: return "Faults";
1152 - case V4L2_CID_FLASH_CHARGE: return "Charge";
1153 - case V4L2_CID_FLASH_READY: return "Ready to Strobe";
1154 -
1155 - /* JPEG encoder controls */
1156 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1157 - case V4L2_CID_JPEG_CLASS: return "JPEG Compression Controls";
1158 - case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: return "Chroma Subsampling";
1159 - case V4L2_CID_JPEG_RESTART_INTERVAL: return "Restart Interval";
1160 - case V4L2_CID_JPEG_COMPRESSION_QUALITY: return "Compression Quality";
1161 - case V4L2_CID_JPEG_ACTIVE_MARKER: return "Active Markers";
1162 -
1163 - /* Image source controls */
1164 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1165 - case V4L2_CID_IMAGE_SOURCE_CLASS: return "Image Source Controls";
1166 - case V4L2_CID_VBLANK: return "Vertical Blanking";
1167 - case V4L2_CID_HBLANK: return "Horizontal Blanking";
1168 - case V4L2_CID_ANALOGUE_GAIN: return "Analogue Gain";
1169 - case V4L2_CID_TEST_PATTERN_RED: return "Red Pixel Value";
1170 - case V4L2_CID_TEST_PATTERN_GREENR: return "Green (Red) Pixel Value";
1171 - case V4L2_CID_TEST_PATTERN_BLUE: return "Blue Pixel Value";
1172 - case V4L2_CID_TEST_PATTERN_GREENB: return "Green (Blue) Pixel Value";
1173 -
1174 - /* Image processing controls */
1175 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1176 - case V4L2_CID_IMAGE_PROC_CLASS: return "Image Processing Controls";
1177 - case V4L2_CID_LINK_FREQ: return "Link Frequency";
1178 - case V4L2_CID_PIXEL_RATE: return "Pixel Rate";
1179 - case V4L2_CID_TEST_PATTERN: return "Test Pattern";
1180 - case V4L2_CID_DEINTERLACING_MODE: return "Deinterlacing Mode";
1181 - case V4L2_CID_DIGITAL_GAIN: return "Digital Gain";
1182 -
1183 - /* DV controls */
1184 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1185 - case V4L2_CID_DV_CLASS: return "Digital Video Controls";
1186 - case V4L2_CID_DV_TX_HOTPLUG: return "Hotplug Present";
1187 - case V4L2_CID_DV_TX_RXSENSE: return "RxSense Present";
1188 - case V4L2_CID_DV_TX_EDID_PRESENT: return "EDID Present";
1189 - case V4L2_CID_DV_TX_MODE: return "Transmit Mode";
1190 - case V4L2_CID_DV_TX_RGB_RANGE: return "Tx RGB Quantization Range";
1191 - case V4L2_CID_DV_TX_IT_CONTENT_TYPE: return "Tx IT Content Type";
1192 - case V4L2_CID_DV_RX_POWER_PRESENT: return "Power Present";
1193 - case V4L2_CID_DV_RX_RGB_RANGE: return "Rx RGB Quantization Range";
1194 - case V4L2_CID_DV_RX_IT_CONTENT_TYPE: return "Rx IT Content Type";
1195 -
1196 - case V4L2_CID_FM_RX_CLASS: return "FM Radio Receiver Controls";
1197 - case V4L2_CID_TUNE_DEEMPHASIS: return "De-Emphasis";
1198 - case V4L2_CID_RDS_RECEPTION: return "RDS Reception";
1199 - case V4L2_CID_RF_TUNER_CLASS: return "RF Tuner Controls";
1200 - case V4L2_CID_RF_TUNER_RF_GAIN: return "RF Gain";
1201 - case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO: return "LNA Gain, Auto";
1202 - case V4L2_CID_RF_TUNER_LNA_GAIN: return "LNA Gain";
1203 - case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO: return "Mixer Gain, Auto";
1204 - case V4L2_CID_RF_TUNER_MIXER_GAIN: return "Mixer Gain";
1205 - case V4L2_CID_RF_TUNER_IF_GAIN_AUTO: return "IF Gain, Auto";
1206 - case V4L2_CID_RF_TUNER_IF_GAIN: return "IF Gain";
1207 - case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO: return "Bandwidth, Auto";
1208 - case V4L2_CID_RF_TUNER_BANDWIDTH: return "Bandwidth";
1209 - case V4L2_CID_RF_TUNER_PLL_LOCK: return "PLL Lock";
1210 - case V4L2_CID_RDS_RX_PTY: return "RDS Program Type";
1211 - case V4L2_CID_RDS_RX_PS_NAME: return "RDS PS Name";
1212 - case V4L2_CID_RDS_RX_RADIO_TEXT: return "RDS Radio Text";
1213 - case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
1214 - case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM: return "RDS Traffic Program";
1215 - case V4L2_CID_RDS_RX_MUSIC_SPEECH: return "RDS Music";
1216 -
1217 - /* Detection controls */
1218 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1219 - case V4L2_CID_DETECT_CLASS: return "Detection Controls";
1220 - case V4L2_CID_DETECT_MD_MODE: return "Motion Detection Mode";
1221 - case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD: return "MD Global Threshold";
1222 - case V4L2_CID_DETECT_MD_THRESHOLD_GRID: return "MD Threshold Grid";
1223 - case V4L2_CID_DETECT_MD_REGION_GRID: return "MD Region Grid";
1224 -
1225 - /* Stateless Codec controls */
1226 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1227 - case V4L2_CID_CODEC_STATELESS_CLASS: return "Stateless Codec Controls";
1228 - case V4L2_CID_STATELESS_H264_DECODE_MODE: return "H264 Decode Mode";
1229 - case V4L2_CID_STATELESS_H264_START_CODE: return "H264 Start Code";
1230 - case V4L2_CID_STATELESS_H264_SPS: return "H264 Sequence Parameter Set";
1231 - case V4L2_CID_STATELESS_H264_PPS: return "H264 Picture Parameter Set";
1232 - case V4L2_CID_STATELESS_H264_SCALING_MATRIX: return "H264 Scaling Matrix";
1233 - case V4L2_CID_STATELESS_H264_PRED_WEIGHTS: return "H264 Prediction Weight Table";
1234 - case V4L2_CID_STATELESS_H264_SLICE_PARAMS: return "H264 Slice Parameters";
1235 - case V4L2_CID_STATELESS_H264_DECODE_PARAMS: return "H264 Decode Parameters";
1236 - case V4L2_CID_STATELESS_FWHT_PARAMS: return "FWHT Stateless Parameters";
1237 - case V4L2_CID_STATELESS_VP8_FRAME: return "VP8 Frame Parameters";
1238 -
1239 - /* Colorimetry controls */
1240 - /* Keep the order of the 'case's the same as in v4l2-controls.h! */
1241 - case V4L2_CID_COLORIMETRY_CLASS: return "Colorimetry Controls";
1242 - case V4L2_CID_COLORIMETRY_HDR10_CLL_INFO: return "HDR10 Content Light Info";
1243 - case V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY: return "HDR10 Mastering Display";
1244 - default:
1245 - return NULL;
1246 - }
1247 -}
1248 -EXPORT_SYMBOL(v4l2_ctrl_get_name);
1249 -
1250 -void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
1251 - s64 *min, s64 *max, u64 *step, s64 *def, u32 *flags)
1252 -{
1253 - *name = v4l2_ctrl_get_name(id);
1254 - *flags = 0;
1255 -
1256 - switch (id) {
1257 - case V4L2_CID_AUDIO_MUTE:
1258 - case V4L2_CID_AUDIO_LOUDNESS:
1259 - case V4L2_CID_AUTO_WHITE_BALANCE:
1260 - case V4L2_CID_AUTOGAIN:
1261 - case V4L2_CID_HFLIP:
1262 - case V4L2_CID_VFLIP:
1263 - case V4L2_CID_HUE_AUTO:
1264 - case V4L2_CID_CHROMA_AGC:
1265 - case V4L2_CID_COLOR_KILLER:
1266 - case V4L2_CID_AUTOBRIGHTNESS:
1267 - case V4L2_CID_MPEG_AUDIO_MUTE:
1268 - case V4L2_CID_MPEG_VIDEO_MUTE:
1269 - case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1270 - case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1271 - case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
1272 - case V4L2_CID_FOCUS_AUTO:
1273 - case V4L2_CID_PRIVACY:
1274 - case V4L2_CID_AUDIO_LIMITER_ENABLED:
1275 - case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
1276 - case V4L2_CID_PILOT_TONE_ENABLED:
1277 - case V4L2_CID_ILLUMINATORS_1:
1278 - case V4L2_CID_ILLUMINATORS_2:
1279 - case V4L2_CID_FLASH_STROBE_STATUS:
1280 - case V4L2_CID_FLASH_CHARGE:
1281 - case V4L2_CID_FLASH_READY:
1282 - case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
1283 - case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
1284 - case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE:
1285 - case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
1286 - case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
1287 - case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
1288 - case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
1289 - case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
1290 - case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:
1291 - case V4L2_CID_MPEG_VIDEO_AU_DELIMITER:
1292 - case V4L2_CID_WIDE_DYNAMIC_RANGE:
1293 - case V4L2_CID_IMAGE_STABILIZATION:
1294 - case V4L2_CID_RDS_RECEPTION:
1295 - case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:
1296 - case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO:
1297 - case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:
1298 - case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
1299 - case V4L2_CID_RF_TUNER_PLL_LOCK:
1300 - case V4L2_CID_RDS_TX_MONO_STEREO:
1301 - case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:
1302 - case V4L2_CID_RDS_TX_COMPRESSED:
1303 - case V4L2_CID_RDS_TX_DYNAMIC_PTY:
1304 - case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
1305 - case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
1306 - case V4L2_CID_RDS_TX_MUSIC_SPEECH:
1307 - case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:
1308 - case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
1309 - case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
1310 - case V4L2_CID_RDS_RX_MUSIC_SPEECH:
1311 - *type = V4L2_CTRL_TYPE_BOOLEAN;
1312 - *min = 0;
1313 - *max = *step = 1;
1314 - break;
1315 - case V4L2_CID_ROTATE:
1316 - *type = V4L2_CTRL_TYPE_INTEGER;
1317 - *flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
1318 - break;
1319 - case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:
1320 - case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:
1321 - case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY:
1322 - *type = V4L2_CTRL_TYPE_INTEGER;
1323 - break;
1324 - case V4L2_CID_MPEG_VIDEO_LTR_COUNT:
1325 - *type = V4L2_CTRL_TYPE_INTEGER;
1326 - break;
1327 - case V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX:
1328 - *type = V4L2_CTRL_TYPE_INTEGER;
1329 - *flags |= V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1330 - break;
1331 - case V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES:
1332 - *type = V4L2_CTRL_TYPE_BITMASK;
1333 - *flags |= V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1334 - break;
1335 - case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:
1336 - case V4L2_CID_PAN_RESET:
1337 - case V4L2_CID_TILT_RESET:
1338 - case V4L2_CID_FLASH_STROBE:
1339 - case V4L2_CID_FLASH_STROBE_STOP:
1340 - case V4L2_CID_AUTO_FOCUS_START:
1341 - case V4L2_CID_AUTO_FOCUS_STOP:
1342 - case V4L2_CID_DO_WHITE_BALANCE:
1343 - *type = V4L2_CTRL_TYPE_BUTTON;
1344 - *flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1345 - V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1346 - *min = *max = *step = *def = 0;
1347 - break;
1348 - case V4L2_CID_POWER_LINE_FREQUENCY:
1349 - case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1350 - case V4L2_CID_MPEG_AUDIO_ENCODING:
1351 - case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1352 - case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1353 - case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1354 - case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
1355 - case V4L2_CID_MPEG_AUDIO_MODE:
1356 - case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1357 - case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1358 - case V4L2_CID_MPEG_AUDIO_CRC:
1359 - case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
1360 - case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
1361 - case V4L2_CID_MPEG_VIDEO_ENCODING:
1362 - case V4L2_CID_MPEG_VIDEO_ASPECT:
1363 - case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1364 - case V4L2_CID_MPEG_STREAM_TYPE:
1365 - case V4L2_CID_MPEG_STREAM_VBI_FMT:
1366 - case V4L2_CID_EXPOSURE_AUTO:
1367 - case V4L2_CID_AUTO_FOCUS_RANGE:
1368 - case V4L2_CID_COLORFX:
1369 - case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
1370 - case V4L2_CID_TUNE_PREEMPHASIS:
1371 - case V4L2_CID_FLASH_LED_MODE:
1372 - case V4L2_CID_FLASH_STROBE_SOURCE:
1373 - case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1374 - case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE:
1375 - case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1376 - case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1377 - case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1378 - case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1379 - case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1380 - case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1381 - case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
1382 - case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
1383 - case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE:
1384 - case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:
1385 - case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE:
1386 - case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1387 - case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1388 - case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1389 - case V4L2_CID_ISO_SENSITIVITY_AUTO:
1390 - case V4L2_CID_EXPOSURE_METERING:
1391 - case V4L2_CID_SCENE_MODE:
1392 - case V4L2_CID_DV_TX_MODE:
1393 - case V4L2_CID_DV_TX_RGB_RANGE:
1394 - case V4L2_CID_DV_TX_IT_CONTENT_TYPE:
1395 - case V4L2_CID_DV_RX_RGB_RANGE:
1396 - case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
1397 - case V4L2_CID_TEST_PATTERN:
1398 - case V4L2_CID_DEINTERLACING_MODE:
1399 - case V4L2_CID_TUNE_DEEMPHASIS:
1400 - case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
1401 - case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
1402 - case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:
1403 - case V4L2_CID_MPEG_VIDEO_VP9_LEVEL:
1404 - case V4L2_CID_DETECT_MD_MODE:
1405 - case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
1406 - case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
1407 - case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:
1408 - case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE:
1409 - case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:
1410 - case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
1411 - case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:
1412 - case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE:
1413 - case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE:
1414 - case V4L2_CID_STATELESS_H264_DECODE_MODE:
1415 - case V4L2_CID_STATELESS_H264_START_CODE:
1416 - case V4L2_CID_CAMERA_ORIENTATION:
1417 - *type = V4L2_CTRL_TYPE_MENU;
1418 - break;
1419 - case V4L2_CID_LINK_FREQ:
1420 - *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1421 - break;
1422 - case V4L2_CID_RDS_TX_PS_NAME:
1423 - case V4L2_CID_RDS_TX_RADIO_TEXT:
1424 - case V4L2_CID_RDS_RX_PS_NAME:
1425 - case V4L2_CID_RDS_RX_RADIO_TEXT:
1426 - *type = V4L2_CTRL_TYPE_STRING;
1427 - break;
1428 - case V4L2_CID_ISO_SENSITIVITY:
1429 - case V4L2_CID_AUTO_EXPOSURE_BIAS:
1430 - case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
1431 - case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
1432 - *type = V4L2_CTRL_TYPE_INTEGER_MENU;
1433 - break;
1434 - case V4L2_CID_USER_CLASS:
1435 - case V4L2_CID_CAMERA_CLASS:
1436 - case V4L2_CID_CODEC_CLASS:
1437 - case V4L2_CID_FM_TX_CLASS:
1438 - case V4L2_CID_FLASH_CLASS:
1439 - case V4L2_CID_JPEG_CLASS:
1440 - case V4L2_CID_IMAGE_SOURCE_CLASS:
1441 - case V4L2_CID_IMAGE_PROC_CLASS:
1442 - case V4L2_CID_DV_CLASS:
1443 - case V4L2_CID_FM_RX_CLASS:
1444 - case V4L2_CID_RF_TUNER_CLASS:
1445 - case V4L2_CID_DETECT_CLASS:
1446 - case V4L2_CID_CODEC_STATELESS_CLASS:
1447 - case V4L2_CID_COLORIMETRY_CLASS:
1448 - *type = V4L2_CTRL_TYPE_CTRL_CLASS;
1449 - /* You can neither read nor write these */
1450 - *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
1451 - *min = *max = *step = *def = 0;
1452 - break;
1453 - case V4L2_CID_BG_COLOR:
1454 - *type = V4L2_CTRL_TYPE_INTEGER;
1455 - *step = 1;
1456 - *min = 0;
1457 - /* Max is calculated as RGB888 that is 2^24 */
1458 - *max = 0xFFFFFF;
1459 - break;
1460 - case V4L2_CID_FLASH_FAULT:
1461 - case V4L2_CID_JPEG_ACTIVE_MARKER:
1462 - case V4L2_CID_3A_LOCK:
1463 - case V4L2_CID_AUTO_FOCUS_STATUS:
1464 - case V4L2_CID_DV_TX_HOTPLUG:
1465 - case V4L2_CID_DV_TX_RXSENSE:
1466 - case V4L2_CID_DV_TX_EDID_PRESENT:
1467 - case V4L2_CID_DV_RX_POWER_PRESENT:
1468 - *type = V4L2_CTRL_TYPE_BITMASK;
1469 - break;
1470 - case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
1471 - case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
1472 - *type = V4L2_CTRL_TYPE_INTEGER;
1473 - *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1474 - break;
1475 - case V4L2_CID_MPEG_VIDEO_DEC_PTS:
1476 - *type = V4L2_CTRL_TYPE_INTEGER64;
1477 - *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1478 - *min = *def = 0;
1479 - *max = 0x1ffffffffLL;
1480 - *step = 1;
1481 - break;
1482 - case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
1483 - *type = V4L2_CTRL_TYPE_INTEGER64;
1484 - *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1485 - *min = *def = 0;
1486 - *max = 0x7fffffffffffffffLL;
1487 - *step = 1;
1488 - break;
1489 - case V4L2_CID_MPEG_VIDEO_DEC_CONCEAL_COLOR:
1490 - *type = V4L2_CTRL_TYPE_INTEGER64;
1491 - *min = 0;
1492 - /* default for 8 bit black, luma is 16, chroma is 128 */
1493 - *def = 0x8000800010LL;
1494 - *max = 0xffffffffffffLL;
1495 - *step = 1;
1496 - break;
1497 - case V4L2_CID_PIXEL_RATE:
1498 - *type = V4L2_CTRL_TYPE_INTEGER64;
1499 - *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1500 - break;
1501 - case V4L2_CID_DETECT_MD_REGION_GRID:
1502 - *type = V4L2_CTRL_TYPE_U8;
1503 - break;
1504 - case V4L2_CID_DETECT_MD_THRESHOLD_GRID:
1505 - *type = V4L2_CTRL_TYPE_U16;
1506 - break;
1507 - case V4L2_CID_RDS_TX_ALT_FREQS:
1508 - *type = V4L2_CTRL_TYPE_U32;
1509 - break;
1510 - case V4L2_CID_MPEG_VIDEO_MPEG2_SLICE_PARAMS:
1511 - *type = V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS;
1512 - break;
1513 - case V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION:
1514 - *type = V4L2_CTRL_TYPE_MPEG2_QUANTIZATION;
1515 - break;
1516 - case V4L2_CID_STATELESS_FWHT_PARAMS:
1517 - *type = V4L2_CTRL_TYPE_FWHT_PARAMS;
1518 - break;
1519 - case V4L2_CID_STATELESS_H264_SPS:
1520 - *type = V4L2_CTRL_TYPE_H264_SPS;
1521 - break;
1522 - case V4L2_CID_STATELESS_H264_PPS:
1523 - *type = V4L2_CTRL_TYPE_H264_PPS;
1524 - break;
1525 - case V4L2_CID_STATELESS_H264_SCALING_MATRIX:
1526 - *type = V4L2_CTRL_TYPE_H264_SCALING_MATRIX;
1527 - break;
1528 - case V4L2_CID_STATELESS_H264_SLICE_PARAMS:
1529 - *type = V4L2_CTRL_TYPE_H264_SLICE_PARAMS;
1530 - break;
1531 - case V4L2_CID_STATELESS_H264_DECODE_PARAMS:
1532 - *type = V4L2_CTRL_TYPE_H264_DECODE_PARAMS;
1533 - break;
1534 - case V4L2_CID_STATELESS_H264_PRED_WEIGHTS:
1535 - *type = V4L2_CTRL_TYPE_H264_PRED_WEIGHTS;
1536 - break;
1537 - case V4L2_CID_STATELESS_VP8_FRAME:
1538 - *type = V4L2_CTRL_TYPE_VP8_FRAME;
1539 - break;
1540 - case V4L2_CID_MPEG_VIDEO_HEVC_SPS:
1541 - *type = V4L2_CTRL_TYPE_HEVC_SPS;
1542 - break;
1543 - case V4L2_CID_MPEG_VIDEO_HEVC_PPS:
1544 - *type = V4L2_CTRL_TYPE_HEVC_PPS;
1545 - break;
1546 - case V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS:
1547 - *type = V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS;
1548 - break;
1549 - case V4L2_CID_MPEG_VIDEO_HEVC_SCALING_MATRIX:
1550 - *type = V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX;
1551 - break;
1552 - case V4L2_CID_UNIT_CELL_SIZE:
1553 - *type = V4L2_CTRL_TYPE_AREA;
1554 - *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1555 - break;
1556 - case V4L2_CID_COLORIMETRY_HDR10_CLL_INFO:
1557 - *type = V4L2_CTRL_TYPE_HDR10_CLL_INFO;
1558 - break;
1559 - case V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY:
1560 - *type = V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY;
1561 - break;
1562 - default:
1563 - *type = V4L2_CTRL_TYPE_INTEGER;
1564 - break;
1565 - }
1566 - switch (id) {
1567 - case V4L2_CID_MPEG_AUDIO_ENCODING:
1568 - case V4L2_CID_MPEG_AUDIO_MODE:
1569 - case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1570 - case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1571 - case V4L2_CID_MPEG_STREAM_TYPE:
1572 - *flags |= V4L2_CTRL_FLAG_UPDATE;
1573 - break;
1574 - case V4L2_CID_AUDIO_VOLUME:
1575 - case V4L2_CID_AUDIO_BALANCE:
1576 - case V4L2_CID_AUDIO_BASS:
1577 - case V4L2_CID_AUDIO_TREBLE:
1578 - case V4L2_CID_BRIGHTNESS:
1579 - case V4L2_CID_CONTRAST:
1580 - case V4L2_CID_SATURATION:
1581 - case V4L2_CID_HUE:
1582 - case V4L2_CID_RED_BALANCE:
1583 - case V4L2_CID_BLUE_BALANCE:
1584 - case V4L2_CID_GAMMA:
1585 - case V4L2_CID_SHARPNESS:
1586 - case V4L2_CID_CHROMA_GAIN:
1587 - case V4L2_CID_RDS_TX_DEVIATION:
1588 - case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1589 - case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1590 - case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1591 - case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1592 - case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1593 - case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1594 - case V4L2_CID_PILOT_TONE_DEVIATION:
1595 - case V4L2_CID_PILOT_TONE_FREQUENCY:
1596 - case V4L2_CID_TUNE_POWER_LEVEL:
1597 - case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1598 - case V4L2_CID_RF_TUNER_RF_GAIN:
1599 - case V4L2_CID_RF_TUNER_LNA_GAIN:
1600 - case V4L2_CID_RF_TUNER_MIXER_GAIN:
1601 - case V4L2_CID_RF_TUNER_IF_GAIN:
1602 - case V4L2_CID_RF_TUNER_BANDWIDTH:
1603 - case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD:
1604 - *flags |= V4L2_CTRL_FLAG_SLIDER;
1605 - break;
1606 - case V4L2_CID_PAN_RELATIVE:
1607 - case V4L2_CID_TILT_RELATIVE:
1608 - case V4L2_CID_FOCUS_RELATIVE:
1609 - case V4L2_CID_IRIS_RELATIVE:
1610 - case V4L2_CID_ZOOM_RELATIVE:
1611 - *flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1612 - V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1613 - break;
1614 - case V4L2_CID_FLASH_STROBE_STATUS:
1615 - case V4L2_CID_AUTO_FOCUS_STATUS:
1616 - case V4L2_CID_FLASH_READY:
1617 - case V4L2_CID_DV_TX_HOTPLUG:
1618 - case V4L2_CID_DV_TX_RXSENSE:
1619 - case V4L2_CID_DV_TX_EDID_PRESENT:
1620 - case V4L2_CID_DV_RX_POWER_PRESENT:
1621 - case V4L2_CID_DV_RX_IT_CONTENT_TYPE:
1622 - case V4L2_CID_RDS_RX_PTY:
1623 - case V4L2_CID_RDS_RX_PS_NAME:
1624 - case V4L2_CID_RDS_RX_RADIO_TEXT:
1625 - case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
1626 - case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
1627 - case V4L2_CID_RDS_RX_MUSIC_SPEECH:
1628 - case V4L2_CID_CAMERA_ORIENTATION:
1629 - case V4L2_CID_CAMERA_SENSOR_ROTATION:
1630 - *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1631 - break;
1632 - case V4L2_CID_RF_TUNER_PLL_LOCK:
1633 - *flags |= V4L2_CTRL_FLAG_VOLATILE;
1634 - break;
1635 - }
1636 -}
1637 -EXPORT_SYMBOL(v4l2_ctrl_fill);
1638 -
1639 -static u32 user_flags(const struct v4l2_ctrl *ctrl)
1640 -{
1641 - u32 flags = ctrl->flags;
1642 -
1643 - if (ctrl->is_ptr)
1644 - flags |= V4L2_CTRL_FLAG_HAS_PAYLOAD;
1645 -
1646 - return flags;
1647 -}
1648 -
1649 -static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes)
1650 -{
1651 - memset(ev, 0, sizeof(*ev));
1652 - ev->type = V4L2_EVENT_CTRL;
1653 - ev->id = ctrl->id;
1654 - ev->u.ctrl.changes = changes;
1655 - ev->u.ctrl.type = ctrl->type;
1656 - ev->u.ctrl.flags = user_flags(ctrl);
1657 - if (ctrl->is_ptr)
1658 - ev->u.ctrl.value64 = 0;
1659 - else
1660 - ev->u.ctrl.value64 = *ctrl->p_cur.p_s64;
1661 - ev->u.ctrl.minimum = ctrl->minimum;
1662 - ev->u.ctrl.maximum = ctrl->maximum;
1663 - if (ctrl->type == V4L2_CTRL_TYPE_MENU
1664 - || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1665 - ev->u.ctrl.step = 1;
1666 - else
1667 - ev->u.ctrl.step = ctrl->step;
1668 - ev->u.ctrl.default_value = ctrl->default_value;
1669 -}
1670 -
1671 -static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
1672 -{
1673 - struct v4l2_event ev;
1674 - struct v4l2_subscribed_event *sev;
1675 -
1676 - if (list_empty(&ctrl->ev_subs))
1677 - return;
1678 - fill_event(&ev, ctrl, changes);
1679 -
1680 - list_for_each_entry(sev, &ctrl->ev_subs, node)
1681 - if (sev->fh != fh ||
1682 - (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
1683 - v4l2_event_queue_fh(sev->fh, &ev);
1684 -}
1685 -
1686 -static bool std_equal(const struct v4l2_ctrl *ctrl, u32 idx,
1687 - union v4l2_ctrl_ptr ptr1,
1688 - union v4l2_ctrl_ptr ptr2)
1689 -{
1690 - switch (ctrl->type) {
1691 - case V4L2_CTRL_TYPE_BUTTON:
1692 - return false;
1693 - case V4L2_CTRL_TYPE_STRING:
1694 - idx *= ctrl->elem_size;
1695 - /* strings are always 0-terminated */
1696 - return !strcmp(ptr1.p_char + idx, ptr2.p_char + idx);
1697 - case V4L2_CTRL_TYPE_INTEGER64:
1698 - return ptr1.p_s64[idx] == ptr2.p_s64[idx];
1699 - case V4L2_CTRL_TYPE_U8:
1700 - return ptr1.p_u8[idx] == ptr2.p_u8[idx];
1701 - case V4L2_CTRL_TYPE_U16:
1702 - return ptr1.p_u16[idx] == ptr2.p_u16[idx];
1703 - case V4L2_CTRL_TYPE_U32:
1704 - return ptr1.p_u32[idx] == ptr2.p_u32[idx];
1705 - default:
1706 - if (ctrl->is_int)
1707 - return ptr1.p_s32[idx] == ptr2.p_s32[idx];
1708 - idx *= ctrl->elem_size;
1709 - return !memcmp(ptr1.p_const + idx, ptr2.p_const + idx,
1710 - ctrl->elem_size);
1711 - }
1712 -}
1713 -
1714 -static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx,
1715 - union v4l2_ctrl_ptr ptr)
1716 -{
1717 - struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params;
1718 - struct v4l2_ctrl_vp8_frame *p_vp8_frame;
1719 - struct v4l2_ctrl_fwht_params *p_fwht_params;
1720 - void *p = ptr.p + idx * ctrl->elem_size;
1721 -
1722 - if (ctrl->p_def.p_const)
1723 - memcpy(p, ctrl->p_def.p_const, ctrl->elem_size);
1724 - else
1725 - memset(p, 0, ctrl->elem_size);
1726 -
1727 - /*
1728 - * The cast is needed to get rid of a gcc warning complaining that
1729 - * V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS is not part of the
1730 - * v4l2_ctrl_type enum.
1731 - */
1732 - switch ((u32)ctrl->type) {
1733 - case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS:
1734 - p_mpeg2_slice_params = p;
1735 - /* 4:2:0 */
1736 - p_mpeg2_slice_params->sequence.chroma_format = 1;
1737 - /* interlaced top field */
1738 - p_mpeg2_slice_params->picture.picture_structure = 1;
1739 - p_mpeg2_slice_params->picture.picture_coding_type =
1740 - V4L2_MPEG2_PICTURE_CODING_TYPE_I;
1741 - break;
1742 - case V4L2_CTRL_TYPE_VP8_FRAME:
1743 - p_vp8_frame = p;
1744 - p_vp8_frame->num_dct_parts = 1;
1745 - break;
1746 - case V4L2_CTRL_TYPE_FWHT_PARAMS:
1747 - p_fwht_params = p;
1748 - p_fwht_params->version = V4L2_FWHT_VERSION;
1749 - p_fwht_params->width = 1280;
1750 - p_fwht_params->height = 720;
1751 - p_fwht_params->flags = V4L2_FWHT_FL_PIXENC_YUV |
1752 - (2 << V4L2_FWHT_FL_COMPONENTS_NUM_OFFSET);
1753 - break;
1754 - }
1755 -}
1756 -
1757 -static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
1758 - union v4l2_ctrl_ptr ptr)
1759 -{
1760 - switch (ctrl->type) {
1761 - case V4L2_CTRL_TYPE_STRING:
1762 - idx *= ctrl->elem_size;
1763 - memset(ptr.p_char + idx, ' ', ctrl->minimum);
1764 - ptr.p_char[idx + ctrl->minimum] = '\0';
1765 - break;
1766 - case V4L2_CTRL_TYPE_INTEGER64:
1767 - ptr.p_s64[idx] = ctrl->default_value;
1768 - break;
1769 - case V4L2_CTRL_TYPE_INTEGER:
1770 - case V4L2_CTRL_TYPE_INTEGER_MENU:
1771 - case V4L2_CTRL_TYPE_MENU:
1772 - case V4L2_CTRL_TYPE_BITMASK:
1773 - case V4L2_CTRL_TYPE_BOOLEAN:
1774 - ptr.p_s32[idx] = ctrl->default_value;
1775 - break;
1776 - case V4L2_CTRL_TYPE_BUTTON:
1777 - case V4L2_CTRL_TYPE_CTRL_CLASS:
1778 - ptr.p_s32[idx] = 0;
1779 - break;
1780 - case V4L2_CTRL_TYPE_U8:
1781 - ptr.p_u8[idx] = ctrl->default_value;
1782 - break;
1783 - case V4L2_CTRL_TYPE_U16:
1784 - ptr.p_u16[idx] = ctrl->default_value;
1785 - break;
1786 - case V4L2_CTRL_TYPE_U32:
1787 - ptr.p_u32[idx] = ctrl->default_value;
1788 - break;
1789 - default:
1790 - std_init_compound(ctrl, idx, ptr);
1791 - break;
1792 - }
1793 -}
1794 -
1795 -static void std_log(const struct v4l2_ctrl *ctrl)
1796 -{
1797 - union v4l2_ctrl_ptr ptr = ctrl->p_cur;
1798 -
1799 - if (ctrl->is_array) {
1800 - unsigned i;
1801 -
1802 - for (i = 0; i < ctrl->nr_of_dims; i++)
1803 - pr_cont("[%u]", ctrl->dims[i]);
1804 - pr_cont(" ");
1805 - }
1806 -
1807 - switch (ctrl->type) {
1808 - case V4L2_CTRL_TYPE_INTEGER:
1809 - pr_cont("%d", *ptr.p_s32);
1810 - break;
1811 - case V4L2_CTRL_TYPE_BOOLEAN:
1812 - pr_cont("%s", *ptr.p_s32 ? "true" : "false");
1813 - break;
1814 - case V4L2_CTRL_TYPE_MENU:
1815 - pr_cont("%s", ctrl->qmenu[*ptr.p_s32]);
1816 - break;
1817 - case V4L2_CTRL_TYPE_INTEGER_MENU:
1818 - pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]);
1819 - break;
1820 - case V4L2_CTRL_TYPE_BITMASK:
1821 - pr_cont("0x%08x", *ptr.p_s32);
1822 - break;
1823 - case V4L2_CTRL_TYPE_INTEGER64:
1824 - pr_cont("%lld", *ptr.p_s64);
1825 - break;
1826 - case V4L2_CTRL_TYPE_STRING:
1827 - pr_cont("%s", ptr.p_char);
1828 - break;
1829 - case V4L2_CTRL_TYPE_U8:
1830 - pr_cont("%u", (unsigned)*ptr.p_u8);
1831 - break;
1832 - case V4L2_CTRL_TYPE_U16:
1833 - pr_cont("%u", (unsigned)*ptr.p_u16);
1834 - break;
1835 - case V4L2_CTRL_TYPE_U32:
1836 - pr_cont("%u", (unsigned)*ptr.p_u32);
1837 - break;
1838 - case V4L2_CTRL_TYPE_H264_SPS:
1839 - pr_cont("H264_SPS");
1840 - break;
1841 - case V4L2_CTRL_TYPE_H264_PPS:
1842 - pr_cont("H264_PPS");
1843 - break;
1844 - case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
1845 - pr_cont("H264_SCALING_MATRIX");
1846 - break;
1847 - case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
1848 - pr_cont("H264_SLICE_PARAMS");
1849 - break;
1850 - case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
1851 - pr_cont("H264_DECODE_PARAMS");
1852 - break;
1853 - case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
1854 - pr_cont("H264_PRED_WEIGHTS");
1855 - break;
1856 - case V4L2_CTRL_TYPE_FWHT_PARAMS:
1857 - pr_cont("FWHT_PARAMS");
1858 - break;
1859 - case V4L2_CTRL_TYPE_VP8_FRAME:
1860 - pr_cont("VP8_FRAME");
1861 - break;
1862 - case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
1863 - pr_cont("HDR10_CLL_INFO");
1864 - break;
1865 - case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
1866 - pr_cont("HDR10_MASTERING_DISPLAY");
1867 - break;
1868 - default:
1869 - pr_cont("unknown type %d", ctrl->type);
1870 - break;
1871 - }
1872 -}
1873 -
1874 -/*
1875 - * Round towards the closest legal value. Be careful when we are
1876 - * close to the maximum range of the control type to prevent
1877 - * wrap-arounds.
1878 - */
1879 -#define ROUND_TO_RANGE(val, offset_type, ctrl) \
1880 -({ \
1881 - offset_type offset; \
1882 - if ((ctrl)->maximum >= 0 && \
1883 - val >= (ctrl)->maximum - (s32)((ctrl)->step / 2)) \
1884 - val = (ctrl)->maximum; \
1885 - else \
1886 - val += (s32)((ctrl)->step / 2); \
1887 - val = clamp_t(typeof(val), val, \
1888 - (ctrl)->minimum, (ctrl)->maximum); \
1889 - offset = (val) - (ctrl)->minimum; \
1890 - offset = (ctrl)->step * (offset / (u32)(ctrl)->step); \
1891 - val = (ctrl)->minimum + offset; \
1892 - 0; \
1893 -})
1894 -
1895 -/* Validate a new control */
1896 -
1897 -#define zero_padding(s) \
1898 - memset(&(s).padding, 0, sizeof((s).padding))
1899 -#define zero_reserved(s) \
1900 - memset(&(s).reserved, 0, sizeof((s).reserved))
1901 -
1902 -/*
1903 - * Compound controls validation requires setting unused fields/flags to zero
1904 - * in order to properly detect unchanged controls with std_equal's memcmp.
1905 - */
1906 -static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx,
1907 - union v4l2_ctrl_ptr ptr)
1908 -{
1909 - struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params;
1910 - struct v4l2_ctrl_vp8_frame *p_vp8_frame;
1911 - struct v4l2_ctrl_fwht_params *p_fwht_params;
1912 - struct v4l2_ctrl_h264_sps *p_h264_sps;
1913 - struct v4l2_ctrl_h264_pps *p_h264_pps;
1914 - struct v4l2_ctrl_h264_pred_weights *p_h264_pred_weights;
1915 - struct v4l2_ctrl_h264_slice_params *p_h264_slice_params;
1916 - struct v4l2_ctrl_h264_decode_params *p_h264_dec_params;
1917 - struct v4l2_ctrl_hevc_sps *p_hevc_sps;
1918 - struct v4l2_ctrl_hevc_pps *p_hevc_pps;
1919 - struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params;
1920 - struct v4l2_ctrl_hdr10_mastering_display *p_hdr10_mastering;
1921 - struct v4l2_area *area;
1922 - void *p = ptr.p + idx * ctrl->elem_size;
1923 - unsigned int i;
1924 -
1925 - switch ((u32)ctrl->type) {
1926 - case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS:
1927 - p_mpeg2_slice_params = p;
1928 -
1929 - switch (p_mpeg2_slice_params->sequence.chroma_format) {
1930 - case 1: /* 4:2:0 */
1931 - case 2: /* 4:2:2 */
1932 - case 3: /* 4:4:4 */
1933 - break;
1934 - default:
1935 - return -EINVAL;
1936 - }
1937 -
1938 - switch (p_mpeg2_slice_params->picture.intra_dc_precision) {
1939 - case 0: /* 8 bits */
1940 - case 1: /* 9 bits */
1941 - case 2: /* 10 bits */
1942 - case 3: /* 11 bits */
1943 - break;
1944 - default:
1945 - return -EINVAL;
1946 - }
1947 -
1948 - switch (p_mpeg2_slice_params->picture.picture_structure) {
1949 - case 1: /* interlaced top field */
1950 - case 2: /* interlaced bottom field */
1951 - case 3: /* progressive */
1952 - break;
1953 - default:
1954 - return -EINVAL;
1955 - }
1956 -
1957 - switch (p_mpeg2_slice_params->picture.picture_coding_type) {
1958 - case V4L2_MPEG2_PICTURE_CODING_TYPE_I:
1959 - case V4L2_MPEG2_PICTURE_CODING_TYPE_P:
1960 - case V4L2_MPEG2_PICTURE_CODING_TYPE_B:
1961 - break;
1962 - default:
1963 - return -EINVAL;
1964 - }
1965 -
1966 - break;
1967 -
1968 - case V4L2_CTRL_TYPE_MPEG2_QUANTIZATION:
1969 - break;
1970 -
1971 - case V4L2_CTRL_TYPE_FWHT_PARAMS:
1972 - p_fwht_params = p;
1973 - if (p_fwht_params->version < V4L2_FWHT_VERSION)
1974 - return -EINVAL;
1975 - if (!p_fwht_params->width || !p_fwht_params->height)
1976 - return -EINVAL;
1977 - break;
1978 -
1979 - case V4L2_CTRL_TYPE_H264_SPS:
1980 - p_h264_sps = p;
1981 -
1982 - /* Some syntax elements are only conditionally valid */
1983 - if (p_h264_sps->pic_order_cnt_type != 0) {
1984 - p_h264_sps->log2_max_pic_order_cnt_lsb_minus4 = 0;
1985 - } else if (p_h264_sps->pic_order_cnt_type != 1) {
1986 - p_h264_sps->num_ref_frames_in_pic_order_cnt_cycle = 0;
1987 - p_h264_sps->offset_for_non_ref_pic = 0;
1988 - p_h264_sps->offset_for_top_to_bottom_field = 0;
1989 - memset(&p_h264_sps->offset_for_ref_frame, 0,
1990 - sizeof(p_h264_sps->offset_for_ref_frame));
1991 - }
1992 -
1993 - if (!V4L2_H264_SPS_HAS_CHROMA_FORMAT(p_h264_sps)) {
1994 - p_h264_sps->chroma_format_idc = 1;
1995 - p_h264_sps->bit_depth_luma_minus8 = 0;
1996 - p_h264_sps->bit_depth_chroma_minus8 = 0;
1997 -
1998 - p_h264_sps->flags &=
1999 - ~V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS;
2000 -
2001 - if (p_h264_sps->chroma_format_idc < 3)
2002 - p_h264_sps->flags &=
2003 - ~V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE;
2004 - }
2005 -
2006 - if (p_h264_sps->flags & V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY)
2007 - p_h264_sps->flags &=
2008 - ~V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD;
2009 -
2010 - /*
2011 - * Chroma 4:2:2 format require at least High 4:2:2 profile.
2012 - *
2013 - * The H264 specification and well-known parser implementations
2014 - * use profile-idc values directly, as that is clearer and
2015 - * less ambiguous. We do the same here.
2016 - */
2017 - if (p_h264_sps->profile_idc < 122 &&
2018 - p_h264_sps->chroma_format_idc > 1)
2019 - return -EINVAL;
2020 - /* Chroma 4:4:4 format require at least High 4:2:2 profile */
2021 - if (p_h264_sps->profile_idc < 244 &&
2022 - p_h264_sps->chroma_format_idc > 2)
2023 - return -EINVAL;
2024 - if (p_h264_sps->chroma_format_idc > 3)
2025 - return -EINVAL;
2026 -
2027 - if (p_h264_sps->bit_depth_luma_minus8 > 6)
2028 - return -EINVAL;
2029 - if (p_h264_sps->bit_depth_chroma_minus8 > 6)
2030 - return -EINVAL;
2031 - if (p_h264_sps->log2_max_frame_num_minus4 > 12)
2032 - return -EINVAL;
2033 - if (p_h264_sps->pic_order_cnt_type > 2)
2034 - return -EINVAL;
2035 - if (p_h264_sps->log2_max_pic_order_cnt_lsb_minus4 > 12)
2036 - return -EINVAL;
2037 - if (p_h264_sps->max_num_ref_frames > V4L2_H264_REF_LIST_LEN)
2038 - return -EINVAL;
2039 - break;
2040 -
2041 - case V4L2_CTRL_TYPE_H264_PPS:
2042 - p_h264_pps = p;
2043 -
2044 - if (p_h264_pps->num_slice_groups_minus1 > 7)
2045 - return -EINVAL;
2046 - if (p_h264_pps->num_ref_idx_l0_default_active_minus1 >
2047 - (V4L2_H264_REF_LIST_LEN - 1))
2048 - return -EINVAL;
2049 - if (p_h264_pps->num_ref_idx_l1_default_active_minus1 >
2050 - (V4L2_H264_REF_LIST_LEN - 1))
2051 - return -EINVAL;
2052 - if (p_h264_pps->weighted_bipred_idc > 2)
2053 - return -EINVAL;
2054 - /*
2055 - * pic_init_qp_minus26 shall be in the range of
2056 - * -(26 + QpBdOffset_y) to +25, inclusive,
2057 - * where QpBdOffset_y is 6 * bit_depth_luma_minus8
2058 - */
2059 - if (p_h264_pps->pic_init_qp_minus26 < -62 ||
2060 - p_h264_pps->pic_init_qp_minus26 > 25)
2061 - return -EINVAL;
2062 - if (p_h264_pps->pic_init_qs_minus26 < -26 ||
2063 - p_h264_pps->pic_init_qs_minus26 > 25)
2064 - return -EINVAL;
2065 - if (p_h264_pps->chroma_qp_index_offset < -12 ||
2066 - p_h264_pps->chroma_qp_index_offset > 12)
2067 - return -EINVAL;
2068 - if (p_h264_pps->second_chroma_qp_index_offset < -12 ||
2069 - p_h264_pps->second_chroma_qp_index_offset > 12)
2070 - return -EINVAL;
2071 - break;
2072 -
2073 - case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
2074 - break;
2075 -
2076 - case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
2077 - p_h264_pred_weights = p;
2078 -
2079 - if (p_h264_pred_weights->luma_log2_weight_denom > 7)
2080 - return -EINVAL;
2081 - if (p_h264_pred_weights->chroma_log2_weight_denom > 7)
2082 - return -EINVAL;
2083 - break;
2084 -
2085 - case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
2086 - p_h264_slice_params = p;
2087 -
2088 - if (p_h264_slice_params->slice_type != V4L2_H264_SLICE_TYPE_B)
2089 - p_h264_slice_params->flags &=
2090 - ~V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED;
2091 -
2092 - if (p_h264_slice_params->colour_plane_id > 2)
2093 - return -EINVAL;
2094 - if (p_h264_slice_params->cabac_init_idc > 2)
2095 - return -EINVAL;
2096 - if (p_h264_slice_params->disable_deblocking_filter_idc > 2)
2097 - return -EINVAL;
2098 - if (p_h264_slice_params->slice_alpha_c0_offset_div2 < -6 ||
2099 - p_h264_slice_params->slice_alpha_c0_offset_div2 > 6)
2100 - return -EINVAL;
2101 - if (p_h264_slice_params->slice_beta_offset_div2 < -6 ||
2102 - p_h264_slice_params->slice_beta_offset_div2 > 6)
2103 - return -EINVAL;
2104 -
2105 - if (p_h264_slice_params->slice_type == V4L2_H264_SLICE_TYPE_I ||
2106 - p_h264_slice_params->slice_type == V4L2_H264_SLICE_TYPE_SI)
2107 - p_h264_slice_params->num_ref_idx_l0_active_minus1 = 0;
2108 - if (p_h264_slice_params->slice_type != V4L2_H264_SLICE_TYPE_B)
2109 - p_h264_slice_params->num_ref_idx_l1_active_minus1 = 0;
2110 -
2111 - if (p_h264_slice_params->num_ref_idx_l0_active_minus1 >
2112 - (V4L2_H264_REF_LIST_LEN - 1))
2113 - return -EINVAL;
2114 - if (p_h264_slice_params->num_ref_idx_l1_active_minus1 >
2115 - (V4L2_H264_REF_LIST_LEN - 1))
2116 - return -EINVAL;
2117 - zero_reserved(*p_h264_slice_params);
2118 - break;
2119 -
2120 - case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
2121 - p_h264_dec_params = p;
2122 -
2123 - if (p_h264_dec_params->nal_ref_idc > 3)
2124 - return -EINVAL;
2125 - for (i = 0; i < V4L2_H264_NUM_DPB_ENTRIES; i++) {
2126 - struct v4l2_h264_dpb_entry *dpb_entry =
2127 - &p_h264_dec_params->dpb[i];
2128 -
2129 - zero_reserved(*dpb_entry);
2130 - }
2131 - zero_reserved(*p_h264_dec_params);
2132 - break;
2133 -
2134 - case V4L2_CTRL_TYPE_VP8_FRAME:
2135 - p_vp8_frame = p;
2136 -
2137 - switch (p_vp8_frame->num_dct_parts) {
2138 - case 1:
2139 - case 2:
2140 - case 4:
2141 - case 8:
2142 - break;
2143 - default:
2144 - return -EINVAL;
2145 - }
2146 - zero_padding(p_vp8_frame->segment);
2147 - zero_padding(p_vp8_frame->lf);
2148 - zero_padding(p_vp8_frame->quant);
2149 - zero_padding(p_vp8_frame->entropy);
2150 - zero_padding(p_vp8_frame->coder_state);
2151 - break;
2152 -
2153 - case V4L2_CTRL_TYPE_HEVC_SPS:
2154 - p_hevc_sps = p;
2155 -
2156 - if (!(p_hevc_sps->flags & V4L2_HEVC_SPS_FLAG_PCM_ENABLED)) {
2157 - p_hevc_sps->pcm_sample_bit_depth_luma_minus1 = 0;
2158 - p_hevc_sps->pcm_sample_bit_depth_chroma_minus1 = 0;
2159 - p_hevc_sps->log2_min_pcm_luma_coding_block_size_minus3 = 0;
2160 - p_hevc_sps->log2_diff_max_min_pcm_luma_coding_block_size = 0;
2161 - }
2162 -
2163 - if (!(p_hevc_sps->flags &
2164 - V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT))
2165 - p_hevc_sps->num_long_term_ref_pics_sps = 0;
2166 - break;
2167 -
2168 - case V4L2_CTRL_TYPE_HEVC_PPS:
2169 - p_hevc_pps = p;
2170 -
2171 - if (!(p_hevc_pps->flags &
2172 - V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED))
2173 - p_hevc_pps->diff_cu_qp_delta_depth = 0;
2174 -
2175 - if (!(p_hevc_pps->flags & V4L2_HEVC_PPS_FLAG_TILES_ENABLED)) {
2176 - p_hevc_pps->num_tile_columns_minus1 = 0;
2177 - p_hevc_pps->num_tile_rows_minus1 = 0;
2178 - memset(&p_hevc_pps->column_width_minus1, 0,
2179 - sizeof(p_hevc_pps->column_width_minus1));
2180 - memset(&p_hevc_pps->row_height_minus1, 0,
2181 - sizeof(p_hevc_pps->row_height_minus1));
2182 -
2183 - p_hevc_pps->flags &=
2184 - ~V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED;
2185 - }
2186 -
2187 - if (p_hevc_pps->flags &
2188 - V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER) {
2189 - p_hevc_pps->pps_beta_offset_div2 = 0;
2190 - p_hevc_pps->pps_tc_offset_div2 = 0;
2191 - }
2192 -
2193 - zero_padding(*p_hevc_pps);
2194 - break;
2195 -
2196 - case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
2197 - p_hevc_slice_params = p;
2198 -
2199 - if (p_hevc_slice_params->num_active_dpb_entries >
2200 - V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
2201 - return -EINVAL;
2202 -
2203 - zero_padding(p_hevc_slice_params->pred_weight_table);
2204 -
2205 - for (i = 0; i < p_hevc_slice_params->num_active_dpb_entries;
2206 - i++) {
2207 - struct v4l2_hevc_dpb_entry *dpb_entry =
2208 - &p_hevc_slice_params->dpb[i];
2209 -
2210 - zero_padding(*dpb_entry);
2211 - }
2212 -
2213 - zero_padding(*p_hevc_slice_params);
2214 - break;
2215 -
2216 - case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
2217 - break;
2218 -
2219 - case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
2220 - p_hdr10_mastering = p;
2221 -
2222 - for (i = 0; i < 3; ++i) {
2223 - if (p_hdr10_mastering->display_primaries_x[i] <
2224 - V4L2_HDR10_MASTERING_PRIMARIES_X_LOW ||
2225 - p_hdr10_mastering->display_primaries_x[i] >
2226 - V4L2_HDR10_MASTERING_PRIMARIES_X_HIGH ||
2227 - p_hdr10_mastering->display_primaries_y[i] <
2228 - V4L2_HDR10_MASTERING_PRIMARIES_Y_LOW ||
2229 - p_hdr10_mastering->display_primaries_y[i] >
2230 - V4L2_HDR10_MASTERING_PRIMARIES_Y_HIGH)
2231 - return -EINVAL;
2232 - }
2233 -
2234 - if (p_hdr10_mastering->white_point_x <
2235 - V4L2_HDR10_MASTERING_WHITE_POINT_X_LOW ||
2236 - p_hdr10_mastering->white_point_x >
2237 - V4L2_HDR10_MASTERING_WHITE_POINT_X_HIGH ||
2238 - p_hdr10_mastering->white_point_y <
2239 - V4L2_HDR10_MASTERING_WHITE_POINT_Y_LOW ||
2240 - p_hdr10_mastering->white_point_y >
2241 - V4L2_HDR10_MASTERING_WHITE_POINT_Y_HIGH)
2242 - return -EINVAL;
2243 -
2244 - if (p_hdr10_mastering->max_display_mastering_luminance <
2245 - V4L2_HDR10_MASTERING_MAX_LUMA_LOW ||
2246 - p_hdr10_mastering->max_display_mastering_luminance >
2247 - V4L2_HDR10_MASTERING_MAX_LUMA_HIGH ||
2248 - p_hdr10_mastering->min_display_mastering_luminance <
2249 - V4L2_HDR10_MASTERING_MIN_LUMA_LOW ||
2250 - p_hdr10_mastering->min_display_mastering_luminance >
2251 - V4L2_HDR10_MASTERING_MIN_LUMA_HIGH)
2252 - return -EINVAL;
2253 -
2254 - /* The following restriction comes from ITU-T Rec. H.265 spec */
2255 - if (p_hdr10_mastering->max_display_mastering_luminance ==
2256 - V4L2_HDR10_MASTERING_MAX_LUMA_LOW &&
2257 - p_hdr10_mastering->min_display_mastering_luminance ==
2258 - V4L2_HDR10_MASTERING_MIN_LUMA_HIGH)
2259 - return -EINVAL;
2260 -
2261 - break;
2262 -
2263 - case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX:
2264 - break;
2265 -
2266 - case V4L2_CTRL_TYPE_AREA:
2267 - area = p;
2268 - if (!area->width || !area->height)
2269 - return -EINVAL;
2270 - break;
2271 -
2272 - default:
2273 - return -EINVAL;
2274 - }
2275 -
2276 - return 0;
2277 -}
2278 -
2279 -static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
2280 - union v4l2_ctrl_ptr ptr)
2281 -{
2282 - size_t len;
2283 - u64 offset;
2284 - s64 val;
2285 -
2286 - switch ((u32)ctrl->type) {
2287 - case V4L2_CTRL_TYPE_INTEGER:
2288 - return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
2289 - case V4L2_CTRL_TYPE_INTEGER64:
2290 - /*
2291 - * We can't use the ROUND_TO_RANGE define here due to
2292 - * the u64 divide that needs special care.
2293 - */
2294 - val = ptr.p_s64[idx];
2295 - if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2))
2296 - val = ctrl->maximum;
2297 - else
2298 - val += (s64)(ctrl->step / 2);
2299 - val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum);
2300 - offset = val - ctrl->minimum;
2301 - do_div(offset, ctrl->step);
2302 - ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step;
2303 - return 0;
2304 - case V4L2_CTRL_TYPE_U8:
2305 - return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl);
2306 - case V4L2_CTRL_TYPE_U16:
2307 - return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl);
2308 - case V4L2_CTRL_TYPE_U32:
2309 - return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl);
2310 -
2311 - case V4L2_CTRL_TYPE_BOOLEAN:
2312 - ptr.p_s32[idx] = !!ptr.p_s32[idx];
2313 - return 0;
2314 -
2315 - case V4L2_CTRL_TYPE_MENU:
2316 - case V4L2_CTRL_TYPE_INTEGER_MENU:
2317 - if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum)
2318 - return -ERANGE;
2319 - if (ptr.p_s32[idx] < BITS_PER_LONG_LONG &&
2320 - (ctrl->menu_skip_mask & BIT_ULL(ptr.p_s32[idx])))
2321 - return -EINVAL;
2322 - if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
2323 - ctrl->qmenu[ptr.p_s32[idx]][0] == '\0')
2324 - return -EINVAL;
2325 - return 0;
2326 -
2327 - case V4L2_CTRL_TYPE_BITMASK:
2328 - ptr.p_s32[idx] &= ctrl->maximum;
2329 - return 0;
2330 -
2331 - case V4L2_CTRL_TYPE_BUTTON:
2332 - case V4L2_CTRL_TYPE_CTRL_CLASS:
2333 - ptr.p_s32[idx] = 0;
2334 - return 0;
2335 -
2336 - case V4L2_CTRL_TYPE_STRING:
2337 - idx *= ctrl->elem_size;
2338 - len = strlen(ptr.p_char + idx);
2339 - if (len < ctrl->minimum)
2340 - return -ERANGE;
2341 - if ((len - (u32)ctrl->minimum) % (u32)ctrl->step)
2342 - return -ERANGE;
2343 - return 0;
2344 -
2345 - default:
2346 - return std_validate_compound(ctrl, idx, ptr);
2347 - }
2348 -}
2349 -
2350 -static const struct v4l2_ctrl_type_ops std_type_ops = {
2351 - .equal = std_equal,
2352 - .init = std_init,
2353 - .log = std_log,
2354 - .validate = std_validate,
2355 -};
2356 -
2357 -/* Helper function: copy the given control value back to the caller */
2358 -static int ptr_to_user(struct v4l2_ext_control *c,
2359 - struct v4l2_ctrl *ctrl,
2360 - union v4l2_ctrl_ptr ptr)
2361 -{
2362 - u32 len;
2363 -
2364 - if (ctrl->is_ptr && !ctrl->is_string)
2365 - return copy_to_user(c->ptr, ptr.p_const, c->size) ?
2366 - -EFAULT : 0;
2367 -
2368 - switch (ctrl->type) {
2369 - case V4L2_CTRL_TYPE_STRING:
2370 - len = strlen(ptr.p_char);
2371 - if (c->size < len + 1) {
2372 - c->size = ctrl->elem_size;
2373 - return -ENOSPC;
2374 - }
2375 - return copy_to_user(c->string, ptr.p_char, len + 1) ?
2376 - -EFAULT : 0;
2377 - case V4L2_CTRL_TYPE_INTEGER64:
2378 - c->value64 = *ptr.p_s64;
2379 - break;
2380 - default:
2381 - c->value = *ptr.p_s32;
2382 - break;
2383 - }
2384 - return 0;
2385 -}
2386 -
2387 -/* Helper function: copy the current control value back to the caller */
2388 -static int cur_to_user(struct v4l2_ext_control *c,
2389 - struct v4l2_ctrl *ctrl)
2390 -{
2391 - return ptr_to_user(c, ctrl, ctrl->p_cur);
2392 -}
2393 -
2394 -/* Helper function: copy the new control value back to the caller */
2395 -static int new_to_user(struct v4l2_ext_control *c,
2396 - struct v4l2_ctrl *ctrl)
2397 -{
2398 - return ptr_to_user(c, ctrl, ctrl->p_new);
2399 -}
2400 -
2401 -/* Helper function: copy the request value back to the caller */
2402 -static int req_to_user(struct v4l2_ext_control *c,
2403 - struct v4l2_ctrl_ref *ref)
2404 -{
2405 - return ptr_to_user(c, ref->ctrl, ref->p_req);
2406 -}
2407 -
2408 -/* Helper function: copy the initial control value back to the caller */
2409 -static int def_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
2410 -{
2411 - int idx;
2412 -
2413 - for (idx = 0; idx < ctrl->elems; idx++)
2414 - ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
2415 -
2416 - return ptr_to_user(c, ctrl, ctrl->p_new);
2417 -}
2418 -
2419 -/* Helper function: copy the caller-provider value to the given control value */
2420 -static int user_to_ptr(struct v4l2_ext_control *c,
2421 - struct v4l2_ctrl *ctrl,
2422 - union v4l2_ctrl_ptr ptr)
2423 -{
2424 - int ret;
2425 - u32 size;
2426 -
2427 - ctrl->is_new = 1;
2428 - if (ctrl->is_ptr && !ctrl->is_string) {
2429 - unsigned idx;
2430 -
2431 - ret = copy_from_user(ptr.p, c->ptr, c->size) ? -EFAULT : 0;
2432 - if (ret || !ctrl->is_array)
2433 - return ret;
2434 - for (idx = c->size / ctrl->elem_size; idx < ctrl->elems; idx++)
2435 - ctrl->type_ops->init(ctrl, idx, ptr);
2436 - return 0;
2437 - }
2438 -
2439 - switch (ctrl->type) {
2440 - case V4L2_CTRL_TYPE_INTEGER64:
2441 - *ptr.p_s64 = c->value64;
2442 - break;
2443 - case V4L2_CTRL_TYPE_STRING:
2444 - size = c->size;
2445 - if (size == 0)
2446 - return -ERANGE;
2447 - if (size > ctrl->maximum + 1)
2448 - size = ctrl->maximum + 1;
2449 - ret = copy_from_user(ptr.p_char, c->string, size) ? -EFAULT : 0;
2450 - if (!ret) {
2451 - char last = ptr.p_char[size - 1];
2452 -
2453 - ptr.p_char[size - 1] = 0;
2454 - /* If the string was longer than ctrl->maximum,
2455 - then return an error. */
2456 - if (strlen(ptr.p_char) == ctrl->maximum && last)
2457 - return -ERANGE;
2458 - }
2459 - return ret;
2460 - default:
2461 - *ptr.p_s32 = c->value;
2462 - break;
2463 - }
2464 - return 0;
2465 -}
2466 -
2467 -/* Helper function: copy the caller-provider value as the new control value */
2468 -static int user_to_new(struct v4l2_ext_control *c,
2469 - struct v4l2_ctrl *ctrl)
2470 -{
2471 - return user_to_ptr(c, ctrl, ctrl->p_new);
2472 -}
2473 -
2474 -/* Copy the one value to another. */
2475 -static void ptr_to_ptr(struct v4l2_ctrl *ctrl,
2476 - union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to)
2477 -{
2478 - if (ctrl == NULL)
2479 - return;
2480 - memcpy(to.p, from.p_const, ctrl->elems * ctrl->elem_size);
2481 -}
2482 -
2483 -/* Copy the new value to the current value. */
2484 -static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
2485 -{
2486 - bool changed;
2487 -
2488 - if (ctrl == NULL)
2489 - return;
2490 -
2491 - /* has_changed is set by cluster_changed */
2492 - changed = ctrl->has_changed;
2493 - if (changed)
2494 - ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur);
2495 -
2496 - if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
2497 - /* Note: CH_FLAGS is only set for auto clusters. */
2498 - ctrl->flags &=
2499 - ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
2500 - if (!is_cur_manual(ctrl->cluster[0])) {
2501 - ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
2502 - if (ctrl->cluster[0]->has_volatiles)
2503 - ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
2504 - }
2505 - fh = NULL;
2506 - }
2507 - if (changed || ch_flags) {
2508 - /* If a control was changed that was not one of the controls
2509 - modified by the application, then send the event to all. */
2510 - if (!ctrl->is_new)
2511 - fh = NULL;
2512 - send_event(fh, ctrl,
2513 - (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
2514 - if (ctrl->call_notify && changed && ctrl->handler->notify)
2515 - ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
2516 - }
2517 -}
2518 -
2519 -/* Copy the current value to the new value */
2520 -static void cur_to_new(struct v4l2_ctrl *ctrl)
2521 -{
2522 - if (ctrl == NULL)
2523 - return;
2524 - ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
2525 -}
2526 -
2527 -/* Copy the new value to the request value */
2528 -static void new_to_req(struct v4l2_ctrl_ref *ref)
2529 -{
2530 - if (!ref)
2531 - return;
2532 - ptr_to_ptr(ref->ctrl, ref->ctrl->p_new, ref->p_req);
2533 - ref->valid_p_req = true;
2534 -}
2535 -
2536 -/* Copy the current value to the request value */
2537 -static void cur_to_req(struct v4l2_ctrl_ref *ref)
2538 -{
2539 - if (!ref)
2540 - return;
2541 - ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->p_req);
2542 - ref->valid_p_req = true;
2543 -}
2544 -
2545 -/* Copy the request value to the new value */
2546 -static void req_to_new(struct v4l2_ctrl_ref *ref)
2547 -{
2548 - if (!ref)
2549 - return;
2550 - if (ref->valid_p_req)
2551 - ptr_to_ptr(ref->ctrl, ref->p_req, ref->ctrl->p_new);
2552 - else
2553 - ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->ctrl->p_new);
2554 -}
2555 -
2556 -/* Return non-zero if one or more of the controls in the cluster has a new
2557 - value that differs from the current value. */
2558 -static int cluster_changed(struct v4l2_ctrl *master)
2559 -{
2560 - bool changed = false;
2561 - unsigned idx;
2562 - int i;
2563 -
2564 - for (i = 0; i < master->ncontrols; i++) {
2565 - struct v4l2_ctrl *ctrl = master->cluster[i];
2566 - bool ctrl_changed = false;
2567 -
2568 - if (ctrl == NULL)
2569 - continue;
2570 -
2571 - if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE)
2572 - changed = ctrl_changed = true;
2573 -
2574 - /*
2575 - * Set has_changed to false to avoid generating
2576 - * the event V4L2_EVENT_CTRL_CH_VALUE
2577 - */
2578 - if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2579 - ctrl->has_changed = false;
2580 - continue;
2581 - }
2582 -
2583 - for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++)
2584 - ctrl_changed = !ctrl->type_ops->equal(ctrl, idx,
2585 - ctrl->p_cur, ctrl->p_new);
2586 - ctrl->has_changed = ctrl_changed;
2587 - changed |= ctrl->has_changed;
2588 - }
2589 - return changed;
2590 -}
2591 -
2592 -/* Control range checking */
2593 -static int check_range(enum v4l2_ctrl_type type,
2594 - s64 min, s64 max, u64 step, s64 def)
2595 -{
2596 - switch (type) {
2597 - case V4L2_CTRL_TYPE_BOOLEAN:
2598 - if (step != 1 || max > 1 || min < 0)
2599 - return -ERANGE;
2600 - fallthrough;
2601 - case V4L2_CTRL_TYPE_U8:
2602 - case V4L2_CTRL_TYPE_U16:
2603 - case V4L2_CTRL_TYPE_U32:
2604 - case V4L2_CTRL_TYPE_INTEGER:
2605 - case V4L2_CTRL_TYPE_INTEGER64:
2606 - if (step == 0 || min > max || def < min || def > max)
2607 - return -ERANGE;
2608 - return 0;
2609 - case V4L2_CTRL_TYPE_BITMASK:
2610 - if (step || min || !max || (def & ~max))
2611 - return -ERANGE;
2612 - return 0;
2613 - case V4L2_CTRL_TYPE_MENU:
2614 - case V4L2_CTRL_TYPE_INTEGER_MENU:
2615 - if (min > max || def < min || def > max)
2616 - return -ERANGE;
2617 - /* Note: step == menu_skip_mask for menu controls.
2618 - So here we check if the default value is masked out. */
2619 - if (step && ((1 << def) & step))
2620 - return -EINVAL;
2621 - return 0;
2622 - case V4L2_CTRL_TYPE_STRING:
2623 - if (min > max || min < 0 || step < 1 || def)
2624 - return -ERANGE;
2625 - return 0;
2626 - default:
2627 - return 0;
2628 - }
2629 -}
2630 -
2631 -/* Validate a new control */
2632 -static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
2633 -{
2634 - unsigned idx;
2635 - int err = 0;
2636 -
2637 - for (idx = 0; !err && idx < ctrl->elems; idx++)
2638 - err = ctrl->type_ops->validate(ctrl, idx, p_new);
2639 - return err;
2640 -}
2641 -
2642 -static inline u32 node2id(struct list_head *node)
2643 -{
2644 - return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
2645 -}
2646 -
2647 -/* Set the handler's error code if it wasn't set earlier already */
2648 -static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
2649 -{
2650 - if (hdl->error == 0)
2651 - hdl->error = err;
2652 - return err;
2653 -}
2654 -
2655 -/* Initialize the handler */
2656 -int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
2657 - unsigned nr_of_controls_hint,
2658 - struct lock_class_key *key, const char *name)
2659 -{
2660 - mutex_init(&hdl->_lock);
2661 - hdl->lock = &hdl->_lock;
2662 - lockdep_set_class_and_name(hdl->lock, key, name);
2663 - INIT_LIST_HEAD(&hdl->ctrls);
2664 - INIT_LIST_HEAD(&hdl->ctrl_refs);
2665 - INIT_LIST_HEAD(&hdl->requests);
2666 - INIT_LIST_HEAD(&hdl->requests_queued);
2667 - hdl->request_is_queued = false;
2668 - hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
2669 - hdl->buckets = kvmalloc_array(hdl->nr_of_buckets,
2670 - sizeof(hdl->buckets[0]),
2671 - GFP_KERNEL | __GFP_ZERO);
2672 - hdl->error = hdl->buckets ? 0 : -ENOMEM;
2673 - media_request_object_init(&hdl->req_obj);
2674 - return hdl->error;
2675 -}
2676 -EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
2677 -
2678 -/* Free all controls and control refs */
2679 -void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
2680 -{
2681 - struct v4l2_ctrl_ref *ref, *next_ref;
2682 - struct v4l2_ctrl *ctrl, *next_ctrl;
2683 - struct v4l2_subscribed_event *sev, *next_sev;
2684 -
2685 - if (hdl == NULL || hdl->buckets == NULL)
2686 - return;
2687 -
2688 - /*
2689 - * If the main handler is freed and it is used by handler objects in
2690 - * outstanding requests, then unbind and put those objects before
2691 - * freeing the main handler.
2692 - *
2693 - * The main handler can be identified by having a NULL ops pointer in
2694 - * the request object.
2695 - */
2696 - if (!hdl->req_obj.ops && !list_empty(&hdl->requests)) {
2697 - struct v4l2_ctrl_handler *req, *next_req;
2698 -
2699 - list_for_each_entry_safe(req, next_req, &hdl->requests, requests) {
2700 - media_request_object_unbind(&req->req_obj);
2701 - media_request_object_put(&req->req_obj);
2702 - }
2703 - }
2704 - mutex_lock(hdl->lock);
2705 - /* Free all nodes */
2706 - list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
2707 - list_del(&ref->node);
2708 - kfree(ref);
2709 - }
2710 - /* Free all controls owned by the handler */
2711 - list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
2712 - list_del(&ctrl->node);
2713 - list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
2714 - list_del(&sev->node);
2715 - kvfree(ctrl);
2716 - }
2717 - kvfree(hdl->buckets);
2718 - hdl->buckets = NULL;
2719 - hdl->cached = NULL;
2720 - hdl->error = 0;
2721 - mutex_unlock(hdl->lock);
2722 - mutex_destroy(&hdl->_lock);
2723 -}
2724 -EXPORT_SYMBOL(v4l2_ctrl_handler_free);
2725 -
2726 -/* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
2727 - be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
2728 - with applications that do not use the NEXT_CTRL flag.
2729 -
2730 - We just find the n-th private user control. It's O(N), but that should not
2731 - be an issue in this particular case. */
2732 -static struct v4l2_ctrl_ref *find_private_ref(
2733 - struct v4l2_ctrl_handler *hdl, u32 id)
2734 -{
2735 - struct v4l2_ctrl_ref *ref;
2736 -
2737 - id -= V4L2_CID_PRIVATE_BASE;
2738 - list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2739 - /* Search for private user controls that are compatible with
2740 - VIDIOC_G/S_CTRL. */
2741 - if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
2742 - V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
2743 - if (!ref->ctrl->is_int)
2744 - continue;
2745 - if (id == 0)
2746 - return ref;
2747 - id--;
2748 - }
2749 - }
2750 - return NULL;
2751 -}
2752 -
2753 -/* Find a control with the given ID. */
2754 -static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
2755 -{
2756 - struct v4l2_ctrl_ref *ref;
2757 - int bucket;
2758 -
2759 - id &= V4L2_CTRL_ID_MASK;
2760 -
2761 - /* Old-style private controls need special handling */
2762 - if (id >= V4L2_CID_PRIVATE_BASE)
2763 - return find_private_ref(hdl, id);
2764 - bucket = id % hdl->nr_of_buckets;
2765 -
2766 - /* Simple optimization: cache the last control found */
2767 - if (hdl->cached && hdl->cached->ctrl->id == id)
2768 - return hdl->cached;
2769 -
2770 - /* Not in cache, search the hash */
2771 - ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
2772 - while (ref && ref->ctrl->id != id)
2773 - ref = ref->next;
2774 -
2775 - if (ref)
2776 - hdl->cached = ref; /* cache it! */
2777 - return ref;
2778 -}
2779 -
2780 -/* Find a control with the given ID. Take the handler's lock first. */
2781 -static struct v4l2_ctrl_ref *find_ref_lock(
2782 - struct v4l2_ctrl_handler *hdl, u32 id)
2783 -{
2784 - struct v4l2_ctrl_ref *ref = NULL;
2785 -
2786 - if (hdl) {
2787 - mutex_lock(hdl->lock);
2788 - ref = find_ref(hdl, id);
2789 - mutex_unlock(hdl->lock);
2790 - }
2791 - return ref;
2792 -}
2793 -
2794 -/* Find a control with the given ID. */
2795 -struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
2796 -{
2797 - struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
2798 -
2799 - return ref ? ref->ctrl : NULL;
2800 -}
2801 -EXPORT_SYMBOL(v4l2_ctrl_find);
2802 -
2803 -/* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
2804 -static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
2805 - struct v4l2_ctrl *ctrl,
2806 - struct v4l2_ctrl_ref **ctrl_ref,
2807 - bool from_other_dev, bool allocate_req)
2808 -{
2809 - struct v4l2_ctrl_ref *ref;
2810 - struct v4l2_ctrl_ref *new_ref;
2811 - u32 id = ctrl->id;
2812 - u32 class_ctrl = V4L2_CTRL_ID2WHICH(id) | 1;
2813 - int bucket = id % hdl->nr_of_buckets; /* which bucket to use */
2814 - unsigned int size_extra_req = 0;
2815 -
2816 - if (ctrl_ref)
2817 - *ctrl_ref = NULL;
2818 -
2819 - /*
2820 - * Automatically add the control class if it is not yet present and
2821 - * the new control is not a compound control.
2822 - */
2823 - if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES &&
2824 - id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
2825 - if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
2826 - return hdl->error;
2827 -
2828 - if (hdl->error)
2829 - return hdl->error;
2830 -
2831 - if (allocate_req)
2832 - size_extra_req = ctrl->elems * ctrl->elem_size;
2833 - new_ref = kzalloc(sizeof(*new_ref) + size_extra_req, GFP_KERNEL);
2834 - if (!new_ref)
2835 - return handler_set_err(hdl, -ENOMEM);
2836 - new_ref->ctrl = ctrl;
2837 - new_ref->from_other_dev = from_other_dev;
2838 - if (size_extra_req)
2839 - new_ref->p_req.p = &new_ref[1];
2840 -
2841 - INIT_LIST_HEAD(&new_ref->node);
2842 -
2843 - mutex_lock(hdl->lock);
2844 -
2845 - /* Add immediately at the end of the list if the list is empty, or if
2846 - the last element in the list has a lower ID.
2847 - This ensures that when elements are added in ascending order the
2848 - insertion is an O(1) operation. */
2849 - if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
2850 - list_add_tail(&new_ref->node, &hdl->ctrl_refs);
2851 - goto insert_in_hash;
2852 - }
2853 -
2854 - /* Find insert position in sorted list */
2855 - list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2856 - if (ref->ctrl->id < id)
2857 - continue;
2858 - /* Don't add duplicates */
2859 - if (ref->ctrl->id == id) {
2860 - kfree(new_ref);
2861 - goto unlock;
2862 - }
2863 - list_add(&new_ref->node, ref->node.prev);
2864 - break;
2865 - }
2866 -
2867 -insert_in_hash:
2868 - /* Insert the control node in the hash */
2869 - new_ref->next = hdl->buckets[bucket];
2870 - hdl->buckets[bucket] = new_ref;
2871 - if (ctrl_ref)
2872 - *ctrl_ref = new_ref;
2873 - if (ctrl->handler == hdl) {
2874 - /* By default each control starts in a cluster of its own.
2875 - * new_ref->ctrl is basically a cluster array with one
2876 - * element, so that's perfect to use as the cluster pointer.
2877 - * But only do this for the handler that owns the control.
2878 - */
2879 - ctrl->cluster = &new_ref->ctrl;
2880 - ctrl->ncontrols = 1;
2881 - }
2882 -
2883 -unlock:
2884 - mutex_unlock(hdl->lock);
2885 - return 0;
2886 -}
2887 -
2888 -/* Add a new control */
2889 -static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
2890 - const struct v4l2_ctrl_ops *ops,
2891 - const struct v4l2_ctrl_type_ops *type_ops,
2892 - u32 id, const char *name, enum v4l2_ctrl_type type,
2893 - s64 min, s64 max, u64 step, s64 def,
2894 - const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
2895 - u32 flags, const char * const *qmenu,
2896 - const s64 *qmenu_int, const union v4l2_ctrl_ptr p_def,
2897 - void *priv)
2898 -{
2899 - struct v4l2_ctrl *ctrl;
2900 - unsigned sz_extra;
2901 - unsigned nr_of_dims = 0;
2902 - unsigned elems = 1;
2903 - bool is_array;
2904 - unsigned tot_ctrl_size;
2905 - unsigned idx;
2906 - void *data;
2907 - int err;
2908 -
2909 - if (hdl->error)
2910 - return NULL;
2911 -
2912 - while (dims && dims[nr_of_dims]) {
2913 - elems *= dims[nr_of_dims];
2914 - nr_of_dims++;
2915 - if (nr_of_dims == V4L2_CTRL_MAX_DIMS)
2916 - break;
2917 - }
2918 - is_array = nr_of_dims > 0;
2919 -
2920 - /* Prefill elem_size for all types handled by std_type_ops */
2921 - switch ((u32)type) {
2922 - case V4L2_CTRL_TYPE_INTEGER64:
2923 - elem_size = sizeof(s64);
2924 - break;
2925 - case V4L2_CTRL_TYPE_STRING:
2926 - elem_size = max + 1;
2927 - break;
2928 - case V4L2_CTRL_TYPE_U8:
2929 - elem_size = sizeof(u8);
2930 - break;
2931 - case V4L2_CTRL_TYPE_U16:
2932 - elem_size = sizeof(u16);
2933 - break;
2934 - case V4L2_CTRL_TYPE_U32:
2935 - elem_size = sizeof(u32);
2936 - break;
2937 - case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS:
2938 - elem_size = sizeof(struct v4l2_ctrl_mpeg2_slice_params);
2939 - break;
2940 - case V4L2_CTRL_TYPE_MPEG2_QUANTIZATION:
2941 - elem_size = sizeof(struct v4l2_ctrl_mpeg2_quantization);
2942 - break;
2943 - case V4L2_CTRL_TYPE_FWHT_PARAMS:
2944 - elem_size = sizeof(struct v4l2_ctrl_fwht_params);
2945 - break;
2946 - case V4L2_CTRL_TYPE_H264_SPS:
2947 - elem_size = sizeof(struct v4l2_ctrl_h264_sps);
2948 - break;
2949 - case V4L2_CTRL_TYPE_H264_PPS:
2950 - elem_size = sizeof(struct v4l2_ctrl_h264_pps);
2951 - break;
2952 - case V4L2_CTRL_TYPE_H264_SCALING_MATRIX:
2953 - elem_size = sizeof(struct v4l2_ctrl_h264_scaling_matrix);
2954 - break;
2955 - case V4L2_CTRL_TYPE_H264_SLICE_PARAMS:
2956 - elem_size = sizeof(struct v4l2_ctrl_h264_slice_params);
2957 - break;
2958 - case V4L2_CTRL_TYPE_H264_DECODE_PARAMS:
2959 - elem_size = sizeof(struct v4l2_ctrl_h264_decode_params);
2960 - break;
2961 - case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
2962 - elem_size = sizeof(struct v4l2_ctrl_h264_pred_weights);
2963 - break;
2964 - case V4L2_CTRL_TYPE_VP8_FRAME:
2965 - elem_size = sizeof(struct v4l2_ctrl_vp8_frame);
2966 - break;
2967 - case V4L2_CTRL_TYPE_HEVC_SPS:
2968 - elem_size = sizeof(struct v4l2_ctrl_hevc_sps);
2969 - break;
2970 - case V4L2_CTRL_TYPE_HEVC_PPS:
2971 - elem_size = sizeof(struct v4l2_ctrl_hevc_pps);
2972 - break;
2973 - case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
2974 - elem_size = sizeof(struct v4l2_ctrl_hevc_slice_params);
2975 - break;
2976 - case V4L2_CTRL_TYPE_HDR10_CLL_INFO:
2977 - elem_size = sizeof(struct v4l2_ctrl_hdr10_cll_info);
2978 - break;
2979 - case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY:
2980 - elem_size = sizeof(struct v4l2_ctrl_hdr10_mastering_display);
2981 - break;
2982 - case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX:
2983 - elem_size = sizeof(struct v4l2_ctrl_hevc_scaling_matrix);
2984 - break;
2985 - case V4L2_CTRL_TYPE_AREA:
2986 - elem_size = sizeof(struct v4l2_area);
2987 - break;
2988 - default:
2989 - if (type < V4L2_CTRL_COMPOUND_TYPES)
2990 - elem_size = sizeof(s32);
2991 - break;
2992 - }
2993 - tot_ctrl_size = elem_size * elems;
2994 -
2995 - /* Sanity checks */
2996 - if (id == 0 || name == NULL || !elem_size ||
2997 - id >= V4L2_CID_PRIVATE_BASE ||
2998 - (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
2999 - (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
3000 - handler_set_err(hdl, -ERANGE);
3001 - return NULL;
3002 - }
3003 - err = check_range(type, min, max, step, def);
3004 - if (err) {
3005 - handler_set_err(hdl, err);
3006 - return NULL;
3007 - }
3008 - if (is_array &&
3009 - (type == V4L2_CTRL_TYPE_BUTTON ||
3010 - type == V4L2_CTRL_TYPE_CTRL_CLASS)) {
3011 - handler_set_err(hdl, -EINVAL);
3012 - return NULL;
3013 - }
3014 -
3015 - sz_extra = 0;
3016 - if (type == V4L2_CTRL_TYPE_BUTTON)
3017 - flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
3018 - V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
3019 - else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
3020 - flags |= V4L2_CTRL_FLAG_READ_ONLY;
3021 - else if (type == V4L2_CTRL_TYPE_INTEGER64 ||
3022 - type == V4L2_CTRL_TYPE_STRING ||
3023 - type >= V4L2_CTRL_COMPOUND_TYPES ||
3024 - is_array)
3025 - sz_extra += 2 * tot_ctrl_size;
3026 -
3027 - if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const)
3028 - sz_extra += elem_size;
3029 -
3030 - ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
3031 - if (ctrl == NULL) {
3032 - handler_set_err(hdl, -ENOMEM);
3033 - return NULL;
3034 - }
3035 -
3036 - INIT_LIST_HEAD(&ctrl->node);
3037 - INIT_LIST_HEAD(&ctrl->ev_subs);
3038 - ctrl->handler = hdl;
3039 - ctrl->ops = ops;
3040 - ctrl->type_ops = type_ops ? type_ops : &std_type_ops;
3041 - ctrl->id = id;
3042 - ctrl->name = name;
3043 - ctrl->type = type;
3044 - ctrl->flags = flags;
3045 - ctrl->minimum = min;
3046 - ctrl->maximum = max;
3047 - ctrl->step = step;
3048 - ctrl->default_value = def;
3049 - ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING;
3050 - ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string;
3051 - ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64;
3052 - ctrl->is_array = is_array;
3053 - ctrl->elems = elems;
3054 - ctrl->nr_of_dims = nr_of_dims;
3055 - if (nr_of_dims)
3056 - memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0]));
3057 - ctrl->elem_size = elem_size;
3058 - if (type == V4L2_CTRL_TYPE_MENU)
3059 - ctrl->qmenu = qmenu;
3060 - else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
3061 - ctrl->qmenu_int = qmenu_int;
3062 - ctrl->priv = priv;
3063 - ctrl->cur.val = ctrl->val = def;
3064 - data = &ctrl[1];
3065 -
3066 - if (!ctrl->is_int) {
3067 - ctrl->p_new.p = data;
3068 - ctrl->p_cur.p = data + tot_ctrl_size;
3069 - } else {
3070 - ctrl->p_new.p = &ctrl->val;
3071 - ctrl->p_cur.p = &ctrl->cur.val;
3072 - }
3073 -
3074 - if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const) {
3075 - ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size;
3076 - memcpy(ctrl->p_def.p, p_def.p_const, elem_size);
3077 - }
3078 -
3079 - for (idx = 0; idx < elems; idx++) {
3080 - ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
3081 - ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
3082 - }
3083 -
3084 - if (handler_new_ref(hdl, ctrl, NULL, false, false)) {
3085 - kvfree(ctrl);
3086 - return NULL;
3087 - }
3088 - mutex_lock(hdl->lock);
3089 - list_add_tail(&ctrl->node, &hdl->ctrls);
3090 - mutex_unlock(hdl->lock);
3091 - return ctrl;
3092 -}
3093 -
3094 -struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
3095 - const struct v4l2_ctrl_config *cfg, void *priv)
3096 -{
3097 - bool is_menu;
3098 - struct v4l2_ctrl *ctrl;
3099 - const char *name = cfg->name;
3100 - const char * const *qmenu = cfg->qmenu;
3101 - const s64 *qmenu_int = cfg->qmenu_int;
3102 - enum v4l2_ctrl_type type = cfg->type;
3103 - u32 flags = cfg->flags;
3104 - s64 min = cfg->min;
3105 - s64 max = cfg->max;
3106 - u64 step = cfg->step;
3107 - s64 def = cfg->def;
3108 -
3109 - if (name == NULL)
3110 - v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
3111 - &def, &flags);
3112 -
3113 - is_menu = (type == V4L2_CTRL_TYPE_MENU ||
3114 - type == V4L2_CTRL_TYPE_INTEGER_MENU);
3115 - if (is_menu)
3116 - WARN_ON(step);
3117 - else
3118 - WARN_ON(cfg->menu_skip_mask);
3119 - if (type == V4L2_CTRL_TYPE_MENU && !qmenu) {
3120 - qmenu = v4l2_ctrl_get_menu(cfg->id);
3121 - } else if (type == V4L2_CTRL_TYPE_INTEGER_MENU && !qmenu_int) {
3122 - handler_set_err(hdl, -EINVAL);
3123 - return NULL;
3124 - }
3125 -
3126 - ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name,
3127 - type, min, max,
3128 - is_menu ? cfg->menu_skip_mask : step, def,
3129 - cfg->dims, cfg->elem_size,
3130 - flags, qmenu, qmenu_int, cfg->p_def, priv);
3131 - if (ctrl)
3132 - ctrl->is_private = cfg->is_private;
3133 - return ctrl;
3134 -}
3135 -EXPORT_SYMBOL(v4l2_ctrl_new_custom);
3136 -
3137 -/* Helper function for standard non-menu controls */
3138 -struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
3139 - const struct v4l2_ctrl_ops *ops,
3140 - u32 id, s64 min, s64 max, u64 step, s64 def)
3141 -{
3142 - const char *name;
3143 - enum v4l2_ctrl_type type;
3144 - u32 flags;
3145 -
3146 - v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
3147 - if (type == V4L2_CTRL_TYPE_MENU ||
3148 - type == V4L2_CTRL_TYPE_INTEGER_MENU ||
3149 - type >= V4L2_CTRL_COMPOUND_TYPES) {
3150 - handler_set_err(hdl, -EINVAL);
3151 - return NULL;
3152 - }
3153 - return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
3154 - min, max, step, def, NULL, 0,
3155 - flags, NULL, NULL, ptr_null, NULL);
3156 -}
3157 -EXPORT_SYMBOL(v4l2_ctrl_new_std);
3158 -
3159 -/* Helper function for standard menu controls */
3160 -struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
3161 - const struct v4l2_ctrl_ops *ops,
3162 - u32 id, u8 _max, u64 mask, u8 _def)
3163 -{
3164 - const char * const *qmenu = NULL;
3165 - const s64 *qmenu_int = NULL;
3166 - unsigned int qmenu_int_len = 0;
3167 - const char *name;
3168 - enum v4l2_ctrl_type type;
3169 - s64 min;
3170 - s64 max = _max;
3171 - s64 def = _def;
3172 - u64 step;
3173 - u32 flags;
3174 -
3175 - v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
3176 -
3177 - if (type == V4L2_CTRL_TYPE_MENU)
3178 - qmenu = v4l2_ctrl_get_menu(id);
3179 - else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
3180 - qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
3181 -
3182 - if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
3183 - handler_set_err(hdl, -EINVAL);
3184 - return NULL;
3185 - }
3186 - return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
3187 - 0, max, mask, def, NULL, 0,
3188 - flags, qmenu, qmenu_int, ptr_null, NULL);
3189 -}
3190 -EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
3191 -
3192 -/* Helper function for standard menu controls with driver defined menu */
3193 -struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
3194 - const struct v4l2_ctrl_ops *ops, u32 id, u8 _max,
3195 - u64 mask, u8 _def, const char * const *qmenu)
3196 -{
3197 - enum v4l2_ctrl_type type;
3198 - const char *name;
3199 - u32 flags;
3200 - u64 step;
3201 - s64 min;
3202 - s64 max = _max;
3203 - s64 def = _def;
3204 -
3205 - /* v4l2_ctrl_new_std_menu_items() should only be called for
3206 - * standard controls without a standard menu.
3207 - */
3208 - if (v4l2_ctrl_get_menu(id)) {
3209 - handler_set_err(hdl, -EINVAL);
3210 - return NULL;
3211 - }
3212 -
3213 - v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
3214 - if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
3215 - handler_set_err(hdl, -EINVAL);
3216 - return NULL;
3217 - }
3218 - return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
3219 - 0, max, mask, def, NULL, 0,
3220 - flags, qmenu, NULL, ptr_null, NULL);
3221 -
3222 -}
3223 -EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
3224 -
3225 -/* Helper function for standard compound controls */
3226 -struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl,
3227 - const struct v4l2_ctrl_ops *ops, u32 id,
3228 - const union v4l2_ctrl_ptr p_def)
3229 -{
3230 - const char *name;
3231 - enum v4l2_ctrl_type type;
3232 - u32 flags;
3233 - s64 min, max, step, def;
3234 -
3235 - v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
3236 - if (type < V4L2_CTRL_COMPOUND_TYPES) {
3237 - handler_set_err(hdl, -EINVAL);
3238 - return NULL;
3239 - }
3240 - return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
3241 - min, max, step, def, NULL, 0,
3242 - flags, NULL, NULL, p_def, NULL);
3243 -}
3244 -EXPORT_SYMBOL(v4l2_ctrl_new_std_compound);
3245 -
3246 -/* Helper function for standard integer menu controls */
3247 -struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
3248 - const struct v4l2_ctrl_ops *ops,
3249 - u32 id, u8 _max, u8 _def, const s64 *qmenu_int)
3250 -{
3251 - const char *name;
3252 - enum v4l2_ctrl_type type;
3253 - s64 min;
3254 - u64 step;
3255 - s64 max = _max;
3256 - s64 def = _def;
3257 - u32 flags;
3258 -
3259 - v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
3260 - if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
3261 - handler_set_err(hdl, -EINVAL);
3262 - return NULL;
3263 - }
3264 - return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
3265 - 0, max, 0, def, NULL, 0,
3266 - flags, NULL, qmenu_int, ptr_null, NULL);
3267 -}
3268 -EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
3269 -
3270 -/* Add the controls from another handler to our own. */
3271 -int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
3272 - struct v4l2_ctrl_handler *add,
3273 - bool (*filter)(const struct v4l2_ctrl *ctrl),
3274 - bool from_other_dev)
3275 -{
3276 - struct v4l2_ctrl_ref *ref;
3277 - int ret = 0;
3278 -
3279 - /* Do nothing if either handler is NULL or if they are the same */
3280 - if (!hdl || !add || hdl == add)
3281 - return 0;
3282 - if (hdl->error)
3283 - return hdl->error;
3284 - mutex_lock(add->lock);
3285 - list_for_each_entry(ref, &add->ctrl_refs, node) {
3286 - struct v4l2_ctrl *ctrl = ref->ctrl;
3287 -
3288 - /* Skip handler-private controls. */
3289 - if (ctrl->is_private)
3290 - continue;
3291 - /* And control classes */
3292 - if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
3293 - continue;
3294 - /* Filter any unwanted controls */
3295 - if (filter && !filter(ctrl))
3296 - continue;
3297 - ret = handler_new_ref(hdl, ctrl, NULL, from_other_dev, false);
3298 - if (ret)
3299 - break;
3300 - }
3301 - mutex_unlock(add->lock);
3302 - return ret;
3303 -}
3304 -EXPORT_SYMBOL(v4l2_ctrl_add_handler);
3305 -
3306 -bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
3307 -{
3308 - if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
3309 - return true;
3310 - if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
3311 - return true;
3312 - switch (ctrl->id) {
3313 - case V4L2_CID_AUDIO_MUTE:
3314 - case V4L2_CID_AUDIO_VOLUME:
3315 - case V4L2_CID_AUDIO_BALANCE:
3316 - case V4L2_CID_AUDIO_BASS:
3317 - case V4L2_CID_AUDIO_TREBLE:
3318 - case V4L2_CID_AUDIO_LOUDNESS:
3319 - return true;
3320 - default:
3321 - break;
3322 - }
3323 - return false;
3324 -}
3325 -EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
3326 -
3327 -/* Cluster controls */
3328 -void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
3329 -{
3330 - bool has_volatiles = false;
3331 - int i;
3332 -
3333 - /* The first control is the master control and it must not be NULL */
3334 - if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
3335 - return;
3336 -
3337 - for (i = 0; i < ncontrols; i++) {
3338 - if (controls[i]) {
3339 - controls[i]->cluster = controls;
3340 - controls[i]->ncontrols = ncontrols;
3341 - if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
3342 - has_volatiles = true;
3343 - }
3344 - }
3345 - controls[0]->has_volatiles = has_volatiles;
3346 -}
3347 -EXPORT_SYMBOL(v4l2_ctrl_cluster);
3348 -
3349 -void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
3350 - u8 manual_val, bool set_volatile)
3351 -{
3352 - struct v4l2_ctrl *master = controls[0];
3353 - u32 flag = 0;
3354 - int i;
3355 -
3356 - v4l2_ctrl_cluster(ncontrols, controls);
3357 - WARN_ON(ncontrols <= 1);
3358 - WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
3359 - WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
3360 - master->is_auto = true;
3361 - master->has_volatiles = set_volatile;
3362 - master->manual_mode_value = manual_val;
3363 - master->flags |= V4L2_CTRL_FLAG_UPDATE;
3364 -
3365 - if (!is_cur_manual(master))
3366 - flag = V4L2_CTRL_FLAG_INACTIVE |
3367 - (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
3368 -
3369 - for (i = 1; i < ncontrols; i++)
3370 - if (controls[i])
3371 - controls[i]->flags |= flag;
3372 -}
3373 -EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
3374 -
3375 -/* Activate/deactivate a control. */
3376 -void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
3377 -{
3378 - /* invert since the actual flag is called 'inactive' */
3379 - bool inactive = !active;
3380 - bool old;
3381 -
3382 - if (ctrl == NULL)
3383 - return;
3384 -
3385 - if (inactive)
3386 - /* set V4L2_CTRL_FLAG_INACTIVE */
3387 - old = test_and_set_bit(4, &ctrl->flags);
3388 - else
3389 - /* clear V4L2_CTRL_FLAG_INACTIVE */
3390 - old = test_and_clear_bit(4, &ctrl->flags);
3391 - if (old != inactive)
3392 - send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
3393 -}
3394 -EXPORT_SYMBOL(v4l2_ctrl_activate);
3395 -
3396 -void __v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
3397 -{
3398 - bool old;
3399 -
3400 - if (ctrl == NULL)
3401 - return;
3402 -
3403 - lockdep_assert_held(ctrl->handler->lock);
3404 -
3405 - if (grabbed)
3406 - /* set V4L2_CTRL_FLAG_GRABBED */
3407 - old = test_and_set_bit(1, &ctrl->flags);
3408 - else
3409 - /* clear V4L2_CTRL_FLAG_GRABBED */
3410 - old = test_and_clear_bit(1, &ctrl->flags);
3411 - if (old != grabbed)
3412 - send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
3413 -}
3414 -EXPORT_SYMBOL(__v4l2_ctrl_grab);
3415 -
3416 -/* Log the control name and value */
3417 -static void log_ctrl(const struct v4l2_ctrl *ctrl,
3418 - const char *prefix, const char *colon)
3419 -{
3420 - if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
3421 - return;
3422 - if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
3423 - return;
3424 -
3425 - pr_info("%s%s%s: ", prefix, colon, ctrl->name);
3426 -
3427 - ctrl->type_ops->log(ctrl);
3428 -
3429 - if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
3430 - V4L2_CTRL_FLAG_GRABBED |
3431 - V4L2_CTRL_FLAG_VOLATILE)) {
3432 - if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
3433 - pr_cont(" inactive");
3434 - if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
3435 - pr_cont(" grabbed");
3436 - if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
3437 - pr_cont(" volatile");
3438 - }
3439 - pr_cont("\n");
3440 -}
3441 -
3442 -/* Log all controls owned by the handler */
3443 -void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
3444 - const char *prefix)
3445 -{
3446 - struct v4l2_ctrl *ctrl;
3447 - const char *colon = "";
3448 - int len;
3449 -
3450 - if (hdl == NULL)
3451 - return;
3452 - if (prefix == NULL)
3453 - prefix = "";
3454 - len = strlen(prefix);
3455 - if (len && prefix[len - 1] != ' ')
3456 - colon = ": ";
3457 - mutex_lock(hdl->lock);
3458 - list_for_each_entry(ctrl, &hdl->ctrls, node)
3459 - if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
3460 - log_ctrl(ctrl, prefix, colon);
3461 - mutex_unlock(hdl->lock);
3462 -}
3463 -EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
3464 -
3465 -int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
3466 -{
3467 - v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
3468 - return 0;
3469 -}
3470 -EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
3471 -
3472 -/* Call s_ctrl for all controls owned by the handler */
3473 -int __v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
3474 -{
3475 - struct v4l2_ctrl *ctrl;
3476 - int ret = 0;
3477 -
3478 - if (hdl == NULL)
3479 - return 0;
3480 -
3481 - lockdep_assert_held(hdl->lock);
3482 -
3483 - list_for_each_entry(ctrl, &hdl->ctrls, node)
3484 - ctrl->done = false;
3485 -
3486 - list_for_each_entry(ctrl, &hdl->ctrls, node) {
3487 - struct v4l2_ctrl *master = ctrl->cluster[0];
3488 - int i;
3489 -
3490 - /* Skip if this control was already handled by a cluster. */
3491 - /* Skip button controls and read-only controls. */
3492 - if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
3493 - (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
3494 - continue;
3495 -
3496 - for (i = 0; i < master->ncontrols; i++) {
3497 - if (master->cluster[i]) {
3498 - cur_to_new(master->cluster[i]);
3499 - master->cluster[i]->is_new = 1;
3500 - master->cluster[i]->done = true;
3501 - }
3502 - }
3503 - ret = call_op(master, s_ctrl);
3504 - if (ret)
3505 - break;
3506 - }
3507 -
3508 - return ret;
3509 -}
3510 -EXPORT_SYMBOL_GPL(__v4l2_ctrl_handler_setup);
3511 -
3512 -int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
3513 -{
3514 - int ret;
3515 -
3516 - if (hdl == NULL)
3517 - return 0;
3518 -
3519 - mutex_lock(hdl->lock);
3520 - ret = __v4l2_ctrl_handler_setup(hdl);
3521 - mutex_unlock(hdl->lock);
3522 -
3523 - return ret;
3524 -}
3525 -EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
3526 -
3527 -/* Implement VIDIOC_QUERY_EXT_CTRL */
3528 -int v4l2_query_ext_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_query_ext_ctrl *qc)
3529 -{
3530 - const unsigned next_flags = V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND;
3531 - u32 id = qc->id & V4L2_CTRL_ID_MASK;
3532 - struct v4l2_ctrl_ref *ref;
3533 - struct v4l2_ctrl *ctrl;
3534 -
3535 - if (hdl == NULL)
3536 - return -EINVAL;
3537 -
3538 - mutex_lock(hdl->lock);
3539 -
3540 - /* Try to find it */
3541 - ref = find_ref(hdl, id);
3542 -
3543 - if ((qc->id & next_flags) && !list_empty(&hdl->ctrl_refs)) {
3544 - bool is_compound;
3545 - /* Match any control that is not hidden */
3546 - unsigned mask = 1;
3547 - bool match = false;
3548 -
3549 - if ((qc->id & next_flags) == V4L2_CTRL_FLAG_NEXT_COMPOUND) {
3550 - /* Match any hidden control */
3551 - match = true;
3552 - } else if ((qc->id & next_flags) == next_flags) {
3553 - /* Match any control, compound or not */
3554 - mask = 0;
3555 - }
3556 -
3557 - /* Find the next control with ID > qc->id */
3558 -
3559 - /* Did we reach the end of the control list? */
3560 - if (id >= node2id(hdl->ctrl_refs.prev)) {
3561 - ref = NULL; /* Yes, so there is no next control */
3562 - } else if (ref) {
3563 - /* We found a control with the given ID, so just get
3564 - the next valid one in the list. */
3565 - list_for_each_entry_continue(ref, &hdl->ctrl_refs, node) {
3566 - is_compound = ref->ctrl->is_array ||
3567 - ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
3568 - if (id < ref->ctrl->id &&
3569 - (is_compound & mask) == match)
3570 - break;
3571 - }
3572 - if (&ref->node == &hdl->ctrl_refs)
3573 - ref = NULL;
3574 - } else {
3575 - /* No control with the given ID exists, so start
3576 - searching for the next largest ID. We know there
3577 - is one, otherwise the first 'if' above would have
3578 - been true. */
3579 - list_for_each_entry(ref, &hdl->ctrl_refs, node) {
3580 - is_compound = ref->ctrl->is_array ||
3581 - ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
3582 - if (id < ref->ctrl->id &&
3583 - (is_compound & mask) == match)
3584 - break;
3585 - }
3586 - if (&ref->node == &hdl->ctrl_refs)
3587 - ref = NULL;
3588 - }
3589 - }
3590 - mutex_unlock(hdl->lock);
3591 -
3592 - if (!ref)
3593 - return -EINVAL;
3594 -
3595 - ctrl = ref->ctrl;
3596 - memset(qc, 0, sizeof(*qc));
3597 - if (id >= V4L2_CID_PRIVATE_BASE)
3598 - qc->id = id;
3599 - else
3600 - qc->id = ctrl->id;
3601 - strscpy(qc->name, ctrl->name, sizeof(qc->name));
3602 - qc->flags = user_flags(ctrl);
3603 - qc->type = ctrl->type;
3604 - qc->elem_size = ctrl->elem_size;
3605 - qc->elems = ctrl->elems;
3606 - qc->nr_of_dims = ctrl->nr_of_dims;
3607 - memcpy(qc->dims, ctrl->dims, qc->nr_of_dims * sizeof(qc->dims[0]));
3608 - qc->minimum = ctrl->minimum;
3609 - qc->maximum = ctrl->maximum;
3610 - qc->default_value = ctrl->default_value;
3611 - if (ctrl->type == V4L2_CTRL_TYPE_MENU
3612 - || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
3613 - qc->step = 1;
3614 - else
3615 - qc->step = ctrl->step;
3616 - return 0;
3617 -}
3618 -EXPORT_SYMBOL(v4l2_query_ext_ctrl);
3619 -
3620 -/* Implement VIDIOC_QUERYCTRL */
3621 -int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
3622 -{
3623 - struct v4l2_query_ext_ctrl qec = { qc->id };
3624 - int rc;
3625 -
3626 - rc = v4l2_query_ext_ctrl(hdl, &qec);
3627 - if (rc)
3628 - return rc;
3629 -
3630 - qc->id = qec.id;
3631 - qc->type = qec.type;
3632 - qc->flags = qec.flags;
3633 - strscpy(qc->name, qec.name, sizeof(qc->name));
3634 - switch (qc->type) {
3635 - case V4L2_CTRL_TYPE_INTEGER:
3636 - case V4L2_CTRL_TYPE_BOOLEAN:
3637 - case V4L2_CTRL_TYPE_MENU:
3638 - case V4L2_CTRL_TYPE_INTEGER_MENU:
3639 - case V4L2_CTRL_TYPE_STRING:
3640 - case V4L2_CTRL_TYPE_BITMASK:
3641 - qc->minimum = qec.minimum;
3642 - qc->maximum = qec.maximum;
3643 - qc->step = qec.step;
3644 - qc->default_value = qec.default_value;
3645 - break;
3646 - default:
3647 - qc->minimum = 0;
3648 - qc->maximum = 0;
3649 - qc->step = 0;
3650 - qc->default_value = 0;
3651 - break;
3652 - }
3653 - return 0;
3654 -}
3655 -EXPORT_SYMBOL(v4l2_queryctrl);
3656 -
3657 -/* Implement VIDIOC_QUERYMENU */
3658 -int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
3659 -{
3660 - struct v4l2_ctrl *ctrl;
3661 - u32 i = qm->index;
3662 -
3663 - ctrl = v4l2_ctrl_find(hdl, qm->id);
3664 - if (!ctrl)
3665 - return -EINVAL;
3666 -
3667 - qm->reserved = 0;
3668 - /* Sanity checks */
3669 - switch (ctrl->type) {
3670 - case V4L2_CTRL_TYPE_MENU:
3671 - if (ctrl->qmenu == NULL)
3672 - return -EINVAL;
3673 - break;
3674 - case V4L2_CTRL_TYPE_INTEGER_MENU:
3675 - if (ctrl->qmenu_int == NULL)
3676 - return -EINVAL;
3677 - break;
3678 - default:
3679 - return -EINVAL;
3680 - }
3681 -
3682 - if (i < ctrl->minimum || i > ctrl->maximum)
3683 - return -EINVAL;
3684 -
3685 - /* Use mask to see if this menu item should be skipped */
3686 - if (ctrl->menu_skip_mask & (1ULL << i))
3687 - return -EINVAL;
3688 - /* Empty menu items should also be skipped */
3689 - if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
3690 - if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
3691 - return -EINVAL;
3692 - strscpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
3693 - } else {
3694 - qm->value = ctrl->qmenu_int[i];
3695 - }
3696 - return 0;
3697 -}
3698 -EXPORT_SYMBOL(v4l2_querymenu);
3699 -
3700 -static int v4l2_ctrl_request_clone(struct v4l2_ctrl_handler *hdl,
3701 - const struct v4l2_ctrl_handler *from)
3702 -{
3703 - struct v4l2_ctrl_ref *ref;
3704 - int err = 0;
3705 -
3706 - if (WARN_ON(!hdl || hdl == from))
3707 - return -EINVAL;
3708 -
3709 - if (hdl->error)
3710 - return hdl->error;
3711 -
3712 - WARN_ON(hdl->lock != &hdl->_lock);
3713 -
3714 - mutex_lock(from->lock);
3715 - list_for_each_entry(ref, &from->ctrl_refs, node) {
3716 - struct v4l2_ctrl *ctrl = ref->ctrl;
3717 - struct v4l2_ctrl_ref *new_ref;
3718 -
3719 - /* Skip refs inherited from other devices */
3720 - if (ref->from_other_dev)
3721 - continue;
3722 - err = handler_new_ref(hdl, ctrl, &new_ref, false, true);
3723 - if (err)
3724 - break;
3725 - }
3726 - mutex_unlock(from->lock);
3727 - return err;
3728 -}
3729 -
3730 -static void v4l2_ctrl_request_queue(struct media_request_object *obj)
3731 -{
3732 - struct v4l2_ctrl_handler *hdl =
3733 - container_of(obj, struct v4l2_ctrl_handler, req_obj);
3734 - struct v4l2_ctrl_handler *main_hdl = obj->priv;
3735 -
3736 - mutex_lock(main_hdl->lock);
3737 - list_add_tail(&hdl->requests_queued, &main_hdl->requests_queued);
3738 - hdl->request_is_queued = true;
3739 - mutex_unlock(main_hdl->lock);
3740 -}
3741 -
3742 -static void v4l2_ctrl_request_unbind(struct media_request_object *obj)
3743 -{
3744 - struct v4l2_ctrl_handler *hdl =
3745 - container_of(obj, struct v4l2_ctrl_handler, req_obj);
3746 - struct v4l2_ctrl_handler *main_hdl = obj->priv;
3747 -
3748 - mutex_lock(main_hdl->lock);
3749 - list_del_init(&hdl->requests);
3750 - if (hdl->request_is_queued) {
3751 - list_del_init(&hdl->requests_queued);
3752 - hdl->request_is_queued = false;
3753 - }
3754 - mutex_unlock(main_hdl->lock);
3755 -}
3756 -
3757 -static void v4l2_ctrl_request_release(struct media_request_object *obj)
3758 -{
3759 - struct v4l2_ctrl_handler *hdl =
3760 - container_of(obj, struct v4l2_ctrl_handler, req_obj);
3761 -
3762 - v4l2_ctrl_handler_free(hdl);
3763 - kfree(hdl);
3764 -}
3765 -
3766 -static const struct media_request_object_ops req_ops = {
3767 - .queue = v4l2_ctrl_request_queue,
3768 - .unbind = v4l2_ctrl_request_unbind,
3769 - .release = v4l2_ctrl_request_release,
3770 -};
3771 -
3772 -struct v4l2_ctrl_handler *v4l2_ctrl_request_hdl_find(struct media_request *req,
3773 - struct v4l2_ctrl_handler *parent)
3774 -{
3775 - struct media_request_object *obj;
3776 -
3777 - if (WARN_ON(req->state != MEDIA_REQUEST_STATE_VALIDATING &&
3778 - req->state != MEDIA_REQUEST_STATE_QUEUED))
3779 - return NULL;
3780 -
3781 - obj = media_request_object_find(req, &req_ops, parent);
3782 - if (obj)
3783 - return container_of(obj, struct v4l2_ctrl_handler, req_obj);
3784 - return NULL;
3785 -}
3786 -EXPORT_SYMBOL_GPL(v4l2_ctrl_request_hdl_find);
3787 -
3788 -struct v4l2_ctrl *
3789 -v4l2_ctrl_request_hdl_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
3790 -{
3791 - struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
3792 -
3793 - return (ref && ref->valid_p_req) ? ref->ctrl : NULL;
3794 -}
3795 -EXPORT_SYMBOL_GPL(v4l2_ctrl_request_hdl_ctrl_find);
3796 -
3797 -static int v4l2_ctrl_request_bind(struct media_request *req,
3798 - struct v4l2_ctrl_handler *hdl,
3799 - struct v4l2_ctrl_handler *from)
3800 -{
3801 - int ret;
3802 -
3803 - ret = v4l2_ctrl_request_clone(hdl, from);
3804 -
3805 - if (!ret) {
3806 - ret = media_request_object_bind(req, &req_ops,
3807 - from, false, &hdl->req_obj);
3808 - if (!ret) {
3809 - mutex_lock(from->lock);
3810 - list_add_tail(&hdl->requests, &from->requests);
3811 - mutex_unlock(from->lock);
3812 - }
3813 - }
3814 - return ret;
3815 -}
3816 -
3817 -/* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
3818 -
3819 - It is not a fully atomic operation, just best-effort only. After all, if
3820 - multiple controls have to be set through multiple i2c writes (for example)
3821 - then some initial writes may succeed while others fail. Thus leaving the
3822 - system in an inconsistent state. The question is how much effort you are
3823 - willing to spend on trying to make something atomic that really isn't.
3824 -
3825 - From the point of view of an application the main requirement is that
3826 - when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
3827 - error should be returned without actually affecting any controls.
3828 -
3829 - If all the values are correct, then it is acceptable to just give up
3830 - in case of low-level errors.
3831 -
3832 - It is important though that the application can tell when only a partial
3833 - configuration was done. The way we do that is through the error_idx field
3834 - of struct v4l2_ext_controls: if that is equal to the count field then no
3835 - controls were affected. Otherwise all controls before that index were
3836 - successful in performing their 'get' or 'set' operation, the control at
3837 - the given index failed, and you don't know what happened with the controls
3838 - after the failed one. Since if they were part of a control cluster they
3839 - could have been successfully processed (if a cluster member was encountered
3840 - at index < error_idx), they could have failed (if a cluster member was at
3841 - error_idx), or they may not have been processed yet (if the first cluster
3842 - member appeared after error_idx).
3843 -
3844 - It is all fairly theoretical, though. In practice all you can do is to
3845 - bail out. If error_idx == count, then it is an application bug. If
3846 - error_idx < count then it is only an application bug if the error code was
3847 - EBUSY. That usually means that something started streaming just when you
3848 - tried to set the controls. In all other cases it is a driver/hardware
3849 - problem and all you can do is to retry or bail out.
3850 -
3851 - Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
3852 - never modifies controls the error_idx is just set to whatever control
3853 - has an invalid value.
3854 - */
3855 -
3856 -/* Prepare for the extended g/s/try functions.
3857 - Find the controls in the control array and do some basic checks. */
3858 -static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
3859 - struct v4l2_ext_controls *cs,
3860 - struct v4l2_ctrl_helper *helpers,
3861 - struct video_device *vdev,
3862 - bool get)
3863 -{
3864 - struct v4l2_ctrl_helper *h;
3865 - bool have_clusters = false;
3866 - u32 i;
3867 -
3868 - for (i = 0, h = helpers; i < cs->count; i++, h++) {
3869 - struct v4l2_ext_control *c = &cs->controls[i];
3870 - struct v4l2_ctrl_ref *ref;
3871 - struct v4l2_ctrl *ctrl;
3872 - u32 id = c->id & V4L2_CTRL_ID_MASK;
3873 -
3874 - cs->error_idx = i;
3875 -
3876 - if (cs->which &&
3877 - cs->which != V4L2_CTRL_WHICH_DEF_VAL &&
3878 - cs->which != V4L2_CTRL_WHICH_REQUEST_VAL &&
3879 - V4L2_CTRL_ID2WHICH(id) != cs->which) {
3880 - dprintk(vdev,
3881 - "invalid which 0x%x or control id 0x%x\n",
3882 - cs->which, id);
3883 - return -EINVAL;
3884 - }
3885 -
3886 - /* Old-style private controls are not allowed for
3887 - extended controls */
3888 - if (id >= V4L2_CID_PRIVATE_BASE) {
3889 - dprintk(vdev,
3890 - "old-style private controls not allowed\n");
3891 - return -EINVAL;
3892 - }
3893 - ref = find_ref_lock(hdl, id);
3894 - if (ref == NULL) {
3895 - dprintk(vdev, "cannot find control id 0x%x\n", id);
3896 - return -EINVAL;
3897 - }
3898 - h->ref = ref;
3899 - ctrl = ref->ctrl;
3900 - if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED) {
3901 - dprintk(vdev, "control id 0x%x is disabled\n", id);
3902 - return -EINVAL;
3903 - }
3904 -
3905 - if (ctrl->cluster[0]->ncontrols > 1)
3906 - have_clusters = true;
3907 - if (ctrl->cluster[0] != ctrl)
3908 - ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
3909 - if (ctrl->is_ptr && !ctrl->is_string) {
3910 - unsigned tot_size = ctrl->elems * ctrl->elem_size;
3911 -
3912 - if (c->size < tot_size) {
3913 - /*
3914 - * In the get case the application first
3915 - * queries to obtain the size of the control.
3916 - */
3917 - if (get) {
3918 - c->size = tot_size;
3919 - return -ENOSPC;
3920 - }
3921 - dprintk(vdev,
3922 - "pointer control id 0x%x size too small, %d bytes but %d bytes needed\n",
3923 - id, c->size, tot_size);
3924 - return -EFAULT;
3925 - }
3926 - c->size = tot_size;
3927 - }
3928 - /* Store the ref to the master control of the cluster */
3929 - h->mref = ref;
3930 - /* Initially set next to 0, meaning that there is no other
3931 - control in this helper array belonging to the same
3932 - cluster */
3933 - h->next = 0;
3934 - }
3935 -
3936 - /* We are done if there were no controls that belong to a multi-
3937 - control cluster. */
3938 - if (!have_clusters)
3939 - return 0;
3940 -
3941 - /* The code below figures out in O(n) time which controls in the list
3942 - belong to the same cluster. */
3943 -
3944 - /* This has to be done with the handler lock taken. */
3945 - mutex_lock(hdl->lock);
3946 -
3947 - /* First zero the helper field in the master control references */
3948 - for (i = 0; i < cs->count; i++)
3949 - helpers[i].mref->helper = NULL;
3950 - for (i = 0, h = helpers; i < cs->count; i++, h++) {
3951 - struct v4l2_ctrl_ref *mref = h->mref;
3952 -
3953 - /* If the mref->helper is set, then it points to an earlier
3954 - helper that belongs to the same cluster. */
3955 - if (mref->helper) {
3956 - /* Set the next field of mref->helper to the current
3957 - index: this means that that earlier helper now
3958 - points to the next helper in the same cluster. */
3959 - mref->helper->next = i;
3960 - /* mref should be set only for the first helper in the
3961 - cluster, clear the others. */
3962 - h->mref = NULL;
3963 - }
3964 - /* Point the mref helper to the current helper struct. */
3965 - mref->helper = h;
3966 - }
3967 - mutex_unlock(hdl->lock);
3968 - return 0;
3969 -}
3970 -
3971 -/* Handles the corner case where cs->count == 0. It checks whether the
3972 - specified control class exists. If that class ID is 0, then it checks
3973 - whether there are any controls at all. */
3974 -static int class_check(struct v4l2_ctrl_handler *hdl, u32 which)
3975 -{
3976 - if (which == 0 || which == V4L2_CTRL_WHICH_DEF_VAL ||
3977 - which == V4L2_CTRL_WHICH_REQUEST_VAL)
3978 - return 0;
3979 - return find_ref_lock(hdl, which | 1) ? 0 : -EINVAL;
3980 -}
3981 -
3982 -/*
3983 - * Get extended controls. Allocates the helpers array if needed.
3984 - *
3985 - * Note that v4l2_g_ext_ctrls_common() with 'which' set to
3986 - * V4L2_CTRL_WHICH_REQUEST_VAL is only called if the request was
3987 - * completed, and in that case valid_p_req is true for all controls.
3988 - */
3989 -static int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
3990 - struct v4l2_ext_controls *cs,
3991 - struct video_device *vdev)
3992 -{
3993 - struct v4l2_ctrl_helper helper[4];
3994 - struct v4l2_ctrl_helper *helpers = helper;
3995 - int ret;
3996 - int i, j;
3997 - bool is_default, is_request;
3998 -
3999 - is_default = (cs->which == V4L2_CTRL_WHICH_DEF_VAL);
4000 - is_request = (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL);
4001 -
4002 - cs->error_idx = cs->count;
4003 - cs->which = V4L2_CTRL_ID2WHICH(cs->which);
4004 -
4005 - if (hdl == NULL)
4006 - return -EINVAL;
4007 -
4008 - if (cs->count == 0)
4009 - return class_check(hdl, cs->which);
4010 -
4011 - if (cs->count > ARRAY_SIZE(helper)) {
4012 - helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
4013 - GFP_KERNEL);
4014 - if (helpers == NULL)
4015 - return -ENOMEM;
4016 - }
4017 -
4018 - ret = prepare_ext_ctrls(hdl, cs, helpers, vdev, true);
4019 - cs->error_idx = cs->count;
4020 -
4021 - for (i = 0; !ret && i < cs->count; i++)
4022 - if (helpers[i].ref->ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
4023 - ret = -EACCES;
4024 -
4025 - for (i = 0; !ret && i < cs->count; i++) {
4026 - struct v4l2_ctrl *master;
4027 - bool is_volatile = false;
4028 - u32 idx = i;
4029 -
4030 - if (helpers[i].mref == NULL)
4031 - continue;
4032 -
4033 - master = helpers[i].mref->ctrl;
4034 - cs->error_idx = i;
4035 -
4036 - v4l2_ctrl_lock(master);
4037 -
4038 - /*
4039 - * g_volatile_ctrl will update the new control values.
4040 - * This makes no sense for V4L2_CTRL_WHICH_DEF_VAL and
4041 - * V4L2_CTRL_WHICH_REQUEST_VAL. In the case of requests
4042 - * it is v4l2_ctrl_request_complete() that copies the
4043 - * volatile controls at the time of request completion
4044 - * to the request, so you don't want to do that again.
4045 - */
4046 - if (!is_default && !is_request &&
4047 - ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
4048 - (master->has_volatiles && !is_cur_manual(master)))) {
4049 - for (j = 0; j < master->ncontrols; j++)
4050 - cur_to_new(master->cluster[j]);
4051 - ret = call_op(master, g_volatile_ctrl);
4052 - is_volatile = true;
4053 - }
4054 -
4055 - if (ret) {
4056 - v4l2_ctrl_unlock(master);
4057 - break;
4058 - }
4059 -
4060 - /*
4061 - * Copy the default value (if is_default is true), the
4062 - * request value (if is_request is true and p_req is valid),
4063 - * the new volatile value (if is_volatile is true) or the
4064 - * current value.
4065 - */
4066 - do {
4067 - struct v4l2_ctrl_ref *ref = helpers[idx].ref;
4068 -
4069 - if (is_default)
4070 - ret = def_to_user(cs->controls + idx, ref->ctrl);
4071 - else if (is_request && ref->valid_p_req)
4072 - ret = req_to_user(cs->controls + idx, ref);
4073 - else if (is_volatile)
4074 - ret = new_to_user(cs->controls + idx, ref->ctrl);
4075 - else
4076 - ret = cur_to_user(cs->controls + idx, ref->ctrl);
4077 - idx = helpers[idx].next;
4078 - } while (!ret && idx);
4079 -
4080 - v4l2_ctrl_unlock(master);
4081 - }
4082 -
4083 - if (cs->count > ARRAY_SIZE(helper))
4084 - kvfree(helpers);
4085 - return ret;
4086 -}
4087 -
4088 -static struct media_request_object *
4089 -v4l2_ctrls_find_req_obj(struct v4l2_ctrl_handler *hdl,
4090 - struct media_request *req, bool set)
4091 -{
4092 - struct media_request_object *obj;
4093 - struct v4l2_ctrl_handler *new_hdl;
4094 - int ret;
4095 -
4096 - if (IS_ERR(req))
4097 - return ERR_CAST(req);
4098 -
4099 - if (set && WARN_ON(req->state != MEDIA_REQUEST_STATE_UPDATING))
4100 - return ERR_PTR(-EBUSY);
4101 -
4102 - obj = media_request_object_find(req, &req_ops, hdl);
4103 - if (obj)
4104 - return obj;
4105 - if (!set)
4106 - return ERR_PTR(-ENOENT);
4107 -
4108 - new_hdl = kzalloc(sizeof(*new_hdl), GFP_KERNEL);
4109 - if (!new_hdl)
4110 - return ERR_PTR(-ENOMEM);
4111 -
4112 - obj = &new_hdl->req_obj;
4113 - ret = v4l2_ctrl_handler_init(new_hdl, (hdl->nr_of_buckets - 1) * 8);
4114 - if (!ret)
4115 - ret = v4l2_ctrl_request_bind(req, new_hdl, hdl);
4116 - if (ret) {
4117 - kfree(new_hdl);
4118 -
4119 - return ERR_PTR(ret);
4120 - }
4121 -
4122 - media_request_object_get(obj);
4123 - return obj;
4124 -}
4125 -
4126 -int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct video_device *vdev,
4127 - struct media_device *mdev, struct v4l2_ext_controls *cs)
4128 -{
4129 - struct media_request_object *obj = NULL;
4130 - struct media_request *req = NULL;
4131 - int ret;
4132 -
4133 - if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL) {
4134 - if (!mdev || cs->request_fd < 0)
4135 - return -EINVAL;
4136 -
4137 - req = media_request_get_by_fd(mdev, cs->request_fd);
4138 - if (IS_ERR(req))
4139 - return PTR_ERR(req);
4140 -
4141 - if (req->state != MEDIA_REQUEST_STATE_COMPLETE) {
4142 - media_request_put(req);
4143 - return -EACCES;
4144 - }
4145 -
4146 - ret = media_request_lock_for_access(req);
4147 - if (ret) {
4148 - media_request_put(req);
4149 - return ret;
4150 - }
4151 -
4152 - obj = v4l2_ctrls_find_req_obj(hdl, req, false);
4153 - if (IS_ERR(obj)) {
4154 - media_request_unlock_for_access(req);
4155 - media_request_put(req);
4156 - return PTR_ERR(obj);
4157 - }
4158 -
4159 - hdl = container_of(obj, struct v4l2_ctrl_handler,
4160 - req_obj);
4161 - }
4162 -
4163 - ret = v4l2_g_ext_ctrls_common(hdl, cs, vdev);
4164 -
4165 - if (obj) {
4166 - media_request_unlock_for_access(req);
4167 - media_request_object_put(obj);
4168 - media_request_put(req);
4169 - }
4170 - return ret;
4171 -}
4172 -EXPORT_SYMBOL(v4l2_g_ext_ctrls);
4173 -
4174 -/* Helper function to get a single control */
4175 -static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
4176 -{
4177 - struct v4l2_ctrl *master = ctrl->cluster[0];
4178 - int ret = 0;
4179 - int i;
4180 -
4181 - /* Compound controls are not supported. The new_to_user() and
4182 - * cur_to_user() calls below would need to be modified not to access
4183 - * userspace memory when called from get_ctrl().
4184 - */
4185 - if (!ctrl->is_int && ctrl->type != V4L2_CTRL_TYPE_INTEGER64)
4186 - return -EINVAL;
4187 -
4188 - if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
4189 - return -EACCES;
4190 -
4191 - v4l2_ctrl_lock(master);
4192 - /* g_volatile_ctrl will update the current control values */
4193 - if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
4194 - for (i = 0; i < master->ncontrols; i++)
4195 - cur_to_new(master->cluster[i]);
4196 - ret = call_op(master, g_volatile_ctrl);
4197 - new_to_user(c, ctrl);
4198 - } else {
4199 - cur_to_user(c, ctrl);
4200 - }
4201 - v4l2_ctrl_unlock(master);
4202 - return ret;
4203 -}
4204 -
4205 -int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
4206 -{
4207 - struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
4208 - struct v4l2_ext_control c;
4209 - int ret;
4210 -
4211 - if (ctrl == NULL || !ctrl->is_int)
4212 - return -EINVAL;
4213 - ret = get_ctrl(ctrl, &c);
4214 - control->value = c.value;
4215 - return ret;
4216 -}
4217 -EXPORT_SYMBOL(v4l2_g_ctrl);
4218 -
4219 -s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
4220 -{
4221 - struct v4l2_ext_control c;
4222 -
4223 - /* It's a driver bug if this happens. */
4224 - if (WARN_ON(!ctrl->is_int))
4225 - return 0;
4226 - c.value = 0;
4227 - get_ctrl(ctrl, &c);
4228 - return c.value;
4229 -}
4230 -EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
4231 -
4232 -s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
4233 -{
4234 - struct v4l2_ext_control c;
4235 -
4236 - /* It's a driver bug if this happens. */
4237 - if (WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64))
4238 - return 0;
4239 - c.value64 = 0;
4240 - get_ctrl(ctrl, &c);
4241 - return c.value64;
4242 -}
4243 -EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
4244 -
4245 -
4246 -/* Core function that calls try/s_ctrl and ensures that the new value is
4247 - copied to the current value on a set.
4248 - Must be called with ctrl->handler->lock held. */
4249 -static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
4250 - bool set, u32 ch_flags)
4251 -{
4252 - bool update_flag;
4253 - int ret;
4254 - int i;
4255 -
4256 - /* Go through the cluster and either validate the new value or
4257 - (if no new value was set), copy the current value to the new
4258 - value, ensuring a consistent view for the control ops when
4259 - called. */
4260 - for (i = 0; i < master->ncontrols; i++) {
4261 - struct v4l2_ctrl *ctrl = master->cluster[i];
4262 -
4263 - if (ctrl == NULL)
4264 - continue;
4265 -
4266 - if (!ctrl->is_new) {
4267 - cur_to_new(ctrl);
4268 - continue;
4269 - }
4270 - /* Check again: it may have changed since the
4271 - previous check in try_or_set_ext_ctrls(). */
4272 - if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
4273 - return -EBUSY;
4274 - }
4275 -
4276 - ret = call_op(master, try_ctrl);
4277 -
4278 - /* Don't set if there is no change */
4279 - if (ret || !set || !cluster_changed(master))
4280 - return ret;
4281 - ret = call_op(master, s_ctrl);
4282 - if (ret)
4283 - return ret;
4284 -
4285 - /* If OK, then make the new values permanent. */
4286 - update_flag = is_cur_manual(master) != is_new_manual(master);
4287 -
4288 - for (i = 0; i < master->ncontrols; i++) {
4289 - /*
4290 - * If we switch from auto to manual mode, and this cluster
4291 - * contains volatile controls, then all non-master controls
4292 - * have to be marked as changed. The 'new' value contains
4293 - * the volatile value (obtained by update_from_auto_cluster),
4294 - * which now has to become the current value.
4295 - */
4296 - if (i && update_flag && is_new_manual(master) &&
4297 - master->has_volatiles && master->cluster[i])
4298 - master->cluster[i]->has_changed = true;
4299 -
4300 - new_to_cur(fh, master->cluster[i], ch_flags |
4301 - ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
4302 - }
4303 - return 0;
4304 -}
4305 -
4306 -/* Validate controls. */
4307 -static int validate_ctrls(struct v4l2_ext_controls *cs,
4308 - struct v4l2_ctrl_helper *helpers,
4309 - struct video_device *vdev,
4310 - bool set)
4311 -{
4312 - unsigned i;
4313 - int ret = 0;
4314 -
4315 - cs->error_idx = cs->count;
4316 - for (i = 0; i < cs->count; i++) {
4317 - struct v4l2_ctrl *ctrl = helpers[i].ref->ctrl;
4318 - union v4l2_ctrl_ptr p_new;
4319 -
4320 - cs->error_idx = i;
4321 -
4322 - if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY) {
4323 - dprintk(vdev,
4324 - "control id 0x%x is read-only\n",
4325 - ctrl->id);
4326 - return -EACCES;
4327 - }
4328 - /* This test is also done in try_set_control_cluster() which
4329 - is called in atomic context, so that has the final say,
4330 - but it makes sense to do an up-front check as well. Once
4331 - an error occurs in try_set_control_cluster() some other
4332 - controls may have been set already and we want to do a
4333 - best-effort to avoid that. */
4334 - if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)) {
4335 - dprintk(vdev,
4336 - "control id 0x%x is grabbed, cannot set\n",
4337 - ctrl->id);
4338 - return -EBUSY;
4339 - }
4340 - /*
4341 - * Skip validation for now if the payload needs to be copied
4342 - * from userspace into kernelspace. We'll validate those later.
4343 - */
4344 - if (ctrl->is_ptr)
4345 - continue;
4346 - if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
4347 - p_new.p_s64 = &cs->controls[i].value64;
4348 - else
4349 - p_new.p_s32 = &cs->controls[i].value;
4350 - ret = validate_new(ctrl, p_new);
4351 - if (ret)
4352 - return ret;
4353 - }
4354 - return 0;
4355 -}
4356 -
4357 -/* Obtain the current volatile values of an autocluster and mark them
4358 - as new. */
4359 -static void update_from_auto_cluster(struct v4l2_ctrl *master)
4360 -{
4361 - int i;
4362 -
4363 - for (i = 1; i < master->ncontrols; i++)
4364 - cur_to_new(master->cluster[i]);
4365 - if (!call_op(master, g_volatile_ctrl))
4366 - for (i = 1; i < master->ncontrols; i++)
4367 - if (master->cluster[i])
4368 - master->cluster[i]->is_new = 1;
4369 -}
4370 -
4371 -/* Try or try-and-set controls */
4372 -static int try_set_ext_ctrls_common(struct v4l2_fh *fh,
4373 - struct v4l2_ctrl_handler *hdl,
4374 - struct v4l2_ext_controls *cs,
4375 - struct video_device *vdev, bool set)
4376 -{
4377 - struct v4l2_ctrl_helper helper[4];
4378 - struct v4l2_ctrl_helper *helpers = helper;
4379 - unsigned i, j;
4380 - int ret;
4381 -
4382 - cs->error_idx = cs->count;
4383 -
4384 - /* Default value cannot be changed */
4385 - if (cs->which == V4L2_CTRL_WHICH_DEF_VAL) {
4386 - dprintk(vdev, "%s: cannot change default value\n",
4387 - video_device_node_name(vdev));
4388 - return -EINVAL;
4389 - }
4390 -
4391 - cs->which = V4L2_CTRL_ID2WHICH(cs->which);
4392 -
4393 - if (hdl == NULL) {
4394 - dprintk(vdev, "%s: invalid null control handler\n",
4395 - video_device_node_name(vdev));
4396 - return -EINVAL;
4397 - }
4398 -
4399 - if (cs->count == 0)
4400 - return class_check(hdl, cs->which);
4401 -
4402 - if (cs->count > ARRAY_SIZE(helper)) {
4403 - helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
4404 - GFP_KERNEL);
4405 - if (!helpers)
4406 - return -ENOMEM;
4407 - }
4408 - ret = prepare_ext_ctrls(hdl, cs, helpers, vdev, false);
4409 - if (!ret)
4410 - ret = validate_ctrls(cs, helpers, vdev, set);
4411 - if (ret && set)
4412 - cs->error_idx = cs->count;
4413 - for (i = 0; !ret && i < cs->count; i++) {
4414 - struct v4l2_ctrl *master;
4415 - u32 idx = i;
4416 -
4417 - if (helpers[i].mref == NULL)
4418 - continue;
4419 -
4420 - cs->error_idx = i;
4421 - master = helpers[i].mref->ctrl;
4422 - v4l2_ctrl_lock(master);
4423 -
4424 - /* Reset the 'is_new' flags of the cluster */
4425 - for (j = 0; j < master->ncontrols; j++)
4426 - if (master->cluster[j])
4427 - master->cluster[j]->is_new = 0;
4428 -
4429 - /* For volatile autoclusters that are currently in auto mode
4430 - we need to discover if it will be set to manual mode.
4431 - If so, then we have to copy the current volatile values
4432 - first since those will become the new manual values (which
4433 - may be overwritten by explicit new values from this set
4434 - of controls). */
4435 - if (master->is_auto && master->has_volatiles &&
4436 - !is_cur_manual(master)) {
4437 - /* Pick an initial non-manual value */
4438 - s32 new_auto_val = master->manual_mode_value + 1;
4439 - u32 tmp_idx = idx;
4440 -
4441 - do {
4442 - /* Check if the auto control is part of the
4443 - list, and remember the new value. */
4444 - if (helpers[tmp_idx].ref->ctrl == master)
4445 - new_auto_val = cs->controls[tmp_idx].value;
4446 - tmp_idx = helpers[tmp_idx].next;
4447 - } while (tmp_idx);
4448 - /* If the new value == the manual value, then copy
4449 - the current volatile values. */
4450 - if (new_auto_val == master->manual_mode_value)
4451 - update_from_auto_cluster(master);
4452 - }
4453 -
4454 - /* Copy the new caller-supplied control values.
4455 - user_to_new() sets 'is_new' to 1. */
4456 - do {
4457 - struct v4l2_ctrl *ctrl = helpers[idx].ref->ctrl;
4458 -
4459 - ret = user_to_new(cs->controls + idx, ctrl);
4460 - if (!ret && ctrl->is_ptr) {
4461 - ret = validate_new(ctrl, ctrl->p_new);
4462 - if (ret)
4463 - dprintk(vdev,
4464 - "failed to validate control %s (%d)\n",
4465 - v4l2_ctrl_get_name(ctrl->id), ret);
4466 - }
4467 - idx = helpers[idx].next;
4468 - } while (!ret && idx);
4469 -
4470 - if (!ret)
4471 - ret = try_or_set_cluster(fh, master,
4472 - !hdl->req_obj.req && set, 0);
4473 - if (!ret && hdl->req_obj.req && set) {
4474 - for (j = 0; j < master->ncontrols; j++) {
4475 - struct v4l2_ctrl_ref *ref =
4476 - find_ref(hdl, master->cluster[j]->id);
4477 -
4478 - new_to_req(ref);
4479 - }
4480 - }
4481 -
4482 - /* Copy the new values back to userspace. */
4483 - if (!ret) {
4484 - idx = i;
4485 - do {
4486 - ret = new_to_user(cs->controls + idx,
4487 - helpers[idx].ref->ctrl);
4488 - idx = helpers[idx].next;
4489 - } while (!ret && idx);
4490 - }
4491 - v4l2_ctrl_unlock(master);
4492 - }
4493 -
4494 - if (cs->count > ARRAY_SIZE(helper))
4495 - kvfree(helpers);
4496 - return ret;
4497 -}
4498 -
4499 -static int try_set_ext_ctrls(struct v4l2_fh *fh,
4500 - struct v4l2_ctrl_handler *hdl,
4501 - struct video_device *vdev,
4502 - struct media_device *mdev,
4503 - struct v4l2_ext_controls *cs, bool set)
4504 -{
4505 - struct media_request_object *obj = NULL;
4506 - struct media_request *req = NULL;
4507 - int ret;
4508 -
4509 - if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL) {
4510 - if (!mdev) {
4511 - dprintk(vdev, "%s: missing media device\n",
4512 - video_device_node_name(vdev));
4513 - return -EINVAL;
4514 - }
4515 -
4516 - if (cs->request_fd < 0) {
4517 - dprintk(vdev, "%s: invalid request fd %d\n",
4518 - video_device_node_name(vdev), cs->request_fd);
4519 - return -EINVAL;
4520 - }
4521 -
4522 - req = media_request_get_by_fd(mdev, cs->request_fd);
4523 - if (IS_ERR(req)) {
4524 - dprintk(vdev, "%s: cannot find request fd %d\n",
4525 - video_device_node_name(vdev), cs->request_fd);
4526 - return PTR_ERR(req);
4527 - }
4528 -
4529 - ret = media_request_lock_for_update(req);
4530 - if (ret) {
4531 - dprintk(vdev, "%s: cannot lock request fd %d\n",
4532 - video_device_node_name(vdev), cs->request_fd);
4533 - media_request_put(req);
4534 - return ret;
4535 - }
4536 -
4537 - obj = v4l2_ctrls_find_req_obj(hdl, req, set);
4538 - if (IS_ERR(obj)) {
4539 - dprintk(vdev,
4540 - "%s: cannot find request object for request fd %d\n",
4541 - video_device_node_name(vdev),
4542 - cs->request_fd);
4543 - media_request_unlock_for_update(req);
4544 - media_request_put(req);
4545 - return PTR_ERR(obj);
4546 - }
4547 - hdl = container_of(obj, struct v4l2_ctrl_handler,
4548 - req_obj);
4549 - }
4550 -
4551 - ret = try_set_ext_ctrls_common(fh, hdl, cs, vdev, set);
4552 - if (ret)
4553 - dprintk(vdev,
4554 - "%s: try_set_ext_ctrls_common failed (%d)\n",
4555 - video_device_node_name(vdev), ret);
4556 -
4557 - if (obj) {
4558 - media_request_unlock_for_update(req);
4559 - media_request_object_put(obj);
4560 - media_request_put(req);
4561 - }
4562 -
4563 - return ret;
4564 -}
4565 -
4566 -int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl,
4567 - struct video_device *vdev,
4568 - struct media_device *mdev,
4569 - struct v4l2_ext_controls *cs)
4570 -{
4571 - return try_set_ext_ctrls(NULL, hdl, vdev, mdev, cs, false);
4572 -}
4573 -EXPORT_SYMBOL(v4l2_try_ext_ctrls);
4574 -
4575 -int v4l2_s_ext_ctrls(struct v4l2_fh *fh,
4576 - struct v4l2_ctrl_handler *hdl,
4577 - struct video_device *vdev,
4578 - struct media_device *mdev,
4579 - struct v4l2_ext_controls *cs)
4580 -{
4581 - return try_set_ext_ctrls(fh, hdl, vdev, mdev, cs, true);
4582 -}
4583 -EXPORT_SYMBOL(v4l2_s_ext_ctrls);
4584 -
4585 -/* Helper function for VIDIOC_S_CTRL compatibility */
4586 -static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
4587 -{
4588 - struct v4l2_ctrl *master = ctrl->cluster[0];
4589 - int ret;
4590 - int i;
4591 -
4592 - /* Reset the 'is_new' flags of the cluster */
4593 - for (i = 0; i < master->ncontrols; i++)
4594 - if (master->cluster[i])
4595 - master->cluster[i]->is_new = 0;
4596 -
4597 - ret = validate_new(ctrl, ctrl->p_new);
4598 - if (ret)
4599 - return ret;
4600 -
4601 - /* For autoclusters with volatiles that are switched from auto to
4602 - manual mode we have to update the current volatile values since
4603 - those will become the initial manual values after such a switch. */
4604 - if (master->is_auto && master->has_volatiles && ctrl == master &&
4605 - !is_cur_manual(master) && ctrl->val == master->manual_mode_value)
4606 - update_from_auto_cluster(master);
4607 -
4608 - ctrl->is_new = 1;
4609 - return try_or_set_cluster(fh, master, true, ch_flags);
4610 -}
4611 -
4612 -/* Helper function for VIDIOC_S_CTRL compatibility */
4613 -static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
4614 - struct v4l2_ext_control *c)
4615 -{
4616 - int ret;
4617 -
4618 - v4l2_ctrl_lock(ctrl);
4619 - user_to_new(c, ctrl);
4620 - ret = set_ctrl(fh, ctrl, 0);
4621 - if (!ret)
4622 - cur_to_user(c, ctrl);
4623 - v4l2_ctrl_unlock(ctrl);
4624 - return ret;
4625 -}
4626 -
4627 -int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
4628 - struct v4l2_control *control)
4629 -{
4630 - struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
4631 - struct v4l2_ext_control c = { control->id };
4632 - int ret;
4633 -
4634 - if (ctrl == NULL || !ctrl->is_int)
4635 - return -EINVAL;
4636 -
4637 - if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
4638 - return -EACCES;
4639 -
4640 - c.value = control->value;
4641 - ret = set_ctrl_lock(fh, ctrl, &c);
4642 - control->value = c.value;
4643 - return ret;
4644 -}
4645 -EXPORT_SYMBOL(v4l2_s_ctrl);
4646 -
4647 -int __v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
4648 -{
4649 - lockdep_assert_held(ctrl->handler->lock);
4650 -
4651 - /* It's a driver bug if this happens. */
4652 - if (WARN_ON(!ctrl->is_int))
4653 - return -EINVAL;
4654 - ctrl->val = val;
4655 - return set_ctrl(NULL, ctrl, 0);
4656 -}
4657 -EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl);
4658 -
4659 -int __v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
4660 -{
4661 - lockdep_assert_held(ctrl->handler->lock);
4662 -
4663 - /* It's a driver bug if this happens. */
4664 - if (WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64))
4665 - return -EINVAL;
4666 - *ctrl->p_new.p_s64 = val;
4667 - return set_ctrl(NULL, ctrl, 0);
4668 -}
4669 -EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_int64);
4670 -
4671 -int __v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl *ctrl, const char *s)
4672 -{
4673 - lockdep_assert_held(ctrl->handler->lock);
4674 -
4675 - /* It's a driver bug if this happens. */
4676 - if (WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING))
4677 - return -EINVAL;
4678 - strscpy(ctrl->p_new.p_char, s, ctrl->maximum + 1);
4679 - return set_ctrl(NULL, ctrl, 0);
4680 -}
4681 -EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string);
4682 -
4683 -int __v4l2_ctrl_s_ctrl_compound(struct v4l2_ctrl *ctrl,
4684 - enum v4l2_ctrl_type type, const void *p)
4685 -{
4686 - lockdep_assert_held(ctrl->handler->lock);
4687 -
4688 - /* It's a driver bug if this happens. */
4689 - if (WARN_ON(ctrl->type != type))
4690 - return -EINVAL;
4691 - memcpy(ctrl->p_new.p, p, ctrl->elems * ctrl->elem_size);
4692 - return set_ctrl(NULL, ctrl, 0);
4693 -}
4694 -EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_compound);
4695 -
4696 -void v4l2_ctrl_request_complete(struct media_request *req,
4697 - struct v4l2_ctrl_handler *main_hdl)
4698 -{
4699 - struct media_request_object *obj;
4700 - struct v4l2_ctrl_handler *hdl;
4701 - struct v4l2_ctrl_ref *ref;
4702 -
4703 - if (!req || !main_hdl)
4704 - return;
4705 -
4706 - /*
4707 - * Note that it is valid if nothing was found. It means
4708 - * that this request doesn't have any controls and so just
4709 - * wants to leave the controls unchanged.
4710 - */
4711 - obj = media_request_object_find(req, &req_ops, main_hdl);
4712 - if (!obj)
4713 - return;
4714 - hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj);
4715 -
4716 - list_for_each_entry(ref, &hdl->ctrl_refs, node) {
4717 - struct v4l2_ctrl *ctrl = ref->ctrl;
4718 - struct v4l2_ctrl *master = ctrl->cluster[0];
4719 - unsigned int i;
4720 -
4721 - if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
4722 - v4l2_ctrl_lock(master);
4723 - /* g_volatile_ctrl will update the current control values */
4724 - for (i = 0; i < master->ncontrols; i++)
4725 - cur_to_new(master->cluster[i]);
4726 - call_op(master, g_volatile_ctrl);
4727 - new_to_req(ref);
4728 - v4l2_ctrl_unlock(master);
4729 - continue;
4730 - }
4731 - if (ref->valid_p_req)
4732 - continue;
4733 -
4734 - /* Copy the current control value into the request */
4735 - v4l2_ctrl_lock(ctrl);
4736 - cur_to_req(ref);
4737 - v4l2_ctrl_unlock(ctrl);
4738 - }
4739 -
4740 - mutex_lock(main_hdl->lock);
4741 - WARN_ON(!hdl->request_is_queued);
4742 - list_del_init(&hdl->requests_queued);
4743 - hdl->request_is_queued = false;
4744 - mutex_unlock(main_hdl->lock);
4745 - media_request_object_complete(obj);
4746 - media_request_object_put(obj);
4747 -}
4748 -EXPORT_SYMBOL(v4l2_ctrl_request_complete);
4749 -
4750 -int v4l2_ctrl_request_setup(struct media_request *req,
4751 - struct v4l2_ctrl_handler *main_hdl)
4752 -{
4753 - struct media_request_object *obj;
4754 - struct v4l2_ctrl_handler *hdl;
4755 - struct v4l2_ctrl_ref *ref;
4756 - int ret = 0;
4757 -
4758 - if (!req || !main_hdl)
4759 - return 0;
4760 -
4761 - if (WARN_ON(req->state != MEDIA_REQUEST_STATE_QUEUED))
4762 - return -EBUSY;
4763 -
4764 - /*
4765 - * Note that it is valid if nothing was found. It means
4766 - * that this request doesn't have any controls and so just
4767 - * wants to leave the controls unchanged.
4768 - */
4769 - obj = media_request_object_find(req, &req_ops, main_hdl);
4770 - if (!obj)
4771 - return 0;
4772 - if (obj->completed) {
4773 - media_request_object_put(obj);
4774 - return -EBUSY;
4775 - }
4776 - hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj);
4777 -
4778 - list_for_each_entry(ref, &hdl->ctrl_refs, node)
4779 - ref->req_done = false;
4780 -
4781 - list_for_each_entry(ref, &hdl->ctrl_refs, node) {
4782 - struct v4l2_ctrl *ctrl = ref->ctrl;
4783 - struct v4l2_ctrl *master = ctrl->cluster[0];
4784 - bool have_new_data = false;
4785 - int i;
4786 -
4787 - /*
4788 - * Skip if this control was already handled by a cluster.
4789 - * Skip button controls and read-only controls.
4790 - */
4791 - if (ref->req_done || (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
4792 - continue;
4793 -
4794 - v4l2_ctrl_lock(master);
4795 - for (i = 0; i < master->ncontrols; i++) {
4796 - if (master->cluster[i]) {
4797 - struct v4l2_ctrl_ref *r =
4798 - find_ref(hdl, master->cluster[i]->id);
4799 -
4800 - if (r->valid_p_req) {
4801 - have_new_data = true;
4802 - break;
4803 - }
4804 - }
4805 - }
4806 - if (!have_new_data) {
4807 - v4l2_ctrl_unlock(master);
4808 - continue;
4809 - }
4810 -
4811 - for (i = 0; i < master->ncontrols; i++) {
4812 - if (master->cluster[i]) {
4813 - struct v4l2_ctrl_ref *r =
4814 - find_ref(hdl, master->cluster[i]->id);
4815 -
4816 - req_to_new(r);
4817 - master->cluster[i]->is_new = 1;
4818 - r->req_done = true;
4819 - }
4820 - }
4821 - /*
4822 - * For volatile autoclusters that are currently in auto mode
4823 - * we need to discover if it will be set to manual mode.
4824 - * If so, then we have to copy the current volatile values
4825 - * first since those will become the new manual values (which
4826 - * may be overwritten by explicit new values from this set
4827 - * of controls).
4828 - */
4829 - if (master->is_auto && master->has_volatiles &&
4830 - !is_cur_manual(master)) {
4831 - s32 new_auto_val = *master->p_new.p_s32;
4832 -
4833 - /*
4834 - * If the new value == the manual value, then copy
4835 - * the current volatile values.
4836 - */
4837 - if (new_auto_val == master->manual_mode_value)
4838 - update_from_auto_cluster(master);
4839 - }
4840 -
4841 - ret = try_or_set_cluster(NULL, master, true, 0);
4842 - v4l2_ctrl_unlock(master);
4843 -
4844 - if (ret)
4845 - break;
4846 - }
4847 -
4848 - media_request_object_put(obj);
4849 - return ret;
4850 -}
4851 -EXPORT_SYMBOL(v4l2_ctrl_request_setup);
4852 -
4853 -void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
4854 -{
4855 - if (ctrl == NULL)
4856 - return;
4857 - if (notify == NULL) {
4858 - ctrl->call_notify = 0;
4859 - return;
4860 - }
4861 - if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
4862 - return;
4863 - ctrl->handler->notify = notify;
4864 - ctrl->handler->notify_priv = priv;
4865 - ctrl->call_notify = 1;
4866 -}
4867 -EXPORT_SYMBOL(v4l2_ctrl_notify);
4868 -
4869 -int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
4870 - s64 min, s64 max, u64 step, s64 def)
4871 -{
4872 - bool value_changed;
4873 - bool range_changed = false;
4874 - int ret;
4875 -
4876 - lockdep_assert_held(ctrl->handler->lock);
4877 -
4878 - switch (ctrl->type) {
4879 - case V4L2_CTRL_TYPE_INTEGER:
4880 - case V4L2_CTRL_TYPE_INTEGER64:
4881 - case V4L2_CTRL_TYPE_BOOLEAN:
4882 - case V4L2_CTRL_TYPE_MENU:
4883 - case V4L2_CTRL_TYPE_INTEGER_MENU:
4884 - case V4L2_CTRL_TYPE_BITMASK:
4885 - case V4L2_CTRL_TYPE_U8:
4886 - case V4L2_CTRL_TYPE_U16:
4887 - case V4L2_CTRL_TYPE_U32:
4888 - if (ctrl->is_array)
4889 - return -EINVAL;
4890 - ret = check_range(ctrl->type, min, max, step, def);
4891 - if (ret)
4892 - return ret;
4893 - break;
4894 - default:
4895 - return -EINVAL;
4896 - }
4897 - if ((ctrl->minimum != min) || (ctrl->maximum != max) ||
4898 - (ctrl->step != step) || ctrl->default_value != def) {
4899 - range_changed = true;
4900 - ctrl->minimum = min;
4901 - ctrl->maximum = max;
4902 - ctrl->step = step;
4903 - ctrl->default_value = def;
4904 - }
4905 - cur_to_new(ctrl);
4906 - if (validate_new(ctrl, ctrl->p_new)) {
4907 - if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
4908 - *ctrl->p_new.p_s64 = def;
4909 - else
4910 - *ctrl->p_new.p_s32 = def;
4911 - }
4912 -
4913 - if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
4914 - value_changed = *ctrl->p_new.p_s64 != *ctrl->p_cur.p_s64;
4915 - else
4916 - value_changed = *ctrl->p_new.p_s32 != *ctrl->p_cur.p_s32;
4917 - if (value_changed)
4918 - ret = set_ctrl(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
4919 - else if (range_changed)
4920 - send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
4921 - return ret;
4922 -}
4923 -EXPORT_SYMBOL(__v4l2_ctrl_modify_range);
4924 -
4925 -static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
4926 -{
4927 - struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
4928 -
4929 - if (ctrl == NULL)
4930 - return -EINVAL;
4931 -
4932 - v4l2_ctrl_lock(ctrl);
4933 - list_add_tail(&sev->node, &ctrl->ev_subs);
4934 - if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
4935 - (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
4936 - struct v4l2_event ev;
4937 - u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
4938 -
4939 - if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
4940 - changes |= V4L2_EVENT_CTRL_CH_VALUE;
4941 - fill_event(&ev, ctrl, changes);
4942 - /* Mark the queue as active, allowing this initial
4943 - event to be accepted. */
4944 - sev->elems = elems;
4945 - v4l2_event_queue_fh(sev->fh, &ev);
4946 - }
4947 - v4l2_ctrl_unlock(ctrl);
4948 - return 0;
4949 -}
4950 -
4951 -static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
4952 -{
4953 - struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
4954 -
4955 - if (ctrl == NULL)
4956 - return;
4957 -
4958 - v4l2_ctrl_lock(ctrl);
4959 - list_del(&sev->node);
4960 - v4l2_ctrl_unlock(ctrl);
4961 -}
4962 -
4963 -void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
4964 -{
4965 - u32 old_changes = old->u.ctrl.changes;
4966 -
4967 - old->u.ctrl = new->u.ctrl;
4968 - old->u.ctrl.changes |= old_changes;
4969 -}
4970 -EXPORT_SYMBOL(v4l2_ctrl_replace);
4971 -
4972 -void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
4973 -{
4974 - new->u.ctrl.changes |= old->u.ctrl.changes;
4975 -}
4976 -EXPORT_SYMBOL(v4l2_ctrl_merge);
4977 -
4978 -const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
4979 - .add = v4l2_ctrl_add_event,
4980 - .del = v4l2_ctrl_del_event,
4981 - .replace = v4l2_ctrl_replace,
4982 - .merge = v4l2_ctrl_merge,
4983 -};
4984 -EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
4985 -
4986 -int v4l2_ctrl_log_status(struct file *file, void *fh)
4987 -{
4988 - struct video_device *vfd = video_devdata(file);
4989 - struct v4l2_fh *vfh = file->private_data;
4990 -
4991 - if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
4992 - v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
4993 - vfd->v4l2_dev->name);
4994 - return 0;
4995 -}
4996 -EXPORT_SYMBOL(v4l2_ctrl_log_status);
4997 -
4998 -int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
4999 - const struct v4l2_event_subscription *sub)
5000 -{
5001 - if (sub->type == V4L2_EVENT_CTRL)
5002 - return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
5003 - return -EINVAL;
5004 -}
5005 -EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
5006 -
5007 -int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
5008 - struct v4l2_event_subscription *sub)
5009 -{
5010 - if (!sd->ctrl_handler)
5011 - return -EINVAL;
5012 - return v4l2_ctrl_subscribe_event(fh, sub);
5013 -}
5014 -EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
5015 -
5016 -__poll_t v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
5017 -{
5018 - struct v4l2_fh *fh = file->private_data;
5019 -
5020 - poll_wait(file, &fh->wait, wait);
5021 - if (v4l2_event_pending(fh))
5022 - return EPOLLPRI;
5023 - return 0;
5024 -}
5025 -EXPORT_SYMBOL(v4l2_ctrl_poll);
5026 -
5027 -int v4l2_ctrl_new_fwnode_properties(struct v4l2_ctrl_handler *hdl,
5028 - const struct v4l2_ctrl_ops *ctrl_ops,
5029 - const struct v4l2_fwnode_device_properties *p)
5030 -{
5031 - if (p->orientation != V4L2_FWNODE_PROPERTY_UNSET) {
5032 - u32 orientation_ctrl;
5033 -
5034 - switch (p->orientation) {
5035 - case V4L2_FWNODE_ORIENTATION_FRONT:
5036 - orientation_ctrl = V4L2_CAMERA_ORIENTATION_FRONT;
5037 - break;
5038 - case V4L2_FWNODE_ORIENTATION_BACK:
5039 - orientation_ctrl = V4L2_CAMERA_ORIENTATION_BACK;
5040 - break;
5041 - case V4L2_FWNODE_ORIENTATION_EXTERNAL:
5042 - orientation_ctrl = V4L2_CAMERA_ORIENTATION_EXTERNAL;
5043 - break;
5044 - default:
5045 - return -EINVAL;
5046 - }
5047 - if (!v4l2_ctrl_new_std_menu(hdl, ctrl_ops,
5048 - V4L2_CID_CAMERA_ORIENTATION,
5049 - V4L2_CAMERA_ORIENTATION_EXTERNAL, 0,
5050 - orientation_ctrl))
5051 - return hdl->error;
5052 - }
5053 -
5054 - if (p->rotation != V4L2_FWNODE_PROPERTY_UNSET) {
5055 - if (!v4l2_ctrl_new_std(hdl, ctrl_ops,
5056 - V4L2_CID_CAMERA_SENSOR_ROTATION,
5057 - p->rotation, p->rotation, 1,
5058 - p->rotation))
5059 - return hdl->error;
5060 - }
5061 -
5062 - return hdl->error;
5063 -}
5064 -EXPORT_SYMBOL(v4l2_ctrl_new_fwnode_properties);
OpenWrt Source Repository