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