• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 		*min = *max = *step = *def = 0;
996 		break;
997 	case V4L2_CID_POWER_LINE_FREQUENCY:
998 	case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
999 	case V4L2_CID_MPEG_AUDIO_ENCODING:
1000 	case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1001 	case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1002 	case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1003 	case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
1004 	case V4L2_CID_MPEG_AUDIO_MODE:
1005 	case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1006 	case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1007 	case V4L2_CID_MPEG_AUDIO_CRC:
1008 	case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
1009 	case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
1010 	case V4L2_CID_MPEG_VIDEO_ENCODING:
1011 	case V4L2_CID_MPEG_VIDEO_ASPECT:
1012 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1013 	case V4L2_CID_MPEG_STREAM_TYPE:
1014 	case V4L2_CID_MPEG_STREAM_VBI_FMT:
1015 	case V4L2_CID_EXPOSURE_AUTO:
1016 	case V4L2_CID_AUTO_FOCUS_RANGE:
1017 	case V4L2_CID_COLORFX:
1018 	case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
1019 	case V4L2_CID_TUNE_PREEMPHASIS:
1020 	case V4L2_CID_FLASH_LED_MODE:
1021 	case V4L2_CID_FLASH_STROBE_SOURCE:
1022 	case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1023 	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1024 	case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1025 	case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1026 	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1027 	case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1028 	case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1029 	case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
1030 	case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
1031 	case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1032 	case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1033 	case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1034 	case V4L2_CID_ISO_SENSITIVITY_AUTO:
1035 	case V4L2_CID_EXPOSURE_METERING:
1036 	case V4L2_CID_SCENE_MODE:
1037 	case V4L2_CID_DV_TX_MODE:
1038 	case V4L2_CID_DV_TX_RGB_RANGE:
1039 	case V4L2_CID_DV_RX_RGB_RANGE:
1040 	case V4L2_CID_TEST_PATTERN:
1041 	case V4L2_CID_TUNE_DEEMPHASIS:
1042 	case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
1043 	case V4L2_CID_DETECT_MD_MODE:
1044 		*type = V4L2_CTRL_TYPE_MENU;
1045 		break;
1046 	case V4L2_CID_LINK_FREQ:
1047 		*type = V4L2_CTRL_TYPE_INTEGER_MENU;
1048 		break;
1049 	case V4L2_CID_RDS_TX_PS_NAME:
1050 	case V4L2_CID_RDS_TX_RADIO_TEXT:
1051 	case V4L2_CID_RDS_RX_PS_NAME:
1052 	case V4L2_CID_RDS_RX_RADIO_TEXT:
1053 		*type = V4L2_CTRL_TYPE_STRING;
1054 		break;
1055 	case V4L2_CID_ISO_SENSITIVITY:
1056 	case V4L2_CID_AUTO_EXPOSURE_BIAS:
1057 	case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
1058 	case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
1059 		*type = V4L2_CTRL_TYPE_INTEGER_MENU;
1060 		break;
1061 	case V4L2_CID_USER_CLASS:
1062 	case V4L2_CID_CAMERA_CLASS:
1063 	case V4L2_CID_MPEG_CLASS:
1064 	case V4L2_CID_FM_TX_CLASS:
1065 	case V4L2_CID_FLASH_CLASS:
1066 	case V4L2_CID_JPEG_CLASS:
1067 	case V4L2_CID_IMAGE_SOURCE_CLASS:
1068 	case V4L2_CID_IMAGE_PROC_CLASS:
1069 	case V4L2_CID_DV_CLASS:
1070 	case V4L2_CID_FM_RX_CLASS:
1071 	case V4L2_CID_RF_TUNER_CLASS:
1072 	case V4L2_CID_DETECT_CLASS:
1073 		*type = V4L2_CTRL_TYPE_CTRL_CLASS;
1074 		/* You can neither read not write these */
1075 		*flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
1076 		*min = *max = *step = *def = 0;
1077 		break;
1078 	case V4L2_CID_BG_COLOR:
1079 		*type = V4L2_CTRL_TYPE_INTEGER;
1080 		*step = 1;
1081 		*min = 0;
1082 		/* Max is calculated as RGB888 that is 2^24 */
1083 		*max = 0xFFFFFF;
1084 		break;
1085 	case V4L2_CID_FLASH_FAULT:
1086 	case V4L2_CID_JPEG_ACTIVE_MARKER:
1087 	case V4L2_CID_3A_LOCK:
1088 	case V4L2_CID_AUTO_FOCUS_STATUS:
1089 	case V4L2_CID_DV_TX_HOTPLUG:
1090 	case V4L2_CID_DV_TX_RXSENSE:
1091 	case V4L2_CID_DV_TX_EDID_PRESENT:
1092 	case V4L2_CID_DV_RX_POWER_PRESENT:
1093 		*type = V4L2_CTRL_TYPE_BITMASK;
1094 		break;
1095 	case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
1096 	case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
1097 		*type = V4L2_CTRL_TYPE_INTEGER;
1098 		*flags |= V4L2_CTRL_FLAG_READ_ONLY;
1099 		break;
1100 	case V4L2_CID_MPEG_VIDEO_DEC_PTS:
1101 		*type = V4L2_CTRL_TYPE_INTEGER64;
1102 		*flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1103 		*min = *def = 0;
1104 		*max = 0x1ffffffffLL;
1105 		*step = 1;
1106 		break;
1107 	case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
1108 		*type = V4L2_CTRL_TYPE_INTEGER64;
1109 		*flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY;
1110 		*min = *def = 0;
1111 		*max = 0x7fffffffffffffffLL;
1112 		*step = 1;
1113 		break;
1114 	case V4L2_CID_PIXEL_RATE:
1115 		*type = V4L2_CTRL_TYPE_INTEGER64;
1116 		*flags |= V4L2_CTRL_FLAG_READ_ONLY;
1117 		break;
1118 	case V4L2_CID_DETECT_MD_REGION_GRID:
1119 		*type = V4L2_CTRL_TYPE_U8;
1120 		break;
1121 	case V4L2_CID_DETECT_MD_THRESHOLD_GRID:
1122 		*type = V4L2_CTRL_TYPE_U16;
1123 		break;
1124 	case V4L2_CID_RDS_TX_ALT_FREQS:
1125 		*type = V4L2_CTRL_TYPE_U32;
1126 		break;
1127 	default:
1128 		*type = V4L2_CTRL_TYPE_INTEGER;
1129 		break;
1130 	}
1131 	switch (id) {
1132 	case V4L2_CID_MPEG_AUDIO_ENCODING:
1133 	case V4L2_CID_MPEG_AUDIO_MODE:
1134 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1135 	case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1136 	case V4L2_CID_MPEG_STREAM_TYPE:
1137 		*flags |= V4L2_CTRL_FLAG_UPDATE;
1138 		break;
1139 	case V4L2_CID_AUDIO_VOLUME:
1140 	case V4L2_CID_AUDIO_BALANCE:
1141 	case V4L2_CID_AUDIO_BASS:
1142 	case V4L2_CID_AUDIO_TREBLE:
1143 	case V4L2_CID_BRIGHTNESS:
1144 	case V4L2_CID_CONTRAST:
1145 	case V4L2_CID_SATURATION:
1146 	case V4L2_CID_HUE:
1147 	case V4L2_CID_RED_BALANCE:
1148 	case V4L2_CID_BLUE_BALANCE:
1149 	case V4L2_CID_GAMMA:
1150 	case V4L2_CID_SHARPNESS:
1151 	case V4L2_CID_CHROMA_GAIN:
1152 	case V4L2_CID_RDS_TX_DEVIATION:
1153 	case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1154 	case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1155 	case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1156 	case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1157 	case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1158 	case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1159 	case V4L2_CID_PILOT_TONE_DEVIATION:
1160 	case V4L2_CID_PILOT_TONE_FREQUENCY:
1161 	case V4L2_CID_TUNE_POWER_LEVEL:
1162 	case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1163 	case V4L2_CID_RF_TUNER_LNA_GAIN:
1164 	case V4L2_CID_RF_TUNER_MIXER_GAIN:
1165 	case V4L2_CID_RF_TUNER_IF_GAIN:
1166 	case V4L2_CID_RF_TUNER_BANDWIDTH:
1167 	case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD:
1168 		*flags |= V4L2_CTRL_FLAG_SLIDER;
1169 		break;
1170 	case V4L2_CID_PAN_RELATIVE:
1171 	case V4L2_CID_TILT_RELATIVE:
1172 	case V4L2_CID_FOCUS_RELATIVE:
1173 	case V4L2_CID_IRIS_RELATIVE:
1174 	case V4L2_CID_ZOOM_RELATIVE:
1175 		*flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1176 		break;
1177 	case V4L2_CID_FLASH_STROBE_STATUS:
1178 	case V4L2_CID_AUTO_FOCUS_STATUS:
1179 	case V4L2_CID_FLASH_READY:
1180 	case V4L2_CID_DV_TX_HOTPLUG:
1181 	case V4L2_CID_DV_TX_RXSENSE:
1182 	case V4L2_CID_DV_TX_EDID_PRESENT:
1183 	case V4L2_CID_DV_RX_POWER_PRESENT:
1184 	case V4L2_CID_RDS_RX_PTY:
1185 	case V4L2_CID_RDS_RX_PS_NAME:
1186 	case V4L2_CID_RDS_RX_RADIO_TEXT:
1187 	case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT:
1188 	case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM:
1189 	case V4L2_CID_RDS_RX_MUSIC_SPEECH:
1190 		*flags |= V4L2_CTRL_FLAG_READ_ONLY;
1191 		break;
1192 	case V4L2_CID_RF_TUNER_PLL_LOCK:
1193 		*flags |= V4L2_CTRL_FLAG_VOLATILE;
1194 		break;
1195 	}
1196 }
1197 EXPORT_SYMBOL(v4l2_ctrl_fill);
1198 
user_flags(const struct v4l2_ctrl * ctrl)1199 static u32 user_flags(const struct v4l2_ctrl *ctrl)
1200 {
1201 	u32 flags = ctrl->flags;
1202 
1203 	if (ctrl->is_ptr)
1204 		flags |= V4L2_CTRL_FLAG_HAS_PAYLOAD;
1205 
1206 	return flags;
1207 }
1208 
fill_event(struct v4l2_event * ev,struct v4l2_ctrl * ctrl,u32 changes)1209 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes)
1210 {
1211 	memset(ev->reserved, 0, sizeof(ev->reserved));
1212 	ev->type = V4L2_EVENT_CTRL;
1213 	ev->id = ctrl->id;
1214 	ev->u.ctrl.changes = changes;
1215 	ev->u.ctrl.type = ctrl->type;
1216 	ev->u.ctrl.flags = user_flags(ctrl);
1217 	if (ctrl->is_ptr)
1218 		ev->u.ctrl.value64 = 0;
1219 	else
1220 		ev->u.ctrl.value64 = *ctrl->p_cur.p_s64;
1221 	ev->u.ctrl.minimum = ctrl->minimum;
1222 	ev->u.ctrl.maximum = ctrl->maximum;
1223 	if (ctrl->type == V4L2_CTRL_TYPE_MENU
1224 	    || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1225 		ev->u.ctrl.step = 1;
1226 	else
1227 		ev->u.ctrl.step = ctrl->step;
1228 	ev->u.ctrl.default_value = ctrl->default_value;
1229 }
1230 
send_event(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,u32 changes)1231 static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
1232 {
1233 	struct v4l2_event ev;
1234 	struct v4l2_subscribed_event *sev;
1235 
1236 	if (list_empty(&ctrl->ev_subs))
1237 		return;
1238 	fill_event(&ev, ctrl, changes);
1239 
1240 	list_for_each_entry(sev, &ctrl->ev_subs, node)
1241 		if (sev->fh != fh ||
1242 		    (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
1243 			v4l2_event_queue_fh(sev->fh, &ev);
1244 }
1245 
std_equal(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr1,union v4l2_ctrl_ptr ptr2)1246 static bool std_equal(const struct v4l2_ctrl *ctrl, u32 idx,
1247 		      union v4l2_ctrl_ptr ptr1,
1248 		      union v4l2_ctrl_ptr ptr2)
1249 {
1250 	switch (ctrl->type) {
1251 	case V4L2_CTRL_TYPE_BUTTON:
1252 		return false;
1253 	case V4L2_CTRL_TYPE_STRING:
1254 		idx *= ctrl->elem_size;
1255 		/* strings are always 0-terminated */
1256 		return !strcmp(ptr1.p_char + idx, ptr2.p_char + idx);
1257 	case V4L2_CTRL_TYPE_INTEGER64:
1258 		return ptr1.p_s64[idx] == ptr2.p_s64[idx];
1259 	case V4L2_CTRL_TYPE_U8:
1260 		return ptr1.p_u8[idx] == ptr2.p_u8[idx];
1261 	case V4L2_CTRL_TYPE_U16:
1262 		return ptr1.p_u16[idx] == ptr2.p_u16[idx];
1263 	case V4L2_CTRL_TYPE_U32:
1264 		return ptr1.p_u32[idx] == ptr2.p_u32[idx];
1265 	default:
1266 		if (ctrl->is_int)
1267 			return ptr1.p_s32[idx] == ptr2.p_s32[idx];
1268 		idx *= ctrl->elem_size;
1269 		return !memcmp(ptr1.p + idx, ptr2.p + idx, ctrl->elem_size);
1270 	}
1271 }
1272 
std_init(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr)1273 static void std_init(const struct v4l2_ctrl *ctrl, u32 idx,
1274 		     union v4l2_ctrl_ptr ptr)
1275 {
1276 	switch (ctrl->type) {
1277 	case V4L2_CTRL_TYPE_STRING:
1278 		idx *= ctrl->elem_size;
1279 		memset(ptr.p_char + idx, ' ', ctrl->minimum);
1280 		ptr.p_char[idx + ctrl->minimum] = '\0';
1281 		break;
1282 	case V4L2_CTRL_TYPE_INTEGER64:
1283 		ptr.p_s64[idx] = ctrl->default_value;
1284 		break;
1285 	case V4L2_CTRL_TYPE_INTEGER:
1286 	case V4L2_CTRL_TYPE_INTEGER_MENU:
1287 	case V4L2_CTRL_TYPE_MENU:
1288 	case V4L2_CTRL_TYPE_BITMASK:
1289 	case V4L2_CTRL_TYPE_BOOLEAN:
1290 		ptr.p_s32[idx] = ctrl->default_value;
1291 		break;
1292 	case V4L2_CTRL_TYPE_U8:
1293 		ptr.p_u8[idx] = ctrl->default_value;
1294 		break;
1295 	case V4L2_CTRL_TYPE_U16:
1296 		ptr.p_u16[idx] = ctrl->default_value;
1297 		break;
1298 	case V4L2_CTRL_TYPE_U32:
1299 		ptr.p_u32[idx] = ctrl->default_value;
1300 		break;
1301 	default:
1302 		idx *= ctrl->elem_size;
1303 		memset(ptr.p + idx, 0, ctrl->elem_size);
1304 		break;
1305 	}
1306 }
1307 
std_log(const struct v4l2_ctrl * ctrl)1308 static void std_log(const struct v4l2_ctrl *ctrl)
1309 {
1310 	union v4l2_ctrl_ptr ptr = ctrl->p_cur;
1311 
1312 	if (ctrl->is_array) {
1313 		unsigned i;
1314 
1315 		for (i = 0; i < ctrl->nr_of_dims; i++)
1316 			pr_cont("[%u]", ctrl->dims[i]);
1317 		pr_cont(" ");
1318 	}
1319 
1320 	switch (ctrl->type) {
1321 	case V4L2_CTRL_TYPE_INTEGER:
1322 		pr_cont("%d", *ptr.p_s32);
1323 		break;
1324 	case V4L2_CTRL_TYPE_BOOLEAN:
1325 		pr_cont("%s", *ptr.p_s32 ? "true" : "false");
1326 		break;
1327 	case V4L2_CTRL_TYPE_MENU:
1328 		pr_cont("%s", ctrl->qmenu[*ptr.p_s32]);
1329 		break;
1330 	case V4L2_CTRL_TYPE_INTEGER_MENU:
1331 		pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]);
1332 		break;
1333 	case V4L2_CTRL_TYPE_BITMASK:
1334 		pr_cont("0x%08x", *ptr.p_s32);
1335 		break;
1336 	case V4L2_CTRL_TYPE_INTEGER64:
1337 		pr_cont("%lld", *ptr.p_s64);
1338 		break;
1339 	case V4L2_CTRL_TYPE_STRING:
1340 		pr_cont("%s", ptr.p_char);
1341 		break;
1342 	case V4L2_CTRL_TYPE_U8:
1343 		pr_cont("%u", (unsigned)*ptr.p_u8);
1344 		break;
1345 	case V4L2_CTRL_TYPE_U16:
1346 		pr_cont("%u", (unsigned)*ptr.p_u16);
1347 		break;
1348 	case V4L2_CTRL_TYPE_U32:
1349 		pr_cont("%u", (unsigned)*ptr.p_u32);
1350 		break;
1351 	default:
1352 		pr_cont("unknown type %d", ctrl->type);
1353 		break;
1354 	}
1355 }
1356 
1357 /*
1358  * Round towards the closest legal value. Be careful when we are
1359  * close to the maximum range of the control type to prevent
1360  * wrap-arounds.
1361  */
1362 #define ROUND_TO_RANGE(val, offset_type, ctrl)			\
1363 ({								\
1364 	offset_type offset;					\
1365 	if ((ctrl)->maximum >= 0 &&				\
1366 	    val >= (ctrl)->maximum - (s32)((ctrl)->step / 2))	\
1367 		val = (ctrl)->maximum;				\
1368 	else							\
1369 		val += (s32)((ctrl)->step / 2);			\
1370 	val = clamp_t(typeof(val), val,				\
1371 		      (ctrl)->minimum, (ctrl)->maximum);	\
1372 	offset = (val) - (ctrl)->minimum;			\
1373 	offset = (ctrl)->step * (offset / (u32)(ctrl)->step);	\
1374 	val = (ctrl)->minimum + offset;				\
1375 	0;							\
1376 })
1377 
1378 /* Validate a new control */
std_validate(const struct v4l2_ctrl * ctrl,u32 idx,union v4l2_ctrl_ptr ptr)1379 static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx,
1380 			union v4l2_ctrl_ptr ptr)
1381 {
1382 	size_t len;
1383 	u64 offset;
1384 	s64 val;
1385 
1386 	switch (ctrl->type) {
1387 	case V4L2_CTRL_TYPE_INTEGER:
1388 		return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
1389 	case V4L2_CTRL_TYPE_INTEGER64:
1390 		/*
1391 		 * We can't use the ROUND_TO_RANGE define here due to
1392 		 * the u64 divide that needs special care.
1393 		 */
1394 		val = ptr.p_s64[idx];
1395 		if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2))
1396 			val = ctrl->maximum;
1397 		else
1398 			val += (s64)(ctrl->step / 2);
1399 		val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum);
1400 		offset = val - ctrl->minimum;
1401 		do_div(offset, ctrl->step);
1402 		ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step;
1403 		return 0;
1404 	case V4L2_CTRL_TYPE_U8:
1405 		return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl);
1406 	case V4L2_CTRL_TYPE_U16:
1407 		return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl);
1408 	case V4L2_CTRL_TYPE_U32:
1409 		return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl);
1410 
1411 	case V4L2_CTRL_TYPE_BOOLEAN:
1412 		ptr.p_s32[idx] = !!ptr.p_s32[idx];
1413 		return 0;
1414 
1415 	case V4L2_CTRL_TYPE_MENU:
1416 	case V4L2_CTRL_TYPE_INTEGER_MENU:
1417 		if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum)
1418 			return -ERANGE;
1419 		if (ctrl->menu_skip_mask & (1 << ptr.p_s32[idx]))
1420 			return -EINVAL;
1421 		if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1422 		    ctrl->qmenu[ptr.p_s32[idx]][0] == '\0')
1423 			return -EINVAL;
1424 		return 0;
1425 
1426 	case V4L2_CTRL_TYPE_BITMASK:
1427 		ptr.p_s32[idx] &= ctrl->maximum;
1428 		return 0;
1429 
1430 	case V4L2_CTRL_TYPE_BUTTON:
1431 	case V4L2_CTRL_TYPE_CTRL_CLASS:
1432 		ptr.p_s32[idx] = 0;
1433 		return 0;
1434 
1435 	case V4L2_CTRL_TYPE_STRING:
1436 		idx *= ctrl->elem_size;
1437 		len = strlen(ptr.p_char + idx);
1438 		if (len < ctrl->minimum)
1439 			return -ERANGE;
1440 		if ((len - (u32)ctrl->minimum) % (u32)ctrl->step)
1441 			return -ERANGE;
1442 		return 0;
1443 
1444 	default:
1445 		return -EINVAL;
1446 	}
1447 }
1448 
1449 static const struct v4l2_ctrl_type_ops std_type_ops = {
1450 	.equal = std_equal,
1451 	.init = std_init,
1452 	.log = std_log,
1453 	.validate = std_validate,
1454 };
1455 
1456 /* 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)1457 static int ptr_to_user(struct v4l2_ext_control *c,
1458 		       struct v4l2_ctrl *ctrl,
1459 		       union v4l2_ctrl_ptr ptr)
1460 {
1461 	u32 len;
1462 
1463 	if (ctrl->is_ptr && !ctrl->is_string)
1464 		return copy_to_user(c->ptr, ptr.p, c->size) ?
1465 		       -EFAULT : 0;
1466 
1467 	switch (ctrl->type) {
1468 	case V4L2_CTRL_TYPE_STRING:
1469 		len = strlen(ptr.p_char);
1470 		if (c->size < len + 1) {
1471 			c->size = ctrl->elem_size;
1472 			return -ENOSPC;
1473 		}
1474 		return copy_to_user(c->string, ptr.p_char, len + 1) ?
1475 		       -EFAULT : 0;
1476 	case V4L2_CTRL_TYPE_INTEGER64:
1477 		c->value64 = *ptr.p_s64;
1478 		break;
1479 	default:
1480 		c->value = *ptr.p_s32;
1481 		break;
1482 	}
1483 	return 0;
1484 }
1485 
1486 /* Helper function: copy the current control value back to the caller */
cur_to_user(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl)1487 static int cur_to_user(struct v4l2_ext_control *c,
1488 		       struct v4l2_ctrl *ctrl)
1489 {
1490 	return ptr_to_user(c, ctrl, ctrl->p_cur);
1491 }
1492 
1493 /* Helper function: copy the new control value back to the caller */
new_to_user(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl)1494 static int new_to_user(struct v4l2_ext_control *c,
1495 		       struct v4l2_ctrl *ctrl)
1496 {
1497 	return ptr_to_user(c, ctrl, ctrl->p_new);
1498 }
1499 
1500 /* 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)1501 static int user_to_ptr(struct v4l2_ext_control *c,
1502 		       struct v4l2_ctrl *ctrl,
1503 		       union v4l2_ctrl_ptr ptr)
1504 {
1505 	int ret;
1506 	u32 size;
1507 
1508 	ctrl->is_new = 1;
1509 	if (ctrl->is_ptr && !ctrl->is_string) {
1510 		unsigned idx;
1511 
1512 		ret = copy_from_user(ptr.p, c->ptr, c->size) ? -EFAULT : 0;
1513 		if (ret || !ctrl->is_array)
1514 			return ret;
1515 		for (idx = c->size / ctrl->elem_size; idx < ctrl->elems; idx++)
1516 			ctrl->type_ops->init(ctrl, idx, ptr);
1517 		return 0;
1518 	}
1519 
1520 	switch (ctrl->type) {
1521 	case V4L2_CTRL_TYPE_INTEGER64:
1522 		*ptr.p_s64 = c->value64;
1523 		break;
1524 	case V4L2_CTRL_TYPE_STRING:
1525 		size = c->size;
1526 		if (size == 0)
1527 			return -ERANGE;
1528 		if (size > ctrl->maximum + 1)
1529 			size = ctrl->maximum + 1;
1530 		ret = copy_from_user(ptr.p_char, c->string, size) ? -EFAULT : 0;
1531 		if (!ret) {
1532 			char last = ptr.p_char[size - 1];
1533 
1534 			ptr.p_char[size - 1] = 0;
1535 			/* If the string was longer than ctrl->maximum,
1536 			   then return an error. */
1537 			if (strlen(ptr.p_char) == ctrl->maximum && last)
1538 				return -ERANGE;
1539 		}
1540 		return ret;
1541 	default:
1542 		*ptr.p_s32 = c->value;
1543 		break;
1544 	}
1545 	return 0;
1546 }
1547 
1548 /* Helper function: copy the caller-provider value as the new control value */
user_to_new(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl)1549 static int user_to_new(struct v4l2_ext_control *c,
1550 		       struct v4l2_ctrl *ctrl)
1551 {
1552 	return user_to_ptr(c, ctrl, ctrl->p_new);
1553 }
1554 
1555 /* Copy the one value to another. */
ptr_to_ptr(struct v4l2_ctrl * ctrl,union v4l2_ctrl_ptr from,union v4l2_ctrl_ptr to)1556 static void ptr_to_ptr(struct v4l2_ctrl *ctrl,
1557 		       union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to)
1558 {
1559 	if (ctrl == NULL)
1560 		return;
1561 	memcpy(to.p, from.p, ctrl->elems * ctrl->elem_size);
1562 }
1563 
1564 /* Copy the new value to the current value. */
new_to_cur(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,u32 ch_flags)1565 static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
1566 {
1567 	bool changed;
1568 
1569 	if (ctrl == NULL)
1570 		return;
1571 
1572 	/* has_changed is set by cluster_changed */
1573 	changed = ctrl->has_changed;
1574 	if (changed)
1575 		ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur);
1576 
1577 	if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
1578 		/* Note: CH_FLAGS is only set for auto clusters. */
1579 		ctrl->flags &=
1580 			~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1581 		if (!is_cur_manual(ctrl->cluster[0])) {
1582 			ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1583 			if (ctrl->cluster[0]->has_volatiles)
1584 				ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1585 		}
1586 		fh = NULL;
1587 	}
1588 	if (changed || ch_flags) {
1589 		/* If a control was changed that was not one of the controls
1590 		   modified by the application, then send the event to all. */
1591 		if (!ctrl->is_new)
1592 			fh = NULL;
1593 		send_event(fh, ctrl,
1594 			(changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
1595 		if (ctrl->call_notify && changed && ctrl->handler->notify)
1596 			ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
1597 	}
1598 }
1599 
1600 /* Copy the current value to the new value */
cur_to_new(struct v4l2_ctrl * ctrl)1601 static void cur_to_new(struct v4l2_ctrl *ctrl)
1602 {
1603 	if (ctrl == NULL)
1604 		return;
1605 	ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);
1606 }
1607 
1608 /* Return non-zero if one or more of the controls in the cluster has a new
1609    value that differs from the current value. */
cluster_changed(struct v4l2_ctrl * master)1610 static int cluster_changed(struct v4l2_ctrl *master)
1611 {
1612 	bool changed = false;
1613 	unsigned idx;
1614 	int i;
1615 
1616 	for (i = 0; i < master->ncontrols; i++) {
1617 		struct v4l2_ctrl *ctrl = master->cluster[i];
1618 		bool ctrl_changed = false;
1619 
1620 		if (ctrl == NULL)
1621 			continue;
1622 		for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++)
1623 			ctrl_changed = !ctrl->type_ops->equal(ctrl, idx,
1624 				ctrl->p_cur, ctrl->p_new);
1625 		ctrl->has_changed = ctrl_changed;
1626 		changed |= ctrl->has_changed;
1627 	}
1628 	return changed;
1629 }
1630 
1631 /* Control range checking */
check_range(enum v4l2_ctrl_type type,s64 min,s64 max,u64 step,s64 def)1632 static int check_range(enum v4l2_ctrl_type type,
1633 		s64 min, s64 max, u64 step, s64 def)
1634 {
1635 	switch (type) {
1636 	case V4L2_CTRL_TYPE_BOOLEAN:
1637 		if (step != 1 || max > 1 || min < 0)
1638 			return -ERANGE;
1639 		/* fall through */
1640 	case V4L2_CTRL_TYPE_U8:
1641 	case V4L2_CTRL_TYPE_U16:
1642 	case V4L2_CTRL_TYPE_U32:
1643 	case V4L2_CTRL_TYPE_INTEGER:
1644 	case V4L2_CTRL_TYPE_INTEGER64:
1645 		if (step == 0 || min > max || def < min || def > max)
1646 			return -ERANGE;
1647 		return 0;
1648 	case V4L2_CTRL_TYPE_BITMASK:
1649 		if (step || min || !max || (def & ~max))
1650 			return -ERANGE;
1651 		return 0;
1652 	case V4L2_CTRL_TYPE_MENU:
1653 	case V4L2_CTRL_TYPE_INTEGER_MENU:
1654 		if (min > max || def < min || def > max)
1655 			return -ERANGE;
1656 		/* Note: step == menu_skip_mask for menu controls.
1657 		   So here we check if the default value is masked out. */
1658 		if (step && ((1 << def) & step))
1659 			return -EINVAL;
1660 		return 0;
1661 	case V4L2_CTRL_TYPE_STRING:
1662 		if (min > max || min < 0 || step < 1 || def)
1663 			return -ERANGE;
1664 		return 0;
1665 	default:
1666 		return 0;
1667 	}
1668 }
1669 
1670 /* Validate a new control */
validate_new(const struct v4l2_ctrl * ctrl,struct v4l2_ext_control * c)1671 static int validate_new(const struct v4l2_ctrl *ctrl,
1672 			struct v4l2_ext_control *c)
1673 {
1674 	union v4l2_ctrl_ptr ptr;
1675 	unsigned idx;
1676 	int err = 0;
1677 
1678 	if (!ctrl->is_ptr) {
1679 		switch (ctrl->type) {
1680 		case V4L2_CTRL_TYPE_INTEGER:
1681 		case V4L2_CTRL_TYPE_INTEGER_MENU:
1682 		case V4L2_CTRL_TYPE_MENU:
1683 		case V4L2_CTRL_TYPE_BITMASK:
1684 		case V4L2_CTRL_TYPE_BOOLEAN:
1685 		case V4L2_CTRL_TYPE_BUTTON:
1686 		case V4L2_CTRL_TYPE_CTRL_CLASS:
1687 			ptr.p_s32 = &c->value;
1688 			return ctrl->type_ops->validate(ctrl, 0, ptr);
1689 
1690 		case V4L2_CTRL_TYPE_INTEGER64:
1691 			ptr.p_s64 = &c->value64;
1692 			return ctrl->type_ops->validate(ctrl, 0, ptr);
1693 		default:
1694 			break;
1695 		}
1696 	}
1697 	ptr.p = c->ptr;
1698 	for (idx = 0; !err && idx < c->size / ctrl->elem_size; idx++)
1699 		err = ctrl->type_ops->validate(ctrl, idx, ptr);
1700 	return err;
1701 }
1702 
node2id(struct list_head * node)1703 static inline u32 node2id(struct list_head *node)
1704 {
1705 	return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1706 }
1707 
1708 /* Set the handler's error code if it wasn't set earlier already */
handler_set_err(struct v4l2_ctrl_handler * hdl,int err)1709 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1710 {
1711 	if (hdl->error == 0)
1712 		hdl->error = err;
1713 	return err;
1714 }
1715 
1716 /* 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)1717 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
1718 				 unsigned nr_of_controls_hint,
1719 				 struct lock_class_key *key, const char *name)
1720 {
1721 	hdl->lock = &hdl->_lock;
1722 	mutex_init(hdl->lock);
1723 	lockdep_set_class_and_name(hdl->lock, key, name);
1724 	INIT_LIST_HEAD(&hdl->ctrls);
1725 	INIT_LIST_HEAD(&hdl->ctrl_refs);
1726 	hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1727 	hdl->buckets = kcalloc(hdl->nr_of_buckets, sizeof(hdl->buckets[0]),
1728 			       GFP_KERNEL);
1729 	hdl->error = hdl->buckets ? 0 : -ENOMEM;
1730 	return hdl->error;
1731 }
1732 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
1733 
1734 /* Free all controls and control refs */
v4l2_ctrl_handler_free(struct v4l2_ctrl_handler * hdl)1735 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1736 {
1737 	struct v4l2_ctrl_ref *ref, *next_ref;
1738 	struct v4l2_ctrl *ctrl, *next_ctrl;
1739 	struct v4l2_subscribed_event *sev, *next_sev;
1740 
1741 	if (hdl == NULL || hdl->buckets == NULL)
1742 		return;
1743 
1744 	mutex_lock(hdl->lock);
1745 	/* Free all nodes */
1746 	list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1747 		list_del(&ref->node);
1748 		kfree(ref);
1749 	}
1750 	/* Free all controls owned by the handler */
1751 	list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1752 		list_del(&ctrl->node);
1753 		list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1754 			list_del(&sev->node);
1755 		kfree(ctrl);
1756 	}
1757 	kfree(hdl->buckets);
1758 	hdl->buckets = NULL;
1759 	hdl->cached = NULL;
1760 	hdl->error = 0;
1761 	mutex_unlock(hdl->lock);
1762 }
1763 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1764 
1765 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1766    be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1767    with applications that do not use the NEXT_CTRL flag.
1768 
1769    We just find the n-th private user control. It's O(N), but that should not
1770    be an issue in this particular case. */
find_private_ref(struct v4l2_ctrl_handler * hdl,u32 id)1771 static struct v4l2_ctrl_ref *find_private_ref(
1772 		struct v4l2_ctrl_handler *hdl, u32 id)
1773 {
1774 	struct v4l2_ctrl_ref *ref;
1775 
1776 	id -= V4L2_CID_PRIVATE_BASE;
1777 	list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1778 		/* Search for private user controls that are compatible with
1779 		   VIDIOC_G/S_CTRL. */
1780 		if (V4L2_CTRL_ID2CLASS(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1781 		    V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1782 			if (!ref->ctrl->is_int)
1783 				continue;
1784 			if (id == 0)
1785 				return ref;
1786 			id--;
1787 		}
1788 	}
1789 	return NULL;
1790 }
1791 
1792 /* Find a control with the given ID. */
find_ref(struct v4l2_ctrl_handler * hdl,u32 id)1793 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1794 {
1795 	struct v4l2_ctrl_ref *ref;
1796 	int bucket;
1797 
1798 	id &= V4L2_CTRL_ID_MASK;
1799 
1800 	/* Old-style private controls need special handling */
1801 	if (id >= V4L2_CID_PRIVATE_BASE)
1802 		return find_private_ref(hdl, id);
1803 	bucket = id % hdl->nr_of_buckets;
1804 
1805 	/* Simple optimization: cache the last control found */
1806 	if (hdl->cached && hdl->cached->ctrl->id == id)
1807 		return hdl->cached;
1808 
1809 	/* Not in cache, search the hash */
1810 	ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1811 	while (ref && ref->ctrl->id != id)
1812 		ref = ref->next;
1813 
1814 	if (ref)
1815 		hdl->cached = ref; /* cache it! */
1816 	return ref;
1817 }
1818 
1819 /* Find a control with the given ID. Take the handler's lock first. */
find_ref_lock(struct v4l2_ctrl_handler * hdl,u32 id)1820 static struct v4l2_ctrl_ref *find_ref_lock(
1821 		struct v4l2_ctrl_handler *hdl, u32 id)
1822 {
1823 	struct v4l2_ctrl_ref *ref = NULL;
1824 
1825 	if (hdl) {
1826 		mutex_lock(hdl->lock);
1827 		ref = find_ref(hdl, id);
1828 		mutex_unlock(hdl->lock);
1829 	}
1830 	return ref;
1831 }
1832 
1833 /* Find a control with the given ID. */
v4l2_ctrl_find(struct v4l2_ctrl_handler * hdl,u32 id)1834 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1835 {
1836 	struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1837 
1838 	return ref ? ref->ctrl : NULL;
1839 }
1840 EXPORT_SYMBOL(v4l2_ctrl_find);
1841 
1842 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
handler_new_ref(struct v4l2_ctrl_handler * hdl,struct v4l2_ctrl * ctrl)1843 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1844 			   struct v4l2_ctrl *ctrl)
1845 {
1846 	struct v4l2_ctrl_ref *ref;
1847 	struct v4l2_ctrl_ref *new_ref;
1848 	u32 id = ctrl->id;
1849 	u32 class_ctrl = V4L2_CTRL_ID2CLASS(id) | 1;
1850 	int bucket = id % hdl->nr_of_buckets;	/* which bucket to use */
1851 
1852 	/*
1853 	 * Automatically add the control class if it is not yet present and
1854 	 * the new control is not a compound control.
1855 	 */
1856 	if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES &&
1857 	    id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1858 		if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1859 			return hdl->error;
1860 
1861 	if (hdl->error)
1862 		return hdl->error;
1863 
1864 	new_ref = kzalloc(sizeof(*new_ref), GFP_KERNEL);
1865 	if (!new_ref)
1866 		return handler_set_err(hdl, -ENOMEM);
1867 	new_ref->ctrl = ctrl;
1868 	if (ctrl->handler == hdl) {
1869 		/* By default each control starts in a cluster of its own.
1870 		   new_ref->ctrl is basically a cluster array with one
1871 		   element, so that's perfect to use as the cluster pointer.
1872 		   But only do this for the handler that owns the control. */
1873 		ctrl->cluster = &new_ref->ctrl;
1874 		ctrl->ncontrols = 1;
1875 	}
1876 
1877 	INIT_LIST_HEAD(&new_ref->node);
1878 
1879 	mutex_lock(hdl->lock);
1880 
1881 	/* Add immediately at the end of the list if the list is empty, or if
1882 	   the last element in the list has a lower ID.
1883 	   This ensures that when elements are added in ascending order the
1884 	   insertion is an O(1) operation. */
1885 	if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1886 		list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1887 		goto insert_in_hash;
1888 	}
1889 
1890 	/* Find insert position in sorted list */
1891 	list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1892 		if (ref->ctrl->id < id)
1893 			continue;
1894 		/* Don't add duplicates */
1895 		if (ref->ctrl->id == id) {
1896 			kfree(new_ref);
1897 			goto unlock;
1898 		}
1899 		list_add(&new_ref->node, ref->node.prev);
1900 		break;
1901 	}
1902 
1903 insert_in_hash:
1904 	/* Insert the control node in the hash */
1905 	new_ref->next = hdl->buckets[bucket];
1906 	hdl->buckets[bucket] = new_ref;
1907 
1908 unlock:
1909 	mutex_unlock(hdl->lock);
1910 	return 0;
1911 }
1912 
1913 /* 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)1914 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1915 			const struct v4l2_ctrl_ops *ops,
1916 			const struct v4l2_ctrl_type_ops *type_ops,
1917 			u32 id, const char *name, enum v4l2_ctrl_type type,
1918 			s64 min, s64 max, u64 step, s64 def,
1919 			const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size,
1920 			u32 flags, const char * const *qmenu,
1921 			const s64 *qmenu_int, void *priv)
1922 {
1923 	struct v4l2_ctrl *ctrl;
1924 	unsigned sz_extra;
1925 	unsigned nr_of_dims = 0;
1926 	unsigned elems = 1;
1927 	bool is_array;
1928 	unsigned tot_ctrl_size;
1929 	unsigned idx;
1930 	void *data;
1931 	int err;
1932 
1933 	if (hdl->error)
1934 		return NULL;
1935 
1936 	while (dims && dims[nr_of_dims]) {
1937 		elems *= dims[nr_of_dims];
1938 		nr_of_dims++;
1939 		if (nr_of_dims == V4L2_CTRL_MAX_DIMS)
1940 			break;
1941 	}
1942 	is_array = nr_of_dims > 0;
1943 
1944 	/* Prefill elem_size for all types handled by std_type_ops */
1945 	switch (type) {
1946 	case V4L2_CTRL_TYPE_INTEGER64:
1947 		elem_size = sizeof(s64);
1948 		break;
1949 	case V4L2_CTRL_TYPE_STRING:
1950 		elem_size = max + 1;
1951 		break;
1952 	case V4L2_CTRL_TYPE_U8:
1953 		elem_size = sizeof(u8);
1954 		break;
1955 	case V4L2_CTRL_TYPE_U16:
1956 		elem_size = sizeof(u16);
1957 		break;
1958 	case V4L2_CTRL_TYPE_U32:
1959 		elem_size = sizeof(u32);
1960 		break;
1961 	default:
1962 		if (type < V4L2_CTRL_COMPOUND_TYPES)
1963 			elem_size = sizeof(s32);
1964 		break;
1965 	}
1966 	tot_ctrl_size = elem_size * elems;
1967 
1968 	/* Sanity checks */
1969 	if (id == 0 || name == NULL || !elem_size ||
1970 	    id >= V4L2_CID_PRIVATE_BASE ||
1971 	    (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1972 	    (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
1973 		handler_set_err(hdl, -ERANGE);
1974 		return NULL;
1975 	}
1976 	err = check_range(type, min, max, step, def);
1977 	if (err) {
1978 		handler_set_err(hdl, err);
1979 		return NULL;
1980 	}
1981 	if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
1982 		handler_set_err(hdl, -ERANGE);
1983 		return NULL;
1984 	}
1985 	if (is_array &&
1986 	    (type == V4L2_CTRL_TYPE_BUTTON ||
1987 	     type == V4L2_CTRL_TYPE_CTRL_CLASS)) {
1988 		handler_set_err(hdl, -EINVAL);
1989 		return NULL;
1990 	}
1991 
1992 	sz_extra = 0;
1993 	if (type == V4L2_CTRL_TYPE_BUTTON)
1994 		flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1995 	else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1996 		flags |= V4L2_CTRL_FLAG_READ_ONLY;
1997 	else if (type == V4L2_CTRL_TYPE_INTEGER64 ||
1998 		 type == V4L2_CTRL_TYPE_STRING ||
1999 		 type >= V4L2_CTRL_COMPOUND_TYPES ||
2000 		 is_array)
2001 		sz_extra += 2 * tot_ctrl_size;
2002 
2003 	ctrl = kzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
2004 	if (ctrl == NULL) {
2005 		handler_set_err(hdl, -ENOMEM);
2006 		return NULL;
2007 	}
2008 
2009 	INIT_LIST_HEAD(&ctrl->node);
2010 	INIT_LIST_HEAD(&ctrl->ev_subs);
2011 	ctrl->handler = hdl;
2012 	ctrl->ops = ops;
2013 	ctrl->type_ops = type_ops ? type_ops : &std_type_ops;
2014 	ctrl->id = id;
2015 	ctrl->name = name;
2016 	ctrl->type = type;
2017 	ctrl->flags = flags;
2018 	ctrl->minimum = min;
2019 	ctrl->maximum = max;
2020 	ctrl->step = step;
2021 	ctrl->default_value = def;
2022 	ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING;
2023 	ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string;
2024 	ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64;
2025 	ctrl->is_array = is_array;
2026 	ctrl->elems = elems;
2027 	ctrl->nr_of_dims = nr_of_dims;
2028 	if (nr_of_dims)
2029 		memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0]));
2030 	ctrl->elem_size = elem_size;
2031 	if (type == V4L2_CTRL_TYPE_MENU)
2032 		ctrl->qmenu = qmenu;
2033 	else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2034 		ctrl->qmenu_int = qmenu_int;
2035 	ctrl->priv = priv;
2036 	ctrl->cur.val = ctrl->val = def;
2037 	data = &ctrl[1];
2038 
2039 	if (!ctrl->is_int) {
2040 		ctrl->p_new.p = data;
2041 		ctrl->p_cur.p = data + tot_ctrl_size;
2042 	} else {
2043 		ctrl->p_new.p = &ctrl->val;
2044 		ctrl->p_cur.p = &ctrl->cur.val;
2045 	}
2046 	for (idx = 0; idx < elems; idx++) {
2047 		ctrl->type_ops->init(ctrl, idx, ctrl->p_cur);
2048 		ctrl->type_ops->init(ctrl, idx, ctrl->p_new);
2049 	}
2050 
2051 	if (handler_new_ref(hdl, ctrl)) {
2052 		kfree(ctrl);
2053 		return NULL;
2054 	}
2055 	mutex_lock(hdl->lock);
2056 	list_add_tail(&ctrl->node, &hdl->ctrls);
2057 	mutex_unlock(hdl->lock);
2058 	return ctrl;
2059 }
2060 
v4l2_ctrl_new_custom(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_config * cfg,void * priv)2061 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
2062 			const struct v4l2_ctrl_config *cfg, void *priv)
2063 {
2064 	bool is_menu;
2065 	struct v4l2_ctrl *ctrl;
2066 	const char *name = cfg->name;
2067 	const char * const *qmenu = cfg->qmenu;
2068 	const s64 *qmenu_int = cfg->qmenu_int;
2069 	enum v4l2_ctrl_type type = cfg->type;
2070 	u32 flags = cfg->flags;
2071 	s64 min = cfg->min;
2072 	s64 max = cfg->max;
2073 	u64 step = cfg->step;
2074 	s64 def = cfg->def;
2075 
2076 	if (name == NULL)
2077 		v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
2078 								&def, &flags);
2079 
2080 	is_menu = (cfg->type == V4L2_CTRL_TYPE_MENU ||
2081 		   cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU);
2082 	if (is_menu)
2083 		WARN_ON(step);
2084 	else
2085 		WARN_ON(cfg->menu_skip_mask);
2086 	if (cfg->type == V4L2_CTRL_TYPE_MENU && qmenu == NULL)
2087 		qmenu = v4l2_ctrl_get_menu(cfg->id);
2088 	else if (cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU &&
2089 		 qmenu_int == NULL) {
2090 		handler_set_err(hdl, -EINVAL);
2091 		return NULL;
2092 	}
2093 
2094 	ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name,
2095 			type, min, max,
2096 			is_menu ? cfg->menu_skip_mask : step, def,
2097 			cfg->dims, cfg->elem_size,
2098 			flags, qmenu, qmenu_int, priv);
2099 	if (ctrl)
2100 		ctrl->is_private = cfg->is_private;
2101 	return ctrl;
2102 }
2103 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
2104 
2105 /* 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)2106 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
2107 			const struct v4l2_ctrl_ops *ops,
2108 			u32 id, s64 min, s64 max, u64 step, s64 def)
2109 {
2110 	const char *name;
2111 	enum v4l2_ctrl_type type;
2112 	u32 flags;
2113 
2114 	v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2115 	if (type == V4L2_CTRL_TYPE_MENU ||
2116 	    type == V4L2_CTRL_TYPE_INTEGER_MENU ||
2117 	    type >= V4L2_CTRL_COMPOUND_TYPES) {
2118 		handler_set_err(hdl, -EINVAL);
2119 		return NULL;
2120 	}
2121 	return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2122 			     min, max, step, def, NULL, 0,
2123 			     flags, NULL, NULL, NULL);
2124 }
2125 EXPORT_SYMBOL(v4l2_ctrl_new_std);
2126 
2127 /* 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)2128 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
2129 			const struct v4l2_ctrl_ops *ops,
2130 			u32 id, u8 _max, u64 mask, u8 _def)
2131 {
2132 	const char * const *qmenu = NULL;
2133 	const s64 *qmenu_int = NULL;
2134 	unsigned int qmenu_int_len = 0;
2135 	const char *name;
2136 	enum v4l2_ctrl_type type;
2137 	s64 min;
2138 	s64 max = _max;
2139 	s64 def = _def;
2140 	u64 step;
2141 	u32 flags;
2142 
2143 	v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2144 
2145 	if (type == V4L2_CTRL_TYPE_MENU)
2146 		qmenu = v4l2_ctrl_get_menu(id);
2147 	else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
2148 		qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len);
2149 
2150 	if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) {
2151 		handler_set_err(hdl, -EINVAL);
2152 		return NULL;
2153 	}
2154 	return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2155 			     0, max, mask, def, NULL, 0,
2156 			     flags, qmenu, qmenu_int, NULL);
2157 }
2158 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
2159 
2160 /* 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)2161 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
2162 			const struct v4l2_ctrl_ops *ops, u32 id, u8 _max,
2163 			u64 mask, u8 _def, const char * const *qmenu)
2164 {
2165 	enum v4l2_ctrl_type type;
2166 	const char *name;
2167 	u32 flags;
2168 	u64 step;
2169 	s64 min;
2170 	s64 max = _max;
2171 	s64 def = _def;
2172 
2173 	/* v4l2_ctrl_new_std_menu_items() should only be called for
2174 	 * standard controls without a standard menu.
2175 	 */
2176 	if (v4l2_ctrl_get_menu(id)) {
2177 		handler_set_err(hdl, -EINVAL);
2178 		return NULL;
2179 	}
2180 
2181 	v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2182 	if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
2183 		handler_set_err(hdl, -EINVAL);
2184 		return NULL;
2185 	}
2186 	return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2187 			     0, max, mask, def, NULL, 0,
2188 			     flags, qmenu, NULL, NULL);
2189 
2190 }
2191 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
2192 
2193 /* 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)2194 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
2195 			const struct v4l2_ctrl_ops *ops,
2196 			u32 id, u8 _max, u8 _def, const s64 *qmenu_int)
2197 {
2198 	const char *name;
2199 	enum v4l2_ctrl_type type;
2200 	s64 min;
2201 	u64 step;
2202 	s64 max = _max;
2203 	s64 def = _def;
2204 	u32 flags;
2205 
2206 	v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
2207 	if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
2208 		handler_set_err(hdl, -EINVAL);
2209 		return NULL;
2210 	}
2211 	return v4l2_ctrl_new(hdl, ops, NULL, id, name, type,
2212 			     0, max, 0, def, NULL, 0,
2213 			     flags, NULL, qmenu_int, NULL);
2214 }
2215 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
2216 
2217 /* Add a control from another handler to this handler */
v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_ctrl * ctrl)2218 struct v4l2_ctrl *v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler *hdl,
2219 					  struct v4l2_ctrl *ctrl)
2220 {
2221 	if (hdl == NULL || hdl->error)
2222 		return NULL;
2223 	if (ctrl == NULL) {
2224 		handler_set_err(hdl, -EINVAL);
2225 		return NULL;
2226 	}
2227 	if (ctrl->handler == hdl)
2228 		return ctrl;
2229 	return handler_new_ref(hdl, ctrl) ? NULL : ctrl;
2230 }
2231 EXPORT_SYMBOL(v4l2_ctrl_add_ctrl);
2232 
2233 /* 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))2234 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
2235 			  struct v4l2_ctrl_handler *add,
2236 			  bool (*filter)(const struct v4l2_ctrl *ctrl))
2237 {
2238 	struct v4l2_ctrl_ref *ref;
2239 	int ret = 0;
2240 
2241 	/* Do nothing if either handler is NULL or if they are the same */
2242 	if (!hdl || !add || hdl == add)
2243 		return 0;
2244 	if (hdl->error)
2245 		return hdl->error;
2246 	mutex_lock(add->lock);
2247 	list_for_each_entry(ref, &add->ctrl_refs, node) {
2248 		struct v4l2_ctrl *ctrl = ref->ctrl;
2249 
2250 		/* Skip handler-private controls. */
2251 		if (ctrl->is_private)
2252 			continue;
2253 		/* And control classes */
2254 		if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2255 			continue;
2256 		/* Filter any unwanted controls */
2257 		if (filter && !filter(ctrl))
2258 			continue;
2259 		ret = handler_new_ref(hdl, ctrl);
2260 		if (ret)
2261 			break;
2262 	}
2263 	mutex_unlock(add->lock);
2264 	return ret;
2265 }
2266 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
2267 
v4l2_ctrl_radio_filter(const struct v4l2_ctrl * ctrl)2268 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
2269 {
2270 	if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
2271 		return true;
2272 	if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
2273 		return true;
2274 	switch (ctrl->id) {
2275 	case V4L2_CID_AUDIO_MUTE:
2276 	case V4L2_CID_AUDIO_VOLUME:
2277 	case V4L2_CID_AUDIO_BALANCE:
2278 	case V4L2_CID_AUDIO_BASS:
2279 	case V4L2_CID_AUDIO_TREBLE:
2280 	case V4L2_CID_AUDIO_LOUDNESS:
2281 		return true;
2282 	default:
2283 		break;
2284 	}
2285 	return false;
2286 }
2287 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
2288 
2289 /* Cluster controls */
v4l2_ctrl_cluster(unsigned ncontrols,struct v4l2_ctrl ** controls)2290 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
2291 {
2292 	bool has_volatiles = false;
2293 	int i;
2294 
2295 	/* The first control is the master control and it must not be NULL */
2296 	if (WARN_ON(ncontrols == 0 || controls[0] == NULL))
2297 		return;
2298 
2299 	for (i = 0; i < ncontrols; i++) {
2300 		if (controls[i]) {
2301 			controls[i]->cluster = controls;
2302 			controls[i]->ncontrols = ncontrols;
2303 			if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
2304 				has_volatiles = true;
2305 		}
2306 	}
2307 	controls[0]->has_volatiles = has_volatiles;
2308 }
2309 EXPORT_SYMBOL(v4l2_ctrl_cluster);
2310 
v4l2_ctrl_auto_cluster(unsigned ncontrols,struct v4l2_ctrl ** controls,u8 manual_val,bool set_volatile)2311 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
2312 			    u8 manual_val, bool set_volatile)
2313 {
2314 	struct v4l2_ctrl *master = controls[0];
2315 	u32 flag = 0;
2316 	int i;
2317 
2318 	v4l2_ctrl_cluster(ncontrols, controls);
2319 	WARN_ON(ncontrols <= 1);
2320 	WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
2321 	WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
2322 	master->is_auto = true;
2323 	master->has_volatiles = set_volatile;
2324 	master->manual_mode_value = manual_val;
2325 	master->flags |= V4L2_CTRL_FLAG_UPDATE;
2326 
2327 	if (!is_cur_manual(master))
2328 		flag = V4L2_CTRL_FLAG_INACTIVE |
2329 			(set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
2330 
2331 	for (i = 1; i < ncontrols; i++)
2332 		if (controls[i])
2333 			controls[i]->flags |= flag;
2334 }
2335 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
2336 
2337 /* Activate/deactivate a control. */
v4l2_ctrl_activate(struct v4l2_ctrl * ctrl,bool active)2338 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
2339 {
2340 	/* invert since the actual flag is called 'inactive' */
2341 	bool inactive = !active;
2342 	bool old;
2343 
2344 	if (ctrl == NULL)
2345 		return;
2346 
2347 	if (inactive)
2348 		/* set V4L2_CTRL_FLAG_INACTIVE */
2349 		old = test_and_set_bit(4, &ctrl->flags);
2350 	else
2351 		/* clear V4L2_CTRL_FLAG_INACTIVE */
2352 		old = test_and_clear_bit(4, &ctrl->flags);
2353 	if (old != inactive)
2354 		send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2355 }
2356 EXPORT_SYMBOL(v4l2_ctrl_activate);
2357 
2358 /* Grab/ungrab a control.
2359    Typically used when streaming starts and you want to grab controls,
2360    preventing the user from changing them.
2361 
2362    Just call this and the framework will block any attempts to change
2363    these controls. */
v4l2_ctrl_grab(struct v4l2_ctrl * ctrl,bool grabbed)2364 void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
2365 {
2366 	bool old;
2367 
2368 	if (ctrl == NULL)
2369 		return;
2370 
2371 	v4l2_ctrl_lock(ctrl);
2372 	if (grabbed)
2373 		/* set V4L2_CTRL_FLAG_GRABBED */
2374 		old = test_and_set_bit(1, &ctrl->flags);
2375 	else
2376 		/* clear V4L2_CTRL_FLAG_GRABBED */
2377 		old = test_and_clear_bit(1, &ctrl->flags);
2378 	if (old != grabbed)
2379 		send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
2380 	v4l2_ctrl_unlock(ctrl);
2381 }
2382 EXPORT_SYMBOL(v4l2_ctrl_grab);
2383 
2384 /* Log the control name and value */
log_ctrl(const struct v4l2_ctrl * ctrl,const char * prefix,const char * colon)2385 static void log_ctrl(const struct v4l2_ctrl *ctrl,
2386 		     const char *prefix, const char *colon)
2387 {
2388 	if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
2389 		return;
2390 	if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
2391 		return;
2392 
2393 	pr_info("%s%s%s: ", prefix, colon, ctrl->name);
2394 
2395 	ctrl->type_ops->log(ctrl);
2396 
2397 	if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
2398 			   V4L2_CTRL_FLAG_GRABBED |
2399 			   V4L2_CTRL_FLAG_VOLATILE)) {
2400 		if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
2401 			pr_cont(" inactive");
2402 		if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
2403 			pr_cont(" grabbed");
2404 		if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
2405 			pr_cont(" volatile");
2406 	}
2407 	pr_cont("\n");
2408 }
2409 
2410 /* Log all controls owned by the handler */
v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler * hdl,const char * prefix)2411 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
2412 				  const char *prefix)
2413 {
2414 	struct v4l2_ctrl *ctrl;
2415 	const char *colon = "";
2416 	int len;
2417 
2418 	if (hdl == NULL)
2419 		return;
2420 	if (prefix == NULL)
2421 		prefix = "";
2422 	len = strlen(prefix);
2423 	if (len && prefix[len - 1] != ' ')
2424 		colon = ": ";
2425 	mutex_lock(hdl->lock);
2426 	list_for_each_entry(ctrl, &hdl->ctrls, node)
2427 		if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2428 			log_ctrl(ctrl, prefix, colon);
2429 	mutex_unlock(hdl->lock);
2430 }
2431 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2432 
v4l2_ctrl_subdev_log_status(struct v4l2_subdev * sd)2433 int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
2434 {
2435 	v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
2436 	return 0;
2437 }
2438 EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
2439 
2440 /* Call s_ctrl for all controls owned by the handler */
v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler * hdl)2441 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2442 {
2443 	struct v4l2_ctrl *ctrl;
2444 	int ret = 0;
2445 
2446 	if (hdl == NULL)
2447 		return 0;
2448 	mutex_lock(hdl->lock);
2449 	list_for_each_entry(ctrl, &hdl->ctrls, node)
2450 		ctrl->done = false;
2451 
2452 	list_for_each_entry(ctrl, &hdl->ctrls, node) {
2453 		struct v4l2_ctrl *master = ctrl->cluster[0];
2454 		int i;
2455 
2456 		/* Skip if this control was already handled by a cluster. */
2457 		/* Skip button controls and read-only controls. */
2458 		if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2459 		    (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2460 			continue;
2461 
2462 		for (i = 0; i < master->ncontrols; i++) {
2463 			if (master->cluster[i]) {
2464 				cur_to_new(master->cluster[i]);
2465 				master->cluster[i]->is_new = 1;
2466 				master->cluster[i]->done = true;
2467 			}
2468 		}
2469 		ret = call_op(master, s_ctrl);
2470 		if (ret)
2471 			break;
2472 	}
2473 	mutex_unlock(hdl->lock);
2474 	return ret;
2475 }
2476 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2477 
2478 /* Implement VIDIOC_QUERY_EXT_CTRL */
v4l2_query_ext_ctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_query_ext_ctrl * qc)2479 int v4l2_query_ext_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_query_ext_ctrl *qc)
2480 {
2481 	const unsigned next_flags = V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND;
2482 	u32 id = qc->id & V4L2_CTRL_ID_MASK;
2483 	struct v4l2_ctrl_ref *ref;
2484 	struct v4l2_ctrl *ctrl;
2485 
2486 	if (hdl == NULL)
2487 		return -EINVAL;
2488 
2489 	mutex_lock(hdl->lock);
2490 
2491 	/* Try to find it */
2492 	ref = find_ref(hdl, id);
2493 
2494 	if ((qc->id & next_flags) && !list_empty(&hdl->ctrl_refs)) {
2495 		bool is_compound;
2496 		/* Match any control that is not hidden */
2497 		unsigned mask = 1;
2498 		bool match = false;
2499 
2500 		if ((qc->id & next_flags) == V4L2_CTRL_FLAG_NEXT_COMPOUND) {
2501 			/* Match any hidden control */
2502 			match = true;
2503 		} else if ((qc->id & next_flags) == next_flags) {
2504 			/* Match any control, compound or not */
2505 			mask = 0;
2506 		}
2507 
2508 		/* Find the next control with ID > qc->id */
2509 
2510 		/* Did we reach the end of the control list? */
2511 		if (id >= node2id(hdl->ctrl_refs.prev)) {
2512 			ref = NULL; /* Yes, so there is no next control */
2513 		} else if (ref) {
2514 			/* We found a control with the given ID, so just get
2515 			   the next valid one in the list. */
2516 			list_for_each_entry_continue(ref, &hdl->ctrl_refs, node) {
2517 				is_compound =
2518 					ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
2519 				if (id < ref->ctrl->id &&
2520 				    (is_compound & mask) == match)
2521 					break;
2522 			}
2523 			if (&ref->node == &hdl->ctrl_refs)
2524 				ref = NULL;
2525 		} else {
2526 			/* No control with the given ID exists, so start
2527 			   searching for the next largest ID. We know there
2528 			   is one, otherwise the first 'if' above would have
2529 			   been true. */
2530 			list_for_each_entry(ref, &hdl->ctrl_refs, node) {
2531 				is_compound =
2532 					ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
2533 				if (id < ref->ctrl->id &&
2534 				    (is_compound & mask) == match)
2535 					break;
2536 			}
2537 			if (&ref->node == &hdl->ctrl_refs)
2538 				ref = NULL;
2539 		}
2540 	}
2541 	mutex_unlock(hdl->lock);
2542 
2543 	if (!ref)
2544 		return -EINVAL;
2545 
2546 	ctrl = ref->ctrl;
2547 	memset(qc, 0, sizeof(*qc));
2548 	if (id >= V4L2_CID_PRIVATE_BASE)
2549 		qc->id = id;
2550 	else
2551 		qc->id = ctrl->id;
2552 	strlcpy(qc->name, ctrl->name, sizeof(qc->name));
2553 	qc->flags = user_flags(ctrl);
2554 	qc->type = ctrl->type;
2555 	qc->elem_size = ctrl->elem_size;
2556 	qc->elems = ctrl->elems;
2557 	qc->nr_of_dims = ctrl->nr_of_dims;
2558 	memcpy(qc->dims, ctrl->dims, qc->nr_of_dims * sizeof(qc->dims[0]));
2559 	qc->minimum = ctrl->minimum;
2560 	qc->maximum = ctrl->maximum;
2561 	qc->default_value = ctrl->default_value;
2562 	if (ctrl->type == V4L2_CTRL_TYPE_MENU
2563 	    || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
2564 		qc->step = 1;
2565 	else
2566 		qc->step = ctrl->step;
2567 	return 0;
2568 }
2569 EXPORT_SYMBOL(v4l2_query_ext_ctrl);
2570 
2571 /* Implement VIDIOC_QUERYCTRL */
v4l2_queryctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_queryctrl * qc)2572 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
2573 {
2574 	struct v4l2_query_ext_ctrl qec = { qc->id };
2575 	int rc;
2576 
2577 	rc = v4l2_query_ext_ctrl(hdl, &qec);
2578 	if (rc)
2579 		return rc;
2580 
2581 	qc->id = qec.id;
2582 	qc->type = qec.type;
2583 	qc->flags = qec.flags;
2584 	strlcpy(qc->name, qec.name, sizeof(qc->name));
2585 	switch (qc->type) {
2586 	case V4L2_CTRL_TYPE_INTEGER:
2587 	case V4L2_CTRL_TYPE_BOOLEAN:
2588 	case V4L2_CTRL_TYPE_MENU:
2589 	case V4L2_CTRL_TYPE_INTEGER_MENU:
2590 	case V4L2_CTRL_TYPE_STRING:
2591 	case V4L2_CTRL_TYPE_BITMASK:
2592 		qc->minimum = qec.minimum;
2593 		qc->maximum = qec.maximum;
2594 		qc->step = qec.step;
2595 		qc->default_value = qec.default_value;
2596 		break;
2597 	default:
2598 		qc->minimum = 0;
2599 		qc->maximum = 0;
2600 		qc->step = 0;
2601 		qc->default_value = 0;
2602 		break;
2603 	}
2604 	return 0;
2605 }
2606 EXPORT_SYMBOL(v4l2_queryctrl);
2607 
v4l2_subdev_queryctrl(struct v4l2_subdev * sd,struct v4l2_queryctrl * qc)2608 int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
2609 {
2610 	if (qc->id & (V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND))
2611 		return -EINVAL;
2612 	return v4l2_queryctrl(sd->ctrl_handler, qc);
2613 }
2614 EXPORT_SYMBOL(v4l2_subdev_queryctrl);
2615 
2616 /* Implement VIDIOC_QUERYMENU */
v4l2_querymenu(struct v4l2_ctrl_handler * hdl,struct v4l2_querymenu * qm)2617 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
2618 {
2619 	struct v4l2_ctrl *ctrl;
2620 	u32 i = qm->index;
2621 
2622 	ctrl = v4l2_ctrl_find(hdl, qm->id);
2623 	if (!ctrl)
2624 		return -EINVAL;
2625 
2626 	qm->reserved = 0;
2627 	/* Sanity checks */
2628 	switch (ctrl->type) {
2629 	case V4L2_CTRL_TYPE_MENU:
2630 		if (ctrl->qmenu == NULL)
2631 			return -EINVAL;
2632 		break;
2633 	case V4L2_CTRL_TYPE_INTEGER_MENU:
2634 		if (ctrl->qmenu_int == NULL)
2635 			return -EINVAL;
2636 		break;
2637 	default:
2638 		return -EINVAL;
2639 	}
2640 
2641 	if (i < ctrl->minimum || i > ctrl->maximum)
2642 		return -EINVAL;
2643 
2644 	/* Use mask to see if this menu item should be skipped */
2645 	if (ctrl->menu_skip_mask & (1 << i))
2646 		return -EINVAL;
2647 	/* Empty menu items should also be skipped */
2648 	if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
2649 		if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
2650 			return -EINVAL;
2651 		strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
2652 	} else {
2653 		qm->value = ctrl->qmenu_int[i];
2654 	}
2655 	return 0;
2656 }
2657 EXPORT_SYMBOL(v4l2_querymenu);
2658 
v4l2_subdev_querymenu(struct v4l2_subdev * sd,struct v4l2_querymenu * qm)2659 int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
2660 {
2661 	return v4l2_querymenu(sd->ctrl_handler, qm);
2662 }
2663 EXPORT_SYMBOL(v4l2_subdev_querymenu);
2664 
2665 
2666 
2667 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
2668 
2669    It is not a fully atomic operation, just best-effort only. After all, if
2670    multiple controls have to be set through multiple i2c writes (for example)
2671    then some initial writes may succeed while others fail. Thus leaving the
2672    system in an inconsistent state. The question is how much effort you are
2673    willing to spend on trying to make something atomic that really isn't.
2674 
2675    From the point of view of an application the main requirement is that
2676    when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
2677    error should be returned without actually affecting any controls.
2678 
2679    If all the values are correct, then it is acceptable to just give up
2680    in case of low-level errors.
2681 
2682    It is important though that the application can tell when only a partial
2683    configuration was done. The way we do that is through the error_idx field
2684    of struct v4l2_ext_controls: if that is equal to the count field then no
2685    controls were affected. Otherwise all controls before that index were
2686    successful in performing their 'get' or 'set' operation, the control at
2687    the given index failed, and you don't know what happened with the controls
2688    after the failed one. Since if they were part of a control cluster they
2689    could have been successfully processed (if a cluster member was encountered
2690    at index < error_idx), they could have failed (if a cluster member was at
2691    error_idx), or they may not have been processed yet (if the first cluster
2692    member appeared after error_idx).
2693 
2694    It is all fairly theoretical, though. In practice all you can do is to
2695    bail out. If error_idx == count, then it is an application bug. If
2696    error_idx < count then it is only an application bug if the error code was
2697    EBUSY. That usually means that something started streaming just when you
2698    tried to set the controls. In all other cases it is a driver/hardware
2699    problem and all you can do is to retry or bail out.
2700 
2701    Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
2702    never modifies controls the error_idx is just set to whatever control
2703    has an invalid value.
2704  */
2705 
2706 /* Prepare for the extended g/s/try functions.
2707    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)2708 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
2709 			     struct v4l2_ext_controls *cs,
2710 			     struct v4l2_ctrl_helper *helpers,
2711 			     bool get)
2712 {
2713 	struct v4l2_ctrl_helper *h;
2714 	bool have_clusters = false;
2715 	u32 i;
2716 
2717 	for (i = 0, h = helpers; i < cs->count; i++, h++) {
2718 		struct v4l2_ext_control *c = &cs->controls[i];
2719 		struct v4l2_ctrl_ref *ref;
2720 		struct v4l2_ctrl *ctrl;
2721 		u32 id = c->id & V4L2_CTRL_ID_MASK;
2722 
2723 		cs->error_idx = i;
2724 
2725 		if (cs->ctrl_class && V4L2_CTRL_ID2CLASS(id) != cs->ctrl_class)
2726 			return -EINVAL;
2727 
2728 		/* Old-style private controls are not allowed for
2729 		   extended controls */
2730 		if (id >= V4L2_CID_PRIVATE_BASE)
2731 			return -EINVAL;
2732 		ref = find_ref_lock(hdl, id);
2733 		if (ref == NULL)
2734 			return -EINVAL;
2735 		ctrl = ref->ctrl;
2736 		if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
2737 			return -EINVAL;
2738 
2739 		if (ctrl->cluster[0]->ncontrols > 1)
2740 			have_clusters = true;
2741 		if (ctrl->cluster[0] != ctrl)
2742 			ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
2743 		if (ctrl->is_ptr && !ctrl->is_string) {
2744 			unsigned tot_size = ctrl->elems * ctrl->elem_size;
2745 
2746 			if (c->size < tot_size) {
2747 				if (get) {
2748 					c->size = tot_size;
2749 					return -ENOSPC;
2750 				}
2751 				return -EFAULT;
2752 			}
2753 			c->size = tot_size;
2754 		}
2755 		/* Store the ref to the master control of the cluster */
2756 		h->mref = ref;
2757 		h->ctrl = ctrl;
2758 		/* Initially set next to 0, meaning that there is no other
2759 		   control in this helper array belonging to the same
2760 		   cluster */
2761 		h->next = 0;
2762 	}
2763 
2764 	/* We are done if there were no controls that belong to a multi-
2765 	   control cluster. */
2766 	if (!have_clusters)
2767 		return 0;
2768 
2769 	/* The code below figures out in O(n) time which controls in the list
2770 	   belong to the same cluster. */
2771 
2772 	/* This has to be done with the handler lock taken. */
2773 	mutex_lock(hdl->lock);
2774 
2775 	/* First zero the helper field in the master control references */
2776 	for (i = 0; i < cs->count; i++)
2777 		helpers[i].mref->helper = NULL;
2778 	for (i = 0, h = helpers; i < cs->count; i++, h++) {
2779 		struct v4l2_ctrl_ref *mref = h->mref;
2780 
2781 		/* If the mref->helper is set, then it points to an earlier
2782 		   helper that belongs to the same cluster. */
2783 		if (mref->helper) {
2784 			/* Set the next field of mref->helper to the current
2785 			   index: this means that that earlier helper now
2786 			   points to the next helper in the same cluster. */
2787 			mref->helper->next = i;
2788 			/* mref should be set only for the first helper in the
2789 			   cluster, clear the others. */
2790 			h->mref = NULL;
2791 		}
2792 		/* Point the mref helper to the current helper struct. */
2793 		mref->helper = h;
2794 	}
2795 	mutex_unlock(hdl->lock);
2796 	return 0;
2797 }
2798 
2799 /* Handles the corner case where cs->count == 0. It checks whether the
2800    specified control class exists. If that class ID is 0, then it checks
2801    whether there are any controls at all. */
class_check(struct v4l2_ctrl_handler * hdl,u32 ctrl_class)2802 static int class_check(struct v4l2_ctrl_handler *hdl, u32 ctrl_class)
2803 {
2804 	if (ctrl_class == 0)
2805 		return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
2806 	return find_ref_lock(hdl, ctrl_class | 1) ? 0 : -EINVAL;
2807 }
2808 
2809 
2810 
2811 /* Get extended controls. Allocates the helpers array if needed. */
v4l2_g_ext_ctrls(struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs)2812 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2813 {
2814 	struct v4l2_ctrl_helper helper[4];
2815 	struct v4l2_ctrl_helper *helpers = helper;
2816 	int ret;
2817 	int i, j;
2818 
2819 	cs->error_idx = cs->count;
2820 	cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2821 
2822 	if (hdl == NULL)
2823 		return -EINVAL;
2824 
2825 	if (cs->count == 0)
2826 		return class_check(hdl, cs->ctrl_class);
2827 
2828 	if (cs->count > ARRAY_SIZE(helper)) {
2829 		helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2830 					GFP_KERNEL);
2831 		if (helpers == NULL)
2832 			return -ENOMEM;
2833 	}
2834 
2835 	ret = prepare_ext_ctrls(hdl, cs, helpers, true);
2836 	cs->error_idx = cs->count;
2837 
2838 	for (i = 0; !ret && i < cs->count; i++)
2839 		if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2840 			ret = -EACCES;
2841 
2842 	for (i = 0; !ret && i < cs->count; i++) {
2843 		int (*ctrl_to_user)(struct v4l2_ext_control *c,
2844 				    struct v4l2_ctrl *ctrl) = cur_to_user;
2845 		struct v4l2_ctrl *master;
2846 
2847 		if (helpers[i].mref == NULL)
2848 			continue;
2849 
2850 		master = helpers[i].mref->ctrl;
2851 		cs->error_idx = i;
2852 
2853 		v4l2_ctrl_lock(master);
2854 
2855 		/* g_volatile_ctrl will update the new control values */
2856 		if ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
2857 			(master->has_volatiles && !is_cur_manual(master))) {
2858 			for (j = 0; j < master->ncontrols; j++)
2859 				cur_to_new(master->cluster[j]);
2860 			ret = call_op(master, g_volatile_ctrl);
2861 			ctrl_to_user = new_to_user;
2862 		}
2863 		/* If OK, then copy the current (for non-volatile controls)
2864 		   or the new (for volatile controls) control values to the
2865 		   caller */
2866 		if (!ret) {
2867 			u32 idx = i;
2868 
2869 			do {
2870 				ret = ctrl_to_user(cs->controls + idx,
2871 						   helpers[idx].ctrl);
2872 				idx = helpers[idx].next;
2873 			} while (!ret && idx);
2874 		}
2875 		v4l2_ctrl_unlock(master);
2876 	}
2877 
2878 	if (cs->count > ARRAY_SIZE(helper))
2879 		kfree(helpers);
2880 	return ret;
2881 }
2882 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
2883 
v4l2_subdev_g_ext_ctrls(struct v4l2_subdev * sd,struct v4l2_ext_controls * cs)2884 int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2885 {
2886 	return v4l2_g_ext_ctrls(sd->ctrl_handler, cs);
2887 }
2888 EXPORT_SYMBOL(v4l2_subdev_g_ext_ctrls);
2889 
2890 /* Helper function to get a single control */
get_ctrl(struct v4l2_ctrl * ctrl,struct v4l2_ext_control * c)2891 static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
2892 {
2893 	struct v4l2_ctrl *master = ctrl->cluster[0];
2894 	int ret = 0;
2895 	int i;
2896 
2897 	/* Compound controls are not supported. The new_to_user() and
2898 	 * cur_to_user() calls below would need to be modified not to access
2899 	 * userspace memory when called from get_ctrl().
2900 	 */
2901 	if (!ctrl->is_int)
2902 		return -EINVAL;
2903 
2904 	if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2905 		return -EACCES;
2906 
2907 	v4l2_ctrl_lock(master);
2908 	/* g_volatile_ctrl will update the current control values */
2909 	if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2910 		for (i = 0; i < master->ncontrols; i++)
2911 			cur_to_new(master->cluster[i]);
2912 		ret = call_op(master, g_volatile_ctrl);
2913 		new_to_user(c, ctrl);
2914 	} else {
2915 		cur_to_user(c, ctrl);
2916 	}
2917 	v4l2_ctrl_unlock(master);
2918 	return ret;
2919 }
2920 
v4l2_g_ctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_control * control)2921 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
2922 {
2923 	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2924 	struct v4l2_ext_control c;
2925 	int ret;
2926 
2927 	if (ctrl == NULL || !ctrl->is_int)
2928 		return -EINVAL;
2929 	ret = get_ctrl(ctrl, &c);
2930 	control->value = c.value;
2931 	return ret;
2932 }
2933 EXPORT_SYMBOL(v4l2_g_ctrl);
2934 
v4l2_subdev_g_ctrl(struct v4l2_subdev * sd,struct v4l2_control * control)2935 int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2936 {
2937 	return v4l2_g_ctrl(sd->ctrl_handler, control);
2938 }
2939 EXPORT_SYMBOL(v4l2_subdev_g_ctrl);
2940 
v4l2_ctrl_g_ctrl(struct v4l2_ctrl * ctrl)2941 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
2942 {
2943 	struct v4l2_ext_control c;
2944 
2945 	/* It's a driver bug if this happens. */
2946 	WARN_ON(!ctrl->is_int);
2947 	c.value = 0;
2948 	get_ctrl(ctrl, &c);
2949 	return c.value;
2950 }
2951 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
2952 
v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl * ctrl)2953 s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
2954 {
2955 	struct v4l2_ext_control c;
2956 
2957 	/* It's a driver bug if this happens. */
2958 	WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2959 	c.value = 0;
2960 	get_ctrl(ctrl, &c);
2961 	return c.value;
2962 }
2963 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
2964 
2965 
2966 /* Core function that calls try/s_ctrl and ensures that the new value is
2967    copied to the current value on a set.
2968    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)2969 static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
2970 			      bool set, u32 ch_flags)
2971 {
2972 	bool update_flag;
2973 	int ret;
2974 	int i;
2975 
2976 	/* Go through the cluster and either validate the new value or
2977 	   (if no new value was set), copy the current value to the new
2978 	   value, ensuring a consistent view for the control ops when
2979 	   called. */
2980 	for (i = 0; i < master->ncontrols; i++) {
2981 		struct v4l2_ctrl *ctrl = master->cluster[i];
2982 
2983 		if (ctrl == NULL)
2984 			continue;
2985 
2986 		if (!ctrl->is_new) {
2987 			cur_to_new(ctrl);
2988 			continue;
2989 		}
2990 		/* Check again: it may have changed since the
2991 		   previous check in try_or_set_ext_ctrls(). */
2992 		if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2993 			return -EBUSY;
2994 	}
2995 
2996 	ret = call_op(master, try_ctrl);
2997 
2998 	/* Don't set if there is no change */
2999 	if (ret || !set || !cluster_changed(master))
3000 		return ret;
3001 	ret = call_op(master, s_ctrl);
3002 	if (ret)
3003 		return ret;
3004 
3005 	/* If OK, then make the new values permanent. */
3006 	update_flag = is_cur_manual(master) != is_new_manual(master);
3007 	for (i = 0; i < master->ncontrols; i++)
3008 		new_to_cur(fh, master->cluster[i], ch_flags |
3009 			((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
3010 	return 0;
3011 }
3012 
3013 /* Validate controls. */
validate_ctrls(struct v4l2_ext_controls * cs,struct v4l2_ctrl_helper * helpers,bool set)3014 static int validate_ctrls(struct v4l2_ext_controls *cs,
3015 			  struct v4l2_ctrl_helper *helpers, bool set)
3016 {
3017 	unsigned i;
3018 	int ret = 0;
3019 
3020 	cs->error_idx = cs->count;
3021 	for (i = 0; i < cs->count; i++) {
3022 		struct v4l2_ctrl *ctrl = helpers[i].ctrl;
3023 
3024 		cs->error_idx = i;
3025 
3026 		if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
3027 			return -EACCES;
3028 		/* This test is also done in try_set_control_cluster() which
3029 		   is called in atomic context, so that has the final say,
3030 		   but it makes sense to do an up-front check as well. Once
3031 		   an error occurs in try_set_control_cluster() some other
3032 		   controls may have been set already and we want to do a
3033 		   best-effort to avoid that. */
3034 		if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
3035 			return -EBUSY;
3036 		ret = validate_new(ctrl, &cs->controls[i]);
3037 		if (ret)
3038 			return ret;
3039 	}
3040 	return 0;
3041 }
3042 
3043 /* Obtain the current volatile values of an autocluster and mark them
3044    as new. */
update_from_auto_cluster(struct v4l2_ctrl * master)3045 static void update_from_auto_cluster(struct v4l2_ctrl *master)
3046 {
3047 	int i;
3048 
3049 	for (i = 0; i < master->ncontrols; i++)
3050 		cur_to_new(master->cluster[i]);
3051 	if (!call_op(master, g_volatile_ctrl))
3052 		for (i = 1; i < master->ncontrols; i++)
3053 			if (master->cluster[i])
3054 				master->cluster[i]->is_new = 1;
3055 }
3056 
3057 /* 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)3058 static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3059 			     struct v4l2_ext_controls *cs,
3060 			     bool set)
3061 {
3062 	struct v4l2_ctrl_helper helper[4];
3063 	struct v4l2_ctrl_helper *helpers = helper;
3064 	unsigned i, j;
3065 	int ret;
3066 
3067 	cs->error_idx = cs->count;
3068 	cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
3069 
3070 	if (hdl == NULL)
3071 		return -EINVAL;
3072 
3073 	if (cs->count == 0)
3074 		return class_check(hdl, cs->ctrl_class);
3075 
3076 	if (cs->count > ARRAY_SIZE(helper)) {
3077 		helpers = kmalloc_array(cs->count, sizeof(helper[0]),
3078 					GFP_KERNEL);
3079 		if (!helpers)
3080 			return -ENOMEM;
3081 	}
3082 	ret = prepare_ext_ctrls(hdl, cs, helpers, false);
3083 	if (!ret)
3084 		ret = validate_ctrls(cs, helpers, set);
3085 	if (ret && set)
3086 		cs->error_idx = cs->count;
3087 	for (i = 0; !ret && i < cs->count; i++) {
3088 		struct v4l2_ctrl *master;
3089 		u32 idx = i;
3090 
3091 		if (helpers[i].mref == NULL)
3092 			continue;
3093 
3094 		cs->error_idx = i;
3095 		master = helpers[i].mref->ctrl;
3096 		v4l2_ctrl_lock(master);
3097 
3098 		/* Reset the 'is_new' flags of the cluster */
3099 		for (j = 0; j < master->ncontrols; j++)
3100 			if (master->cluster[j])
3101 				master->cluster[j]->is_new = 0;
3102 
3103 		/* For volatile autoclusters that are currently in auto mode
3104 		   we need to discover if it will be set to manual mode.
3105 		   If so, then we have to copy the current volatile values
3106 		   first since those will become the new manual values (which
3107 		   may be overwritten by explicit new values from this set
3108 		   of controls). */
3109 		if (master->is_auto && master->has_volatiles &&
3110 						!is_cur_manual(master)) {
3111 			/* Pick an initial non-manual value */
3112 			s32 new_auto_val = master->manual_mode_value + 1;
3113 			u32 tmp_idx = idx;
3114 
3115 			do {
3116 				/* Check if the auto control is part of the
3117 				   list, and remember the new value. */
3118 				if (helpers[tmp_idx].ctrl == master)
3119 					new_auto_val = cs->controls[tmp_idx].value;
3120 				tmp_idx = helpers[tmp_idx].next;
3121 			} while (tmp_idx);
3122 			/* If the new value == the manual value, then copy
3123 			   the current volatile values. */
3124 			if (new_auto_val == master->manual_mode_value)
3125 				update_from_auto_cluster(master);
3126 		}
3127 
3128 		/* Copy the new caller-supplied control values.
3129 		   user_to_new() sets 'is_new' to 1. */
3130 		do {
3131 			ret = user_to_new(cs->controls + idx, helpers[idx].ctrl);
3132 			idx = helpers[idx].next;
3133 		} while (!ret && idx);
3134 
3135 		if (!ret)
3136 			ret = try_or_set_cluster(fh, master, set, 0);
3137 
3138 		/* Copy the new values back to userspace. */
3139 		if (!ret) {
3140 			idx = i;
3141 			do {
3142 				ret = new_to_user(cs->controls + idx,
3143 						helpers[idx].ctrl);
3144 				idx = helpers[idx].next;
3145 			} while (!ret && idx);
3146 		}
3147 		v4l2_ctrl_unlock(master);
3148 	}
3149 
3150 	if (cs->count > ARRAY_SIZE(helper))
3151 		kfree(helpers);
3152 	return ret;
3153 }
3154 
v4l2_try_ext_ctrls(struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs)3155 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
3156 {
3157 	return try_set_ext_ctrls(NULL, hdl, cs, false);
3158 }
3159 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
3160 
v4l2_s_ext_ctrls(struct v4l2_fh * fh,struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs)3161 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3162 					struct v4l2_ext_controls *cs)
3163 {
3164 	return try_set_ext_ctrls(fh, hdl, cs, true);
3165 }
3166 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
3167 
v4l2_subdev_try_ext_ctrls(struct v4l2_subdev * sd,struct v4l2_ext_controls * cs)3168 int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
3169 {
3170 	return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, false);
3171 }
3172 EXPORT_SYMBOL(v4l2_subdev_try_ext_ctrls);
3173 
v4l2_subdev_s_ext_ctrls(struct v4l2_subdev * sd,struct v4l2_ext_controls * cs)3174 int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
3175 {
3176 	return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, true);
3177 }
3178 EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
3179 
3180 /* Helper function for VIDIOC_S_CTRL compatibility */
set_ctrl(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,struct v4l2_ext_control * c,u32 ch_flags)3181 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
3182 		    struct v4l2_ext_control *c, u32 ch_flags)
3183 {
3184 	struct v4l2_ctrl *master = ctrl->cluster[0];
3185 	int i;
3186 
3187 	/* Reset the 'is_new' flags of the cluster */
3188 	for (i = 0; i < master->ncontrols; i++)
3189 		if (master->cluster[i])
3190 			master->cluster[i]->is_new = 0;
3191 
3192 	if (c)
3193 		user_to_new(c, ctrl);
3194 
3195 	/* For autoclusters with volatiles that are switched from auto to
3196 	   manual mode we have to update the current volatile values since
3197 	   those will become the initial manual values after such a switch. */
3198 	if (master->is_auto && master->has_volatiles && ctrl == master &&
3199 	    !is_cur_manual(master) && ctrl->val == master->manual_mode_value)
3200 		update_from_auto_cluster(master);
3201 
3202 	ctrl->is_new = 1;
3203 	return try_or_set_cluster(fh, master, true, ch_flags);
3204 }
3205 
3206 /* Helper function for VIDIOC_S_CTRL compatibility */
set_ctrl_lock(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,struct v4l2_ext_control * c)3207 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
3208 			 struct v4l2_ext_control *c)
3209 {
3210 	int ret = validate_new(ctrl, c);
3211 
3212 	if (!ret) {
3213 		v4l2_ctrl_lock(ctrl);
3214 		ret = set_ctrl(fh, ctrl, c, 0);
3215 		if (!ret)
3216 			cur_to_user(c, ctrl);
3217 		v4l2_ctrl_unlock(ctrl);
3218 	}
3219 	return ret;
3220 }
3221 
v4l2_s_ctrl(struct v4l2_fh * fh,struct v4l2_ctrl_handler * hdl,struct v4l2_control * control)3222 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
3223 					struct v4l2_control *control)
3224 {
3225 	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
3226 	struct v4l2_ext_control c;
3227 	int ret;
3228 
3229 	if (ctrl == NULL || !ctrl->is_int)
3230 		return -EINVAL;
3231 
3232 	if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
3233 		return -EACCES;
3234 
3235 	c.value = control->value;
3236 	ret = set_ctrl_lock(fh, ctrl, &c);
3237 	control->value = c.value;
3238 	return ret;
3239 }
3240 EXPORT_SYMBOL(v4l2_s_ctrl);
3241 
v4l2_subdev_s_ctrl(struct v4l2_subdev * sd,struct v4l2_control * control)3242 int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
3243 {
3244 	return v4l2_s_ctrl(NULL, sd->ctrl_handler, control);
3245 }
3246 EXPORT_SYMBOL(v4l2_subdev_s_ctrl);
3247 
__v4l2_ctrl_s_ctrl(struct v4l2_ctrl * ctrl,s32 val)3248 int __v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
3249 {
3250 	lockdep_assert_held(ctrl->handler->lock);
3251 
3252 	/* It's a driver bug if this happens. */
3253 	WARN_ON(!ctrl->is_int);
3254 	ctrl->val = val;
3255 	return set_ctrl(NULL, ctrl, NULL, 0);
3256 }
3257 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl);
3258 
__v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl * ctrl,s64 val)3259 int __v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
3260 {
3261 	lockdep_assert_held(ctrl->handler->lock);
3262 
3263 	/* It's a driver bug if this happens. */
3264 	WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
3265 	*ctrl->p_new.p_s64 = val;
3266 	return set_ctrl(NULL, ctrl, NULL, 0);
3267 }
3268 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_int64);
3269 
__v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl * ctrl,const char * s)3270 int __v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl *ctrl, const char *s)
3271 {
3272 	lockdep_assert_held(ctrl->handler->lock);
3273 
3274 	/* It's a driver bug if this happens. */
3275 	WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING);
3276 	strlcpy(ctrl->p_new.p_char, s, ctrl->maximum + 1);
3277 	return set_ctrl(NULL, ctrl, NULL, 0);
3278 }
3279 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string);
3280 
v4l2_ctrl_notify(struct v4l2_ctrl * ctrl,v4l2_ctrl_notify_fnc notify,void * priv)3281 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
3282 {
3283 	if (ctrl == NULL)
3284 		return;
3285 	if (notify == NULL) {
3286 		ctrl->call_notify = 0;
3287 		return;
3288 	}
3289 	if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
3290 		return;
3291 	ctrl->handler->notify = notify;
3292 	ctrl->handler->notify_priv = priv;
3293 	ctrl->call_notify = 1;
3294 }
3295 EXPORT_SYMBOL(v4l2_ctrl_notify);
3296 
__v4l2_ctrl_modify_range(struct v4l2_ctrl * ctrl,s64 min,s64 max,u64 step,s64 def)3297 int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
3298 			s64 min, s64 max, u64 step, s64 def)
3299 {
3300 	int ret;
3301 	struct v4l2_ext_control c;
3302 
3303 	lockdep_assert_held(ctrl->handler->lock);
3304 
3305 	switch (ctrl->type) {
3306 	case V4L2_CTRL_TYPE_INTEGER:
3307 	case V4L2_CTRL_TYPE_INTEGER64:
3308 	case V4L2_CTRL_TYPE_BOOLEAN:
3309 	case V4L2_CTRL_TYPE_MENU:
3310 	case V4L2_CTRL_TYPE_INTEGER_MENU:
3311 	case V4L2_CTRL_TYPE_BITMASK:
3312 	case V4L2_CTRL_TYPE_U8:
3313 	case V4L2_CTRL_TYPE_U16:
3314 	case V4L2_CTRL_TYPE_U32:
3315 		if (ctrl->is_array)
3316 			return -EINVAL;
3317 		ret = check_range(ctrl->type, min, max, step, def);
3318 		if (ret)
3319 			return ret;
3320 		break;
3321 	default:
3322 		return -EINVAL;
3323 	}
3324 	ctrl->minimum = min;
3325 	ctrl->maximum = max;
3326 	ctrl->step = step;
3327 	ctrl->default_value = def;
3328 	c.value = *ctrl->p_cur.p_s32;
3329 	if (validate_new(ctrl, &c))
3330 		c.value = def;
3331 	if (c.value != *ctrl->p_cur.p_s32)
3332 		ret = set_ctrl(NULL, ctrl, &c, V4L2_EVENT_CTRL_CH_RANGE);
3333 	else
3334 		send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
3335 	return ret;
3336 }
3337 EXPORT_SYMBOL(__v4l2_ctrl_modify_range);
3338 
v4l2_ctrl_add_event(struct v4l2_subscribed_event * sev,unsigned elems)3339 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
3340 {
3341 	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
3342 
3343 	if (ctrl == NULL)
3344 		return -EINVAL;
3345 
3346 	v4l2_ctrl_lock(ctrl);
3347 	list_add_tail(&sev->node, &ctrl->ev_subs);
3348 	if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
3349 	    (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
3350 		struct v4l2_event ev;
3351 		u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
3352 
3353 		if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
3354 			changes |= V4L2_EVENT_CTRL_CH_VALUE;
3355 		fill_event(&ev, ctrl, changes);
3356 		/* Mark the queue as active, allowing this initial
3357 		   event to be accepted. */
3358 		sev->elems = elems;
3359 		v4l2_event_queue_fh(sev->fh, &ev);
3360 	}
3361 	v4l2_ctrl_unlock(ctrl);
3362 	return 0;
3363 }
3364 
v4l2_ctrl_del_event(struct v4l2_subscribed_event * sev)3365 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
3366 {
3367 	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
3368 
3369 	v4l2_ctrl_lock(ctrl);
3370 	list_del(&sev->node);
3371 	v4l2_ctrl_unlock(ctrl);
3372 }
3373 
v4l2_ctrl_replace(struct v4l2_event * old,const struct v4l2_event * new)3374 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
3375 {
3376 	u32 old_changes = old->u.ctrl.changes;
3377 
3378 	old->u.ctrl = new->u.ctrl;
3379 	old->u.ctrl.changes |= old_changes;
3380 }
3381 EXPORT_SYMBOL(v4l2_ctrl_replace);
3382 
v4l2_ctrl_merge(const struct v4l2_event * old,struct v4l2_event * new)3383 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
3384 {
3385 	new->u.ctrl.changes |= old->u.ctrl.changes;
3386 }
3387 EXPORT_SYMBOL(v4l2_ctrl_merge);
3388 
3389 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
3390 	.add = v4l2_ctrl_add_event,
3391 	.del = v4l2_ctrl_del_event,
3392 	.replace = v4l2_ctrl_replace,
3393 	.merge = v4l2_ctrl_merge,
3394 };
3395 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
3396 
v4l2_ctrl_log_status(struct file * file,void * fh)3397 int v4l2_ctrl_log_status(struct file *file, void *fh)
3398 {
3399 	struct video_device *vfd = video_devdata(file);
3400 	struct v4l2_fh *vfh = file->private_data;
3401 
3402 	if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
3403 		v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
3404 			vfd->v4l2_dev->name);
3405 	return 0;
3406 }
3407 EXPORT_SYMBOL(v4l2_ctrl_log_status);
3408 
v4l2_ctrl_subscribe_event(struct v4l2_fh * fh,const struct v4l2_event_subscription * sub)3409 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
3410 				const struct v4l2_event_subscription *sub)
3411 {
3412 	if (sub->type == V4L2_EVENT_CTRL)
3413 		return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
3414 	return -EINVAL;
3415 }
3416 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
3417 
v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev * sd,struct v4l2_fh * fh,struct v4l2_event_subscription * sub)3418 int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
3419 				     struct v4l2_event_subscription *sub)
3420 {
3421 	if (!sd->ctrl_handler)
3422 		return -EINVAL;
3423 	return v4l2_ctrl_subscribe_event(fh, sub);
3424 }
3425 EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
3426 
v4l2_ctrl_poll(struct file * file,struct poll_table_struct * wait)3427 unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
3428 {
3429 	struct v4l2_fh *fh = file->private_data;
3430 
3431 	if (v4l2_event_pending(fh))
3432 		return POLLPRI;
3433 	poll_wait(file, &fh->wait, wait);
3434 	return 0;
3435 }
3436 EXPORT_SYMBOL(v4l2_ctrl_poll);
3437