1 /*
2     V4L2 controls framework implementation.
3 
4     Copyright (C) 2010  Hans Verkuil <hverkuil@xs4all.nl>
5 
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10 
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15 
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20 
21 #include <linux/ctype.h>
22 #include <linux/slab.h>
23 #include <linux/export.h>
24 #include <media/v4l2-ioctl.h>
25 #include <media/v4l2-device.h>
26 #include <media/v4l2-ctrls.h>
27 #include <media/v4l2-event.h>
28 #include <media/v4l2-dev.h>
29 
30 #define has_op(master, op) \
31 	(master->ops && master->ops->op)
32 #define call_op(master, op) \
33 	(has_op(master, op) ? master->ops->op(master) : 0)
34 
35 /* Internal temporary helper struct, one for each v4l2_ext_control */
36 struct v4l2_ctrl_helper {
37 	/* Pointer to the control reference of the master control */
38 	struct v4l2_ctrl_ref *mref;
39 	/* The control corresponding to the v4l2_ext_control ID field. */
40 	struct v4l2_ctrl *ctrl;
41 	/* v4l2_ext_control index of the next control belonging to the
42 	   same cluster, or 0 if there isn't any. */
43 	u32 next;
44 };
45 
46 /* Small helper function to determine if the autocluster is set to manual
47    mode. */
is_cur_manual(const struct v4l2_ctrl * master)48 static 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 /* Same as above, but this checks the against the new value instead of the
54    current value. */
is_new_manual(const struct v4l2_ctrl * master)55 static bool is_new_manual(const struct v4l2_ctrl *master)
56 {
57 	return master->is_auto && master->val == master->manual_mode_value;
58 }
59 
60 /* Returns NULL or a character pointer array containing the menu for
61    the given control ID. The pointer array ends with a NULL pointer.
62    An empty string signifies a menu entry that is invalid. This allows
63    drivers to disable certain options if it is not supported. */
v4l2_ctrl_get_menu(u32 id)64 const 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 		NULL,
341 	};
342 	static const char * const h264_loop_filter[] = {
343 		"Enabled",
344 		"Disabled",
345 		"Disabled at Slice Boundary",
346 		NULL,
347 	};
348 	static const char * const h264_profile[] = {
349 		"Baseline",
350 		"Constrained Baseline",
351 		"Main",
352 		"Extended",
353 		"High",
354 		"High 10",
355 		"High 422",
356 		"High 444 Predictive",
357 		"High 10 Intra",
358 		"High 422 Intra",
359 		"High 444 Intra",
360 		"CAVLC 444 Intra",
361 		"Scalable Baseline",
362 		"Scalable High",
363 		"Scalable High Intra",
364 		"Multiview High",
365 		NULL,
366 	};
367 	static const char * const vui_sar_idc[] = {
368 		"Unspecified",
369 		"1:1",
370 		"12:11",
371 		"10:11",
372 		"16:11",
373 		"40:33",
374 		"24:11",
375 		"20:11",
376 		"32:11",
377 		"80:33",
378 		"18:11",
379 		"15:11",
380 		"64:33",
381 		"160:99",
382 		"4:3",
383 		"3:2",
384 		"2:1",
385 		"Extended SAR",
386 		NULL,
387 	};
388 	static const char * const h264_fp_arrangement_type[] = {
389 		"Checkerboard",
390 		"Column",
391 		"Row",
392 		"Side by Side",
393 		"Top Bottom",
394 		"Temporal",
395 		NULL,
396 	};
397 	static const char * const h264_fmo_map_type[] = {
398 		"Interleaved Slices",
399 		"Scattered Slices",
400 		"Foreground with Leftover",
401 		"Box Out",
402 		"Raster Scan",
403 		"Wipe Scan",
404 		"Explicit",
405 		NULL,
406 	};
407 	static const char * const mpeg_mpeg4_level[] = {
408 		"0",
409 		"0b",
410 		"1",
411 		"2",
412 		"3",
413 		"3b",
414 		"4",
415 		"5",
416 		NULL,
417 	};
418 	static const char * const mpeg4_profile[] = {
419 		"Simple",
420 		"Advanced Simple",
421 		"Core",
422 		"Simple Scalable",
423 		"Advanced Coding Efficiency",
424 		NULL,
425 	};
426 
427 	static const char * const vpx_golden_frame_sel[] = {
428 		"Use Previous Frame",
429 		"Use Previous Specific Frame",
430 		NULL,
431 	};
432 
433 	static const char * const flash_led_mode[] = {
434 		"Off",
435 		"Flash",
436 		"Torch",
437 		NULL,
438 	};
439 	static const char * const flash_strobe_source[] = {
440 		"Software",
441 		"External",
442 		NULL,
443 	};
444 
445 	static const char * const jpeg_chroma_subsampling[] = {
446 		"4:4:4",
447 		"4:2:2",
448 		"4:2:0",
449 		"4:1:1",
450 		"4:1:0",
451 		"Gray",
452 		NULL,
453 	};
454 	static const char * const dv_tx_mode[] = {
455 		"DVI-D",
456 		"HDMI",
457 		NULL,
458 	};
459 	static const char * const dv_rgb_range[] = {
460 		"Automatic",
461 		"RGB limited range (16-235)",
462 		"RGB full range (0-255)",
463 		NULL,
464 	};
465 	static const char * const detect_md_mode[] = {
466 		"Disabled",
467 		"Global",
468 		"Threshold Grid",
469 		"Region Grid",
470 		NULL,
471 	};
472 
473 
474 	switch (id) {
475 	case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
476 		return mpeg_audio_sampling_freq;
477 	case V4L2_CID_MPEG_AUDIO_ENCODING:
478 		return mpeg_audio_encoding;
479 	case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
480 		return mpeg_audio_l1_bitrate;
481 	case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
482 		return mpeg_audio_l2_bitrate;
483 	case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
484 		return mpeg_audio_l3_bitrate;
485 	case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
486 		return mpeg_audio_ac3_bitrate;
487 	case V4L2_CID_MPEG_AUDIO_MODE:
488 		return mpeg_audio_mode;
489 	case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
490 		return mpeg_audio_mode_extension;
491 	case V4L2_CID_MPEG_AUDIO_EMPHASIS:
492 		return mpeg_audio_emphasis;
493 	case V4L2_CID_MPEG_AUDIO_CRC:
494 		return mpeg_audio_crc;
495 	case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
496 	case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
497 		return mpeg_audio_dec_playback;
498 	case V4L2_CID_MPEG_VIDEO_ENCODING:
499 		return mpeg_video_encoding;
500 	case V4L2_CID_MPEG_VIDEO_ASPECT:
501 		return mpeg_video_aspect;
502 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
503 		return mpeg_video_bitrate_mode;
504 	case V4L2_CID_MPEG_STREAM_TYPE:
505 		return mpeg_stream_type;
506 	case V4L2_CID_MPEG_STREAM_VBI_FMT:
507 		return mpeg_stream_vbi_fmt;
508 	case V4L2_CID_POWER_LINE_FREQUENCY:
509 		return camera_power_line_frequency;
510 	case V4L2_CID_EXPOSURE_AUTO:
511 		return camera_exposure_auto;
512 	case V4L2_CID_EXPOSURE_METERING:
513 		return camera_exposure_metering;
514 	case V4L2_CID_AUTO_FOCUS_RANGE:
515 		return camera_auto_focus_range;
516 	case V4L2_CID_COLORFX:
517 		return colorfx;
518 	case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
519 		return auto_n_preset_white_balance;
520 	case V4L2_CID_ISO_SENSITIVITY_AUTO:
521 		return camera_iso_sensitivity_auto;
522 	case V4L2_CID_SCENE_MODE:
523 		return scene_mode;
524 	case V4L2_CID_TUNE_PREEMPHASIS:
525 		return tune_emphasis;
526 	case V4L2_CID_TUNE_DEEMPHASIS:
527 		return tune_emphasis;
528 	case V4L2_CID_FLASH_LED_MODE:
529 		return flash_led_mode;
530 	case V4L2_CID_FLASH_STROBE_SOURCE:
531 		return flash_strobe_source;
532 	case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
533 		return header_mode;
534 	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
535 		return multi_slice;
536 	case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
537 		return entropy_mode;
538 	case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
539 		return mpeg_h264_level;
540 	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
541 		return h264_loop_filter;
542 	case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
543 		return h264_profile;
544 	case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
545 		return vui_sar_idc;
546 	case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
547 		return h264_fp_arrangement_type;
548 	case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
549 		return h264_fmo_map_type;
550 	case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
551 		return mpeg_mpeg4_level;
552 	case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
553 		return mpeg4_profile;
554 	case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
555 		return vpx_golden_frame_sel;
556 	case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
557 		return jpeg_chroma_subsampling;
558 	case V4L2_CID_DV_TX_MODE:
559 		return dv_tx_mode;
560 	case V4L2_CID_DV_TX_RGB_RANGE:
561 	case V4L2_CID_DV_RX_RGB_RANGE:
562 		return dv_rgb_range;
563 	case V4L2_CID_DETECT_MD_MODE:
564 		return detect_md_mode;
565 
566 	default:
567 		return NULL;
568 	}
569 }
570 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
571 
572 #define __v4l2_qmenu_int_len(arr, len) ({ *(len) = ARRAY_SIZE(arr); arr; })
573 /*
574  * Returns NULL or an s64 type array containing the menu for given
575  * control ID. The total number of the menu items is returned in @len.
576  */
v4l2_ctrl_get_int_menu(u32 id,u32 * len)577 const s64 *v4l2_ctrl_get_int_menu(u32 id, u32 *len)
578 {
579 	static const s64 qmenu_int_vpx_num_partitions[] = {
580 		1, 2, 4, 8,
581 	};
582 
583 	static const s64 qmenu_int_vpx_num_ref_frames[] = {
584 		1, 2, 3,
585 	};
586 
587 	switch (id) {
588 	case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
589 		return __v4l2_qmenu_int_len(qmenu_int_vpx_num_partitions, len);
590 	case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
591 		return __v4l2_qmenu_int_len(qmenu_int_vpx_num_ref_frames, len);
592 	default:
593 		*len = 0;
594 		return NULL;
595 	}
596 }
597 EXPORT_SYMBOL(v4l2_ctrl_get_int_menu);
598 
599 /* Return the control name. */
v4l2_ctrl_get_name(u32 id)600 const char *v4l2_ctrl_get_name(u32 id)
601 {
602 	switch (id) {
603 	/* USER controls */
604 	/* Keep the order of the 'case's the same as in v4l2-controls.h! */
605 	case V4L2_CID_USER_CLASS:		return "User Controls";
606 	case V4L2_CID_BRIGHTNESS:		return "Brightness";
607 	case V4L2_CID_CONTRAST:			return "Contrast";
608 	case V4L2_CID_SATURATION:		return "Saturation";
609 	case V4L2_CID_HUE:			return "Hue";
610 	case V4L2_CID_AUDIO_VOLUME:		return "Volume";
611 	case V4L2_CID_AUDIO_BALANCE:		return "Balance";
612 	case V4L2_CID_AUDIO_BASS:		return "Bass";
613 	case V4L2_CID_AUDIO_TREBLE:		return "Treble";
614 	case V4L2_CID_AUDIO_MUTE:		return "Mute";
615 	case V4L2_CID_AUDIO_LOUDNESS:		return "Loudness";
616 	case V4L2_CID_BLACK_LEVEL:		return "Black Level";
617 	case V4L2_CID_AUTO_WHITE_BALANCE:	return "White Balance, Automatic";
618 	case V4L2_CID_DO_WHITE_BALANCE:		return "Do White Balance";
619 	case V4L2_CID_RED_BALANCE:		return "Red Balance";
620 	case V4L2_CID_BLUE_BALANCE:		return "Blue Balance";
621 	case V4L2_CID_GAMMA:			return "Gamma";
622 	case V4L2_CID_EXPOSURE:			return "Exposure";
623 	case V4L2_CID_AUTOGAIN:			return "Gain, Automatic";
624 	case V4L2_CID_GAIN:			return "Gain";
625 	case V4L2_CID_HFLIP:			return "Horizontal Flip";
626 	case V4L2_CID_VFLIP:			return "Vertical Flip";
627 	case V4L2_CID_POWER_LINE_FREQUENCY:	return "Power Line Frequency";
628 	case V4L2_CID_HUE_AUTO:			return "Hue, Automatic";
629 	case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
630 	case V4L2_CID_SHARPNESS:		return "Sharpness";
631 	case V4L2_CID_BACKLIGHT_COMPENSATION:	return "Backlight Compensation";
632 	case V4L2_CID_CHROMA_AGC:		return "Chroma AGC";
633 	case V4L2_CID_COLOR_KILLER:		return "Color Killer";
634 	case V4L2_CID_COLORFX:			return "Color Effects";
635 	case V4L2_CID_AUTOBRIGHTNESS:		return "Brightness, Automatic";
636 	case V4L2_CID_BAND_STOP_FILTER:		return "Band-Stop Filter";
637 	case V4L2_CID_ROTATE:			return "Rotate";
638 	case V4L2_CID_BG_COLOR:			return "Background Color";
639 	case V4L2_CID_CHROMA_GAIN:		return "Chroma Gain";
640 	case V4L2_CID_ILLUMINATORS_1:		return "Illuminator 1";
641 	case V4L2_CID_ILLUMINATORS_2:		return "Illuminator 2";
642 	case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:	return "Min Number of Capture Buffers";
643 	case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:	return "Min Number of Output Buffers";
644 	case V4L2_CID_ALPHA_COMPONENT:		return "Alpha Component";
645 	case V4L2_CID_COLORFX_CBCR:		return "Color Effects, CbCr";
646 
647 	/* Codec controls */
648 	/* The MPEG controls are applicable to all codec controls
649 	 * and the 'MPEG' part of the define is historical */
650 	/* Keep the order of the 'case's the same as in videodev2.h! */
651 	case V4L2_CID_MPEG_CLASS:		return "Codec Controls";
652 	case V4L2_CID_MPEG_STREAM_TYPE:		return "Stream Type";
653 	case V4L2_CID_MPEG_STREAM_PID_PMT:	return "Stream PMT Program ID";
654 	case V4L2_CID_MPEG_STREAM_PID_AUDIO:	return "Stream Audio Program ID";
655 	case V4L2_CID_MPEG_STREAM_PID_VIDEO:	return "Stream Video Program ID";
656 	case V4L2_CID_MPEG_STREAM_PID_PCR:	return "Stream PCR Program ID";
657 	case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
658 	case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
659 	case V4L2_CID_MPEG_STREAM_VBI_FMT:	return "Stream VBI Format";
660 	case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
661 	case V4L2_CID_MPEG_AUDIO_ENCODING:	return "Audio Encoding";
662 	case V4L2_CID_MPEG_AUDIO_L1_BITRATE:	return "Audio Layer I Bitrate";
663 	case V4L2_CID_MPEG_AUDIO_L2_BITRATE:	return "Audio Layer II Bitrate";
664 	case V4L2_CID_MPEG_AUDIO_L3_BITRATE:	return "Audio Layer III Bitrate";
665 	case V4L2_CID_MPEG_AUDIO_MODE:		return "Audio Stereo Mode";
666 	case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
667 	case V4L2_CID_MPEG_AUDIO_EMPHASIS:	return "Audio Emphasis";
668 	case V4L2_CID_MPEG_AUDIO_CRC:		return "Audio CRC";
669 	case V4L2_CID_MPEG_AUDIO_MUTE:		return "Audio Mute";
670 	case V4L2_CID_MPEG_AUDIO_AAC_BITRATE:	return "Audio AAC Bitrate";
671 	case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:	return "Audio AC-3 Bitrate";
672 	case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:	return "Audio Playback";
673 	case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: return "Audio Multilingual Playback";
674 	case V4L2_CID_MPEG_VIDEO_ENCODING:	return "Video Encoding";
675 	case V4L2_CID_MPEG_VIDEO_ASPECT:	return "Video Aspect";
676 	case V4L2_CID_MPEG_VIDEO_B_FRAMES:	return "Video B Frames";
677 	case V4L2_CID_MPEG_VIDEO_GOP_SIZE:	return "Video GOP Size";
678 	case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:	return "Video GOP Closure";
679 	case V4L2_CID_MPEG_VIDEO_PULLDOWN:	return "Video Pulldown";
680 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:	return "Video Bitrate Mode";
681 	case V4L2_CID_MPEG_VIDEO_BITRATE:	return "Video Bitrate";
682 	case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:	return "Video Peak Bitrate";
683 	case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
684 	case V4L2_CID_MPEG_VIDEO_MUTE:		return "Video Mute";
685 	case V4L2_CID_MPEG_VIDEO_MUTE_YUV:	return "Video Mute YUV";
686 	case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:	return "Decoder Slice Interface";
687 	case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:	return "MPEG4 Loop Filter Enable";
688 	case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:	return "Number of Intra Refresh MBs";
689 	case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:		return "Frame Level Rate Control Enable";
690 	case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:			return "H264 MB Level Rate Control";
691 	case V4L2_CID_MPEG_VIDEO_HEADER_MODE:			return "Sequence Header Mode";
692 	case V4L2_CID_MPEG_VIDEO_MAX_REF_PIC:			return "Max Number of Reference Pics";
693 	case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP:		return "H263 I-Frame QP Value";
694 	case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP:		return "H263 P-Frame QP Value";
695 	case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP:		return "H263 B-Frame QP Value";
696 	case V4L2_CID_MPEG_VIDEO_H263_MIN_QP:			return "H263 Minimum QP Value";
697 	case V4L2_CID_MPEG_VIDEO_H263_MAX_QP:			return "H263 Maximum QP Value";
698 	case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:		return "H264 I-Frame QP Value";
699 	case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:		return "H264 P-Frame QP Value";
700 	case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:		return "H264 B-Frame QP Value";
701 	case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:			return "H264 Maximum QP Value";
702 	case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:			return "H264 Minimum QP Value";
703 	case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:		return "H264 8x8 Transform Enable";
704 	case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:			return "H264 CPB Buffer Size";
705 	case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:		return "H264 Entropy Mode";
706 	case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:			return "H264 I-Frame Period";
707 	case V4L2_CID_MPEG_VIDEO_H264_LEVEL:			return "H264 Level";
708 	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:	return "H264 Loop Filter Alpha Offset";
709 	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:		return "H264 Loop Filter Beta Offset";
710 	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:		return "H264 Loop Filter Mode";
711 	case V4L2_CID_MPEG_VIDEO_H264_PROFILE:			return "H264 Profile";
712 	case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:	return "Vertical Size of SAR";
713 	case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:	return "Horizontal Size of SAR";
714 	case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:		return "Aspect Ratio VUI Enable";
715 	case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:		return "VUI Aspect Ratio IDC";
716 	case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING:	return "H264 Enable Frame Packing SEI";
717 	case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0:	return "H264 Set Curr. Frame as Frame0";
718 	case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:	return "H264 FP Arrangement Type";
719 	case V4L2_CID_MPEG_VIDEO_H264_FMO:			return "H264 Flexible MB Ordering";
720 	case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:		return "H264 Map Type for FMO";
721 	case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP:		return "H264 FMO Number of Slice Groups";
722 	case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION:	return "H264 FMO Direction of Change";
723 	case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE:		return "H264 FMO Size of 1st Slice Grp";
724 	case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH:		return "H264 FMO No. of Consecutive MBs";
725 	case V4L2_CID_MPEG_VIDEO_H264_ASO:			return "H264 Arbitrary Slice Ordering";
726 	case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER:		return "H264 ASO Slice Order";
727 	case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING:	return "Enable H264 Hierarchical Coding";
728 	case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE:	return "H264 Hierarchical Coding Type";
729 	case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:return "H264 Number of HC Layers";
730 	case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP:
731 								return "H264 Set QP Value for HC Layers";
732 	case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:		return "MPEG4 I-Frame QP Value";
733 	case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:		return "MPEG4 P-Frame QP Value";
734 	case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP:		return "MPEG4 B-Frame QP Value";
735 	case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP:			return "MPEG4 Minimum QP Value";
736 	case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP:			return "MPEG4 Maximum QP Value";
737 	case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:			return "MPEG4 Level";
738 	case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:			return "MPEG4 Profile";
739 	case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:			return "Quarter Pixel Search Enable";
740 	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:		return "Maximum Bytes in a Slice";
741 	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:		return "Number of MBs in a Slice";
742 	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:		return "Slice Partitioning Method";
743 	case V4L2_CID_MPEG_VIDEO_VBV_SIZE:			return "VBV Buffer Size";
744 	case V4L2_CID_MPEG_VIDEO_DEC_PTS:			return "Video Decoder PTS";
745 	case V4L2_CID_MPEG_VIDEO_DEC_FRAME:			return "Video Decoder Frame Count";
746 	case V4L2_CID_MPEG_VIDEO_VBV_DELAY:			return "Initial Delay for VBV Control";
747 	case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:		return "Horizontal MV Search Range";
748 	case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:		return "Vertical MV Search Range";
749 	case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:		return "Repeat Sequence Header";
750 
751 	/* VPX controls */
752 	case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:		return "VPX Number of Partitions";
753 	case V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4:		return "VPX Intra Mode Decision Disable";
754 	case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:		return "VPX No. of Refs for P Frame";
755 	case V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL:		return "VPX Loop Filter Level Range";
756 	case V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS:		return "VPX Deblocking Effect Control";
757 	case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD:	return "VPX Golden Frame Refresh Period";
758 	case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:		return "VPX Golden Frame Indicator";
759 	case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP:			return "VPX Minimum QP Value";
760 	case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP:			return "VPX Maximum QP Value";
761 	case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP:		return "VPX I-Frame QP Value";
762 	case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP:		return "VPX P-Frame QP Value";
763 	case V4L2_CID_MPEG_VIDEO_VPX_PROFILE:			return "VPX Profile";
764 
765 	/* CAMERA controls */
766 	/* Keep the order of the 'case's the same as in v4l2-controls.h! */
767 	case V4L2_CID_CAMERA_CLASS:		return "Camera Controls";
768 	case V4L2_CID_EXPOSURE_AUTO:		return "Auto Exposure";
769 	case V4L2_CID_EXPOSURE_ABSOLUTE:	return "Exposure Time, Absolute";
770 	case V4L2_CID_EXPOSURE_AUTO_PRIORITY:	return "Exposure, Dynamic Framerate";
771 	case V4L2_CID_PAN_RELATIVE:		return "Pan, Relative";
772 	case V4L2_CID_TILT_RELATIVE:		return "Tilt, Relative";
773 	case V4L2_CID_PAN_RESET:		return "Pan, Reset";
774 	case V4L2_CID_TILT_RESET:		return "Tilt, Reset";
775 	case V4L2_CID_PAN_ABSOLUTE:		return "Pan, Absolute";
776 	case V4L2_CID_TILT_ABSOLUTE:		return "Tilt, Absolute";
777 	case V4L2_CID_FOCUS_ABSOLUTE:		return "Focus, Absolute";
778 	case V4L2_CID_FOCUS_RELATIVE:		return "Focus, Relative";
779 	case V4L2_CID_FOCUS_AUTO:		return "Focus, Automatic Continuous";
780 	case V4L2_CID_ZOOM_ABSOLUTE:		return "Zoom, Absolute";
781 	case V4L2_CID_ZOOM_RELATIVE:		return "Zoom, Relative";
782 	case V4L2_CID_ZOOM_CONTINUOUS:		return "Zoom, Continuous";
783 	case V4L2_CID_PRIVACY:			return "Privacy";
784 	case V4L2_CID_IRIS_ABSOLUTE:		return "Iris, Absolute";
785 	case V4L2_CID_IRIS_RELATIVE:		return "Iris, Relative";
786 	case V4L2_CID_AUTO_EXPOSURE_BIAS:	return "Auto Exposure, Bias";
787 	case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset";
788 	case V4L2_CID_WIDE_DYNAMIC_RANGE:	return "Wide Dynamic Range";
789 	case V4L2_CID_IMAGE_STABILIZATION:	return "Image Stabilization";
790 	case V4L2_CID_ISO_SENSITIVITY:		return "ISO Sensitivity";
791 	case V4L2_CID_ISO_SENSITIVITY_AUTO:	return "ISO Sensitivity, Auto";
792 	case V4L2_CID_EXPOSURE_METERING:	return "Exposure, Metering Mode";
793 	case V4L2_CID_SCENE_MODE:		return "Scene Mode";
794 	case V4L2_CID_3A_LOCK:			return "3A Lock";
795 	case V4L2_CID_AUTO_FOCUS_START:		return "Auto Focus, Start";
796 	case V4L2_CID_AUTO_FOCUS_STOP:		return "Auto Focus, Stop";
797 	case V4L2_CID_AUTO_FOCUS_STATUS:	return "Auto Focus, Status";
798 	case V4L2_CID_AUTO_FOCUS_RANGE:		return "Auto Focus, Range";
799 	case V4L2_CID_PAN_SPEED:		return "Pan, Speed";
800 	case V4L2_CID_TILT_SPEED:		return "Tilt, Speed";
801 
802 	/* FM Radio Modulator controls */
803 	/* Keep the order of the 'case's the same as in v4l2-controls.h! */
804 	case V4L2_CID_FM_TX_CLASS:		return "FM Radio Modulator Controls";
805 	case V4L2_CID_RDS_TX_DEVIATION:		return "RDS Signal Deviation";
806 	case V4L2_CID_RDS_TX_PI:		return "RDS Program ID";
807 	case V4L2_CID_RDS_TX_PTY:		return "RDS Program Type";
808 	case V4L2_CID_RDS_TX_PS_NAME:		return "RDS PS Name";
809 	case V4L2_CID_RDS_TX_RADIO_TEXT:	return "RDS Radio Text";
810 	case V4L2_CID_RDS_TX_MONO_STEREO:	return "RDS Stereo";
811 	case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:	return "RDS Artificial Head";
812 	case V4L2_CID_RDS_TX_COMPRESSED:	return "RDS Compressed";
813 	case V4L2_CID_RDS_TX_DYNAMIC_PTY:	return "RDS Dynamic PTY";
814 	case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
815 	case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:	return "RDS Traffic Program";
816 	case V4L2_CID_RDS_TX_MUSIC_SPEECH:	return "RDS Music";
817 	case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:	return "RDS Enable Alt Frequencies";
818 	case V4L2_CID_RDS_TX_ALT_FREQS:		return "RDS Alternate Frequencies";
819 	case V4L2_CID_AUDIO_LIMITER_ENABLED:	return "Audio Limiter Feature Enabled";
820 	case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
821 	case V4L2_CID_AUDIO_LIMITER_DEVIATION:	return "Audio Limiter Deviation";
822 	case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled";
823 	case V4L2_CID_AUDIO_COMPRESSION_GAIN:	return "Audio Compression Gain";
824 	case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
825 	case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
826 	case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
827 	case V4L2_CID_PILOT_TONE_ENABLED:	return "Pilot Tone Feature Enabled";
828 	case V4L2_CID_PILOT_TONE_DEVIATION:	return "Pilot Tone Deviation";
829 	case V4L2_CID_PILOT_TONE_FREQUENCY:	return "Pilot Tone Frequency";
830 	case V4L2_CID_TUNE_PREEMPHASIS:		return "Pre-Emphasis";
831 	case V4L2_CID_TUNE_POWER_LEVEL:		return "Tune Power Level";
832 	case V4L2_CID_TUNE_ANTENNA_CAPACITOR:	return "Tune Antenna Capacitor";
833 
834 	/* Flash controls */
835 	/* Keep the order of the 'case's the same as in v4l2-controls.h! */
836 	case V4L2_CID_FLASH_CLASS:		return "Flash Controls";
837 	case V4L2_CID_FLASH_LED_MODE:		return "LED Mode";
838 	case V4L2_CID_FLASH_STROBE_SOURCE:	return "Strobe Source";
839 	case V4L2_CID_FLASH_STROBE:		return "Strobe";
840 	case V4L2_CID_FLASH_STROBE_STOP:	return "Stop Strobe";
841 	case V4L2_CID_FLASH_STROBE_STATUS:	return "Strobe Status";
842 	case V4L2_CID_FLASH_TIMEOUT:		return "Strobe Timeout";
843 	case V4L2_CID_FLASH_INTENSITY:		return "Intensity, Flash Mode";
844 	case V4L2_CID_FLASH_TORCH_INTENSITY:	return "Intensity, Torch Mode";
845 	case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator";
846 	case V4L2_CID_FLASH_FAULT:		return "Faults";
847 	case V4L2_CID_FLASH_CHARGE:		return "Charge";
848 	case V4L2_CID_FLASH_READY:		return "Ready to Strobe";
849 
850 	/* JPEG encoder controls */
851 	/* Keep the order of the 'case's the same as in v4l2-controls.h! */
852 	case V4L2_CID_JPEG_CLASS:		return "JPEG Compression Controls";
853 	case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:	return "Chroma Subsampling";
854 	case V4L2_CID_JPEG_RESTART_INTERVAL:	return "Restart Interval";
855 	case V4L2_CID_JPEG_COMPRESSION_QUALITY:	return "Compression Quality";
856 	case V4L2_CID_JPEG_ACTIVE_MARKER:	return "Active Markers";
857 
858 	/* Image source controls */
859 	/* Keep the order of the 'case's the same as in v4l2-controls.h! */
860 	case V4L2_CID_IMAGE_SOURCE_CLASS:	return "Image Source Controls";
861 	case V4L2_CID_VBLANK:			return "Vertical Blanking";
862 	case V4L2_CID_HBLANK:			return "Horizontal Blanking";
863 	case V4L2_CID_ANALOGUE_GAIN:		return "Analogue Gain";
864 	case V4L2_CID_TEST_PATTERN_RED:		return "Red Pixel Value";
865 	case V4L2_CID_TEST_PATTERN_GREENR:	return "Green (Red) Pixel Value";
866 	case V4L2_CID_TEST_PATTERN_BLUE:	return "Blue Pixel Value";
867 	case V4L2_CID_TEST_PATTERN_GREENB:	return "Green (Blue) Pixel Value";
868 
869 	/* Image processing controls */
870 	/* Keep the order of the 'case's the same as in v4l2-controls.h! */
871 	case V4L2_CID_IMAGE_PROC_CLASS:		return "Image Processing Controls";
872 	case V4L2_CID_LINK_FREQ:		return "Link Frequency";
873 	case V4L2_CID_PIXEL_RATE:		return "Pixel Rate";
874 	case V4L2_CID_TEST_PATTERN:		return "Test Pattern";
875 
876 	/* DV controls */
877 	/* Keep the order of the 'case's the same as in v4l2-controls.h! */
878 	case V4L2_CID_DV_CLASS:			return "Digital Video Controls";
879 	case V4L2_CID_DV_TX_HOTPLUG:		return "Hotplug Present";
880 	case V4L2_CID_DV_TX_RXSENSE:		return "RxSense Present";
881 	case V4L2_CID_DV_TX_EDID_PRESENT:	return "EDID Present";
882 	case V4L2_CID_DV_TX_MODE:		return "Transmit Mode";
883 	case V4L2_CID_DV_TX_RGB_RANGE:		return "Tx RGB Quantization Range";
884 	case V4L2_CID_DV_RX_POWER_PRESENT:	return "Power Present";
885 	case V4L2_CID_DV_RX_RGB_RANGE:		return "Rx RGB Quantization Range";
886 
887 	case V4L2_CID_FM_RX_CLASS:		return "FM Radio Receiver Controls";
888 	case V4L2_CID_TUNE_DEEMPHASIS:		return "De-Emphasis";
889 	case V4L2_CID_RDS_RECEPTION:		return "RDS Reception";
890 	case V4L2_CID_RF_TUNER_CLASS:		return "RF Tuner Controls";
891 	case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:	return "LNA Gain, Auto";
892 	case V4L2_CID_RF_TUNER_LNA_GAIN:	return "LNA Gain";
893 	case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO:	return "Mixer Gain, Auto";
894 	case V4L2_CID_RF_TUNER_MIXER_GAIN:	return "Mixer Gain";
895 	case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:	return "IF Gain, Auto";
896 	case V4L2_CID_RF_TUNER_IF_GAIN:		return "IF Gain";
897 	case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:	return "Bandwidth, Auto";
898 	case V4L2_CID_RF_TUNER_BANDWIDTH:	return "Bandwidth";
899 	case V4L2_CID_RF_TUNER_PLL_LOCK:	return "PLL Lock";
900 	case V4L2_CID_RDS_RX_PTY:		return "RDS Program Type";
901 	case V4L2_CID_RDS_RX_PS_NAME:		return "RDS PS Name";
902 	case V4L2_CID_RDS_RX_RADIO_TEXT:	return "RDS Radio Text";
903 	case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement";
904 	case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:	return "RDS Traffic Program";
905 	case V4L2_CID_RDS_RX_MUSIC_SPEECH:	return "RDS Music";
906 
907 	/* Detection controls */
908 	/* Keep the order of the 'case's the same as in v4l2-controls.h! */
909 	case V4L2_CID_DETECT_CLASS:		return "Detection Controls";
910 	case V4L2_CID_DETECT_MD_MODE:		return "Motion Detection Mode";
911 	case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD: return "MD Global Threshold";
912 	case V4L2_CID_DETECT_MD_THRESHOLD_GRID:	return "MD Threshold Grid";
913 	case V4L2_CID_DETECT_MD_REGION_GRID:	return "MD Region Grid";
914 	default:
915 		return NULL;
916 	}
917 }
918 EXPORT_SYMBOL(v4l2_ctrl_get_name);
919 
v4l2_ctrl_fill(u32 id,const char ** name,enum v4l2_ctrl_type * type,s64 * min,s64 * max,u64 * step,s64 * def,u32 * flags)920 void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
921 		    s64 *min, s64 *max, u64 *step, s64 *def, u32 *flags)
922 {
923 	*name = v4l2_ctrl_get_name(id);
924 	*flags = 0;
925 
926 	switch (id) {
927 	case V4L2_CID_AUDIO_MUTE:
928 	case V4L2_CID_AUDIO_LOUDNESS:
929 	case V4L2_CID_AUTO_WHITE_BALANCE:
930 	case V4L2_CID_AUTOGAIN:
931 	case V4L2_CID_HFLIP:
932 	case V4L2_CID_VFLIP:
933 	case V4L2_CID_HUE_AUTO:
934 	case V4L2_CID_CHROMA_AGC:
935 	case V4L2_CID_COLOR_KILLER:
936 	case V4L2_CID_AUTOBRIGHTNESS:
937 	case V4L2_CID_MPEG_AUDIO_MUTE:
938 	case V4L2_CID_MPEG_VIDEO_MUTE:
939 	case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
940 	case V4L2_CID_MPEG_VIDEO_PULLDOWN:
941 	case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
942 	case V4L2_CID_FOCUS_AUTO:
943 	case V4L2_CID_PRIVACY:
944 	case V4L2_CID_AUDIO_LIMITER_ENABLED:
945 	case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
946 	case V4L2_CID_PILOT_TONE_ENABLED:
947 	case V4L2_CID_ILLUMINATORS_1:
948 	case V4L2_CID_ILLUMINATORS_2:
949 	case V4L2_CID_FLASH_STROBE_STATUS:
950 	case V4L2_CID_FLASH_CHARGE:
951 	case V4L2_CID_FLASH_READY:
952 	case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
953 	case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
954 	case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
955 	case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
956 	case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
957 	case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
958 	case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
959 	case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:
960 	case V4L2_CID_WIDE_DYNAMIC_RANGE:
961 	case V4L2_CID_IMAGE_STABILIZATION:
962 	case V4L2_CID_RDS_RECEPTION:
963 	case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO:
964 	case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO:
965 	case V4L2_CID_RF_TUNER_IF_GAIN_AUTO:
966 	case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO:
967 	case V4L2_CID_RF_TUNER_PLL_LOCK:
968 	case V4L2_CID_RDS_TX_MONO_STEREO:
969 	case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:
970 	case V4L2_CID_RDS_TX_COMPRESSED:
971 	case V4L2_CID_RDS_TX_DYNAMIC_PTY:
972 	case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
973 	case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
974 	case V4L2_CID_RDS_TX_MUSIC_SPEECH:
975 	case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:
976 	case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
977 	case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
978 	case V4L2_CID_RDS_RX_MUSIC_SPEECH:
979 		*type = V4L2_CTRL_TYPE_BOOLEAN;
980 		*min = 0;
981 		*max = *step = 1;
982 		break;
983 	case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:
984 	case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:
985 		*type = V4L2_CTRL_TYPE_INTEGER;
986 		break;
987 	case V4L2_CID_PAN_RESET:
988 	case V4L2_CID_TILT_RESET:
989 	case V4L2_CID_FLASH_STROBE:
990 	case V4L2_CID_FLASH_STROBE_STOP:
991 	case V4L2_CID_AUTO_FOCUS_START:
992 	case V4L2_CID_AUTO_FOCUS_STOP:
993 		*type = V4L2_CTRL_TYPE_BUTTON;
994 		*flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
995 			  V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
996 		*min = *max = *step = *def = 0;
997 		break;
998 	case V4L2_CID_POWER_LINE_FREQUENCY:
999 	case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1000 	case V4L2_CID_MPEG_AUDIO_ENCODING:
1001 	case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1002 	case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1003 	case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1004 	case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
1005 	case V4L2_CID_MPEG_AUDIO_MODE:
1006 	case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1007 	case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1008 	case V4L2_CID_MPEG_AUDIO_CRC:
1009 	case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
1010 	case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
1011 	case V4L2_CID_MPEG_VIDEO_ENCODING:
1012 	case V4L2_CID_MPEG_VIDEO_ASPECT:
1013 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1014 	case V4L2_CID_MPEG_STREAM_TYPE:
1015 	case V4L2_CID_MPEG_STREAM_VBI_FMT:
1016 	case V4L2_CID_EXPOSURE_AUTO:
1017 	case V4L2_CID_AUTO_FOCUS_RANGE:
1018 	case V4L2_CID_COLORFX:
1019 	case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
1020 	case V4L2_CID_TUNE_PREEMPHASIS:
1021 	case V4L2_CID_FLASH_LED_MODE:
1022 	case V4L2_CID_FLASH_STROBE_SOURCE:
1023 	case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1024 	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1025 	case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1026 	case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1027 	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1028 	case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1029 	case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1030 	case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
1031 	case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
1032 	case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1033 	case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1034 	case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1035 	case V4L2_CID_ISO_SENSITIVITY_AUTO:
1036 	case V4L2_CID_EXPOSURE_METERING:
1037 	case V4L2_CID_SCENE_MODE:
1038 	case V4L2_CID_DV_TX_MODE:
1039 	case V4L2_CID_DV_TX_RGB_RANGE:
1040 	case V4L2_CID_DV_RX_RGB_RANGE:
1041 	case V4L2_CID_TEST_PATTERN:
1042 	case V4L2_CID_TUNE_DEEMPHASIS:
1043 	case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
1044 	case V4L2_CID_DETECT_MD_MODE:
1045 		*type = V4L2_CTRL_TYPE_MENU;
1046 		break;
1047 	case V4L2_CID_LINK_FREQ:
1048 		*type = V4L2_CTRL_TYPE_INTEGER_MENU;
1049 		break;
1050 	case V4L2_CID_RDS_TX_PS_NAME:
1051 	case V4L2_CID_RDS_TX_RADIO_TEXT:
1052 	case V4L2_CID_RDS_RX_PS_NAME:
1053 	case V4L2_CID_RDS_RX_RADIO_TEXT:
1054 		*type = V4L2_CTRL_TYPE_STRING;
1055 		break;
1056 	case V4L2_CID_ISO_SENSITIVITY:
1057 	case V4L2_CID_AUTO_EXPOSURE_BIAS:
1058 	case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
1059 	case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
1060 		*type = V4L2_CTRL_TYPE_INTEGER_MENU;
1061 		break;
1062 	case V4L2_CID_USER_CLASS:
1063 	case V4L2_CID_CAMERA_CLASS:
1064 	case V4L2_CID_MPEG_CLASS:
1065 	case V4L2_CID_FM_TX_CLASS:
1066 	case V4L2_CID_FLASH_CLASS:
1067 	case V4L2_CID_JPEG_CLASS:
1068 	case V4L2_CID_IMAGE_SOURCE_CLASS:
1069 	case V4L2_CID_IMAGE_PROC_CLASS:
1070 	case V4L2_CID_DV_CLASS:
1071 	case V4L2_CID_FM_RX_CLASS:
1072 	case V4L2_CID_RF_TUNER_CLASS:
1073 	case V4L2_CID_DETECT_CLASS:
1074 		*type = V4L2_CTRL_TYPE_CTRL_CLASS;
1075 		/* You can neither read not write these */
1076 		*flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
1077 		*min = *max = *step = *def = 0;
1078 		break;
1079 	case V4L2_CID_BG_COLOR:
1080 		*type = V4L2_CTRL_TYPE_INTEGER;
1081 		*step = 1;
1082 		*min = 0;
1083 		/* Max is calculated as RGB888 that is 2^24 */
1084 		*max = 0xFFFFFF;
1085 		break;
1086 	case V4L2_CID_FLASH_FAULT:
1087 	case V4L2_CID_JPEG_ACTIVE_MARKER:
1088 	case V4L2_CID_3A_LOCK:
1089 	case V4L2_CID_AUTO_FOCUS_STATUS:
1090 	case V4L2_CID_DV_TX_HOTPLUG:
1091 	case V4L2_CID_DV_TX_RXSENSE:
1092 	case V4L2_CID_DV_TX_EDID_PRESENT:
1093 	case V4L2_CID_DV_RX_POWER_PRESENT:
1094 		*type = V4L2_CTRL_TYPE_BITMASK;
1095 		break;
1096 	case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
1097 	case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
1098 		*type = V4L2_CTRL_TYPE_INTEGER;
1099 		*flags |= V4L2_CTRL_FLAG_READ_ONLY;
1100 		break;
1101 	case V4L2_CID_MPEG_VIDEO_DEC_PTS:
1102 		*type = V4L2_CTRL_TYPE_INTEGER64;
1103 		*flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1104 		*min = *def = 0;
1105 		*max = 0x1ffffffffLL;
1106 		*step = 1;
1107 		break;
1108 	case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
1109 		*type = V4L2_CTRL_TYPE_INTEGER64;
1110 		*flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1111 		*min = *def = 0;
1112 		*max = 0x7fffffffffffffffLL;
1113 		*step = 1;
1114 		break;
1115 	case V4L2_CID_PIXEL_RATE:
1116 		*type = V4L2_CTRL_TYPE_INTEGER64;
1117 		*flags |= V4L2_CTRL_FLAG_READ_ONLY;
1118 		break;
1119 	case V4L2_CID_DETECT_MD_REGION_GRID:
1120 		*type = V4L2_CTRL_TYPE_U8;
1121 		break;
1122 	case V4L2_CID_DETECT_MD_THRESHOLD_GRID:
1123 		*type = V4L2_CTRL_TYPE_U16;
1124 		break;
1125 	case V4L2_CID_RDS_TX_ALT_FREQS:
1126 		*type = V4L2_CTRL_TYPE_U32;
1127 		break;
1128 	default:
1129 		*type = V4L2_CTRL_TYPE_INTEGER;
1130 		break;
1131 	}
1132 	switch (id) {
1133 	case V4L2_CID_MPEG_AUDIO_ENCODING:
1134 	case V4L2_CID_MPEG_AUDIO_MODE:
1135 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1136 	case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1137 	case V4L2_CID_MPEG_STREAM_TYPE:
1138 		*flags |= V4L2_CTRL_FLAG_UPDATE;
1139 		break;
1140 	case V4L2_CID_AUDIO_VOLUME:
1141 	case V4L2_CID_AUDIO_BALANCE:
1142 	case V4L2_CID_AUDIO_BASS:
1143 	case V4L2_CID_AUDIO_TREBLE:
1144 	case V4L2_CID_BRIGHTNESS:
1145 	case V4L2_CID_CONTRAST:
1146 	case V4L2_CID_SATURATION:
1147 	case V4L2_CID_HUE:
1148 	case V4L2_CID_RED_BALANCE:
1149 	case V4L2_CID_BLUE_BALANCE:
1150 	case V4L2_CID_GAMMA:
1151 	case V4L2_CID_SHARPNESS:
1152 	case V4L2_CID_CHROMA_GAIN:
1153 	case V4L2_CID_RDS_TX_DEVIATION:
1154 	case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1155 	case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1156 	case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1157 	case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1158 	case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1159 	case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1160 	case V4L2_CID_PILOT_TONE_DEVIATION:
1161 	case V4L2_CID_PILOT_TONE_FREQUENCY:
1162 	case V4L2_CID_TUNE_POWER_LEVEL:
1163 	case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1164 	case V4L2_CID_RF_TUNER_LNA_GAIN:
1165 	case V4L2_CID_RF_TUNER_MIXER_GAIN:
1166 	case V4L2_CID_RF_TUNER_IF_GAIN:
1167 	case V4L2_CID_RF_TUNER_BANDWIDTH:
1168 	case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD:
1169 		*flags |= V4L2_CTRL_FLAG_SLIDER;
1170 		break;
1171 	case V4L2_CID_PAN_RELATIVE:
1172 	case V4L2_CID_TILT_RELATIVE:
1173 	case V4L2_CID_FOCUS_RELATIVE:
1174 	case V4L2_CID_IRIS_RELATIVE:
1175 	case V4L2_CID_ZOOM_RELATIVE:
1176 		*flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1177 			  V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1178 		break;
1179 	case V4L2_CID_FLASH_STROBE_STATUS:
1180 	case V4L2_CID_AUTO_FOCUS_STATUS:
1181 	case V4L2_CID_FLASH_READY:
1182 	case V4L2_CID_DV_TX_HOTPLUG:
1183 	case V4L2_CID_DV_TX_RXSENSE:
1184 	case V4L2_CID_DV_TX_EDID_PRESENT:
1185 	case V4L2_CID_DV_RX_POWER_PRESENT:
1186 	case V4L2_CID_RDS_RX_PTY:
1187 	case V4L2_CID_RDS_RX_PS_NAME:
1188 	case V4L2_CID_RDS_RX_RADIO_TEXT:
1189 	case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
1190 	case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
1191 	case V4L2_CID_RDS_RX_MUSIC_SPEECH:
1192 		*flags |= V4L2_CTRL_FLAG_READ_ONLY;
1193 		break;
1194 	case V4L2_CID_RF_TUNER_PLL_LOCK:
1195 		*flags |= V4L2_CTRL_FLAG_VOLATILE;
1196 		break;
1197 	}
1198 }
1199 EXPORT_SYMBOL(v4l2_ctrl_fill);
1200 
fill_event(struct v4l2_event * ev,struct v4l2_ctrl * ctrl,u32 changes)1201 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes)
1202 {
1203 	memset(ev->reserved, 0, sizeof(ev->reserved));
1204 	ev->type = V4L2_EVENT_CTRL;
1205 	ev->id = ctrl->id;
1206 	ev->u.ctrl.changes = changes;
1207 	ev->u.ctrl.type = ctrl->type;
1208 	ev->u.ctrl.flags = ctrl->flags;
1209 	if (ctrl->is_ptr)
1210 		ev->u.ctrl.value64 = 0;
1211 	else
1212 		ev->u.ctrl.value64 = *ctrl->p_cur.p_s64;
1213 	ev->u.ctrl.minimum = ctrl->minimum;
1214 	ev->u.ctrl.maximum = ctrl->maximum;
1215 	if (ctrl->type == V4L2_CTRL_TYPE_MENU
1216 	    || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1217 		ev->u.ctrl.step = 1;
1218 	else
1219 		ev->u.ctrl.step = ctrl->step;
1220 	ev->u.ctrl.default_value = ctrl->default_value;
1221 }
1222 
send_event(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,u32 changes)1223 static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
1224 {
1225 	struct v4l2_event ev;
1226 	struct v4l2_subscribed_event *sev;
1227 
1228 	if (list_empty(&ctrl->ev_subs))
1229 		return;
1230 	fill_event(&ev, ctrl, changes);
1231 
1232 	list_for_each_entry(sev, &ctrl->ev_subs, node)
1233 		if (sev->fh != fh ||
1234 		    (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
1235 			v4l2_event_queue_fh(sev->fh, &ev);
1236 }
1237 
std_equal(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr1,union v4l2_ctrl_ptr ptr2)1238 static bool std_equal(const struct v4l2_ctrl *ctrl, u32 idx,
1239 		      union v4l2_ctrl_ptr ptr1,
1240 		      union v4l2_ctrl_ptr ptr2)
1241 {
1242 	switch (ctrl->type) {
1243 	case V4L2_CTRL_TYPE_BUTTON:
1244 		return false;
1245 	case V4L2_CTRL_TYPE_STRING:
1246 		idx *= ctrl->elem_size;
1247 		/* strings are always 0-terminated */
1248 		return !strcmp(ptr1.p_char + idx, ptr2.p_char + idx);
1249 	case V4L2_CTRL_TYPE_INTEGER64:
1250 		return ptr1.p_s64[idx] == ptr2.p_s64[idx];
1251 	case V4L2_CTRL_TYPE_U8:
1252 		return ptr1.p_u8[idx] == ptr2.p_u8[idx];
1253 	case V4L2_CTRL_TYPE_U16:
1254 		return ptr1.p_u16[idx] == ptr2.p_u16[idx];
1255 	case V4L2_CTRL_TYPE_U32:
1256 		return ptr1.p_u32[idx] == ptr2.p_u32[idx];
1257 	default:
1258 		if (ctrl->is_int)
1259 			return ptr1.p_s32[idx] == ptr2.p_s32[idx];
1260 		idx *= ctrl->elem_size;
1261 		return !memcmp(ptr1.p + idx, ptr2.p + idx, ctrl->elem_size);
1262 	}
1263 }
1264 
std_init(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr)1265 static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
1266 		     union v4l2_ctrl_ptr ptr)
1267 {
1268 	switch (ctrl->type) {
1269 	case V4L2_CTRL_TYPE_STRING:
1270 		idx *= ctrl->elem_size;
1271 		memset(ptr.p_char + idx, ' ', ctrl->minimum);
1272 		ptr.p_char[idx + ctrl->minimum] = '\0';
1273 		break;
1274 	case V4L2_CTRL_TYPE_INTEGER64:
1275 		ptr.p_s64[idx] = ctrl->default_value;
1276 		break;
1277 	case V4L2_CTRL_TYPE_INTEGER:
1278 	case V4L2_CTRL_TYPE_INTEGER_MENU:
1279 	case V4L2_CTRL_TYPE_MENU:
1280 	case V4L2_CTRL_TYPE_BITMASK:
1281 	case V4L2_CTRL_TYPE_BOOLEAN:
1282 		ptr.p_s32[idx] = ctrl->default_value;
1283 		break;
1284 	case V4L2_CTRL_TYPE_U8:
1285 		ptr.p_u8[idx] = ctrl->default_value;
1286 		break;
1287 	case V4L2_CTRL_TYPE_U16:
1288 		ptr.p_u16[idx] = ctrl->default_value;
1289 		break;
1290 	case V4L2_CTRL_TYPE_U32:
1291 		ptr.p_u32[idx] = ctrl->default_value;
1292 		break;
1293 	default:
1294 		idx *= ctrl->elem_size;
1295 		memset(ptr.p + idx, 0, ctrl->elem_size);
1296 		break;
1297 	}
1298 }
1299 
std_log(const struct v4l2_ctrl * ctrl)1300 static void std_log(const struct v4l2_ctrl *ctrl)
1301 {
1302 	union v4l2_ctrl_ptr ptr = ctrl->p_cur;
1303 
1304 	if (ctrl->is_array) {
1305 		unsigned i;
1306 
1307 		for (i = 0; i < ctrl->nr_of_dims; i++)
1308 			pr_cont("[%u]", ctrl->dims[i]);
1309 		pr_cont(" ");
1310 	}
1311 
1312 	switch (ctrl->type) {
1313 	case V4L2_CTRL_TYPE_INTEGER:
1314 		pr_cont("%d", *ptr.p_s32);
1315 		break;
1316 	case V4L2_CTRL_TYPE_BOOLEAN:
1317 		pr_cont("%s", *ptr.p_s32 ? "true" : "false");
1318 		break;
1319 	case V4L2_CTRL_TYPE_MENU:
1320 		pr_cont("%s", ctrl->qmenu[*ptr.p_s32]);
1321 		break;
1322 	case V4L2_CTRL_TYPE_INTEGER_MENU:
1323 		pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]);
1324 		break;
1325 	case V4L2_CTRL_TYPE_BITMASK:
1326 		pr_cont("0x%08x", *ptr.p_s32);
1327 		break;
1328 	case V4L2_CTRL_TYPE_INTEGER64:
1329 		pr_cont("%lld", *ptr.p_s64);
1330 		break;
1331 	case V4L2_CTRL_TYPE_STRING:
1332 		pr_cont("%s", ptr.p_char);
1333 		break;
1334 	case V4L2_CTRL_TYPE_U8:
1335 		pr_cont("%u", (unsigned)*ptr.p_u8);
1336 		break;
1337 	case V4L2_CTRL_TYPE_U16:
1338 		pr_cont("%u", (unsigned)*ptr.p_u16);
1339 		break;
1340 	case V4L2_CTRL_TYPE_U32:
1341 		pr_cont("%u", (unsigned)*ptr.p_u32);
1342 		break;
1343 	default:
1344 		pr_cont("unknown type %d", ctrl->type);
1345 		break;
1346 	}
1347 }
1348 
1349 /*
1350  * Round towards the closest legal value. Be careful when we are
1351  * close to the maximum range of the control type to prevent
1352  * wrap-arounds.
1353  */
1354 #define ROUND_TO_RANGE(val, offset_type, ctrl)			\
1355 ({								\
1356 	offset_type offset;					\
1357 	if ((ctrl)->maximum >= 0 &&				\
1358 	    val >= (ctrl)->maximum - (s32)((ctrl)->step / 2))	\
1359 		val = (ctrl)->maximum;				\
1360 	else							\
1361 		val += (s32)((ctrl)->step / 2);			\
1362 	val = clamp_t(typeof(val), val,				\
1363 		      (ctrl)->minimum, (ctrl)->maximum);	\
1364 	offset = (val) - (ctrl)->minimum;			\
1365 	offset = (ctrl)->step * (offset / (u32)(ctrl)->step);	\
1366 	val = (ctrl)->minimum + offset;				\
1367 	0;							\
1368 })
1369 
1370 /* Validate a new control */
std_validate(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr)1371 static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
1372 			union v4l2_ctrl_ptr ptr)
1373 {
1374 	size_t len;
1375 	u64 offset;
1376 	s64 val;
1377 
1378 	switch (ctrl->type) {
1379 	case V4L2_CTRL_TYPE_INTEGER:
1380 		return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
1381 	case V4L2_CTRL_TYPE_INTEGER64:
1382 		/*
1383 		 * We can't use the ROUND_TO_RANGE define here due to
1384 		 * the u64 divide that needs special care.
1385 		 */
1386 		val = ptr.p_s64[idx];
1387 		if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2))
1388 			val = ctrl->maximum;
1389 		else
1390 			val += (s64)(ctrl->step / 2);
1391 		val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum);
1392 		offset = val - ctrl->minimum;
1393 		do_div(offset, ctrl->step);
1394 		ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step;
1395 		return 0;
1396 	case V4L2_CTRL_TYPE_U8:
1397 		return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl);
1398 	case V4L2_CTRL_TYPE_U16:
1399 		return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl);
1400 	case V4L2_CTRL_TYPE_U32:
1401 		return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl);
1402 
1403 	case V4L2_CTRL_TYPE_BOOLEAN:
1404 		ptr.p_s32[idx] = !!ptr.p_s32[idx];
1405 		return 0;
1406 
1407 	case V4L2_CTRL_TYPE_MENU:
1408 	case V4L2_CTRL_TYPE_INTEGER_MENU:
1409 		if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum)
1410 			return -ERANGE;
1411 		if (ctrl->menu_skip_mask & (1 << ptr.p_s32[idx]))
1412 			return -EINVAL;
1413 		if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1414 		    ctrl->qmenu[ptr.p_s32[idx]][0] == '\0')
1415 			return -EINVAL;
1416 		return 0;
1417 
1418 	case V4L2_CTRL_TYPE_BITMASK:
1419 		ptr.p_s32[idx] &= ctrl->maximum;
1420 		return 0;
1421 
1422 	case V4L2_CTRL_TYPE_BUTTON:
1423 	case V4L2_CTRL_TYPE_CTRL_CLASS:
1424 		ptr.p_s32[idx] = 0;
1425 		return 0;
1426 
1427 	case V4L2_CTRL_TYPE_STRING:
1428 		idx *= ctrl->elem_size;
1429 		len = strlen(ptr.p_char + idx);
1430 		if (len < ctrl->minimum)
1431 			return -ERANGE;
1432 		if ((len - (u32)ctrl->minimum) % (u32)ctrl->step)
1433 			return -ERANGE;
1434 		return 0;
1435 
1436 	default:
1437 		return -EINVAL;
1438 	}
1439 }
1440 
1441 static const struct v4l2_ctrl_type_ops std_type_ops = {
1442 	.equal = std_equal,
1443 	.init = std_init,
1444 	.log = std_log,
1445 	.validate = std_validate,
1446 };
1447 
1448 /* Helper function: copy the given control value back to the caller */
ptr_to_user(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl,union v4l2_ctrl_ptr ptr)1449 static int ptr_to_user(struct v4l2_ext_control *c,
1450 		       struct v4l2_ctrl *ctrl,
1451 		       union v4l2_ctrl_ptr ptr)
1452 {
1453 	u32 len;
1454 
1455 	if (ctrl->is_ptr && !ctrl->is_string)
1456 		return copy_to_user(c->ptr, ptr.p, c->size) ?
1457 		       -EFAULT : 0;
1458 
1459 	switch (ctrl->type) {
1460 	case V4L2_CTRL_TYPE_STRING:
1461 		len = strlen(ptr.p_char);
1462 		if (c->size < len + 1) {
1463 			c->size = ctrl->elem_size;
1464 			return -ENOSPC;
1465 		}
1466 		return copy_to_user(c->string, ptr.p_char, len + 1) ?
1467 		       -EFAULT : 0;
1468 	case V4L2_CTRL_TYPE_INTEGER64:
1469 		c->value64 = *ptr.p_s64;
1470 		break;
1471 	default:
1472 		c->value = *ptr.p_s32;
1473 		break;
1474 	}
1475 	return 0;
1476 }
1477 
1478 /* Helper function: copy the current control value back to the caller */
cur_to_user(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl)1479 static int cur_to_user(struct v4l2_ext_control *c,
1480 		       struct v4l2_ctrl *ctrl)
1481 {
1482 	return ptr_to_user(c, ctrl, ctrl->p_cur);
1483 }
1484 
1485 /* Helper function: copy the new control value back to the caller */
new_to_user(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl)1486 static int new_to_user(struct v4l2_ext_control *c,
1487 		       struct v4l2_ctrl *ctrl)
1488 {
1489 	return ptr_to_user(c, ctrl, ctrl->p_new);
1490 }
1491 
1492 /* Helper function: copy the caller-provider value to the given control value */
user_to_ptr(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl,union v4l2_ctrl_ptr ptr)1493 static int user_to_ptr(struct v4l2_ext_control *c,
1494 		       struct v4l2_ctrl *ctrl,
1495 		       union v4l2_ctrl_ptr ptr)
1496 {
1497 	int ret;
1498 	u32 size;
1499 
1500 	ctrl->is_new = 1;
1501 	if (ctrl->is_ptr && !ctrl->is_string) {
1502 		unsigned idx;
1503 
1504 		ret = copy_from_user(ptr.p, c->ptr, c->size) ? -EFAULT : 0;
1505 		if (ret || !ctrl->is_array)
1506 			return ret;
1507 		for (idx = c->size / ctrl->elem_size; idx < ctrl->elems; idx++)
1508 			ctrl->type_ops->init(ctrl, idx, ptr);
1509 		return 0;
1510 	}
1511 
1512 	switch (ctrl->type) {
1513 	case V4L2_CTRL_TYPE_INTEGER64:
1514 		*ptr.p_s64 = c->value64;
1515 		break;
1516 	case V4L2_CTRL_TYPE_STRING:
1517 		size = c->size;
1518 		if (size == 0)
1519 			return -ERANGE;
1520 		if (size > ctrl->maximum + 1)
1521 			size = ctrl->maximum + 1;
1522 		ret = copy_from_user(ptr.p_char, c->string, size) ? -EFAULT : 0;
1523 		if (!ret) {
1524 			char last = ptr.p_char[size - 1];
1525 
1526 			ptr.p_char[size - 1] = 0;
1527 			/* If the string was longer than ctrl->maximum,
1528 			   then return an error. */
1529 			if (strlen(ptr.p_char) == ctrl->maximum && last)
1530 				return -ERANGE;
1531 		}
1532 		return ret;
1533 	default:
1534 		*ptr.p_s32 = c->value;
1535 		break;
1536 	}
1537 	return 0;
1538 }
1539 
1540 /* Helper function: copy the caller-provider value as the new control value */
user_to_new(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl)1541 static int user_to_new(struct v4l2_ext_control *c,
1542 		       struct v4l2_ctrl *ctrl)
1543 {
1544 	return user_to_ptr(c, ctrl, ctrl->p_new);
1545 }
1546 
1547 /* Copy the one value to another. */
ptr_to_ptr(struct v4l2_ctrl * ctrl,union v4l2_ctrl_ptr from,union v4l2_ctrl_ptr to)1548 static void ptr_to_ptr(struct v4l2_ctrl *ctrl,
1549 		       union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to)
1550 {
1551 	if (ctrl == NULL)
1552 		return;
1553 	memcpy(to.p, from.p, ctrl->elems * ctrl->elem_size);
1554 }
1555 
1556 /* Copy the new value to the current value. */
new_to_cur(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,u32 ch_flags)1557 static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
1558 {
1559 	bool changed;
1560 
1561 	if (ctrl == NULL)
1562 		return;
1563 
1564 	/* has_changed is set by cluster_changed */
1565 	changed = ctrl->has_changed;
1566 	if (changed)
1567 		ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur);
1568 
1569 	if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
1570 		/* Note: CH_FLAGS is only set for auto clusters. */
1571 		ctrl->flags &=
1572 			~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1573 		if (!is_cur_manual(ctrl->cluster[0])) {
1574 			ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1575 			if (ctrl->cluster[0]->has_volatiles)
1576 				ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1577 		}
1578 		fh = NULL;
1579 	}
1580 	if (changed || ch_flags) {
1581 		/* If a control was changed that was not one of the controls
1582 		   modified by the application, then send the event to all. */
1583 		if (!ctrl->is_new)
1584 			fh = NULL;
1585 		send_event(fh, ctrl,
1586 			(changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
1587 		if (ctrl->call_notify && changed && ctrl->handler->notify)
1588 			ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
1589 	}
1590 }
1591 
1592 /* Copy the current value to the new value */
cur_to_new(struct v4l2_ctrl * ctrl)1593 static void cur_to_new(struct v4l2_ctrl *ctrl)
1594 {
1595 	if (ctrl == NULL)
1596 		return;
1597 	ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
1598 }
1599 
1600 /* Return non-zero if one or more of the controls in the cluster has a new
1601    value that differs from the current value. */
cluster_changed(struct v4l2_ctrl * master)1602 static int cluster_changed(struct v4l2_ctrl *master)
1603 {
1604 	bool changed = false;
1605 	unsigned idx;
1606 	int i;
1607 
1608 	for (i = 0; i < master->ncontrols; i++) {
1609 		struct v4l2_ctrl *ctrl = master->cluster[i];
1610 		bool ctrl_changed = false;
1611 
1612 		if (ctrl == NULL)
1613 			continue;
1614 
1615 		if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE)
1616 			changed = ctrl_changed = true;
1617 
1618 		/*
1619 		 * Set has_changed to false to avoid generating
1620 		 * the event V4L2_EVENT_CTRL_CH_VALUE
1621 		 */
1622 		if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
1623 			ctrl->has_changed = false;
1624 			continue;
1625 		}
1626 
1627 		for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++)
1628 			ctrl_changed = !ctrl->type_ops->equal(ctrl, idx,
1629 				ctrl->p_cur, ctrl->p_new);
1630 		ctrl->has_changed = ctrl_changed;
1631 		changed |= ctrl->has_changed;
1632 	}
1633 	return changed;
1634 }
1635 
1636 /* Control range checking */
check_range(enum v4l2_ctrl_type type,s64 min,s64 max,u64 step,s64 def)1637 static int check_range(enum v4l2_ctrl_type type,
1638 		s64 min, s64 max, u64 step, s64 def)
1639 {
1640 	switch (type) {
1641 	case V4L2_CTRL_TYPE_BOOLEAN:
1642 		if (step != 1 || max > 1 || min < 0)
1643 			return -ERANGE;
1644 		/* fall through */
1645 	case V4L2_CTRL_TYPE_U8:
1646 	case V4L2_CTRL_TYPE_U16:
1647 	case V4L2_CTRL_TYPE_U32:
1648 	case V4L2_CTRL_TYPE_INTEGER:
1649 	case V4L2_CTRL_TYPE_INTEGER64:
1650 		if (step == 0 || min > max || def < min || def > max)
1651 			return -ERANGE;
1652 		return 0;
1653 	case V4L2_CTRL_TYPE_BITMASK:
1654 		if (step || min || !max || (def & ~max))
1655 			return -ERANGE;
1656 		return 0;
1657 	case V4L2_CTRL_TYPE_MENU:
1658 	case V4L2_CTRL_TYPE_INTEGER_MENU:
1659 		if (min > max || def < min || def > max)
1660 			return -ERANGE;
1661 		/* Note: step == menu_skip_mask for menu controls.
1662 		   So here we check if the default value is masked out. */
1663 		if (step && ((1 << def) & step))
1664 			return -EINVAL;
1665 		return 0;
1666 	case V4L2_CTRL_TYPE_STRING:
1667 		if (min > max || min < 0 || step < 1 || def)
1668 			return -ERANGE;
1669 		return 0;
1670 	default:
1671 		return 0;
1672 	}
1673 }
1674 
1675 /* Validate a new control */
validate_new(const struct v4l2_ctrl * ctrl,union v4l2_ctrl_ptr p_new)1676 static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
1677 {
1678 	unsigned idx;
1679 	int err = 0;
1680 
1681 	if (!ctrl->is_ptr) {
1682 		switch (ctrl->type) {
1683 		case V4L2_CTRL_TYPE_INTEGER:
1684 		case V4L2_CTRL_TYPE_INTEGER_MENU:
1685 		case V4L2_CTRL_TYPE_MENU:
1686 		case V4L2_CTRL_TYPE_BITMASK:
1687 		case V4L2_CTRL_TYPE_BOOLEAN:
1688 		case V4L2_CTRL_TYPE_BUTTON:
1689 		case V4L2_CTRL_TYPE_CTRL_CLASS:
1690 		case V4L2_CTRL_TYPE_INTEGER64:
1691 			return ctrl->type_ops->validate(ctrl, 0, p_new);
1692 		default:
1693 			break;
1694 		}
1695 	}
1696 	for (idx = 0; !err && idx < ctrl->elems; idx++)
1697 		err = ctrl->type_ops->validate(ctrl, idx, p_new);
1698 	return err;
1699 }
1700 
node2id(struct list_head * node)1701 static inline u32 node2id(struct list_head *node)
1702 {
1703 	return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1704 }
1705 
1706 /* Set the handler's error code if it wasn't set earlier already */
handler_set_err(struct v4l2_ctrl_handler * hdl,int err)1707 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1708 {
1709 	if (hdl->error == 0)
1710 		hdl->error = err;
1711 	return err;
1712 }
1713 
1714 /* Initialize the handler */
v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler * hdl,unsigned nr_of_controls_hint,struct lock_class_key * key,const char * name)1715 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
1716 				 unsigned nr_of_controls_hint,
1717 				 struct lock_class_key *key, const char *name)
1718 {
1719 	hdl->lock = &hdl->_lock;
1720 	mutex_init(hdl->lock);
1721 	lockdep_set_class_and_name(hdl->lock, key, name);
1722 	INIT_LIST_HEAD(&hdl->ctrls);
1723 	INIT_LIST_HEAD(&hdl->ctrl_refs);
1724 	hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1725 	hdl->buckets = kcalloc(hdl->nr_of_buckets, sizeof(hdl->buckets[0]),
1726 			       GFP_KERNEL);
1727 	hdl->error = hdl->buckets ? 0 : -ENOMEM;
1728 	return hdl->error;
1729 }
1730 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
1731 
1732 /* Free all controls and control refs */
v4l2_ctrl_handler_free(struct v4l2_ctrl_handler * hdl)1733 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1734 {
1735 	struct v4l2_ctrl_ref *ref, *next_ref;
1736 	struct v4l2_ctrl *ctrl, *next_ctrl;
1737 	struct v4l2_subscribed_event *sev, *next_sev;
1738 
1739 	if (hdl == NULL || hdl->buckets == NULL)
1740 		return;
1741 
1742 	mutex_lock(hdl->lock);
1743 	/* Free all nodes */
1744 	list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1745 		list_del(&ref->node);
1746 		kfree(ref);
1747 	}
1748 	/* Free all controls owned by the handler */
1749 	list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1750 		list_del(&ctrl->node);
1751 		list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1752 			list_del(&sev->node);
1753 		kfree(ctrl);
1754 	}
1755 	kfree(hdl->buckets);
1756 	hdl->buckets = NULL;
1757 	hdl->cached = NULL;
1758 	hdl->error = 0;
1759 	mutex_unlock(hdl->lock);
1760 }
1761 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1762 
1763 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1764    be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1765    with applications that do not use the NEXT_CTRL flag.
1766 
1767    We just find the n-th private user control. It's O(N), but that should not
1768    be an issue in this particular case. */
find_private_ref(struct v4l2_ctrl_handler * hdl,u32 id)1769 static struct v4l2_ctrl_ref *find_private_ref(
1770 		struct v4l2_ctrl_handler *hdl, u32 id)
1771 {
1772 	struct v4l2_ctrl_ref *ref;
1773 
1774 	id -= V4L2_CID_PRIVATE_BASE;
1775 	list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1776 		/* Search for private user controls that are compatible with
1777 		   VIDIOC_G/S_CTRL. */
1778 		if (V4L2_CTRL_ID2CLASS(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1779 		    V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1780 			if (!ref->ctrl->is_int)
1781 				continue;
1782 			if (id == 0)
1783 				return ref;
1784 			id--;
1785 		}
1786 	}
1787 	return NULL;
1788 }
1789 
1790 /* Find a control with the given ID. */
find_ref(struct v4l2_ctrl_handler * hdl,u32 id)1791 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1792 {
1793 	struct v4l2_ctrl_ref *ref;
1794 	int bucket;
1795 
1796 	id &= V4L2_CTRL_ID_MASK;
1797 
1798 	/* Old-style private controls need special handling */
1799 	if (id >= V4L2_CID_PRIVATE_BASE)
1800 		return find_private_ref(hdl, id);
1801 	bucket = id % hdl->nr_of_buckets;
1802 
1803 	/* Simple optimization: cache the last control found */
1804 	if (hdl->cached && hdl->cached->ctrl->id == id)
1805 		return hdl->cached;
1806 
1807 	/* Not in cache, search the hash */
1808 	ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1809 	while (ref && ref->ctrl->id != id)
1810 		ref = ref->next;
1811 
1812 	if (ref)
1813 		hdl->cached = ref; /* cache it! */
1814 	return ref;
1815 }
1816 
1817 /* Find a control with the given ID. Take the handler's lock first. */
find_ref_lock(struct v4l2_ctrl_handler * hdl,u32 id)1818 static struct v4l2_ctrl_ref *find_ref_lock(
1819 		struct v4l2_ctrl_handler *hdl, u32 id)
1820 {
1821 	struct v4l2_ctrl_ref *ref = NULL;
1822 
1823 	if (hdl) {
1824 		mutex_lock(hdl->lock);
1825 		ref = find_ref(hdl, id);
1826 		mutex_unlock(hdl->lock);
1827 	}
1828 	return ref;
1829 }
1830 
1831 /* Find a control with the given ID. */
v4l2_ctrl_find(struct v4l2_ctrl_handler * hdl,u32 id)1832 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1833 {
1834 	struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1835 
1836 	return ref ? ref->ctrl : NULL;
1837 }
1838 EXPORT_SYMBOL(v4l2_ctrl_find);
1839 
1840 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
handler_new_ref(struct v4l2_ctrl_handler * hdl,struct v4l2_ctrl * ctrl)1841 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1842 			   struct v4l2_ctrl *ctrl)
1843 {
1844 	struct v4l2_ctrl_ref *ref;
1845 	struct v4l2_ctrl_ref *new_ref;
1846 	u32 id = ctrl->id;
1847 	u32 class_ctrl = V4L2_CTRL_ID2CLASS(id) | 1;
1848 	int bucket = id % hdl->nr_of_buckets;	/* which bucket to use */
1849 
1850 	/*
1851 	 * Automatically add the control class if it is not yet present and
1852 	 * the new control is not a compound control.
1853 	 */
1854 	if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES &&
1855 	    id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1856 		if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1857 			return hdl->error;
1858 
1859 	if (hdl->error)
1860 		return hdl->error;
1861 
1862 	new_ref = kzalloc(sizeof(*new_ref), GFP_KERNEL);
1863 	if (!new_ref)
1864 		return handler_set_err(hdl, -ENOMEM);
1865 	new_ref->ctrl = ctrl;
1866 	if (ctrl->handler == hdl) {
1867 		/* By default each control starts in a cluster of its own.
1868 		   new_ref->ctrl is basically a cluster array with one
1869 		   element, so that's perfect to use as the cluster pointer.
1870 		   But only do this for the handler that owns the control. */
1871 		ctrl->cluster = &new_ref->ctrl;
1872 		ctrl->ncontrols = 1;
1873 	}
1874 
1875 	INIT_LIST_HEAD(&new_ref->node);
1876 
1877 	mutex_lock(hdl->lock);
1878 
1879 	/* Add immediately at the end of the list if the list is empty, or if
1880 	   the last element in the list has a lower ID.
1881 	   This ensures that when elements are added in ascending order the
1882 	   insertion is an O(1) operation. */
1883 	if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1884 		list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1885 		goto insert_in_hash;
1886 	}
1887 
1888 	/* Find insert position in sorted list */
1889 	list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1890 		if (ref->ctrl->id < id)
1891 			continue;
1892 		/* Don't add duplicates */
1893 		if (ref->ctrl->id == id) {
1894 			kfree(new_ref);
1895 			goto unlock;
1896 		}
1897 		list_add(&new_ref->node, ref->node.prev);
1898 		break;
1899 	}
1900 
1901 insert_in_hash:
1902 	/* Insert the control node in the hash */
1903 	new_ref->next = hdl->buckets[bucket];
1904 	hdl->buckets[bucket] = new_ref;
1905 
1906 unlock:
1907 	mutex_unlock(hdl->lock);
1908 	return 0;
1909 }
1910 
1911 /* Add a new control */
v4l2_ctrl_new(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,const struct v4l2_ctrl_type_ops * type_ops,u32 id,const char * name,enum v4l2_ctrl_type type,s64 min,s64 max,u64 step,s64 def,const u32 dims[V4L2_CTRL_MAX_DIMS],u32 elem_size,u32 flags,const char * const * qmenu,const s64 * qmenu_int,void * priv)1912 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1913 			const struct v4l2_ctrl_ops *ops,
1914 			const struct v4l2_ctrl_type_ops *type_ops,
1915 			u32 id, const char *name, enum v4l2_ctrl_type type,
1916 			s64 min, s64 max, u64 step, s64 def,
1917 			const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
1918 			u32 flags, const char * const *qmenu,
1919 			const s64 *qmenu_int, void *priv)
1920 {
1921 	struct v4l2_ctrl *ctrl;
1922 	unsigned sz_extra;
1923 	unsigned nr_of_dims = 0;
1924 	unsigned elems = 1;
1925 	bool is_array;
1926 	unsigned tot_ctrl_size;
1927 	unsigned idx;
1928 	void *data;
1929 	int err;
1930 
1931 	if (hdl->error)
1932 		return NULL;
1933 
1934 	while (dims && dims[nr_of_dims]) {
1935 		elems *= dims[nr_of_dims];
1936 		nr_of_dims++;
1937 		if (nr_of_dims == V4L2_CTRL_MAX_DIMS)
1938 			break;
1939 	}
1940 	is_array = nr_of_dims > 0;
1941 
1942 	/* Prefill elem_size for all types handled by std_type_ops */
1943 	switch (type) {
1944 	case V4L2_CTRL_TYPE_INTEGER64:
1945 		elem_size = sizeof(s64);
1946 		break;
1947 	case V4L2_CTRL_TYPE_STRING:
1948 		elem_size = max + 1;
1949 		break;
1950 	case V4L2_CTRL_TYPE_U8:
1951 		elem_size = sizeof(u8);
1952 		break;
1953 	case V4L2_CTRL_TYPE_U16:
1954 		elem_size = sizeof(u16);
1955 		break;
1956 	case V4L2_CTRL_TYPE_U32:
1957 		elem_size = sizeof(u32);
1958 		break;
1959 	default:
1960 		if (type < V4L2_CTRL_COMPOUND_TYPES)
1961 			elem_size = sizeof(s32);
1962 		break;
1963 	}
1964 	tot_ctrl_size = elem_size * elems;
1965 
1966 	/* Sanity checks */
1967 	if (id == 0 || name == NULL || !elem_size ||
1968 	    id >= V4L2_CID_PRIVATE_BASE ||
1969 	    (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1970 	    (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
1971 		handler_set_err(hdl, -ERANGE);
1972 		return NULL;
1973 	}
1974 	err = check_range(type, min, max, step, def);
1975 	if (err) {
1976 		handler_set_err(hdl, err);
1977 		return NULL;
1978 	}
1979 	if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
1980 		handler_set_err(hdl, -ERANGE);
1981 		return NULL;
1982 	}
1983 	if (is_array &&
1984 	    (type == V4L2_CTRL_TYPE_BUTTON ||
1985 	     type == V4L2_CTRL_TYPE_CTRL_CLASS)) {
1986 		handler_set_err(hdl, -EINVAL);
1987 		return NULL;
1988 	}
1989 
1990 	sz_extra = 0;
1991 	if (type == V4L2_CTRL_TYPE_BUTTON)
1992 		flags |= V4L2_CTRL_FLAG_WRITE_ONLY |
1993 			V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
1994 	else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1995 		flags |= V4L2_CTRL_FLAG_READ_ONLY;
1996 	else if (type == V4L2_CTRL_TYPE_INTEGER64 ||
1997 		 type == V4L2_CTRL_TYPE_STRING ||
1998 		 type >= V4L2_CTRL_COMPOUND_TYPES ||
1999 		 is_array)
2000 		sz_extra += 2 * tot_ctrl_size;
2001 
2002 	ctrl = kzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
2003 	if (ctrl == NULL) {
2004 		handler_set_err(hdl, -ENOMEM);
2005 		return NULL;
2006 	}
2007 
2008 	INIT_LIST_HEAD(&ctrl->node);
2009 	INIT_LIST_HEAD(&ctrl->ev_subs);
2010 	ctrl->handler = hdl;
2011 	ctrl->ops = ops;
2012 	ctrl->type_ops = type_ops ? type_ops : &std_type_ops;
2013 	ctrl->id = id;
2014 	ctrl->name = name;
2015 	ctrl->type = type;
2016 	ctrl->flags = flags;
2017 	ctrl->minimum = min;
2018 	ctrl->maximum = max;
2019 	ctrl->step = step;
2020 	ctrl->default_value = def;
2021 	ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING;
2022 	ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string;
2023 	ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64;
2024 	ctrl->is_array = is_array;
2025 	ctrl->elems = elems;
2026 	ctrl->nr_of_dims = nr_of_dims;
2027 	if (nr_of_dims)
2028 		memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0]));
2029 	ctrl->elem_size = elem_size;
2030 	if (type == V4L2_CTRL_TYPE_MENU)
2031 		ctrl->qmenu = qmenu;
2032 	else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2033 		ctrl->qmenu_int = qmenu_int;
2034 	ctrl->priv = priv;
2035 	ctrl->cur.val = ctrl->val = def;
2036 	data = &ctrl[1];
2037 
2038 	if (!ctrl->is_int) {
2039 		ctrl->p_new.p = data;
2040 		ctrl->p_cur.p = data + tot_ctrl_size;
2041 	} else {
2042 		ctrl->p_new.p = &ctrl->val;
2043 		ctrl->p_cur.p = &ctrl->cur.val;
2044 	}
2045 	for (idx = 0; idx < elems; idx++) {
2046 		ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
2047 		ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
2048 	}
2049 
2050 	if (handler_new_ref(hdl, ctrl)) {
2051 		kfree(ctrl);
2052 		return NULL;
2053 	}
2054 	mutex_lock(hdl->lock);
2055 	list_add_tail(&ctrl->node, &hdl->ctrls);
2056 	mutex_unlock(hdl->lock);
2057 	return ctrl;
2058 }
2059 
v4l2_ctrl_new_custom(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_config * cfg,void * priv)2060 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
2061 			const struct v4l2_ctrl_config *cfg, void *priv)
2062 {
2063 	bool is_menu;
2064 	struct v4l2_ctrl *ctrl;
2065 	const char *name = cfg->name;
2066 	const char * const *qmenu = cfg->qmenu;
2067 	const s64 *qmenu_int = cfg->qmenu_int;
2068 	enum v4l2_ctrl_type type = cfg->type;
2069 	u32 flags = cfg->flags;
2070 	s64 min = cfg->min;
2071 	s64 max = cfg->max;
2072 	u64 step = cfg->step;
2073 	s64 def = cfg->def;
2074 
2075 	if (name == NULL)
2076 		v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
2077 								&def, &flags);
2078 
2079 	is_menu = (cfg->type == V4L2_CTRL_TYPE_MENU ||
2080 		   cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU);
2081 	if (is_menu)
2082 		WARN_ON(step);
2083 	else
2084 		WARN_ON(cfg->menu_skip_mask);
2085 	if (cfg->type == V4L2_CTRL_TYPE_MENU && qmenu == NULL)
2086 		qmenu = v4l2_ctrl_get_menu(cfg->id);
2087 	else if (cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU &&
2088 		 qmenu_int == NULL) {
2089 		handler_set_err(hdl, -EINVAL);
2090 		return NULL;
2091 	}
2092 
2093 	ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name,
2094 			type, min, max,
2095 			is_menu ? cfg->menu_skip_mask : step, def,
2096 			cfg->dims, cfg->elem_size,
2097 			flags, qmenu, qmenu_int, priv);
2098 	if (ctrl)
2099 		ctrl->is_private = cfg->is_private;
2100 	return ctrl;
2101 }
2102 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
2103 
2104 /* Helper function for standard non-menu controls */
v4l2_ctrl_new_std(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,s64 min,s64 max,u64 step,s64 def)2105 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
2106 			const struct v4l2_ctrl_ops *ops,
2107 			u32 id, s64 min, s64 max, u64 step, s64 def)
2108 {
2109 	const char *name;
2110 	enum v4l2_ctrl_type type;
2111 	u32 flags;
2112 
2113 	v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2114 	if (type == V4L2_CTRL_TYPE_MENU ||
2115 	    type == V4L2_CTRL_TYPE_INTEGER_MENU ||
2116 	    type >= V4L2_CTRL_COMPOUND_TYPES) {
2117 		handler_set_err(hdl, -EINVAL);
2118 		return NULL;
2119 	}
2120 	return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2121 			     min, max, step, def, NULL, 0,
2122 			     flags, NULL, NULL, NULL);
2123 }
2124 EXPORT_SYMBOL(v4l2_ctrl_new_std);
2125 
2126 /* Helper function for standard menu controls */
v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,u8 _max,u64 mask,u8 _def)2127 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
2128 			const struct v4l2_ctrl_ops *ops,
2129 			u32 id, u8 _max, u64 mask, u8 _def)
2130 {
2131 	const char * const *qmenu = NULL;
2132 	const s64 *qmenu_int = NULL;
2133 	unsigned int qmenu_int_len = 0;
2134 	const char *name;
2135 	enum v4l2_ctrl_type type;
2136 	s64 min;
2137 	s64 max = _max;
2138 	s64 def = _def;
2139 	u64 step;
2140 	u32 flags;
2141 
2142 	v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2143 
2144 	if (type == V4L2_CTRL_TYPE_MENU)
2145 		qmenu = v4l2_ctrl_get_menu(id);
2146 	else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2147 		qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
2148 
2149 	if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
2150 		handler_set_err(hdl, -EINVAL);
2151 		return NULL;
2152 	}
2153 	return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2154 			     0, max, mask, def, NULL, 0,
2155 			     flags, qmenu, qmenu_int, NULL);
2156 }
2157 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
2158 
2159 /* Helper function for standard menu controls with driver defined menu */
v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,u8 _max,u64 mask,u8 _def,const char * const * qmenu)2160 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
2161 			const struct v4l2_ctrl_ops *ops, u32 id, u8 _max,
2162 			u64 mask, u8 _def, const char * const *qmenu)
2163 {
2164 	enum v4l2_ctrl_type type;
2165 	const char *name;
2166 	u32 flags;
2167 	u64 step;
2168 	s64 min;
2169 	s64 max = _max;
2170 	s64 def = _def;
2171 
2172 	/* v4l2_ctrl_new_std_menu_items() should only be called for
2173 	 * standard controls without a standard menu.
2174 	 */
2175 	if (v4l2_ctrl_get_menu(id)) {
2176 		handler_set_err(hdl, -EINVAL);
2177 		return NULL;
2178 	}
2179 
2180 	v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2181 	if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
2182 		handler_set_err(hdl, -EINVAL);
2183 		return NULL;
2184 	}
2185 	return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2186 			     0, max, mask, def, NULL, 0,
2187 			     flags, qmenu, NULL, NULL);
2188 
2189 }
2190 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
2191 
2192 /* Helper function for standard integer menu controls */
v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,u8 _max,u8 _def,const s64 * qmenu_int)2193 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
2194 			const struct v4l2_ctrl_ops *ops,
2195 			u32 id, u8 _max, u8 _def, const s64 *qmenu_int)
2196 {
2197 	const char *name;
2198 	enum v4l2_ctrl_type type;
2199 	s64 min;
2200 	u64 step;
2201 	s64 max = _max;
2202 	s64 def = _def;
2203 	u32 flags;
2204 
2205 	v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2206 	if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
2207 		handler_set_err(hdl, -EINVAL);
2208 		return NULL;
2209 	}
2210 	return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2211 			     0, max, 0, def, NULL, 0,
2212 			     flags, NULL, qmenu_int, NULL);
2213 }
2214 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
2215 
2216 /* Add a control from another handler to this handler */
v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_ctrl * ctrl)2217 struct v4l2_ctrl *v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler *hdl,
2218 					  struct v4l2_ctrl *ctrl)
2219 {
2220 	if (hdl == NULL || hdl->error)
2221 		return NULL;
2222 	if (ctrl == NULL) {
2223 		handler_set_err(hdl, -EINVAL);
2224 		return NULL;
2225 	}
2226 	if (ctrl->handler == hdl)
2227 		return ctrl;
2228 	return handler_new_ref(hdl, ctrl) ? NULL : ctrl;
2229 }
2230 EXPORT_SYMBOL(v4l2_ctrl_add_ctrl);
2231 
2232 /* Add the controls from another handler to our own. */
v4l2_ctrl_add_handler(struct v4l2_ctrl_handler * hdl,struct v4l2_ctrl_handler * add,bool (* filter)(const struct v4l2_ctrl * ctrl))2233 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
2234 			  struct v4l2_ctrl_handler *add,
2235 			  bool (*filter)(const struct v4l2_ctrl *ctrl))
2236 {
2237 	struct v4l2_ctrl_ref *ref;
2238 	int ret = 0;
2239 
2240 	/* Do nothing if either handler is NULL or if they are the same */
2241 	if (!hdl || !add || hdl == add)
2242 		return 0;
2243 	if (hdl->error)
2244 		return hdl->error;
2245 	mutex_lock(add->lock);
2246 	list_for_each_entry(ref, &add->ctrl_refs, node) {
2247 		struct v4l2_ctrl *ctrl = ref->ctrl;
2248 
2249 		/* Skip handler-private controls. */
2250 		if (ctrl->is_private)
2251 			continue;
2252 		/* And control classes */
2253 		if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2254 			continue;
2255 		/* Filter any unwanted controls */
2256 		if (filter && !filter(ctrl))
2257 			continue;
2258 		ret = handler_new_ref(hdl, ctrl);
2259 		if (ret)
2260 			break;
2261 	}
2262 	mutex_unlock(add->lock);
2263 	return ret;
2264 }
2265 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
2266 
v4l2_ctrl_radio_filter(const struct v4l2_ctrl * ctrl)2267 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
2268 {
2269 	if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
2270 		return true;
2271 	if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
2272 		return true;
2273 	switch (ctrl->id) {
2274 	case V4L2_CID_AUDIO_MUTE:
2275 	case V4L2_CID_AUDIO_VOLUME:
2276 	case V4L2_CID_AUDIO_BALANCE:
2277 	case V4L2_CID_AUDIO_BASS:
2278 	case V4L2_CID_AUDIO_TREBLE:
2279 	case V4L2_CID_AUDIO_LOUDNESS:
2280 		return true;
2281 	default:
2282 		break;
2283 	}
2284 	return false;
2285 }
2286 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
2287 
2288 /* Cluster controls */
v4l2_ctrl_cluster(unsigned ncontrols,struct v4l2_ctrl ** controls)2289 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
2290 {
2291 	bool has_volatiles = false;
2292 	int i;
2293 
2294 	/* The first control is the master control and it must not be NULL */
2295 	if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
2296 		return;
2297 
2298 	for (i = 0; i < ncontrols; i++) {
2299 		if (controls[i]) {
2300 			controls[i]->cluster = controls;
2301 			controls[i]->ncontrols = ncontrols;
2302 			if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
2303 				has_volatiles = true;
2304 		}
2305 	}
2306 	controls[0]->has_volatiles = has_volatiles;
2307 }
2308 EXPORT_SYMBOL(v4l2_ctrl_cluster);
2309 
v4l2_ctrl_auto_cluster(unsigned ncontrols,struct v4l2_ctrl ** controls,u8 manual_val,bool set_volatile)2310 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
2311 			    u8 manual_val, bool set_volatile)
2312 {
2313 	struct v4l2_ctrl *master = controls[0];
2314 	u32 flag = 0;
2315 	int i;
2316 
2317 	v4l2_ctrl_cluster(ncontrols, controls);
2318 	WARN_ON(ncontrols <= 1);
2319 	WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
2320 	WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
2321 	master->is_auto = true;
2322 	master->has_volatiles = set_volatile;
2323 	master->manual_mode_value = manual_val;
2324 	master->flags |= V4L2_CTRL_FLAG_UPDATE;
2325 
2326 	if (!is_cur_manual(master))
2327 		flag = V4L2_CTRL_FLAG_INACTIVE |
2328 			(set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
2329 
2330 	for (i = 1; i < ncontrols; i++)
2331 		if (controls[i])
2332 			controls[i]->flags |= flag;
2333 }
2334 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
2335 
2336 /* Activate/deactivate a control. */
v4l2_ctrl_activate(struct v4l2_ctrl * ctrl,bool active)2337 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
2338 {
2339 	/* invert since the actual flag is called 'inactive' */
2340 	bool inactive = !active;
2341 	bool old;
2342 
2343 	if (ctrl == NULL)
2344 		return;
2345 
2346 	if (inactive)
2347 		/* set V4L2_CTRL_FLAG_INACTIVE */
2348 		old = test_and_set_bit(4, &ctrl->flags);
2349 	else
2350 		/* clear V4L2_CTRL_FLAG_INACTIVE */
2351 		old = test_and_clear_bit(4, &ctrl->flags);
2352 	if (old != inactive)
2353 		send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2354 }
2355 EXPORT_SYMBOL(v4l2_ctrl_activate);
2356 
2357 /* Grab/ungrab a control.
2358    Typically used when streaming starts and you want to grab controls,
2359    preventing the user from changing them.
2360 
2361    Just call this and the framework will block any attempts to change
2362    these controls. */
v4l2_ctrl_grab(struct v4l2_ctrl * ctrl,bool grabbed)2363 void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
2364 {
2365 	bool old;
2366 
2367 	if (ctrl == NULL)
2368 		return;
2369 
2370 	v4l2_ctrl_lock(ctrl);
2371 	if (grabbed)
2372 		/* set V4L2_CTRL_FLAG_GRABBED */
2373 		old = test_and_set_bit(1, &ctrl->flags);
2374 	else
2375 		/* clear V4L2_CTRL_FLAG_GRABBED */
2376 		old = test_and_clear_bit(1, &ctrl->flags);
2377 	if (old != grabbed)
2378 		send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2379 	v4l2_ctrl_unlock(ctrl);
2380 }
2381 EXPORT_SYMBOL(v4l2_ctrl_grab);
2382 
2383 /* Log the control name and value */
log_ctrl(const struct v4l2_ctrl * ctrl,const char * prefix,const char * colon)2384 static void log_ctrl(const struct v4l2_ctrl *ctrl,
2385 		     const char *prefix, const char *colon)
2386 {
2387 	if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
2388 		return;
2389 	if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2390 		return;
2391 
2392 	pr_info("%s%s%s: ", prefix, colon, ctrl->name);
2393 
2394 	ctrl->type_ops->log(ctrl);
2395 
2396 	if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
2397 			   V4L2_CTRL_FLAG_GRABBED |
2398 			   V4L2_CTRL_FLAG_VOLATILE)) {
2399 		if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
2400 			pr_cont(" inactive");
2401 		if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
2402 			pr_cont(" grabbed");
2403 		if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
2404 			pr_cont(" volatile");
2405 	}
2406 	pr_cont("\n");
2407 }
2408 
2409 /* Log all controls owned by the handler */
v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler * hdl,const char * prefix)2410 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
2411 				  const char *prefix)
2412 {
2413 	struct v4l2_ctrl *ctrl;
2414 	const char *colon = "";
2415 	int len;
2416 
2417 	if (hdl == NULL)
2418 		return;
2419 	if (prefix == NULL)
2420 		prefix = "";
2421 	len = strlen(prefix);
2422 	if (len && prefix[len - 1] != ' ')
2423 		colon = ": ";
2424 	mutex_lock(hdl->lock);
2425 	list_for_each_entry(ctrl, &hdl->ctrls, node)
2426 		if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2427 			log_ctrl(ctrl, prefix, colon);
2428 	mutex_unlock(hdl->lock);
2429 }
2430 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2431 
v4l2_ctrl_subdev_log_status(struct v4l2_subdev * sd)2432 int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
2433 {
2434 	v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
2435 	return 0;
2436 }
2437 EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
2438 
2439 /* Call s_ctrl for all controls owned by the handler */
v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler * hdl)2440 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2441 {
2442 	struct v4l2_ctrl *ctrl;
2443 	int ret = 0;
2444 
2445 	if (hdl == NULL)
2446 		return 0;
2447 	mutex_lock(hdl->lock);
2448 	list_for_each_entry(ctrl, &hdl->ctrls, node)
2449 		ctrl->done = false;
2450 
2451 	list_for_each_entry(ctrl, &hdl->ctrls, node) {
2452 		struct v4l2_ctrl *master = ctrl->cluster[0];
2453 		int i;
2454 
2455 		/* Skip if this control was already handled by a cluster. */
2456 		/* Skip button controls and read-only controls. */
2457 		if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2458 		    (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2459 			continue;
2460 
2461 		for (i = 0; i < master->ncontrols; i++) {
2462 			if (master->cluster[i]) {
2463 				cur_to_new(master->cluster[i]);
2464 				master->cluster[i]->is_new = 1;
2465 				master->cluster[i]->done = true;
2466 			}
2467 		}
2468 		ret = call_op(master, s_ctrl);
2469 		if (ret)
2470 			break;
2471 	}
2472 	mutex_unlock(hdl->lock);
2473 	return ret;
2474 }
2475 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2476 
2477 /* Implement VIDIOC_QUERY_EXT_CTRL */
v4l2_query_ext_ctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_query_ext_ctrl * qc)2478 int v4l2_query_ext_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_query_ext_ctrl *qc)
2479 {
2480 	const unsigned next_flags = V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND;
2481 	u32 id = qc->id & V4L2_CTRL_ID_MASK;
2482 	struct v4l2_ctrl_ref *ref;
2483 	struct v4l2_ctrl *ctrl;
2484 
2485 	if (hdl == NULL)
2486 		return -EINVAL;
2487 
2488 	mutex_lock(hdl->lock);
2489 
2490 	/* Try to find it */
2491 	ref = find_ref(hdl, id);
2492 
2493 	if ((qc->id & next_flags) && !list_empty(&hdl->ctrl_refs)) {
2494 		bool is_compound;
2495 		/* Match any control that is not hidden */
2496 		unsigned mask = 1;
2497 		bool match = false;
2498 
2499 		if ((qc->id & next_flags) == V4L2_CTRL_FLAG_NEXT_COMPOUND) {
2500 			/* Match any hidden control */
2501 			match = true;
2502 		} else if ((qc->id & next_flags) == next_flags) {
2503 			/* Match any control, compound or not */
2504 			mask = 0;
2505 		}
2506 
2507 		/* Find the next control with ID > qc->id */
2508 
2509 		/* Did we reach the end of the control list? */
2510 		if (id >= node2id(hdl->ctrl_refs.prev)) {
2511 			ref = NULL; /* Yes, so there is no next control */
2512 		} else if (ref) {
2513 			/* We found a control with the given ID, so just get
2514 			   the next valid one in the list. */
2515 			list_for_each_entry_continue(ref, &hdl->ctrl_refs, node) {
2516 				is_compound =
2517 					ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
2518 				if (id < ref->ctrl->id &&
2519 				    (is_compound & mask) == match)
2520 					break;
2521 			}
2522 			if (&ref->node == &hdl->ctrl_refs)
2523 				ref = NULL;
2524 		} else {
2525 			/* No control with the given ID exists, so start
2526 			   searching for the next largest ID. We know there
2527 			   is one, otherwise the first 'if' above would have
2528 			   been true. */
2529 			list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2530 				is_compound =
2531 					ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
2532 				if (id < ref->ctrl->id &&
2533 				    (is_compound & mask) == match)
2534 					break;
2535 			}
2536 			if (&ref->node == &hdl->ctrl_refs)
2537 				ref = NULL;
2538 		}
2539 	}
2540 	mutex_unlock(hdl->lock);
2541 
2542 	if (!ref)
2543 		return -EINVAL;
2544 
2545 	ctrl = ref->ctrl;
2546 	memset(qc, 0, sizeof(*qc));
2547 	if (id >= V4L2_CID_PRIVATE_BASE)
2548 		qc->id = id;
2549 	else
2550 		qc->id = ctrl->id;
2551 	strlcpy(qc->name, ctrl->name, sizeof(qc->name));
2552 	qc->flags = ctrl->flags;
2553 	qc->type = ctrl->type;
2554 	if (ctrl->is_ptr)
2555 		qc->flags |= V4L2_CTRL_FLAG_HAS_PAYLOAD;
2556 	qc->elem_size = ctrl->elem_size;
2557 	qc->elems = ctrl->elems;
2558 	qc->nr_of_dims = ctrl->nr_of_dims;
2559 	memcpy(qc->dims, ctrl->dims, qc->nr_of_dims * sizeof(qc->dims[0]));
2560 	qc->minimum = ctrl->minimum;
2561 	qc->maximum = ctrl->maximum;
2562 	qc->default_value = ctrl->default_value;
2563 	if (ctrl->type == V4L2_CTRL_TYPE_MENU
2564 	    || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
2565 		qc->step = 1;
2566 	else
2567 		qc->step = ctrl->step;
2568 	return 0;
2569 }
2570 EXPORT_SYMBOL(v4l2_query_ext_ctrl);
2571 
2572 /* Implement VIDIOC_QUERYCTRL */
v4l2_queryctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_queryctrl * qc)2573 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
2574 {
2575 	struct v4l2_query_ext_ctrl qec = { qc->id };
2576 	int rc;
2577 
2578 	rc = v4l2_query_ext_ctrl(hdl, &qec);
2579 	if (rc)
2580 		return rc;
2581 
2582 	qc->id = qec.id;
2583 	qc->type = qec.type;
2584 	qc->flags = qec.flags;
2585 	strlcpy(qc->name, qec.name, sizeof(qc->name));
2586 	switch (qc->type) {
2587 	case V4L2_CTRL_TYPE_INTEGER:
2588 	case V4L2_CTRL_TYPE_BOOLEAN:
2589 	case V4L2_CTRL_TYPE_MENU:
2590 	case V4L2_CTRL_TYPE_INTEGER_MENU:
2591 	case V4L2_CTRL_TYPE_STRING:
2592 	case V4L2_CTRL_TYPE_BITMASK:
2593 		qc->minimum = qec.minimum;
2594 		qc->maximum = qec.maximum;
2595 		qc->step = qec.step;
2596 		qc->default_value = qec.default_value;
2597 		break;
2598 	default:
2599 		qc->minimum = 0;
2600 		qc->maximum = 0;
2601 		qc->step = 0;
2602 		qc->default_value = 0;
2603 		break;
2604 	}
2605 	return 0;
2606 }
2607 EXPORT_SYMBOL(v4l2_queryctrl);
2608 
v4l2_subdev_queryctrl(struct v4l2_subdev * sd,struct v4l2_queryctrl * qc)2609 int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
2610 {
2611 	if (qc->id & (V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND))
2612 		return -EINVAL;
2613 	return v4l2_queryctrl(sd->ctrl_handler, qc);
2614 }
2615 EXPORT_SYMBOL(v4l2_subdev_queryctrl);
2616 
2617 /* Implement VIDIOC_QUERYMENU */
v4l2_querymenu(struct v4l2_ctrl_handler * hdl,struct v4l2_querymenu * qm)2618 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
2619 {
2620 	struct v4l2_ctrl *ctrl;
2621 	u32 i = qm->index;
2622 
2623 	ctrl = v4l2_ctrl_find(hdl, qm->id);
2624 	if (!ctrl)
2625 		return -EINVAL;
2626 
2627 	qm->reserved = 0;
2628 	/* Sanity checks */
2629 	switch (ctrl->type) {
2630 	case V4L2_CTRL_TYPE_MENU:
2631 		if (ctrl->qmenu == NULL)
2632 			return -EINVAL;
2633 		break;
2634 	case V4L2_CTRL_TYPE_INTEGER_MENU:
2635 		if (ctrl->qmenu_int == NULL)
2636 			return -EINVAL;
2637 		break;
2638 	default:
2639 		return -EINVAL;
2640 	}
2641 
2642 	if (i < ctrl->minimum || i > ctrl->maximum)
2643 		return -EINVAL;
2644 
2645 	/* Use mask to see if this menu item should be skipped */
2646 	if (ctrl->menu_skip_mask & (1 << i))
2647 		return -EINVAL;
2648 	/* Empty menu items should also be skipped */
2649 	if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
2650 		if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
2651 			return -EINVAL;
2652 		strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
2653 	} else {
2654 		qm->value = ctrl->qmenu_int[i];
2655 	}
2656 	return 0;
2657 }
2658 EXPORT_SYMBOL(v4l2_querymenu);
2659 
v4l2_subdev_querymenu(struct v4l2_subdev * sd,struct v4l2_querymenu * qm)2660 int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
2661 {
2662 	return v4l2_querymenu(sd->ctrl_handler, qm);
2663 }
2664 EXPORT_SYMBOL(v4l2_subdev_querymenu);
2665 
2666 
2667 
2668 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
2669 
2670    It is not a fully atomic operation, just best-effort only. After all, if
2671    multiple controls have to be set through multiple i2c writes (for example)
2672    then some initial writes may succeed while others fail. Thus leaving the
2673    system in an inconsistent state. The question is how much effort you are
2674    willing to spend on trying to make something atomic that really isn't.
2675 
2676    From the point of view of an application the main requirement is that
2677    when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
2678    error should be returned without actually affecting any controls.
2679 
2680    If all the values are correct, then it is acceptable to just give up
2681    in case of low-level errors.
2682 
2683    It is important though that the application can tell when only a partial
2684    configuration was done. The way we do that is through the error_idx field
2685    of struct v4l2_ext_controls: if that is equal to the count field then no
2686    controls were affected. Otherwise all controls before that index were
2687    successful in performing their 'get' or 'set' operation, the control at
2688    the given index failed, and you don't know what happened with the controls
2689    after the failed one. Since if they were part of a control cluster they
2690    could have been successfully processed (if a cluster member was encountered
2691    at index < error_idx), they could have failed (if a cluster member was at
2692    error_idx), or they may not have been processed yet (if the first cluster
2693    member appeared after error_idx).
2694 
2695    It is all fairly theoretical, though. In practice all you can do is to
2696    bail out. If error_idx == count, then it is an application bug. If
2697    error_idx < count then it is only an application bug if the error code was
2698    EBUSY. That usually means that something started streaming just when you
2699    tried to set the controls. In all other cases it is a driver/hardware
2700    problem and all you can do is to retry or bail out.
2701 
2702    Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
2703    never modifies controls the error_idx is just set to whatever control
2704    has an invalid value.
2705  */
2706 
2707 /* Prepare for the extended g/s/try functions.
2708    Find the controls in the control array and do some basic checks. */
prepare_ext_ctrls(struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs,struct v4l2_ctrl_helper * helpers,bool get)2709 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
2710 			     struct v4l2_ext_controls *cs,
2711 			     struct v4l2_ctrl_helper *helpers,
2712 			     bool get)
2713 {
2714 	struct v4l2_ctrl_helper *h;
2715 	bool have_clusters = false;
2716 	u32 i;
2717 
2718 	for (i = 0, h = helpers; i < cs->count; i++, h++) {
2719 		struct v4l2_ext_control *c = &cs->controls[i];
2720 		struct v4l2_ctrl_ref *ref;
2721 		struct v4l2_ctrl *ctrl;
2722 		u32 id = c->id & V4L2_CTRL_ID_MASK;
2723 
2724 		cs->error_idx = i;
2725 
2726 		if (cs->ctrl_class && V4L2_CTRL_ID2CLASS(id) != cs->ctrl_class)
2727 			return -EINVAL;
2728 
2729 		/* Old-style private controls are not allowed for
2730 		   extended controls */
2731 		if (id >= V4L2_CID_PRIVATE_BASE)
2732 			return -EINVAL;
2733 		ref = find_ref_lock(hdl, id);
2734 		if (ref == NULL)
2735 			return -EINVAL;
2736 		ctrl = ref->ctrl;
2737 		if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
2738 			return -EINVAL;
2739 
2740 		if (ctrl->cluster[0]->ncontrols > 1)
2741 			have_clusters = true;
2742 		if (ctrl->cluster[0] != ctrl)
2743 			ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
2744 		if (ctrl->is_ptr && !ctrl->is_string) {
2745 			unsigned tot_size = ctrl->elems * ctrl->elem_size;
2746 
2747 			if (c->size < tot_size) {
2748 				if (get) {
2749 					c->size = tot_size;
2750 					return -ENOSPC;
2751 				}
2752 				return -EFAULT;
2753 			}
2754 			c->size = tot_size;
2755 		}
2756 		/* Store the ref to the master control of the cluster */
2757 		h->mref = ref;
2758 		h->ctrl = ctrl;
2759 		/* Initially set next to 0, meaning that there is no other
2760 		   control in this helper array belonging to the same
2761 		   cluster */
2762 		h->next = 0;
2763 	}
2764 
2765 	/* We are done if there were no controls that belong to a multi-
2766 	   control cluster. */
2767 	if (!have_clusters)
2768 		return 0;
2769 
2770 	/* The code below figures out in O(n) time which controls in the list
2771 	   belong to the same cluster. */
2772 
2773 	/* This has to be done with the handler lock taken. */
2774 	mutex_lock(hdl->lock);
2775 
2776 	/* First zero the helper field in the master control references */
2777 	for (i = 0; i < cs->count; i++)
2778 		helpers[i].mref->helper = NULL;
2779 	for (i = 0, h = helpers; i < cs->count; i++, h++) {
2780 		struct v4l2_ctrl_ref *mref = h->mref;
2781 
2782 		/* If the mref->helper is set, then it points to an earlier
2783 		   helper that belongs to the same cluster. */
2784 		if (mref->helper) {
2785 			/* Set the next field of mref->helper to the current
2786 			   index: this means that that earlier helper now
2787 			   points to the next helper in the same cluster. */
2788 			mref->helper->next = i;
2789 			/* mref should be set only for the first helper in the
2790 			   cluster, clear the others. */
2791 			h->mref = NULL;
2792 		}
2793 		/* Point the mref helper to the current helper struct. */
2794 		mref->helper = h;
2795 	}
2796 	mutex_unlock(hdl->lock);
2797 	return 0;
2798 }
2799 
2800 /* Handles the corner case where cs->count == 0. It checks whether the
2801    specified control class exists. If that class ID is 0, then it checks
2802    whether there are any controls at all. */
class_check(struct v4l2_ctrl_handler * hdl,u32 ctrl_class)2803 static int class_check(struct v4l2_ctrl_handler *hdl, u32 ctrl_class)
2804 {
2805 	if (ctrl_class == 0)
2806 		return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
2807 	return find_ref_lock(hdl, ctrl_class | 1) ? 0 : -EINVAL;
2808 }
2809 
2810 
2811 
2812 /* Get extended controls. Allocates the helpers array if needed. */
v4l2_g_ext_ctrls(struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs)2813 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2814 {
2815 	struct v4l2_ctrl_helper helper[4];
2816 	struct v4l2_ctrl_helper *helpers = helper;
2817 	int ret;
2818 	int i, j;
2819 
2820 	cs->error_idx = cs->count;
2821 	cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2822 
2823 	if (hdl == NULL)
2824 		return -EINVAL;
2825 
2826 	if (cs->count == 0)
2827 		return class_check(hdl, cs->ctrl_class);
2828 
2829 	if (cs->count > ARRAY_SIZE(helper)) {
2830 		helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2831 					GFP_KERNEL);
2832 		if (helpers == NULL)
2833 			return -ENOMEM;
2834 	}
2835 
2836 	ret = prepare_ext_ctrls(hdl, cs, helpers, true);
2837 	cs->error_idx = cs->count;
2838 
2839 	for (i = 0; !ret && i < cs->count; i++)
2840 		if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2841 			ret = -EACCES;
2842 
2843 	for (i = 0; !ret && i < cs->count; i++) {
2844 		int (*ctrl_to_user)(struct v4l2_ext_control *c,
2845 				    struct v4l2_ctrl *ctrl) = cur_to_user;
2846 		struct v4l2_ctrl *master;
2847 
2848 		if (helpers[i].mref == NULL)
2849 			continue;
2850 
2851 		master = helpers[i].mref->ctrl;
2852 		cs->error_idx = i;
2853 
2854 		v4l2_ctrl_lock(master);
2855 
2856 		/* g_volatile_ctrl will update the new control values */
2857 		if ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
2858 			(master->has_volatiles && !is_cur_manual(master))) {
2859 			for (j = 0; j < master->ncontrols; j++)
2860 				cur_to_new(master->cluster[j]);
2861 			ret = call_op(master, g_volatile_ctrl);
2862 			ctrl_to_user = new_to_user;
2863 		}
2864 		/* If OK, then copy the current (for non-volatile controls)
2865 		   or the new (for volatile controls) control values to the
2866 		   caller */
2867 		if (!ret) {
2868 			u32 idx = i;
2869 
2870 			do {
2871 				ret = ctrl_to_user(cs->controls + idx,
2872 						   helpers[idx].ctrl);
2873 				idx = helpers[idx].next;
2874 			} while (!ret && idx);
2875 		}
2876 		v4l2_ctrl_unlock(master);
2877 	}
2878 
2879 	if (cs->count > ARRAY_SIZE(helper))
2880 		kfree(helpers);
2881 	return ret;
2882 }
2883 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
2884 
v4l2_subdev_g_ext_ctrls(struct v4l2_subdev * sd,struct v4l2_ext_controls * cs)2885 int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2886 {
2887 	return v4l2_g_ext_ctrls(sd->ctrl_handler, cs);
2888 }
2889 EXPORT_SYMBOL(v4l2_subdev_g_ext_ctrls);
2890 
2891 /* Helper function to get a single control */
get_ctrl(struct v4l2_ctrl * ctrl,struct v4l2_ext_control * c)2892 static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
2893 {
2894 	struct v4l2_ctrl *master = ctrl->cluster[0];
2895 	int ret = 0;
2896 	int i;
2897 
2898 	/* Compound controls are not supported. The new_to_user() and
2899 	 * cur_to_user() calls below would need to be modified not to access
2900 	 * userspace memory when called from get_ctrl().
2901 	 */
2902 	if (!ctrl->is_int)
2903 		return -EINVAL;
2904 
2905 	if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2906 		return -EACCES;
2907 
2908 	v4l2_ctrl_lock(master);
2909 	/* g_volatile_ctrl will update the current control values */
2910 	if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2911 		for (i = 0; i < master->ncontrols; i++)
2912 			cur_to_new(master->cluster[i]);
2913 		ret = call_op(master, g_volatile_ctrl);
2914 		new_to_user(c, ctrl);
2915 	} else {
2916 		cur_to_user(c, ctrl);
2917 	}
2918 	v4l2_ctrl_unlock(master);
2919 	return ret;
2920 }
2921 
v4l2_g_ctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_control * control)2922 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
2923 {
2924 	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2925 	struct v4l2_ext_control c;
2926 	int ret;
2927 
2928 	if (ctrl == NULL || !ctrl->is_int)
2929 		return -EINVAL;
2930 	ret = get_ctrl(ctrl, &c);
2931 	control->value = c.value;
2932 	return ret;
2933 }
2934 EXPORT_SYMBOL(v4l2_g_ctrl);
2935 
v4l2_subdev_g_ctrl(struct v4l2_subdev * sd,struct v4l2_control * control)2936 int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2937 {
2938 	return v4l2_g_ctrl(sd->ctrl_handler, control);
2939 }
2940 EXPORT_SYMBOL(v4l2_subdev_g_ctrl);
2941 
v4l2_ctrl_g_ctrl(struct v4l2_ctrl * ctrl)2942 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
2943 {
2944 	struct v4l2_ext_control c;
2945 
2946 	/* It's a driver bug if this happens. */
2947 	WARN_ON(!ctrl->is_int);
2948 	c.value = 0;
2949 	get_ctrl(ctrl, &c);
2950 	return c.value;
2951 }
2952 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
2953 
v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl * ctrl)2954 s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
2955 {
2956 	struct v4l2_ext_control c;
2957 
2958 	/* It's a driver bug if this happens. */
2959 	WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2960 	c.value = 0;
2961 	get_ctrl(ctrl, &c);
2962 	return c.value;
2963 }
2964 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
2965 
2966 
2967 /* Core function that calls try/s_ctrl and ensures that the new value is
2968    copied to the current value on a set.
2969    Must be called with ctrl->handler->lock held. */
try_or_set_cluster(struct v4l2_fh * fh,struct v4l2_ctrl * master,bool set,u32 ch_flags)2970 static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
2971 			      bool set, u32 ch_flags)
2972 {
2973 	bool update_flag;
2974 	int ret;
2975 	int i;
2976 
2977 	/* Go through the cluster and either validate the new value or
2978 	   (if no new value was set), copy the current value to the new
2979 	   value, ensuring a consistent view for the control ops when
2980 	   called. */
2981 	for (i = 0; i < master->ncontrols; i++) {
2982 		struct v4l2_ctrl *ctrl = master->cluster[i];
2983 
2984 		if (ctrl == NULL)
2985 			continue;
2986 
2987 		if (!ctrl->is_new) {
2988 			cur_to_new(ctrl);
2989 			continue;
2990 		}
2991 		/* Check again: it may have changed since the
2992 		   previous check in try_or_set_ext_ctrls(). */
2993 		if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2994 			return -EBUSY;
2995 	}
2996 
2997 	ret = call_op(master, try_ctrl);
2998 
2999 	/* Don't set if there is no change */
3000 	if (ret || !set || !cluster_changed(master))
3001 		return ret;
3002 	ret = call_op(master, s_ctrl);
3003 	if (ret)
3004 		return ret;
3005 
3006 	/* If OK, then make the new values permanent. */
3007 	update_flag = is_cur_manual(master) != is_new_manual(master);
3008 	for (i = 0; i < master->ncontrols; i++)
3009 		new_to_cur(fh, master->cluster[i], ch_flags |
3010 			((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
3011 	return 0;
3012 }
3013 
3014 /* Validate controls. */
validate_ctrls(struct v4l2_ext_controls * cs,struct v4l2_ctrl_helper * helpers,bool set)3015 static int validate_ctrls(struct v4l2_ext_controls *cs,
3016 			  struct v4l2_ctrl_helper *helpers, bool set)
3017 {
3018 	unsigned i;
3019 	int ret = 0;
3020 
3021 	cs->error_idx = cs->count;
3022 	for (i = 0; i < cs->count; i++) {
3023 		struct v4l2_ctrl *ctrl = helpers[i].ctrl;
3024 		union v4l2_ctrl_ptr p_new;
3025 
3026 		cs->error_idx = i;
3027 
3028 		if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
3029 			return -EACCES;
3030 		/* This test is also done in try_set_control_cluster() which
3031 		   is called in atomic context, so that has the final say,
3032 		   but it makes sense to do an up-front check as well. Once
3033 		   an error occurs in try_set_control_cluster() some other
3034 		   controls may have been set already and we want to do a
3035 		   best-effort to avoid that. */
3036 		if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
3037 			return -EBUSY;
3038 		/*
3039 		 * Skip validation for now if the payload needs to be copied
3040 		 * from userspace into kernelspace. We'll validate those later.
3041 		 */
3042 		if (ctrl->is_ptr)
3043 			continue;
3044 		if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
3045 			p_new.p_s64 = &cs->controls[i].value64;
3046 		else
3047 			p_new.p_s32 = &cs->controls[i].value;
3048 		ret = validate_new(ctrl, p_new);
3049 		if (ret)
3050 			return ret;
3051 	}
3052 	return 0;
3053 }
3054 
3055 /* Obtain the current volatile values of an autocluster and mark them
3056    as new. */
update_from_auto_cluster(struct v4l2_ctrl * master)3057 static void update_from_auto_cluster(struct v4l2_ctrl *master)
3058 {
3059 	int i;
3060 
3061 	for (i = 0; i < master->ncontrols; i++)
3062 		cur_to_new(master->cluster[i]);
3063 	if (!call_op(master, g_volatile_ctrl))
3064 		for (i = 1; i < master->ncontrols; i++)
3065 			if (master->cluster[i])
3066 				master->cluster[i]->is_new = 1;
3067 }
3068 
3069 /* Try or try-and-set controls */
try_set_ext_ctrls(struct v4l2_fh * fh,struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs,bool set)3070 static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3071 			     struct v4l2_ext_controls *cs,
3072 			     bool set)
3073 {
3074 	struct v4l2_ctrl_helper helper[4];
3075 	struct v4l2_ctrl_helper *helpers = helper;
3076 	unsigned i, j;
3077 	int ret;
3078 
3079 	cs->error_idx = cs->count;
3080 	cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
3081 
3082 	if (hdl == NULL)
3083 		return -EINVAL;
3084 
3085 	if (cs->count == 0)
3086 		return class_check(hdl, cs->ctrl_class);
3087 
3088 	if (cs->count > ARRAY_SIZE(helper)) {
3089 		helpers = kmalloc_array(cs->count, sizeof(helper[0]),
3090 					GFP_KERNEL);
3091 		if (!helpers)
3092 			return -ENOMEM;
3093 	}
3094 	ret = prepare_ext_ctrls(hdl, cs, helpers, false);
3095 	if (!ret)
3096 		ret = validate_ctrls(cs, helpers, set);
3097 	if (ret && set)
3098 		cs->error_idx = cs->count;
3099 	for (i = 0; !ret && i < cs->count; i++) {
3100 		struct v4l2_ctrl *master;
3101 		u32 idx = i;
3102 
3103 		if (helpers[i].mref == NULL)
3104 			continue;
3105 
3106 		cs->error_idx = i;
3107 		master = helpers[i].mref->ctrl;
3108 		v4l2_ctrl_lock(master);
3109 
3110 		/* Reset the 'is_new' flags of the cluster */
3111 		for (j = 0; j < master->ncontrols; j++)
3112 			if (master->cluster[j])
3113 				master->cluster[j]->is_new = 0;
3114 
3115 		/* For volatile autoclusters that are currently in auto mode
3116 		   we need to discover if it will be set to manual mode.
3117 		   If so, then we have to copy the current volatile values
3118 		   first since those will become the new manual values (which
3119 		   may be overwritten by explicit new values from this set
3120 		   of controls). */
3121 		if (master->is_auto && master->has_volatiles &&
3122 						!is_cur_manual(master)) {
3123 			/* Pick an initial non-manual value */
3124 			s32 new_auto_val = master->manual_mode_value + 1;
3125 			u32 tmp_idx = idx;
3126 
3127 			do {
3128 				/* Check if the auto control is part of the
3129 				   list, and remember the new value. */
3130 				if (helpers[tmp_idx].ctrl == master)
3131 					new_auto_val = cs->controls[tmp_idx].value;
3132 				tmp_idx = helpers[tmp_idx].next;
3133 			} while (tmp_idx);
3134 			/* If the new value == the manual value, then copy
3135 			   the current volatile values. */
3136 			if (new_auto_val == master->manual_mode_value)
3137 				update_from_auto_cluster(master);
3138 		}
3139 
3140 		/* Copy the new caller-supplied control values.
3141 		   user_to_new() sets 'is_new' to 1. */
3142 		do {
3143 			struct v4l2_ctrl *ctrl = helpers[idx].ctrl;
3144 
3145 			ret = user_to_new(cs->controls + idx, ctrl);
3146 			if (!ret && ctrl->is_ptr)
3147 				ret = validate_new(ctrl, ctrl->p_new);
3148 			idx = helpers[idx].next;
3149 		} while (!ret && idx);
3150 
3151 		if (!ret)
3152 			ret = try_or_set_cluster(fh, master, set, 0);
3153 
3154 		/* Copy the new values back to userspace. */
3155 		if (!ret) {
3156 			idx = i;
3157 			do {
3158 				ret = new_to_user(cs->controls + idx,
3159 						helpers[idx].ctrl);
3160 				idx = helpers[idx].next;
3161 			} while (!ret && idx);
3162 		}
3163 		v4l2_ctrl_unlock(master);
3164 	}
3165 
3166 	if (cs->count > ARRAY_SIZE(helper))
3167 		kfree(helpers);
3168 	return ret;
3169 }
3170 
v4l2_try_ext_ctrls(struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs)3171 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
3172 {
3173 	return try_set_ext_ctrls(NULL, hdl, cs, false);
3174 }
3175 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
3176 
v4l2_s_ext_ctrls(struct v4l2_fh * fh,struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs)3177 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3178 					struct v4l2_ext_controls *cs)
3179 {
3180 	return try_set_ext_ctrls(fh, hdl, cs, true);
3181 }
3182 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
3183 
v4l2_subdev_try_ext_ctrls(struct v4l2_subdev * sd,struct v4l2_ext_controls * cs)3184 int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
3185 {
3186 	return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, false);
3187 }
3188 EXPORT_SYMBOL(v4l2_subdev_try_ext_ctrls);
3189 
v4l2_subdev_s_ext_ctrls(struct v4l2_subdev * sd,struct v4l2_ext_controls * cs)3190 int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
3191 {
3192 	return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, true);
3193 }
3194 EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
3195 
3196 /* Helper function for VIDIOC_S_CTRL compatibility */
set_ctrl(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,u32 ch_flags)3197 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
3198 {
3199 	struct v4l2_ctrl *master = ctrl->cluster[0];
3200 	int ret;
3201 	int i;
3202 
3203 	/* Reset the 'is_new' flags of the cluster */
3204 	for (i = 0; i < master->ncontrols; i++)
3205 		if (master->cluster[i])
3206 			master->cluster[i]->is_new = 0;
3207 
3208 	ret = validate_new(ctrl, ctrl->p_new);
3209 	if (ret)
3210 		return ret;
3211 
3212 	/* For autoclusters with volatiles that are switched from auto to
3213 	   manual mode we have to update the current volatile values since
3214 	   those will become the initial manual values after such a switch. */
3215 	if (master->is_auto && master->has_volatiles && ctrl == master &&
3216 	    !is_cur_manual(master) && ctrl->val == master->manual_mode_value)
3217 		update_from_auto_cluster(master);
3218 
3219 	ctrl->is_new = 1;
3220 	return try_or_set_cluster(fh, master, true, ch_flags);
3221 }
3222 
3223 /* Helper function for VIDIOC_S_CTRL compatibility */
set_ctrl_lock(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,struct v4l2_ext_control * c)3224 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
3225 			 struct v4l2_ext_control *c)
3226 {
3227 	int ret;
3228 
3229 	v4l2_ctrl_lock(ctrl);
3230 	user_to_new(c, ctrl);
3231 	ret = set_ctrl(fh, ctrl, 0);
3232 	if (!ret)
3233 		cur_to_user(c, ctrl);
3234 	v4l2_ctrl_unlock(ctrl);
3235 	return ret;
3236 }
3237 
v4l2_s_ctrl(struct v4l2_fh * fh,struct v4l2_ctrl_handler * hdl,struct v4l2_control * control)3238 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3239 					struct v4l2_control *control)
3240 {
3241 	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
3242 	struct v4l2_ext_control c = { control->id };
3243 	int ret;
3244 
3245 	if (ctrl == NULL || !ctrl->is_int)
3246 		return -EINVAL;
3247 
3248 	if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
3249 		return -EACCES;
3250 
3251 	c.value = control->value;
3252 	ret = set_ctrl_lock(fh, ctrl, &c);
3253 	control->value = c.value;
3254 	return ret;
3255 }
3256 EXPORT_SYMBOL(v4l2_s_ctrl);
3257 
v4l2_subdev_s_ctrl(struct v4l2_subdev * sd,struct v4l2_control * control)3258 int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
3259 {
3260 	return v4l2_s_ctrl(NULL, sd->ctrl_handler, control);
3261 }
3262 EXPORT_SYMBOL(v4l2_subdev_s_ctrl);
3263 
__v4l2_ctrl_s_ctrl(struct v4l2_ctrl * ctrl,s32 val)3264 int __v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
3265 {
3266 	lockdep_assert_held(ctrl->handler->lock);
3267 
3268 	/* It's a driver bug if this happens. */
3269 	WARN_ON(!ctrl->is_int);
3270 	ctrl->val = val;
3271 	return set_ctrl(NULL, ctrl, 0);
3272 }
3273 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl);
3274 
__v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl * ctrl,s64 val)3275 int __v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
3276 {
3277 	lockdep_assert_held(ctrl->handler->lock);
3278 
3279 	/* It's a driver bug if this happens. */
3280 	WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
3281 	*ctrl->p_new.p_s64 = val;
3282 	return set_ctrl(NULL, ctrl, 0);
3283 }
3284 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_int64);
3285 
__v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl * ctrl,const char * s)3286 int __v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl *ctrl, const char *s)
3287 {
3288 	lockdep_assert_held(ctrl->handler->lock);
3289 
3290 	/* It's a driver bug if this happens. */
3291 	WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING);
3292 	strlcpy(ctrl->p_new.p_char, s, ctrl->maximum + 1);
3293 	return set_ctrl(NULL, ctrl, 0);
3294 }
3295 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string);
3296 
v4l2_ctrl_notify(struct v4l2_ctrl * ctrl,v4l2_ctrl_notify_fnc notify,void * priv)3297 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
3298 {
3299 	if (ctrl == NULL)
3300 		return;
3301 	if (notify == NULL) {
3302 		ctrl->call_notify = 0;
3303 		return;
3304 	}
3305 	if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
3306 		return;
3307 	ctrl->handler->notify = notify;
3308 	ctrl->handler->notify_priv = priv;
3309 	ctrl->call_notify = 1;
3310 }
3311 EXPORT_SYMBOL(v4l2_ctrl_notify);
3312 
__v4l2_ctrl_modify_range(struct v4l2_ctrl * ctrl,s64 min,s64 max,u64 step,s64 def)3313 int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
3314 			s64 min, s64 max, u64 step, s64 def)
3315 {
3316 	bool changed;
3317 	int ret;
3318 
3319 	lockdep_assert_held(ctrl->handler->lock);
3320 
3321 	switch (ctrl->type) {
3322 	case V4L2_CTRL_TYPE_INTEGER:
3323 	case V4L2_CTRL_TYPE_INTEGER64:
3324 	case V4L2_CTRL_TYPE_BOOLEAN:
3325 	case V4L2_CTRL_TYPE_MENU:
3326 	case V4L2_CTRL_TYPE_INTEGER_MENU:
3327 	case V4L2_CTRL_TYPE_BITMASK:
3328 	case V4L2_CTRL_TYPE_U8:
3329 	case V4L2_CTRL_TYPE_U16:
3330 	case V4L2_CTRL_TYPE_U32:
3331 		if (ctrl->is_array)
3332 			return -EINVAL;
3333 		ret = check_range(ctrl->type, min, max, step, def);
3334 		if (ret)
3335 			return ret;
3336 		break;
3337 	default:
3338 		return -EINVAL;
3339 	}
3340 	ctrl->minimum = min;
3341 	ctrl->maximum = max;
3342 	ctrl->step = step;
3343 	ctrl->default_value = def;
3344 	cur_to_new(ctrl);
3345 	if (validate_new(ctrl, ctrl->p_new)) {
3346 		if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
3347 			*ctrl->p_new.p_s64 = def;
3348 		else
3349 			*ctrl->p_new.p_s32 = def;
3350 	}
3351 
3352 	if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
3353 		changed = *ctrl->p_new.p_s64 != *ctrl->p_cur.p_s64;
3354 	else
3355 		changed = *ctrl->p_new.p_s32 != *ctrl->p_cur.p_s32;
3356 	if (changed)
3357 		ret = set_ctrl(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
3358 	else
3359 		send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
3360 	return ret;
3361 }
3362 EXPORT_SYMBOL(__v4l2_ctrl_modify_range);
3363 
v4l2_ctrl_add_event(struct v4l2_subscribed_event * sev,unsigned elems)3364 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
3365 {
3366 	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
3367 
3368 	if (ctrl == NULL)
3369 		return -EINVAL;
3370 
3371 	v4l2_ctrl_lock(ctrl);
3372 	list_add_tail(&sev->node, &ctrl->ev_subs);
3373 	if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
3374 	    (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
3375 		struct v4l2_event ev;
3376 		u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
3377 
3378 		if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
3379 			changes |= V4L2_EVENT_CTRL_CH_VALUE;
3380 		fill_event(&ev, ctrl, changes);
3381 		/* Mark the queue as active, allowing this initial
3382 		   event to be accepted. */
3383 		sev->elems = elems;
3384 		v4l2_event_queue_fh(sev->fh, &ev);
3385 	}
3386 	v4l2_ctrl_unlock(ctrl);
3387 	return 0;
3388 }
3389 
v4l2_ctrl_del_event(struct v4l2_subscribed_event * sev)3390 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
3391 {
3392 	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
3393 
3394 	v4l2_ctrl_lock(ctrl);
3395 	list_del(&sev->node);
3396 	v4l2_ctrl_unlock(ctrl);
3397 }
3398 
v4l2_ctrl_replace(struct v4l2_event * old,const struct v4l2_event * new)3399 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
3400 {
3401 	u32 old_changes = old->u.ctrl.changes;
3402 
3403 	old->u.ctrl = new->u.ctrl;
3404 	old->u.ctrl.changes |= old_changes;
3405 }
3406 EXPORT_SYMBOL(v4l2_ctrl_replace);
3407 
v4l2_ctrl_merge(const struct v4l2_event * old,struct v4l2_event * new)3408 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
3409 {
3410 	new->u.ctrl.changes |= old->u.ctrl.changes;
3411 }
3412 EXPORT_SYMBOL(v4l2_ctrl_merge);
3413 
3414 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
3415 	.add = v4l2_ctrl_add_event,
3416 	.del = v4l2_ctrl_del_event,
3417 	.replace = v4l2_ctrl_replace,
3418 	.merge = v4l2_ctrl_merge,
3419 };
3420 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
3421 
v4l2_ctrl_log_status(struct file * file,void * fh)3422 int v4l2_ctrl_log_status(struct file *file, void *fh)
3423 {
3424 	struct video_device *vfd = video_devdata(file);
3425 	struct v4l2_fh *vfh = file->private_data;
3426 
3427 	if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
3428 		v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
3429 			vfd->v4l2_dev->name);
3430 	return 0;
3431 }
3432 EXPORT_SYMBOL(v4l2_ctrl_log_status);
3433 
v4l2_ctrl_subscribe_event(struct v4l2_fh * fh,const struct v4l2_event_subscription * sub)3434 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
3435 				const struct v4l2_event_subscription *sub)
3436 {
3437 	if (sub->type == V4L2_EVENT_CTRL)
3438 		return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
3439 	return -EINVAL;
3440 }
3441 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
3442 
v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev * sd,struct v4l2_fh * fh,struct v4l2_event_subscription * sub)3443 int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
3444 				     struct v4l2_event_subscription *sub)
3445 {
3446 	if (!sd->ctrl_handler)
3447 		return -EINVAL;
3448 	return v4l2_ctrl_subscribe_event(fh, sub);
3449 }
3450 EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
3451 
v4l2_ctrl_poll(struct file * file,struct poll_table_struct * wait)3452 unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
3453 {
3454 	struct v4l2_fh *fh = file->private_data;
3455 
3456 	if (v4l2_event_pending(fh))
3457 		return POLLPRI;
3458 	poll_wait(file, &fh->wait, wait);
3459 	return 0;
3460 }
3461 EXPORT_SYMBOL(v4l2_ctrl_poll);
3462