]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - drivers/media/v4l2-core/v4l2-ctrls.c
projects / mirror_ubuntu-focal-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[media] V4L: Add MATRIX option to V4L2_CID_EXPOSURE_METERING control
[mirror_ubuntu-focal-kernel.git] / drivers / media / v4l2-core / v4l2-ctrls.c
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. */
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. */
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. */
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 Efficency",
424 NULL,
425 };
426
427 static const char * const flash_led_mode[] = {
428 "Off",
429 "Flash",
430 "Torch",
431 NULL,
432 };
433 static const char * const flash_strobe_source[] = {
434 "Software",
435 "External",
436 NULL,
437 };
438
439 static const char * const jpeg_chroma_subsampling[] = {
440 "4:4:4",
441 "4:2:2",
442 "4:2:0",
443 "4:1:1",
444 "4:1:0",
445 "Gray",
446 NULL,
447 };
448 static const char * const dv_tx_mode[] = {
449 "DVI-D",
450 "HDMI",
451 NULL,
452 };
453 static const char * const dv_rgb_range[] = {
454 "Automatic",
455 "RGB limited range (16-235)",
456 "RGB full range (0-255)",
457 NULL,
458 };
459
460
461 switch (id) {
462 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
463 return mpeg_audio_sampling_freq;
464 case V4L2_CID_MPEG_AUDIO_ENCODING:
465 return mpeg_audio_encoding;
466 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
467 return mpeg_audio_l1_bitrate;
468 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
469 return mpeg_audio_l2_bitrate;
470 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
471 return mpeg_audio_l3_bitrate;
472 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
473 return mpeg_audio_ac3_bitrate;
474 case V4L2_CID_MPEG_AUDIO_MODE:
475 return mpeg_audio_mode;
476 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
477 return mpeg_audio_mode_extension;
478 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
479 return mpeg_audio_emphasis;
480 case V4L2_CID_MPEG_AUDIO_CRC:
481 return mpeg_audio_crc;
482 case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
483 case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
484 return mpeg_audio_dec_playback;
485 case V4L2_CID_MPEG_VIDEO_ENCODING:
486 return mpeg_video_encoding;
487 case V4L2_CID_MPEG_VIDEO_ASPECT:
488 return mpeg_video_aspect;
489 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
490 return mpeg_video_bitrate_mode;
491 case V4L2_CID_MPEG_STREAM_TYPE:
492 return mpeg_stream_type;
493 case V4L2_CID_MPEG_STREAM_VBI_FMT:
494 return mpeg_stream_vbi_fmt;
495 case V4L2_CID_POWER_LINE_FREQUENCY:
496 return camera_power_line_frequency;
497 case V4L2_CID_EXPOSURE_AUTO:
498 return camera_exposure_auto;
499 case V4L2_CID_EXPOSURE_METERING:
500 return camera_exposure_metering;
501 case V4L2_CID_AUTO_FOCUS_RANGE:
502 return camera_auto_focus_range;
503 case V4L2_CID_COLORFX:
504 return colorfx;
505 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
506 return auto_n_preset_white_balance;
507 case V4L2_CID_ISO_SENSITIVITY_AUTO:
508 return camera_iso_sensitivity_auto;
509 case V4L2_CID_SCENE_MODE:
510 return scene_mode;
511 case V4L2_CID_TUNE_PREEMPHASIS:
512 return tune_emphasis;
513 case V4L2_CID_TUNE_DEEMPHASIS:
514 return tune_emphasis;
515 case V4L2_CID_FLASH_LED_MODE:
516 return flash_led_mode;
517 case V4L2_CID_FLASH_STROBE_SOURCE:
518 return flash_strobe_source;
519 case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
520 return header_mode;
521 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
522 return multi_slice;
523 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
524 return entropy_mode;
525 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
526 return mpeg_h264_level;
527 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
528 return h264_loop_filter;
529 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
530 return h264_profile;
531 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
532 return vui_sar_idc;
533 case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
534 return h264_fp_arrangement_type;
535 case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
536 return h264_fmo_map_type;
537 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
538 return mpeg_mpeg4_level;
539 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
540 return mpeg4_profile;
541 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
542 return jpeg_chroma_subsampling;
543 case V4L2_CID_DV_TX_MODE:
544 return dv_tx_mode;
545 case V4L2_CID_DV_TX_RGB_RANGE:
546 case V4L2_CID_DV_RX_RGB_RANGE:
547 return dv_rgb_range;
548
549 default:
550 return NULL;
551 }
552 }
553 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
554
555 /* Return the control name. */
556 const char *v4l2_ctrl_get_name(u32 id)
557 {
558 switch (id) {
559 /* USER controls */
560 /* Keep the order of the 'case's the same as in videodev2.h! */
561 case V4L2_CID_USER_CLASS: return "User Controls";
562 case V4L2_CID_BRIGHTNESS: return "Brightness";
563 case V4L2_CID_CONTRAST: return "Contrast";
564 case V4L2_CID_SATURATION: return "Saturation";
565 case V4L2_CID_HUE: return "Hue";
566 case V4L2_CID_AUDIO_VOLUME: return "Volume";
567 case V4L2_CID_AUDIO_BALANCE: return "Balance";
568 case V4L2_CID_AUDIO_BASS: return "Bass";
569 case V4L2_CID_AUDIO_TREBLE: return "Treble";
570 case V4L2_CID_AUDIO_MUTE: return "Mute";
571 case V4L2_CID_AUDIO_LOUDNESS: return "Loudness";
572 case V4L2_CID_BLACK_LEVEL: return "Black Level";
573 case V4L2_CID_AUTO_WHITE_BALANCE: return "White Balance, Automatic";
574 case V4L2_CID_DO_WHITE_BALANCE: return "Do White Balance";
575 case V4L2_CID_RED_BALANCE: return "Red Balance";
576 case V4L2_CID_BLUE_BALANCE: return "Blue Balance";
577 case V4L2_CID_GAMMA: return "Gamma";
578 case V4L2_CID_EXPOSURE: return "Exposure";
579 case V4L2_CID_AUTOGAIN: return "Gain, Automatic";
580 case V4L2_CID_GAIN: return "Gain";
581 case V4L2_CID_HFLIP: return "Horizontal Flip";
582 case V4L2_CID_VFLIP: return "Vertical Flip";
583 case V4L2_CID_POWER_LINE_FREQUENCY: return "Power Line Frequency";
584 case V4L2_CID_HUE_AUTO: return "Hue, Automatic";
585 case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
586 case V4L2_CID_SHARPNESS: return "Sharpness";
587 case V4L2_CID_BACKLIGHT_COMPENSATION: return "Backlight Compensation";
588 case V4L2_CID_CHROMA_AGC: return "Chroma AGC";
589 case V4L2_CID_COLOR_KILLER: return "Color Killer";
590 case V4L2_CID_COLORFX: return "Color Effects";
591 case V4L2_CID_AUTOBRIGHTNESS: return "Brightness, Automatic";
592 case V4L2_CID_BAND_STOP_FILTER: return "Band-Stop Filter";
593 case V4L2_CID_ROTATE: return "Rotate";
594 case V4L2_CID_BG_COLOR: return "Background Color";
595 case V4L2_CID_CHROMA_GAIN: return "Chroma Gain";
596 case V4L2_CID_ILLUMINATORS_1: return "Illuminator 1";
597 case V4L2_CID_ILLUMINATORS_2: return "Illuminator 2";
598 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE: return "Min Number of Capture Buffers";
599 case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT: return "Min Number of Output Buffers";
600 case V4L2_CID_ALPHA_COMPONENT: return "Alpha Component";
601 case V4L2_CID_COLORFX_CBCR: return "Color Effects, CbCr";
602
603 /* MPEG controls */
604 /* Keep the order of the 'case's the same as in videodev2.h! */
605 case V4L2_CID_MPEG_CLASS: return "MPEG Encoder Controls";
606 case V4L2_CID_MPEG_STREAM_TYPE: return "Stream Type";
607 case V4L2_CID_MPEG_STREAM_PID_PMT: return "Stream PMT Program ID";
608 case V4L2_CID_MPEG_STREAM_PID_AUDIO: return "Stream Audio Program ID";
609 case V4L2_CID_MPEG_STREAM_PID_VIDEO: return "Stream Video Program ID";
610 case V4L2_CID_MPEG_STREAM_PID_PCR: return "Stream PCR Program ID";
611 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
612 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
613 case V4L2_CID_MPEG_STREAM_VBI_FMT: return "Stream VBI Format";
614 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
615 case V4L2_CID_MPEG_AUDIO_ENCODING: return "Audio Encoding";
616 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: return "Audio Layer I Bitrate";
617 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: return "Audio Layer II Bitrate";
618 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: return "Audio Layer III Bitrate";
619 case V4L2_CID_MPEG_AUDIO_MODE: return "Audio Stereo Mode";
620 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
621 case V4L2_CID_MPEG_AUDIO_EMPHASIS: return "Audio Emphasis";
622 case V4L2_CID_MPEG_AUDIO_CRC: return "Audio CRC";
623 case V4L2_CID_MPEG_AUDIO_MUTE: return "Audio Mute";
624 case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate";
625 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: return "Audio AC-3 Bitrate";
626 case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK: return "Audio Playback";
627 case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: return "Audio Multilingual Playback";
628 case V4L2_CID_MPEG_VIDEO_ENCODING: return "Video Encoding";
629 case V4L2_CID_MPEG_VIDEO_ASPECT: return "Video Aspect";
630 case V4L2_CID_MPEG_VIDEO_B_FRAMES: return "Video B Frames";
631 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: return "Video GOP Size";
632 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: return "Video GOP Closure";
633 case V4L2_CID_MPEG_VIDEO_PULLDOWN: return "Video Pulldown";
634 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: return "Video Bitrate Mode";
635 case V4L2_CID_MPEG_VIDEO_BITRATE: return "Video Bitrate";
636 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: return "Video Peak Bitrate";
637 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
638 case V4L2_CID_MPEG_VIDEO_MUTE: return "Video Mute";
639 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: return "Video Mute YUV";
640 case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE: return "Decoder Slice Interface";
641 case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER: return "MPEG4 Loop Filter Enable";
642 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB: return "Number of Intra Refresh MBs";
643 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE: return "Frame Level Rate Control Enable";
644 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE: return "H264 MB Level Rate Control";
645 case V4L2_CID_MPEG_VIDEO_HEADER_MODE: return "Sequence Header Mode";
646 case V4L2_CID_MPEG_VIDEO_MAX_REF_PIC: return "Max Number of Reference Pics";
647 case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP: return "H263 I-Frame QP Value";
648 case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP: return "H263 P-Frame QP Value";
649 case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP: return "H263 B-Frame QP Value";
650 case V4L2_CID_MPEG_VIDEO_H263_MIN_QP: return "H263 Minimum QP Value";
651 case V4L2_CID_MPEG_VIDEO_H263_MAX_QP: return "H263 Maximum QP Value";
652 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP: return "H264 I-Frame QP Value";
653 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP: return "H264 P-Frame QP Value";
654 case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP: return "H264 B-Frame QP Value";
655 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP: return "H264 Maximum QP Value";
656 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP: return "H264 Minimum QP Value";
657 case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM: return "H264 8x8 Transform Enable";
658 case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE: return "H264 CPB Buffer Size";
659 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE: return "H264 Entropy Mode";
660 case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD: return "H264 I-Frame Period";
661 case V4L2_CID_MPEG_VIDEO_H264_LEVEL: return "H264 Level";
662 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA: return "H264 Loop Filter Alpha Offset";
663 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA: return "H264 Loop Filter Beta Offset";
664 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE: return "H264 Loop Filter Mode";
665 case V4L2_CID_MPEG_VIDEO_H264_PROFILE: return "H264 Profile";
666 case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT: return "Vertical Size of SAR";
667 case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH: return "Horizontal Size of SAR";
668 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE: return "Aspect Ratio VUI Enable";
669 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC: return "VUI Aspect Ratio IDC";
670 case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING: return "H264 Enable Frame Packing SEI";
671 case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0: return "H264 Set Curr. Frame as Frame0";
672 case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE: return "H264 FP Arrangement Type";
673 case V4L2_CID_MPEG_VIDEO_H264_FMO: return "H264 Flexible MB Ordering";
674 case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE: return "H264 Map Type for FMO";
675 case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP: return "H264 FMO Number of Slice Groups";
676 case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION: return "H264 FMO Direction of Change";
677 case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE: return "H264 FMO Size of 1st Slice Grp";
678 case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH: return "H264 FMO No. of Consecutive MBs";
679 case V4L2_CID_MPEG_VIDEO_H264_ASO: return "H264 Arbitrary Slice Ordering";
680 case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER: return "H264 ASO Slice Order";
681 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING: return "Enable H264 Hierarchical Coding";
682 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE: return "H264 Hierarchical Coding Type";
683 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:return "H264 Number of HC Layers";
684 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP:
685 return "H264 Set QP Value for HC Layers";
686 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP: return "MPEG4 I-Frame QP Value";
687 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP: return "MPEG4 P-Frame QP Value";
688 case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP: return "MPEG4 B-Frame QP Value";
689 case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP: return "MPEG4 Minimum QP Value";
690 case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP: return "MPEG4 Maximum QP Value";
691 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL: return "MPEG4 Level";
692 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE: return "MPEG4 Profile";
693 case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL: return "Quarter Pixel Search Enable";
694 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES: return "Maximum Bytes in a Slice";
695 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB: return "Number of MBs in a Slice";
696 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: return "Slice Partitioning Method";
697 case V4L2_CID_MPEG_VIDEO_VBV_SIZE: return "VBV Buffer Size";
698 case V4L2_CID_MPEG_VIDEO_DEC_PTS: return "Video Decoder PTS";
699 case V4L2_CID_MPEG_VIDEO_DEC_FRAME: return "Video Decoder Frame Count";
700 case V4L2_CID_MPEG_VIDEO_VBV_DELAY: return "Initial Delay for VBV Control";
701 case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER: return "Repeat Sequence Header";
702
703 /* CAMERA controls */
704 /* Keep the order of the 'case's the same as in videodev2.h! */
705 case V4L2_CID_CAMERA_CLASS: return "Camera Controls";
706 case V4L2_CID_EXPOSURE_AUTO: return "Auto Exposure";
707 case V4L2_CID_EXPOSURE_ABSOLUTE: return "Exposure Time, Absolute";
708 case V4L2_CID_EXPOSURE_AUTO_PRIORITY: return "Exposure, Dynamic Framerate";
709 case V4L2_CID_PAN_RELATIVE: return "Pan, Relative";
710 case V4L2_CID_TILT_RELATIVE: return "Tilt, Relative";
711 case V4L2_CID_PAN_RESET: return "Pan, Reset";
712 case V4L2_CID_TILT_RESET: return "Tilt, Reset";
713 case V4L2_CID_PAN_ABSOLUTE: return "Pan, Absolute";
714 case V4L2_CID_TILT_ABSOLUTE: return "Tilt, Absolute";
715 case V4L2_CID_FOCUS_ABSOLUTE: return "Focus, Absolute";
716 case V4L2_CID_FOCUS_RELATIVE: return "Focus, Relative";
717 case V4L2_CID_FOCUS_AUTO: return "Focus, Automatic Continuous";
718 case V4L2_CID_ZOOM_ABSOLUTE: return "Zoom, Absolute";
719 case V4L2_CID_ZOOM_RELATIVE: return "Zoom, Relative";
720 case V4L2_CID_ZOOM_CONTINUOUS: return "Zoom, Continuous";
721 case V4L2_CID_PRIVACY: return "Privacy";
722 case V4L2_CID_IRIS_ABSOLUTE: return "Iris, Absolute";
723 case V4L2_CID_IRIS_RELATIVE: return "Iris, Relative";
724 case V4L2_CID_AUTO_EXPOSURE_BIAS: return "Auto Exposure, Bias";
725 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset";
726 case V4L2_CID_WIDE_DYNAMIC_RANGE: return "Wide Dynamic Range";
727 case V4L2_CID_IMAGE_STABILIZATION: return "Image Stabilization";
728 case V4L2_CID_ISO_SENSITIVITY: return "ISO Sensitivity";
729 case V4L2_CID_ISO_SENSITIVITY_AUTO: return "ISO Sensitivity, Auto";
730 case V4L2_CID_EXPOSURE_METERING: return "Exposure, Metering Mode";
731 case V4L2_CID_SCENE_MODE: return "Scene Mode";
732 case V4L2_CID_3A_LOCK: return "3A Lock";
733 case V4L2_CID_AUTO_FOCUS_START: return "Auto Focus, Start";
734 case V4L2_CID_AUTO_FOCUS_STOP: return "Auto Focus, Stop";
735 case V4L2_CID_AUTO_FOCUS_STATUS: return "Auto Focus, Status";
736 case V4L2_CID_AUTO_FOCUS_RANGE: return "Auto Focus, Range";
737
738 /* FM Radio Modulator control */
739 /* Keep the order of the 'case's the same as in videodev2.h! */
740 case V4L2_CID_FM_TX_CLASS: return "FM Radio Modulator Controls";
741 case V4L2_CID_RDS_TX_DEVIATION: return "RDS Signal Deviation";
742 case V4L2_CID_RDS_TX_PI: return "RDS Program ID";
743 case V4L2_CID_RDS_TX_PTY: return "RDS Program Type";
744 case V4L2_CID_RDS_TX_PS_NAME: return "RDS PS Name";
745 case V4L2_CID_RDS_TX_RADIO_TEXT: return "RDS Radio Text";
746 case V4L2_CID_AUDIO_LIMITER_ENABLED: return "Audio Limiter Feature Enabled";
747 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
748 case V4L2_CID_AUDIO_LIMITER_DEVIATION: return "Audio Limiter Deviation";
749 case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled";
750 case V4L2_CID_AUDIO_COMPRESSION_GAIN: return "Audio Compression Gain";
751 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
752 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
753 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
754 case V4L2_CID_PILOT_TONE_ENABLED: return "Pilot Tone Feature Enabled";
755 case V4L2_CID_PILOT_TONE_DEVIATION: return "Pilot Tone Deviation";
756 case V4L2_CID_PILOT_TONE_FREQUENCY: return "Pilot Tone Frequency";
757 case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-Emphasis";
758 case V4L2_CID_TUNE_POWER_LEVEL: return "Tune Power Level";
759 case V4L2_CID_TUNE_ANTENNA_CAPACITOR: return "Tune Antenna Capacitor";
760
761 /* Flash controls */
762 case V4L2_CID_FLASH_CLASS: return "Flash Controls";
763 case V4L2_CID_FLASH_LED_MODE: return "LED Mode";
764 case V4L2_CID_FLASH_STROBE_SOURCE: return "Strobe Source";
765 case V4L2_CID_FLASH_STROBE: return "Strobe";
766 case V4L2_CID_FLASH_STROBE_STOP: return "Stop Strobe";
767 case V4L2_CID_FLASH_STROBE_STATUS: return "Strobe Status";
768 case V4L2_CID_FLASH_TIMEOUT: return "Strobe Timeout";
769 case V4L2_CID_FLASH_INTENSITY: return "Intensity, Flash Mode";
770 case V4L2_CID_FLASH_TORCH_INTENSITY: return "Intensity, Torch Mode";
771 case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator";
772 case V4L2_CID_FLASH_FAULT: return "Faults";
773 case V4L2_CID_FLASH_CHARGE: return "Charge";
774 case V4L2_CID_FLASH_READY: return "Ready to Strobe";
775
776 /* JPEG encoder controls */
777 /* Keep the order of the 'case's the same as in videodev2.h! */
778 case V4L2_CID_JPEG_CLASS: return "JPEG Compression Controls";
779 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: return "Chroma Subsampling";
780 case V4L2_CID_JPEG_RESTART_INTERVAL: return "Restart Interval";
781 case V4L2_CID_JPEG_COMPRESSION_QUALITY: return "Compression Quality";
782 case V4L2_CID_JPEG_ACTIVE_MARKER: return "Active Markers";
783
784 /* Image source controls */
785 case V4L2_CID_IMAGE_SOURCE_CLASS: return "Image Source Controls";
786 case V4L2_CID_VBLANK: return "Vertical Blanking";
787 case V4L2_CID_HBLANK: return "Horizontal Blanking";
788 case V4L2_CID_ANALOGUE_GAIN: return "Analogue Gain";
789
790 /* Image processing controls */
791 case V4L2_CID_IMAGE_PROC_CLASS: return "Image Processing Controls";
792 case V4L2_CID_LINK_FREQ: return "Link Frequency";
793 case V4L2_CID_PIXEL_RATE: return "Pixel Rate";
794 case V4L2_CID_TEST_PATTERN: return "Test Pattern";
795
796 /* DV controls */
797 case V4L2_CID_DV_CLASS: return "Digital Video Controls";
798 case V4L2_CID_DV_TX_HOTPLUG: return "Hotplug Present";
799 case V4L2_CID_DV_TX_RXSENSE: return "RxSense Present";
800 case V4L2_CID_DV_TX_EDID_PRESENT: return "EDID Present";
801 case V4L2_CID_DV_TX_MODE: return "Transmit Mode";
802 case V4L2_CID_DV_TX_RGB_RANGE: return "Tx RGB Quantization Range";
803 case V4L2_CID_DV_RX_POWER_PRESENT: return "Power Present";
804 case V4L2_CID_DV_RX_RGB_RANGE: return "Rx RGB Quantization Range";
805
806 case V4L2_CID_FM_RX_CLASS: return "FM Radio Receiver Controls";
807 case V4L2_CID_TUNE_DEEMPHASIS: return "De-Emphasis";
808 case V4L2_CID_RDS_RECEPTION: return "RDS Reception";
809 default:
810 return NULL;
811 }
812 }
813 EXPORT_SYMBOL(v4l2_ctrl_get_name);
814
815 void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
816 s32 *min, s32 *max, s32 *step, s32 *def, u32 *flags)
817 {
818 *name = v4l2_ctrl_get_name(id);
819 *flags = 0;
820
821 switch (id) {
822 case V4L2_CID_AUDIO_MUTE:
823 case V4L2_CID_AUDIO_LOUDNESS:
824 case V4L2_CID_AUTO_WHITE_BALANCE:
825 case V4L2_CID_AUTOGAIN:
826 case V4L2_CID_HFLIP:
827 case V4L2_CID_VFLIP:
828 case V4L2_CID_HUE_AUTO:
829 case V4L2_CID_CHROMA_AGC:
830 case V4L2_CID_COLOR_KILLER:
831 case V4L2_CID_AUTOBRIGHTNESS:
832 case V4L2_CID_MPEG_AUDIO_MUTE:
833 case V4L2_CID_MPEG_VIDEO_MUTE:
834 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
835 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
836 case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
837 case V4L2_CID_FOCUS_AUTO:
838 case V4L2_CID_PRIVACY:
839 case V4L2_CID_AUDIO_LIMITER_ENABLED:
840 case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
841 case V4L2_CID_PILOT_TONE_ENABLED:
842 case V4L2_CID_ILLUMINATORS_1:
843 case V4L2_CID_ILLUMINATORS_2:
844 case V4L2_CID_FLASH_STROBE_STATUS:
845 case V4L2_CID_FLASH_CHARGE:
846 case V4L2_CID_FLASH_READY:
847 case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
848 case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
849 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
850 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
851 case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
852 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
853 case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
854 case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:
855 case V4L2_CID_WIDE_DYNAMIC_RANGE:
856 case V4L2_CID_IMAGE_STABILIZATION:
857 case V4L2_CID_RDS_RECEPTION:
858 *type = V4L2_CTRL_TYPE_BOOLEAN;
859 *min = 0;
860 *max = *step = 1;
861 break;
862 case V4L2_CID_PAN_RESET:
863 case V4L2_CID_TILT_RESET:
864 case V4L2_CID_FLASH_STROBE:
865 case V4L2_CID_FLASH_STROBE_STOP:
866 case V4L2_CID_AUTO_FOCUS_START:
867 case V4L2_CID_AUTO_FOCUS_STOP:
868 *type = V4L2_CTRL_TYPE_BUTTON;
869 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
870 *min = *max = *step = *def = 0;
871 break;
872 case V4L2_CID_POWER_LINE_FREQUENCY:
873 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
874 case V4L2_CID_MPEG_AUDIO_ENCODING:
875 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
876 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
877 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
878 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
879 case V4L2_CID_MPEG_AUDIO_MODE:
880 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
881 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
882 case V4L2_CID_MPEG_AUDIO_CRC:
883 case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
884 case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
885 case V4L2_CID_MPEG_VIDEO_ENCODING:
886 case V4L2_CID_MPEG_VIDEO_ASPECT:
887 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
888 case V4L2_CID_MPEG_STREAM_TYPE:
889 case V4L2_CID_MPEG_STREAM_VBI_FMT:
890 case V4L2_CID_EXPOSURE_AUTO:
891 case V4L2_CID_AUTO_FOCUS_RANGE:
892 case V4L2_CID_COLORFX:
893 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
894 case V4L2_CID_TUNE_PREEMPHASIS:
895 case V4L2_CID_FLASH_LED_MODE:
896 case V4L2_CID_FLASH_STROBE_SOURCE:
897 case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
898 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
899 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
900 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
901 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
902 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
903 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
904 case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
905 case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
906 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
907 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
908 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
909 case V4L2_CID_ISO_SENSITIVITY_AUTO:
910 case V4L2_CID_EXPOSURE_METERING:
911 case V4L2_CID_SCENE_MODE:
912 case V4L2_CID_DV_TX_MODE:
913 case V4L2_CID_DV_TX_RGB_RANGE:
914 case V4L2_CID_DV_RX_RGB_RANGE:
915 case V4L2_CID_TEST_PATTERN:
916 case V4L2_CID_TUNE_DEEMPHASIS:
917 *type = V4L2_CTRL_TYPE_MENU;
918 break;
919 case V4L2_CID_LINK_FREQ:
920 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
921 break;
922 case V4L2_CID_RDS_TX_PS_NAME:
923 case V4L2_CID_RDS_TX_RADIO_TEXT:
924 *type = V4L2_CTRL_TYPE_STRING;
925 break;
926 case V4L2_CID_ISO_SENSITIVITY:
927 case V4L2_CID_AUTO_EXPOSURE_BIAS:
928 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
929 break;
930 case V4L2_CID_USER_CLASS:
931 case V4L2_CID_CAMERA_CLASS:
932 case V4L2_CID_MPEG_CLASS:
933 case V4L2_CID_FM_TX_CLASS:
934 case V4L2_CID_FLASH_CLASS:
935 case V4L2_CID_JPEG_CLASS:
936 case V4L2_CID_IMAGE_SOURCE_CLASS:
937 case V4L2_CID_IMAGE_PROC_CLASS:
938 case V4L2_CID_DV_CLASS:
939 case V4L2_CID_FM_RX_CLASS:
940 *type = V4L2_CTRL_TYPE_CTRL_CLASS;
941 /* You can neither read not write these */
942 *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
943 *min = *max = *step = *def = 0;
944 break;
945 case V4L2_CID_BG_COLOR:
946 *type = V4L2_CTRL_TYPE_INTEGER;
947 *step = 1;
948 *min = 0;
949 /* Max is calculated as RGB888 that is 2^24 */
950 *max = 0xFFFFFF;
951 break;
952 case V4L2_CID_FLASH_FAULT:
953 case V4L2_CID_JPEG_ACTIVE_MARKER:
954 case V4L2_CID_3A_LOCK:
955 case V4L2_CID_AUTO_FOCUS_STATUS:
956 case V4L2_CID_DV_TX_HOTPLUG:
957 case V4L2_CID_DV_TX_RXSENSE:
958 case V4L2_CID_DV_TX_EDID_PRESENT:
959 case V4L2_CID_DV_RX_POWER_PRESENT:
960 *type = V4L2_CTRL_TYPE_BITMASK;
961 break;
962 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
963 case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
964 *type = V4L2_CTRL_TYPE_INTEGER;
965 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
966 break;
967 case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
968 case V4L2_CID_MPEG_VIDEO_DEC_PTS:
969 *flags |= V4L2_CTRL_FLAG_VOLATILE;
970 /* Fall through */
971 case V4L2_CID_PIXEL_RATE:
972 *type = V4L2_CTRL_TYPE_INTEGER64;
973 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
974 *min = *max = *step = *def = 0;
975 break;
976 default:
977 *type = V4L2_CTRL_TYPE_INTEGER;
978 break;
979 }
980 switch (id) {
981 case V4L2_CID_MPEG_AUDIO_ENCODING:
982 case V4L2_CID_MPEG_AUDIO_MODE:
983 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
984 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
985 case V4L2_CID_MPEG_STREAM_TYPE:
986 *flags |= V4L2_CTRL_FLAG_UPDATE;
987 break;
988 case V4L2_CID_AUDIO_VOLUME:
989 case V4L2_CID_AUDIO_BALANCE:
990 case V4L2_CID_AUDIO_BASS:
991 case V4L2_CID_AUDIO_TREBLE:
992 case V4L2_CID_BRIGHTNESS:
993 case V4L2_CID_CONTRAST:
994 case V4L2_CID_SATURATION:
995 case V4L2_CID_HUE:
996 case V4L2_CID_RED_BALANCE:
997 case V4L2_CID_BLUE_BALANCE:
998 case V4L2_CID_GAMMA:
999 case V4L2_CID_SHARPNESS:
1000 case V4L2_CID_CHROMA_GAIN:
1001 case V4L2_CID_RDS_TX_DEVIATION:
1002 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1003 case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1004 case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1005 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1006 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1007 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1008 case V4L2_CID_PILOT_TONE_DEVIATION:
1009 case V4L2_CID_PILOT_TONE_FREQUENCY:
1010 case V4L2_CID_TUNE_POWER_LEVEL:
1011 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1012 *flags |= V4L2_CTRL_FLAG_SLIDER;
1013 break;
1014 case V4L2_CID_PAN_RELATIVE:
1015 case V4L2_CID_TILT_RELATIVE:
1016 case V4L2_CID_FOCUS_RELATIVE:
1017 case V4L2_CID_IRIS_RELATIVE:
1018 case V4L2_CID_ZOOM_RELATIVE:
1019 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1020 break;
1021 case V4L2_CID_FLASH_STROBE_STATUS:
1022 case V4L2_CID_AUTO_FOCUS_STATUS:
1023 case V4L2_CID_FLASH_READY:
1024 case V4L2_CID_DV_TX_HOTPLUG:
1025 case V4L2_CID_DV_TX_RXSENSE:
1026 case V4L2_CID_DV_TX_EDID_PRESENT:
1027 case V4L2_CID_DV_RX_POWER_PRESENT:
1028 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1029 break;
1030 }
1031 }
1032 EXPORT_SYMBOL(v4l2_ctrl_fill);
1033
1034 /* Helper function to determine whether the control type is compatible with
1035 VIDIOC_G/S_CTRL. */
1036 static bool type_is_int(const struct v4l2_ctrl *ctrl)
1037 {
1038 switch (ctrl->type) {
1039 case V4L2_CTRL_TYPE_INTEGER64:
1040 case V4L2_CTRL_TYPE_STRING:
1041 /* Nope, these need v4l2_ext_control */
1042 return false;
1043 default:
1044 return true;
1045 }
1046 }
1047
1048 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes)
1049 {
1050 memset(ev->reserved, 0, sizeof(ev->reserved));
1051 ev->type = V4L2_EVENT_CTRL;
1052 ev->id = ctrl->id;
1053 ev->u.ctrl.changes = changes;
1054 ev->u.ctrl.type = ctrl->type;
1055 ev->u.ctrl.flags = ctrl->flags;
1056 if (ctrl->type == V4L2_CTRL_TYPE_STRING)
1057 ev->u.ctrl.value64 = 0;
1058 else
1059 ev->u.ctrl.value64 = ctrl->cur.val64;
1060 ev->u.ctrl.minimum = ctrl->minimum;
1061 ev->u.ctrl.maximum = ctrl->maximum;
1062 if (ctrl->type == V4L2_CTRL_TYPE_MENU
1063 || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1064 ev->u.ctrl.step = 1;
1065 else
1066 ev->u.ctrl.step = ctrl->step;
1067 ev->u.ctrl.default_value = ctrl->default_value;
1068 }
1069
1070 static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
1071 {
1072 struct v4l2_event ev;
1073 struct v4l2_subscribed_event *sev;
1074
1075 if (list_empty(&ctrl->ev_subs))
1076 return;
1077 fill_event(&ev, ctrl, changes);
1078
1079 list_for_each_entry(sev, &ctrl->ev_subs, node)
1080 if (sev->fh != fh ||
1081 (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
1082 v4l2_event_queue_fh(sev->fh, &ev);
1083 }
1084
1085 /* Helper function: copy the current control value back to the caller */
1086 static int cur_to_user(struct v4l2_ext_control *c,
1087 struct v4l2_ctrl *ctrl)
1088 {
1089 u32 len;
1090
1091 switch (ctrl->type) {
1092 case V4L2_CTRL_TYPE_STRING:
1093 len = strlen(ctrl->cur.string);
1094 if (c->size < len + 1) {
1095 c->size = len + 1;
1096 return -ENOSPC;
1097 }
1098 return copy_to_user(c->string, ctrl->cur.string,
1099 len + 1) ? -EFAULT : 0;
1100 case V4L2_CTRL_TYPE_INTEGER64:
1101 c->value64 = ctrl->cur.val64;
1102 break;
1103 default:
1104 c->value = ctrl->cur.val;
1105 break;
1106 }
1107 return 0;
1108 }
1109
1110 /* Helper function: copy the caller-provider value as the new control value */
1111 static int user_to_new(struct v4l2_ext_control *c,
1112 struct v4l2_ctrl *ctrl)
1113 {
1114 int ret;
1115 u32 size;
1116
1117 ctrl->is_new = 1;
1118 switch (ctrl->type) {
1119 case V4L2_CTRL_TYPE_INTEGER64:
1120 ctrl->val64 = c->value64;
1121 break;
1122 case V4L2_CTRL_TYPE_STRING:
1123 size = c->size;
1124 if (size == 0)
1125 return -ERANGE;
1126 if (size > ctrl->maximum + 1)
1127 size = ctrl->maximum + 1;
1128 ret = copy_from_user(ctrl->string, c->string, size);
1129 if (!ret) {
1130 char last = ctrl->string[size - 1];
1131
1132 ctrl->string[size - 1] = 0;
1133 /* If the string was longer than ctrl->maximum,
1134 then return an error. */
1135 if (strlen(ctrl->string) == ctrl->maximum && last)
1136 return -ERANGE;
1137 }
1138 return ret ? -EFAULT : 0;
1139 default:
1140 ctrl->val = c->value;
1141 break;
1142 }
1143 return 0;
1144 }
1145
1146 /* Helper function: copy the new control value back to the caller */
1147 static int new_to_user(struct v4l2_ext_control *c,
1148 struct v4l2_ctrl *ctrl)
1149 {
1150 u32 len;
1151
1152 switch (ctrl->type) {
1153 case V4L2_CTRL_TYPE_STRING:
1154 len = strlen(ctrl->string);
1155 if (c->size < len + 1) {
1156 c->size = ctrl->maximum + 1;
1157 return -ENOSPC;
1158 }
1159 return copy_to_user(c->string, ctrl->string,
1160 len + 1) ? -EFAULT : 0;
1161 case V4L2_CTRL_TYPE_INTEGER64:
1162 c->value64 = ctrl->val64;
1163 break;
1164 default:
1165 c->value = ctrl->val;
1166 break;
1167 }
1168 return 0;
1169 }
1170
1171 /* Copy the new value to the current value. */
1172 static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
1173 {
1174 bool changed = false;
1175
1176 if (ctrl == NULL)
1177 return;
1178 switch (ctrl->type) {
1179 case V4L2_CTRL_TYPE_BUTTON:
1180 changed = true;
1181 break;
1182 case V4L2_CTRL_TYPE_STRING:
1183 /* strings are always 0-terminated */
1184 changed = strcmp(ctrl->string, ctrl->cur.string);
1185 strcpy(ctrl->cur.string, ctrl->string);
1186 break;
1187 case V4L2_CTRL_TYPE_INTEGER64:
1188 changed = ctrl->val64 != ctrl->cur.val64;
1189 ctrl->cur.val64 = ctrl->val64;
1190 break;
1191 default:
1192 changed = ctrl->val != ctrl->cur.val;
1193 ctrl->cur.val = ctrl->val;
1194 break;
1195 }
1196 if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
1197 /* Note: CH_FLAGS is only set for auto clusters. */
1198 ctrl->flags &=
1199 ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1200 if (!is_cur_manual(ctrl->cluster[0])) {
1201 ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1202 if (ctrl->cluster[0]->has_volatiles)
1203 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1204 }
1205 fh = NULL;
1206 }
1207 if (changed || ch_flags) {
1208 /* If a control was changed that was not one of the controls
1209 modified by the application, then send the event to all. */
1210 if (!ctrl->is_new)
1211 fh = NULL;
1212 send_event(fh, ctrl,
1213 (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
1214 if (ctrl->call_notify && changed && ctrl->handler->notify)
1215 ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
1216 }
1217 }
1218
1219 /* Copy the current value to the new value */
1220 static void cur_to_new(struct v4l2_ctrl *ctrl)
1221 {
1222 if (ctrl == NULL)
1223 return;
1224 switch (ctrl->type) {
1225 case V4L2_CTRL_TYPE_STRING:
1226 /* strings are always 0-terminated */
1227 strcpy(ctrl->string, ctrl->cur.string);
1228 break;
1229 case V4L2_CTRL_TYPE_INTEGER64:
1230 ctrl->val64 = ctrl->cur.val64;
1231 break;
1232 default:
1233 ctrl->val = ctrl->cur.val;
1234 break;
1235 }
1236 }
1237
1238 /* Return non-zero if one or more of the controls in the cluster has a new
1239 value that differs from the current value. */
1240 static int cluster_changed(struct v4l2_ctrl *master)
1241 {
1242 int diff = 0;
1243 int i;
1244
1245 for (i = 0; !diff && i < master->ncontrols; i++) {
1246 struct v4l2_ctrl *ctrl = master->cluster[i];
1247
1248 if (ctrl == NULL)
1249 continue;
1250 switch (ctrl->type) {
1251 case V4L2_CTRL_TYPE_BUTTON:
1252 /* Button controls are always 'different' */
1253 return 1;
1254 case V4L2_CTRL_TYPE_STRING:
1255 /* strings are always 0-terminated */
1256 diff = strcmp(ctrl->string, ctrl->cur.string);
1257 break;
1258 case V4L2_CTRL_TYPE_INTEGER64:
1259 diff = ctrl->val64 != ctrl->cur.val64;
1260 break;
1261 default:
1262 diff = ctrl->val != ctrl->cur.val;
1263 break;
1264 }
1265 }
1266 return diff;
1267 }
1268
1269 /* Control range checking */
1270 static int check_range(enum v4l2_ctrl_type type,
1271 s32 min, s32 max, u32 step, s32 def)
1272 {
1273 switch (type) {
1274 case V4L2_CTRL_TYPE_BOOLEAN:
1275 if (step != 1 || max > 1 || min < 0)
1276 return -ERANGE;
1277 /* fall through */
1278 case V4L2_CTRL_TYPE_INTEGER:
1279 if (step <= 0 || min > max || def < min || def > max)
1280 return -ERANGE;
1281 return 0;
1282 case V4L2_CTRL_TYPE_BITMASK:
1283 if (step || min || !max || (def & ~max))
1284 return -ERANGE;
1285 return 0;
1286 case V4L2_CTRL_TYPE_MENU:
1287 case V4L2_CTRL_TYPE_INTEGER_MENU:
1288 if (min > max || def < min || def > max)
1289 return -ERANGE;
1290 /* Note: step == menu_skip_mask for menu controls.
1291 So here we check if the default value is masked out. */
1292 if (step && ((1 << def) & step))
1293 return -EINVAL;
1294 return 0;
1295 case V4L2_CTRL_TYPE_STRING:
1296 if (min > max || min < 0 || step < 1 || def)
1297 return -ERANGE;
1298 return 0;
1299 default:
1300 return 0;
1301 }
1302 }
1303
1304 /* Validate a new control */
1305 static int validate_new(const struct v4l2_ctrl *ctrl,
1306 struct v4l2_ext_control *c)
1307 {
1308 size_t len;
1309 u32 offset;
1310 s32 val;
1311
1312 switch (ctrl->type) {
1313 case V4L2_CTRL_TYPE_INTEGER:
1314 /* Round towards the closest legal value */
1315 val = c->value + ctrl->step / 2;
1316 val = clamp(val, ctrl->minimum, ctrl->maximum);
1317 offset = val - ctrl->minimum;
1318 offset = ctrl->step * (offset / ctrl->step);
1319 c->value = ctrl->minimum + offset;
1320 return 0;
1321
1322 case V4L2_CTRL_TYPE_BOOLEAN:
1323 c->value = !!c->value;
1324 return 0;
1325
1326 case V4L2_CTRL_TYPE_MENU:
1327 case V4L2_CTRL_TYPE_INTEGER_MENU:
1328 if (c->value < ctrl->minimum || c->value > ctrl->maximum)
1329 return -ERANGE;
1330 if (ctrl->menu_skip_mask & (1 << c->value))
1331 return -EINVAL;
1332 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1333 ctrl->qmenu[c->value][0] == '\0')
1334 return -EINVAL;
1335 return 0;
1336
1337 case V4L2_CTRL_TYPE_BITMASK:
1338 c->value &= ctrl->maximum;
1339 return 0;
1340
1341 case V4L2_CTRL_TYPE_BUTTON:
1342 case V4L2_CTRL_TYPE_CTRL_CLASS:
1343 c->value = 0;
1344 return 0;
1345
1346 case V4L2_CTRL_TYPE_INTEGER64:
1347 return 0;
1348
1349 case V4L2_CTRL_TYPE_STRING:
1350 len = strlen(c->string);
1351 if (len < ctrl->minimum)
1352 return -ERANGE;
1353 if ((len - ctrl->minimum) % ctrl->step)
1354 return -ERANGE;
1355 return 0;
1356
1357 default:
1358 return -EINVAL;
1359 }
1360 }
1361
1362 static inline u32 node2id(struct list_head *node)
1363 {
1364 return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1365 }
1366
1367 /* Set the handler's error code if it wasn't set earlier already */
1368 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1369 {
1370 if (hdl->error == 0)
1371 hdl->error = err;
1372 return err;
1373 }
1374
1375 /* Initialize the handler */
1376 int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl,
1377 unsigned nr_of_controls_hint,
1378 struct lock_class_key *key, const char *name)
1379 {
1380 hdl->lock = &hdl->_lock;
1381 mutex_init(hdl->lock);
1382 lockdep_set_class_and_name(hdl->lock, key, name);
1383 INIT_LIST_HEAD(&hdl->ctrls);
1384 INIT_LIST_HEAD(&hdl->ctrl_refs);
1385 hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1386 hdl->buckets = kcalloc(hdl->nr_of_buckets, sizeof(hdl->buckets[0]),
1387 GFP_KERNEL);
1388 hdl->error = hdl->buckets ? 0 : -ENOMEM;
1389 return hdl->error;
1390 }
1391 EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
1392
1393 /* Free all controls and control refs */
1394 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1395 {
1396 struct v4l2_ctrl_ref *ref, *next_ref;
1397 struct v4l2_ctrl *ctrl, *next_ctrl;
1398 struct v4l2_subscribed_event *sev, *next_sev;
1399
1400 if (hdl == NULL || hdl->buckets == NULL)
1401 return;
1402
1403 mutex_lock(hdl->lock);
1404 /* Free all nodes */
1405 list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1406 list_del(&ref->node);
1407 kfree(ref);
1408 }
1409 /* Free all controls owned by the handler */
1410 list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1411 list_del(&ctrl->node);
1412 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1413 list_del(&sev->node);
1414 kfree(ctrl);
1415 }
1416 kfree(hdl->buckets);
1417 hdl->buckets = NULL;
1418 hdl->cached = NULL;
1419 hdl->error = 0;
1420 mutex_unlock(hdl->lock);
1421 }
1422 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1423
1424 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1425 be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1426 with applications that do not use the NEXT_CTRL flag.
1427
1428 We just find the n-th private user control. It's O(N), but that should not
1429 be an issue in this particular case. */
1430 static struct v4l2_ctrl_ref *find_private_ref(
1431 struct v4l2_ctrl_handler *hdl, u32 id)
1432 {
1433 struct v4l2_ctrl_ref *ref;
1434
1435 id -= V4L2_CID_PRIVATE_BASE;
1436 list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1437 /* Search for private user controls that are compatible with
1438 VIDIOC_G/S_CTRL. */
1439 if (V4L2_CTRL_ID2CLASS(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1440 V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1441 if (!type_is_int(ref->ctrl))
1442 continue;
1443 if (id == 0)
1444 return ref;
1445 id--;
1446 }
1447 }
1448 return NULL;
1449 }
1450
1451 /* Find a control with the given ID. */
1452 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1453 {
1454 struct v4l2_ctrl_ref *ref;
1455 int bucket;
1456
1457 id &= V4L2_CTRL_ID_MASK;
1458
1459 /* Old-style private controls need special handling */
1460 if (id >= V4L2_CID_PRIVATE_BASE)
1461 return find_private_ref(hdl, id);
1462 bucket = id % hdl->nr_of_buckets;
1463
1464 /* Simple optimization: cache the last control found */
1465 if (hdl->cached && hdl->cached->ctrl->id == id)
1466 return hdl->cached;
1467
1468 /* Not in cache, search the hash */
1469 ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1470 while (ref && ref->ctrl->id != id)
1471 ref = ref->next;
1472
1473 if (ref)
1474 hdl->cached = ref; /* cache it! */
1475 return ref;
1476 }
1477
1478 /* Find a control with the given ID. Take the handler's lock first. */
1479 static struct v4l2_ctrl_ref *find_ref_lock(
1480 struct v4l2_ctrl_handler *hdl, u32 id)
1481 {
1482 struct v4l2_ctrl_ref *ref = NULL;
1483
1484 if (hdl) {
1485 mutex_lock(hdl->lock);
1486 ref = find_ref(hdl, id);
1487 mutex_unlock(hdl->lock);
1488 }
1489 return ref;
1490 }
1491
1492 /* Find a control with the given ID. */
1493 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1494 {
1495 struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1496
1497 return ref ? ref->ctrl : NULL;
1498 }
1499 EXPORT_SYMBOL(v4l2_ctrl_find);
1500
1501 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
1502 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1503 struct v4l2_ctrl *ctrl)
1504 {
1505 struct v4l2_ctrl_ref *ref;
1506 struct v4l2_ctrl_ref *new_ref;
1507 u32 id = ctrl->id;
1508 u32 class_ctrl = V4L2_CTRL_ID2CLASS(id) | 1;
1509 int bucket = id % hdl->nr_of_buckets; /* which bucket to use */
1510
1511 /* Automatically add the control class if it is not yet present. */
1512 if (id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1513 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1514 return hdl->error;
1515
1516 if (hdl->error)
1517 return hdl->error;
1518
1519 new_ref = kzalloc(sizeof(*new_ref), GFP_KERNEL);
1520 if (!new_ref)
1521 return handler_set_err(hdl, -ENOMEM);
1522 new_ref->ctrl = ctrl;
1523 if (ctrl->handler == hdl) {
1524 /* By default each control starts in a cluster of its own.
1525 new_ref->ctrl is basically a cluster array with one
1526 element, so that's perfect to use as the cluster pointer.
1527 But only do this for the handler that owns the control. */
1528 ctrl->cluster = &new_ref->ctrl;
1529 ctrl->ncontrols = 1;
1530 }
1531
1532 INIT_LIST_HEAD(&new_ref->node);
1533
1534 mutex_lock(hdl->lock);
1535
1536 /* Add immediately at the end of the list if the list is empty, or if
1537 the last element in the list has a lower ID.
1538 This ensures that when elements are added in ascending order the
1539 insertion is an O(1) operation. */
1540 if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1541 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1542 goto insert_in_hash;
1543 }
1544
1545 /* Find insert position in sorted list */
1546 list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1547 if (ref->ctrl->id < id)
1548 continue;
1549 /* Don't add duplicates */
1550 if (ref->ctrl->id == id) {
1551 kfree(new_ref);
1552 goto unlock;
1553 }
1554 list_add(&new_ref->node, ref->node.prev);
1555 break;
1556 }
1557
1558 insert_in_hash:
1559 /* Insert the control node in the hash */
1560 new_ref->next = hdl->buckets[bucket];
1561 hdl->buckets[bucket] = new_ref;
1562
1563 unlock:
1564 mutex_unlock(hdl->lock);
1565 return 0;
1566 }
1567
1568 /* Add a new control */
1569 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1570 const struct v4l2_ctrl_ops *ops,
1571 u32 id, const char *name, enum v4l2_ctrl_type type,
1572 s32 min, s32 max, u32 step, s32 def,
1573 u32 flags, const char * const *qmenu,
1574 const s64 *qmenu_int, void *priv)
1575 {
1576 struct v4l2_ctrl *ctrl;
1577 unsigned sz_extra = 0;
1578 int err;
1579
1580 if (hdl->error)
1581 return NULL;
1582
1583 /* Sanity checks */
1584 if (id == 0 || name == NULL || id >= V4L2_CID_PRIVATE_BASE ||
1585 (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1586 (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
1587 handler_set_err(hdl, -ERANGE);
1588 return NULL;
1589 }
1590 err = check_range(type, min, max, step, def);
1591 if (err) {
1592 handler_set_err(hdl, err);
1593 return NULL;
1594 }
1595 if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
1596 handler_set_err(hdl, -ERANGE);
1597 return NULL;
1598 }
1599
1600 if (type == V4L2_CTRL_TYPE_BUTTON)
1601 flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1602 else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1603 flags |= V4L2_CTRL_FLAG_READ_ONLY;
1604 else if (type == V4L2_CTRL_TYPE_STRING)
1605 sz_extra += 2 * (max + 1);
1606
1607 ctrl = kzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
1608 if (ctrl == NULL) {
1609 handler_set_err(hdl, -ENOMEM);
1610 return NULL;
1611 }
1612
1613 INIT_LIST_HEAD(&ctrl->node);
1614 INIT_LIST_HEAD(&ctrl->ev_subs);
1615 ctrl->handler = hdl;
1616 ctrl->ops = ops;
1617 ctrl->id = id;
1618 ctrl->name = name;
1619 ctrl->type = type;
1620 ctrl->flags = flags;
1621 ctrl->minimum = min;
1622 ctrl->maximum = max;
1623 ctrl->step = step;
1624 if (type == V4L2_CTRL_TYPE_MENU)
1625 ctrl->qmenu = qmenu;
1626 else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1627 ctrl->qmenu_int = qmenu_int;
1628 ctrl->priv = priv;
1629 ctrl->cur.val = ctrl->val = ctrl->default_value = def;
1630
1631 if (ctrl->type == V4L2_CTRL_TYPE_STRING) {
1632 ctrl->cur.string = (char *)&ctrl[1] + sz_extra - (max + 1);
1633 ctrl->string = (char *)&ctrl[1] + sz_extra - 2 * (max + 1);
1634 if (ctrl->minimum)
1635 memset(ctrl->cur.string, ' ', ctrl->minimum);
1636 }
1637 if (handler_new_ref(hdl, ctrl)) {
1638 kfree(ctrl);
1639 return NULL;
1640 }
1641 mutex_lock(hdl->lock);
1642 list_add_tail(&ctrl->node, &hdl->ctrls);
1643 mutex_unlock(hdl->lock);
1644 return ctrl;
1645 }
1646
1647 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
1648 const struct v4l2_ctrl_config *cfg, void *priv)
1649 {
1650 bool is_menu;
1651 struct v4l2_ctrl *ctrl;
1652 const char *name = cfg->name;
1653 const char * const *qmenu = cfg->qmenu;
1654 const s64 *qmenu_int = cfg->qmenu_int;
1655 enum v4l2_ctrl_type type = cfg->type;
1656 u32 flags = cfg->flags;
1657 s32 min = cfg->min;
1658 s32 max = cfg->max;
1659 u32 step = cfg->step;
1660 s32 def = cfg->def;
1661
1662 if (name == NULL)
1663 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
1664 &def, &flags);
1665
1666 is_menu = (cfg->type == V4L2_CTRL_TYPE_MENU ||
1667 cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU);
1668 if (is_menu)
1669 WARN_ON(step);
1670 else
1671 WARN_ON(cfg->menu_skip_mask);
1672 if (cfg->type == V4L2_CTRL_TYPE_MENU && qmenu == NULL)
1673 qmenu = v4l2_ctrl_get_menu(cfg->id);
1674 else if (cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU &&
1675 qmenu_int == NULL) {
1676 handler_set_err(hdl, -EINVAL);
1677 return NULL;
1678 }
1679
1680 ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->id, name,
1681 type, min, max,
1682 is_menu ? cfg->menu_skip_mask : step,
1683 def, flags, qmenu, qmenu_int, priv);
1684 if (ctrl)
1685 ctrl->is_private = cfg->is_private;
1686 return ctrl;
1687 }
1688 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
1689
1690 /* Helper function for standard non-menu controls */
1691 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
1692 const struct v4l2_ctrl_ops *ops,
1693 u32 id, s32 min, s32 max, u32 step, s32 def)
1694 {
1695 const char *name;
1696 enum v4l2_ctrl_type type;
1697 u32 flags;
1698
1699 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1700 if (type == V4L2_CTRL_TYPE_MENU
1701 || type == V4L2_CTRL_TYPE_INTEGER_MENU) {
1702 handler_set_err(hdl, -EINVAL);
1703 return NULL;
1704 }
1705 return v4l2_ctrl_new(hdl, ops, id, name, type,
1706 min, max, step, def, flags, NULL, NULL, NULL);
1707 }
1708 EXPORT_SYMBOL(v4l2_ctrl_new_std);
1709
1710 /* Helper function for standard menu controls */
1711 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
1712 const struct v4l2_ctrl_ops *ops,
1713 u32 id, s32 max, s32 mask, s32 def)
1714 {
1715 const char * const *qmenu = v4l2_ctrl_get_menu(id);
1716 const char *name;
1717 enum v4l2_ctrl_type type;
1718 s32 min;
1719 s32 step;
1720 u32 flags;
1721
1722 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1723 if (type != V4L2_CTRL_TYPE_MENU) {
1724 handler_set_err(hdl, -EINVAL);
1725 return NULL;
1726 }
1727 return v4l2_ctrl_new(hdl, ops, id, name, type,
1728 0, max, mask, def, flags, qmenu, NULL, NULL);
1729 }
1730 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
1731
1732 /* Helper function for standard menu controls with driver defined menu */
1733 struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl,
1734 const struct v4l2_ctrl_ops *ops, u32 id, s32 max,
1735 s32 mask, s32 def, const char * const *qmenu)
1736 {
1737 enum v4l2_ctrl_type type;
1738 const char *name;
1739 u32 flags;
1740 s32 step;
1741 s32 min;
1742
1743 /* v4l2_ctrl_new_std_menu_items() should only be called for
1744 * standard controls without a standard menu.
1745 */
1746 if (v4l2_ctrl_get_menu(id)) {
1747 handler_set_err(hdl, -EINVAL);
1748 return NULL;
1749 }
1750
1751 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1752 if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) {
1753 handler_set_err(hdl, -EINVAL);
1754 return NULL;
1755 }
1756 return v4l2_ctrl_new(hdl, ops, id, name, type, 0, max, mask, def,
1757 flags, qmenu, NULL, NULL);
1758
1759 }
1760 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items);
1761
1762 /* Helper function for standard integer menu controls */
1763 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
1764 const struct v4l2_ctrl_ops *ops,
1765 u32 id, s32 max, s32 def, const s64 *qmenu_int)
1766 {
1767 const char *name;
1768 enum v4l2_ctrl_type type;
1769 s32 min;
1770 s32 step;
1771 u32 flags;
1772
1773 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1774 if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
1775 handler_set_err(hdl, -EINVAL);
1776 return NULL;
1777 }
1778 return v4l2_ctrl_new(hdl, ops, id, name, type,
1779 0, max, 0, def, flags, NULL, qmenu_int, NULL);
1780 }
1781 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
1782
1783 /* Add a control from another handler to this handler */
1784 struct v4l2_ctrl *v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler *hdl,
1785 struct v4l2_ctrl *ctrl)
1786 {
1787 if (hdl == NULL || hdl->error)
1788 return NULL;
1789 if (ctrl == NULL) {
1790 handler_set_err(hdl, -EINVAL);
1791 return NULL;
1792 }
1793 if (ctrl->handler == hdl)
1794 return ctrl;
1795 return handler_new_ref(hdl, ctrl) ? NULL : ctrl;
1796 }
1797 EXPORT_SYMBOL(v4l2_ctrl_add_ctrl);
1798
1799 /* Add the controls from another handler to our own. */
1800 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
1801 struct v4l2_ctrl_handler *add,
1802 bool (*filter)(const struct v4l2_ctrl *ctrl))
1803 {
1804 struct v4l2_ctrl_ref *ref;
1805 int ret = 0;
1806
1807 /* Do nothing if either handler is NULL or if they are the same */
1808 if (!hdl || !add || hdl == add)
1809 return 0;
1810 if (hdl->error)
1811 return hdl->error;
1812 mutex_lock(add->lock);
1813 list_for_each_entry(ref, &add->ctrl_refs, node) {
1814 struct v4l2_ctrl *ctrl = ref->ctrl;
1815
1816 /* Skip handler-private controls. */
1817 if (ctrl->is_private)
1818 continue;
1819 /* And control classes */
1820 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1821 continue;
1822 /* Filter any unwanted controls */
1823 if (filter && !filter(ctrl))
1824 continue;
1825 ret = handler_new_ref(hdl, ctrl);
1826 if (ret)
1827 break;
1828 }
1829 mutex_unlock(add->lock);
1830 return ret;
1831 }
1832 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
1833
1834 bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl)
1835 {
1836 if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_FM_TX)
1837 return true;
1838 switch (ctrl->id) {
1839 case V4L2_CID_AUDIO_MUTE:
1840 case V4L2_CID_AUDIO_VOLUME:
1841 case V4L2_CID_AUDIO_BALANCE:
1842 case V4L2_CID_AUDIO_BASS:
1843 case V4L2_CID_AUDIO_TREBLE:
1844 case V4L2_CID_AUDIO_LOUDNESS:
1845 return true;
1846 default:
1847 break;
1848 }
1849 return false;
1850 }
1851 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
1852
1853 /* Cluster controls */
1854 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
1855 {
1856 bool has_volatiles = false;
1857 int i;
1858
1859 /* The first control is the master control and it must not be NULL */
1860 BUG_ON(ncontrols == 0 || controls[0] == NULL);
1861
1862 for (i = 0; i < ncontrols; i++) {
1863 if (controls[i]) {
1864 controls[i]->cluster = controls;
1865 controls[i]->ncontrols = ncontrols;
1866 if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
1867 has_volatiles = true;
1868 }
1869 }
1870 controls[0]->has_volatiles = has_volatiles;
1871 }
1872 EXPORT_SYMBOL(v4l2_ctrl_cluster);
1873
1874 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
1875 u8 manual_val, bool set_volatile)
1876 {
1877 struct v4l2_ctrl *master = controls[0];
1878 u32 flag = 0;
1879 int i;
1880
1881 v4l2_ctrl_cluster(ncontrols, controls);
1882 WARN_ON(ncontrols <= 1);
1883 WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
1884 WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
1885 master->is_auto = true;
1886 master->has_volatiles = set_volatile;
1887 master->manual_mode_value = manual_val;
1888 master->flags |= V4L2_CTRL_FLAG_UPDATE;
1889
1890 if (!is_cur_manual(master))
1891 flag = V4L2_CTRL_FLAG_INACTIVE |
1892 (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
1893
1894 for (i = 1; i < ncontrols; i++)
1895 if (controls[i])
1896 controls[i]->flags |= flag;
1897 }
1898 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
1899
1900 /* Activate/deactivate a control. */
1901 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
1902 {
1903 /* invert since the actual flag is called 'inactive' */
1904 bool inactive = !active;
1905 bool old;
1906
1907 if (ctrl == NULL)
1908 return;
1909
1910 if (inactive)
1911 /* set V4L2_CTRL_FLAG_INACTIVE */
1912 old = test_and_set_bit(4, &ctrl->flags);
1913 else
1914 /* clear V4L2_CTRL_FLAG_INACTIVE */
1915 old = test_and_clear_bit(4, &ctrl->flags);
1916 if (old != inactive)
1917 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1918 }
1919 EXPORT_SYMBOL(v4l2_ctrl_activate);
1920
1921 /* Grab/ungrab a control.
1922 Typically used when streaming starts and you want to grab controls,
1923 preventing the user from changing them.
1924
1925 Just call this and the framework will block any attempts to change
1926 these controls. */
1927 void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
1928 {
1929 bool old;
1930
1931 if (ctrl == NULL)
1932 return;
1933
1934 v4l2_ctrl_lock(ctrl);
1935 if (grabbed)
1936 /* set V4L2_CTRL_FLAG_GRABBED */
1937 old = test_and_set_bit(1, &ctrl->flags);
1938 else
1939 /* clear V4L2_CTRL_FLAG_GRABBED */
1940 old = test_and_clear_bit(1, &ctrl->flags);
1941 if (old != grabbed)
1942 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1943 v4l2_ctrl_unlock(ctrl);
1944 }
1945 EXPORT_SYMBOL(v4l2_ctrl_grab);
1946
1947 /* Log the control name and value */
1948 static void log_ctrl(const struct v4l2_ctrl *ctrl,
1949 const char *prefix, const char *colon)
1950 {
1951 if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
1952 return;
1953 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1954 return;
1955
1956 printk(KERN_INFO "%s%s%s: ", prefix, colon, ctrl->name);
1957
1958 switch (ctrl->type) {
1959 case V4L2_CTRL_TYPE_INTEGER:
1960 printk(KERN_CONT "%d", ctrl->cur.val);
1961 break;
1962 case V4L2_CTRL_TYPE_BOOLEAN:
1963 printk(KERN_CONT "%s", ctrl->cur.val ? "true" : "false");
1964 break;
1965 case V4L2_CTRL_TYPE_MENU:
1966 printk(KERN_CONT "%s", ctrl->qmenu[ctrl->cur.val]);
1967 break;
1968 case V4L2_CTRL_TYPE_INTEGER_MENU:
1969 printk(KERN_CONT "%lld", ctrl->qmenu_int[ctrl->cur.val]);
1970 break;
1971 case V4L2_CTRL_TYPE_BITMASK:
1972 printk(KERN_CONT "0x%08x", ctrl->cur.val);
1973 break;
1974 case V4L2_CTRL_TYPE_INTEGER64:
1975 printk(KERN_CONT "%lld", ctrl->cur.val64);
1976 break;
1977 case V4L2_CTRL_TYPE_STRING:
1978 printk(KERN_CONT "%s", ctrl->cur.string);
1979 break;
1980 default:
1981 printk(KERN_CONT "unknown type %d", ctrl->type);
1982 break;
1983 }
1984 if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
1985 V4L2_CTRL_FLAG_GRABBED |
1986 V4L2_CTRL_FLAG_VOLATILE)) {
1987 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
1988 printk(KERN_CONT " inactive");
1989 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
1990 printk(KERN_CONT " grabbed");
1991 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
1992 printk(KERN_CONT " volatile");
1993 }
1994 printk(KERN_CONT "\n");
1995 }
1996
1997 /* Log all controls owned by the handler */
1998 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
1999 const char *prefix)
2000 {
2001 struct v4l2_ctrl *ctrl;
2002 const char *colon = "";
2003 int len;
2004
2005 if (hdl == NULL)
2006 return;
2007 if (prefix == NULL)
2008 prefix = "";
2009 len = strlen(prefix);
2010 if (len && prefix[len - 1] != ' ')
2011 colon = ": ";
2012 mutex_lock(hdl->lock);
2013 list_for_each_entry(ctrl, &hdl->ctrls, node)
2014 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2015 log_ctrl(ctrl, prefix, colon);
2016 mutex_unlock(hdl->lock);
2017 }
2018 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2019
2020 int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
2021 {
2022 v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
2023 return 0;
2024 }
2025 EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
2026
2027 /* Call s_ctrl for all controls owned by the handler */
2028 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2029 {
2030 struct v4l2_ctrl *ctrl;
2031 int ret = 0;
2032
2033 if (hdl == NULL)
2034 return 0;
2035 mutex_lock(hdl->lock);
2036 list_for_each_entry(ctrl, &hdl->ctrls, node)
2037 ctrl->done = false;
2038
2039 list_for_each_entry(ctrl, &hdl->ctrls, node) {
2040 struct v4l2_ctrl *master = ctrl->cluster[0];
2041 int i;
2042
2043 /* Skip if this control was already handled by a cluster. */
2044 /* Skip button controls and read-only controls. */
2045 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2046 (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2047 continue;
2048
2049 for (i = 0; i < master->ncontrols; i++) {
2050 if (master->cluster[i]) {
2051 cur_to_new(master->cluster[i]);
2052 master->cluster[i]->is_new = 1;
2053 master->cluster[i]->done = true;
2054 }
2055 }
2056 ret = call_op(master, s_ctrl);
2057 if (ret)
2058 break;
2059 }
2060 mutex_unlock(hdl->lock);
2061 return ret;
2062 }
2063 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2064
2065 /* Implement VIDIOC_QUERYCTRL */
2066 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
2067 {
2068 u32 id = qc->id & V4L2_CTRL_ID_MASK;
2069 struct v4l2_ctrl_ref *ref;
2070 struct v4l2_ctrl *ctrl;
2071
2072 if (hdl == NULL)
2073 return -EINVAL;
2074
2075 mutex_lock(hdl->lock);
2076
2077 /* Try to find it */
2078 ref = find_ref(hdl, id);
2079
2080 if ((qc->id & V4L2_CTRL_FLAG_NEXT_CTRL) && !list_empty(&hdl->ctrl_refs)) {
2081 /* Find the next control with ID > qc->id */
2082
2083 /* Did we reach the end of the control list? */
2084 if (id >= node2id(hdl->ctrl_refs.prev)) {
2085 ref = NULL; /* Yes, so there is no next control */
2086 } else if (ref) {
2087 /* We found a control with the given ID, so just get
2088 the next one in the list. */
2089 ref = list_entry(ref->node.next, typeof(*ref), node);
2090 } else {
2091 /* No control with the given ID exists, so start
2092 searching for the next largest ID. We know there
2093 is one, otherwise the first 'if' above would have
2094 been true. */
2095 list_for_each_entry(ref, &hdl->ctrl_refs, node)
2096 if (id < ref->ctrl->id)
2097 break;
2098 }
2099 }
2100 mutex_unlock(hdl->lock);
2101 if (!ref)
2102 return -EINVAL;
2103
2104 ctrl = ref->ctrl;
2105 memset(qc, 0, sizeof(*qc));
2106 if (id >= V4L2_CID_PRIVATE_BASE)
2107 qc->id = id;
2108 else
2109 qc->id = ctrl->id;
2110 strlcpy(qc->name, ctrl->name, sizeof(qc->name));
2111 qc->minimum = ctrl->minimum;
2112 qc->maximum = ctrl->maximum;
2113 qc->default_value = ctrl->default_value;
2114 if (ctrl->type == V4L2_CTRL_TYPE_MENU
2115 || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
2116 qc->step = 1;
2117 else
2118 qc->step = ctrl->step;
2119 qc->flags = ctrl->flags;
2120 qc->type = ctrl->type;
2121 return 0;
2122 }
2123 EXPORT_SYMBOL(v4l2_queryctrl);
2124
2125 int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
2126 {
2127 if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL)
2128 return -EINVAL;
2129 return v4l2_queryctrl(sd->ctrl_handler, qc);
2130 }
2131 EXPORT_SYMBOL(v4l2_subdev_queryctrl);
2132
2133 /* Implement VIDIOC_QUERYMENU */
2134 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
2135 {
2136 struct v4l2_ctrl *ctrl;
2137 u32 i = qm->index;
2138
2139 ctrl = v4l2_ctrl_find(hdl, qm->id);
2140 if (!ctrl)
2141 return -EINVAL;
2142
2143 qm->reserved = 0;
2144 /* Sanity checks */
2145 switch (ctrl->type) {
2146 case V4L2_CTRL_TYPE_MENU:
2147 if (ctrl->qmenu == NULL)
2148 return -EINVAL;
2149 break;
2150 case V4L2_CTRL_TYPE_INTEGER_MENU:
2151 if (ctrl->qmenu_int == NULL)
2152 return -EINVAL;
2153 break;
2154 default:
2155 return -EINVAL;
2156 }
2157
2158 if (i < ctrl->minimum || i > ctrl->maximum)
2159 return -EINVAL;
2160
2161 /* Use mask to see if this menu item should be skipped */
2162 if (ctrl->menu_skip_mask & (1 << i))
2163 return -EINVAL;
2164 /* Empty menu items should also be skipped */
2165 if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
2166 if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
2167 return -EINVAL;
2168 strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
2169 } else {
2170 qm->value = ctrl->qmenu_int[i];
2171 }
2172 return 0;
2173 }
2174 EXPORT_SYMBOL(v4l2_querymenu);
2175
2176 int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
2177 {
2178 return v4l2_querymenu(sd->ctrl_handler, qm);
2179 }
2180 EXPORT_SYMBOL(v4l2_subdev_querymenu);
2181
2182
2183
2184 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
2185
2186 It is not a fully atomic operation, just best-effort only. After all, if
2187 multiple controls have to be set through multiple i2c writes (for example)
2188 then some initial writes may succeed while others fail. Thus leaving the
2189 system in an inconsistent state. The question is how much effort you are
2190 willing to spend on trying to make something atomic that really isn't.
2191
2192 From the point of view of an application the main requirement is that
2193 when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
2194 error should be returned without actually affecting any controls.
2195
2196 If all the values are correct, then it is acceptable to just give up
2197 in case of low-level errors.
2198
2199 It is important though that the application can tell when only a partial
2200 configuration was done. The way we do that is through the error_idx field
2201 of struct v4l2_ext_controls: if that is equal to the count field then no
2202 controls were affected. Otherwise all controls before that index were
2203 successful in performing their 'get' or 'set' operation, the control at
2204 the given index failed, and you don't know what happened with the controls
2205 after the failed one. Since if they were part of a control cluster they
2206 could have been successfully processed (if a cluster member was encountered
2207 at index < error_idx), they could have failed (if a cluster member was at
2208 error_idx), or they may not have been processed yet (if the first cluster
2209 member appeared after error_idx).
2210
2211 It is all fairly theoretical, though. In practice all you can do is to
2212 bail out. If error_idx == count, then it is an application bug. If
2213 error_idx < count then it is only an application bug if the error code was
2214 EBUSY. That usually means that something started streaming just when you
2215 tried to set the controls. In all other cases it is a driver/hardware
2216 problem and all you can do is to retry or bail out.
2217
2218 Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
2219 never modifies controls the error_idx is just set to whatever control
2220 has an invalid value.
2221 */
2222
2223 /* Prepare for the extended g/s/try functions.
2224 Find the controls in the control array and do some basic checks. */
2225 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
2226 struct v4l2_ext_controls *cs,
2227 struct v4l2_ctrl_helper *helpers)
2228 {
2229 struct v4l2_ctrl_helper *h;
2230 bool have_clusters = false;
2231 u32 i;
2232
2233 for (i = 0, h = helpers; i < cs->count; i++, h++) {
2234 struct v4l2_ext_control *c = &cs->controls[i];
2235 struct v4l2_ctrl_ref *ref;
2236 struct v4l2_ctrl *ctrl;
2237 u32 id = c->id & V4L2_CTRL_ID_MASK;
2238
2239 cs->error_idx = i;
2240
2241 if (cs->ctrl_class && V4L2_CTRL_ID2CLASS(id) != cs->ctrl_class)
2242 return -EINVAL;
2243
2244 /* Old-style private controls are not allowed for
2245 extended controls */
2246 if (id >= V4L2_CID_PRIVATE_BASE)
2247 return -EINVAL;
2248 ref = find_ref_lock(hdl, id);
2249 if (ref == NULL)
2250 return -EINVAL;
2251 ctrl = ref->ctrl;
2252 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
2253 return -EINVAL;
2254
2255 if (ctrl->cluster[0]->ncontrols > 1)
2256 have_clusters = true;
2257 if (ctrl->cluster[0] != ctrl)
2258 ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
2259 /* Store the ref to the master control of the cluster */
2260 h->mref = ref;
2261 h->ctrl = ctrl;
2262 /* Initially set next to 0, meaning that there is no other
2263 control in this helper array belonging to the same
2264 cluster */
2265 h->next = 0;
2266 }
2267
2268 /* We are done if there were no controls that belong to a multi-
2269 control cluster. */
2270 if (!have_clusters)
2271 return 0;
2272
2273 /* The code below figures out in O(n) time which controls in the list
2274 belong to the same cluster. */
2275
2276 /* This has to be done with the handler lock taken. */
2277 mutex_lock(hdl->lock);
2278
2279 /* First zero the helper field in the master control references */
2280 for (i = 0; i < cs->count; i++)
2281 helpers[i].mref->helper = NULL;
2282 for (i = 0, h = helpers; i < cs->count; i++, h++) {
2283 struct v4l2_ctrl_ref *mref = h->mref;
2284
2285 /* If the mref->helper is set, then it points to an earlier
2286 helper that belongs to the same cluster. */
2287 if (mref->helper) {
2288 /* Set the next field of mref->helper to the current
2289 index: this means that that earlier helper now
2290 points to the next helper in the same cluster. */
2291 mref->helper->next = i;
2292 /* mref should be set only for the first helper in the
2293 cluster, clear the others. */
2294 h->mref = NULL;
2295 }
2296 /* Point the mref helper to the current helper struct. */
2297 mref->helper = h;
2298 }
2299 mutex_unlock(hdl->lock);
2300 return 0;
2301 }
2302
2303 /* Handles the corner case where cs->count == 0. It checks whether the
2304 specified control class exists. If that class ID is 0, then it checks
2305 whether there are any controls at all. */
2306 static int class_check(struct v4l2_ctrl_handler *hdl, u32 ctrl_class)
2307 {
2308 if (ctrl_class == 0)
2309 return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
2310 return find_ref_lock(hdl, ctrl_class | 1) ? 0 : -EINVAL;
2311 }
2312
2313
2314
2315 /* Get extended controls. Allocates the helpers array if needed. */
2316 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2317 {
2318 struct v4l2_ctrl_helper helper[4];
2319 struct v4l2_ctrl_helper *helpers = helper;
2320 int ret;
2321 int i, j;
2322
2323 cs->error_idx = cs->count;
2324 cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2325
2326 if (hdl == NULL)
2327 return -EINVAL;
2328
2329 if (cs->count == 0)
2330 return class_check(hdl, cs->ctrl_class);
2331
2332 if (cs->count > ARRAY_SIZE(helper)) {
2333 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2334 GFP_KERNEL);
2335 if (helpers == NULL)
2336 return -ENOMEM;
2337 }
2338
2339 ret = prepare_ext_ctrls(hdl, cs, helpers);
2340 cs->error_idx = cs->count;
2341
2342 for (i = 0; !ret && i < cs->count; i++)
2343 if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2344 ret = -EACCES;
2345
2346 for (i = 0; !ret && i < cs->count; i++) {
2347 int (*ctrl_to_user)(struct v4l2_ext_control *c,
2348 struct v4l2_ctrl *ctrl) = cur_to_user;
2349 struct v4l2_ctrl *master;
2350
2351 if (helpers[i].mref == NULL)
2352 continue;
2353
2354 master = helpers[i].mref->ctrl;
2355 cs->error_idx = i;
2356
2357 v4l2_ctrl_lock(master);
2358
2359 /* g_volatile_ctrl will update the new control values */
2360 if ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
2361 (master->has_volatiles && !is_cur_manual(master))) {
2362 for (j = 0; j < master->ncontrols; j++)
2363 cur_to_new(master->cluster[j]);
2364 ret = call_op(master, g_volatile_ctrl);
2365 ctrl_to_user = new_to_user;
2366 }
2367 /* If OK, then copy the current (for non-volatile controls)
2368 or the new (for volatile controls) control values to the
2369 caller */
2370 if (!ret) {
2371 u32 idx = i;
2372
2373 do {
2374 ret = ctrl_to_user(cs->controls + idx,
2375 helpers[idx].ctrl);
2376 idx = helpers[idx].next;
2377 } while (!ret && idx);
2378 }
2379 v4l2_ctrl_unlock(master);
2380 }
2381
2382 if (cs->count > ARRAY_SIZE(helper))
2383 kfree(helpers);
2384 return ret;
2385 }
2386 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
2387
2388 int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2389 {
2390 return v4l2_g_ext_ctrls(sd->ctrl_handler, cs);
2391 }
2392 EXPORT_SYMBOL(v4l2_subdev_g_ext_ctrls);
2393
2394 /* Helper function to get a single control */
2395 static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
2396 {
2397 struct v4l2_ctrl *master = ctrl->cluster[0];
2398 int ret = 0;
2399 int i;
2400
2401 /* String controls are not supported. The new_to_user() and
2402 * cur_to_user() calls below would need to be modified not to access
2403 * userspace memory when called from get_ctrl().
2404 */
2405 if (ctrl->type == V4L2_CTRL_TYPE_STRING)
2406 return -EINVAL;
2407
2408 if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2409 return -EACCES;
2410
2411 v4l2_ctrl_lock(master);
2412 /* g_volatile_ctrl will update the current control values */
2413 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2414 for (i = 0; i < master->ncontrols; i++)
2415 cur_to_new(master->cluster[i]);
2416 ret = call_op(master, g_volatile_ctrl);
2417 new_to_user(c, ctrl);
2418 } else {
2419 cur_to_user(c, ctrl);
2420 }
2421 v4l2_ctrl_unlock(master);
2422 return ret;
2423 }
2424
2425 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
2426 {
2427 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2428 struct v4l2_ext_control c;
2429 int ret;
2430
2431 if (ctrl == NULL || !type_is_int(ctrl))
2432 return -EINVAL;
2433 ret = get_ctrl(ctrl, &c);
2434 control->value = c.value;
2435 return ret;
2436 }
2437 EXPORT_SYMBOL(v4l2_g_ctrl);
2438
2439 int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2440 {
2441 return v4l2_g_ctrl(sd->ctrl_handler, control);
2442 }
2443 EXPORT_SYMBOL(v4l2_subdev_g_ctrl);
2444
2445 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
2446 {
2447 struct v4l2_ext_control c;
2448
2449 /* It's a driver bug if this happens. */
2450 WARN_ON(!type_is_int(ctrl));
2451 c.value = 0;
2452 get_ctrl(ctrl, &c);
2453 return c.value;
2454 }
2455 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
2456
2457 s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
2458 {
2459 struct v4l2_ext_control c;
2460
2461 /* It's a driver bug if this happens. */
2462 WARN_ON(ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2463 c.value = 0;
2464 get_ctrl(ctrl, &c);
2465 return c.value;
2466 }
2467 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
2468
2469
2470 /* Core function that calls try/s_ctrl and ensures that the new value is
2471 copied to the current value on a set.
2472 Must be called with ctrl->handler->lock held. */
2473 static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
2474 bool set, u32 ch_flags)
2475 {
2476 bool update_flag;
2477 int ret;
2478 int i;
2479
2480 /* Go through the cluster and either validate the new value or
2481 (if no new value was set), copy the current value to the new
2482 value, ensuring a consistent view for the control ops when
2483 called. */
2484 for (i = 0; i < master->ncontrols; i++) {
2485 struct v4l2_ctrl *ctrl = master->cluster[i];
2486
2487 if (ctrl == NULL)
2488 continue;
2489
2490 if (!ctrl->is_new) {
2491 cur_to_new(ctrl);
2492 continue;
2493 }
2494 /* Check again: it may have changed since the
2495 previous check in try_or_set_ext_ctrls(). */
2496 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2497 return -EBUSY;
2498 }
2499
2500 ret = call_op(master, try_ctrl);
2501
2502 /* Don't set if there is no change */
2503 if (ret || !set || !cluster_changed(master))
2504 return ret;
2505 ret = call_op(master, s_ctrl);
2506 if (ret)
2507 return ret;
2508
2509 /* If OK, then make the new values permanent. */
2510 update_flag = is_cur_manual(master) != is_new_manual(master);
2511 for (i = 0; i < master->ncontrols; i++)
2512 new_to_cur(fh, master->cluster[i], ch_flags |
2513 ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
2514 return 0;
2515 }
2516
2517 /* Validate controls. */
2518 static int validate_ctrls(struct v4l2_ext_controls *cs,
2519 struct v4l2_ctrl_helper *helpers, bool set)
2520 {
2521 unsigned i;
2522 int ret = 0;
2523
2524 cs->error_idx = cs->count;
2525 for (i = 0; i < cs->count; i++) {
2526 struct v4l2_ctrl *ctrl = helpers[i].ctrl;
2527
2528 cs->error_idx = i;
2529
2530 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2531 return -EACCES;
2532 /* This test is also done in try_set_control_cluster() which
2533 is called in atomic context, so that has the final say,
2534 but it makes sense to do an up-front check as well. Once
2535 an error occurs in try_set_control_cluster() some other
2536 controls may have been set already and we want to do a
2537 best-effort to avoid that. */
2538 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2539 return -EBUSY;
2540 ret = validate_new(ctrl, &cs->controls[i]);
2541 if (ret)
2542 return ret;
2543 }
2544 return 0;
2545 }
2546
2547 /* Obtain the current volatile values of an autocluster and mark them
2548 as new. */
2549 static void update_from_auto_cluster(struct v4l2_ctrl *master)
2550 {
2551 int i;
2552
2553 for (i = 0; i < master->ncontrols; i++)
2554 cur_to_new(master->cluster[i]);
2555 if (!call_op(master, g_volatile_ctrl))
2556 for (i = 1; i < master->ncontrols; i++)
2557 if (master->cluster[i])
2558 master->cluster[i]->is_new = 1;
2559 }
2560
2561 /* Try or try-and-set controls */
2562 static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2563 struct v4l2_ext_controls *cs,
2564 bool set)
2565 {
2566 struct v4l2_ctrl_helper helper[4];
2567 struct v4l2_ctrl_helper *helpers = helper;
2568 unsigned i, j;
2569 int ret;
2570
2571 cs->error_idx = cs->count;
2572 cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2573
2574 if (hdl == NULL)
2575 return -EINVAL;
2576
2577 if (cs->count == 0)
2578 return class_check(hdl, cs->ctrl_class);
2579
2580 if (cs->count > ARRAY_SIZE(helper)) {
2581 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2582 GFP_KERNEL);
2583 if (!helpers)
2584 return -ENOMEM;
2585 }
2586 ret = prepare_ext_ctrls(hdl, cs, helpers);
2587 if (!ret)
2588 ret = validate_ctrls(cs, helpers, set);
2589 if (ret && set)
2590 cs->error_idx = cs->count;
2591 for (i = 0; !ret && i < cs->count; i++) {
2592 struct v4l2_ctrl *master;
2593 u32 idx = i;
2594
2595 if (helpers[i].mref == NULL)
2596 continue;
2597
2598 cs->error_idx = i;
2599 master = helpers[i].mref->ctrl;
2600 v4l2_ctrl_lock(master);
2601
2602 /* Reset the 'is_new' flags of the cluster */
2603 for (j = 0; j < master->ncontrols; j++)
2604 if (master->cluster[j])
2605 master->cluster[j]->is_new = 0;
2606
2607 /* For volatile autoclusters that are currently in auto mode
2608 we need to discover if it will be set to manual mode.
2609 If so, then we have to copy the current volatile values
2610 first since those will become the new manual values (which
2611 may be overwritten by explicit new values from this set
2612 of controls). */
2613 if (master->is_auto && master->has_volatiles &&
2614 !is_cur_manual(master)) {
2615 /* Pick an initial non-manual value */
2616 s32 new_auto_val = master->manual_mode_value + 1;
2617 u32 tmp_idx = idx;
2618
2619 do {
2620 /* Check if the auto control is part of the
2621 list, and remember the new value. */
2622 if (helpers[tmp_idx].ctrl == master)
2623 new_auto_val = cs->controls[tmp_idx].value;
2624 tmp_idx = helpers[tmp_idx].next;
2625 } while (tmp_idx);
2626 /* If the new value == the manual value, then copy
2627 the current volatile values. */
2628 if (new_auto_val == master->manual_mode_value)
2629 update_from_auto_cluster(master);
2630 }
2631
2632 /* Copy the new caller-supplied control values.
2633 user_to_new() sets 'is_new' to 1. */
2634 do {
2635 ret = user_to_new(cs->controls + idx, helpers[idx].ctrl);
2636 idx = helpers[idx].next;
2637 } while (!ret && idx);
2638
2639 if (!ret)
2640 ret = try_or_set_cluster(fh, master, set, 0);
2641
2642 /* Copy the new values back to userspace. */
2643 if (!ret) {
2644 idx = i;
2645 do {
2646 ret = new_to_user(cs->controls + idx,
2647 helpers[idx].ctrl);
2648 idx = helpers[idx].next;
2649 } while (!ret && idx);
2650 }
2651 v4l2_ctrl_unlock(master);
2652 }
2653
2654 if (cs->count > ARRAY_SIZE(helper))
2655 kfree(helpers);
2656 return ret;
2657 }
2658
2659 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2660 {
2661 return try_set_ext_ctrls(NULL, hdl, cs, false);
2662 }
2663 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
2664
2665 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2666 struct v4l2_ext_controls *cs)
2667 {
2668 return try_set_ext_ctrls(fh, hdl, cs, true);
2669 }
2670 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
2671
2672 int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2673 {
2674 return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, false);
2675 }
2676 EXPORT_SYMBOL(v4l2_subdev_try_ext_ctrls);
2677
2678 int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2679 {
2680 return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, true);
2681 }
2682 EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
2683
2684 /* Helper function for VIDIOC_S_CTRL compatibility */
2685 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
2686 struct v4l2_ext_control *c, u32 ch_flags)
2687 {
2688 struct v4l2_ctrl *master = ctrl->cluster[0];
2689 int i;
2690
2691 /* String controls are not supported. The user_to_new() and
2692 * cur_to_user() calls below would need to be modified not to access
2693 * userspace memory when called from set_ctrl().
2694 */
2695 if (ctrl->type == V4L2_CTRL_TYPE_STRING)
2696 return -EINVAL;
2697
2698 /* Reset the 'is_new' flags of the cluster */
2699 for (i = 0; i < master->ncontrols; i++)
2700 if (master->cluster[i])
2701 master->cluster[i]->is_new = 0;
2702
2703 /* For autoclusters with volatiles that are switched from auto to
2704 manual mode we have to update the current volatile values since
2705 those will become the initial manual values after such a switch. */
2706 if (master->is_auto && master->has_volatiles && ctrl == master &&
2707 !is_cur_manual(master) && c->value == master->manual_mode_value)
2708 update_from_auto_cluster(master);
2709
2710 user_to_new(c, ctrl);
2711 return try_or_set_cluster(fh, master, true, ch_flags);
2712 }
2713
2714 /* Helper function for VIDIOC_S_CTRL compatibility */
2715 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
2716 struct v4l2_ext_control *c)
2717 {
2718 int ret = validate_new(ctrl, c);
2719
2720 if (!ret) {
2721 v4l2_ctrl_lock(ctrl);
2722 ret = set_ctrl(fh, ctrl, c, 0);
2723 if (!ret)
2724 cur_to_user(c, ctrl);
2725 v4l2_ctrl_unlock(ctrl);
2726 }
2727 return ret;
2728 }
2729
2730 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2731 struct v4l2_control *control)
2732 {
2733 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2734 struct v4l2_ext_control c;
2735 int ret;
2736
2737 if (ctrl == NULL || !type_is_int(ctrl))
2738 return -EINVAL;
2739
2740 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2741 return -EACCES;
2742
2743 c.value = control->value;
2744 ret = set_ctrl_lock(fh, ctrl, &c);
2745 control->value = c.value;
2746 return ret;
2747 }
2748 EXPORT_SYMBOL(v4l2_s_ctrl);
2749
2750 int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2751 {
2752 return v4l2_s_ctrl(NULL, sd->ctrl_handler, control);
2753 }
2754 EXPORT_SYMBOL(v4l2_subdev_s_ctrl);
2755
2756 int v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
2757 {
2758 struct v4l2_ext_control c;
2759
2760 /* It's a driver bug if this happens. */
2761 WARN_ON(!type_is_int(ctrl));
2762 c.value = val;
2763 return set_ctrl_lock(NULL, ctrl, &c);
2764 }
2765 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl);
2766
2767 int v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
2768 {
2769 struct v4l2_ext_control c;
2770
2771 /* It's a driver bug if this happens. */
2772 WARN_ON(ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2773 c.value64 = val;
2774 return set_ctrl_lock(NULL, ctrl, &c);
2775 }
2776 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl_int64);
2777
2778 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
2779 {
2780 if (ctrl == NULL)
2781 return;
2782 if (notify == NULL) {
2783 ctrl->call_notify = 0;
2784 return;
2785 }
2786 if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
2787 return;
2788 ctrl->handler->notify = notify;
2789 ctrl->handler->notify_priv = priv;
2790 ctrl->call_notify = 1;
2791 }
2792 EXPORT_SYMBOL(v4l2_ctrl_notify);
2793
2794 int v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
2795 s32 min, s32 max, u32 step, s32 def)
2796 {
2797 int ret = check_range(ctrl->type, min, max, step, def);
2798 struct v4l2_ext_control c;
2799
2800 switch (ctrl->type) {
2801 case V4L2_CTRL_TYPE_INTEGER:
2802 case V4L2_CTRL_TYPE_BOOLEAN:
2803 case V4L2_CTRL_TYPE_MENU:
2804 case V4L2_CTRL_TYPE_INTEGER_MENU:
2805 case V4L2_CTRL_TYPE_BITMASK:
2806 if (ret)
2807 return ret;
2808 break;
2809 default:
2810 return -EINVAL;
2811 }
2812 v4l2_ctrl_lock(ctrl);
2813 ctrl->minimum = min;
2814 ctrl->maximum = max;
2815 ctrl->step = step;
2816 ctrl->default_value = def;
2817 c.value = ctrl->cur.val;
2818 if (validate_new(ctrl, &c))
2819 c.value = def;
2820 if (c.value != ctrl->cur.val)
2821 ret = set_ctrl(NULL, ctrl, &c, V4L2_EVENT_CTRL_CH_RANGE);
2822 else
2823 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
2824 v4l2_ctrl_unlock(ctrl);
2825 return ret;
2826 }
2827 EXPORT_SYMBOL(v4l2_ctrl_modify_range);
2828
2829 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
2830 {
2831 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2832
2833 if (ctrl == NULL)
2834 return -EINVAL;
2835
2836 v4l2_ctrl_lock(ctrl);
2837 list_add_tail(&sev->node, &ctrl->ev_subs);
2838 if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
2839 (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
2840 struct v4l2_event ev;
2841 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
2842
2843 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
2844 changes |= V4L2_EVENT_CTRL_CH_VALUE;
2845 fill_event(&ev, ctrl, changes);
2846 /* Mark the queue as active, allowing this initial
2847 event to be accepted. */
2848 sev->elems = elems;
2849 v4l2_event_queue_fh(sev->fh, &ev);
2850 }
2851 v4l2_ctrl_unlock(ctrl);
2852 return 0;
2853 }
2854
2855 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
2856 {
2857 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2858
2859 v4l2_ctrl_lock(ctrl);
2860 list_del(&sev->node);
2861 v4l2_ctrl_unlock(ctrl);
2862 }
2863
2864 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
2865 {
2866 u32 old_changes = old->u.ctrl.changes;
2867
2868 old->u.ctrl = new->u.ctrl;
2869 old->u.ctrl.changes |= old_changes;
2870 }
2871 EXPORT_SYMBOL(v4l2_ctrl_replace);
2872
2873 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
2874 {
2875 new->u.ctrl.changes |= old->u.ctrl.changes;
2876 }
2877 EXPORT_SYMBOL(v4l2_ctrl_merge);
2878
2879 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
2880 .add = v4l2_ctrl_add_event,
2881 .del = v4l2_ctrl_del_event,
2882 .replace = v4l2_ctrl_replace,
2883 .merge = v4l2_ctrl_merge,
2884 };
2885 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
2886
2887 int v4l2_ctrl_log_status(struct file *file, void *fh)
2888 {
2889 struct video_device *vfd = video_devdata(file);
2890 struct v4l2_fh *vfh = file->private_data;
2891
2892 if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
2893 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
2894 vfd->v4l2_dev->name);
2895 return 0;
2896 }
2897 EXPORT_SYMBOL(v4l2_ctrl_log_status);
2898
2899 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
2900 const struct v4l2_event_subscription *sub)
2901 {
2902 if (sub->type == V4L2_EVENT_CTRL)
2903 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
2904 return -EINVAL;
2905 }
2906 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
2907
2908 int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
2909 struct v4l2_event_subscription *sub)
2910 {
2911 if (!sd->ctrl_handler)
2912 return -EINVAL;
2913 return v4l2_ctrl_subscribe_event(fh, sub);
2914 }
2915 EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
2916
2917 unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
2918 {
2919 struct v4l2_fh *fh = file->private_data;
2920
2921 if (v4l2_event_pending(fh))
2922 return POLLPRI;
2923 poll_wait(file, &fh->wait, wait);
2924 return 0;
2925 }
2926 EXPORT_SYMBOL(v4l2_ctrl_poll);
Ubuntu Focal Linux kernel mirror