2 V4L2 controls framework implementation.
4 Copyright (C) 2010 Hans Verkuil <hverkuil@xs4all.nl>
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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>
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)
35 /* Internal temporary helper struct, one for each v4l2_ext_control */
36 struct v4l2_ctrl_helper {
37 /* Pointer to the control reference of the master control */
38 struct v4l2_ctrl_ref *mref;
39 /* The control corresponding to the v4l2_ext_control ID field. */
40 struct v4l2_ctrl *ctrl;
41 /* v4l2_ext_control index of the next control belonging to the
42 same cluster, or 0 if there isn't any. */
46 /* Small helper function to determine if the autocluster is set to manual
48 static bool is_cur_manual(const struct v4l2_ctrl *master)
50 return master->is_auto && master->cur.val == master->manual_mode_value;
53 /* Same as above, but this checks the against the new value instead of the
55 static bool is_new_manual(const struct v4l2_ctrl *master)
57 return master->is_auto && master->val == master->manual_mode_value;
60 /* Returns NULL or a character pointer array containing the menu for
61 the given control ID. The pointer array ends with a NULL pointer.
62 An empty string signifies a menu entry that is invalid. This allows
63 drivers to disable certain options if it is not supported. */
64 const char * const *v4l2_ctrl_get_menu(u32 id)
66 static const char * const mpeg_audio_sampling_freq[] = {
72 static const char * const mpeg_audio_encoding[] = {
80 static const char * const mpeg_audio_l1_bitrate[] = {
97 static const char * const mpeg_audio_l2_bitrate[] = {
114 static const char * const mpeg_audio_l3_bitrate[] = {
131 static const char * const mpeg_audio_ac3_bitrate[] = {
153 static const char * const mpeg_audio_mode[] = {
160 static const char * const mpeg_audio_mode_extension[] = {
167 static const char * const mpeg_audio_emphasis[] = {
173 static const char * const mpeg_audio_crc[] = {
178 static const char * const mpeg_audio_dec_playback[] = {
187 static const char * const mpeg_video_encoding[] = {
193 static const char * const mpeg_video_aspect[] = {
200 static const char * const mpeg_video_bitrate_mode[] = {
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",
214 static const char * const mpeg_stream_vbi_fmt[] = {
216 "Private Packet, IVTV Format",
219 static const char * const camera_power_line_frequency[] = {
226 static const char * const camera_exposure_auto[] = {
229 "Shutter Priority Mode",
230 "Aperture Priority Mode",
233 static const char * const colorfx[] = {
252 static const char * const auto_n_preset_white_balance[] = {
265 static const char * const tune_preemphasis[] = {
271 static const char * const header_mode[] = {
273 "Joined With 1st Frame",
276 static const char * const multi_slice[] = {
282 static const char * const entropy_mode[] = {
287 static const char * const mpeg_h264_level[] = {
306 static const char * const h264_loop_filter[] = {
309 "Disabled at Slice Boundary",
312 static const char * const h264_profile[] = {
314 "Constrained Baseline",
320 "High 444 Predictive",
327 "Scalable High Intra",
331 static const char * const vui_sar_idc[] = {
352 static const char * const mpeg_mpeg4_level[] = {
363 static const char * const mpeg4_profile[] = {
368 "Advanced Coding Efficency",
372 static const char * const flash_led_mode[] = {
378 static const char * const flash_strobe_source[] = {
384 static const char * const jpeg_chroma_subsampling[] = {
395 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
396 return mpeg_audio_sampling_freq;
397 case V4L2_CID_MPEG_AUDIO_ENCODING:
398 return mpeg_audio_encoding;
399 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
400 return mpeg_audio_l1_bitrate;
401 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
402 return mpeg_audio_l2_bitrate;
403 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
404 return mpeg_audio_l3_bitrate;
405 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
406 return mpeg_audio_ac3_bitrate;
407 case V4L2_CID_MPEG_AUDIO_MODE:
408 return mpeg_audio_mode;
409 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
410 return mpeg_audio_mode_extension;
411 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
412 return mpeg_audio_emphasis;
413 case V4L2_CID_MPEG_AUDIO_CRC:
414 return mpeg_audio_crc;
415 case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
416 case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
417 return mpeg_audio_dec_playback;
418 case V4L2_CID_MPEG_VIDEO_ENCODING:
419 return mpeg_video_encoding;
420 case V4L2_CID_MPEG_VIDEO_ASPECT:
421 return mpeg_video_aspect;
422 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
423 return mpeg_video_bitrate_mode;
424 case V4L2_CID_MPEG_STREAM_TYPE:
425 return mpeg_stream_type;
426 case V4L2_CID_MPEG_STREAM_VBI_FMT:
427 return mpeg_stream_vbi_fmt;
428 case V4L2_CID_POWER_LINE_FREQUENCY:
429 return camera_power_line_frequency;
430 case V4L2_CID_EXPOSURE_AUTO:
431 return camera_exposure_auto;
432 case V4L2_CID_COLORFX:
434 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
435 return auto_n_preset_white_balance;
436 case V4L2_CID_TUNE_PREEMPHASIS:
437 return tune_preemphasis;
438 case V4L2_CID_FLASH_LED_MODE:
439 return flash_led_mode;
440 case V4L2_CID_FLASH_STROBE_SOURCE:
441 return flash_strobe_source;
442 case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
444 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
446 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
448 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
449 return mpeg_h264_level;
450 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
451 return h264_loop_filter;
452 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
454 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
456 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
457 return mpeg_mpeg4_level;
458 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
459 return mpeg4_profile;
460 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
461 return jpeg_chroma_subsampling;
467 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
469 /* Return the control name. */
470 const char *v4l2_ctrl_get_name(u32 id)
474 /* Keep the order of the 'case's the same as in videodev2.h! */
475 case V4L2_CID_USER_CLASS: return "User Controls";
476 case V4L2_CID_BRIGHTNESS: return "Brightness";
477 case V4L2_CID_CONTRAST: return "Contrast";
478 case V4L2_CID_SATURATION: return "Saturation";
479 case V4L2_CID_HUE: return "Hue";
480 case V4L2_CID_AUDIO_VOLUME: return "Volume";
481 case V4L2_CID_AUDIO_BALANCE: return "Balance";
482 case V4L2_CID_AUDIO_BASS: return "Bass";
483 case V4L2_CID_AUDIO_TREBLE: return "Treble";
484 case V4L2_CID_AUDIO_MUTE: return "Mute";
485 case V4L2_CID_AUDIO_LOUDNESS: return "Loudness";
486 case V4L2_CID_BLACK_LEVEL: return "Black Level";
487 case V4L2_CID_AUTO_WHITE_BALANCE: return "White Balance, Automatic";
488 case V4L2_CID_DO_WHITE_BALANCE: return "Do White Balance";
489 case V4L2_CID_RED_BALANCE: return "Red Balance";
490 case V4L2_CID_BLUE_BALANCE: return "Blue Balance";
491 case V4L2_CID_GAMMA: return "Gamma";
492 case V4L2_CID_EXPOSURE: return "Exposure";
493 case V4L2_CID_AUTOGAIN: return "Gain, Automatic";
494 case V4L2_CID_GAIN: return "Gain";
495 case V4L2_CID_HFLIP: return "Horizontal Flip";
496 case V4L2_CID_VFLIP: return "Vertical Flip";
497 case V4L2_CID_HCENTER: return "Horizontal Center";
498 case V4L2_CID_VCENTER: return "Vertical Center";
499 case V4L2_CID_POWER_LINE_FREQUENCY: return "Power Line Frequency";
500 case V4L2_CID_HUE_AUTO: return "Hue, Automatic";
501 case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
502 case V4L2_CID_SHARPNESS: return "Sharpness";
503 case V4L2_CID_BACKLIGHT_COMPENSATION: return "Backlight Compensation";
504 case V4L2_CID_CHROMA_AGC: return "Chroma AGC";
505 case V4L2_CID_COLOR_KILLER: return "Color Killer";
506 case V4L2_CID_COLORFX: return "Color Effects";
507 case V4L2_CID_AUTOBRIGHTNESS: return "Brightness, Automatic";
508 case V4L2_CID_BAND_STOP_FILTER: return "Band-Stop Filter";
509 case V4L2_CID_ROTATE: return "Rotate";
510 case V4L2_CID_BG_COLOR: return "Background Color";
511 case V4L2_CID_CHROMA_GAIN: return "Chroma Gain";
512 case V4L2_CID_ILLUMINATORS_1: return "Illuminator 1";
513 case V4L2_CID_ILLUMINATORS_2: return "Illuminator 2";
514 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE: return "Min Number of Capture Buffers";
515 case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT: return "Min Number of Output Buffers";
516 case V4L2_CID_ALPHA_COMPONENT: return "Alpha Component";
517 case V4L2_CID_COLORFX_CBCR: return "Color Effects, CbCr";
520 /* Keep the order of the 'case's the same as in videodev2.h! */
521 case V4L2_CID_MPEG_CLASS: return "MPEG Encoder Controls";
522 case V4L2_CID_MPEG_STREAM_TYPE: return "Stream Type";
523 case V4L2_CID_MPEG_STREAM_PID_PMT: return "Stream PMT Program ID";
524 case V4L2_CID_MPEG_STREAM_PID_AUDIO: return "Stream Audio Program ID";
525 case V4L2_CID_MPEG_STREAM_PID_VIDEO: return "Stream Video Program ID";
526 case V4L2_CID_MPEG_STREAM_PID_PCR: return "Stream PCR Program ID";
527 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
528 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
529 case V4L2_CID_MPEG_STREAM_VBI_FMT: return "Stream VBI Format";
530 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
531 case V4L2_CID_MPEG_AUDIO_ENCODING: return "Audio Encoding";
532 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: return "Audio Layer I Bitrate";
533 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: return "Audio Layer II Bitrate";
534 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: return "Audio Layer III Bitrate";
535 case V4L2_CID_MPEG_AUDIO_MODE: return "Audio Stereo Mode";
536 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
537 case V4L2_CID_MPEG_AUDIO_EMPHASIS: return "Audio Emphasis";
538 case V4L2_CID_MPEG_AUDIO_CRC: return "Audio CRC";
539 case V4L2_CID_MPEG_AUDIO_MUTE: return "Audio Mute";
540 case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate";
541 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: return "Audio AC-3 Bitrate";
542 case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK: return "Audio Playback";
543 case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: return "Audio Multilingual Playback";
544 case V4L2_CID_MPEG_VIDEO_ENCODING: return "Video Encoding";
545 case V4L2_CID_MPEG_VIDEO_ASPECT: return "Video Aspect";
546 case V4L2_CID_MPEG_VIDEO_B_FRAMES: return "Video B Frames";
547 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: return "Video GOP Size";
548 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: return "Video GOP Closure";
549 case V4L2_CID_MPEG_VIDEO_PULLDOWN: return "Video Pulldown";
550 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: return "Video Bitrate Mode";
551 case V4L2_CID_MPEG_VIDEO_BITRATE: return "Video Bitrate";
552 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: return "Video Peak Bitrate";
553 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
554 case V4L2_CID_MPEG_VIDEO_MUTE: return "Video Mute";
555 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: return "Video Mute YUV";
556 case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE: return "Decoder Slice Interface";
557 case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER: return "MPEG4 Loop Filter Enable";
558 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB: return "Number of Intra Refresh MBs";
559 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE: return "Frame Level Rate Control Enable";
560 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE: return "H264 MB Level Rate Control";
561 case V4L2_CID_MPEG_VIDEO_HEADER_MODE: return "Sequence Header Mode";
562 case V4L2_CID_MPEG_VIDEO_MAX_REF_PIC: return "Max Number of Reference Pics";
563 case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP: return "H263 I-Frame QP Value";
564 case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP: return "H263 P-Frame QP Value";
565 case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP: return "H263 B-Frame QP Value";
566 case V4L2_CID_MPEG_VIDEO_H263_MIN_QP: return "H263 Minimum QP Value";
567 case V4L2_CID_MPEG_VIDEO_H263_MAX_QP: return "H263 Maximum QP Value";
568 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP: return "H264 I-Frame QP Value";
569 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP: return "H264 P-Frame QP Value";
570 case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP: return "H264 B-Frame QP Value";
571 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP: return "H264 Maximum QP Value";
572 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP: return "H264 Minimum QP Value";
573 case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM: return "H264 8x8 Transform Enable";
574 case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE: return "H264 CPB Buffer Size";
575 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE: return "H264 Entropy Mode";
576 case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD: return "H264 I-Frame Period";
577 case V4L2_CID_MPEG_VIDEO_H264_LEVEL: return "H264 Level";
578 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA: return "H264 Loop Filter Alpha Offset";
579 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA: return "H264 Loop Filter Beta Offset";
580 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE: return "H264 Loop Filter Mode";
581 case V4L2_CID_MPEG_VIDEO_H264_PROFILE: return "H264 Profile";
582 case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT: return "Vertical Size of SAR";
583 case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH: return "Horizontal Size of SAR";
584 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE: return "Aspect Ratio VUI Enable";
585 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC: return "VUI Aspect Ratio IDC";
586 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP: return "MPEG4 I-Frame QP Value";
587 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP: return "MPEG4 P-Frame QP Value";
588 case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP: return "MPEG4 B-Frame QP Value";
589 case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP: return "MPEG4 Minimum QP Value";
590 case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP: return "MPEG4 Maximum QP Value";
591 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL: return "MPEG4 Level";
592 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE: return "MPEG4 Profile";
593 case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL: return "Quarter Pixel Search Enable";
594 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES: return "Maximum Bytes in a Slice";
595 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB: return "Number of MBs in a Slice";
596 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: return "Slice Partitioning Method";
597 case V4L2_CID_MPEG_VIDEO_VBV_SIZE: return "VBV Buffer Size";
598 case V4L2_CID_MPEG_VIDEO_DEC_PTS: return "Video Decoder PTS";
599 case V4L2_CID_MPEG_VIDEO_DEC_FRAME: return "Video Decoder Frame Count";
601 /* CAMERA controls */
602 /* Keep the order of the 'case's the same as in videodev2.h! */
603 case V4L2_CID_CAMERA_CLASS: return "Camera Controls";
604 case V4L2_CID_EXPOSURE_AUTO: return "Auto Exposure";
605 case V4L2_CID_EXPOSURE_ABSOLUTE: return "Exposure Time, Absolute";
606 case V4L2_CID_EXPOSURE_AUTO_PRIORITY: return "Exposure, Dynamic Framerate";
607 case V4L2_CID_PAN_RELATIVE: return "Pan, Relative";
608 case V4L2_CID_TILT_RELATIVE: return "Tilt, Relative";
609 case V4L2_CID_PAN_RESET: return "Pan, Reset";
610 case V4L2_CID_TILT_RESET: return "Tilt, Reset";
611 case V4L2_CID_PAN_ABSOLUTE: return "Pan, Absolute";
612 case V4L2_CID_TILT_ABSOLUTE: return "Tilt, Absolute";
613 case V4L2_CID_FOCUS_ABSOLUTE: return "Focus, Absolute";
614 case V4L2_CID_FOCUS_RELATIVE: return "Focus, Relative";
615 case V4L2_CID_FOCUS_AUTO: return "Focus, Automatic";
616 case V4L2_CID_ZOOM_ABSOLUTE: return "Zoom, Absolute";
617 case V4L2_CID_ZOOM_RELATIVE: return "Zoom, Relative";
618 case V4L2_CID_ZOOM_CONTINUOUS: return "Zoom, Continuous";
619 case V4L2_CID_PRIVACY: return "Privacy";
620 case V4L2_CID_IRIS_ABSOLUTE: return "Iris, Absolute";
621 case V4L2_CID_IRIS_RELATIVE: return "Iris, Relative";
622 case V4L2_CID_AUTO_EXPOSURE_BIAS: return "Auto Exposure, Bias";
623 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset";
624 case V4L2_CID_WIDE_DYNAMIC_RANGE: return "Wide Dynamic Range";
626 /* FM Radio Modulator control */
627 /* Keep the order of the 'case's the same as in videodev2.h! */
628 case V4L2_CID_FM_TX_CLASS: return "FM Radio Modulator Controls";
629 case V4L2_CID_RDS_TX_DEVIATION: return "RDS Signal Deviation";
630 case V4L2_CID_RDS_TX_PI: return "RDS Program ID";
631 case V4L2_CID_RDS_TX_PTY: return "RDS Program Type";
632 case V4L2_CID_RDS_TX_PS_NAME: return "RDS PS Name";
633 case V4L2_CID_RDS_TX_RADIO_TEXT: return "RDS Radio Text";
634 case V4L2_CID_AUDIO_LIMITER_ENABLED: return "Audio Limiter Feature Enabled";
635 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
636 case V4L2_CID_AUDIO_LIMITER_DEVIATION: return "Audio Limiter Deviation";
637 case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled";
638 case V4L2_CID_AUDIO_COMPRESSION_GAIN: return "Audio Compression Gain";
639 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
640 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
641 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
642 case V4L2_CID_PILOT_TONE_ENABLED: return "Pilot Tone Feature Enabled";
643 case V4L2_CID_PILOT_TONE_DEVIATION: return "Pilot Tone Deviation";
644 case V4L2_CID_PILOT_TONE_FREQUENCY: return "Pilot Tone Frequency";
645 case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-Emphasis";
646 case V4L2_CID_TUNE_POWER_LEVEL: return "Tune Power Level";
647 case V4L2_CID_TUNE_ANTENNA_CAPACITOR: return "Tune Antenna Capacitor";
650 case V4L2_CID_FLASH_CLASS: return "Flash Controls";
651 case V4L2_CID_FLASH_LED_MODE: return "LED Mode";
652 case V4L2_CID_FLASH_STROBE_SOURCE: return "Strobe Source";
653 case V4L2_CID_FLASH_STROBE: return "Strobe";
654 case V4L2_CID_FLASH_STROBE_STOP: return "Stop Strobe";
655 case V4L2_CID_FLASH_STROBE_STATUS: return "Strobe Status";
656 case V4L2_CID_FLASH_TIMEOUT: return "Strobe Timeout";
657 case V4L2_CID_FLASH_INTENSITY: return "Intensity, Flash Mode";
658 case V4L2_CID_FLASH_TORCH_INTENSITY: return "Intensity, Torch Mode";
659 case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator";
660 case V4L2_CID_FLASH_FAULT: return "Faults";
661 case V4L2_CID_FLASH_CHARGE: return "Charge";
662 case V4L2_CID_FLASH_READY: return "Ready to Strobe";
664 /* JPEG encoder controls */
665 /* Keep the order of the 'case's the same as in videodev2.h! */
666 case V4L2_CID_JPEG_CLASS: return "JPEG Compression Controls";
667 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: return "Chroma Subsampling";
668 case V4L2_CID_JPEG_RESTART_INTERVAL: return "Restart Interval";
669 case V4L2_CID_JPEG_COMPRESSION_QUALITY: return "Compression Quality";
670 case V4L2_CID_JPEG_ACTIVE_MARKER: return "Active Markers";
672 /* Image source controls */
673 case V4L2_CID_IMAGE_SOURCE_CLASS: return "Image Source Controls";
674 case V4L2_CID_VBLANK: return "Vertical Blanking";
675 case V4L2_CID_HBLANK: return "Horizontal Blanking";
676 case V4L2_CID_ANALOGUE_GAIN: return "Analogue Gain";
678 /* Image processing controls */
679 case V4L2_CID_IMAGE_PROC_CLASS: return "Image Processing Controls";
680 case V4L2_CID_LINK_FREQ: return "Link Frequency";
681 case V4L2_CID_PIXEL_RATE: return "Pixel Rate";
687 EXPORT_SYMBOL(v4l2_ctrl_get_name);
689 void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
690 s32 *min, s32 *max, s32 *step, s32 *def, u32 *flags)
692 *name = v4l2_ctrl_get_name(id);
696 case V4L2_CID_AUDIO_MUTE:
697 case V4L2_CID_AUDIO_LOUDNESS:
698 case V4L2_CID_AUTO_WHITE_BALANCE:
699 case V4L2_CID_AUTOGAIN:
702 case V4L2_CID_HUE_AUTO:
703 case V4L2_CID_CHROMA_AGC:
704 case V4L2_CID_COLOR_KILLER:
705 case V4L2_CID_MPEG_AUDIO_MUTE:
706 case V4L2_CID_MPEG_VIDEO_MUTE:
707 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
708 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
709 case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
710 case V4L2_CID_FOCUS_AUTO:
711 case V4L2_CID_PRIVACY:
712 case V4L2_CID_AUDIO_LIMITER_ENABLED:
713 case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
714 case V4L2_CID_PILOT_TONE_ENABLED:
715 case V4L2_CID_ILLUMINATORS_1:
716 case V4L2_CID_ILLUMINATORS_2:
717 case V4L2_CID_FLASH_STROBE_STATUS:
718 case V4L2_CID_FLASH_CHARGE:
719 case V4L2_CID_FLASH_READY:
720 case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER:
721 case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE:
722 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
723 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
724 case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
725 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
726 case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
727 case V4L2_CID_WIDE_DYNAMIC_RANGE:
728 *type = V4L2_CTRL_TYPE_BOOLEAN;
732 case V4L2_CID_PAN_RESET:
733 case V4L2_CID_TILT_RESET:
734 case V4L2_CID_FLASH_STROBE:
735 case V4L2_CID_FLASH_STROBE_STOP:
736 *type = V4L2_CTRL_TYPE_BUTTON;
737 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
738 *min = *max = *step = *def = 0;
740 case V4L2_CID_POWER_LINE_FREQUENCY:
741 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
742 case V4L2_CID_MPEG_AUDIO_ENCODING:
743 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
744 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
745 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
746 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
747 case V4L2_CID_MPEG_AUDIO_MODE:
748 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
749 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
750 case V4L2_CID_MPEG_AUDIO_CRC:
751 case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK:
752 case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK:
753 case V4L2_CID_MPEG_VIDEO_ENCODING:
754 case V4L2_CID_MPEG_VIDEO_ASPECT:
755 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
756 case V4L2_CID_MPEG_STREAM_TYPE:
757 case V4L2_CID_MPEG_STREAM_VBI_FMT:
758 case V4L2_CID_EXPOSURE_AUTO:
759 case V4L2_CID_COLORFX:
760 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
761 case V4L2_CID_TUNE_PREEMPHASIS:
762 case V4L2_CID_FLASH_LED_MODE:
763 case V4L2_CID_FLASH_STROBE_SOURCE:
764 case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
765 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
766 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
767 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
768 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
769 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
770 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
771 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
772 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
773 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
774 *type = V4L2_CTRL_TYPE_MENU;
776 case V4L2_CID_LINK_FREQ:
777 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
779 case V4L2_CID_RDS_TX_PS_NAME:
780 case V4L2_CID_RDS_TX_RADIO_TEXT:
781 *type = V4L2_CTRL_TYPE_STRING;
783 case V4L2_CID_AUTO_EXPOSURE_BIAS:
784 *type = V4L2_CTRL_TYPE_INTEGER_MENU;
786 case V4L2_CID_USER_CLASS:
787 case V4L2_CID_CAMERA_CLASS:
788 case V4L2_CID_MPEG_CLASS:
789 case V4L2_CID_FM_TX_CLASS:
790 case V4L2_CID_FLASH_CLASS:
791 case V4L2_CID_JPEG_CLASS:
792 case V4L2_CID_IMAGE_SOURCE_CLASS:
793 case V4L2_CID_IMAGE_PROC_CLASS:
794 *type = V4L2_CTRL_TYPE_CTRL_CLASS;
795 /* You can neither read not write these */
796 *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY;
797 *min = *max = *step = *def = 0;
799 case V4L2_CID_BG_COLOR:
800 *type = V4L2_CTRL_TYPE_INTEGER;
803 /* Max is calculated as RGB888 that is 2^24 */
806 case V4L2_CID_FLASH_FAULT:
807 case V4L2_CID_JPEG_ACTIVE_MARKER:
808 *type = V4L2_CTRL_TYPE_BITMASK;
810 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
811 case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
812 *type = V4L2_CTRL_TYPE_INTEGER;
813 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
815 case V4L2_CID_MPEG_VIDEO_DEC_FRAME:
816 case V4L2_CID_MPEG_VIDEO_DEC_PTS:
817 *flags |= V4L2_CTRL_FLAG_VOLATILE;
819 case V4L2_CID_PIXEL_RATE:
820 *type = V4L2_CTRL_TYPE_INTEGER64;
821 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
822 *min = *max = *step = *def = 0;
825 *type = V4L2_CTRL_TYPE_INTEGER;
829 case V4L2_CID_MPEG_AUDIO_ENCODING:
830 case V4L2_CID_MPEG_AUDIO_MODE:
831 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
832 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
833 case V4L2_CID_MPEG_STREAM_TYPE:
834 *flags |= V4L2_CTRL_FLAG_UPDATE;
836 case V4L2_CID_AUDIO_VOLUME:
837 case V4L2_CID_AUDIO_BALANCE:
838 case V4L2_CID_AUDIO_BASS:
839 case V4L2_CID_AUDIO_TREBLE:
840 case V4L2_CID_BRIGHTNESS:
841 case V4L2_CID_CONTRAST:
842 case V4L2_CID_SATURATION:
844 case V4L2_CID_RED_BALANCE:
845 case V4L2_CID_BLUE_BALANCE:
847 case V4L2_CID_SHARPNESS:
848 case V4L2_CID_CHROMA_GAIN:
849 case V4L2_CID_RDS_TX_DEVIATION:
850 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
851 case V4L2_CID_AUDIO_LIMITER_DEVIATION:
852 case V4L2_CID_AUDIO_COMPRESSION_GAIN:
853 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
854 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
855 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
856 case V4L2_CID_PILOT_TONE_DEVIATION:
857 case V4L2_CID_PILOT_TONE_FREQUENCY:
858 case V4L2_CID_TUNE_POWER_LEVEL:
859 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
860 *flags |= V4L2_CTRL_FLAG_SLIDER;
862 case V4L2_CID_PAN_RELATIVE:
863 case V4L2_CID_TILT_RELATIVE:
864 case V4L2_CID_FOCUS_RELATIVE:
865 case V4L2_CID_IRIS_RELATIVE:
866 case V4L2_CID_ZOOM_RELATIVE:
867 *flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
869 case V4L2_CID_FLASH_STROBE_STATUS:
870 case V4L2_CID_FLASH_READY:
871 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
875 EXPORT_SYMBOL(v4l2_ctrl_fill);
877 /* Helper function to determine whether the control type is compatible with
879 static bool type_is_int(const struct v4l2_ctrl *ctrl)
881 switch (ctrl->type) {
882 case V4L2_CTRL_TYPE_INTEGER64:
883 case V4L2_CTRL_TYPE_STRING:
884 /* Nope, these need v4l2_ext_control */
891 static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes)
893 memset(ev->reserved, 0, sizeof(ev->reserved));
894 ev->type = V4L2_EVENT_CTRL;
896 ev->u.ctrl.changes = changes;
897 ev->u.ctrl.type = ctrl->type;
898 ev->u.ctrl.flags = ctrl->flags;
899 if (ctrl->type == V4L2_CTRL_TYPE_STRING)
900 ev->u.ctrl.value64 = 0;
902 ev->u.ctrl.value64 = ctrl->cur.val64;
903 ev->u.ctrl.minimum = ctrl->minimum;
904 ev->u.ctrl.maximum = ctrl->maximum;
905 if (ctrl->type == V4L2_CTRL_TYPE_MENU
906 || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
909 ev->u.ctrl.step = ctrl->step;
910 ev->u.ctrl.default_value = ctrl->default_value;
913 static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes)
915 struct v4l2_event ev;
916 struct v4l2_subscribed_event *sev;
918 if (list_empty(&ctrl->ev_subs))
920 fill_event(&ev, ctrl, changes);
922 list_for_each_entry(sev, &ctrl->ev_subs, node)
924 (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK))
925 v4l2_event_queue_fh(sev->fh, &ev);
928 /* Helper function: copy the current control value back to the caller */
929 static int cur_to_user(struct v4l2_ext_control *c,
930 struct v4l2_ctrl *ctrl)
934 switch (ctrl->type) {
935 case V4L2_CTRL_TYPE_STRING:
936 len = strlen(ctrl->cur.string);
937 if (c->size < len + 1) {
941 return copy_to_user(c->string, ctrl->cur.string,
942 len + 1) ? -EFAULT : 0;
943 case V4L2_CTRL_TYPE_INTEGER64:
944 c->value64 = ctrl->cur.val64;
947 c->value = ctrl->cur.val;
953 /* Helper function: copy the caller-provider value as the new control value */
954 static int user_to_new(struct v4l2_ext_control *c,
955 struct v4l2_ctrl *ctrl)
961 switch (ctrl->type) {
962 case V4L2_CTRL_TYPE_INTEGER64:
963 ctrl->val64 = c->value64;
965 case V4L2_CTRL_TYPE_STRING:
969 if (size > ctrl->maximum + 1)
970 size = ctrl->maximum + 1;
971 ret = copy_from_user(ctrl->string, c->string, size);
973 char last = ctrl->string[size - 1];
975 ctrl->string[size - 1] = 0;
976 /* If the string was longer than ctrl->maximum,
977 then return an error. */
978 if (strlen(ctrl->string) == ctrl->maximum && last)
981 return ret ? -EFAULT : 0;
983 ctrl->val = c->value;
989 /* Helper function: copy the new control value back to the caller */
990 static int new_to_user(struct v4l2_ext_control *c,
991 struct v4l2_ctrl *ctrl)
995 switch (ctrl->type) {
996 case V4L2_CTRL_TYPE_STRING:
997 len = strlen(ctrl->string);
998 if (c->size < len + 1) {
999 c->size = ctrl->maximum + 1;
1002 return copy_to_user(c->string, ctrl->string,
1003 len + 1) ? -EFAULT : 0;
1004 case V4L2_CTRL_TYPE_INTEGER64:
1005 c->value64 = ctrl->val64;
1008 c->value = ctrl->val;
1014 /* Copy the new value to the current value. */
1015 static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
1016 bool update_inactive)
1018 bool changed = false;
1022 switch (ctrl->type) {
1023 case V4L2_CTRL_TYPE_BUTTON:
1026 case V4L2_CTRL_TYPE_STRING:
1027 /* strings are always 0-terminated */
1028 changed = strcmp(ctrl->string, ctrl->cur.string);
1029 strcpy(ctrl->cur.string, ctrl->string);
1031 case V4L2_CTRL_TYPE_INTEGER64:
1032 changed = ctrl->val64 != ctrl->cur.val64;
1033 ctrl->cur.val64 = ctrl->val64;
1036 changed = ctrl->val != ctrl->cur.val;
1037 ctrl->cur.val = ctrl->val;
1040 if (update_inactive) {
1041 /* Note: update_inactive can only be true for auto clusters. */
1043 ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
1044 if (!is_cur_manual(ctrl->cluster[0])) {
1045 ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1046 if (ctrl->cluster[0]->has_volatiles)
1047 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
1051 if (changed || update_inactive) {
1052 /* If a control was changed that was not one of the controls
1053 modified by the application, then send the event to all. */
1056 send_event(fh, ctrl,
1057 (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) |
1058 (update_inactive ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
1062 /* Copy the current value to the new value */
1063 static void cur_to_new(struct v4l2_ctrl *ctrl)
1067 switch (ctrl->type) {
1068 case V4L2_CTRL_TYPE_STRING:
1069 /* strings are always 0-terminated */
1070 strcpy(ctrl->string, ctrl->cur.string);
1072 case V4L2_CTRL_TYPE_INTEGER64:
1073 ctrl->val64 = ctrl->cur.val64;
1076 ctrl->val = ctrl->cur.val;
1081 /* Return non-zero if one or more of the controls in the cluster has a new
1082 value that differs from the current value. */
1083 static int cluster_changed(struct v4l2_ctrl *master)
1088 for (i = 0; !diff && i < master->ncontrols; i++) {
1089 struct v4l2_ctrl *ctrl = master->cluster[i];
1093 switch (ctrl->type) {
1094 case V4L2_CTRL_TYPE_BUTTON:
1095 /* Button controls are always 'different' */
1097 case V4L2_CTRL_TYPE_STRING:
1098 /* strings are always 0-terminated */
1099 diff = strcmp(ctrl->string, ctrl->cur.string);
1101 case V4L2_CTRL_TYPE_INTEGER64:
1102 diff = ctrl->val64 != ctrl->cur.val64;
1105 diff = ctrl->val != ctrl->cur.val;
1112 /* Validate integer-type control */
1113 static int validate_new_int(const struct v4l2_ctrl *ctrl, s32 *pval)
1118 switch (ctrl->type) {
1119 case V4L2_CTRL_TYPE_INTEGER:
1120 /* Round towards the closest legal value */
1121 val += ctrl->step / 2;
1122 if (val < ctrl->minimum)
1123 val = ctrl->minimum;
1124 if (val > ctrl->maximum)
1125 val = ctrl->maximum;
1126 offset = val - ctrl->minimum;
1127 offset = ctrl->step * (offset / ctrl->step);
1128 val = ctrl->minimum + offset;
1132 case V4L2_CTRL_TYPE_BOOLEAN:
1136 case V4L2_CTRL_TYPE_MENU:
1137 case V4L2_CTRL_TYPE_INTEGER_MENU:
1138 if (val < ctrl->minimum || val > ctrl->maximum)
1140 if (ctrl->menu_skip_mask & (1 << val))
1142 if (ctrl->type == V4L2_CTRL_TYPE_MENU &&
1143 ctrl->qmenu[val][0] == '\0')
1147 case V4L2_CTRL_TYPE_BITMASK:
1148 *pval &= ctrl->maximum;
1151 case V4L2_CTRL_TYPE_BUTTON:
1152 case V4L2_CTRL_TYPE_CTRL_CLASS:
1161 /* Validate a new control */
1162 static int validate_new(const struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
1164 char *s = c->string;
1167 switch (ctrl->type) {
1168 case V4L2_CTRL_TYPE_INTEGER:
1169 case V4L2_CTRL_TYPE_BOOLEAN:
1170 case V4L2_CTRL_TYPE_MENU:
1171 case V4L2_CTRL_TYPE_INTEGER_MENU:
1172 case V4L2_CTRL_TYPE_BITMASK:
1173 case V4L2_CTRL_TYPE_BUTTON:
1174 case V4L2_CTRL_TYPE_CTRL_CLASS:
1175 return validate_new_int(ctrl, &c->value);
1177 case V4L2_CTRL_TYPE_INTEGER64:
1180 case V4L2_CTRL_TYPE_STRING:
1182 if (len < ctrl->minimum)
1184 if ((len - ctrl->minimum) % ctrl->step)
1193 static inline u32 node2id(struct list_head *node)
1195 return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id;
1198 /* Set the handler's error code if it wasn't set earlier already */
1199 static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err)
1201 if (hdl->error == 0)
1206 /* Initialize the handler */
1207 int v4l2_ctrl_handler_init(struct v4l2_ctrl_handler *hdl,
1208 unsigned nr_of_controls_hint)
1210 hdl->lock = &hdl->_lock;
1211 mutex_init(hdl->lock);
1212 INIT_LIST_HEAD(&hdl->ctrls);
1213 INIT_LIST_HEAD(&hdl->ctrl_refs);
1214 hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
1215 hdl->buckets = kcalloc(hdl->nr_of_buckets, sizeof(hdl->buckets[0]),
1217 hdl->error = hdl->buckets ? 0 : -ENOMEM;
1220 EXPORT_SYMBOL(v4l2_ctrl_handler_init);
1222 /* Free all controls and control refs */
1223 void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl)
1225 struct v4l2_ctrl_ref *ref, *next_ref;
1226 struct v4l2_ctrl *ctrl, *next_ctrl;
1227 struct v4l2_subscribed_event *sev, *next_sev;
1229 if (hdl == NULL || hdl->buckets == NULL)
1232 mutex_lock(hdl->lock);
1233 /* Free all nodes */
1234 list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {
1235 list_del(&ref->node);
1238 /* Free all controls owned by the handler */
1239 list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) {
1240 list_del(&ctrl->node);
1241 list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node)
1242 list_del(&sev->node);
1245 kfree(hdl->buckets);
1246 hdl->buckets = NULL;
1249 mutex_unlock(hdl->lock);
1251 EXPORT_SYMBOL(v4l2_ctrl_handler_free);
1253 /* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer
1254 be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing
1255 with applications that do not use the NEXT_CTRL flag.
1257 We just find the n-th private user control. It's O(N), but that should not
1258 be an issue in this particular case. */
1259 static struct v4l2_ctrl_ref *find_private_ref(
1260 struct v4l2_ctrl_handler *hdl, u32 id)
1262 struct v4l2_ctrl_ref *ref;
1264 id -= V4L2_CID_PRIVATE_BASE;
1265 list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1266 /* Search for private user controls that are compatible with
1268 if (V4L2_CTRL_ID2CLASS(ref->ctrl->id) == V4L2_CTRL_CLASS_USER &&
1269 V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) {
1270 if (!type_is_int(ref->ctrl))
1280 /* Find a control with the given ID. */
1281 static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id)
1283 struct v4l2_ctrl_ref *ref;
1286 id &= V4L2_CTRL_ID_MASK;
1288 /* Old-style private controls need special handling */
1289 if (id >= V4L2_CID_PRIVATE_BASE)
1290 return find_private_ref(hdl, id);
1291 bucket = id % hdl->nr_of_buckets;
1293 /* Simple optimization: cache the last control found */
1294 if (hdl->cached && hdl->cached->ctrl->id == id)
1297 /* Not in cache, search the hash */
1298 ref = hdl->buckets ? hdl->buckets[bucket] : NULL;
1299 while (ref && ref->ctrl->id != id)
1303 hdl->cached = ref; /* cache it! */
1307 /* Find a control with the given ID. Take the handler's lock first. */
1308 static struct v4l2_ctrl_ref *find_ref_lock(
1309 struct v4l2_ctrl_handler *hdl, u32 id)
1311 struct v4l2_ctrl_ref *ref = NULL;
1314 mutex_lock(hdl->lock);
1315 ref = find_ref(hdl, id);
1316 mutex_unlock(hdl->lock);
1321 /* Find a control with the given ID. */
1322 struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
1324 struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
1326 return ref ? ref->ctrl : NULL;
1328 EXPORT_SYMBOL(v4l2_ctrl_find);
1330 /* Allocate a new v4l2_ctrl_ref and hook it into the handler. */
1331 static int handler_new_ref(struct v4l2_ctrl_handler *hdl,
1332 struct v4l2_ctrl *ctrl)
1334 struct v4l2_ctrl_ref *ref;
1335 struct v4l2_ctrl_ref *new_ref;
1337 u32 class_ctrl = V4L2_CTRL_ID2CLASS(id) | 1;
1338 int bucket = id % hdl->nr_of_buckets; /* which bucket to use */
1340 /* Automatically add the control class if it is not yet present. */
1341 if (id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL)
1342 if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0))
1348 new_ref = kzalloc(sizeof(*new_ref), GFP_KERNEL);
1350 return handler_set_err(hdl, -ENOMEM);
1351 new_ref->ctrl = ctrl;
1352 if (ctrl->handler == hdl) {
1353 /* By default each control starts in a cluster of its own.
1354 new_ref->ctrl is basically a cluster array with one
1355 element, so that's perfect to use as the cluster pointer.
1356 But only do this for the handler that owns the control. */
1357 ctrl->cluster = &new_ref->ctrl;
1358 ctrl->ncontrols = 1;
1361 INIT_LIST_HEAD(&new_ref->node);
1363 mutex_lock(hdl->lock);
1365 /* Add immediately at the end of the list if the list is empty, or if
1366 the last element in the list has a lower ID.
1367 This ensures that when elements are added in ascending order the
1368 insertion is an O(1) operation. */
1369 if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) {
1370 list_add_tail(&new_ref->node, &hdl->ctrl_refs);
1371 goto insert_in_hash;
1374 /* Find insert position in sorted list */
1375 list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1376 if (ref->ctrl->id < id)
1378 /* Don't add duplicates */
1379 if (ref->ctrl->id == id) {
1383 list_add(&new_ref->node, ref->node.prev);
1388 /* Insert the control node in the hash */
1389 new_ref->next = hdl->buckets[bucket];
1390 hdl->buckets[bucket] = new_ref;
1393 mutex_unlock(hdl->lock);
1397 /* Add a new control */
1398 static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
1399 const struct v4l2_ctrl_ops *ops,
1400 u32 id, const char *name, enum v4l2_ctrl_type type,
1401 s32 min, s32 max, u32 step, s32 def,
1402 u32 flags, const char * const *qmenu,
1403 const s64 *qmenu_int, void *priv)
1405 struct v4l2_ctrl *ctrl;
1406 unsigned sz_extra = 0;
1412 if (id == 0 || name == NULL || id >= V4L2_CID_PRIVATE_BASE ||
1413 (type == V4L2_CTRL_TYPE_INTEGER && step == 0) ||
1414 (type == V4L2_CTRL_TYPE_BITMASK && max == 0) ||
1415 (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
1416 (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL) ||
1417 (type == V4L2_CTRL_TYPE_STRING && max == 0)) {
1418 handler_set_err(hdl, -ERANGE);
1421 if (type != V4L2_CTRL_TYPE_BITMASK && max < min) {
1422 handler_set_err(hdl, -ERANGE);
1425 if ((type == V4L2_CTRL_TYPE_INTEGER ||
1426 type == V4L2_CTRL_TYPE_MENU ||
1427 type == V4L2_CTRL_TYPE_INTEGER_MENU ||
1428 type == V4L2_CTRL_TYPE_BOOLEAN) &&
1429 (def < min || def > max)) {
1430 handler_set_err(hdl, -ERANGE);
1433 if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
1434 handler_set_err(hdl, -ERANGE);
1438 if (type == V4L2_CTRL_TYPE_BUTTON)
1439 flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
1440 else if (type == V4L2_CTRL_TYPE_CTRL_CLASS)
1441 flags |= V4L2_CTRL_FLAG_READ_ONLY;
1442 else if (type == V4L2_CTRL_TYPE_STRING)
1443 sz_extra += 2 * (max + 1);
1445 ctrl = kzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL);
1447 handler_set_err(hdl, -ENOMEM);
1451 INIT_LIST_HEAD(&ctrl->node);
1452 INIT_LIST_HEAD(&ctrl->ev_subs);
1453 ctrl->handler = hdl;
1458 ctrl->flags = flags;
1459 ctrl->minimum = min;
1460 ctrl->maximum = max;
1462 if (type == V4L2_CTRL_TYPE_MENU)
1463 ctrl->qmenu = qmenu;
1464 else if (type == V4L2_CTRL_TYPE_INTEGER_MENU)
1465 ctrl->qmenu_int = qmenu_int;
1467 ctrl->cur.val = ctrl->val = ctrl->default_value = def;
1469 if (ctrl->type == V4L2_CTRL_TYPE_STRING) {
1470 ctrl->cur.string = (char *)&ctrl[1] + sz_extra - (max + 1);
1471 ctrl->string = (char *)&ctrl[1] + sz_extra - 2 * (max + 1);
1473 memset(ctrl->cur.string, ' ', ctrl->minimum);
1475 if (handler_new_ref(hdl, ctrl)) {
1479 mutex_lock(hdl->lock);
1480 list_add_tail(&ctrl->node, &hdl->ctrls);
1481 mutex_unlock(hdl->lock);
1485 struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
1486 const struct v4l2_ctrl_config *cfg, void *priv)
1489 struct v4l2_ctrl *ctrl;
1490 const char *name = cfg->name;
1491 const char * const *qmenu = cfg->qmenu;
1492 const s64 *qmenu_int = cfg->qmenu_int;
1493 enum v4l2_ctrl_type type = cfg->type;
1494 u32 flags = cfg->flags;
1497 u32 step = cfg->step;
1501 v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step,
1504 is_menu = (cfg->type == V4L2_CTRL_TYPE_MENU ||
1505 cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU);
1509 WARN_ON(cfg->menu_skip_mask);
1510 if (cfg->type == V4L2_CTRL_TYPE_MENU && qmenu == NULL)
1511 qmenu = v4l2_ctrl_get_menu(cfg->id);
1512 else if (cfg->type == V4L2_CTRL_TYPE_INTEGER_MENU &&
1513 qmenu_int == NULL) {
1514 handler_set_err(hdl, -EINVAL);
1518 ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->id, name,
1520 is_menu ? cfg->menu_skip_mask : step,
1521 def, flags, qmenu, qmenu_int, priv);
1523 ctrl->is_private = cfg->is_private;
1526 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
1528 /* Helper function for standard non-menu controls */
1529 struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
1530 const struct v4l2_ctrl_ops *ops,
1531 u32 id, s32 min, s32 max, u32 step, s32 def)
1534 enum v4l2_ctrl_type type;
1537 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1538 if (type == V4L2_CTRL_TYPE_MENU
1539 || type == V4L2_CTRL_TYPE_INTEGER_MENU) {
1540 handler_set_err(hdl, -EINVAL);
1543 return v4l2_ctrl_new(hdl, ops, id, name, type,
1544 min, max, step, def, flags, NULL, NULL, NULL);
1546 EXPORT_SYMBOL(v4l2_ctrl_new_std);
1548 /* Helper function for standard menu controls */
1549 struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
1550 const struct v4l2_ctrl_ops *ops,
1551 u32 id, s32 max, s32 mask, s32 def)
1553 const char * const *qmenu = v4l2_ctrl_get_menu(id);
1555 enum v4l2_ctrl_type type;
1560 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1561 if (type != V4L2_CTRL_TYPE_MENU) {
1562 handler_set_err(hdl, -EINVAL);
1565 return v4l2_ctrl_new(hdl, ops, id, name, type,
1566 0, max, mask, def, flags, qmenu, NULL, NULL);
1568 EXPORT_SYMBOL(v4l2_ctrl_new_std_menu);
1570 /* Helper function for standard integer menu controls */
1571 struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
1572 const struct v4l2_ctrl_ops *ops,
1573 u32 id, s32 max, s32 def, const s64 *qmenu_int)
1576 enum v4l2_ctrl_type type;
1581 v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags);
1582 if (type != V4L2_CTRL_TYPE_INTEGER_MENU) {
1583 handler_set_err(hdl, -EINVAL);
1586 return v4l2_ctrl_new(hdl, ops, id, name, type,
1587 0, max, 0, def, flags, NULL, qmenu_int, NULL);
1589 EXPORT_SYMBOL(v4l2_ctrl_new_int_menu);
1591 /* Add a control from another handler to this handler */
1592 struct v4l2_ctrl *v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler *hdl,
1593 struct v4l2_ctrl *ctrl)
1595 if (hdl == NULL || hdl->error)
1598 handler_set_err(hdl, -EINVAL);
1601 if (ctrl->handler == hdl)
1603 return handler_new_ref(hdl, ctrl) ? NULL : ctrl;
1605 EXPORT_SYMBOL(v4l2_ctrl_add_ctrl);
1607 /* Add the controls from another handler to our own. */
1608 int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
1609 struct v4l2_ctrl_handler *add)
1611 struct v4l2_ctrl_ref *ref;
1614 /* Do nothing if either handler is NULL or if they are the same */
1615 if (!hdl || !add || hdl == add)
1619 mutex_lock(add->lock);
1620 list_for_each_entry(ref, &add->ctrl_refs, node) {
1621 struct v4l2_ctrl *ctrl = ref->ctrl;
1623 /* Skip handler-private controls. */
1624 if (ctrl->is_private)
1626 /* And control classes */
1627 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1629 ret = handler_new_ref(hdl, ctrl);
1633 mutex_unlock(add->lock);
1636 EXPORT_SYMBOL(v4l2_ctrl_add_handler);
1638 /* Cluster controls */
1639 void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls)
1641 bool has_volatiles = false;
1644 /* The first control is the master control and it must not be NULL */
1645 BUG_ON(ncontrols == 0 || controls[0] == NULL);
1647 for (i = 0; i < ncontrols; i++) {
1649 controls[i]->cluster = controls;
1650 controls[i]->ncontrols = ncontrols;
1651 if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE)
1652 has_volatiles = true;
1655 controls[0]->has_volatiles = has_volatiles;
1657 EXPORT_SYMBOL(v4l2_ctrl_cluster);
1659 void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
1660 u8 manual_val, bool set_volatile)
1662 struct v4l2_ctrl *master = controls[0];
1666 v4l2_ctrl_cluster(ncontrols, controls);
1667 WARN_ON(ncontrols <= 1);
1668 WARN_ON(manual_val < master->minimum || manual_val > master->maximum);
1669 WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl));
1670 master->is_auto = true;
1671 master->has_volatiles = set_volatile;
1672 master->manual_mode_value = manual_val;
1673 master->flags |= V4L2_CTRL_FLAG_UPDATE;
1675 if (!is_cur_manual(master))
1676 flag = V4L2_CTRL_FLAG_INACTIVE |
1677 (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0);
1679 for (i = 1; i < ncontrols; i++)
1681 controls[i]->flags |= flag;
1683 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
1685 /* Activate/deactivate a control. */
1686 void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active)
1688 /* invert since the actual flag is called 'inactive' */
1689 bool inactive = !active;
1696 /* set V4L2_CTRL_FLAG_INACTIVE */
1697 old = test_and_set_bit(4, &ctrl->flags);
1699 /* clear V4L2_CTRL_FLAG_INACTIVE */
1700 old = test_and_clear_bit(4, &ctrl->flags);
1701 if (old != inactive)
1702 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1704 EXPORT_SYMBOL(v4l2_ctrl_activate);
1706 /* Grab/ungrab a control.
1707 Typically used when streaming starts and you want to grab controls,
1708 preventing the user from changing them.
1710 Just call this and the framework will block any attempts to change
1712 void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed)
1719 v4l2_ctrl_lock(ctrl);
1721 /* set V4L2_CTRL_FLAG_GRABBED */
1722 old = test_and_set_bit(1, &ctrl->flags);
1724 /* clear V4L2_CTRL_FLAG_GRABBED */
1725 old = test_and_clear_bit(1, &ctrl->flags);
1727 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS);
1728 v4l2_ctrl_unlock(ctrl);
1730 EXPORT_SYMBOL(v4l2_ctrl_grab);
1732 /* Log the control name and value */
1733 static void log_ctrl(const struct v4l2_ctrl *ctrl,
1734 const char *prefix, const char *colon)
1736 if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
1738 if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1741 printk(KERN_INFO "%s%s%s: ", prefix, colon, ctrl->name);
1743 switch (ctrl->type) {
1744 case V4L2_CTRL_TYPE_INTEGER:
1745 printk(KERN_CONT "%d", ctrl->cur.val);
1747 case V4L2_CTRL_TYPE_BOOLEAN:
1748 printk(KERN_CONT "%s", ctrl->cur.val ? "true" : "false");
1750 case V4L2_CTRL_TYPE_MENU:
1751 printk(KERN_CONT "%s", ctrl->qmenu[ctrl->cur.val]);
1753 case V4L2_CTRL_TYPE_INTEGER_MENU:
1754 printk(KERN_CONT "%lld", ctrl->qmenu_int[ctrl->cur.val]);
1756 case V4L2_CTRL_TYPE_BITMASK:
1757 printk(KERN_CONT "0x%08x", ctrl->cur.val);
1759 case V4L2_CTRL_TYPE_INTEGER64:
1760 printk(KERN_CONT "%lld", ctrl->cur.val64);
1762 case V4L2_CTRL_TYPE_STRING:
1763 printk(KERN_CONT "%s", ctrl->cur.string);
1766 printk(KERN_CONT "unknown type %d", ctrl->type);
1769 if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
1770 V4L2_CTRL_FLAG_GRABBED |
1771 V4L2_CTRL_FLAG_VOLATILE)) {
1772 if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
1773 printk(KERN_CONT " inactive");
1774 if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
1775 printk(KERN_CONT " grabbed");
1776 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
1777 printk(KERN_CONT " volatile");
1779 printk(KERN_CONT "\n");
1782 /* Log all controls owned by the handler */
1783 void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
1786 struct v4l2_ctrl *ctrl;
1787 const char *colon = "";
1794 len = strlen(prefix);
1795 if (len && prefix[len - 1] != ' ')
1797 mutex_lock(hdl->lock);
1798 list_for_each_entry(ctrl, &hdl->ctrls, node)
1799 if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED))
1800 log_ctrl(ctrl, prefix, colon);
1801 mutex_unlock(hdl->lock);
1803 EXPORT_SYMBOL(v4l2_ctrl_handler_log_status);
1805 /* Call s_ctrl for all controls owned by the handler */
1806 int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl)
1808 struct v4l2_ctrl *ctrl;
1813 mutex_lock(hdl->lock);
1814 list_for_each_entry(ctrl, &hdl->ctrls, node)
1817 list_for_each_entry(ctrl, &hdl->ctrls, node) {
1818 struct v4l2_ctrl *master = ctrl->cluster[0];
1821 /* Skip if this control was already handled by a cluster. */
1822 /* Skip button controls and read-only controls. */
1823 if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||
1824 (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
1827 for (i = 0; i < master->ncontrols; i++) {
1828 if (master->cluster[i]) {
1829 cur_to_new(master->cluster[i]);
1830 master->cluster[i]->is_new = 1;
1831 master->cluster[i]->done = true;
1834 ret = call_op(master, s_ctrl);
1838 mutex_unlock(hdl->lock);
1841 EXPORT_SYMBOL(v4l2_ctrl_handler_setup);
1843 /* Implement VIDIOC_QUERYCTRL */
1844 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
1846 u32 id = qc->id & V4L2_CTRL_ID_MASK;
1847 struct v4l2_ctrl_ref *ref;
1848 struct v4l2_ctrl *ctrl;
1853 mutex_lock(hdl->lock);
1855 /* Try to find it */
1856 ref = find_ref(hdl, id);
1858 if ((qc->id & V4L2_CTRL_FLAG_NEXT_CTRL) && !list_empty(&hdl->ctrl_refs)) {
1859 /* Find the next control with ID > qc->id */
1861 /* Did we reach the end of the control list? */
1862 if (id >= node2id(hdl->ctrl_refs.prev)) {
1863 ref = NULL; /* Yes, so there is no next control */
1865 /* We found a control with the given ID, so just get
1866 the next one in the list. */
1867 ref = list_entry(ref->node.next, typeof(*ref), node);
1869 /* No control with the given ID exists, so start
1870 searching for the next largest ID. We know there
1871 is one, otherwise the first 'if' above would have
1873 list_for_each_entry(ref, &hdl->ctrl_refs, node)
1874 if (id < ref->ctrl->id)
1878 mutex_unlock(hdl->lock);
1883 memset(qc, 0, sizeof(*qc));
1884 if (id >= V4L2_CID_PRIVATE_BASE)
1888 strlcpy(qc->name, ctrl->name, sizeof(qc->name));
1889 qc->minimum = ctrl->minimum;
1890 qc->maximum = ctrl->maximum;
1891 qc->default_value = ctrl->default_value;
1892 if (ctrl->type == V4L2_CTRL_TYPE_MENU
1893 || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1896 qc->step = ctrl->step;
1897 qc->flags = ctrl->flags;
1898 qc->type = ctrl->type;
1901 EXPORT_SYMBOL(v4l2_queryctrl);
1903 int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1905 if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL)
1907 return v4l2_queryctrl(sd->ctrl_handler, qc);
1909 EXPORT_SYMBOL(v4l2_subdev_queryctrl);
1911 /* Implement VIDIOC_QUERYMENU */
1912 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
1914 struct v4l2_ctrl *ctrl;
1917 ctrl = v4l2_ctrl_find(hdl, qm->id);
1923 switch (ctrl->type) {
1924 case V4L2_CTRL_TYPE_MENU:
1925 if (ctrl->qmenu == NULL)
1928 case V4L2_CTRL_TYPE_INTEGER_MENU:
1929 if (ctrl->qmenu_int == NULL)
1936 if (i < ctrl->minimum || i > ctrl->maximum)
1939 /* Use mask to see if this menu item should be skipped */
1940 if (ctrl->menu_skip_mask & (1 << i))
1942 /* Empty menu items should also be skipped */
1943 if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
1944 if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0')
1946 strlcpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
1948 qm->value = ctrl->qmenu_int[i];
1952 EXPORT_SYMBOL(v4l2_querymenu);
1954 int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
1956 return v4l2_querymenu(sd->ctrl_handler, qm);
1958 EXPORT_SYMBOL(v4l2_subdev_querymenu);
1962 /* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
1964 It is not a fully atomic operation, just best-effort only. After all, if
1965 multiple controls have to be set through multiple i2c writes (for example)
1966 then some initial writes may succeed while others fail. Thus leaving the
1967 system in an inconsistent state. The question is how much effort you are
1968 willing to spend on trying to make something atomic that really isn't.
1970 From the point of view of an application the main requirement is that
1971 when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
1972 error should be returned without actually affecting any controls.
1974 If all the values are correct, then it is acceptable to just give up
1975 in case of low-level errors.
1977 It is important though that the application can tell when only a partial
1978 configuration was done. The way we do that is through the error_idx field
1979 of struct v4l2_ext_controls: if that is equal to the count field then no
1980 controls were affected. Otherwise all controls before that index were
1981 successful in performing their 'get' or 'set' operation, the control at
1982 the given index failed, and you don't know what happened with the controls
1983 after the failed one. Since if they were part of a control cluster they
1984 could have been successfully processed (if a cluster member was encountered
1985 at index < error_idx), they could have failed (if a cluster member was at
1986 error_idx), or they may not have been processed yet (if the first cluster
1987 member appeared after error_idx).
1989 It is all fairly theoretical, though. In practice all you can do is to
1990 bail out. If error_idx == count, then it is an application bug. If
1991 error_idx < count then it is only an application bug if the error code was
1992 EBUSY. That usually means that something started streaming just when you
1993 tried to set the controls. In all other cases it is a driver/hardware
1994 problem and all you can do is to retry or bail out.
1996 Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
1997 never modifies controls the error_idx is just set to whatever control
1998 has an invalid value.
2001 /* Prepare for the extended g/s/try functions.
2002 Find the controls in the control array and do some basic checks. */
2003 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
2004 struct v4l2_ext_controls *cs,
2005 struct v4l2_ctrl_helper *helpers)
2007 struct v4l2_ctrl_helper *h;
2008 bool have_clusters = false;
2011 for (i = 0, h = helpers; i < cs->count; i++, h++) {
2012 struct v4l2_ext_control *c = &cs->controls[i];
2013 struct v4l2_ctrl_ref *ref;
2014 struct v4l2_ctrl *ctrl;
2015 u32 id = c->id & V4L2_CTRL_ID_MASK;
2019 if (cs->ctrl_class && V4L2_CTRL_ID2CLASS(id) != cs->ctrl_class)
2022 /* Old-style private controls are not allowed for
2023 extended controls */
2024 if (id >= V4L2_CID_PRIVATE_BASE)
2026 ref = find_ref_lock(hdl, id);
2030 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED)
2033 if (ctrl->cluster[0]->ncontrols > 1)
2034 have_clusters = true;
2035 if (ctrl->cluster[0] != ctrl)
2036 ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
2037 /* Store the ref to the master control of the cluster */
2040 /* Initially set next to 0, meaning that there is no other
2041 control in this helper array belonging to the same
2046 /* We are done if there were no controls that belong to a multi-
2051 /* The code below figures out in O(n) time which controls in the list
2052 belong to the same cluster. */
2054 /* This has to be done with the handler lock taken. */
2055 mutex_lock(hdl->lock);
2057 /* First zero the helper field in the master control references */
2058 for (i = 0; i < cs->count; i++)
2059 helpers[i].mref->helper = 0;
2060 for (i = 0, h = helpers; i < cs->count; i++, h++) {
2061 struct v4l2_ctrl_ref *mref = h->mref;
2063 /* If the mref->helper is set, then it points to an earlier
2064 helper that belongs to the same cluster. */
2066 /* Set the next field of mref->helper to the current
2067 index: this means that that earlier helper now
2068 points to the next helper in the same cluster. */
2069 mref->helper->next = i;
2070 /* mref should be set only for the first helper in the
2071 cluster, clear the others. */
2074 /* Point the mref helper to the current helper struct. */
2077 mutex_unlock(hdl->lock);
2081 /* Handles the corner case where cs->count == 0. It checks whether the
2082 specified control class exists. If that class ID is 0, then it checks
2083 whether there are any controls at all. */
2084 static int class_check(struct v4l2_ctrl_handler *hdl, u32 ctrl_class)
2086 if (ctrl_class == 0)
2087 return list_empty(&hdl->ctrl_refs) ? -EINVAL : 0;
2088 return find_ref_lock(hdl, ctrl_class | 1) ? 0 : -EINVAL;
2093 /* Get extended controls. Allocates the helpers array if needed. */
2094 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2096 struct v4l2_ctrl_helper helper[4];
2097 struct v4l2_ctrl_helper *helpers = helper;
2101 cs->error_idx = cs->count;
2102 cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2108 return class_check(hdl, cs->ctrl_class);
2110 if (cs->count > ARRAY_SIZE(helper)) {
2111 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2113 if (helpers == NULL)
2117 ret = prepare_ext_ctrls(hdl, cs, helpers);
2118 cs->error_idx = cs->count;
2120 for (i = 0; !ret && i < cs->count; i++)
2121 if (helpers[i].ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2124 for (i = 0; !ret && i < cs->count; i++) {
2125 int (*ctrl_to_user)(struct v4l2_ext_control *c,
2126 struct v4l2_ctrl *ctrl) = cur_to_user;
2127 struct v4l2_ctrl *master;
2129 if (helpers[i].mref == NULL)
2132 master = helpers[i].mref->ctrl;
2135 v4l2_ctrl_lock(master);
2137 /* g_volatile_ctrl will update the new control values */
2138 if ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
2139 (master->has_volatiles && !is_cur_manual(master))) {
2140 for (j = 0; j < master->ncontrols; j++)
2141 cur_to_new(master->cluster[j]);
2142 ret = call_op(master, g_volatile_ctrl);
2143 ctrl_to_user = new_to_user;
2145 /* If OK, then copy the current (for non-volatile controls)
2146 or the new (for volatile controls) control values to the
2152 ret = ctrl_to_user(cs->controls + idx,
2154 idx = helpers[idx].next;
2155 } while (!ret && idx);
2157 v4l2_ctrl_unlock(master);
2160 if (cs->count > ARRAY_SIZE(helper))
2164 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
2166 int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2168 return v4l2_g_ext_ctrls(sd->ctrl_handler, cs);
2170 EXPORT_SYMBOL(v4l2_subdev_g_ext_ctrls);
2172 /* Helper function to get a single control */
2173 static int get_ctrl(struct v4l2_ctrl *ctrl, s32 *val)
2175 struct v4l2_ctrl *master = ctrl->cluster[0];
2179 if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
2182 v4l2_ctrl_lock(master);
2183 /* g_volatile_ctrl will update the current control values */
2184 if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
2185 for (i = 0; i < master->ncontrols; i++)
2186 cur_to_new(master->cluster[i]);
2187 ret = call_op(master, g_volatile_ctrl);
2190 *val = ctrl->cur.val;
2192 v4l2_ctrl_unlock(master);
2196 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
2198 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2200 if (ctrl == NULL || !type_is_int(ctrl))
2202 return get_ctrl(ctrl, &control->value);
2204 EXPORT_SYMBOL(v4l2_g_ctrl);
2206 int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2208 return v4l2_g_ctrl(sd->ctrl_handler, control);
2210 EXPORT_SYMBOL(v4l2_subdev_g_ctrl);
2212 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
2216 /* It's a driver bug if this happens. */
2217 WARN_ON(!type_is_int(ctrl));
2218 get_ctrl(ctrl, &val);
2221 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
2224 /* Core function that calls try/s_ctrl and ensures that the new value is
2225 copied to the current value on a set.
2226 Must be called with ctrl->handler->lock held. */
2227 static int try_or_set_cluster(struct v4l2_fh *fh,
2228 struct v4l2_ctrl *master, bool set)
2234 /* Go through the cluster and either validate the new value or
2235 (if no new value was set), copy the current value to the new
2236 value, ensuring a consistent view for the control ops when
2238 for (i = 0; i < master->ncontrols; i++) {
2239 struct v4l2_ctrl *ctrl = master->cluster[i];
2244 if (!ctrl->is_new) {
2248 /* Check again: it may have changed since the
2249 previous check in try_or_set_ext_ctrls(). */
2250 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2254 ret = call_op(master, try_ctrl);
2256 /* Don't set if there is no change */
2257 if (ret || !set || !cluster_changed(master))
2259 ret = call_op(master, s_ctrl);
2263 /* If OK, then make the new values permanent. */
2264 update_flag = is_cur_manual(master) != is_new_manual(master);
2265 for (i = 0; i < master->ncontrols; i++)
2266 new_to_cur(fh, master->cluster[i], update_flag && i > 0);
2270 /* Validate controls. */
2271 static int validate_ctrls(struct v4l2_ext_controls *cs,
2272 struct v4l2_ctrl_helper *helpers, bool set)
2277 cs->error_idx = cs->count;
2278 for (i = 0; i < cs->count; i++) {
2279 struct v4l2_ctrl *ctrl = helpers[i].ctrl;
2283 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2285 /* This test is also done in try_set_control_cluster() which
2286 is called in atomic context, so that has the final say,
2287 but it makes sense to do an up-front check as well. Once
2288 an error occurs in try_set_control_cluster() some other
2289 controls may have been set already and we want to do a
2290 best-effort to avoid that. */
2291 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED))
2293 ret = validate_new(ctrl, &cs->controls[i]);
2300 /* Obtain the current volatile values of an autocluster and mark them
2302 static void update_from_auto_cluster(struct v4l2_ctrl *master)
2306 for (i = 0; i < master->ncontrols; i++)
2307 cur_to_new(master->cluster[i]);
2308 if (!call_op(master, g_volatile_ctrl))
2309 for (i = 1; i < master->ncontrols; i++)
2310 if (master->cluster[i])
2311 master->cluster[i]->is_new = 1;
2314 /* Try or try-and-set controls */
2315 static int try_set_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2316 struct v4l2_ext_controls *cs,
2319 struct v4l2_ctrl_helper helper[4];
2320 struct v4l2_ctrl_helper *helpers = helper;
2324 cs->error_idx = cs->count;
2325 cs->ctrl_class = V4L2_CTRL_ID2CLASS(cs->ctrl_class);
2331 return class_check(hdl, cs->ctrl_class);
2333 if (cs->count > ARRAY_SIZE(helper)) {
2334 helpers = kmalloc_array(cs->count, sizeof(helper[0]),
2339 ret = prepare_ext_ctrls(hdl, cs, helpers);
2341 ret = validate_ctrls(cs, helpers, set);
2343 cs->error_idx = cs->count;
2344 for (i = 0; !ret && i < cs->count; i++) {
2345 struct v4l2_ctrl *master;
2348 if (helpers[i].mref == NULL)
2352 master = helpers[i].mref->ctrl;
2353 v4l2_ctrl_lock(master);
2355 /* Reset the 'is_new' flags of the cluster */
2356 for (j = 0; j < master->ncontrols; j++)
2357 if (master->cluster[j])
2358 master->cluster[j]->is_new = 0;
2360 /* For volatile autoclusters that are currently in auto mode
2361 we need to discover if it will be set to manual mode.
2362 If so, then we have to copy the current volatile values
2363 first since those will become the new manual values (which
2364 may be overwritten by explicit new values from this set
2366 if (master->is_auto && master->has_volatiles &&
2367 !is_cur_manual(master)) {
2368 /* Pick an initial non-manual value */
2369 s32 new_auto_val = master->manual_mode_value + 1;
2373 /* Check if the auto control is part of the
2374 list, and remember the new value. */
2375 if (helpers[tmp_idx].ctrl == master)
2376 new_auto_val = cs->controls[tmp_idx].value;
2377 tmp_idx = helpers[tmp_idx].next;
2379 /* If the new value == the manual value, then copy
2380 the current volatile values. */
2381 if (new_auto_val == master->manual_mode_value)
2382 update_from_auto_cluster(master);
2385 /* Copy the new caller-supplied control values.
2386 user_to_new() sets 'is_new' to 1. */
2388 ret = user_to_new(cs->controls + idx, helpers[idx].ctrl);
2389 idx = helpers[idx].next;
2390 } while (!ret && idx);
2393 ret = try_or_set_cluster(fh, master, set);
2395 /* Copy the new values back to userspace. */
2399 ret = new_to_user(cs->controls + idx,
2401 idx = helpers[idx].next;
2402 } while (!ret && idx);
2404 v4l2_ctrl_unlock(master);
2407 if (cs->count > ARRAY_SIZE(helper))
2412 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)
2414 return try_set_ext_ctrls(NULL, hdl, cs, false);
2416 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
2418 int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2419 struct v4l2_ext_controls *cs)
2421 return try_set_ext_ctrls(fh, hdl, cs, true);
2423 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
2425 int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2427 return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, false);
2429 EXPORT_SYMBOL(v4l2_subdev_try_ext_ctrls);
2431 int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs)
2433 return try_set_ext_ctrls(NULL, sd->ctrl_handler, cs, true);
2435 EXPORT_SYMBOL(v4l2_subdev_s_ext_ctrls);
2437 /* Helper function for VIDIOC_S_CTRL compatibility */
2438 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, s32 *val)
2440 struct v4l2_ctrl *master = ctrl->cluster[0];
2444 ret = validate_new_int(ctrl, val);
2448 v4l2_ctrl_lock(ctrl);
2450 /* Reset the 'is_new' flags of the cluster */
2451 for (i = 0; i < master->ncontrols; i++)
2452 if (master->cluster[i])
2453 master->cluster[i]->is_new = 0;
2455 /* For autoclusters with volatiles that are switched from auto to
2456 manual mode we have to update the current volatile values since
2457 those will become the initial manual values after such a switch. */
2458 if (master->is_auto && master->has_volatiles && ctrl == master &&
2459 !is_cur_manual(master) && *val == master->manual_mode_value)
2460 update_from_auto_cluster(master);
2463 ret = try_or_set_cluster(fh, master, true);
2464 *val = ctrl->cur.val;
2465 v4l2_ctrl_unlock(ctrl);
2469 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
2470 struct v4l2_control *control)
2472 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
2474 if (ctrl == NULL || !type_is_int(ctrl))
2477 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
2480 return set_ctrl(fh, ctrl, &control->value);
2482 EXPORT_SYMBOL(v4l2_s_ctrl);
2484 int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *control)
2486 return v4l2_s_ctrl(NULL, sd->ctrl_handler, control);
2488 EXPORT_SYMBOL(v4l2_subdev_s_ctrl);
2490 int v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
2492 /* It's a driver bug if this happens. */
2493 WARN_ON(!type_is_int(ctrl));
2494 return set_ctrl(NULL, ctrl, &val);
2496 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl);
2498 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev)
2500 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2505 v4l2_ctrl_lock(ctrl);
2506 list_add_tail(&sev->node, &ctrl->ev_subs);
2507 if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
2508 (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) {
2509 struct v4l2_event ev;
2510 u32 changes = V4L2_EVENT_CTRL_CH_FLAGS;
2512 if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY))
2513 changes |= V4L2_EVENT_CTRL_CH_VALUE;
2514 fill_event(&ev, ctrl, changes);
2515 v4l2_event_queue_fh(sev->fh, &ev);
2517 v4l2_ctrl_unlock(ctrl);
2521 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
2523 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
2525 v4l2_ctrl_lock(ctrl);
2526 list_del(&sev->node);
2527 v4l2_ctrl_unlock(ctrl);
2530 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
2532 u32 old_changes = old->u.ctrl.changes;
2534 old->u.ctrl = new->u.ctrl;
2535 old->u.ctrl.changes |= old_changes;
2537 EXPORT_SYMBOL(v4l2_ctrl_replace);
2539 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
2541 new->u.ctrl.changes |= old->u.ctrl.changes;
2543 EXPORT_SYMBOL(v4l2_ctrl_merge);
2545 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
2546 .add = v4l2_ctrl_add_event,
2547 .del = v4l2_ctrl_del_event,
2548 .replace = v4l2_ctrl_replace,
2549 .merge = v4l2_ctrl_merge,
2551 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
2553 int v4l2_ctrl_log_status(struct file *file, void *fh)
2555 struct video_device *vfd = video_devdata(file);
2556 struct v4l2_fh *vfh = file->private_data;
2558 if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
2559 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
2560 vfd->v4l2_dev->name);
2563 EXPORT_SYMBOL(v4l2_ctrl_log_status);
2565 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
2566 struct v4l2_event_subscription *sub)
2568 if (sub->type == V4L2_EVENT_CTRL)
2569 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
2572 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
2574 unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
2576 struct v4l2_fh *fh = file->private_data;
2578 if (v4l2_event_pending(fh))
2580 poll_wait(file, &fh->wait, wait);
2583 EXPORT_SYMBOL(v4l2_ctrl_poll);