]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/media/video/v4l2-ctrls.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


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