1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/ctype.h>
22#include <linux/slab.h>
23#include <linux/export.h>
24#include <media/v4l2-ioctl.h>
25#include <media/v4l2-device.h>
26#include <media/v4l2-ctrls.h>
27#include <media/v4l2-event.h>
28#include <media/v4l2-dev.h>
29
30#define has_op(master, op) \
31 (master->ops && master->ops->op)
32#define call_op(master, op) \
33 (has_op(master, op) ? master->ops->op(master) : 0)
34
35
36struct v4l2_ctrl_helper {
37
38 struct v4l2_ctrl_ref *mref;
39
40 struct v4l2_ctrl *ctrl;
41
42
43 u32 next;
44};
45
46
47
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
54
55static bool is_new_manual(const struct v4l2_ctrl *master)
56{
57 return master->is_auto && master->val == master->manual_mode_value;
58}
59
60
61
62
63
64const char * const *v4l2_ctrl_get_menu(u32 id)
65{
66 static const char * const mpeg_audio_sampling_freq[] = {
67 "44.1 kHz",
68 "48 kHz",
69 "32 kHz",
70 NULL
71 };
72 static const char * const mpeg_audio_encoding[] = {
73 "MPEG-1/2 Layer I",
74 "MPEG-1/2 Layer II",
75 "MPEG-1/2 Layer III",
76 "MPEG-2/4 AAC",
77 "AC-3",
78 NULL
79 };
80 static const char * const mpeg_audio_l1_bitrate[] = {
81 "32 kbps",
82 "64 kbps",
83 "96 kbps",
84 "128 kbps",
85 "160 kbps",
86 "192 kbps",
87 "224 kbps",
88 "256 kbps",
89 "288 kbps",
90 "320 kbps",
91 "352 kbps",
92 "384 kbps",
93 "416 kbps",
94 "448 kbps",
95 NULL
96 };
97 static const char * const mpeg_audio_l2_bitrate[] = {
98 "32 kbps",
99 "48 kbps",
100 "56 kbps",
101 "64 kbps",
102 "80 kbps",
103 "96 kbps",
104 "112 kbps",
105 "128 kbps",
106 "160 kbps",
107 "192 kbps",
108 "224 kbps",
109 "256 kbps",
110 "320 kbps",
111 "384 kbps",
112 NULL
113 };
114 static const char * const mpeg_audio_l3_bitrate[] = {
115 "32 kbps",
116 "40 kbps",
117 "48 kbps",
118 "56 kbps",
119 "64 kbps",
120 "80 kbps",
121 "96 kbps",
122 "112 kbps",
123 "128 kbps",
124 "160 kbps",
125 "192 kbps",
126 "224 kbps",
127 "256 kbps",
128 "320 kbps",
129 NULL
130 };
131 static const char * const mpeg_audio_ac3_bitrate[] = {
132 "32 kbps",
133 "40 kbps",
134 "48 kbps",
135 "56 kbps",
136 "64 kbps",
137 "80 kbps",
138 "96 kbps",
139 "112 kbps",
140 "128 kbps",
141 "160 kbps",
142 "192 kbps",
143 "224 kbps",
144 "256 kbps",
145 "320 kbps",
146 "384 kbps",
147 "448 kbps",
148 "512 kbps",
149 "576 kbps",
150 "640 kbps",
151 NULL
152 };
153 static const char * const mpeg_audio_mode[] = {
154 "Stereo",
155 "Joint Stereo",
156 "Dual",
157 "Mono",
158 NULL
159 };
160 static const char * const mpeg_audio_mode_extension[] = {
161 "Bound 4",
162 "Bound 8",
163 "Bound 12",
164 "Bound 16",
165 NULL
166 };
167 static const char * const mpeg_audio_emphasis[] = {
168 "No Emphasis",
169 "50/15 us",
170 "CCITT J17",
171 NULL
172 };
173 static const char * const mpeg_audio_crc[] = {
174 "No CRC",
175 "16-bit CRC",
176 NULL
177 };
178 static const char * const mpeg_audio_dec_playback[] = {
179 "Auto",
180 "Stereo",
181 "Left",
182 "Right",
183 "Mono",
184 "Swapped Stereo",
185 NULL
186 };
187 static const char * const mpeg_video_encoding[] = {
188 "MPEG-1",
189 "MPEG-2",
190 "MPEG-4 AVC",
191 NULL
192 };
193 static const char * const mpeg_video_aspect[] = {
194 "1x1",
195 "4x3",
196 "16x9",
197 "2.21x1",
198 NULL
199 };
200 static const char * const mpeg_video_bitrate_mode[] = {
201 "Variable Bitrate",
202 "Constant Bitrate",
203 NULL
204 };
205 static const char * const mpeg_stream_type[] = {
206 "MPEG-2 Program Stream",
207 "MPEG-2 Transport Stream",
208 "MPEG-1 System Stream",
209 "MPEG-2 DVD-compatible Stream",
210 "MPEG-1 VCD-compatible Stream",
211 "MPEG-2 SVCD-compatible Stream",
212 NULL
213 };
214 static const char * const mpeg_stream_vbi_fmt[] = {
215 "No VBI",
216 "Private Packet, IVTV Format",
217 NULL
218 };
219 static const char * const camera_power_line_frequency[] = {
220 "Disabled",
221 "50 Hz",
222 "60 Hz",
223 "Auto",
224 NULL
225 };
226 static const char * const camera_exposure_auto[] = {
227 "Auto Mode",
228 "Manual Mode",
229 "Shutter Priority Mode",
230 "Aperture Priority Mode",
231 NULL
232 };
233 static const char * const camera_exposure_metering[] = {
234 "Average",
235 "Center Weighted",
236 "Spot",
237 "Matrix",
238 NULL
239 };
240 static const char * const camera_auto_focus_range[] = {
241 "Auto",
242 "Normal",
243 "Macro",
244 "Infinity",
245 NULL
246 };
247 static const char * const colorfx[] = {
248 "None",
249 "Black & White",
250 "Sepia",
251 "Negative",
252 "Emboss",
253 "Sketch",
254 "Sky Blue",
255 "Grass Green",
256 "Skin Whiten",
257 "Vivid",
258 "Aqua",
259 "Art Freeze",
260 "Silhouette",
261 "Solarization",
262 "Antique",
263 "Set Cb/Cr",
264 NULL
265 };
266 static const char * const auto_n_preset_white_balance[] = {
267 "Manual",
268 "Auto",
269 "Incandescent",
270 "Fluorescent",
271 "Fluorescent H",
272 "Horizon",
273 "Daylight",
274 "Flash",
275 "Cloudy",
276 "Shade",
277 NULL,
278 };
279 static const char * const camera_iso_sensitivity_auto[] = {
280 "Manual",
281 "Auto",
282 NULL
283 };
284 static const char * const scene_mode[] = {
285 "None",
286 "Backlight",
287 "Beach/Snow",
288 "Candle Light",
289 "Dusk/Dawn",
290 "Fall Colors",
291 "Fireworks",
292 "Landscape",
293 "Night",
294 "Party/Indoor",
295 "Portrait",
296 "Sports",
297 "Sunset",
298 "Text",
299 NULL
300 };
301 static const char * const tune_emphasis[] = {
302 "None",
303 "50 Microseconds",
304 "75 Microseconds",
305 NULL,
306 };
307 static const char * const header_mode[] = {
308 "Separate Buffer",
309 "Joined With 1st Frame",
310 NULL,
311 };
312 static const char * const multi_slice[] = {
313 "Single",
314 "Max Macroblocks",
315 "Max Bytes",
316 NULL,
317 };
318 static const char * const entropy_mode[] = {
319 "CAVLC",
320 "CABAC",
321 NULL,
322 };
323 static const char * const mpeg_h264_level[] = {
324 "1",
325 "1b",
326 "1.1",
327 "1.2",
328 "1.3",
329 "2",
330 "2.1",
331 "2.2",
332 "3",
333 "3.1",
334 "3.2",
335 "4",
336 "4.1",
337 "4.2",
338 "5",
339 "5.1",
340 NULL,
341 };
342 static const char * const h264_loop_filter[] = {
343 "Enabled",
344 "Disabled",
345 "Disabled at Slice Boundary",
346 NULL,
347 };
348 static const char * const h264_profile[] = {
349 "Baseline",
350 "Constrained Baseline",
351 "Main",
352 "Extended",
353 "High",
354 "High 10",
355 "High 422",
356 "High 444 Predictive",
357 "High 10 Intra",
358 "High 422 Intra",
359 "High 444 Intra",
360 "CAVLC 444 Intra",
361 "Scalable Baseline",
362 "Scalable High",
363 "Scalable High Intra",
364 "Multiview High",
365 NULL,
366 };
367 static const char * const vui_sar_idc[] = {
368 "Unspecified",
369 "1:1",
370 "12:11",
371 "10:11",
372 "16:11",
373 "40:33",
374 "24:11",
375 "20:11",
376 "32:11",
377 "80:33",
378 "18:11",
379 "15:11",
380 "64:33",
381 "160:99",
382 "4:3",
383 "3:2",
384 "2:1",
385 "Extended SAR",
386 NULL,
387 };
388 static const char * const h264_fp_arrangement_type[] = {
389 "Checkerboard",
390 "Column",
391 "Row",
392 "Side by Side",
393 "Top Bottom",
394 "Temporal",
395 NULL,
396 };
397 static const char * const h264_fmo_map_type[] = {
398 "Interleaved Slices",
399 "Scattered Slices",
400 "Foreground with Leftover",
401 "Box Out",
402 "Raster Scan",
403 "Wipe Scan",
404 "Explicit",
405 NULL,
406 };
407 static const char * const mpeg_mpeg4_level[] = {
408 "0",
409 "0b",
410 "1",
411 "2",
412 "3",
413 "3b",
414 "4",
415 "5",
416 NULL,
417 };
418 static const char * const mpeg4_profile[] = {
419 "Simple",
420 "Advanced Simple",
421 "Core",
422 "Simple Scalable",
423 "Advanced Coding Efficency",
424 NULL,
425 };
426
427 static const char * const flash_led_mode[] = {
428 "Off",
429 "Flash",
430 "Torch",
431 NULL,
432 };
433 static const char * const flash_strobe_source[] = {
434 "Software",
435 "External",
436 NULL,
437 };
438
439 static const char * const jpeg_chroma_subsampling[] = {
440 "4:4:4",
441 "4:2:2",
442 "4:2:0",
443 "4:1:1",
444 "4:1:0",
445 "Gray",
446 NULL,
447 };
448 static const char * const dv_tx_mode[] = {
449 "DVI-D",
450 "HDMI",
451 NULL,
452 };
453 static const char * const dv_rgb_range[] = {
454 "Automatic",
455 "RGB limited range (16-235)",
456 "RGB full range (0-255)",
457 NULL,
458 };
459
460
461 switch (id) {
462 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
463 return mpeg_audio_sampling_freq;
464 case V4L2_CID_MPEG_AUDIO_ENCODING:
465 return mpeg_audio_encoding;
466 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
467 return mpeg_audio_l1_bitrate;
468 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
469 return mpeg_audio_l2_bitrate;
470 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
471 return mpeg_audio_l3_bitrate;
472 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
473 return mpeg_audio_ac3_bitrate;
474 case V4L2_CID_MPEG_AUDIO_MODE:
475 return mpeg_audio_mode;
476 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
477 return mpeg_audio_mode_extension;
478 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
479 return mpeg_audio_emphasis;
480 case V4L2_CID_MPEG_AUDIO_CRC:
481 return mpeg_audio_crc;
482 case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
483 case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
484 return mpeg_audio_dec_playback;
485 case V4L2_CID_MPEG_VIDEO_ENCODING:
486 return mpeg_video_encoding;
487 case V4L2_CID_MPEG_VIDEO_ASPECT:
488 return mpeg_video_aspect;
489 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
490 return mpeg_video_bitrate_mode;
491 case V4L2_CID_MPEG_STREAM_TYPE:
492 return mpeg_stream_type;
493 case V4L2_CID_MPEG_STREAM_VBI_FMT:
494 return mpeg_stream_vbi_fmt;
495 case V4L2_CID_POWER_LINE_FREQUENCY:
496 return camera_power_line_frequency;
497 case V4L2_CID_EXPOSURE_AUTO:
498 return camera_exposure_auto;
499 case V4L2_CID_EXPOSURE_METERING:
500 return camera_exposure_metering;
501 case V4L2_CID_AUTO_FOCUS_RANGE:
502 return camera_auto_focus_range;
503 case V4L2_CID_COLORFX:
504 return colorfx;
505 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
506 return auto_n_preset_white_balance;
507 case V4L2_CID_ISO_SENSITIVITY_AUTO:
508 return camera_iso_sensitivity_auto;
509 case V4L2_CID_SCENE_MODE:
510 return scene_mode;
511 case V4L2_CID_TUNE_PREEMPHASIS:
512 return tune_emphasis;
513 case V4L2_CID_TUNE_DEEMPHASIS:
514 return tune_emphasis;
515 case V4L2_CID_FLASH_LED_MODE:
516 return flash_led_mode;
517 case V4L2_CID_FLASH_STROBE_SOURCE:
518 return flash_strobe_source;
519 case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
520 return header_mode;
521 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
522 return multi_slice;
523 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
524 return entropy_mode;
525 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
526 return mpeg_h264_level;
527 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
528 return h264_loop_filter;
529 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
530 return h264_profile;
531 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
532 return vui_sar_idc;
533 case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
534 return h264_fp_arrangement_type;
535 case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
536 return h264_fmo_map_type;
537 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
538 return mpeg_mpeg4_level;
539 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
540 return mpeg4_profile;
541 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
542 return jpeg_chroma_subsampling;
543 case V4L2_CID_DV_TX_MODE:
544 return dv_tx_mode;
545 case V4L2_CID_DV_TX_RGB_RANGE:
546 case V4L2_CID_DV_RX_RGB_RANGE:
547 return dv_rgb_range;
548
549 default:
550 return NULL;
551 }
552}
553EXPORT_SYMBOL(v4l2_ctrl_get_menu);
554
555
556const char *v4l2_ctrl_get_name(u32 id)
557{
558 switch (id) {
559
560
561 case V4L2_CID_USER_CLASS: return "User Controls";
562 case V4L2_CID_BRIGHTNESS: return "Brightness";
563 case V4L2_CID_CONTRAST: return "Contrast";
564 case V4L2_CID_SATURATION: return "Saturation";
565 case V4L2_CID_HUE: return "Hue";
566 case V4L2_CID_AUDIO_VOLUME: return "Volume";
567 case V4L2_CID_AUDIO_BALANCE: return "Balance";
568 case V4L2_CID_AUDIO_BASS: return "Bass";
569 case V4L2_CID_AUDIO_TREBLE: return "Treble";
570 case V4L2_CID_AUDIO_MUTE: return "Mute";
571 case V4L2_CID_AUDIO_LOUDNESS: return "Loudness";
572 case V4L2_CID_BLACK_LEVEL: return "Black Level";
573 case V4L2_CID_AUTO_WHITE_BALANCE: return "White Balance, Automatic";
574 case V4L2_CID_DO_WHITE_BALANCE: return "Do White Balance";
575 case V4L2_CID_RED_BALANCE: return "Red Balance";
576 case V4L2_CID_BLUE_BALANCE: return "Blue Balance";
577 case V4L2_CID_GAMMA: return "Gamma";
578 case V4L2_CID_EXPOSURE: return "Exposure";
579 case V4L2_CID_AUTOGAIN: return "Gain, Automatic";
580 case V4L2_CID_GAIN: return "Gain";
581 case V4L2_CID_HFLIP: return "Horizontal Flip";
582 case V4L2_CID_VFLIP: return "Vertical Flip";
583 case V4L2_CID_POWER_LINE_FREQUENCY: return "Power Line Frequency";
584 case V4L2_CID_HUE_AUTO: return "Hue, Automatic";
585 case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
586 case V4L2_CID_SHARPNESS: return "Sharpness";
587 case V4L2_CID_BACKLIGHT_COMPENSATION: return "Backlight Compensation";
588 case V4L2_CID_CHROMA_AGC: return "Chroma AGC";
589 case V4L2_CID_COLOR_KILLER: return "Color Killer";
590 case V4L2_CID_COLORFX: return "Color Effects";
591 case V4L2_CID_AUTOBRIGHTNESS: return "Brightness, Automatic";
592 case V4L2_CID_BAND_STOP_FILTER: return "Band-Stop Filter";
593 case V4L2_CID_ROTATE: return "Rotate";
594 case V4L2_CID_BG_COLOR: return "Background Color";
595 case V4L2_CID_CHROMA_GAIN: return "Chroma Gain";
596 case V4L2_CID_ILLUMINATORS_1: return "Illuminator 1";
597 case V4L2_CID_ILLUMINATORS_2: return "Illuminator 2";
598 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE: return "Min Number of Capture Buffers";
599 case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT: return "Min Number of Output Buffers";
600 case V4L2_CID_ALPHA_COMPONENT: return "Alpha Component";
601 case V4L2_CID_COLORFX_CBCR: return "Color Effects, CbCr";
602
603
604
605 case V4L2_CID_MPEG_CLASS: return "MPEG Encoder Controls";
606 case V4L2_CID_MPEG_STREAM_TYPE: return "Stream Type";
607 case V4L2_CID_MPEG_STREAM_PID_PMT: return "Stream PMT Program ID";
608 case V4L2_CID_MPEG_STREAM_PID_AUDIO: return "Stream Audio Program ID";
609 case V4L2_CID_MPEG_STREAM_PID_VIDEO: return "Stream Video Program ID";
610 case V4L2_CID_MPEG_STREAM_PID_PCR: return "Stream PCR Program ID";
611 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
612 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
613 case V4L2_CID_MPEG_STREAM_VBI_FMT: return "Stream VBI Format";
614 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
615 case V4L2_CID_MPEG_AUDIO_ENCODING: return "Audio Encoding";
616 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: return "Audio Layer I Bitrate";
617 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: return "Audio Layer II Bitrate";
618 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: return "Audio Layer III Bitrate";
619 case V4L2_CID_MPEG_AUDIO_MODE: return "Audio Stereo Mode";
620 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
621 case V4L2_CID_MPEG_AUDIO_EMPHASIS: return "Audio Emphasis";
622 case V4L2_CID_MPEG_AUDIO_CRC: return "Audio CRC";
623 case V4L2_CID_MPEG_AUDIO_MUTE: return "Audio Mute";
624 case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate";
625 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: return "Audio AC-3 Bitrate";
626 case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK: return "Audio Playback";
627 case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: return "Audio Multilingual Playback";
628 case V4L2_CID_MPEG_VIDEO_ENCODING: return "Video Encoding";
629 case V4L2_CID_MPEG_VIDEO_ASPECT: return "Video Aspect";
630 case V4L2_CID_MPEG_VIDEO_B_FRAMES: return "Video B Frames";
631 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: return "Video GOP Size";
632 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: return "Video GOP Closure";
633 case V4L2_CID_MPEG_VIDEO_PULLDOWN: return "Video Pulldown";
634 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: return "Video Bitrate Mode";
635 case V4L2_CID_MPEG_VIDEO_BITRATE: return "Video Bitrate";
636 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: return "Video Peak Bitrate";
637 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
638 case V4L2_CID_MPEG_VIDEO_MUTE: return "Video Mute";
639 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: return "Video Mute YUV";
640 case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE: return "Decoder Slice Interface";
641 case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER: return "MPEG4 Loop Filter Enable";
642 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB: return "Number of Intra Refresh MBs";
643 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE: return "Frame Level Rate Control Enable";
644 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE: return "H264 MB Level Rate Control";
645 case V4L2_CID_MPEG_VIDEO_HEADER_MODE: return "Sequence Header Mode";
646 case V4L2_CID_MPEG_VIDEO_MAX_REF_PIC: return "Max Number of Reference Pics";
647 case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP: return "H263 I-Frame QP Value";
648 case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP: return "H263 P-Frame QP Value";
649 case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP: return "H263 B-Frame QP Value";
650 case V4L2_CID_MPEG_VIDEO_H263_MIN_QP: return "H263 Minimum QP Value";
651 case V4L2_CID_MPEG_VIDEO_H263_MAX_QP: return "H263 Maximum QP Value";
652 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP: return "H264 I-Frame QP Value";
653 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP: return "H264 P-Frame QP Value";
654 case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP: return "H264 B-Frame QP Value";
655 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP: return "H264 Maximum QP Value";
656 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP: return "H264 Minimum QP Value";
657 case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM: return "H264 8x8 Transform Enable";
658 case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE: return "H264 CPB Buffer Size";
659 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE: return "H264 Entropy Mode";
660 case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD: return "H264 I-Frame Period";
661 case V4L2_CID_MPEG_VIDEO_H264_LEVEL: return "H264 Level";
662 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA: return "H264 Loop Filter Alpha Offset";
663 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA: return "H264 Loop Filter Beta Offset";
664 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE: return "H264 Loop Filter Mode";
665 case V4L2_CID_MPEG_VIDEO_H264_PROFILE: return "H264 Profile";
666 case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT: return "Vertical Size of SAR";
667 case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH: return "Horizontal Size of SAR";
668 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE: return "Aspect Ratio VUI Enable";
669 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC: return "VUI Aspect Ratio IDC";
670 case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING: return "H264 Enable Frame Packing SEI";
671 case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0: return "H264 Set Curr. Frame as Frame0";
672 case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE: return "H264 FP Arrangement Type";
673 case V4L2_CID_MPEG_VIDEO_H264_FMO: return "H264 Flexible MB Ordering";
674 case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE: return "H264 Map Type for FMO";
675 case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP: return "H264 FMO Number of Slice Groups";
676 case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION: return "H264 FMO Direction of Change";
677 case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE: return "H264 FMO Size of 1st Slice Grp";
678 case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH: return "H264 FMO No. of Consecutive MBs";
679 case V4L2_CID_MPEG_VIDEO_H264_ASO: return "H264 Arbitrary Slice Ordering";
680 case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER: return "H264 ASO Slice Order";
681 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING: return "Enable H264 Hierarchical Coding";
682 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE: return "H264 Hierarchical Coding Type";
683 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:return "H264 Number of HC Layers";
684 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP:
685 return "H264 Set QP Value for HC Layers";
686 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP: return "MPEG4 I-Frame QP Value";
687 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP: return "MPEG4 P-Frame QP Value";
688 case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP: return "MPEG4 B-Frame QP Value";
689 case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP: return "MPEG4 Minimum QP Value";
690 case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP: return "MPEG4 Maximum QP Value";
691 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL: return "MPEG4 Level";
692 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE: return "MPEG4 Profile";
693 case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL: return "Quarter Pixel Search Enable";
694 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES: return "Maximum Bytes in a Slice";
695 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB: return "Number of MBs in a Slice";
696 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: return "Slice Partitioning Method";
697 case V4L2_CID_MPEG_VIDEO_VBV_SIZE: return "VBV Buffer Size";
698 case V4L2_CID_MPEG_VIDEO_DEC_PTS: return "Video Decoder PTS";
699 case V4L2_CID_MPEG_VIDEO_DEC_FRAME: return "Video Decoder Frame Count";
700 case V4L2_CID_MPEG_VIDEO_VBV_DELAY: return "Initial Delay for VBV Control";
701 case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER: return "Repeat Sequence Header";
702
703
704
705 case V4L2_CID_CAMERA_CLASS: return "Camera Controls";
706 case V4L2_CID_EXPOSURE_AUTO: return "Auto Exposure";
707 case V4L2_CID_EXPOSURE_ABSOLUTE: return "Exposure Time, Absolute";
708 case V4L2_CID_EXPOSURE_AUTO_PRIORITY: return "Exposure, Dynamic Framerate";
709 case V4L2_CID_PAN_RELATIVE: return "Pan, Relative";
710 case V4L2_CID_TILT_RELATIVE: return "Tilt, Relative";
711 case V4L2_CID_PAN_RESET: return "Pan, Reset";
712 case V4L2_CID_TILT_RESET: return "Tilt, Reset";
713 case V4L2_CID_PAN_ABSOLUTE: return "Pan, Absolute";
714 case V4L2_CID_TILT_ABSOLUTE: return "Tilt, Absolute";
715 case V4L2_CID_FOCUS_ABSOLUTE: return "Focus, Absolute";
716 case V4L2_CID_FOCUS_RELATIVE: return "Focus, Relative";
717 case V4L2_CID_FOCUS_AUTO: return "Focus, Automatic Continuous";
718 case V4L2_CID_ZOOM_ABSOLUTE: return "Zoom, Absolute";
719 case V4L2_CID_ZOOM_RELATIVE: return "Zoom, Relative";
720 case V4L2_CID_ZOOM_CONTINUOUS: return "Zoom, Continuous";
721 case V4L2_CID_PRIVACY: return "Privacy";
722 case V4L2_CID_IRIS_ABSOLUTE: return "Iris, Absolute";
723 case V4L2_CID_IRIS_RELATIVE: return "Iris, Relative";
724 case V4L2_CID_AUTO_EXPOSURE_BIAS: return "Auto Exposure, Bias";
725 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset";
726 case V4L2_CID_WIDE_DYNAMIC_RANGE: return "Wide Dynamic Range";
727 case V4L2_CID_IMAGE_STABILIZATION: return "Image Stabilization";
728 case V4L2_CID_ISO_SENSITIVITY: return "ISO Sensitivity";
729 case V4L2_CID_ISO_SENSITIVITY_AUTO: return "ISO Sensitivity, Auto";
730 case V4L2_CID_EXPOSURE_METERING: return "Exposure, Metering Mode";
731 case V4L2_CID_SCENE_MODE: return "Scene Mode";
732 case V4L2_CID_3A_LOCK: return "3A Lock";
733 case V4L2_CID_AUTO_FOCUS_START: return "Auto Focus, Start";
734 case V4L2_CID_AUTO_FOCUS_STOP: return "Auto Focus, Stop";
735 case V4L2_CID_AUTO_FOCUS_STATUS: return "Auto Focus, Status";
736 case V4L2_CID_AUTO_FOCUS_RANGE: return "Auto Focus, Range";
737
738
739
740 case V4L2_CID_FM_TX_CLASS: return "FM Radio Modulator Controls";
741 case V4L2_CID_RDS_TX_DEVIATION: return "RDS Signal Deviation";
742 case V4L2_CID_RDS_TX_PI: return "RDS Program ID";
743 case V4L2_CID_RDS_TX_PTY: return "RDS Program Type";
744 case V4L2_CID_RDS_TX_PS_NAME: return "RDS PS Name";
745 case V4L2_CID_RDS_TX_RADIO_TEXT: return "RDS Radio Text";
746 case V4L2_CID_AUDIO_LIMITER_ENABLED: return "Audio Limiter Feature Enabled";
747 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
748 case V4L2_CID_AUDIO_LIMITER_DEVIATION: return "Audio Limiter Deviation";
749 case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled";
750 case V4L2_CID_AUDIO_COMPRESSION_GAIN: return "Audio Compression Gain";
751 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
752 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
753 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
754 case V4L2_CID_PILOT_TONE_ENABLED: return "Pilot Tone Feature Enabled";
755 case V4L2_CID_PILOT_TONE_DEVIATION: return "Pilot Tone Deviation";
756 case V4L2_CID_PILOT_TONE_FREQUENCY: return "Pilot Tone Frequency";
757 case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-Emphasis";
758 case V4L2_CID_TUNE_POWER_LEVEL: return "Tune Power Level";
759 case V4L2_CID_TUNE_ANTENNA_CAPACITOR: return "Tune Antenna Capacitor";
760
761
762 case V4L2_CID_FLASH_CLASS: return "Flash Controls";
763 case V4L2_CID_FLASH_LED_MODE: return "LED Mode";
764 case V4L2_CID_FLASH_STROBE_SOURCE: return "Strobe Source";
765 case V4L2_CID_FLASH_STROBE: return "Strobe";
766 case V4L2_CID_FLASH_STROBE_STOP: return "Stop Strobe";
767 case V4L2_CID_FLASH_STROBE_STATUS: return "Strobe Status";
768 case V4L2_CID_FLASH_TIMEOUT: return "Strobe Timeout";
769 case V4L2_CID_FLASH_INTENSITY: return "Intensity, Flash Mode";
770 case V4L2_CID_FLASH_TORCH_INTENSITY: return "Intensity, Torch Mode";
771 case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator";
772 case V4L2_CID_FLASH_FAULT: return "Faults";
773 case V4L2_CID_FLASH_CHARGE: return "Charge";
774 case V4L2_CID_FLASH_READY: return "Ready to Strobe";
775
776
777
778 case V4L2_CID_JPEG_CLASS: return "JPEG Compression Controls";
779 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: return "Chroma Subsampling";
780 case V4L2_CID_JPEG_RESTART_INTERVAL: return "Restart Interval";
781 case V4L2_CID_JPEG_COMPRESSION_QUALITY: return "Compression Quality";
782 case V4L2_CID_JPEG_ACTIVE_MARKER: return "Active Markers";
783
784
785 case V4L2_CID_IMAGE_SOURCE_CLASS: return "Image Source Controls";
786 case V4L2_CID_VBLANK: return "Vertical Blanking";
787 case V4L2_CID_HBLANK: return "Horizontal Blanking";
788 case V4L2_CID_ANALOGUE_GAIN: return "Analogue Gain";
789
790
791 case V4L2_CID_IMAGE_PROC_CLASS: return "Image Processing Controls";
792 case V4L2_CID_LINK_FREQ: return "Link Frequency";
793 case V4L2_CID_PIXEL_RATE: return "Pixel Rate";
794 case V4L2_CID_TEST_PATTERN: return "Test Pattern";
795
796
797 case V4L2_CID_DV_CLASS: return "Digital Video Controls";
798 case V4L2_CID_DV_TX_HOTPLUG: return "Hotplug Present";
799 case V4L2_CID_DV_TX_RXSENSE: return "RxSense Present";
800 case V4L2_CID_DV_TX_EDID_PRESENT: return "EDID Present";
801 case V4L2_CID_DV_TX_MODE: return "Transmit Mode";
802 case V4L2_CID_DV_TX_RGB_RANGE: return "Tx RGB Quantization Range";
803 case V4L2_CID_DV_RX_POWER_PRESENT: return "Power Present";
804 case V4L2_CID_DV_RX_RGB_RANGE: return "Rx RGB Quantization Range";
805
806 case V4L2_CID_FM_RX_CLASS: return "FM Radio Receiver Controls";
807 case V4L2_CID_TUNE_DEEMPHASIS: return "De-Emphasis";
808 case V4L2_CID_RDS_RECEPTION: return "RDS Reception";
809 default:
810 return NULL;
811 }
812}
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:
831 case V4L2_CID_AUTOBRIGHTNESS:
832 case V4L2_CID_MPEG_AUDIO_MUTE:
833 case V4L2_CID_MPEG_VIDEO_MUTE:
834 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
835 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
836 case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
837 case V4L2_CID_FOCUS_AUTO:
838 case V4L2_CID_PRIVACY:
839 case V4L2_CID_AUDIO_LIMITER_ENABLED:
840 case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
841 case V4L2_CID_PILOT_TONE_ENABLED:
842 case V4L2_CID_ILLUMINATORS_1:
843 case V4L2_CID_ILLUMINATORS_2:
844 case V4L2_CID_FLASH_STROBE_STATUS:
845 case V4L2_CID_FLASH_CHARGE:
846 case V4L2_CID_FLASH_READY:
847 case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
848 case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
849 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
850 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
851 case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
852 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
853 case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
854 case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER:
855 case V4L2_CID_WIDE_DYNAMIC_RANGE:
856 case V4L2_CID_IMAGE_STABILIZATION:
857 case V4L2_CID_RDS_RECEPTION:
858 *type = V4L2_CTRL_TYPE_BOOLEAN;
859 *min = 0;
860 *max = *step = 1;
861 break;
862 case V4L2_CID_PAN_RESET:
863 case V4L2_CID_TILT_RESET:
864 case V4L2_CID_FLASH_STROBE:
865 case V4L2_CID_FLASH_STROBE_STOP:
866 case V4L2_CID_AUTO_FOCUS_START:
867 case V4L2_CID_AUTO_FOCUS_STOP:
868 *type = V4L2_CTRL_TYPE_BUTTON;
869 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
870 *min = *max = *step = *def = 0;
871 break;
872 case V4L2_CID_POWER_LINE_FREQUENCY:
873 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
874 case V4L2_CID_MPEG_AUDIO_ENCODING:
875 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
876 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
877 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
878 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
879 case V4L2_CID_MPEG_AUDIO_MODE:
880 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
881 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
882 case V4L2_CID_MPEG_AUDIO_CRC:
883 case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
884 case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
885 case V4L2_CID_MPEG_VIDEO_ENCODING:
886 case V4L2_CID_MPEG_VIDEO_ASPECT:
887 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
888 case V4L2_CID_MPEG_STREAM_TYPE:
889 case V4L2_CID_MPEG_STREAM_VBI_FMT:
890 case V4L2_CID_EXPOSURE_AUTO:
891 case V4L2_CID_AUTO_FOCUS_RANGE:
892 case V4L2_CID_COLORFX:
893 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
894 case V4L2_CID_TUNE_PREEMPHASIS:
895 case V4L2_CID_FLASH_LED_MODE:
896 case V4L2_CID_FLASH_STROBE_SOURCE:
897 case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
898 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
899 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
900 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
901 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
902 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
903 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
904 case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
905 case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
906 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
907 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
908 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
909 case V4L2_CID_ISO_SENSITIVITY_AUTO:
910 case V4L2_CID_EXPOSURE_METERING:
911 case V4L2_CID_SCENE_MODE:
912 case V4L2_CID_DV_TX_MODE:
913 case V4L2_CID_DV_TX_RGB_RANGE:
914 case V4L2_CID_DV_RX_RGB_RANGE:
915 case V4L2_CID_TEST_PATTERN:
916 case V4L2_CID_TUNE_DEEMPHASIS:
917 *type = V4L2_CTRL_TYPE_MENU;
918 break;
919 case V4L2_CID_LINK_FREQ:
920 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
921 break;
922 case V4L2_CID_RDS_TX_PS_NAME:
923 case V4L2_CID_RDS_TX_RADIO_TEXT:
924 *type = V4L2_CTRL_TYPE_STRING;
925 break;
926 case V4L2_CID_ISO_SENSITIVITY:
927 case V4L2_CID_AUTO_EXPOSURE_BIAS:
928 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
929 break;
930 case V4L2_CID_USER_CLASS:
931 case V4L2_CID_CAMERA_CLASS:
932 case V4L2_CID_MPEG_CLASS:
933 case V4L2_CID_FM_TX_CLASS:
934 case V4L2_CID_FLASH_CLASS:
935 case V4L2_CID_JPEG_CLASS:
936 case V4L2_CID_IMAGE_SOURCE_CLASS:
937 case V4L2_CID_IMAGE_PROC_CLASS:
938 case V4L2_CID_DV_CLASS:
939 case V4L2_CID_FM_RX_CLASS:
940 *type = V4L2_CTRL_TYPE_CTRL_CLASS;
941
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
950 *max = 0xFFFFFF;
951 break;
952 case V4L2_CID_FLASH_FAULT:
953 case V4L2_CID_JPEG_ACTIVE_MARKER:
954 case V4L2_CID_3A_LOCK:
955 case V4L2_CID_AUTO_FOCUS_STATUS:
956 case V4L2_CID_DV_TX_HOTPLUG:
957 case V4L2_CID_DV_TX_RXSENSE:
958 case V4L2_CID_DV_TX_EDID_PRESENT:
959 case V4L2_CID_DV_RX_POWER_PRESENT:
960 *type = V4L2_CTRL_TYPE_BITMASK;
961 break;
962 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
963 case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
964 *type = V4L2_CTRL_TYPE_INTEGER;
965 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
966 break;
967 case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
968 case V4L2_CID_MPEG_VIDEO_DEC_PTS:
969 *flags |= V4L2_CTRL_FLAG_VOLATILE;
970
971 case V4L2_CID_PIXEL_RATE:
972 *type = V4L2_CTRL_TYPE_INTEGER64;
973 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
974 *min = *max = *step = *def = 0;
975 break;
976 default:
977 *type = V4L2_CTRL_TYPE_INTEGER;
978 break;
979 }
980 switch (id) {
981 case V4L2_CID_MPEG_AUDIO_ENCODING:
982 case V4L2_CID_MPEG_AUDIO_MODE:
983 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
984 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
985 case V4L2_CID_MPEG_STREAM_TYPE:
986 *flags |= V4L2_CTRL_FLAG_UPDATE;
987 break;
988 case V4L2_CID_AUDIO_VOLUME:
989 case V4L2_CID_AUDIO_BALANCE:
990 case V4L2_CID_AUDIO_BASS:
991 case V4L2_CID_AUDIO_TREBLE:
992 case V4L2_CID_BRIGHTNESS:
993 case V4L2_CID_CONTRAST:
994 case V4L2_CID_SATURATION:
995 case V4L2_CID_HUE:
996 case V4L2_CID_RED_BALANCE:
997 case V4L2_CID_BLUE_BALANCE:
998 case V4L2_CID_GAMMA:
999 case V4L2_CID_SHARPNESS:
1000 case V4L2_CID_CHROMA_GAIN:
1001 case V4L2_CID_RDS_TX_DEVIATION:
1002 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1003 case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1004 case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1005 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1006 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1007 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1008 case V4L2_CID_PILOT_TONE_DEVIATION:
1009 case V4L2_CID_PILOT_TONE_FREQUENCY:
1010 case V4L2_CID_TUNE_POWER_LEVEL:
1011 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1012 *flags |= V4L2_CTRL_FLAG_SLIDER;
1013 break;
1014 case V4L2_CID_PAN_RELATIVE:
1015 case V4L2_CID_TILT_RELATIVE:
1016 case V4L2_CID_FOCUS_RELATIVE:
1017 case V4L2_CID_IRIS_RELATIVE:
1018 case V4L2_CID_ZOOM_RELATIVE:
1019 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1020 break;
1021 case V4L2_CID_FLASH_STROBE_STATUS:
1022 case V4L2_CID_AUTO_FOCUS_STATUS:
1023 case V4L2_CID_FLASH_READY:
1024 case V4L2_CID_DV_TX_HOTPLUG:
1025 case V4L2_CID_DV_TX_RXSENSE:
1026 case V4L2_CID_DV_TX_EDID_PRESENT:
1027 case V4L2_CID_DV_RX_POWER_PRESENT:
1028 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
1029 break;
1030 }
1031}
1032EXPORT_SYMBOL(v4l2_ctrl_fill);
1033
1034
1035
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
1042 return false;
1043 default:
1044 return true;
1045 }
1046}
1047
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;
1062 if (ctrl->type == V4L2_CTRL_TYPE_MENU
1063 || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1064 ev->u.ctrl.step = 1;
1065 else
1066 ev->u.ctrl.step = ctrl->step;
1067 ev->u.ctrl.default_value = ctrl->default_value;
1068}
1069
1070static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
1071{
1072 struct v4l2_event ev;
1073 struct v4l2_subscribed_event *sev;
1074
1075 if (list_empty(&ctrl->ev_subs))
1076 return;
1077 fill_event(&ev, ctrl, changes);
1078
1079 list_for_each_entry(sev, &ctrl->ev_subs, node)
1080 if (sev->fh != fh ||
1081 (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
1082 v4l2_event_queue_fh(sev->fh, &ev);
1083}
1084
1085
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
1111static int user_to_new(struct v4l2_ext_control *c,
1112 struct v4l2_ctrl *ctrl)
1113{
1114 int ret;
1115 u32 size;
1116
1117 ctrl->is_new = 1;
1118 switch (ctrl->type) {
1119 case V4L2_CTRL_TYPE_INTEGER64:
1120 ctrl->val64 = c->value64;
1121 break;
1122 case V4L2_CTRL_TYPE_STRING:
1123 size = c->size;
1124 if (size == 0)
1125 return -ERANGE;
1126 if (size > ctrl->maximum + 1)
1127 size = ctrl->maximum + 1;
1128 ret = copy_from_user(ctrl->string, c->string, size);
1129 if (!ret) {
1130 char last = ctrl->string[size - 1];
1131
1132 ctrl->string[size - 1] = 0;
1133
1134
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
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
1172static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
1173{
1174 bool changed = false;
1175
1176 if (ctrl == NULL)
1177 return;
1178 switch (ctrl->type) {
1179 case V4L2_CTRL_TYPE_BUTTON:
1180 changed = true;
1181 break;
1182 case V4L2_CTRL_TYPE_STRING:
1183
1184 changed = strcmp(ctrl->string, ctrl->cur.string);
1185 strcpy(ctrl->cur.string, ctrl->string);
1186 break;
1187 case V4L2_CTRL_TYPE_INTEGER64:
1188 changed = ctrl->val64 != ctrl->cur.val64;
1189 ctrl->cur.val64 = ctrl->val64;
1190 break;
1191 default:
1192 changed = ctrl->val != ctrl->cur.val;
1193 ctrl->cur.val = ctrl->val;
1194 break;
1195 }
1196 if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
1197
1198 ctrl->flags &=
1199 ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1200 if (!is_cur_manual(ctrl->cluster[0])) {
1201 ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1202 if (ctrl->cluster[0]->has_volatiles)
1203 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1204 }
1205 fh = NULL;
1206 }
1207 if (changed || ch_flags) {
1208
1209
1210 if (!ctrl->is_new)
1211 fh = NULL;
1212 send_event(fh, ctrl,
1213 (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
1214 if (ctrl->call_notify && changed && ctrl->handler->notify)
1215 ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
1216 }
1217}
1218
1219
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
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
1239
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
1253 return 1;
1254 case V4L2_CTRL_TYPE_STRING:
1255
1256 diff = strcmp(ctrl->string, ctrl->cur.string);
1257 break;
1258 case V4L2_CTRL_TYPE_INTEGER64:
1259 diff = ctrl->val64 != ctrl->cur.val64;
1260 break;
1261 default:
1262 diff = ctrl->val != ctrl->cur.val;
1263 break;
1264 }
1265 }
1266 return diff;
1267}
1268
1269
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
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
1291
1292 if (step && ((1 << def) & step))
1293 return -EINVAL;
1294 return 0;
1295 case V4L2_CTRL_TYPE_STRING:
1296 if (min > max || min < 0 || step < 1 || def)
1297 return -ERANGE;
1298 return 0;
1299 default:
1300 return 0;
1301 }
1302}
1303
1304
1305static int validate_new(const struct v4l2_ctrl *ctrl,
1306 struct v4l2_ext_control *c)
1307{
1308 size_t len;
1309 u32 offset;
1310 s32 val;
1311
1312 switch (ctrl->type) {
1313 case V4L2_CTRL_TYPE_INTEGER:
1314
1315 val = c->value + ctrl->step / 2;
1316 val = clamp(val, ctrl->minimum, ctrl->maximum);
1317 offset = val - ctrl->minimum;
1318 offset = ctrl->step * (offset / ctrl->step);
1319 c->value = ctrl->minimum + offset;
1320 return 0;
1321
1322 case V4L2_CTRL_TYPE_BOOLEAN:
1323 c->value = !!c->value;
1324 return 0;
1325
1326 case V4L2_CTRL_TYPE_MENU:
1327 case V4L2_CTRL_TYPE_INTEGER_MENU:
1328 if (c->value < ctrl->minimum || c->value > ctrl->maximum)
1329 return -ERANGE;
1330 if (ctrl->menu_skip_mask & (1 << c->value))
1331 return -EINVAL;
1332 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1333 ctrl->qmenu[c->value][0] == '\0')
1334 return -EINVAL;
1335 return 0;
1336
1337 case V4L2_CTRL_TYPE_BITMASK:
1338 c->value &= ctrl->maximum;
1339 return 0;
1340
1341 case V4L2_CTRL_TYPE_BUTTON:
1342 case V4L2_CTRL_TYPE_CTRL_CLASS:
1343 c->value = 0;
1344 return 0;
1345
1346 case V4L2_CTRL_TYPE_INTEGER64:
1347 return 0;
1348
1349 case V4L2_CTRL_TYPE_STRING:
1350 len = strlen(c->string);
1351 if (len < ctrl->minimum)
1352 return -ERANGE;
1353 if ((len - ctrl->minimum) % ctrl->step)
1354 return -ERANGE;
1355 return 0;
1356
1357 default:
1358 return -EINVAL;
1359 }
1360}
1361
1362static inline u32 node2id(struct list_head *node)
1363{
1364 return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1365}
1366
1367
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
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)
1379{
1380 hdl->lock = &hdl->_lock;
1381 mutex_init(hdl->lock);
1382 lockdep_set_class_and_name(hdl->lock, key, name);
1383 INIT_LIST_HEAD(&hdl->ctrls);
1384 INIT_LIST_HEAD(&hdl->ctrl_refs);
1385 hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1386 hdl->buckets = kcalloc(hdl->nr_of_buckets, sizeof(hdl->buckets[0]),
1387 GFP_KERNEL);
1388 hdl->error = hdl->buckets ? 0 : -ENOMEM;
1389 return hdl->error;
1390}
1391EXPORT_SYMBOL(v4l2_ctrl_handler_init_class);
1392
1393
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;
1398 struct v4l2_subscribed_event *sev, *next_sev;
1399
1400 if (hdl == NULL || hdl->buckets == NULL)
1401 return;
1402
1403 mutex_lock(hdl->lock);
1404
1405 list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1406 list_del(&ref->node);
1407 kfree(ref);
1408 }
1409
1410 list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1411 list_del(&ctrl->node);
1412 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1413 list_del(&sev->node);
1414 kfree(ctrl);
1415 }
1416 kfree(hdl->buckets);
1417 hdl->buckets = NULL;
1418 hdl->cached = NULL;
1419 hdl->error = 0;
1420 mutex_unlock(hdl->lock);
1421}
1422EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1423
1424
1425
1426
1427
1428
1429
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
1438
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
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
1460 if (id >= V4L2_CID_PRIVATE_BASE)
1461 return find_private_ref(hdl, id);
1462 bucket = id % hdl->nr_of_buckets;
1463
1464
1465 if (hdl->cached && hdl->cached->ctrl->id == id)
1466 return hdl->cached;
1467
1468
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;
1475 return ref;
1476}
1477
1478
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) {
1485 mutex_lock(hdl->lock);
1486 ref = find_ref(hdl, id);
1487 mutex_unlock(hdl->lock);
1488 }
1489 return ref;
1490}
1491
1492
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
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;
1510
1511
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
1525
1526
1527
1528 ctrl->cluster = &new_ref->ctrl;
1529 ctrl->ncontrols = 1;
1530 }
1531
1532 INIT_LIST_HEAD(&new_ref->node);
1533
1534 mutex_lock(hdl->lock);
1535
1536
1537
1538
1539
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
1546 list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1547 if (ref->ctrl->id < id)
1548 continue;
1549
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
1560 new_ref->next = hdl->buckets[bucket];
1561 hdl->buckets[bucket] = new_ref;
1562
1563unlock:
1564 mutex_unlock(hdl->lock);
1565 return 0;
1566}
1567
1568
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,
1573 u32 flags, const char * const *qmenu,
1574 const s64 *qmenu_int, void *priv)
1575{
1576 struct v4l2_ctrl *ctrl;
1577 unsigned sz_extra = 0;
1578 int err;
1579
1580 if (hdl->error)
1581 return NULL;
1582
1583
1584 if (id == 0 || name == NULL || id >= V4L2_CID_PRIVATE_BASE ||
1585 (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1586 (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
1587 handler_set_err(hdl, -ERANGE);
1588 return NULL;
1589 }
1590 err = check_range(type, min, max, step, def);
1591 if (err) {
1592 handler_set_err(hdl, err);
1593 return NULL;
1594 }
1595 if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
1596 handler_set_err(hdl, -ERANGE);
1597 return NULL;
1598 }
1599
1600 if (type == V4L2_CTRL_TYPE_BUTTON)
1601 flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1602 else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1603 flags |= V4L2_CTRL_FLAG_READ_ONLY;
1604 else if (type == V4L2_CTRL_TYPE_STRING)
1605 sz_extra += 2 * (max + 1);
1606
1607 ctrl = kzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
1608 if (ctrl == NULL) {
1609 handler_set_err(hdl, -ENOMEM);
1610 return NULL;
1611 }
1612
1613 INIT_LIST_HEAD(&ctrl->node);
1614 INIT_LIST_HEAD(&ctrl->ev_subs);
1615 ctrl->handler = hdl;
1616 ctrl->ops = ops;
1617 ctrl->id = id;
1618 ctrl->name = name;
1619 ctrl->type = type;
1620 ctrl->flags = flags;
1621 ctrl->minimum = min;
1622 ctrl->maximum = max;
1623 ctrl->step = step;
1624 if (type == V4L2_CTRL_TYPE_MENU)
1625 ctrl->qmenu = qmenu;
1626 else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1627 ctrl->qmenu_int = qmenu_int;
1628 ctrl->priv = priv;
1629 ctrl->cur.val = ctrl->val = ctrl->default_value = def;
1630
1631 if (ctrl->type == V4L2_CTRL_TYPE_STRING) {
1632 ctrl->cur.string = (char *)&ctrl[1] + sz_extra - (max + 1);
1633 ctrl->string = (char *)&ctrl[1] + sz_extra - 2 * (max + 1);
1634 if (ctrl->minimum)
1635 memset(ctrl->cur.string, ' ', ctrl->minimum);
1636 }
1637 if (handler_new_ref(hdl, ctrl)) {
1638 kfree(ctrl);
1639 return NULL;
1640 }
1641 mutex_lock(hdl->lock);
1642 list_add_tail(&ctrl->node, &hdl->ctrls);
1643 mutex_unlock(hdl->lock);
1644 return ctrl;
1645}
1646
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;
1653 const char * const *qmenu = cfg->qmenu;
1654 const s64 *qmenu_int = cfg->qmenu_int;
1655 enum v4l2_ctrl_type type = cfg->type;
1656 u32 flags = cfg->flags;
1657 s32 min = cfg->min;
1658 s32 max = cfg->max;
1659 u32 step = cfg->step;
1660 s32 def = cfg->def;
1661
1662 if (name == NULL)
1663 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
1664 &def, &flags);
1665
1666 is_menu = (cfg->type == V4L2_CTRL_TYPE_MENU ||
1667 cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU);
1668 if (is_menu)
1669 WARN_ON(step);
1670 else
1671 WARN_ON(cfg->menu_skip_mask);
1672 if (cfg->type == V4L2_CTRL_TYPE_MENU && qmenu == NULL)
1673 qmenu = v4l2_ctrl_get_menu(cfg->id);
1674 else if (cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU &&
1675 qmenu_int == NULL) {
1676 handler_set_err(hdl, -EINVAL);
1677 return NULL;
1678 }
1679
1680 ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->id, name,
1681 type, min, max,
1682 is_menu ? cfg->menu_skip_mask : step,
1683 def, flags, qmenu, qmenu_int, priv);
1684 if (ctrl)
1685 ctrl->is_private = cfg->is_private;
1686 return ctrl;
1687}
1688EXPORT_SYMBOL(v4l2_ctrl_new_custom);
1689
1690
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);
1700 if (type == V4L2_CTRL_TYPE_MENU
1701 || type == V4L2_CTRL_TYPE_INTEGER_MENU) {
1702 handler_set_err(hdl, -EINVAL);
1703 return NULL;
1704 }
1705 return v4l2_ctrl_new(hdl, ops, id, name, type,
1706 min, max, step, def, flags, NULL, NULL, NULL);
1707}
1708EXPORT_SYMBOL(v4l2_ctrl_new_std);
1709
1710
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{
1715 const char * const *qmenu = v4l2_ctrl_get_menu(id);
1716 const char *name;
1717 enum v4l2_ctrl_type type;
1718 s32 min;
1719 s32 step;
1720 u32 flags;
1721
1722 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1723 if (type != V4L2_CTRL_TYPE_MENU) {
1724 handler_set_err(hdl, -EINVAL);
1725 return NULL;
1726 }
1727 return v4l2_ctrl_new(hdl, ops, id, name, type,
1728 0, max, mask, def, flags, qmenu, NULL, NULL);
1729}
1730EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
1731
1732
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
1744
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
1762
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
1783
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
1800int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
1801 struct v4l2_ctrl_handler *add,
1802 bool (*filter)(const struct v4l2_ctrl *ctrl))
1803{
1804 struct v4l2_ctrl_ref *ref;
1805 int ret = 0;
1806
1807
1808 if (!hdl || !add || hdl == add)
1809 return 0;
1810 if (hdl->error)
1811 return hdl->error;
1812 mutex_lock(add->lock);
1813 list_for_each_entry(ref, &add->ctrl_refs, node) {
1814 struct v4l2_ctrl *ctrl = ref->ctrl;
1815
1816
1817 if (ctrl->is_private)
1818 continue;
1819
1820 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1821 continue;
1822
1823 if (filter && !filter(ctrl))
1824 continue;
1825 ret = handler_new_ref(hdl, ctrl);
1826 if (ret)
1827 break;
1828 }
1829 mutex_unlock(add->lock);
1830 return ret;
1831}
1832EXPORT_SYMBOL(v4l2_ctrl_add_handler);
1833
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 if (V4L2_CTRL_ID2CLASS(ctrl->id) == V4L2_CTRL_CLASS_FM_RX)
1839 return true;
1840 switch (ctrl->id) {
1841 case V4L2_CID_AUDIO_MUTE:
1842 case V4L2_CID_AUDIO_VOLUME:
1843 case V4L2_CID_AUDIO_BALANCE:
1844 case V4L2_CID_AUDIO_BASS:
1845 case V4L2_CID_AUDIO_TREBLE:
1846 case V4L2_CID_AUDIO_LOUDNESS:
1847 return true;
1848 default:
1849 break;
1850 }
1851 return false;
1852}
1853EXPORT_SYMBOL(v4l2_ctrl_radio_filter);
1854
1855
1856void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
1857{
1858 bool has_volatiles = false;
1859 int i;
1860
1861
1862 BUG_ON(ncontrols == 0 || controls[0] == NULL);
1863
1864 for (i = 0; i < ncontrols; i++) {
1865 if (controls[i]) {
1866 controls[i]->cluster = controls;
1867 controls[i]->ncontrols = ncontrols;
1868 if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
1869 has_volatiles = true;
1870 }
1871 }
1872 controls[0]->has_volatiles = has_volatiles;
1873}
1874EXPORT_SYMBOL(v4l2_ctrl_cluster);
1875
1876void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
1877 u8 manual_val, bool set_volatile)
1878{
1879 struct v4l2_ctrl *master = controls[0];
1880 u32 flag = 0;
1881 int i;
1882
1883 v4l2_ctrl_cluster(ncontrols, controls);
1884 WARN_ON(ncontrols <= 1);
1885 WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
1886 WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
1887 master->is_auto = true;
1888 master->has_volatiles = set_volatile;
1889 master->manual_mode_value = manual_val;
1890 master->flags |= V4L2_CTRL_FLAG_UPDATE;
1891
1892 if (!is_cur_manual(master))
1893 flag = V4L2_CTRL_FLAG_INACTIVE |
1894 (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
1895
1896 for (i = 1; i < ncontrols; i++)
1897 if (controls[i])
1898 controls[i]->flags |= flag;
1899}
1900EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
1901
1902
1903void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
1904{
1905
1906 bool inactive = !active;
1907 bool old;
1908
1909 if (ctrl == NULL)
1910 return;
1911
1912 if (inactive)
1913
1914 old = test_and_set_bit(4, &ctrl->flags);
1915 else
1916
1917 old = test_and_clear_bit(4, &ctrl->flags);
1918 if (old != inactive)
1919 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1920}
1921EXPORT_SYMBOL(v4l2_ctrl_activate);
1922
1923
1924
1925
1926
1927
1928
1929void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
1930{
1931 bool old;
1932
1933 if (ctrl == NULL)
1934 return;
1935
1936 v4l2_ctrl_lock(ctrl);
1937 if (grabbed)
1938
1939 old = test_and_set_bit(1, &ctrl->flags);
1940 else
1941
1942 old = test_and_clear_bit(1, &ctrl->flags);
1943 if (old != grabbed)
1944 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1945 v4l2_ctrl_unlock(ctrl);
1946}
1947EXPORT_SYMBOL(v4l2_ctrl_grab);
1948
1949
1950static void log_ctrl(const struct v4l2_ctrl *ctrl,
1951 const char *prefix, const char *colon)
1952{
1953 if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
1954 return;
1955 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1956 return;
1957
1958 printk(KERN_INFO "%s%s%s: ", prefix, colon, ctrl->name);
1959
1960 switch (ctrl->type) {
1961 case V4L2_CTRL_TYPE_INTEGER:
1962 printk(KERN_CONT "%d", ctrl->cur.val);
1963 break;
1964 case V4L2_CTRL_TYPE_BOOLEAN:
1965 printk(KERN_CONT "%s", ctrl->cur.val ? "true" : "false");
1966 break;
1967 case V4L2_CTRL_TYPE_MENU:
1968 printk(KERN_CONT "%s", ctrl->qmenu[ctrl->cur.val]);
1969 break;
1970 case V4L2_CTRL_TYPE_INTEGER_MENU:
1971 printk(KERN_CONT "%lld", ctrl->qmenu_int[ctrl->cur.val]);
1972 break;
1973 case V4L2_CTRL_TYPE_BITMASK:
1974 printk(KERN_CONT "0x%08x", ctrl->cur.val);
1975 break;
1976 case V4L2_CTRL_TYPE_INTEGER64:
1977 printk(KERN_CONT "%lld", ctrl->cur.val64);
1978 break;
1979 case V4L2_CTRL_TYPE_STRING:
1980 printk(KERN_CONT "%s", ctrl->cur.string);
1981 break;
1982 default:
1983 printk(KERN_CONT "unknown type %d", ctrl->type);
1984 break;
1985 }
1986 if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
1987 V4L2_CTRL_FLAG_GRABBED |
1988 V4L2_CTRL_FLAG_VOLATILE)) {
1989 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
1990 printk(KERN_CONT " inactive");
1991 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
1992 printk(KERN_CONT " grabbed");
1993 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
1994 printk(KERN_CONT " volatile");
1995 }
1996 printk(KERN_CONT "\n");
1997}
1998
1999
2000void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
2001 const char *prefix)
2002{
2003 struct v4l2_ctrl *ctrl;
2004 const char *colon = "";
2005 int len;
2006
2007 if (hdl == NULL)
2008 return;
2009 if (prefix == NULL)
2010 prefix = "";
2011 len = strlen(prefix);
2012 if (len && prefix[len - 1] != ' ')
2013 colon = ": ";
2014 mutex_lock(hdl->lock);
2015 list_for_each_entry(ctrl, &hdl->ctrls, node)
2016 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
2017 log_ctrl(ctrl, prefix, colon);
2018 mutex_unlock(hdl->lock);
2019}
2020EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
2021
2022int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
2023{
2024 v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
2025 return 0;
2026}
2027EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
2028
2029
2030int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
2031{
2032 struct v4l2_ctrl *ctrl;
2033 int ret = 0;
2034
2035 if (hdl == NULL)
2036 return 0;
2037 mutex_lock(hdl->lock);
2038 list_for_each_entry(ctrl, &hdl->ctrls, node)
2039 ctrl->done = false;
2040
2041 list_for_each_entry(ctrl, &hdl->ctrls, node) {
2042 struct v4l2_ctrl *master = ctrl->cluster[0];
2043 int i;
2044
2045
2046
2047 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
2048 (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
2049 continue;
2050
2051 for (i = 0; i < master->ncontrols; i++) {
2052 if (master->cluster[i]) {
2053 cur_to_new(master->cluster[i]);
2054 master->cluster[i]->is_new = 1;
2055 master->cluster[i]->done = true;
2056 }
2057 }
2058 ret = call_op(master, s_ctrl);
2059 if (ret)
2060 break;
2061 }
2062 mutex_unlock(hdl->lock);
2063 return ret;
2064}
2065EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
2066
2067
2068int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
2069{
2070 u32 id = qc->id & V4L2_CTRL_ID_MASK;
2071 struct v4l2_ctrl_ref *ref;
2072 struct v4l2_ctrl *ctrl;
2073
2074 if (hdl == NULL)
2075 return -EINVAL;
2076
2077 mutex_lock(hdl->lock);
2078
2079
2080 ref = find_ref(hdl, id);
2081
2082 if ((qc->id & V4L2_CTRL_FLAG_NEXT_CTRL) && !list_empty(&hdl->ctrl_refs)) {
2083
2084
2085
2086 if (id >= node2id(hdl->ctrl_refs.prev)) {
2087 ref = NULL;
2088 } else if (ref) {
2089
2090
2091 ref = list_entry(ref->node.next, typeof(*ref), node);
2092 } else {
2093
2094
2095
2096
2097 list_for_each_entry(ref, &hdl->ctrl_refs, node)
2098 if (id < ref->ctrl->id)
2099 break;
2100 }
2101 }
2102 mutex_unlock(hdl->lock);
2103 if (!ref)
2104 return -EINVAL;
2105
2106 ctrl = ref->ctrl;
2107 memset(qc, 0, sizeof(*qc));
2108 if (id >= V4L2_CID_PRIVATE_BASE)
2109 qc->id = id;
2110 else
2111 qc->id = ctrl->id;
2112 strlcpy(qc->name, ctrl->name, sizeof(qc->name));
2113 qc->minimum = ctrl->minimum;
2114 qc->maximum = ctrl->maximum;
2115 qc->default_value = ctrl->default_value;
2116 if (ctrl->type == V4L2_CTRL_TYPE_MENU
2117 || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
2118 qc->step = 1;
2119 else
2120 qc->step = ctrl->step;
2121 qc->flags = ctrl->flags;
2122 qc->type = ctrl->type;
2123 return 0;
2124}
2125EXPORT_SYMBOL(v4l2_queryctrl);
2126
2127int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
2128{
2129 if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL)
2130 return -EINVAL;
2131 return v4l2_queryctrl(sd->ctrl_handler, qc);
2132}
2133EXPORT_SYMBOL(v4l2_subdev_queryctrl);
2134
2135
2136int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
2137{
2138 struct v4l2_ctrl *ctrl;
2139 u32 i = qm->index;
2140
2141 ctrl = v4l2_ctrl_find(hdl, qm->id);
2142 if (!ctrl)
2143 return -EINVAL;
2144
2145 qm->reserved = 0;
2146
2147 switch (ctrl->type) {
2148 case V4L2_CTRL_TYPE_MENU:
2149 if (ctrl->qmenu == NULL)
2150 return -EINVAL;
2151 break;
2152 case V4L2_CTRL_TYPE_INTEGER_MENU:
2153 if (ctrl->qmenu_int == NULL)
2154 return -EINVAL;
2155 break;
2156 default:
2157 return -EINVAL;
2158 }
2159
2160 if (i < ctrl->minimum || i > ctrl->maximum)
2161 return -EINVAL;
2162
2163
2164 if (ctrl->menu_skip_mask & (1 << i))
2165 return -EINVAL;
2166
2167 if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
2168 if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
2169 return -EINVAL;
2170 strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
2171 } else {
2172 qm->value = ctrl->qmenu_int[i];
2173 }
2174 return 0;
2175}
2176EXPORT_SYMBOL(v4l2_querymenu);
2177
2178int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
2179{
2180 return v4l2_querymenu(sd->ctrl_handler, qm);
2181}
2182EXPORT_SYMBOL(v4l2_subdev_querymenu);
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
2228 struct v4l2_ext_controls *cs,
2229 struct v4l2_ctrl_helper *helpers)
2230{
2231 struct v4l2_ctrl_helper *h;
2232 bool have_clusters = false;
2233 u32 i;
2234
2235 for (i = 0, h = helpers; i < cs->count; i++, h++) {
2236 struct v4l2_ext_control *c = &cs->controls[i];
2237 struct v4l2_ctrl_ref *ref;
2238 struct v4l2_ctrl *ctrl;
2239 u32 id = c->id & V4L2_CTRL_ID_MASK;
2240
2241 cs->error_idx = i;
2242
2243 if (cs->ctrl_class && V4L2_CTRL_ID2CLASS(id) != cs->ctrl_class)
2244 return -EINVAL;
2245
2246
2247
2248 if (id >= V4L2_CID_PRIVATE_BASE)
2249 return -EINVAL;
2250 ref = find_ref_lock(hdl, id);
2251 if (ref == NULL)
2252 return -EINVAL;
2253 ctrl = ref->ctrl;
2254 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
2255 return -EINVAL;
2256
2257 if (ctrl->cluster[0]->ncontrols > 1)
2258 have_clusters = true;
2259 if (ctrl->cluster[0] != ctrl)
2260 ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
2261
2262 h->mref = ref;
2263 h->ctrl = ctrl;
2264
2265
2266
2267 h->next = 0;
2268 }
2269
2270
2271
2272 if (!have_clusters)
2273 return 0;
2274
2275
2276
2277
2278
2279 mutex_lock(hdl->lock);
2280
2281
2282 for (i = 0; i < cs->count; i++)
2283 helpers[i].mref->helper = NULL;
2284 for (i = 0, h = helpers; i < cs->count; i++, h++) {
2285 struct v4l2_ctrl_ref *mref = h->mref;
2286
2287
2288
2289 if (mref->helper) {
2290
2291
2292
2293 mref->helper->next = i;
2294
2295
2296 h->mref = NULL;
2297 }
2298
2299 mref->helper = h;
2300 }
2301 mutex_unlock(hdl->lock);
2302 return 0;
2303}
2304
2305
2306
2307
2308static int class_check(struct v4l2_ctrl_handler *hdl, u32 ctrl_class)
2309{
2310 if (ctrl_class == 0)
2311 return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
2312 return find_ref_lock(hdl, ctrl_class | 1) ? 0 : -EINVAL;
2313}
2314
2315
2316
2317
2318int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2319{
2320 struct v4l2_ctrl_helper helper[4];
2321 struct v4l2_ctrl_helper *helpers = helper;
2322 int ret;
2323 int i, j;
2324
2325 cs->error_idx = cs->count;
2326 cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2327
2328 if (hdl == NULL)
2329 return -EINVAL;
2330
2331 if (cs->count == 0)
2332 return class_check(hdl, cs->ctrl_class);
2333
2334 if (cs->count > ARRAY_SIZE(helper)) {
2335 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2336 GFP_KERNEL);
2337 if (helpers == NULL)
2338 return -ENOMEM;
2339 }
2340
2341 ret = prepare_ext_ctrls(hdl, cs, helpers);
2342 cs->error_idx = cs->count;
2343
2344 for (i = 0; !ret && i < cs->count; i++)
2345 if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2346 ret = -EACCES;
2347
2348 for (i = 0; !ret && i < cs->count; i++) {
2349 int (*ctrl_to_user)(struct v4l2_ext_control *c,
2350 struct v4l2_ctrl *ctrl) = cur_to_user;
2351 struct v4l2_ctrl *master;
2352
2353 if (helpers[i].mref == NULL)
2354 continue;
2355
2356 master = helpers[i].mref->ctrl;
2357 cs->error_idx = i;
2358
2359 v4l2_ctrl_lock(master);
2360
2361
2362 if ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
2363 (master->has_volatiles && !is_cur_manual(master))) {
2364 for (j = 0; j < master->ncontrols; j++)
2365 cur_to_new(master->cluster[j]);
2366 ret = call_op(master, g_volatile_ctrl);
2367 ctrl_to_user = new_to_user;
2368 }
2369
2370
2371
2372 if (!ret) {
2373 u32 idx = i;
2374
2375 do {
2376 ret = ctrl_to_user(cs->controls + idx,
2377 helpers[idx].ctrl);
2378 idx = helpers[idx].next;
2379 } while (!ret && idx);
2380 }
2381 v4l2_ctrl_unlock(master);
2382 }
2383
2384 if (cs->count > ARRAY_SIZE(helper))
2385 kfree(helpers);
2386 return ret;
2387}
2388EXPORT_SYMBOL(v4l2_g_ext_ctrls);
2389
2390int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2391{
2392 return v4l2_g_ext_ctrls(sd->ctrl_handler, cs);
2393}
2394EXPORT_SYMBOL(v4l2_subdev_g_ext_ctrls);
2395
2396
2397static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
2398{
2399 struct v4l2_ctrl *master = ctrl->cluster[0];
2400 int ret = 0;
2401 int i;
2402
2403
2404
2405
2406
2407 if (ctrl->type == V4L2_CTRL_TYPE_STRING)
2408 return -EINVAL;
2409
2410 if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2411 return -EACCES;
2412
2413 v4l2_ctrl_lock(master);
2414
2415 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2416 for (i = 0; i < master->ncontrols; i++)
2417 cur_to_new(master->cluster[i]);
2418 ret = call_op(master, g_volatile_ctrl);
2419 new_to_user(c, ctrl);
2420 } else {
2421 cur_to_user(c, ctrl);
2422 }
2423 v4l2_ctrl_unlock(master);
2424 return ret;
2425}
2426
2427int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
2428{
2429 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2430 struct v4l2_ext_control c;
2431 int ret;
2432
2433 if (ctrl == NULL || !type_is_int(ctrl))
2434 return -EINVAL;
2435 ret = get_ctrl(ctrl, &c);
2436 control->value = c.value;
2437 return ret;
2438}
2439EXPORT_SYMBOL(v4l2_g_ctrl);
2440
2441int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2442{
2443 return v4l2_g_ctrl(sd->ctrl_handler, control);
2444}
2445EXPORT_SYMBOL(v4l2_subdev_g_ctrl);
2446
2447s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
2448{
2449 struct v4l2_ext_control c;
2450
2451
2452 WARN_ON(!type_is_int(ctrl));
2453 c.value = 0;
2454 get_ctrl(ctrl, &c);
2455 return c.value;
2456}
2457EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
2458
2459s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
2460{
2461 struct v4l2_ext_control c;
2462
2463
2464 WARN_ON(ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2465 c.value = 0;
2466 get_ctrl(ctrl, &c);
2467 return c.value;
2468}
2469EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
2470
2471
2472
2473
2474
2475static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
2476 bool set, u32 ch_flags)
2477{
2478 bool update_flag;
2479 int ret;
2480 int i;
2481
2482
2483
2484
2485
2486 for (i = 0; i < master->ncontrols; i++) {
2487 struct v4l2_ctrl *ctrl = master->cluster[i];
2488
2489 if (ctrl == NULL)
2490 continue;
2491
2492 if (!ctrl->is_new) {
2493 cur_to_new(ctrl);
2494 continue;
2495 }
2496
2497
2498 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2499 return -EBUSY;
2500 }
2501
2502 ret = call_op(master, try_ctrl);
2503
2504
2505 if (ret || !set || !cluster_changed(master))
2506 return ret;
2507 ret = call_op(master, s_ctrl);
2508 if (ret)
2509 return ret;
2510
2511
2512 update_flag = is_cur_manual(master) != is_new_manual(master);
2513 for (i = 0; i < master->ncontrols; i++)
2514 new_to_cur(fh, master->cluster[i], ch_flags |
2515 ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
2516 return 0;
2517}
2518
2519
2520static int validate_ctrls(struct v4l2_ext_controls *cs,
2521 struct v4l2_ctrl_helper *helpers, bool set)
2522{
2523 unsigned i;
2524 int ret = 0;
2525
2526 cs->error_idx = cs->count;
2527 for (i = 0; i < cs->count; i++) {
2528 struct v4l2_ctrl *ctrl = helpers[i].ctrl;
2529
2530 cs->error_idx = i;
2531
2532 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2533 return -EACCES;
2534
2535
2536
2537
2538
2539
2540 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2541 return -EBUSY;
2542 ret = validate_new(ctrl, &cs->controls[i]);
2543 if (ret)
2544 return ret;
2545 }
2546 return 0;
2547}
2548
2549
2550
2551static void update_from_auto_cluster(struct v4l2_ctrl *master)
2552{
2553 int i;
2554
2555 for (i = 0; i < master->ncontrols; i++)
2556 cur_to_new(master->cluster[i]);
2557 if (!call_op(master, g_volatile_ctrl))
2558 for (i = 1; i < master->ncontrols; i++)
2559 if (master->cluster[i])
2560 master->cluster[i]->is_new = 1;
2561}
2562
2563
2564static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2565 struct v4l2_ext_controls *cs,
2566 bool set)
2567{
2568 struct v4l2_ctrl_helper helper[4];
2569 struct v4l2_ctrl_helper *helpers = helper;
2570 unsigned i, j;
2571 int ret;
2572
2573 cs->error_idx = cs->count;
2574 cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2575
2576 if (hdl == NULL)
2577 return -EINVAL;
2578
2579 if (cs->count == 0)
2580 return class_check(hdl, cs->ctrl_class);
2581
2582 if (cs->count > ARRAY_SIZE(helper)) {
2583 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2584 GFP_KERNEL);
2585 if (!helpers)
2586 return -ENOMEM;
2587 }
2588 ret = prepare_ext_ctrls(hdl, cs, helpers);
2589 if (!ret)
2590 ret = validate_ctrls(cs, helpers, set);
2591 if (ret && set)
2592 cs->error_idx = cs->count;
2593 for (i = 0; !ret && i < cs->count; i++) {
2594 struct v4l2_ctrl *master;
2595 u32 idx = i;
2596
2597 if (helpers[i].mref == NULL)
2598 continue;
2599
2600 cs->error_idx = i;
2601 master = helpers[i].mref->ctrl;
2602 v4l2_ctrl_lock(master);
2603
2604
2605 for (j = 0; j < master->ncontrols; j++)
2606 if (master->cluster[j])
2607 master->cluster[j]->is_new = 0;
2608
2609
2610
2611
2612
2613
2614
2615 if (master->is_auto && master->has_volatiles &&
2616 !is_cur_manual(master)) {
2617
2618 s32 new_auto_val = master->manual_mode_value + 1;
2619 u32 tmp_idx = idx;
2620
2621 do {
2622
2623
2624 if (helpers[tmp_idx].ctrl == master)
2625 new_auto_val = cs->controls[tmp_idx].value;
2626 tmp_idx = helpers[tmp_idx].next;
2627 } while (tmp_idx);
2628
2629
2630 if (new_auto_val == master->manual_mode_value)
2631 update_from_auto_cluster(master);
2632 }
2633
2634
2635
2636 do {
2637 ret = user_to_new(cs->controls + idx, helpers[idx].ctrl);
2638 idx = helpers[idx].next;
2639 } while (!ret && idx);
2640
2641 if (!ret)
2642 ret = try_or_set_cluster(fh, master, set, 0);
2643
2644
2645 if (!ret) {
2646 idx = i;
2647 do {
2648 ret = new_to_user(cs->controls + idx,
2649 helpers[idx].ctrl);
2650 idx = helpers[idx].next;
2651 } while (!ret && idx);
2652 }
2653 v4l2_ctrl_unlock(master);
2654 }
2655
2656 if (cs->count > ARRAY_SIZE(helper))
2657 kfree(helpers);
2658 return ret;
2659}
2660
2661int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2662{
2663 return try_set_ext_ctrls(NULL, hdl, cs, false);
2664}
2665EXPORT_SYMBOL(v4l2_try_ext_ctrls);
2666
2667int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2668 struct v4l2_ext_controls *cs)
2669{
2670 return try_set_ext_ctrls(fh, hdl, cs, true);
2671}
2672EXPORT_SYMBOL(v4l2_s_ext_ctrls);
2673
2674int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2675{
2676 return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, false);
2677}
2678EXPORT_SYMBOL(v4l2_subdev_try_ext_ctrls);
2679
2680int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2681{
2682 return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, true);
2683}
2684EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
2685
2686
2687static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
2688 struct v4l2_ext_control *c, u32 ch_flags)
2689{
2690 struct v4l2_ctrl *master = ctrl->cluster[0];
2691 int i;
2692
2693
2694
2695
2696
2697 if (ctrl->type == V4L2_CTRL_TYPE_STRING)
2698 return -EINVAL;
2699
2700
2701 for (i = 0; i < master->ncontrols; i++)
2702 if (master->cluster[i])
2703 master->cluster[i]->is_new = 0;
2704
2705
2706
2707
2708 if (master->is_auto && master->has_volatiles && ctrl == master &&
2709 !is_cur_manual(master) && c->value == master->manual_mode_value)
2710 update_from_auto_cluster(master);
2711
2712 user_to_new(c, ctrl);
2713 return try_or_set_cluster(fh, master, true, ch_flags);
2714}
2715
2716
2717static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
2718 struct v4l2_ext_control *c)
2719{
2720 int ret = validate_new(ctrl, c);
2721
2722 if (!ret) {
2723 v4l2_ctrl_lock(ctrl);
2724 ret = set_ctrl(fh, ctrl, c, 0);
2725 if (!ret)
2726 cur_to_user(c, ctrl);
2727 v4l2_ctrl_unlock(ctrl);
2728 }
2729 return ret;
2730}
2731
2732int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2733 struct v4l2_control *control)
2734{
2735 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2736 struct v4l2_ext_control c;
2737 int ret;
2738
2739 if (ctrl == NULL || !type_is_int(ctrl))
2740 return -EINVAL;
2741
2742 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2743 return -EACCES;
2744
2745 c.value = control->value;
2746 ret = set_ctrl_lock(fh, ctrl, &c);
2747 control->value = c.value;
2748 return ret;
2749}
2750EXPORT_SYMBOL(v4l2_s_ctrl);
2751
2752int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2753{
2754 return v4l2_s_ctrl(NULL, sd->ctrl_handler, control);
2755}
2756EXPORT_SYMBOL(v4l2_subdev_s_ctrl);
2757
2758int v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
2759{
2760 struct v4l2_ext_control c;
2761
2762
2763 WARN_ON(!type_is_int(ctrl));
2764 c.value = val;
2765 return set_ctrl_lock(NULL, ctrl, &c);
2766}
2767EXPORT_SYMBOL(v4l2_ctrl_s_ctrl);
2768
2769int v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
2770{
2771 struct v4l2_ext_control c;
2772
2773
2774 WARN_ON(ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
2775 c.value64 = val;
2776 return set_ctrl_lock(NULL, ctrl, &c);
2777}
2778EXPORT_SYMBOL(v4l2_ctrl_s_ctrl_int64);
2779
2780void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)
2781{
2782 if (ctrl == NULL)
2783 return;
2784 if (notify == NULL) {
2785 ctrl->call_notify = 0;
2786 return;
2787 }
2788 if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify))
2789 return;
2790 ctrl->handler->notify = notify;
2791 ctrl->handler->notify_priv = priv;
2792 ctrl->call_notify = 1;
2793}
2794EXPORT_SYMBOL(v4l2_ctrl_notify);
2795
2796int v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
2797 s32 min, s32 max, u32 step, s32 def)
2798{
2799 int ret = check_range(ctrl->type, min, max, step, def);
2800 struct v4l2_ext_control c;
2801
2802 switch (ctrl->type) {
2803 case V4L2_CTRL_TYPE_INTEGER:
2804 case V4L2_CTRL_TYPE_BOOLEAN:
2805 case V4L2_CTRL_TYPE_MENU:
2806 case V4L2_CTRL_TYPE_INTEGER_MENU:
2807 case V4L2_CTRL_TYPE_BITMASK:
2808 if (ret)
2809 return ret;
2810 break;
2811 default:
2812 return -EINVAL;
2813 }
2814 v4l2_ctrl_lock(ctrl);
2815 ctrl->minimum = min;
2816 ctrl->maximum = max;
2817 ctrl->step = step;
2818 ctrl->default_value = def;
2819 c.value = ctrl->cur.val;
2820 if (validate_new(ctrl, &c))
2821 c.value = def;
2822 if (c.value != ctrl->cur.val)
2823 ret = set_ctrl(NULL, ctrl, &c, V4L2_EVENT_CTRL_CH_RANGE);
2824 else
2825 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
2826 v4l2_ctrl_unlock(ctrl);
2827 return ret;
2828}
2829EXPORT_SYMBOL(v4l2_ctrl_modify_range);
2830
2831static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
2832{
2833 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2834
2835 if (ctrl == NULL)
2836 return -EINVAL;
2837
2838 v4l2_ctrl_lock(ctrl);
2839 list_add_tail(&sev->node, &ctrl->ev_subs);
2840 if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
2841 (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
2842 struct v4l2_event ev;
2843 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
2844
2845 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
2846 changes |= V4L2_EVENT_CTRL_CH_VALUE;
2847 fill_event(&ev, ctrl, changes);
2848
2849
2850 sev->elems = elems;
2851 v4l2_event_queue_fh(sev->fh, &ev);
2852 }
2853 v4l2_ctrl_unlock(ctrl);
2854 return 0;
2855}
2856
2857static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
2858{
2859 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2860
2861 v4l2_ctrl_lock(ctrl);
2862 list_del(&sev->node);
2863 v4l2_ctrl_unlock(ctrl);
2864}
2865
2866void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
2867{
2868 u32 old_changes = old->u.ctrl.changes;
2869
2870 old->u.ctrl = new->u.ctrl;
2871 old->u.ctrl.changes |= old_changes;
2872}
2873EXPORT_SYMBOL(v4l2_ctrl_replace);
2874
2875void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
2876{
2877 new->u.ctrl.changes |= old->u.ctrl.changes;
2878}
2879EXPORT_SYMBOL(v4l2_ctrl_merge);
2880
2881const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
2882 .add = v4l2_ctrl_add_event,
2883 .del = v4l2_ctrl_del_event,
2884 .replace = v4l2_ctrl_replace,
2885 .merge = v4l2_ctrl_merge,
2886};
2887EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
2888
2889int v4l2_ctrl_log_status(struct file *file, void *fh)
2890{
2891 struct video_device *vfd = video_devdata(file);
2892 struct v4l2_fh *vfh = file->private_data;
2893
2894 if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
2895 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
2896 vfd->v4l2_dev->name);
2897 return 0;
2898}
2899EXPORT_SYMBOL(v4l2_ctrl_log_status);
2900
2901int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
2902 const struct v4l2_event_subscription *sub)
2903{
2904 if (sub->type == V4L2_EVENT_CTRL)
2905 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
2906 return -EINVAL;
2907}
2908EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
2909
2910int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
2911 struct v4l2_event_subscription *sub)
2912{
2913 if (!sd->ctrl_handler)
2914 return -EINVAL;
2915 return v4l2_ctrl_subscribe_event(fh, sub);
2916}
2917EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
2918
2919unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
2920{
2921 struct v4l2_fh *fh = file->private_data;
2922
2923 if (v4l2_event_pending(fh))
2924 return POLLPRI;
2925 poll_wait(file, &fh->wait, wait);
2926 return 0;
2927}
2928EXPORT_SYMBOL(v4l2_ctrl_poll);
2929
