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