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