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