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