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