1 /*
2 V4L2 controls framework implementation.
3
4 Copyright (C) 2010 Hans Verkuil <hverkuil@xs4all.nl>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include <linux/ctype.h>
22 #include <linux/slab.h>
23 #include <linux/export.h>
24 #include <media/v4l2-ioctl.h>
25 #include <media/v4l2-device.h>
26 #include <media/v4l2-ctrls.h>
27 #include <media/v4l2-event.h>
28 #include <media/v4l2-dev.h>
29
30 #define has_op(master, op) \
31 (master->ops && master->ops->op)
32 #define call_op(master, op) \
33 (has_op(master, op) ? master->ops->op(master) : 0)
34
35 /* Internal temporary helper struct, one for each v4l2_ext_control */
36 struct v4l2_ctrl_helper {
37 /* Pointer to the control reference of the master control */
38 struct v4l2_ctrl_ref *mref;
39 /* The control corresponding to the v4l2_ext_control ID field. */
40 struct v4l2_ctrl *ctrl;
41 /* v4l2_ext_control index of the next control belonging to the
42 same cluster, or 0 if there isn't any. */
43 u32 next;
44 };
45
46 /* Small helper function to determine if the autocluster is set to manual
47 mode. */
is_cur_manual(const struct v4l2_ctrl * master)48 static bool is_cur_manual(const struct v4l2_ctrl *master)
49 {
50 return master->is_auto && master->cur.val == master->manual_mode_value;
51 }
52
53 /* Same as above, but this checks the against the new value instead of the
54 current value. */
is_new_manual(const struct v4l2_ctrl * master)55 static bool is_new_manual(const struct v4l2_ctrl *master)
56 {
57 return master->is_auto && master->val == master->manual_mode_value;
58 }
59
60 /* Returns NULL or a character pointer array containing the menu for
61 the given control ID. The pointer array ends with a NULL pointer.
62 An empty string signifies a menu entry that is invalid. This allows
63 drivers to disable certain options if it is not supported. */
v4l2_ctrl_get_menu(u32 id)64 const char * const *v4l2_ctrl_get_menu(u32 id)
65 {
66 static const char * const mpeg_audio_sampling_freq[] = {
67 "44.1 kHz",
68 "48 kHz",
69 "32 kHz",
70 NULL
71 };
72 static const char * const mpeg_audio_encoding[] = {
73 "MPEG-1/2 Layer I",
74 "MPEG-1/2 Layer II",
75 "MPEG-1/2 Layer III",
76 "MPEG-2/4 AAC",
77 "AC-3",
78 NULL
79 };
80 static const char * const mpeg_audio_l1_bitrate[] = {
81 "32 kbps",
82 "64 kbps",
83 "96 kbps",
84 "128 kbps",
85 "160 kbps",
86 "192 kbps",
87 "224 kbps",
88 "256 kbps",
89 "288 kbps",
90 "320 kbps",
91 "352 kbps",
92 "384 kbps",
93 "416 kbps",
94 "448 kbps",
95 NULL
96 };
97 static const char * const mpeg_audio_l2_bitrate[] = {
98 "32 kbps",
99 "48 kbps",
100 "56 kbps",
101 "64 kbps",
102 "80 kbps",
103 "96 kbps",
104 "112 kbps",
105 "128 kbps",
106 "160 kbps",
107 "192 kbps",
108 "224 kbps",
109 "256 kbps",
110 "320 kbps",
111 "384 kbps",
112 NULL
113 };
114 static const char * const mpeg_audio_l3_bitrate[] = {
115 "32 kbps",
116 "40 kbps",
117 "48 kbps",
118 "56 kbps",
119 "64 kbps",
120 "80 kbps",
121 "96 kbps",
122 "112 kbps",
123 "128 kbps",
124 "160 kbps",
125 "192 kbps",
126 "224 kbps",
127 "256 kbps",
128 "320 kbps",
129 NULL
130 };
131 static const char * const mpeg_audio_ac3_bitrate[] = {
132 "32 kbps",
133 "40 kbps",
134 "48 kbps",
135 "56 kbps",
136 "64 kbps",
137 "80 kbps",
138 "96 kbps",
139 "112 kbps",
140 "128 kbps",
141 "160 kbps",
142 "192 kbps",
143 "224 kbps",
144 "256 kbps",
145 "320 kbps",
146 "384 kbps",
147 "448 kbps",
148 "512 kbps",
149 "576 kbps",
150 "640 kbps",
151 NULL
152 };
153 static const char * const mpeg_audio_mode[] = {
154 "Stereo",
155 "Joint Stereo",
156 "Dual",
157 "Mono",
158 NULL
159 };
160 static const char * const mpeg_audio_mode_extension[] = {
161 "Bound 4",
162 "Bound 8",
163 "Bound 12",
164 "Bound 16",
165 NULL
166 };
167 static const char * const mpeg_audio_emphasis[] = {
168 "No Emphasis",
169 "50/15 us",
170 "CCITT J17",
171 NULL
172 };
173 static const char * const mpeg_audio_crc[] = {
174 "No CRC",
175 "16-bit CRC",
176 NULL
177 };
178 static const char * const mpeg_audio_dec_playback[] = {
179 "Auto",
180 "Stereo",
181 "Left",
182 "Right",
183 "Mono",
184 "Swapped Stereo",
185 NULL
186 };
187 static const char * const mpeg_video_encoding[] = {
188 "MPEG-1",
189 "MPEG-2",
190 "MPEG-4 AVC",
191 NULL
192 };
193 static const char * const mpeg_video_aspect[] = {
194 "1x1",
195 "4x3",
196 "16x9",
197 "2.21x1",
198 NULL
199 };
200 static const char * const mpeg_video_bitrate_mode[] = {
201 "Variable Bitrate",
202 "Constant Bitrate",
203 NULL
204 };
205 static const char * const mpeg_stream_type[] = {
206 "MPEG-2 Program Stream",
207 "MPEG-2 Transport Stream",
208 "MPEG-1 System Stream",
209 "MPEG-2 DVD-compatible Stream",
210 "MPEG-1 VCD-compatible Stream",
211 "MPEG-2 SVCD-compatible Stream",
212 NULL
213 };
214 static const char * const mpeg_stream_vbi_fmt[] = {
215 "No VBI",
216 "Private Packet, IVTV Format",
217 NULL
218 };
219 static const char * const camera_power_line_frequency[] = {
220 "Disabled",
221 "50 Hz",
222 "60 Hz",
223 "Auto",
224 NULL
225 };
226 static const char * const camera_exposure_auto[] = {
227 "Auto Mode",
228 "Manual Mode",
229 "Shutter Priority Mode",
230 "Aperture Priority Mode",
231 NULL
232 };
233 static const char * const camera_exposure_metering[] = {
234 "Average",
235 "Center Weighted",
236 "Spot",
237 "Matrix",
238 NULL
239 };
240 static const char * const camera_auto_focus_range[] = {
241 "Auto",
242 "Normal",
243 "Macro",
244 "Infinity",
245 NULL
246 };
247 static const char * const colorfx[] = {
248 "None",
249 "Black & White",
250 "Sepia",
251 "Negative",
252 "Emboss",
253 "Sketch",
254 "Sky Blue",
255 "Grass Green",
256 "Skin Whiten",
257 "Vivid",
258 "Aqua",
259 "Art Freeze",
260 "Silhouette",
261 "Solarization",
262 "Antique",
263 "Set Cb/Cr",
264 NULL
265 };
266 static const char * const auto_n_preset_white_balance[] = {
267 "Manual",
268 "Auto",
269 "Incandescent",
270 "Fluorescent",
271 "Fluorescent H",
272 "Horizon",
273 "Daylight",
274 "Flash",
275 "Cloudy",
276 "Shade",
277 NULL,
278 };
279 static const char * const camera_iso_sensitivity_auto[] = {
280 "Manual",
281 "Auto",
282 NULL
283 };
284 static const char * const scene_mode[] = {
285 "None",
286 "Backlight",
287 "Beach/Snow",
288 "Candle Light",
289 "Dusk/Dawn",
290 "Fall Colors",
291 "Fireworks",
292 "Landscape",
293 "Night",
294 "Party/Indoor",
295 "Portrait",
296 "Sports",
297 "Sunset",
298 "Text",
299 NULL
300 };
301 static const char * const tune_emphasis[] = {
302 "None",
303 "50 Microseconds",
304 "75 Microseconds",
305 NULL,
306 };
307 static const char * const header_mode[] = {
308 "Separate Buffer",
309 "Joined With 1st Frame",
310 NULL,
311 };
312 static const char * const multi_slice[] = {
313 "Single",
314 "Max Macroblocks",
315 "Max Bytes",
316 NULL,
317 };
318 static const char * const entropy_mode[] = {
319 "CAVLC",
320 "CABAC",
321 NULL,
322 };
323 static const char * const mpeg_h264_level[] = {
324 "1",
325 "1b",
326 "1.1",
327 "1.2",
328 "1.3",
329 "2",
330 "2.1",
331 "2.2",
332 "3",
333 "3.1",
334 "3.2",
335 "4",
336 "4.1",
337 "4.2",
338 "5",
339 "5.1",
340 NULL,
341 };
342 static const char * const h264_loop_filter[] = {
343 "Enabled",
344 "Disabled",
345 "Disabled at Slice Boundary",
346 NULL,
347 };
348 static const char * const h264_profile[] = {
349 "Baseline",
350 "Constrained Baseline",
351 "Main",
352 "Extended",
353 "High",
354 "High 10",
355 "High 422",
356 "High 444 Predictive",
357 "High 10 Intra",
358 "High 422 Intra",
359 "High 444 Intra",
360 "CAVLC 444 Intra",
361 "Scalable Baseline",
362 "Scalable High",
363 "Scalable High Intra",
364 "Multiview High",
365 NULL,
366 };
367 static const char * const vui_sar_idc[] = {
368 "Unspecified",
369 "1:1",
370 "12:11",
371 "10:11",
372 "16:11",
373 "40:33",
374 "24:11",
375 "20:11",
376 "32:11",
377 "80:33",
378 "18:11",
379 "15:11",
380 "64:33",
381 "160:99",
382 "4:3",
383 "3:2",
384 "2:1",
385 "Extended SAR",
386 NULL,
387 };
388 static const char * const h264_fp_arrangement_type[] = {
389 "Checkerboard",
390 "Column",
391 "Row",
392 "Side by Side",
393 "Top Bottom",
394 "Temporal",
395 NULL,
396 };
397 static const char * const h264_fmo_map_type[] = {
398 "Interleaved Slices",
399 "Scattered Slices",
400 "Foreground with Leftover",
401 "Box Out",
402 "Raster Scan",
403 "Wipe Scan",
404 "Explicit",
405 NULL,
406 };
407 static const char * const mpeg_mpeg4_level[] = {
408 "0",
409 "0b",
410 "1",
411 "2",
412 "3",
413 "3b",
414 "4",
415 "5",
416 NULL,
417 };
418 static const char * const mpeg4_profile[] = {
419 "Simple",
420 "Advanced Simple",
421 "Core",
422 "Simple Scalable",
423 "Advanced Coding 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. */
v4l2_ctrl_get_name(u32 id)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
v4l2_ctrl_fill(u32 id,const char ** name,enum v4l2_ctrl_type * type,s32 * min,s32 * max,s32 * step,s32 * def,u32 * flags)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. */
type_is_int(const struct v4l2_ctrl * 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
fill_event(struct v4l2_event * ev,struct v4l2_ctrl * ctrl,u32 changes)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
send_event(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,u32 changes)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 */
cur_to_user(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl)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 */
user_to_new(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl)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 */
new_to_user(struct v4l2_ext_control * c,struct v4l2_ctrl * ctrl)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. */
new_to_cur(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,u32 ch_flags)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 */
cur_to_new(struct v4l2_ctrl * ctrl)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. */
cluster_changed(struct v4l2_ctrl * master)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 */
check_range(enum v4l2_ctrl_type type,s32 min,s32 max,u32 step,s32 def)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 */
validate_new(const struct v4l2_ctrl * ctrl,struct v4l2_ext_control * c)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
node2id(struct list_head * node)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 */
handler_set_err(struct v4l2_ctrl_handler * hdl,int err)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 */
v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler * hdl,unsigned nr_of_controls_hint,struct lock_class_key * key,const char * name)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 */
v4l2_ctrl_handler_free(struct v4l2_ctrl_handler * hdl)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. */
find_private_ref(struct v4l2_ctrl_handler * hdl,u32 id)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. */
find_ref(struct v4l2_ctrl_handler * hdl,u32 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. */
find_ref_lock(struct v4l2_ctrl_handler * hdl,u32 id)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. */
v4l2_ctrl_find(struct v4l2_ctrl_handler * hdl,u32 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. */
handler_new_ref(struct v4l2_ctrl_handler * hdl,struct v4l2_ctrl * ctrl)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 */
v4l2_ctrl_new(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,const char * name,enum v4l2_ctrl_type type,s32 min,s32 max,u32 step,s32 def,u32 flags,const char * const * qmenu,const s64 * qmenu_int,void * priv)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
v4l2_ctrl_new_custom(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_config * cfg,void * priv)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 */
v4l2_ctrl_new_std(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,s32 min,s32 max,u32 step,s32 def)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 */
v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,s32 max,s32 mask,s32 def)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 */
v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,s32 max,s32 mask,s32 def,const char * const * qmenu)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 */
v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler * hdl,const struct v4l2_ctrl_ops * ops,u32 id,s32 max,s32 def,const s64 * qmenu_int)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 */
v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_ctrl * ctrl)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. */
v4l2_ctrl_add_handler(struct v4l2_ctrl_handler * hdl,struct v4l2_ctrl_handler * add,bool (* filter)(const struct v4l2_ctrl * ctrl))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
v4l2_ctrl_radio_filter(const struct v4l2_ctrl * ctrl)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 if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
1839 return true;
1840 switch (ctrl->id) {
1841 case V4L2_CID_AUDIO_MUTE:
1842 case V4L2_CID_AUDIO_VOLUME:
1843 case V4L2_CID_AUDIO_BALANCE:
1844 case V4L2_CID_AUDIO_BASS:
1845 case V4L2_CID_AUDIO_TREBLE:
1846 case V4L2_CID_AUDIO_LOUDNESS:
1847 return true;
1848 default:
1849 break;
1850 }
1851 return false;
1852 }
1853 EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
1854
1855 /* Cluster controls */
v4l2_ctrl_cluster(unsigned ncontrols,struct v4l2_ctrl ** controls)1856 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
1857 {
1858 bool has_volatiles = false;
1859 int i;
1860
1861 /* The first control is the master control and it must not be NULL */
1862 BUG_ON(ncontrols == 0 || controls[0] == NULL);
1863
1864 for (i = 0; i < ncontrols; i++) {
1865 if (controls[i]) {
1866 controls[i]->cluster = controls;
1867 controls[i]->ncontrols = ncontrols;
1868 if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
1869 has_volatiles = true;
1870 }
1871 }
1872 controls[0]->has_volatiles = has_volatiles;
1873 }
1874 EXPORT_SYMBOL(v4l2_ctrl_cluster);
1875
v4l2_ctrl_auto_cluster(unsigned ncontrols,struct v4l2_ctrl ** controls,u8 manual_val,bool set_volatile)1876 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
1877 u8 manual_val, bool set_volatile)
1878 {
1879 struct v4l2_ctrl *master = controls[0];
1880 u32 flag = 0;
1881 int i;
1882
1883 v4l2_ctrl_cluster(ncontrols, controls);
1884 WARN_ON(ncontrols <= 1);
1885 WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
1886 WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
1887 master->is_auto = true;
1888 master->has_volatiles = set_volatile;
1889 master->manual_mode_value = manual_val;
1890 master->flags |= V4L2_CTRL_FLAG_UPDATE;
1891
1892 if (!is_cur_manual(master))
1893 flag = V4L2_CTRL_FLAG_INACTIVE |
1894 (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
1895
1896 for (i = 1; i < ncontrols; i++)
1897 if (controls[i])
1898 controls[i]->flags |= flag;
1899 }
1900 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
1901
1902 /* Activate/deactivate a control. */
v4l2_ctrl_activate(struct v4l2_ctrl * ctrl,bool active)1903 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
1904 {
1905 /* invert since the actual flag is called 'inactive' */
1906 bool inactive = !active;
1907 bool old;
1908
1909 if (ctrl == NULL)
1910 return;
1911
1912 if (inactive)
1913 /* set V4L2_CTRL_FLAG_INACTIVE */
1914 old = test_and_set_bit(4, &ctrl->flags);
1915 else
1916 /* clear V4L2_CTRL_FLAG_INACTIVE */
1917 old = test_and_clear_bit(4, &ctrl->flags);
1918 if (old != inactive)
1919 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1920 }
1921 EXPORT_SYMBOL(v4l2_ctrl_activate);
1922
1923 /* Grab/ungrab a control.
1924 Typically used when streaming starts and you want to grab controls,
1925 preventing the user from changing them.
1926
1927 Just call this and the framework will block any attempts to change
1928 these controls. */
v4l2_ctrl_grab(struct v4l2_ctrl * ctrl,bool grabbed)1929 void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
1930 {
1931 bool old;
1932
1933 if (ctrl == NULL)
1934 return;
1935
1936 v4l2_ctrl_lock(ctrl);
1937 if (grabbed)
1938 /* set V4L2_CTRL_FLAG_GRABBED */
1939 old = test_and_set_bit(1, &ctrl->flags);
1940 else
1941 /* clear V4L2_CTRL_FLAG_GRABBED */
1942 old = test_and_clear_bit(1, &ctrl->flags);
1943 if (old != grabbed)
1944 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1945 v4l2_ctrl_unlock(ctrl);
1946 }
1947 EXPORT_SYMBOL(v4l2_ctrl_grab);
1948
1949 /* Log the control name and value */
log_ctrl(const struct v4l2_ctrl * ctrl,const char * prefix,const char * colon)1950 static void log_ctrl(const struct v4l2_ctrl *ctrl,
1951 const char *prefix, const char *colon)
1952 {
1953 if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
1954 return;
1955 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1956 return;
1957
1958 printk(KERN_INFO "%s%s%s: ", prefix, colon, ctrl->name);
1959
1960 switch (ctrl->type) {
1961 case V4L2_CTRL_TYPE_INTEGER:
1962 printk(KERN_CONT "%d", ctrl->cur.val);
1963 break;
1964 case V4L2_CTRL_TYPE_BOOLEAN:
1965 printk(KERN_CONT "%s", ctrl->cur.val ? "true" : "false");
1966 break;
1967 case V4L2_CTRL_TYPE_MENU:
1968 printk(KERN_CONT "%s", ctrl->qmenu[ctrl->cur.val]);
1969 break;
1970 case V4L2_CTRL_TYPE_INTEGER_MENU:
1971 printk(KERN_CONT "%lld", ctrl->qmenu_int[ctrl->cur.val]);
1972 break;
1973 case V4L2_CTRL_TYPE_BITMASK:
1974 printk(KERN_CONT "0x%08x", ctrl->cur.val);
1975 break;
1976 case V4L2_CTRL_TYPE_INTEGER64:
1977 printk(KERN_CONT "%lld", ctrl->cur.val64);
1978 break;
1979 case V4L2_CTRL_TYPE_STRING:
1980 printk(KERN_CONT "%s", ctrl->cur.string);
1981 break;
1982 default:
1983 printk(KERN_CONT "unknown type %d", ctrl->type);
1984 break;
1985 }
1986 if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
1987 V4L2_CTRL_FLAG_GRABBED |
1988 V4L2_CTRL_FLAG_VOLATILE)) {
1989 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
1990 printk(KERN_CONT " inactive");
1991 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
1992 printk(KERN_CONT " grabbed");
1993 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
1994 printk(KERN_CONT " volatile");
1995 }
1996 printk(KERN_CONT "\n");
1997 }
1998
1999 /* Log all controls owned by the handler */
v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler * hdl,const char * prefix)2000 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
2001 const char *prefix)
2002 {
2003 struct v4l2_ctrl *ctrl;
2004 const char *colon = "";
2005 int len;
2006
2007 if (hdl == NULL)
2008 return;
2009 if (prefix == NULL)
2010 prefix = "";
2011 len = strlen(prefix);
2012 if (len && prefix[len - 1] != ' ')
2013 colon = ": ";
2014 mutex_lock(hdl->lock);
2015 list_for_each_entry(ctrl, &hdl->ctrls, node)
2016 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2017 log_ctrl(ctrl, prefix, colon);
2018 mutex_unlock(hdl->lock);
2019 }
2020 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2021
v4l2_ctrl_subdev_log_status(struct v4l2_subdev * sd)2022 int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
2023 {
2024 v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
2025 return 0;
2026 }
2027 EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
2028
2029 /* Call s_ctrl for all controls owned by the handler */
v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler * hdl)2030 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2031 {
2032 struct v4l2_ctrl *ctrl;
2033 int ret = 0;
2034
2035 if (hdl == NULL)
2036 return 0;
2037 mutex_lock(hdl->lock);
2038 list_for_each_entry(ctrl, &hdl->ctrls, node)
2039 ctrl->done = false;
2040
2041 list_for_each_entry(ctrl, &hdl->ctrls, node) {
2042 struct v4l2_ctrl *master = ctrl->cluster[0];
2043 int i;
2044
2045 /* Skip if this control was already handled by a cluster. */
2046 /* Skip button controls and read-only controls. */
2047 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2048 (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2049 continue;
2050
2051 for (i = 0; i < master->ncontrols; i++) {
2052 if (master->cluster[i]) {
2053 cur_to_new(master->cluster[i]);
2054 master->cluster[i]->is_new = 1;
2055 master->cluster[i]->done = true;
2056 }
2057 }
2058 ret = call_op(master, s_ctrl);
2059 if (ret)
2060 break;
2061 }
2062 mutex_unlock(hdl->lock);
2063 return ret;
2064 }
2065 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2066
2067 /* Implement VIDIOC_QUERYCTRL */
v4l2_queryctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_queryctrl * qc)2068 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
2069 {
2070 u32 id = qc->id & V4L2_CTRL_ID_MASK;
2071 struct v4l2_ctrl_ref *ref;
2072 struct v4l2_ctrl *ctrl;
2073
2074 if (hdl == NULL)
2075 return -EINVAL;
2076
2077 mutex_lock(hdl->lock);
2078
2079 /* Try to find it */
2080 ref = find_ref(hdl, id);
2081
2082 if ((qc->id & V4L2_CTRL_FLAG_NEXT_CTRL) && !list_empty(&hdl->ctrl_refs)) {
2083 /* Find the next control with ID > qc->id */
2084
2085 /* Did we reach the end of the control list? */
2086 if (id >= node2id(hdl->ctrl_refs.prev)) {
2087 ref = NULL; /* Yes, so there is no next control */
2088 } else if (ref) {
2089 /* We found a control with the given ID, so just get
2090 the next one in the list. */
2091 ref = list_entry(ref->node.next, typeof(*ref), node);
2092 } else {
2093 /* No control with the given ID exists, so start
2094 searching for the next largest ID. We know there
2095 is one, otherwise the first 'if' above would have
2096 been true. */
2097 list_for_each_entry(ref, &hdl->ctrl_refs, node)
2098 if (id < ref->ctrl->id)
2099 break;
2100 }
2101 }
2102 mutex_unlock(hdl->lock);
2103 if (!ref)
2104 return -EINVAL;
2105
2106 ctrl = ref->ctrl;
2107 memset(qc, 0, sizeof(*qc));
2108 if (id >= V4L2_CID_PRIVATE_BASE)
2109 qc->id = id;
2110 else
2111 qc->id = ctrl->id;
2112 strlcpy(qc->name, ctrl->name, sizeof(qc->name));
2113 qc->minimum = ctrl->minimum;
2114 qc->maximum = ctrl->maximum;
2115 qc->default_value = ctrl->default_value;
2116 if (ctrl->type == V4L2_CTRL_TYPE_MENU
2117 || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
2118 qc->step = 1;
2119 else
2120 qc->step = ctrl->step;
2121 qc->flags = ctrl->flags;
2122 qc->type = ctrl->type;
2123 return 0;
2124 }
2125 EXPORT_SYMBOL(v4l2_queryctrl);
2126
v4l2_subdev_queryctrl(struct v4l2_subdev * sd,struct v4l2_queryctrl * qc)2127 int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
2128 {
2129 if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL)
2130 return -EINVAL;
2131 return v4l2_queryctrl(sd->ctrl_handler, qc);
2132 }
2133 EXPORT_SYMBOL(v4l2_subdev_queryctrl);
2134
2135 /* Implement VIDIOC_QUERYMENU */
v4l2_querymenu(struct v4l2_ctrl_handler * hdl,struct v4l2_querymenu * qm)2136 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
2137 {
2138 struct v4l2_ctrl *ctrl;
2139 u32 i = qm->index;
2140
2141 ctrl = v4l2_ctrl_find(hdl, qm->id);
2142 if (!ctrl)
2143 return -EINVAL;
2144
2145 qm->reserved = 0;
2146 /* Sanity checks */
2147 switch (ctrl->type) {
2148 case V4L2_CTRL_TYPE_MENU:
2149 if (ctrl->qmenu == NULL)
2150 return -EINVAL;
2151 break;
2152 case V4L2_CTRL_TYPE_INTEGER_MENU:
2153 if (ctrl->qmenu_int == NULL)
2154 return -EINVAL;
2155 break;
2156 default:
2157 return -EINVAL;
2158 }
2159
2160 if (i < ctrl->minimum || i > ctrl->maximum)
2161 return -EINVAL;
2162
2163 /* Use mask to see if this menu item should be skipped */
2164 if (ctrl->menu_skip_mask & (1 << i))
2165 return -EINVAL;
2166 /* Empty menu items should also be skipped */
2167 if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
2168 if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
2169 return -EINVAL;
2170 strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
2171 } else {
2172 qm->value = ctrl->qmenu_int[i];
2173 }
2174 return 0;
2175 }
2176 EXPORT_SYMBOL(v4l2_querymenu);
2177
v4l2_subdev_querymenu(struct v4l2_subdev * sd,struct v4l2_querymenu * qm)2178 int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
2179 {
2180 return v4l2_querymenu(sd->ctrl_handler, qm);
2181 }
2182 EXPORT_SYMBOL(v4l2_subdev_querymenu);
2183
2184
2185
2186 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
2187
2188 It is not a fully atomic operation, just best-effort only. After all, if
2189 multiple controls have to be set through multiple i2c writes (for example)
2190 then some initial writes may succeed while others fail. Thus leaving the
2191 system in an inconsistent state. The question is how much effort you are
2192 willing to spend on trying to make something atomic that really isn't.
2193
2194 From the point of view of an application the main requirement is that
2195 when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
2196 error should be returned without actually affecting any controls.
2197
2198 If all the values are correct, then it is acceptable to just give up
2199 in case of low-level errors.
2200
2201 It is important though that the application can tell when only a partial
2202 configuration was done. The way we do that is through the error_idx field
2203 of struct v4l2_ext_controls: if that is equal to the count field then no
2204 controls were affected. Otherwise all controls before that index were
2205 successful in performing their 'get' or 'set' operation, the control at
2206 the given index failed, and you don't know what happened with the controls
2207 after the failed one. Since if they were part of a control cluster they
2208 could have been successfully processed (if a cluster member was encountered
2209 at index < error_idx), they could have failed (if a cluster member was at
2210 error_idx), or they may not have been processed yet (if the first cluster
2211 member appeared after error_idx).
2212
2213 It is all fairly theoretical, though. In practice all you can do is to
2214 bail out. If error_idx == count, then it is an application bug. If
2215 error_idx < count then it is only an application bug if the error code was
2216 EBUSY. That usually means that something started streaming just when you
2217 tried to set the controls. In all other cases it is a driver/hardware
2218 problem and all you can do is to retry or bail out.
2219
2220 Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
2221 never modifies controls the error_idx is just set to whatever control
2222 has an invalid value.
2223 */
2224
2225 /* Prepare for the extended g/s/try functions.
2226 Find the controls in the control array and do some basic checks. */
prepare_ext_ctrls(struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs,struct v4l2_ctrl_helper * helpers)2227 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
2228 struct v4l2_ext_controls *cs,
2229 struct v4l2_ctrl_helper *helpers)
2230 {
2231 struct v4l2_ctrl_helper *h;
2232 bool have_clusters = false;
2233 u32 i;
2234
2235 for (i = 0, h = helpers; i < cs->count; i++, h++) {
2236 struct v4l2_ext_control *c = &cs->controls[i];
2237 struct v4l2_ctrl_ref *ref;
2238 struct v4l2_ctrl *ctrl;
2239 u32 id = c->id & V4L2_CTRL_ID_MASK;
2240
2241 cs->error_idx = i;
2242
2243 if (cs->ctrl_class && V4L2_CTRL_ID2CLASS(id) != cs->ctrl_class)
2244 return -EINVAL;
2245
2246 /* Old-style private controls are not allowed for
2247 extended controls */
2248 if (id >= V4L2_CID_PRIVATE_BASE)
2249 return -EINVAL;
2250 ref = find_ref_lock(hdl, id);
2251 if (ref == NULL)
2252 return -EINVAL;
2253 ctrl = ref->ctrl;
2254 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
2255 return -EINVAL;
2256
2257 if (ctrl->cluster[0]->ncontrols > 1)
2258 have_clusters = true;
2259 if (ctrl->cluster[0] != ctrl)
2260 ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
2261 /* Store the ref to the master control of the cluster */
2262 h->mref = ref;
2263 h->ctrl = ctrl;
2264 /* Initially set next to 0, meaning that there is no other
2265 control in this helper array belonging to the same
2266 cluster */
2267 h->next = 0;
2268 }
2269
2270 /* We are done if there were no controls that belong to a multi-
2271 control cluster. */
2272 if (!have_clusters)
2273 return 0;
2274
2275 /* The code below figures out in O(n) time which controls in the list
2276 belong to the same cluster. */
2277
2278 /* This has to be done with the handler lock taken. */
2279 mutex_lock(hdl->lock);
2280
2281 /* First zero the helper field in the master control references */
2282 for (i = 0; i < cs->count; i++)
2283 helpers[i].mref->helper = NULL;
2284 for (i = 0, h = helpers; i < cs->count; i++, h++) {
2285 struct v4l2_ctrl_ref *mref = h->mref;
2286
2287 /* If the mref->helper is set, then it points to an earlier
2288 helper that belongs to the same cluster. */
2289 if (mref->helper) {
2290 /* Set the next field of mref->helper to the current
2291 index: this means that that earlier helper now
2292 points to the next helper in the same cluster. */
2293 mref->helper->next = i;
2294 /* mref should be set only for the first helper in the
2295 cluster, clear the others. */
2296 h->mref = NULL;
2297 }
2298 /* Point the mref helper to the current helper struct. */
2299 mref->helper = h;
2300 }
2301 mutex_unlock(hdl->lock);
2302 return 0;
2303 }
2304
2305 /* Handles the corner case where cs->count == 0. It checks whether the
2306 specified control class exists. If that class ID is 0, then it checks
2307 whether there are any controls at all. */
class_check(struct v4l2_ctrl_handler * hdl,u32 ctrl_class)2308 static int class_check(struct v4l2_ctrl_handler *hdl, u32 ctrl_class)
2309 {
2310 if (ctrl_class == 0)
2311 return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
2312 return find_ref_lock(hdl, ctrl_class | 1) ? 0 : -EINVAL;
2313 }
2314
2315
2316
2317 /* Get extended controls. Allocates the helpers array if needed. */
v4l2_g_ext_ctrls(struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs)2318 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2319 {
2320 struct v4l2_ctrl_helper helper[4];
2321 struct v4l2_ctrl_helper *helpers = helper;
2322 int ret;
2323 int i, j;
2324
2325 cs->error_idx = cs->count;
2326 cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2327
2328 if (hdl == NULL)
2329 return -EINVAL;
2330
2331 if (cs->count == 0)
2332 return class_check(hdl, cs->ctrl_class);
2333
2334 if (cs->count > ARRAY_SIZE(helper)) {
2335 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2336 GFP_KERNEL);
2337 if (helpers == NULL)
2338 return -ENOMEM;
2339 }
2340
2341 ret = prepare_ext_ctrls(hdl, cs, helpers);
2342 cs->error_idx = cs->count;
2343
2344 for (i = 0; !ret && i < cs->count; i++)
2345 if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2346 ret = -EACCES;
2347
2348 for (i = 0; !ret && i < cs->count; i++) {
2349 int (*ctrl_to_user)(struct v4l2_ext_control *c,
2350 struct v4l2_ctrl *ctrl) = cur_to_user;
2351 struct v4l2_ctrl *master;
2352
2353 if (helpers[i].mref == NULL)
2354 continue;
2355
2356 master = helpers[i].mref->ctrl;
2357 cs->error_idx = i;
2358
2359 v4l2_ctrl_lock(master);
2360
2361 /* g_volatile_ctrl will update the new control values */
2362 if ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
2363 (master->has_volatiles && !is_cur_manual(master))) {
2364 for (j = 0; j < master->ncontrols; j++)
2365 cur_to_new(master->cluster[j]);
2366 ret = call_op(master, g_volatile_ctrl);
2367 ctrl_to_user = new_to_user;
2368 }
2369 /* If OK, then copy the current (for non-volatile controls)
2370 or the new (for volatile controls) control values to the
2371 caller */
2372 if (!ret) {
2373 u32 idx = i;
2374
2375 do {
2376 ret = ctrl_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 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
2389
v4l2_subdev_g_ext_ctrls(struct v4l2_subdev * sd,struct v4l2_ext_controls * cs)2390 int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2391 {
2392 return v4l2_g_ext_ctrls(sd->ctrl_handler, cs);
2393 }
2394 EXPORT_SYMBOL(v4l2_subdev_g_ext_ctrls);
2395
2396 /* Helper function to get a single control */
get_ctrl(struct v4l2_ctrl * ctrl,struct v4l2_ext_control * c)2397 static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
2398 {
2399 struct v4l2_ctrl *master = ctrl->cluster[0];
2400 int ret = 0;
2401 int i;
2402
2403 /* String controls are not supported. The new_to_user() and
2404 * cur_to_user() calls below would need to be modified not to access
2405 * userspace memory when called from get_ctrl().
2406 */
2407 if (ctrl->type == V4L2_CTRL_TYPE_STRING)
2408 return -EINVAL;
2409
2410 if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2411 return -EACCES;
2412
2413 v4l2_ctrl_lock(master);
2414 /* g_volatile_ctrl will update the current control values */
2415 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2416 for (i = 0; i < master->ncontrols; i++)
2417 cur_to_new(master->cluster[i]);
2418 ret = call_op(master, g_volatile_ctrl);
2419 new_to_user(c, ctrl);
2420 } else {
2421 cur_to_user(c, ctrl);
2422 }
2423 v4l2_ctrl_unlock(master);
2424 return ret;
2425 }
2426
v4l2_g_ctrl(struct v4l2_ctrl_handler * hdl,struct v4l2_control * control)2427 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
2428 {
2429 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2430 struct v4l2_ext_control c;
2431 int ret;
2432
2433 if (ctrl == NULL || !type_is_int(ctrl))
2434 return -EINVAL;
2435 ret = get_ctrl(ctrl, &c);
2436 control->value = c.value;
2437 return ret;
2438 }
2439 EXPORT_SYMBOL(v4l2_g_ctrl);
2440
v4l2_subdev_g_ctrl(struct v4l2_subdev * sd,struct v4l2_control * control)2441 int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2442 {
2443 return v4l2_g_ctrl(sd->ctrl_handler, control);
2444 }
2445 EXPORT_SYMBOL(v4l2_subdev_g_ctrl);
2446
v4l2_ctrl_g_ctrl(struct v4l2_ctrl * ctrl)2447 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
2448 {
2449 struct v4l2_ext_control c;
2450
2451 /* It's a driver bug if this happens. */
2452 WARN_ON(!type_is_int(ctrl));
2453 c.value = 0;
2454 get_ctrl(ctrl, &c);
2455 return c.value;
2456 }
2457 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
2458
v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl * ctrl)2459 s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
2460 {
2461 struct v4l2_ext_control c;
2462
2463 /* It's a driver bug if this happens. */
2464 WARN_ON(ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2465 c.value = 0;
2466 get_ctrl(ctrl, &c);
2467 return c.value;
2468 }
2469 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
2470
2471
2472 /* Core function that calls try/s_ctrl and ensures that the new value is
2473 copied to the current value on a set.
2474 Must be called with ctrl->handler->lock held. */
try_or_set_cluster(struct v4l2_fh * fh,struct v4l2_ctrl * master,bool set,u32 ch_flags)2475 static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
2476 bool set, u32 ch_flags)
2477 {
2478 bool update_flag;
2479 int ret;
2480 int i;
2481
2482 /* Go through the cluster and either validate the new value or
2483 (if no new value was set), copy the current value to the new
2484 value, ensuring a consistent view for the control ops when
2485 called. */
2486 for (i = 0; i < master->ncontrols; i++) {
2487 struct v4l2_ctrl *ctrl = master->cluster[i];
2488
2489 if (ctrl == NULL)
2490 continue;
2491
2492 if (!ctrl->is_new) {
2493 cur_to_new(ctrl);
2494 continue;
2495 }
2496 /* Check again: it may have changed since the
2497 previous check in try_or_set_ext_ctrls(). */
2498 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2499 return -EBUSY;
2500 }
2501
2502 ret = call_op(master, try_ctrl);
2503
2504 /* Don't set if there is no change */
2505 if (ret || !set || !cluster_changed(master))
2506 return ret;
2507 ret = call_op(master, s_ctrl);
2508 if (ret)
2509 return ret;
2510
2511 /* If OK, then make the new values permanent. */
2512 update_flag = is_cur_manual(master) != is_new_manual(master);
2513 for (i = 0; i < master->ncontrols; i++)
2514 new_to_cur(fh, master->cluster[i], ch_flags |
2515 ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
2516 return 0;
2517 }
2518
2519 /* Validate controls. */
validate_ctrls(struct v4l2_ext_controls * cs,struct v4l2_ctrl_helper * helpers,bool set)2520 static int validate_ctrls(struct v4l2_ext_controls *cs,
2521 struct v4l2_ctrl_helper *helpers, bool set)
2522 {
2523 unsigned i;
2524 int ret = 0;
2525
2526 cs->error_idx = cs->count;
2527 for (i = 0; i < cs->count; i++) {
2528 struct v4l2_ctrl *ctrl = helpers[i].ctrl;
2529
2530 cs->error_idx = i;
2531
2532 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2533 return -EACCES;
2534 /* This test is also done in try_set_control_cluster() which
2535 is called in atomic context, so that has the final say,
2536 but it makes sense to do an up-front check as well. Once
2537 an error occurs in try_set_control_cluster() some other
2538 controls may have been set already and we want to do a
2539 best-effort to avoid that. */
2540 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2541 return -EBUSY;
2542 ret = validate_new(ctrl, &cs->controls[i]);
2543 if (ret)
2544 return ret;
2545 }
2546 return 0;
2547 }
2548
2549 /* Obtain the current volatile values of an autocluster and mark them
2550 as new. */
update_from_auto_cluster(struct v4l2_ctrl * master)2551 static void update_from_auto_cluster(struct v4l2_ctrl *master)
2552 {
2553 int i;
2554
2555 for (i = 0; i < master->ncontrols; i++)
2556 cur_to_new(master->cluster[i]);
2557 if (!call_op(master, g_volatile_ctrl))
2558 for (i = 1; i < master->ncontrols; i++)
2559 if (master->cluster[i])
2560 master->cluster[i]->is_new = 1;
2561 }
2562
2563 /* Try or try-and-set controls */
try_set_ext_ctrls(struct v4l2_fh * fh,struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs,bool set)2564 static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2565 struct v4l2_ext_controls *cs,
2566 bool set)
2567 {
2568 struct v4l2_ctrl_helper helper[4];
2569 struct v4l2_ctrl_helper *helpers = helper;
2570 unsigned i, j;
2571 int ret;
2572
2573 cs->error_idx = cs->count;
2574 cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2575
2576 if (hdl == NULL)
2577 return -EINVAL;
2578
2579 if (cs->count == 0)
2580 return class_check(hdl, cs->ctrl_class);
2581
2582 if (cs->count > ARRAY_SIZE(helper)) {
2583 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2584 GFP_KERNEL);
2585 if (!helpers)
2586 return -ENOMEM;
2587 }
2588 ret = prepare_ext_ctrls(hdl, cs, helpers);
2589 if (!ret)
2590 ret = validate_ctrls(cs, helpers, set);
2591 if (ret && set)
2592 cs->error_idx = cs->count;
2593 for (i = 0; !ret && i < cs->count; i++) {
2594 struct v4l2_ctrl *master;
2595 u32 idx = i;
2596
2597 if (helpers[i].mref == NULL)
2598 continue;
2599
2600 cs->error_idx = i;
2601 master = helpers[i].mref->ctrl;
2602 v4l2_ctrl_lock(master);
2603
2604 /* Reset the 'is_new' flags of the cluster */
2605 for (j = 0; j < master->ncontrols; j++)
2606 if (master->cluster[j])
2607 master->cluster[j]->is_new = 0;
2608
2609 /* For volatile autoclusters that are currently in auto mode
2610 we need to discover if it will be set to manual mode.
2611 If so, then we have to copy the current volatile values
2612 first since those will become the new manual values (which
2613 may be overwritten by explicit new values from this set
2614 of controls). */
2615 if (master->is_auto && master->has_volatiles &&
2616 !is_cur_manual(master)) {
2617 /* Pick an initial non-manual value */
2618 s32 new_auto_val = master->manual_mode_value + 1;
2619 u32 tmp_idx = idx;
2620
2621 do {
2622 /* Check if the auto control is part of the
2623 list, and remember the new value. */
2624 if (helpers[tmp_idx].ctrl == master)
2625 new_auto_val = cs->controls[tmp_idx].value;
2626 tmp_idx = helpers[tmp_idx].next;
2627 } while (tmp_idx);
2628 /* If the new value == the manual value, then copy
2629 the current volatile values. */
2630 if (new_auto_val == master->manual_mode_value)
2631 update_from_auto_cluster(master);
2632 }
2633
2634 /* Copy the new caller-supplied control values.
2635 user_to_new() sets 'is_new' to 1. */
2636 do {
2637 ret = user_to_new(cs->controls + idx, helpers[idx].ctrl);
2638 idx = helpers[idx].next;
2639 } while (!ret && idx);
2640
2641 if (!ret)
2642 ret = try_or_set_cluster(fh, master, set, 0);
2643
2644 /* Copy the new values back to userspace. */
2645 if (!ret) {
2646 idx = i;
2647 do {
2648 ret = new_to_user(cs->controls + idx,
2649 helpers[idx].ctrl);
2650 idx = helpers[idx].next;
2651 } while (!ret && idx);
2652 }
2653 v4l2_ctrl_unlock(master);
2654 }
2655
2656 if (cs->count > ARRAY_SIZE(helper))
2657 kfree(helpers);
2658 return ret;
2659 }
2660
v4l2_try_ext_ctrls(struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs)2661 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2662 {
2663 return try_set_ext_ctrls(NULL, hdl, cs, false);
2664 }
2665 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
2666
v4l2_s_ext_ctrls(struct v4l2_fh * fh,struct v4l2_ctrl_handler * hdl,struct v4l2_ext_controls * cs)2667 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2668 struct v4l2_ext_controls *cs)
2669 {
2670 return try_set_ext_ctrls(fh, hdl, cs, true);
2671 }
2672 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
2673
v4l2_subdev_try_ext_ctrls(struct v4l2_subdev * sd,struct v4l2_ext_controls * cs)2674 int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2675 {
2676 return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, false);
2677 }
2678 EXPORT_SYMBOL(v4l2_subdev_try_ext_ctrls);
2679
v4l2_subdev_s_ext_ctrls(struct v4l2_subdev * sd,struct v4l2_ext_controls * cs)2680 int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2681 {
2682 return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, true);
2683 }
2684 EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
2685
2686 /* Helper function for VIDIOC_S_CTRL compatibility */
set_ctrl(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,struct v4l2_ext_control * c,u32 ch_flags)2687 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
2688 struct v4l2_ext_control *c, u32 ch_flags)
2689 {
2690 struct v4l2_ctrl *master = ctrl->cluster[0];
2691 int i;
2692
2693 /* String controls are not supported. The user_to_new() and
2694 * cur_to_user() calls below would need to be modified not to access
2695 * userspace memory when called from set_ctrl().
2696 */
2697 if (ctrl->type == V4L2_CTRL_TYPE_STRING)
2698 return -EINVAL;
2699
2700 /* Reset the 'is_new' flags of the cluster */
2701 for (i = 0; i < master->ncontrols; i++)
2702 if (master->cluster[i])
2703 master->cluster[i]->is_new = 0;
2704
2705 /* For autoclusters with volatiles that are switched from auto to
2706 manual mode we have to update the current volatile values since
2707 those will become the initial manual values after such a switch. */
2708 if (master->is_auto && master->has_volatiles && ctrl == master &&
2709 !is_cur_manual(master) && c->value == master->manual_mode_value)
2710 update_from_auto_cluster(master);
2711
2712 user_to_new(c, ctrl);
2713 return try_or_set_cluster(fh, master, true, ch_flags);
2714 }
2715
2716 /* Helper function for VIDIOC_S_CTRL compatibility */
set_ctrl_lock(struct v4l2_fh * fh,struct v4l2_ctrl * ctrl,struct v4l2_ext_control * c)2717 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
2718 struct v4l2_ext_control *c)
2719 {
2720 int ret = validate_new(ctrl, c);
2721
2722 if (!ret) {
2723 v4l2_ctrl_lock(ctrl);
2724 ret = set_ctrl(fh, ctrl, c, 0);
2725 if (!ret)
2726 cur_to_user(c, ctrl);
2727 v4l2_ctrl_unlock(ctrl);
2728 }
2729 return ret;
2730 }
2731
v4l2_s_ctrl(struct v4l2_fh * fh,struct v4l2_ctrl_handler * hdl,struct v4l2_control * control)2732 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2733 struct v4l2_control *control)
2734 {
2735 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2736 struct v4l2_ext_control c;
2737 int ret;
2738
2739 if (ctrl == NULL || !type_is_int(ctrl))
2740 return -EINVAL;
2741
2742 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2743 return -EACCES;
2744
2745 c.value = control->value;
2746 ret = set_ctrl_lock(fh, ctrl, &c);
2747 control->value = c.value;
2748 return ret;
2749 }
2750 EXPORT_SYMBOL(v4l2_s_ctrl);
2751
v4l2_subdev_s_ctrl(struct v4l2_subdev * sd,struct v4l2_control * control)2752 int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2753 {
2754 return v4l2_s_ctrl(NULL, sd->ctrl_handler, control);
2755 }
2756 EXPORT_SYMBOL(v4l2_subdev_s_ctrl);
2757
v4l2_ctrl_s_ctrl(struct v4l2_ctrl * ctrl,s32 val)2758 int v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
2759 {
2760 struct v4l2_ext_control c;
2761
2762 /* It's a driver bug if this happens. */
2763 WARN_ON(!type_is_int(ctrl));
2764 c.value = val;
2765 return set_ctrl_lock(NULL, ctrl, &c);
2766 }
2767 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl);
2768
v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl * ctrl,s64 val)2769 int v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
2770 {
2771 struct v4l2_ext_control c;
2772
2773 /* It's a driver bug if this happens. */
2774 WARN_ON(ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2775 c.value64 = val;
2776 return set_ctrl_lock(NULL, ctrl, &c);
2777 }
2778 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl_int64);
2779
v4l2_ctrl_notify(struct v4l2_ctrl * ctrl,v4l2_ctrl_notify_fnc notify,void * priv)2780 void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
2781 {
2782 if (ctrl == NULL)
2783 return;
2784 if (notify == NULL) {
2785 ctrl->call_notify = 0;
2786 return;
2787 }
2788 if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
2789 return;
2790 ctrl->handler->notify = notify;
2791 ctrl->handler->notify_priv = priv;
2792 ctrl->call_notify = 1;
2793 }
2794 EXPORT_SYMBOL(v4l2_ctrl_notify);
2795
v4l2_ctrl_modify_range(struct v4l2_ctrl * ctrl,s32 min,s32 max,u32 step,s32 def)2796 int v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
2797 s32 min, s32 max, u32 step, s32 def)
2798 {
2799 int ret = check_range(ctrl->type, min, max, step, def);
2800 struct v4l2_ext_control c;
2801
2802 switch (ctrl->type) {
2803 case V4L2_CTRL_TYPE_INTEGER:
2804 case V4L2_CTRL_TYPE_BOOLEAN:
2805 case V4L2_CTRL_TYPE_MENU:
2806 case V4L2_CTRL_TYPE_INTEGER_MENU:
2807 case V4L2_CTRL_TYPE_BITMASK:
2808 if (ret)
2809 return ret;
2810 break;
2811 default:
2812 return -EINVAL;
2813 }
2814 v4l2_ctrl_lock(ctrl);
2815 ctrl->minimum = min;
2816 ctrl->maximum = max;
2817 ctrl->step = step;
2818 ctrl->default_value = def;
2819 c.value = ctrl->cur.val;
2820 if (validate_new(ctrl, &c))
2821 c.value = def;
2822 if (c.value != ctrl->cur.val)
2823 ret = set_ctrl(NULL, ctrl, &c, V4L2_EVENT_CTRL_CH_RANGE);
2824 else
2825 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
2826 v4l2_ctrl_unlock(ctrl);
2827 return ret;
2828 }
2829 EXPORT_SYMBOL(v4l2_ctrl_modify_range);
2830
v4l2_ctrl_add_event(struct v4l2_subscribed_event * sev,unsigned elems)2831 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
2832 {
2833 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2834
2835 if (ctrl == NULL)
2836 return -EINVAL;
2837
2838 v4l2_ctrl_lock(ctrl);
2839 list_add_tail(&sev->node, &ctrl->ev_subs);
2840 if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
2841 (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
2842 struct v4l2_event ev;
2843 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
2844
2845 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
2846 changes |= V4L2_EVENT_CTRL_CH_VALUE;
2847 fill_event(&ev, ctrl, changes);
2848 /* Mark the queue as active, allowing this initial
2849 event to be accepted. */
2850 sev->elems = elems;
2851 v4l2_event_queue_fh(sev->fh, &ev);
2852 }
2853 v4l2_ctrl_unlock(ctrl);
2854 return 0;
2855 }
2856
v4l2_ctrl_del_event(struct v4l2_subscribed_event * sev)2857 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
2858 {
2859 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2860
2861 v4l2_ctrl_lock(ctrl);
2862 list_del(&sev->node);
2863 v4l2_ctrl_unlock(ctrl);
2864 }
2865
v4l2_ctrl_replace(struct v4l2_event * old,const struct v4l2_event * new)2866 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
2867 {
2868 u32 old_changes = old->u.ctrl.changes;
2869
2870 old->u.ctrl = new->u.ctrl;
2871 old->u.ctrl.changes |= old_changes;
2872 }
2873 EXPORT_SYMBOL(v4l2_ctrl_replace);
2874
v4l2_ctrl_merge(const struct v4l2_event * old,struct v4l2_event * new)2875 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
2876 {
2877 new->u.ctrl.changes |= old->u.ctrl.changes;
2878 }
2879 EXPORT_SYMBOL(v4l2_ctrl_merge);
2880
2881 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
2882 .add = v4l2_ctrl_add_event,
2883 .del = v4l2_ctrl_del_event,
2884 .replace = v4l2_ctrl_replace,
2885 .merge = v4l2_ctrl_merge,
2886 };
2887 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
2888
v4l2_ctrl_log_status(struct file * file,void * fh)2889 int v4l2_ctrl_log_status(struct file *file, void *fh)
2890 {
2891 struct video_device *vfd = video_devdata(file);
2892 struct v4l2_fh *vfh = file->private_data;
2893
2894 if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
2895 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
2896 vfd->v4l2_dev->name);
2897 return 0;
2898 }
2899 EXPORT_SYMBOL(v4l2_ctrl_log_status);
2900
v4l2_ctrl_subscribe_event(struct v4l2_fh * fh,const struct v4l2_event_subscription * sub)2901 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
2902 const struct v4l2_event_subscription *sub)
2903 {
2904 if (sub->type == V4L2_EVENT_CTRL)
2905 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
2906 return -EINVAL;
2907 }
2908 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
2909
v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev * sd,struct v4l2_fh * fh,struct v4l2_event_subscription * sub)2910 int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
2911 struct v4l2_event_subscription *sub)
2912 {
2913 if (!sd->ctrl_handler)
2914 return -EINVAL;
2915 return v4l2_ctrl_subscribe_event(fh, sub);
2916 }
2917 EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
2918
v4l2_ctrl_poll(struct file * file,struct poll_table_struct * wait)2919 unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
2920 {
2921 struct v4l2_fh *fh = file->private_data;
2922
2923 if (v4l2_event_pending(fh))
2924 return POLLPRI;
2925 poll_wait(file, &fh->wait, wait);
2926 return 0;
2927 }
2928 EXPORT_SYMBOL(v4l2_ctrl_poll);
2929