diff options
Diffstat (limited to 'target/linux/bcm27xx/patches-5.15/950-0460-media-v4l2-Remove-v4l2-ctrls.c.patch')
| -rw-r--r-- | target/linux/bcm27xx/patches-5.15/950-0460-media-v4l2-Remove-v4l2-ctrls.c.patch | 5064 |
1 files changed, 5064 insertions, 0 deletions
diff --git a/target/linux/bcm27xx/patches-5.15/950-0460-media-v4l2-Remove-v4l2-ctrls.c.patch b/target/linux/bcm27xx/patches-5.15/950-0460-media-v4l2-Remove-v4l2-ctrls.c.patch new file mode 100644 index 0000000000..8a1c24f6cd --- /dev/null +++ b/target/linux/bcm27xx/patches-5.15/950-0460-media-v4l2-Remove-v4l2-ctrls.c.patch @@ -0,0 +1,5064 @@ +From 95280e5163ea457ccb442bc9d6c003c803d13894 Mon Sep 17 00:00:00 2001 +From: John Cox <jc@kynesim.co.uk> +Date: Fri, 6 Aug 2021 10:47:11 +0100 +Subject: [PATCH] media: v4l2: Remove v4l2-ctrls.c + +v4l2-ctrls.c has been split into 4 files v4l2-ctrls-*.c, the original +is redundant, confusing and probably should have been removed by a +previous patch. + +Signed-off-by: John Cox <jc@kynesim.co.uk> +--- + drivers/media/v4l2-core/v4l2-ctrls.c | 5046 -------------------------- + 1 file changed, 5046 deletions(-) + delete mode 100644 drivers/media/v4l2-core/v4l2-ctrls.c + +--- a/drivers/media/v4l2-core/v4l2-ctrls.c ++++ /dev/null +@@ -1,5046 +0,0 @@ +-// SPDX-License-Identifier: GPL-2.0-or-later +-/* +- V4L2 controls framework implementation. +- +- Copyright (C) 2010 Hans Verkuil <hverkuil@xs4all.nl> +- +- */ +- +-#define pr_fmt(fmt) "v4l2-ctrls: " fmt +- +-#include <linux/ctype.h> +-#include <linux/export.h> +-#include <linux/mm.h> +-#include <linux/slab.h> +-#include <media/v4l2-ctrls.h> +-#include <media/v4l2-dev.h> +-#include <media/v4l2-device.h> +-#include <media/v4l2-event.h> +-#include <media/v4l2-fwnode.h> +-#include <media/v4l2-ioctl.h> +- +-#define dprintk(vdev, fmt, arg...) do { \ +- if (!WARN_ON(!(vdev)) && ((vdev)->dev_debug & V4L2_DEV_DEBUG_CTRL)) \ +- printk(KERN_DEBUG pr_fmt("%s: %s: " fmt), \ +- __func__, video_device_node_name(vdev), ##arg); \ +-} while (0) +- +-#define has_op(master, op) \ +- (master->ops && master->ops->op) +-#define call_op(master, op) \ +- (has_op(master, op) ? master->ops->op(master) : 0) +- +-static const union v4l2_ctrl_ptr ptr_null; +- +-/* Internal temporary helper struct, one for each v4l2_ext_control */ +-struct v4l2_ctrl_helper { +- /* Pointer to the control reference of the master control */ +- struct v4l2_ctrl_ref *mref; +- /* The control ref corresponding to the v4l2_ext_control ID field. */ +- struct v4l2_ctrl_ref *ref; +- /* v4l2_ext_control index of the next control belonging to the +- same cluster, or 0 if there isn't any. */ +- u32 next; +-}; +- +-/* Small helper function to determine if the autocluster is set to manual +- mode. */ +-static bool is_cur_manual(const struct v4l2_ctrl *master) +-{ +- return master->is_auto && master->cur.val == master->manual_mode_value; +-} +- +-/* Same as above, but this checks the against the new value instead of the +- current value. */ +-static bool is_new_manual(const struct v4l2_ctrl *master) +-{ +- return master->is_auto && master->val == master->manual_mode_value; +-} +- +-/* Returns NULL or a character pointer array containing the menu for +- the given control ID. The pointer array ends with a NULL pointer. +- An empty string signifies a menu entry that is invalid. This allows +- drivers to disable certain options if it is not supported. */ +-const char * const *v4l2_ctrl_get_menu(u32 id) +-{ +- static const char * const mpeg_audio_sampling_freq[] = { +- "44.1 kHz", +- "48 kHz", +- "32 kHz", +- NULL +- }; +- static const char * const mpeg_audio_encoding[] = { +- "MPEG-1/2 Layer I", +- "MPEG-1/2 Layer II", +- "MPEG-1/2 Layer III", +- "MPEG-2/4 AAC", +- "AC-3", +- NULL +- }; +- static const char * const mpeg_audio_l1_bitrate[] = { +- "32 kbps", +- "64 kbps", +- "96 kbps", +- "128 kbps", +- "160 kbps", +- "192 kbps", +- "224 kbps", +- "256 kbps", +- "288 kbps", +- "320 kbps", +- "352 kbps", +- "384 kbps", +- "416 kbps", +- "448 kbps", +- NULL +- }; +- static const char * const mpeg_audio_l2_bitrate[] = { +- "32 kbps", +- "48 kbps", +- "56 kbps", +- "64 kbps", +- "80 kbps", +- "96 kbps", +- "112 kbps", +- "128 kbps", +- "160 kbps", +- "192 kbps", +- "224 kbps", +- "256 kbps", +- "320 kbps", +- "384 kbps", +- NULL +- }; +- static const char * const mpeg_audio_l3_bitrate[] = { +- "32 kbps", +- "40 kbps", +- "48 kbps", +- "56 kbps", +- "64 kbps", +- "80 kbps", +- "96 kbps", +- "112 kbps", +- "128 kbps", +- "160 kbps", +- "192 kbps", +- "224 kbps", +- "256 kbps", +- "320 kbps", +- NULL +- }; +- static const char * const mpeg_audio_ac3_bitrate[] = { +- "32 kbps", +- "40 kbps", +- "48 kbps", +- "56 kbps", +- "64 kbps", +- "80 kbps", +- "96 kbps", +- "112 kbps", +- "128 kbps", +- "160 kbps", +- "192 kbps", +- "224 kbps", +- "256 kbps", +- "320 kbps", +- "384 kbps", +- "448 kbps", +- "512 kbps", +- "576 kbps", +- "640 kbps", +- NULL +- }; +- static const char * const mpeg_audio_mode[] = { +- "Stereo", +- "Joint Stereo", +- "Dual", +- "Mono", +- NULL +- }; +- static const char * const mpeg_audio_mode_extension[] = { +- "Bound 4", +- "Bound 8", +- "Bound 12", +- "Bound 16", +- NULL +- }; +- static const char * const mpeg_audio_emphasis[] = { +- "No Emphasis", +- "50/15 us", +- "CCITT J17", +- NULL +- }; +- static const char * const mpeg_audio_crc[] = { +- "No CRC", +- "16-bit CRC", +- NULL +- }; +- static const char * const mpeg_audio_dec_playback[] = { +- "Auto", +- "Stereo", +- "Left", +- "Right", +- "Mono", +- "Swapped Stereo", +- NULL +- }; +- static const char * const mpeg_video_encoding[] = { +- "MPEG-1", +- "MPEG-2", +- "MPEG-4 AVC", +- NULL +- }; +- static const char * const mpeg_video_aspect[] = { +- "1x1", +- "4x3", +- "16x9", +- "2.21x1", +- NULL +- }; +- static const char * const mpeg_video_bitrate_mode[] = { +- "Variable Bitrate", +- "Constant Bitrate", +- "Constant Quality", +- NULL +- }; +- static const char * const mpeg_stream_type[] = { +- "MPEG-2 Program Stream", +- "MPEG-2 Transport Stream", +- "MPEG-1 System Stream", +- "MPEG-2 DVD-compatible Stream", +- "MPEG-1 VCD-compatible Stream", +- "MPEG-2 SVCD-compatible Stream", +- NULL +- }; +- static const char * const mpeg_stream_vbi_fmt[] = { +- "No VBI", +- "Private Packet, IVTV Format", +- NULL +- }; +- static const char * const camera_power_line_frequency[] = { +- "Disabled", +- "50 Hz", +- "60 Hz", +- "Auto", +- NULL +- }; +- static const char * const camera_exposure_auto[] = { +- "Auto Mode", +- "Manual Mode", +- "Shutter Priority Mode", +- "Aperture Priority Mode", +- NULL +- }; +- static const char * const camera_exposure_metering[] = { +- "Average", +- "Center Weighted", +- "Spot", +- "Matrix", +- NULL +- }; +- static const char * const camera_auto_focus_range[] = { +- "Auto", +- "Normal", +- "Macro", +- "Infinity", +- NULL +- }; +- static const char * const colorfx[] = { +- "None", +- "Black & White", +- "Sepia", +- "Negative", +- "Emboss", +- "Sketch", +- "Sky Blue", +- "Grass Green", +- "Skin Whiten", +- "Vivid", +- "Aqua", +- "Art Freeze", +- "Silhouette", +- "Solarization", +- "Antique", +- "Set Cb/Cr", +- NULL +- }; +- static const char * const auto_n_preset_white_balance[] = { +- "Manual", +- "Auto", +- "Incandescent", +- "Fluorescent", +- "Fluorescent H", +- "Horizon", +- "Daylight", +- "Flash", +- "Cloudy", +- "Shade", +- "Greyworld", +- NULL, +- }; +- static const char * const camera_iso_sensitivity_auto[] = { +- "Manual", +- "Auto", +- NULL +- }; +- static const char * const scene_mode[] = { +- "None", +- "Backlight", +- "Beach/Snow", +- "Candle Light", +- "Dusk/Dawn", +- "Fall Colors", +- "Fireworks", +- "Landscape", +- "Night", +- "Party/Indoor", +- "Portrait", +- "Sports", +- "Sunset", +- "Text", +- NULL +- }; +- static const char * const tune_emphasis[] = { +- "None", +- "50 Microseconds", +- "75 Microseconds", +- NULL, +- }; +- static const char * const header_mode[] = { +- "Separate Buffer", +- "Joined With 1st Frame", +- NULL, +- }; +- static const char * const multi_slice[] = { +- "Single", +- "Max Macroblocks", +- "Max Bytes", +- NULL, +- }; +- static const char * const entropy_mode[] = { +- "CAVLC", +- "CABAC", +- NULL, +- }; +- static const char * const mpeg_h264_level[] = { +- "1", +- "1b", +- "1.1", +- "1.2", +- "1.3", +- "2", +- "2.1", +- "2.2", +- "3", +- "3.1", +- "3.2", +- "4", +- "4.1", +- "4.2", +- "5", +- "5.1", +- "5.2", +- "6.0", +- "6.1", +- "6.2", +- NULL, +- }; +- static const char * const h264_loop_filter[] = { +- "Enabled", +- "Disabled", +- "Disabled at Slice Boundary", +- NULL, +- }; +- static const char * const h264_profile[] = { +- "Baseline", +- "Constrained Baseline", +- "Main", +- "Extended", +- "High", +- "High 10", +- "High 422", +- "High 444 Predictive", +- "High 10 Intra", +- "High 422 Intra", +- "High 444 Intra", +- "CAVLC 444 Intra", +- "Scalable Baseline", +- "Scalable High", +- "Scalable High Intra", +- "Stereo High", +- "Multiview High", +- "Constrained High", +- NULL, +- }; +- static const char * const vui_sar_idc[] = { +- "Unspecified", +- "1:1", +- "12:11", +- "10:11", +- "16:11", +- "40:33", +- "24:11", +- "20:11", +- "32:11", +- "80:33", +- "18:11", +- "15:11", +- "64:33", +- "160:99", +- "4:3", +- "3:2", +- "2:1", +- "Extended SAR", +- NULL, +- }; +- static const char * const h264_fp_arrangement_type[] = { +- "Checkerboard", +- "Column", +- "Row", +- "Side by Side", +- "Top Bottom", +- "Temporal", +- NULL, +- }; +- static const char * const h264_fmo_map_type[] = { +- "Interleaved Slices", +- "Scattered Slices", +- "Foreground with Leftover", +- "Box Out", +- "Raster Scan", +- "Wipe Scan", +- "Explicit", +- NULL, +- }; +- static const char * const h264_decode_mode[] = { +- "Slice-Based", +- "Frame-Based", +- NULL, +- }; +- static const char * const h264_start_code[] = { +- "No Start Code", +- "Annex B Start Code", +- NULL, +- }; +- static const char * const h264_hierarchical_coding_type[] = { +- "Hier Coding B", +- "Hier Coding P", +- NULL, +- }; +- static const char * const mpeg_mpeg2_level[] = { +- "Low", +- "Main", +- "High 1440", +- "High", +- NULL, +- }; +- static const char * const mpeg2_profile[] = { +- "Simple", +- "Main", +- "SNR Scalable", +- "Spatially Scalable", +- "High", +- NULL, +- }; +- static const char * const mpeg_mpeg4_level[] = { +- "0", +- "0b", +- "1", +- "2", +- "3", +- "3b", +- "4", +- "5", +- NULL, +- }; +- static const char * const mpeg4_profile[] = { +- "Simple", +- "Advanced Simple", +- "Core", +- "Simple Scalable", +- "Advanced Coding Efficiency", +- NULL, +- }; +- +- static const char * const vpx_golden_frame_sel[] = { +- "Use Previous Frame", +- "Use Previous Specific Frame", +- NULL, +- }; +- static const char * const vp8_profile[] = { +- "0", +- "1", +- "2", +- "3", +- NULL, +- }; +- static const char * const vp9_profile[] = { +- "0", +- "1", +- "2", +- "3", +- NULL, +- }; +- static const char * const vp9_level[] = { +- "1", +- "1.1", +- "2", +- "2.1", +- "3", +- "3.1", +- "4", +- "4.1", +- "5", +- "5.1", +- "5.2", +- "6", +- "6.1", +- "6.2", +- NULL, +- }; +- +- static const char * const flash_led_mode[] = { +- "Off", +- "Flash", +- "Torch", +- NULL, +- }; +- static const char * const flash_strobe_source[] = { +- "Software", +- "External", +- NULL, +- }; +- +- static const char * const jpeg_chroma_subsampling[] = { +- "4:4:4", +- "4:2:2", +- "4:2:0", +- "4:1:1", +- "4:1:0", +- "Gray", +- NULL, +- }; +- static const char * const dv_tx_mode[] = { +- "DVI-D", +- "HDMI", +- NULL, +- }; +- static const char * const dv_rgb_range[] = { +- "Automatic", +- "RGB Limited Range (16-235)", +- "RGB Full Range (0-255)", +- NULL, +- }; +- static const char * const dv_it_content_type[] = { +- "Graphics", +- "Photo", +- "Cinema", +- "Game", +- "No IT Content", +- NULL, +- }; +- static const char * const detect_md_mode[] = { +- "Disabled", +- "Global", +- "Threshold Grid", +- "Region Grid", +- NULL, +- }; +- +- static const char * const hevc_profile[] = { +- "Main", +- "Main Still Picture", +- "Main 10", +- NULL, +- }; +- static const char * const hevc_level[] = { +- "1", +- "2", +- "2.1", +- "3", +- "3.1", +- "4", +- "4.1", +- "5", +- "5.1", +- "5.2", +- "6", +- "6.1", +- "6.2", +- NULL, +- }; +- static const char * const hevc_hierarchial_coding_type[] = { +- "B", +- "P", +- NULL, +- }; +- static const char * const hevc_refresh_type[] = { +- "None", +- "CRA", +- "IDR", +- NULL, +- }; +- static const char * const hevc_size_of_length_field[] = { +- "0", +- "1", +- "2", +- "4", +- NULL, +- }; +- static const char * const hevc_tier[] = { +- "Main", +- "High", +- NULL, +- }; +- static const char * const hevc_loop_filter_mode[] = { +- "Disabled", +- "Enabled", +- "Disabled at slice boundary", +- "NULL", +- }; +- static const char * const hevc_decode_mode[] = { +- "Slice-Based", +- "Frame-Based", +- NULL, +- }; +- static const char * const hevc_start_code[] = { +- "No Start Code", +- "Annex B Start Code", +- NULL, +- }; +- static const char * const camera_orientation[] = { +- "Front", +- "Back", +- "External", +- NULL, +- }; +- static const char * const mpeg_video_frame_skip[] = { +- "Disabled", +- "Level Limit", +- "VBV/CPB Limit", +- NULL, +- }; +- +- switch (id) { +- case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: +- return mpeg_audio_sampling_freq; +- case V4L2_CID_MPEG_AUDIO_ENCODING: +- return mpeg_audio_encoding; +- case V4L2_CID_MPEG_AUDIO_L1_BITRATE: +- return mpeg_audio_l1_bitrate; +- case V4L2_CID_MPEG_AUDIO_L2_BITRATE: +- return mpeg_audio_l2_bitrate; +- case V4L2_CID_MPEG_AUDIO_L3_BITRATE: +- return mpeg_audio_l3_bitrate; +- case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: +- return mpeg_audio_ac3_bitrate; +- case V4L2_CID_MPEG_AUDIO_MODE: +- return mpeg_audio_mode; +- case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: +- return mpeg_audio_mode_extension; +- case V4L2_CID_MPEG_AUDIO_EMPHASIS: +- return mpeg_audio_emphasis; +- case V4L2_CID_MPEG_AUDIO_CRC: +- return mpeg_audio_crc; +- case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK: +- case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: +- return mpeg_audio_dec_playback; +- case V4L2_CID_MPEG_VIDEO_ENCODING: +- return mpeg_video_encoding; +- case V4L2_CID_MPEG_VIDEO_ASPECT: +- return mpeg_video_aspect; +- case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: +- return mpeg_video_bitrate_mode; +- case V4L2_CID_MPEG_STREAM_TYPE: +- return mpeg_stream_type; +- case V4L2_CID_MPEG_STREAM_VBI_FMT: +- return mpeg_stream_vbi_fmt; +- case V4L2_CID_POWER_LINE_FREQUENCY: +- return camera_power_line_frequency; +- case V4L2_CID_EXPOSURE_AUTO: +- return camera_exposure_auto; +- case V4L2_CID_EXPOSURE_METERING: +- return camera_exposure_metering; +- case V4L2_CID_AUTO_FOCUS_RANGE: +- return camera_auto_focus_range; +- case V4L2_CID_COLORFX: +- return colorfx; +- case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: +- return auto_n_preset_white_balance; +- case V4L2_CID_ISO_SENSITIVITY_AUTO: +- return camera_iso_sensitivity_auto; +- case V4L2_CID_SCENE_MODE: +- return scene_mode; +- case V4L2_CID_TUNE_PREEMPHASIS: +- return tune_emphasis; +- case V4L2_CID_TUNE_DEEMPHASIS: +- return tune_emphasis; +- case V4L2_CID_FLASH_LED_MODE: +- return flash_led_mode; +- case V4L2_CID_FLASH_STROBE_SOURCE: +- return flash_strobe_source; +- case V4L2_CID_MPEG_VIDEO_HEADER_MODE: +- return header_mode; +- case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE: +- return mpeg_video_frame_skip; +- case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: +- return multi_slice; +- case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE: +- return entropy_mode; +- case V4L2_CID_MPEG_VIDEO_H264_LEVEL: +- return mpeg_h264_level; +- case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE: +- return h264_loop_filter; +- case V4L2_CID_MPEG_VIDEO_H264_PROFILE: +- return h264_profile; +- case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC: +- return vui_sar_idc; +- case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE: +- return h264_fp_arrangement_type; +- case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE: +- return h264_fmo_map_type; +- case V4L2_CID_STATELESS_H264_DECODE_MODE: +- return h264_decode_mode; +- case V4L2_CID_STATELESS_H264_START_CODE: +- return h264_start_code; +- case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE: +- return h264_hierarchical_coding_type; +- case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL: +- return mpeg_mpeg2_level; +- case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE: +- return mpeg2_profile; +- case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL: +- return mpeg_mpeg4_level; +- case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE: +- return mpeg4_profile; +- case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL: +- return vpx_golden_frame_sel; +- case V4L2_CID_MPEG_VIDEO_VP8_PROFILE: +- return vp8_profile; +- case V4L2_CID_MPEG_VIDEO_VP9_PROFILE: +- return vp9_profile; +- case V4L2_CID_MPEG_VIDEO_VP9_LEVEL: +- return vp9_level; +- case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: +- return jpeg_chroma_subsampling; +- case V4L2_CID_DV_TX_MODE: +- return dv_tx_mode; +- case V4L2_CID_DV_TX_RGB_RANGE: +- case V4L2_CID_DV_RX_RGB_RANGE: +- return dv_rgb_range; +- case V4L2_CID_DV_TX_IT_CONTENT_TYPE: +- case V4L2_CID_DV_RX_IT_CONTENT_TYPE: +- return dv_it_content_type; +- case V4L2_CID_DETECT_MD_MODE: +- return detect_md_mode; +- case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE: +- return hevc_profile; +- case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL: +- return hevc_level; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE: +- return hevc_hierarchial_coding_type; +- case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE: +- return hevc_refresh_type; +- case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD: +- return hevc_size_of_length_field; +- case V4L2_CID_MPEG_VIDEO_HEVC_TIER: +- return hevc_tier; +- case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE: +- return hevc_loop_filter_mode; +- case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE: +- return hevc_decode_mode; +- case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE: +- return hevc_start_code; +- case V4L2_CID_CAMERA_ORIENTATION: +- return camera_orientation; +- default: +- return NULL; +- } +-} +-EXPORT_SYMBOL(v4l2_ctrl_get_menu); +- +-#define __v4l2_qmenu_int_len(arr, len) ({ *(len) = ARRAY_SIZE(arr); arr; }) +-/* +- * Returns NULL or an s64 type array containing the menu for given +- * control ID. The total number of the menu items is returned in @len. +- */ +-const s64 *v4l2_ctrl_get_int_menu(u32 id, u32 *len) +-{ +- static const s64 qmenu_int_vpx_num_partitions[] = { +- 1, 2, 4, 8, +- }; +- +- static const s64 qmenu_int_vpx_num_ref_frames[] = { +- 1, 2, 3, +- }; +- +- switch (id) { +- case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS: +- return __v4l2_qmenu_int_len(qmenu_int_vpx_num_partitions, len); +- case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES: +- return __v4l2_qmenu_int_len(qmenu_int_vpx_num_ref_frames, len); +- default: +- *len = 0; +- return NULL; +- } +-} +-EXPORT_SYMBOL(v4l2_ctrl_get_int_menu); +- +-/* Return the control name. */ +-const char *v4l2_ctrl_get_name(u32 id) +-{ +- switch (id) { +- /* USER controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_USER_CLASS: return "User Controls"; +- case V4L2_CID_BRIGHTNESS: return "Brightness"; +- case V4L2_CID_CONTRAST: return "Contrast"; +- case V4L2_CID_SATURATION: return "Saturation"; +- case V4L2_CID_HUE: return "Hue"; +- case V4L2_CID_AUDIO_VOLUME: return "Volume"; +- case V4L2_CID_AUDIO_BALANCE: return "Balance"; +- case V4L2_CID_AUDIO_BASS: return "Bass"; +- case V4L2_CID_AUDIO_TREBLE: return "Treble"; +- case V4L2_CID_AUDIO_MUTE: return "Mute"; +- case V4L2_CID_AUDIO_LOUDNESS: return "Loudness"; +- case V4L2_CID_BLACK_LEVEL: return "Black Level"; +- case V4L2_CID_AUTO_WHITE_BALANCE: return "White Balance, Automatic"; +- case V4L2_CID_DO_WHITE_BALANCE: return "Do White Balance"; +- case V4L2_CID_RED_BALANCE: return "Red Balance"; +- case V4L2_CID_BLUE_BALANCE: return "Blue Balance"; +- case V4L2_CID_GAMMA: return "Gamma"; +- case V4L2_CID_EXPOSURE: return "Exposure"; +- case V4L2_CID_AUTOGAIN: return "Gain, Automatic"; +- case V4L2_CID_GAIN: return "Gain"; +- case V4L2_CID_HFLIP: return "Horizontal Flip"; +- case V4L2_CID_VFLIP: return "Vertical Flip"; +- case V4L2_CID_POWER_LINE_FREQUENCY: return "Power Line Frequency"; +- case V4L2_CID_HUE_AUTO: return "Hue, Automatic"; +- case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature"; +- case V4L2_CID_SHARPNESS: return "Sharpness"; +- case V4L2_CID_BACKLIGHT_COMPENSATION: return "Backlight Compensation"; +- case V4L2_CID_CHROMA_AGC: return "Chroma AGC"; +- case V4L2_CID_COLOR_KILLER: return "Color Killer"; +- case V4L2_CID_COLORFX: return "Color Effects"; +- case V4L2_CID_AUTOBRIGHTNESS: return "Brightness, Automatic"; +- case V4L2_CID_BAND_STOP_FILTER: return "Band-Stop Filter"; +- case V4L2_CID_ROTATE: return "Rotate"; +- case V4L2_CID_BG_COLOR: return "Background Color"; +- case V4L2_CID_CHROMA_GAIN: return "Chroma Gain"; +- case V4L2_CID_ILLUMINATORS_1: return "Illuminator 1"; +- case V4L2_CID_ILLUMINATORS_2: return "Illuminator 2"; +- case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE: return "Min Number of Capture Buffers"; +- case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT: return "Min Number of Output Buffers"; +- case V4L2_CID_ALPHA_COMPONENT: return "Alpha Component"; +- case V4L2_CID_COLORFX_CBCR: return "Color Effects, CbCr"; +- +- /* Codec controls */ +- /* The MPEG controls are applicable to all codec controls +- * and the 'MPEG' part of the define is historical */ +- /* Keep the order of the 'case's the same as in videodev2.h! */ +- case V4L2_CID_CODEC_CLASS: return "Codec Controls"; +- case V4L2_CID_MPEG_STREAM_TYPE: return "Stream Type"; +- case V4L2_CID_MPEG_STREAM_PID_PMT: return "Stream PMT Program ID"; +- case V4L2_CID_MPEG_STREAM_PID_AUDIO: return "Stream Audio Program ID"; +- case V4L2_CID_MPEG_STREAM_PID_VIDEO: return "Stream Video Program ID"; +- case V4L2_CID_MPEG_STREAM_PID_PCR: return "Stream PCR Program ID"; +- case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID"; +- case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID"; +- case V4L2_CID_MPEG_STREAM_VBI_FMT: return "Stream VBI Format"; +- case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency"; +- case V4L2_CID_MPEG_AUDIO_ENCODING: return "Audio Encoding"; +- case V4L2_CID_MPEG_AUDIO_L1_BITRATE: return "Audio Layer I Bitrate"; +- case V4L2_CID_MPEG_AUDIO_L2_BITRATE: return "Audio Layer II Bitrate"; +- case V4L2_CID_MPEG_AUDIO_L3_BITRATE: return "Audio Layer III Bitrate"; +- case V4L2_CID_MPEG_AUDIO_MODE: return "Audio Stereo Mode"; +- case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension"; +- case V4L2_CID_MPEG_AUDIO_EMPHASIS: return "Audio Emphasis"; +- case V4L2_CID_MPEG_AUDIO_CRC: return "Audio CRC"; +- case V4L2_CID_MPEG_AUDIO_MUTE: return "Audio Mute"; +- case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate"; +- case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: return "Audio AC-3 Bitrate"; +- case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK: return "Audio Playback"; +- case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: return "Audio Multilingual Playback"; +- case V4L2_CID_MPEG_VIDEO_ENCODING: return "Video Encoding"; +- case V4L2_CID_MPEG_VIDEO_ASPECT: return "Video Aspect"; +- case V4L2_CID_MPEG_VIDEO_B_FRAMES: return "Video B Frames"; +- case V4L2_CID_MPEG_VIDEO_GOP_SIZE: return "Video GOP Size"; +- case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: return "Video GOP Closure"; +- case V4L2_CID_MPEG_VIDEO_PULLDOWN: return "Video Pulldown"; +- case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: return "Video Bitrate Mode"; +- case V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY: return "Constant Quality"; +- case V4L2_CID_MPEG_VIDEO_BITRATE: return "Video Bitrate"; +- case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: return "Video Peak Bitrate"; +- case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation"; +- case V4L2_CID_MPEG_VIDEO_MUTE: return "Video Mute"; +- case V4L2_CID_MPEG_VIDEO_MUTE_YUV: return "Video Mute YUV"; +- case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE: return "Decoder Slice Interface"; +- case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER: return "MPEG4 Loop Filter Enable"; +- case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB: return "Number of Intra Refresh MBs"; +- case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE: return "Frame Level Rate Control Enable"; +- case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE: return "H264 MB Level Rate Control"; +- case V4L2_CID_MPEG_VIDEO_HEADER_MODE: return "Sequence Header Mode"; +- case V4L2_CID_MPEG_VIDEO_MAX_REF_PIC: return "Max Number of Reference Pics"; +- case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE: return "Frame Skip Mode"; +- case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY: return "Display Delay"; +- case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE: return "Display Delay Enable"; +- case V4L2_CID_MPEG_VIDEO_AU_DELIMITER: return "Generate Access Unit Delimiters"; +- case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP: return "H263 I-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP: return "H263 P-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP: return "H263 B-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_H263_MIN_QP: return "H263 Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_H263_MAX_QP: return "H263 Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP: return "H264 I-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP: return "H264 P-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP: return "H264 B-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_MAX_QP: return "H264 Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_MIN_QP: return "H264 Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM: return "H264 8x8 Transform Enable"; +- case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE: return "H264 CPB Buffer Size"; +- case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE: return "H264 Entropy Mode"; +- case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD: return "H264 I-Frame Period"; +- case V4L2_CID_MPEG_VIDEO_H264_LEVEL: return "H264 Level"; +- case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA: return "H264 Loop Filter Alpha Offset"; +- case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA: return "H264 Loop Filter Beta Offset"; +- case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE: return "H264 Loop Filter Mode"; +- case V4L2_CID_MPEG_VIDEO_H264_PROFILE: return "H264 Profile"; +- case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT: return "Vertical Size of SAR"; +- case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH: return "Horizontal Size of SAR"; +- case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE: return "Aspect Ratio VUI Enable"; +- case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC: return "VUI Aspect Ratio IDC"; +- case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING: return "H264 Enable Frame Packing SEI"; +- case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0: return "H264 Set Curr. Frame as Frame0"; +- case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE: return "H264 FP Arrangement Type"; +- case V4L2_CID_MPEG_VIDEO_H264_FMO: return "H264 Flexible MB Ordering"; +- case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE: return "H264 Map Type for FMO"; +- case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP: return "H264 FMO Number of Slice Groups"; +- case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION: return "H264 FMO Direction of Change"; +- case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE: return "H264 FMO Size of 1st Slice Grp"; +- case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH: return "H264 FMO No. of Consecutive MBs"; +- case V4L2_CID_MPEG_VIDEO_H264_ASO: return "H264 Arbitrary Slice Ordering"; +- case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER: return "H264 ASO Slice Order"; +- case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING: return "Enable H264 Hierarchical Coding"; +- case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE: return "H264 Hierarchical Coding Type"; +- case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:return "H264 Number of HC Layers"; +- case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP: +- return "H264 Set QP Value for HC Layers"; +- case V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION: +- return "H264 Constrained Intra Pred"; +- case V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET: return "H264 Chroma QP Index Offset"; +- case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP: return "H264 I-Frame Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP: return "H264 I-Frame Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP: return "H264 P-Frame Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP: return "H264 P-Frame Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MIN_QP: return "H264 B-Frame Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MAX_QP: return "H264 B-Frame Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L0_BR: return "H264 Hierarchical Lay 0 Bitrate"; +- case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L1_BR: return "H264 Hierarchical Lay 1 Bitrate"; +- case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L2_BR: return "H264 Hierarchical Lay 2 Bitrate"; +- case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L3_BR: return "H264 Hierarchical Lay 3 Bitrate"; +- case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L4_BR: return "H264 Hierarchical Lay 4 Bitrate"; +- case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L5_BR: return "H264 Hierarchical Lay 5 Bitrate"; +- case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L6_BR: return "H264 Hierarchical Lay 6 Bitrate"; +- case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL: return "MPEG2 Level"; +- case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE: return "MPEG2 Profile"; +- case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP: return "MPEG4 I-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP: return "MPEG4 P-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP: return "MPEG4 B-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP: return "MPEG4 Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP: return "MPEG4 Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL: return "MPEG4 Level"; +- case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE: return "MPEG4 Profile"; +- case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL: return "Quarter Pixel Search Enable"; +- case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES: return "Maximum Bytes in a Slice"; +- case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB: return "Number of MBs in a Slice"; +- case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: return "Slice Partitioning Method"; +- case V4L2_CID_MPEG_VIDEO_VBV_SIZE: return "VBV Buffer Size"; +- case V4L2_CID_MPEG_VIDEO_DEC_PTS: return "Video Decoder PTS"; +- case V4L2_CID_MPEG_VIDEO_DEC_FRAME: return "Video Decoder Frame Count"; +- case V4L2_CID_MPEG_VIDEO_DEC_CONCEAL_COLOR: return "Video Decoder Conceal Color"; +- case V4L2_CID_MPEG_VIDEO_VBV_DELAY: return "Initial Delay for VBV Control"; +- case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE: return "Horizontal MV Search Range"; +- case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE: return "Vertical MV Search Range"; +- case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER: return "Repeat Sequence Header"; +- case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME: return "Force Key Frame"; +- case V4L2_CID_MPEG_VIDEO_BASELAYER_PRIORITY_ID: return "Base Layer Priority ID"; +- case V4L2_CID_MPEG_VIDEO_LTR_COUNT: return "LTR Count"; +- case V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX: return "Frame LTR Index"; +- case V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES: return "Use LTR Frames"; +- case V4L2_CID_MPEG_VIDEO_MPEG2_SLICE_PARAMS: return "MPEG-2 Slice Parameters"; +- case V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION: return "MPEG-2 Quantization Matrices"; +- case V4L2_CID_FWHT_I_FRAME_QP: return "FWHT I-Frame QP Value"; +- case V4L2_CID_FWHT_P_FRAME_QP: return "FWHT P-Frame QP Value"; +- +- /* VPX controls */ +- case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS: return "VPX Number of Partitions"; +- case V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4: return "VPX Intra Mode Decision Disable"; +- case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES: return "VPX No. of Refs for P Frame"; +- case V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL: return "VPX Loop Filter Level Range"; +- case V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS: return "VPX Deblocking Effect Control"; +- case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD: return "VPX Golden Frame Refresh Period"; +- case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL: return "VPX Golden Frame Indicator"; +- case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP: return "VPX Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP: return "VPX Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP: return "VPX I-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP: return "VPX P-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_VP8_PROFILE: return "VP8 Profile"; +- case V4L2_CID_MPEG_VIDEO_VP9_PROFILE: return "VP9 Profile"; +- case V4L2_CID_MPEG_VIDEO_VP9_LEVEL: return "VP9 Level"; +- +- /* HEVC controls */ +- case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP: return "HEVC I-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP: return "HEVC P-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP: return "HEVC B-Frame QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP: return "HEVC Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP: return "HEVC Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MIN_QP: return "HEVC I-Frame Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MAX_QP: return "HEVC I-Frame Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MIN_QP: return "HEVC P-Frame Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MAX_QP: return "HEVC P-Frame Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MIN_QP: return "HEVC B-Frame Minimum QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MAX_QP: return "HEVC B-Frame Maximum QP Value"; +- case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE: return "HEVC Profile"; +- case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL: return "HEVC Level"; +- case V4L2_CID_MPEG_VIDEO_HEVC_TIER: return "HEVC Tier"; +- case V4L2_CID_MPEG_VIDEO_HEVC_FRAME_RATE_RESOLUTION: return "HEVC Frame Rate Resolution"; +- case V4L2_CID_MPEG_VIDEO_HEVC_MAX_PARTITION_DEPTH: return "HEVC Maximum Coding Unit Depth"; +- case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE: return "HEVC Refresh Type"; +- case V4L2_CID_MPEG_VIDEO_HEVC_CONST_INTRA_PRED: return "HEVC Constant Intra Prediction"; +- case V4L2_CID_MPEG_VIDEO_HEVC_LOSSLESS_CU: return "HEVC Lossless Encoding"; +- case V4L2_CID_MPEG_VIDEO_HEVC_WAVEFRONT: return "HEVC Wavefront"; +- case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE: return "HEVC Loop Filter"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_QP: return "HEVC QP Values"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE: return "HEVC Hierarchical Coding Type"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER: return "HEVC Hierarchical Coding Layer"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_QP: return "HEVC Hierarchical Layer 0 QP"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_QP: return "HEVC Hierarchical Layer 1 QP"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_QP: return "HEVC Hierarchical Layer 2 QP"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_QP: return "HEVC Hierarchical Layer 3 QP"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_QP: return "HEVC Hierarchical Layer 4 QP"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_QP: return "HEVC Hierarchical Layer 5 QP"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_QP: return "HEVC Hierarchical Layer 6 QP"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_BR: return "HEVC Hierarchical Lay 0 BitRate"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_BR: return "HEVC Hierarchical Lay 1 BitRate"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_BR: return "HEVC Hierarchical Lay 2 BitRate"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_BR: return "HEVC Hierarchical Lay 3 BitRate"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_BR: return "HEVC Hierarchical Lay 4 BitRate"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_BR: return "HEVC Hierarchical Lay 5 BitRate"; +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_BR: return "HEVC Hierarchical Lay 6 BitRate"; +- case V4L2_CID_MPEG_VIDEO_HEVC_GENERAL_PB: return "HEVC General PB"; +- case V4L2_CID_MPEG_VIDEO_HEVC_TEMPORAL_ID: return "HEVC Temporal ID"; +- case V4L2_CID_MPEG_VIDEO_HEVC_STRONG_SMOOTHING: return "HEVC Strong Intra Smoothing"; +- case V4L2_CID_MPEG_VIDEO_HEVC_INTRA_PU_SPLIT: return "HEVC Intra PU Split"; +- case V4L2_CID_MPEG_VIDEO_HEVC_TMV_PREDICTION: return "HEVC TMV Prediction"; +- case V4L2_CID_MPEG_VIDEO_HEVC_MAX_NUM_MERGE_MV_MINUS1: return "HEVC Max Num of Candidate MVs"; +- case V4L2_CID_MPEG_VIDEO_HEVC_WITHOUT_STARTCODE: return "HEVC ENC Without Startcode"; +- case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_PERIOD: return "HEVC Num of I-Frame b/w 2 IDR"; +- case V4L2_CID_MPEG_VIDEO_HEVC_LF_BETA_OFFSET_DIV2: return "HEVC Loop Filter Beta Offset"; +- case V4L2_CID_MPEG_VIDEO_HEVC_LF_TC_OFFSET_DIV2: return "HEVC Loop Filter TC Offset"; +- case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD: return "HEVC Size of Length Field"; +- case V4L2_CID_MPEG_VIDEO_REF_NUMBER_FOR_PFRAMES: return "Reference Frames for a P-Frame"; +- case V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR: return "Prepend SPS and PPS to IDR"; +- case V4L2_CID_MPEG_VIDEO_HEVC_SPS: return "HEVC Sequence Parameter Set"; +- case V4L2_CID_MPEG_VIDEO_HEVC_PPS: return "HEVC Picture Parameter Set"; +- case V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS: return "HEVC Slice Parameters"; +- case V4L2_CID_MPEG_VIDEO_HEVC_SCALING_MATRIX: return "HEVC Scaling Matrix"; +- case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE: return "HEVC Decode Mode"; +- case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE: return "HEVC Start Code"; +- +- /* CAMERA controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_CAMERA_CLASS: return "Camera Controls"; +- case V4L2_CID_EXPOSURE_AUTO: return "Auto Exposure"; +- case V4L2_CID_EXPOSURE_ABSOLUTE: return "Exposure Time, Absolute"; +- case V4L2_CID_EXPOSURE_AUTO_PRIORITY: return "Exposure, Dynamic Framerate"; +- case V4L2_CID_PAN_RELATIVE: return "Pan, Relative"; +- case V4L2_CID_TILT_RELATIVE: return "Tilt, Relative"; +- case V4L2_CID_PAN_RESET: return "Pan, Reset"; +- case V4L2_CID_TILT_RESET: return "Tilt, Reset"; +- case V4L2_CID_PAN_ABSOLUTE: return "Pan, Absolute"; +- case V4L2_CID_TILT_ABSOLUTE: return "Tilt, Absolute"; +- case V4L2_CID_FOCUS_ABSOLUTE: return "Focus, Absolute"; +- case V4L2_CID_FOCUS_RELATIVE: return "Focus, Relative"; +- case V4L2_CID_FOCUS_AUTO: return "Focus, Automatic Continuous"; +- case V4L2_CID_ZOOM_ABSOLUTE: return "Zoom, Absolute"; +- case V4L2_CID_ZOOM_RELATIVE: return "Zoom, Relative"; +- case V4L2_CID_ZOOM_CONTINUOUS: return "Zoom, Continuous"; +- case V4L2_CID_PRIVACY: return "Privacy"; +- case V4L2_CID_IRIS_ABSOLUTE: return "Iris, Absolute"; +- case V4L2_CID_IRIS_RELATIVE: return "Iris, Relative"; +- case V4L2_CID_AUTO_EXPOSURE_BIAS: return "Auto Exposure, Bias"; +- case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: return "White Balance, Auto & Preset"; +- case V4L2_CID_WIDE_DYNAMIC_RANGE: return "Wide Dynamic Range"; +- case V4L2_CID_IMAGE_STABILIZATION: return "Image Stabilization"; +- case V4L2_CID_ISO_SENSITIVITY: return "ISO Sensitivity"; +- case V4L2_CID_ISO_SENSITIVITY_AUTO: return "ISO Sensitivity, Auto"; +- case V4L2_CID_EXPOSURE_METERING: return "Exposure, Metering Mode"; +- case V4L2_CID_SCENE_MODE: return "Scene Mode"; +- case V4L2_CID_3A_LOCK: return "3A Lock"; +- case V4L2_CID_AUTO_FOCUS_START: return "Auto Focus, Start"; +- case V4L2_CID_AUTO_FOCUS_STOP: return "Auto Focus, Stop"; +- case V4L2_CID_AUTO_FOCUS_STATUS: return "Auto Focus, Status"; +- case V4L2_CID_AUTO_FOCUS_RANGE: return "Auto Focus, Range"; +- case V4L2_CID_PAN_SPEED: return "Pan, Speed"; +- case V4L2_CID_TILT_SPEED: return "Tilt, Speed"; +- case V4L2_CID_UNIT_CELL_SIZE: return "Unit Cell Size"; +- case V4L2_CID_CAMERA_ORIENTATION: return "Camera Orientation"; +- case V4L2_CID_CAMERA_SENSOR_ROTATION: return "Camera Sensor Rotation"; +- +- /* FM Radio Modulator controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_FM_TX_CLASS: return "FM Radio Modulator Controls"; +- case V4L2_CID_RDS_TX_DEVIATION: return "RDS Signal Deviation"; +- case V4L2_CID_RDS_TX_PI: return "RDS Program ID"; +- case V4L2_CID_RDS_TX_PTY: return "RDS Program Type"; +- case V4L2_CID_RDS_TX_PS_NAME: return "RDS PS Name"; +- case V4L2_CID_RDS_TX_RADIO_TEXT: return "RDS Radio Text"; +- case V4L2_CID_RDS_TX_MONO_STEREO: return "RDS Stereo"; +- case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD: return "RDS Artificial Head"; +- case V4L2_CID_RDS_TX_COMPRESSED: return "RDS Compressed"; +- case V4L2_CID_RDS_TX_DYNAMIC_PTY: return "RDS Dynamic PTY"; +- case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement"; +- case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM: return "RDS Traffic Program"; +- case V4L2_CID_RDS_TX_MUSIC_SPEECH: return "RDS Music"; +- case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE: return "RDS Enable Alt Frequencies"; +- case V4L2_CID_RDS_TX_ALT_FREQS: return "RDS Alternate Frequencies"; +- case V4L2_CID_AUDIO_LIMITER_ENABLED: return "Audio Limiter Feature Enabled"; +- case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time"; +- case V4L2_CID_AUDIO_LIMITER_DEVIATION: return "Audio Limiter Deviation"; +- case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Enabled"; +- case V4L2_CID_AUDIO_COMPRESSION_GAIN: return "Audio Compression Gain"; +- case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold"; +- case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time"; +- case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time"; +- case V4L2_CID_PILOT_TONE_ENABLED: return "Pilot Tone Feature Enabled"; +- case V4L2_CID_PILOT_TONE_DEVIATION: return "Pilot Tone Deviation"; +- case V4L2_CID_PILOT_TONE_FREQUENCY: return "Pilot Tone Frequency"; +- case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-Emphasis"; +- case V4L2_CID_TUNE_POWER_LEVEL: return "Tune Power Level"; +- case V4L2_CID_TUNE_ANTENNA_CAPACITOR: return "Tune Antenna Capacitor"; +- +- /* Flash controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_FLASH_CLASS: return "Flash Controls"; +- case V4L2_CID_FLASH_LED_MODE: return "LED Mode"; +- case V4L2_CID_FLASH_STROBE_SOURCE: return "Strobe Source"; +- case V4L2_CID_FLASH_STROBE: return "Strobe"; +- case V4L2_CID_FLASH_STROBE_STOP: return "Stop Strobe"; +- case V4L2_CID_FLASH_STROBE_STATUS: return "Strobe Status"; +- case V4L2_CID_FLASH_TIMEOUT: return "Strobe Timeout"; +- case V4L2_CID_FLASH_INTENSITY: return "Intensity, Flash Mode"; +- case V4L2_CID_FLASH_TORCH_INTENSITY: return "Intensity, Torch Mode"; +- case V4L2_CID_FLASH_INDICATOR_INTENSITY: return "Intensity, Indicator"; +- case V4L2_CID_FLASH_FAULT: return "Faults"; +- case V4L2_CID_FLASH_CHARGE: return "Charge"; +- case V4L2_CID_FLASH_READY: return "Ready to Strobe"; +- +- /* JPEG encoder controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_JPEG_CLASS: return "JPEG Compression Controls"; +- case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: return "Chroma Subsampling"; +- case V4L2_CID_JPEG_RESTART_INTERVAL: return "Restart Interval"; +- case V4L2_CID_JPEG_COMPRESSION_QUALITY: return "Compression Quality"; +- case V4L2_CID_JPEG_ACTIVE_MARKER: return "Active Markers"; +- +- /* Image source controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_IMAGE_SOURCE_CLASS: return "Image Source Controls"; +- case V4L2_CID_VBLANK: return "Vertical Blanking"; +- case V4L2_CID_HBLANK: return "Horizontal Blanking"; +- case V4L2_CID_ANALOGUE_GAIN: return "Analogue Gain"; +- case V4L2_CID_TEST_PATTERN_RED: return "Red Pixel Value"; +- case V4L2_CID_TEST_PATTERN_GREENR: return "Green (Red) Pixel Value"; +- case V4L2_CID_TEST_PATTERN_BLUE: return "Blue Pixel Value"; +- case V4L2_CID_TEST_PATTERN_GREENB: return "Green (Blue) Pixel Value"; +- +- /* Image processing controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_IMAGE_PROC_CLASS: return "Image Processing Controls"; +- case V4L2_CID_LINK_FREQ: return "Link Frequency"; +- case V4L2_CID_PIXEL_RATE: return "Pixel Rate"; +- case V4L2_CID_TEST_PATTERN: return "Test Pattern"; +- case V4L2_CID_DEINTERLACING_MODE: return "Deinterlacing Mode"; +- case V4L2_CID_DIGITAL_GAIN: return "Digital Gain"; +- +- /* DV controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_DV_CLASS: return "Digital Video Controls"; +- case V4L2_CID_DV_TX_HOTPLUG: return "Hotplug Present"; +- case V4L2_CID_DV_TX_RXSENSE: return "RxSense Present"; +- case V4L2_CID_DV_TX_EDID_PRESENT: return "EDID Present"; +- case V4L2_CID_DV_TX_MODE: return "Transmit Mode"; +- case V4L2_CID_DV_TX_RGB_RANGE: return "Tx RGB Quantization Range"; +- case V4L2_CID_DV_TX_IT_CONTENT_TYPE: return "Tx IT Content Type"; +- case V4L2_CID_DV_RX_POWER_PRESENT: return "Power Present"; +- case V4L2_CID_DV_RX_RGB_RANGE: return "Rx RGB Quantization Range"; +- case V4L2_CID_DV_RX_IT_CONTENT_TYPE: return "Rx IT Content Type"; +- +- case V4L2_CID_FM_RX_CLASS: return "FM Radio Receiver Controls"; +- case V4L2_CID_TUNE_DEEMPHASIS: return "De-Emphasis"; +- case V4L2_CID_RDS_RECEPTION: return "RDS Reception"; +- case V4L2_CID_RF_TUNER_CLASS: return "RF Tuner Controls"; +- case V4L2_CID_RF_TUNER_RF_GAIN: return "RF Gain"; +- case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO: return "LNA Gain, Auto"; +- case V4L2_CID_RF_TUNER_LNA_GAIN: return "LNA Gain"; +- case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO: return "Mixer Gain, Auto"; +- case V4L2_CID_RF_TUNER_MIXER_GAIN: return "Mixer Gain"; +- case V4L2_CID_RF_TUNER_IF_GAIN_AUTO: return "IF Gain, Auto"; +- case V4L2_CID_RF_TUNER_IF_GAIN: return "IF Gain"; +- case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO: return "Bandwidth, Auto"; +- case V4L2_CID_RF_TUNER_BANDWIDTH: return "Bandwidth"; +- case V4L2_CID_RF_TUNER_PLL_LOCK: return "PLL Lock"; +- case V4L2_CID_RDS_RX_PTY: return "RDS Program Type"; +- case V4L2_CID_RDS_RX_PS_NAME: return "RDS PS Name"; +- case V4L2_CID_RDS_RX_RADIO_TEXT: return "RDS Radio Text"; +- case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT: return "RDS Traffic Announcement"; +- case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM: return "RDS Traffic Program"; +- case V4L2_CID_RDS_RX_MUSIC_SPEECH: return "RDS Music"; +- +- /* Detection controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_DETECT_CLASS: return "Detection Controls"; +- case V4L2_CID_DETECT_MD_MODE: return "Motion Detection Mode"; +- case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD: return "MD Global Threshold"; +- case V4L2_CID_DETECT_MD_THRESHOLD_GRID: return "MD Threshold Grid"; +- case V4L2_CID_DETECT_MD_REGION_GRID: return "MD Region Grid"; +- +- /* Stateless Codec controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_CODEC_STATELESS_CLASS: return "Stateless Codec Controls"; +- case V4L2_CID_STATELESS_H264_DECODE_MODE: return "H264 Decode Mode"; +- case V4L2_CID_STATELESS_H264_START_CODE: return "H264 Start Code"; +- case V4L2_CID_STATELESS_H264_SPS: return "H264 Sequence Parameter Set"; +- case V4L2_CID_STATELESS_H264_PPS: return "H264 Picture Parameter Set"; +- case V4L2_CID_STATELESS_H264_SCALING_MATRIX: return "H264 Scaling Matrix"; +- case V4L2_CID_STATELESS_H264_PRED_WEIGHTS: return "H264 Prediction Weight Table"; +- case V4L2_CID_STATELESS_H264_SLICE_PARAMS: return "H264 Slice Parameters"; +- case V4L2_CID_STATELESS_H264_DECODE_PARAMS: return "H264 Decode Parameters"; +- case V4L2_CID_STATELESS_FWHT_PARAMS: return "FWHT Stateless Parameters"; +- case V4L2_CID_STATELESS_VP8_FRAME: return "VP8 Frame Parameters"; +- +- /* Colorimetry controls */ +- /* Keep the order of the 'case's the same as in v4l2-controls.h! */ +- case V4L2_CID_COLORIMETRY_CLASS: return "Colorimetry Controls"; +- case V4L2_CID_COLORIMETRY_HDR10_CLL_INFO: return "HDR10 Content Light Info"; +- case V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY: return "HDR10 Mastering Display"; +- default: +- return NULL; +- } +-} +-EXPORT_SYMBOL(v4l2_ctrl_get_name); +- +-void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, +- s64 *min, s64 *max, u64 *step, s64 *def, u32 *flags) +-{ +- *name = v4l2_ctrl_get_name(id); +- *flags = 0; +- +- switch (id) { +- case V4L2_CID_AUDIO_MUTE: +- case V4L2_CID_AUDIO_LOUDNESS: +- case V4L2_CID_AUTO_WHITE_BALANCE: +- case V4L2_CID_AUTOGAIN: +- case V4L2_CID_HFLIP: +- case V4L2_CID_VFLIP: +- case V4L2_CID_HUE_AUTO: +- case V4L2_CID_CHROMA_AGC: +- case V4L2_CID_COLOR_KILLER: +- case V4L2_CID_AUTOBRIGHTNESS: +- case V4L2_CID_MPEG_AUDIO_MUTE: +- case V4L2_CID_MPEG_VIDEO_MUTE: +- case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: +- case V4L2_CID_MPEG_VIDEO_PULLDOWN: +- case V4L2_CID_EXPOSURE_AUTO_PRIORITY: +- case V4L2_CID_FOCUS_AUTO: +- case V4L2_CID_PRIVACY: +- case V4L2_CID_AUDIO_LIMITER_ENABLED: +- case V4L2_CID_AUDIO_COMPRESSION_ENABLED: +- case V4L2_CID_PILOT_TONE_ENABLED: +- case V4L2_CID_ILLUMINATORS_1: +- case V4L2_CID_ILLUMINATORS_2: +- case V4L2_CID_FLASH_STROBE_STATUS: +- case V4L2_CID_FLASH_CHARGE: +- case V4L2_CID_FLASH_READY: +- case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER: +- case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE: +- case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE: +- case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE: +- case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE: +- case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM: +- case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE: +- case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL: +- case V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER: +- case V4L2_CID_MPEG_VIDEO_AU_DELIMITER: +- case V4L2_CID_WIDE_DYNAMIC_RANGE: +- case V4L2_CID_IMAGE_STABILIZATION: +- case V4L2_CID_RDS_RECEPTION: +- case V4L2_CID_RF_TUNER_LNA_GAIN_AUTO: +- case V4L2_CID_RF_TUNER_MIXER_GAIN_AUTO: +- case V4L2_CID_RF_TUNER_IF_GAIN_AUTO: +- case V4L2_CID_RF_TUNER_BANDWIDTH_AUTO: +- case V4L2_CID_RF_TUNER_PLL_LOCK: +- case V4L2_CID_RDS_TX_MONO_STEREO: +- case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD: +- case V4L2_CID_RDS_TX_COMPRESSED: +- case V4L2_CID_RDS_TX_DYNAMIC_PTY: +- case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT: +- case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM: +- case V4L2_CID_RDS_TX_MUSIC_SPEECH: +- case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE: +- case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT: +- case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM: +- case V4L2_CID_RDS_RX_MUSIC_SPEECH: +- *type = V4L2_CTRL_TYPE_BOOLEAN; +- *min = 0; +- *max = *step = 1; +- break; +- case V4L2_CID_ROTATE: +- *type = V4L2_CTRL_TYPE_INTEGER; +- *flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; +- break; +- case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE: +- case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE: +- case V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY: +- *type = V4L2_CTRL_TYPE_INTEGER; +- break; +- case V4L2_CID_MPEG_VIDEO_LTR_COUNT: +- *type = V4L2_CTRL_TYPE_INTEGER; +- break; +- case V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX: +- *type = V4L2_CTRL_TYPE_INTEGER; +- *flags |= V4L2_CTRL_FLAG_EXECUTE_ON_WRITE; +- break; +- case V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES: +- *type = V4L2_CTRL_TYPE_BITMASK; +- *flags |= V4L2_CTRL_FLAG_EXECUTE_ON_WRITE; +- break; +- case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME: +- case V4L2_CID_PAN_RESET: +- case V4L2_CID_TILT_RESET: +- case V4L2_CID_FLASH_STROBE: +- case V4L2_CID_FLASH_STROBE_STOP: +- case V4L2_CID_AUTO_FOCUS_START: +- case V4L2_CID_AUTO_FOCUS_STOP: +- case V4L2_CID_DO_WHITE_BALANCE: +- *type = V4L2_CTRL_TYPE_BUTTON; +- *flags |= V4L2_CTRL_FLAG_WRITE_ONLY | +- V4L2_CTRL_FLAG_EXECUTE_ON_WRITE; +- *min = *max = *step = *def = 0; +- break; +- case V4L2_CID_POWER_LINE_FREQUENCY: +- case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: +- case V4L2_CID_MPEG_AUDIO_ENCODING: +- case V4L2_CID_MPEG_AUDIO_L1_BITRATE: +- case V4L2_CID_MPEG_AUDIO_L2_BITRATE: +- case V4L2_CID_MPEG_AUDIO_L3_BITRATE: +- case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: +- case V4L2_CID_MPEG_AUDIO_MODE: +- case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: +- case V4L2_CID_MPEG_AUDIO_EMPHASIS: +- case V4L2_CID_MPEG_AUDIO_CRC: +- case V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK: +- case V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK: +- case V4L2_CID_MPEG_VIDEO_ENCODING: +- case V4L2_CID_MPEG_VIDEO_ASPECT: +- case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: +- case V4L2_CID_MPEG_STREAM_TYPE: +- case V4L2_CID_MPEG_STREAM_VBI_FMT: +- case V4L2_CID_EXPOSURE_AUTO: +- case V4L2_CID_AUTO_FOCUS_RANGE: +- case V4L2_CID_COLORFX: +- case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: +- case V4L2_CID_TUNE_PREEMPHASIS: +- case V4L2_CID_FLASH_LED_MODE: +- case V4L2_CID_FLASH_STROBE_SOURCE: +- case V4L2_CID_MPEG_VIDEO_HEADER_MODE: +- case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE: +- case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: +- case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE: +- case V4L2_CID_MPEG_VIDEO_H264_LEVEL: +- case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE: +- case V4L2_CID_MPEG_VIDEO_H264_PROFILE: +- case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC: +- case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE: +- case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE: +- case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE: +- case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL: +- case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE: +- case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL: +- case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE: +- case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: +- case V4L2_CID_ISO_SENSITIVITY_AUTO: +- case V4L2_CID_EXPOSURE_METERING: +- case V4L2_CID_SCENE_MODE: +- case V4L2_CID_DV_TX_MODE: +- case V4L2_CID_DV_TX_RGB_RANGE: +- case V4L2_CID_DV_TX_IT_CONTENT_TYPE: +- case V4L2_CID_DV_RX_RGB_RANGE: +- case V4L2_CID_DV_RX_IT_CONTENT_TYPE: +- case V4L2_CID_TEST_PATTERN: +- case V4L2_CID_DEINTERLACING_MODE: +- case V4L2_CID_TUNE_DEEMPHASIS: +- case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL: +- case V4L2_CID_MPEG_VIDEO_VP8_PROFILE: +- case V4L2_CID_MPEG_VIDEO_VP9_PROFILE: +- case V4L2_CID_MPEG_VIDEO_VP9_LEVEL: +- case V4L2_CID_DETECT_MD_MODE: +- case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE: +- case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL: +- case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE: +- case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE: +- case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD: +- case V4L2_CID_MPEG_VIDEO_HEVC_TIER: +- case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE: +- case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE: +- case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE: +- case V4L2_CID_STATELESS_H264_DECODE_MODE: +- case V4L2_CID_STATELESS_H264_START_CODE: +- case V4L2_CID_CAMERA_ORIENTATION: +- *type = V4L2_CTRL_TYPE_MENU; +- break; +- case V4L2_CID_LINK_FREQ: +- *type = V4L2_CTRL_TYPE_INTEGER_MENU; +- break; +- case V4L2_CID_RDS_TX_PS_NAME: +- case V4L2_CID_RDS_TX_RADIO_TEXT: +- case V4L2_CID_RDS_RX_PS_NAME: +- case V4L2_CID_RDS_RX_RADIO_TEXT: +- *type = V4L2_CTRL_TYPE_STRING; +- break; +- case V4L2_CID_ISO_SENSITIVITY: +- case V4L2_CID_AUTO_EXPOSURE_BIAS: +- case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS: +- case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES: +- *type = V4L2_CTRL_TYPE_INTEGER_MENU; +- break; +- case V4L2_CID_USER_CLASS: +- case V4L2_CID_CAMERA_CLASS: +- case V4L2_CID_CODEC_CLASS: +- case V4L2_CID_FM_TX_CLASS: +- case V4L2_CID_FLASH_CLASS: +- case V4L2_CID_JPEG_CLASS: +- case V4L2_CID_IMAGE_SOURCE_CLASS: +- case V4L2_CID_IMAGE_PROC_CLASS: +- case V4L2_CID_DV_CLASS: +- case V4L2_CID_FM_RX_CLASS: +- case V4L2_CID_RF_TUNER_CLASS: +- case V4L2_CID_DETECT_CLASS: +- case V4L2_CID_CODEC_STATELESS_CLASS: +- case V4L2_CID_COLORIMETRY_CLASS: +- *type = V4L2_CTRL_TYPE_CTRL_CLASS; +- /* You can neither read nor write these */ +- *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY; +- *min = *max = *step = *def = 0; +- break; +- case V4L2_CID_BG_COLOR: +- *type = V4L2_CTRL_TYPE_INTEGER; +- *step = 1; +- *min = 0; +- /* Max is calculated as RGB888 that is 2^24 */ +- *max = 0xFFFFFF; +- break; +- case V4L2_CID_FLASH_FAULT: +- case V4L2_CID_JPEG_ACTIVE_MARKER: +- case V4L2_CID_3A_LOCK: +- case V4L2_CID_AUTO_FOCUS_STATUS: +- case V4L2_CID_DV_TX_HOTPLUG: +- case V4L2_CID_DV_TX_RXSENSE: +- case V4L2_CID_DV_TX_EDID_PRESENT: +- case V4L2_CID_DV_RX_POWER_PRESENT: +- *type = V4L2_CTRL_TYPE_BITMASK; +- break; +- case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE: +- case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT: +- *type = V4L2_CTRL_TYPE_INTEGER; +- *flags |= V4L2_CTRL_FLAG_READ_ONLY; +- break; +- case V4L2_CID_MPEG_VIDEO_DEC_PTS: +- *type = V4L2_CTRL_TYPE_INTEGER64; +- *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY; +- *min = *def = 0; +- *max = 0x1ffffffffLL; +- *step = 1; +- break; +- case V4L2_CID_MPEG_VIDEO_DEC_FRAME: +- *type = V4L2_CTRL_TYPE_INTEGER64; +- *flags |= V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY; +- *min = *def = 0; +- *max = 0x7fffffffffffffffLL; +- *step = 1; +- break; +- case V4L2_CID_MPEG_VIDEO_DEC_CONCEAL_COLOR: +- *type = V4L2_CTRL_TYPE_INTEGER64; +- *min = 0; +- /* default for 8 bit black, luma is 16, chroma is 128 */ +- *def = 0x8000800010LL; +- *max = 0xffffffffffffLL; +- *step = 1; +- break; +- case V4L2_CID_PIXEL_RATE: +- *type = V4L2_CTRL_TYPE_INTEGER64; +- *flags |= V4L2_CTRL_FLAG_READ_ONLY; +- break; +- case V4L2_CID_DETECT_MD_REGION_GRID: +- *type = V4L2_CTRL_TYPE_U8; +- break; +- case V4L2_CID_DETECT_MD_THRESHOLD_GRID: +- *type = V4L2_CTRL_TYPE_U16; +- break; +- case V4L2_CID_RDS_TX_ALT_FREQS: +- *type = V4L2_CTRL_TYPE_U32; +- break; +- case V4L2_CID_MPEG_VIDEO_MPEG2_SLICE_PARAMS: +- *type = V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS; +- break; +- case V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION: +- *type = V4L2_CTRL_TYPE_MPEG2_QUANTIZATION; +- break; +- case V4L2_CID_STATELESS_FWHT_PARAMS: +- *type = V4L2_CTRL_TYPE_FWHT_PARAMS; +- break; +- case V4L2_CID_STATELESS_H264_SPS: +- *type = V4L2_CTRL_TYPE_H264_SPS; +- break; +- case V4L2_CID_STATELESS_H264_PPS: +- *type = V4L2_CTRL_TYPE_H264_PPS; +- break; +- case V4L2_CID_STATELESS_H264_SCALING_MATRIX: +- *type = V4L2_CTRL_TYPE_H264_SCALING_MATRIX; +- break; +- case V4L2_CID_STATELESS_H264_SLICE_PARAMS: +- *type = V4L2_CTRL_TYPE_H264_SLICE_PARAMS; +- break; +- case V4L2_CID_STATELESS_H264_DECODE_PARAMS: +- *type = V4L2_CTRL_TYPE_H264_DECODE_PARAMS; +- break; +- case V4L2_CID_STATELESS_H264_PRED_WEIGHTS: +- *type = V4L2_CTRL_TYPE_H264_PRED_WEIGHTS; +- break; +- case V4L2_CID_STATELESS_VP8_FRAME: +- *type = V4L2_CTRL_TYPE_VP8_FRAME; +- break; +- case V4L2_CID_MPEG_VIDEO_HEVC_SPS: +- *type = V4L2_CTRL_TYPE_HEVC_SPS; +- break; +- case V4L2_CID_MPEG_VIDEO_HEVC_PPS: +- *type = V4L2_CTRL_TYPE_HEVC_PPS; +- break; +- case V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS: +- *type = V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS; +- break; +- case V4L2_CID_MPEG_VIDEO_HEVC_SCALING_MATRIX: +- *type = V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX; +- break; +- case V4L2_CID_UNIT_CELL_SIZE: +- *type = V4L2_CTRL_TYPE_AREA; +- *flags |= V4L2_CTRL_FLAG_READ_ONLY; +- break; +- case V4L2_CID_COLORIMETRY_HDR10_CLL_INFO: +- *type = V4L2_CTRL_TYPE_HDR10_CLL_INFO; +- break; +- case V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY: +- *type = V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY; +- break; +- default: +- *type = V4L2_CTRL_TYPE_INTEGER; +- break; +- } +- switch (id) { +- case V4L2_CID_MPEG_AUDIO_ENCODING: +- case V4L2_CID_MPEG_AUDIO_MODE: +- case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: +- case V4L2_CID_MPEG_VIDEO_B_FRAMES: +- case V4L2_CID_MPEG_STREAM_TYPE: +- *flags |= V4L2_CTRL_FLAG_UPDATE; +- break; +- case V4L2_CID_AUDIO_VOLUME: +- case V4L2_CID_AUDIO_BALANCE: +- case V4L2_CID_AUDIO_BASS: +- case V4L2_CID_AUDIO_TREBLE: +- case V4L2_CID_BRIGHTNESS: +- case V4L2_CID_CONTRAST: +- case V4L2_CID_SATURATION: +- case V4L2_CID_HUE: +- case V4L2_CID_RED_BALANCE: +- case V4L2_CID_BLUE_BALANCE: +- case V4L2_CID_GAMMA: +- case V4L2_CID_SHARPNESS: +- case V4L2_CID_CHROMA_GAIN: +- case V4L2_CID_RDS_TX_DEVIATION: +- case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: +- case V4L2_CID_AUDIO_LIMITER_DEVIATION: +- case V4L2_CID_AUDIO_COMPRESSION_GAIN: +- case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: +- case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: +- case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: +- case V4L2_CID_PILOT_TONE_DEVIATION: +- case V4L2_CID_PILOT_TONE_FREQUENCY: +- case V4L2_CID_TUNE_POWER_LEVEL: +- case V4L2_CID_TUNE_ANTENNA_CAPACITOR: +- case V4L2_CID_RF_TUNER_RF_GAIN: +- case V4L2_CID_RF_TUNER_LNA_GAIN: +- case V4L2_CID_RF_TUNER_MIXER_GAIN: +- case V4L2_CID_RF_TUNER_IF_GAIN: +- case V4L2_CID_RF_TUNER_BANDWIDTH: +- case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD: +- *flags |= V4L2_CTRL_FLAG_SLIDER; +- break; +- case V4L2_CID_PAN_RELATIVE: +- case V4L2_CID_TILT_RELATIVE: +- case V4L2_CID_FOCUS_RELATIVE: +- case V4L2_CID_IRIS_RELATIVE: +- case V4L2_CID_ZOOM_RELATIVE: +- *flags |= V4L2_CTRL_FLAG_WRITE_ONLY | +- V4L2_CTRL_FLAG_EXECUTE_ON_WRITE; +- break; +- case V4L2_CID_FLASH_STROBE_STATUS: +- case V4L2_CID_AUTO_FOCUS_STATUS: +- case V4L2_CID_FLASH_READY: +- case V4L2_CID_DV_TX_HOTPLUG: +- case V4L2_CID_DV_TX_RXSENSE: +- case V4L2_CID_DV_TX_EDID_PRESENT: +- case V4L2_CID_DV_RX_POWER_PRESENT: +- case V4L2_CID_DV_RX_IT_CONTENT_TYPE: +- case V4L2_CID_RDS_RX_PTY: +- case V4L2_CID_RDS_RX_PS_NAME: +- case V4L2_CID_RDS_RX_RADIO_TEXT: +- case V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT: +- case V4L2_CID_RDS_RX_TRAFFIC_PROGRAM: +- case V4L2_CID_RDS_RX_MUSIC_SPEECH: +- case V4L2_CID_CAMERA_ORIENTATION: +- case V4L2_CID_CAMERA_SENSOR_ROTATION: +- *flags |= V4L2_CTRL_FLAG_READ_ONLY; +- break; +- case V4L2_CID_RF_TUNER_PLL_LOCK: +- *flags |= V4L2_CTRL_FLAG_VOLATILE; +- break; +- } +-} +-EXPORT_SYMBOL(v4l2_ctrl_fill); +- +-static u32 user_flags(const struct v4l2_ctrl *ctrl) +-{ +- u32 flags = ctrl->flags; +- +- if (ctrl->is_ptr) +- flags |= V4L2_CTRL_FLAG_HAS_PAYLOAD; +- +- return flags; +-} +- +-static void fill_event(struct v4l2_event *ev, struct v4l2_ctrl *ctrl, u32 changes) +-{ +- memset(ev, 0, sizeof(*ev)); +- ev->type = V4L2_EVENT_CTRL; +- ev->id = ctrl->id; +- ev->u.ctrl.changes = changes; +- ev->u.ctrl.type = ctrl->type; +- ev->u.ctrl.flags = user_flags(ctrl); +- if (ctrl->is_ptr) +- ev->u.ctrl.value64 = 0; +- else +- ev->u.ctrl.value64 = *ctrl->p_cur.p_s64; +- ev->u.ctrl.minimum = ctrl->minimum; +- ev->u.ctrl.maximum = ctrl->maximum; +- if (ctrl->type == V4L2_CTRL_TYPE_MENU +- || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU) +- ev->u.ctrl.step = 1; +- else +- ev->u.ctrl.step = ctrl->step; +- ev->u.ctrl.default_value = ctrl->default_value; +-} +- +-static void send_event(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 changes) +-{ +- struct v4l2_event ev; +- struct v4l2_subscribed_event *sev; +- +- if (list_empty(&ctrl->ev_subs)) +- return; +- fill_event(&ev, ctrl, changes); +- +- list_for_each_entry(sev, &ctrl->ev_subs, node) +- if (sev->fh != fh || +- (sev->flags & V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK)) +- v4l2_event_queue_fh(sev->fh, &ev); +-} +- +-static bool std_equal(const struct v4l2_ctrl *ctrl, u32 idx, +- union v4l2_ctrl_ptr ptr1, +- union v4l2_ctrl_ptr ptr2) +-{ +- switch (ctrl->type) { +- case V4L2_CTRL_TYPE_BUTTON: +- return false; +- case V4L2_CTRL_TYPE_STRING: +- idx *= ctrl->elem_size; +- /* strings are always 0-terminated */ +- return !strcmp(ptr1.p_char + idx, ptr2.p_char + idx); +- case V4L2_CTRL_TYPE_INTEGER64: +- return ptr1.p_s64[idx] == ptr2.p_s64[idx]; +- case V4L2_CTRL_TYPE_U8: +- return ptr1.p_u8[idx] == ptr2.p_u8[idx]; +- case V4L2_CTRL_TYPE_U16: +- return ptr1.p_u16[idx] == ptr2.p_u16[idx]; +- case V4L2_CTRL_TYPE_U32: +- return ptr1.p_u32[idx] == ptr2.p_u32[idx]; +- default: +- if (ctrl->is_int) +- return ptr1.p_s32[idx] == ptr2.p_s32[idx]; +- idx *= ctrl->elem_size; +- return !memcmp(ptr1.p_const + idx, ptr2.p_const + idx, +- ctrl->elem_size); +- } +-} +- +-static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx, +- union v4l2_ctrl_ptr ptr) +-{ +- struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params; +- struct v4l2_ctrl_vp8_frame *p_vp8_frame; +- struct v4l2_ctrl_fwht_params *p_fwht_params; +- void *p = ptr.p + idx * ctrl->elem_size; +- +- if (ctrl->p_def.p_const) +- memcpy(p, ctrl->p_def.p_const, ctrl->elem_size); +- else +- memset(p, 0, ctrl->elem_size); +- +- /* +- * The cast is needed to get rid of a gcc warning complaining that +- * V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS is not part of the +- * v4l2_ctrl_type enum. +- */ +- switch ((u32)ctrl->type) { +- case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS: +- p_mpeg2_slice_params = p; +- /* 4:2:0 */ +- p_mpeg2_slice_params->sequence.chroma_format = 1; +- /* interlaced top field */ +- p_mpeg2_slice_params->picture.picture_structure = 1; +- p_mpeg2_slice_params->picture.picture_coding_type = +- V4L2_MPEG2_PICTURE_CODING_TYPE_I; +- break; +- case V4L2_CTRL_TYPE_VP8_FRAME: +- p_vp8_frame = p; +- p_vp8_frame->num_dct_parts = 1; +- break; +- case V4L2_CTRL_TYPE_FWHT_PARAMS: +- p_fwht_params = p; +- p_fwht_params->version = V4L2_FWHT_VERSION; +- p_fwht_params->width = 1280; +- p_fwht_params->height = 720; +- p_fwht_params->flags = V4L2_FWHT_FL_PIXENC_YUV | +- (2 << V4L2_FWHT_FL_COMPONENTS_NUM_OFFSET); +- break; +- } +-} +- +-static void std_init(const struct v4l2_ctrl *ctrl, u32 idx, +- union v4l2_ctrl_ptr ptr) +-{ +- switch (ctrl->type) { +- case V4L2_CTRL_TYPE_STRING: +- idx *= ctrl->elem_size; +- memset(ptr.p_char + idx, ' ', ctrl->minimum); +- ptr.p_char[idx + ctrl->minimum] = '\0'; +- break; +- case V4L2_CTRL_TYPE_INTEGER64: +- ptr.p_s64[idx] = ctrl->default_value; +- break; +- case V4L2_CTRL_TYPE_INTEGER: +- case V4L2_CTRL_TYPE_INTEGER_MENU: +- case V4L2_CTRL_TYPE_MENU: +- case V4L2_CTRL_TYPE_BITMASK: +- case V4L2_CTRL_TYPE_BOOLEAN: +- ptr.p_s32[idx] = ctrl->default_value; +- break; +- case V4L2_CTRL_TYPE_BUTTON: +- case V4L2_CTRL_TYPE_CTRL_CLASS: +- ptr.p_s32[idx] = 0; +- break; +- case V4L2_CTRL_TYPE_U8: +- ptr.p_u8[idx] = ctrl->default_value; +- break; +- case V4L2_CTRL_TYPE_U16: +- ptr.p_u16[idx] = ctrl->default_value; +- break; +- case V4L2_CTRL_TYPE_U32: +- ptr.p_u32[idx] = ctrl->default_value; +- break; +- default: +- std_init_compound(ctrl, idx, ptr); +- break; +- } +-} +- +-static void std_log(const struct v4l2_ctrl *ctrl) +-{ +- union v4l2_ctrl_ptr ptr = ctrl->p_cur; +- +- if (ctrl->is_array) { +- unsigned i; +- +- for (i = 0; i < ctrl->nr_of_dims; i++) +- pr_cont("[%u]", ctrl->dims[i]); +- pr_cont(" "); +- } +- +- switch (ctrl->type) { +- case V4L2_CTRL_TYPE_INTEGER: +- pr_cont("%d", *ptr.p_s32); +- break; +- case V4L2_CTRL_TYPE_BOOLEAN: +- pr_cont("%s", *ptr.p_s32 ? "true" : "false"); +- break; +- case V4L2_CTRL_TYPE_MENU: +- pr_cont("%s", ctrl->qmenu[*ptr.p_s32]); +- break; +- case V4L2_CTRL_TYPE_INTEGER_MENU: +- pr_cont("%lld", ctrl->qmenu_int[*ptr.p_s32]); +- break; +- case V4L2_CTRL_TYPE_BITMASK: +- pr_cont("0x%08x", *ptr.p_s32); +- break; +- case V4L2_CTRL_TYPE_INTEGER64: +- pr_cont("%lld", *ptr.p_s64); +- break; +- case V4L2_CTRL_TYPE_STRING: +- pr_cont("%s", ptr.p_char); +- break; +- case V4L2_CTRL_TYPE_U8: +- pr_cont("%u", (unsigned)*ptr.p_u8); +- break; +- case V4L2_CTRL_TYPE_U16: +- pr_cont("%u", (unsigned)*ptr.p_u16); +- break; +- case V4L2_CTRL_TYPE_U32: +- pr_cont("%u", (unsigned)*ptr.p_u32); +- break; +- case V4L2_CTRL_TYPE_H264_SPS: +- pr_cont("H264_SPS"); +- break; +- case V4L2_CTRL_TYPE_H264_PPS: +- pr_cont("H264_PPS"); +- break; +- case V4L2_CTRL_TYPE_H264_SCALING_MATRIX: +- pr_cont("H264_SCALING_MATRIX"); +- break; +- case V4L2_CTRL_TYPE_H264_SLICE_PARAMS: +- pr_cont("H264_SLICE_PARAMS"); +- break; +- case V4L2_CTRL_TYPE_H264_DECODE_PARAMS: +- pr_cont("H264_DECODE_PARAMS"); +- break; +- case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS: +- pr_cont("H264_PRED_WEIGHTS"); +- break; +- case V4L2_CTRL_TYPE_FWHT_PARAMS: +- pr_cont("FWHT_PARAMS"); +- break; +- case V4L2_CTRL_TYPE_VP8_FRAME: +- pr_cont("VP8_FRAME"); +- break; +- case V4L2_CTRL_TYPE_HDR10_CLL_INFO: +- pr_cont("HDR10_CLL_INFO"); +- break; +- case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY: +- pr_cont("HDR10_MASTERING_DISPLAY"); +- break; +- default: +- pr_cont("unknown type %d", ctrl->type); +- break; +- } +-} +- +-/* +- * Round towards the closest legal value. Be careful when we are +- * close to the maximum range of the control type to prevent +- * wrap-arounds. +- */ +-#define ROUND_TO_RANGE(val, offset_type, ctrl) \ +-({ \ +- offset_type offset; \ +- if ((ctrl)->maximum >= 0 && \ +- val >= (ctrl)->maximum - (s32)((ctrl)->step / 2)) \ +- val = (ctrl)->maximum; \ +- else \ +- val += (s32)((ctrl)->step / 2); \ +- val = clamp_t(typeof(val), val, \ +- (ctrl)->minimum, (ctrl)->maximum); \ +- offset = (val) - (ctrl)->minimum; \ +- offset = (ctrl)->step * (offset / (u32)(ctrl)->step); \ +- val = (ctrl)->minimum + offset; \ +- 0; \ +-}) +- +-/* Validate a new control */ +- +-#define zero_padding(s) \ +- memset(&(s).padding, 0, sizeof((s).padding)) +-#define zero_reserved(s) \ +- memset(&(s).reserved, 0, sizeof((s).reserved)) +- +-/* +- * Compound controls validation requires setting unused fields/flags to zero +- * in order to properly detect unchanged controls with std_equal's memcmp. +- */ +-static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx, +- union v4l2_ctrl_ptr ptr) +-{ +- struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params; +- struct v4l2_ctrl_vp8_frame *p_vp8_frame; +- struct v4l2_ctrl_fwht_params *p_fwht_params; +- struct v4l2_ctrl_h264_sps *p_h264_sps; +- struct v4l2_ctrl_h264_pps *p_h264_pps; +- struct v4l2_ctrl_h264_pred_weights *p_h264_pred_weights; +- struct v4l2_ctrl_h264_slice_params *p_h264_slice_params; +- struct v4l2_ctrl_h264_decode_params *p_h264_dec_params; +- struct v4l2_ctrl_hevc_sps *p_hevc_sps; +- struct v4l2_ctrl_hevc_pps *p_hevc_pps; +- struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; +- struct v4l2_ctrl_hdr10_mastering_display *p_hdr10_mastering; +- struct v4l2_area *area; +- void *p = ptr.p + idx * ctrl->elem_size; +- unsigned int i; +- +- switch ((u32)ctrl->type) { +- case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS: +- p_mpeg2_slice_params = p; +- +- switch (p_mpeg2_slice_params->sequence.chroma_format) { +- case 1: /* 4:2:0 */ +- case 2: /* 4:2:2 */ +- case 3: /* 4:4:4 */ +- break; +- default: +- return -EINVAL; +- } +- +- switch (p_mpeg2_slice_params->picture.intra_dc_precision) { +- case 0: /* 8 bits */ +- case 1: /* 9 bits */ +- case 2: /* 10 bits */ +- case 3: /* 11 bits */ +- break; +- default: +- return -EINVAL; +- } +- +- switch (p_mpeg2_slice_params->picture.picture_structure) { +- case 1: /* interlaced top field */ +- case 2: /* interlaced bottom field */ +- case 3: /* progressive */ +- break; +- default: +- return -EINVAL; +- } +- +- switch (p_mpeg2_slice_params->picture.picture_coding_type) { +- case V4L2_MPEG2_PICTURE_CODING_TYPE_I: +- case V4L2_MPEG2_PICTURE_CODING_TYPE_P: +- case V4L2_MPEG2_PICTURE_CODING_TYPE_B: +- break; +- default: +- return -EINVAL; +- } +- +- break; +- +- case V4L2_CTRL_TYPE_MPEG2_QUANTIZATION: +- break; +- +- case V4L2_CTRL_TYPE_FWHT_PARAMS: +- p_fwht_params = p; +- if (p_fwht_params->version < V4L2_FWHT_VERSION) +- return -EINVAL; +- if (!p_fwht_params->width || !p_fwht_params->height) +- return -EINVAL; +- break; +- +- case V4L2_CTRL_TYPE_H264_SPS: +- p_h264_sps = p; +- +- /* Some syntax elements are only conditionally valid */ +- if (p_h264_sps->pic_order_cnt_type != 0) { +- p_h264_sps->log2_max_pic_order_cnt_lsb_minus4 = 0; +- } else if (p_h264_sps->pic_order_cnt_type != 1) { +- p_h264_sps->num_ref_frames_in_pic_order_cnt_cycle = 0; +- p_h264_sps->offset_for_non_ref_pic = 0; +- p_h264_sps->offset_for_top_to_bottom_field = 0; +- memset(&p_h264_sps->offset_for_ref_frame, 0, +- sizeof(p_h264_sps->offset_for_ref_frame)); +- } +- +- if (!V4L2_H264_SPS_HAS_CHROMA_FORMAT(p_h264_sps)) { +- p_h264_sps->chroma_format_idc = 1; +- p_h264_sps->bit_depth_luma_minus8 = 0; +- p_h264_sps->bit_depth_chroma_minus8 = 0; +- +- p_h264_sps->flags &= +- ~V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS; +- +- if (p_h264_sps->chroma_format_idc < 3) +- p_h264_sps->flags &= +- ~V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE; +- } +- +- if (p_h264_sps->flags & V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY) +- p_h264_sps->flags &= +- ~V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD; +- +- /* +- * Chroma 4:2:2 format require at least High 4:2:2 profile. +- * +- * The H264 specification and well-known parser implementations +- * use profile-idc values directly, as that is clearer and +- * less ambiguous. We do the same here. +- */ +- if (p_h264_sps->profile_idc < 122 && +- p_h264_sps->chroma_format_idc > 1) +- return -EINVAL; +- /* Chroma 4:4:4 format require at least High 4:2:2 profile */ +- if (p_h264_sps->profile_idc < 244 && +- p_h264_sps->chroma_format_idc > 2) +- return -EINVAL; +- if (p_h264_sps->chroma_format_idc > 3) +- return -EINVAL; +- +- if (p_h264_sps->bit_depth_luma_minus8 > 6) +- return -EINVAL; +- if (p_h264_sps->bit_depth_chroma_minus8 > 6) +- return -EINVAL; +- if (p_h264_sps->log2_max_frame_num_minus4 > 12) +- return -EINVAL; +- if (p_h264_sps->pic_order_cnt_type > 2) +- return -EINVAL; +- if (p_h264_sps->log2_max_pic_order_cnt_lsb_minus4 > 12) +- return -EINVAL; +- if (p_h264_sps->max_num_ref_frames > V4L2_H264_REF_LIST_LEN) +- return -EINVAL; +- break; +- +- case V4L2_CTRL_TYPE_H264_PPS: +- p_h264_pps = p; +- +- if (p_h264_pps->num_slice_groups_minus1 > 7) +- return -EINVAL; +- if (p_h264_pps->num_ref_idx_l0_default_active_minus1 > +- (V4L2_H264_REF_LIST_LEN - 1)) +- return -EINVAL; +- if (p_h264_pps->num_ref_idx_l1_default_active_minus1 > +- (V4L2_H264_REF_LIST_LEN - 1)) +- return -EINVAL; +- if (p_h264_pps->weighted_bipred_idc > 2) +- return -EINVAL; +- /* +- * pic_init_qp_minus26 shall be in the range of +- * -(26 + QpBdOffset_y) to +25, inclusive, +- * where QpBdOffset_y is 6 * bit_depth_luma_minus8 +- */ +- if (p_h264_pps->pic_init_qp_minus26 < -62 || +- p_h264_pps->pic_init_qp_minus26 > 25) +- return -EINVAL; +- if (p_h264_pps->pic_init_qs_minus26 < -26 || +- p_h264_pps->pic_init_qs_minus26 > 25) +- return -EINVAL; +- if (p_h264_pps->chroma_qp_index_offset < -12 || +- p_h264_pps->chroma_qp_index_offset > 12) +- return -EINVAL; +- if (p_h264_pps->second_chroma_qp_index_offset < -12 || +- p_h264_pps->second_chroma_qp_index_offset > 12) +- return -EINVAL; +- break; +- +- case V4L2_CTRL_TYPE_H264_SCALING_MATRIX: +- break; +- +- case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS: +- p_h264_pred_weights = p; +- +- if (p_h264_pred_weights->luma_log2_weight_denom > 7) +- return -EINVAL; +- if (p_h264_pred_weights->chroma_log2_weight_denom > 7) +- return -EINVAL; +- break; +- +- case V4L2_CTRL_TYPE_H264_SLICE_PARAMS: +- p_h264_slice_params = p; +- +- if (p_h264_slice_params->slice_type != V4L2_H264_SLICE_TYPE_B) +- p_h264_slice_params->flags &= +- ~V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED; +- +- if (p_h264_slice_params->colour_plane_id > 2) +- return -EINVAL; +- if (p_h264_slice_params->cabac_init_idc > 2) +- return -EINVAL; +- if (p_h264_slice_params->disable_deblocking_filter_idc > 2) +- return -EINVAL; +- if (p_h264_slice_params->slice_alpha_c0_offset_div2 < -6 || +- p_h264_slice_params->slice_alpha_c0_offset_div2 > 6) +- return -EINVAL; +- if (p_h264_slice_params->slice_beta_offset_div2 < -6 || +- p_h264_slice_params->slice_beta_offset_div2 > 6) +- return -EINVAL; +- +- if (p_h264_slice_params->slice_type == V4L2_H264_SLICE_TYPE_I || +- p_h264_slice_params->slice_type == V4L2_H264_SLICE_TYPE_SI) +- p_h264_slice_params->num_ref_idx_l0_active_minus1 = 0; +- if (p_h264_slice_params->slice_type != V4L2_H264_SLICE_TYPE_B) +- p_h264_slice_params->num_ref_idx_l1_active_minus1 = 0; +- +- if (p_h264_slice_params->num_ref_idx_l0_active_minus1 > +- (V4L2_H264_REF_LIST_LEN - 1)) +- return -EINVAL; +- if (p_h264_slice_params->num_ref_idx_l1_active_minus1 > +- (V4L2_H264_REF_LIST_LEN - 1)) +- return -EINVAL; +- zero_reserved(*p_h264_slice_params); +- break; +- +- case V4L2_CTRL_TYPE_H264_DECODE_PARAMS: +- p_h264_dec_params = p; +- +- if (p_h264_dec_params->nal_ref_idc > 3) +- return -EINVAL; +- for (i = 0; i < V4L2_H264_NUM_DPB_ENTRIES; i++) { +- struct v4l2_h264_dpb_entry *dpb_entry = +- &p_h264_dec_params->dpb[i]; +- +- zero_reserved(*dpb_entry); +- } +- zero_reserved(*p_h264_dec_params); +- break; +- +- case V4L2_CTRL_TYPE_VP8_FRAME: +- p_vp8_frame = p; +- +- switch (p_vp8_frame->num_dct_parts) { +- case 1: +- case 2: +- case 4: +- case 8: +- break; +- default: +- return -EINVAL; +- } +- zero_padding(p_vp8_frame->segment); +- zero_padding(p_vp8_frame->lf); +- zero_padding(p_vp8_frame->quant); +- zero_padding(p_vp8_frame->entropy); +- zero_padding(p_vp8_frame->coder_state); +- break; +- +- case V4L2_CTRL_TYPE_HEVC_SPS: +- p_hevc_sps = p; +- +- if (!(p_hevc_sps->flags & V4L2_HEVC_SPS_FLAG_PCM_ENABLED)) { +- p_hevc_sps->pcm_sample_bit_depth_luma_minus1 = 0; +- p_hevc_sps->pcm_sample_bit_depth_chroma_minus1 = 0; +- p_hevc_sps->log2_min_pcm_luma_coding_block_size_minus3 = 0; +- p_hevc_sps->log2_diff_max_min_pcm_luma_coding_block_size = 0; +- } +- +- if (!(p_hevc_sps->flags & +- V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT)) +- p_hevc_sps->num_long_term_ref_pics_sps = 0; +- break; +- +- case V4L2_CTRL_TYPE_HEVC_PPS: +- p_hevc_pps = p; +- +- if (!(p_hevc_pps->flags & +- V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED)) +- p_hevc_pps->diff_cu_qp_delta_depth = 0; +- +- if (!(p_hevc_pps->flags & V4L2_HEVC_PPS_FLAG_TILES_ENABLED)) { +- p_hevc_pps->num_tile_columns_minus1 = 0; +- p_hevc_pps->num_tile_rows_minus1 = 0; +- memset(&p_hevc_pps->column_width_minus1, 0, +- sizeof(p_hevc_pps->column_width_minus1)); +- memset(&p_hevc_pps->row_height_minus1, 0, +- sizeof(p_hevc_pps->row_height_minus1)); +- +- p_hevc_pps->flags &= +- ~V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED; +- } +- +- if (p_hevc_pps->flags & +- V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER) { +- p_hevc_pps->pps_beta_offset_div2 = 0; +- p_hevc_pps->pps_tc_offset_div2 = 0; +- } +- +- zero_padding(*p_hevc_pps); +- break; +- +- case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS: +- p_hevc_slice_params = p; +- +- if (p_hevc_slice_params->num_active_dpb_entries > +- V4L2_HEVC_DPB_ENTRIES_NUM_MAX) +- return -EINVAL; +- +- zero_padding(p_hevc_slice_params->pred_weight_table); +- +- for (i = 0; i < p_hevc_slice_params->num_active_dpb_entries; +- i++) { +- struct v4l2_hevc_dpb_entry *dpb_entry = +- &p_hevc_slice_params->dpb[i]; +- +- zero_padding(*dpb_entry); +- } +- +- zero_padding(*p_hevc_slice_params); +- break; +- +- case V4L2_CTRL_TYPE_HDR10_CLL_INFO: +- break; +- +- case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY: +- p_hdr10_mastering = p; +- +- for (i = 0; i < 3; ++i) { +- if (p_hdr10_mastering->display_primaries_x[i] < +- V4L2_HDR10_MASTERING_PRIMARIES_X_LOW || +- p_hdr10_mastering->display_primaries_x[i] > +- V4L2_HDR10_MASTERING_PRIMARIES_X_HIGH || +- p_hdr10_mastering->display_primaries_y[i] < +- V4L2_HDR10_MASTERING_PRIMARIES_Y_LOW || +- p_hdr10_mastering->display_primaries_y[i] > +- V4L2_HDR10_MASTERING_PRIMARIES_Y_HIGH) +- return -EINVAL; +- } +- +- if (p_hdr10_mastering->white_point_x < +- V4L2_HDR10_MASTERING_WHITE_POINT_X_LOW || +- p_hdr10_mastering->white_point_x > +- V4L2_HDR10_MASTERING_WHITE_POINT_X_HIGH || +- p_hdr10_mastering->white_point_y < +- V4L2_HDR10_MASTERING_WHITE_POINT_Y_LOW || +- p_hdr10_mastering->white_point_y > +- V4L2_HDR10_MASTERING_WHITE_POINT_Y_HIGH) +- return -EINVAL; +- +- if (p_hdr10_mastering->max_display_mastering_luminance < +- V4L2_HDR10_MASTERING_MAX_LUMA_LOW || +- p_hdr10_mastering->max_display_mastering_luminance > +- V4L2_HDR10_MASTERING_MAX_LUMA_HIGH || +- p_hdr10_mastering->min_display_mastering_luminance < +- V4L2_HDR10_MASTERING_MIN_LUMA_LOW || +- p_hdr10_mastering->min_display_mastering_luminance > +- V4L2_HDR10_MASTERING_MIN_LUMA_HIGH) +- return -EINVAL; +- +- /* The following restriction comes from ITU-T Rec. H.265 spec */ +- if (p_hdr10_mastering->max_display_mastering_luminance == +- V4L2_HDR10_MASTERING_MAX_LUMA_LOW && +- p_hdr10_mastering->min_display_mastering_luminance == +- V4L2_HDR10_MASTERING_MIN_LUMA_HIGH) +- return -EINVAL; +- +- break; +- +- case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX: +- break; +- +- case V4L2_CTRL_TYPE_AREA: +- area = p; +- if (!area->width || !area->height) +- return -EINVAL; +- break; +- +- default: +- return -EINVAL; +- } +- +- return 0; +-} +- +-static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx, +- union v4l2_ctrl_ptr ptr) +-{ +- size_t len; +- u64 offset; +- s64 val; +- +- switch ((u32)ctrl->type) { +- case V4L2_CTRL_TYPE_INTEGER: +- return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl); +- case V4L2_CTRL_TYPE_INTEGER64: +- /* +- * We can't use the ROUND_TO_RANGE define here due to +- * the u64 divide that needs special care. +- */ +- val = ptr.p_s64[idx]; +- if (ctrl->maximum >= 0 && val >= ctrl->maximum - (s64)(ctrl->step / 2)) +- val = ctrl->maximum; +- else +- val += (s64)(ctrl->step / 2); +- val = clamp_t(s64, val, ctrl->minimum, ctrl->maximum); +- offset = val - ctrl->minimum; +- do_div(offset, ctrl->step); +- ptr.p_s64[idx] = ctrl->minimum + offset * ctrl->step; +- return 0; +- case V4L2_CTRL_TYPE_U8: +- return ROUND_TO_RANGE(ptr.p_u8[idx], u8, ctrl); +- case V4L2_CTRL_TYPE_U16: +- return ROUND_TO_RANGE(ptr.p_u16[idx], u16, ctrl); +- case V4L2_CTRL_TYPE_U32: +- return ROUND_TO_RANGE(ptr.p_u32[idx], u32, ctrl); +- +- case V4L2_CTRL_TYPE_BOOLEAN: +- ptr.p_s32[idx] = !!ptr.p_s32[idx]; +- return 0; +- +- case V4L2_CTRL_TYPE_MENU: +- case V4L2_CTRL_TYPE_INTEGER_MENU: +- if (ptr.p_s32[idx] < ctrl->minimum || ptr.p_s32[idx] > ctrl->maximum) +- return -ERANGE; +- if (ptr.p_s32[idx] < BITS_PER_LONG_LONG && +- (ctrl->menu_skip_mask & BIT_ULL(ptr.p_s32[idx]))) +- return -EINVAL; +- if (ctrl->type == V4L2_CTRL_TYPE_MENU && +- ctrl->qmenu[ptr.p_s32[idx]][0] == '\0') +- return -EINVAL; +- return 0; +- +- case V4L2_CTRL_TYPE_BITMASK: +- ptr.p_s32[idx] &= ctrl->maximum; +- return 0; +- +- case V4L2_CTRL_TYPE_BUTTON: +- case V4L2_CTRL_TYPE_CTRL_CLASS: +- ptr.p_s32[idx] = 0; +- return 0; +- +- case V4L2_CTRL_TYPE_STRING: +- idx *= ctrl->elem_size; +- len = strlen(ptr.p_char + idx); +- if (len < ctrl->minimum) +- return -ERANGE; +- if ((len - (u32)ctrl->minimum) % (u32)ctrl->step) +- return -ERANGE; +- return 0; +- +- default: +- return std_validate_compound(ctrl, idx, ptr); +- } +-} +- +-static const struct v4l2_ctrl_type_ops std_type_ops = { +- .equal = std_equal, +- .init = std_init, +- .log = std_log, +- .validate = std_validate, +-}; +- +-/* Helper function: copy the given control value back to the caller */ +-static int ptr_to_user(struct v4l2_ext_control *c, +- struct v4l2_ctrl *ctrl, +- union v4l2_ctrl_ptr ptr) +-{ +- u32 len; +- +- if (ctrl->is_ptr && !ctrl->is_string) +- return copy_to_user(c->ptr, ptr.p_const, c->size) ? +- -EFAULT : 0; +- +- switch (ctrl->type) { +- case V4L2_CTRL_TYPE_STRING: +- len = strlen(ptr.p_char); +- if (c->size < len + 1) { +- c->size = ctrl->elem_size; +- return -ENOSPC; +- } +- return copy_to_user(c->string, ptr.p_char, len + 1) ? +- -EFAULT : 0; +- case V4L2_CTRL_TYPE_INTEGER64: +- c->value64 = *ptr.p_s64; +- break; +- default: +- c->value = *ptr.p_s32; +- break; +- } +- return 0; +-} +- +-/* Helper function: copy the current control value back to the caller */ +-static int cur_to_user(struct v4l2_ext_control *c, +- struct v4l2_ctrl *ctrl) +-{ +- return ptr_to_user(c, ctrl, ctrl->p_cur); +-} +- +-/* Helper function: copy the new control value back to the caller */ +-static int new_to_user(struct v4l2_ext_control *c, +- struct v4l2_ctrl *ctrl) +-{ +- return ptr_to_user(c, ctrl, ctrl->p_new); +-} +- +-/* Helper function: copy the request value back to the caller */ +-static int req_to_user(struct v4l2_ext_control *c, +- struct v4l2_ctrl_ref *ref) +-{ +- return ptr_to_user(c, ref->ctrl, ref->p_req); +-} +- +-/* Helper function: copy the initial control value back to the caller */ +-static int def_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl) +-{ +- int idx; +- +- for (idx = 0; idx < ctrl->elems; idx++) +- ctrl->type_ops->init(ctrl, idx, ctrl->p_new); +- +- return ptr_to_user(c, ctrl, ctrl->p_new); +-} +- +-/* Helper function: copy the caller-provider value to the given control value */ +-static int user_to_ptr(struct v4l2_ext_control *c, +- struct v4l2_ctrl *ctrl, +- union v4l2_ctrl_ptr ptr) +-{ +- int ret; +- u32 size; +- +- ctrl->is_new = 1; +- if (ctrl->is_ptr && !ctrl->is_string) { +- unsigned idx; +- +- ret = copy_from_user(ptr.p, c->ptr, c->size) ? -EFAULT : 0; +- if (ret || !ctrl->is_array) +- return ret; +- for (idx = c->size / ctrl->elem_size; idx < ctrl->elems; idx++) +- ctrl->type_ops->init(ctrl, idx, ptr); +- return 0; +- } +- +- switch (ctrl->type) { +- case V4L2_CTRL_TYPE_INTEGER64: +- *ptr.p_s64 = c->value64; +- break; +- case V4L2_CTRL_TYPE_STRING: +- size = c->size; +- if (size == 0) +- return -ERANGE; +- if (size > ctrl->maximum + 1) +- size = ctrl->maximum + 1; +- ret = copy_from_user(ptr.p_char, c->string, size) ? -EFAULT : 0; +- if (!ret) { +- char last = ptr.p_char[size - 1]; +- +- ptr.p_char[size - 1] = 0; +- /* If the string was longer than ctrl->maximum, +- then return an error. */ +- if (strlen(ptr.p_char) == ctrl->maximum && last) +- return -ERANGE; +- } +- return ret; +- default: +- *ptr.p_s32 = c->value; +- break; +- } +- return 0; +-} +- +-/* Helper function: copy the caller-provider value as the new control value */ +-static int user_to_new(struct v4l2_ext_control *c, +- struct v4l2_ctrl *ctrl) +-{ +- return user_to_ptr(c, ctrl, ctrl->p_new); +-} +- +-/* Copy the one value to another. */ +-static void ptr_to_ptr(struct v4l2_ctrl *ctrl, +- union v4l2_ctrl_ptr from, union v4l2_ctrl_ptr to) +-{ +- if (ctrl == NULL) +- return; +- memcpy(to.p, from.p_const, ctrl->elems * ctrl->elem_size); +-} +- +-/* Copy the new value to the current value. */ +-static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags) +-{ +- bool changed; +- +- if (ctrl == NULL) +- return; +- +- /* has_changed is set by cluster_changed */ +- changed = ctrl->has_changed; +- if (changed) +- ptr_to_ptr(ctrl, ctrl->p_new, ctrl->p_cur); +- +- if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) { +- /* Note: CH_FLAGS is only set for auto clusters. */ +- ctrl->flags &= +- ~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE); +- if (!is_cur_manual(ctrl->cluster[0])) { +- ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE; +- if (ctrl->cluster[0]->has_volatiles) +- ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE; +- } +- fh = NULL; +- } +- if (changed || ch_flags) { +- /* If a control was changed that was not one of the controls +- modified by the application, then send the event to all. */ +- if (!ctrl->is_new) +- fh = NULL; +- send_event(fh, ctrl, +- (changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags); +- if (ctrl->call_notify && changed && ctrl->handler->notify) +- ctrl->handler->notify(ctrl, ctrl->handler->notify_priv); +- } +-} +- +-/* Copy the current value to the new value */ +-static void cur_to_new(struct v4l2_ctrl *ctrl) +-{ +- if (ctrl == NULL) +- return; +- ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new); +-} +- +-/* Copy the new value to the request value */ +-static void new_to_req(struct v4l2_ctrl_ref *ref) +-{ +- if (!ref) +- return; +- ptr_to_ptr(ref->ctrl, ref->ctrl->p_new, ref->p_req); +- ref->valid_p_req = true; +-} +- +-/* Copy the current value to the request value */ +-static void cur_to_req(struct v4l2_ctrl_ref *ref) +-{ +- if (!ref) +- return; +- ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->p_req); +- ref->valid_p_req = true; +-} +- +-/* Copy the request value to the new value */ +-static void req_to_new(struct v4l2_ctrl_ref *ref) +-{ +- if (!ref) +- return; +- if (ref->valid_p_req) +- ptr_to_ptr(ref->ctrl, ref->p_req, ref->ctrl->p_new); +- else +- ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->ctrl->p_new); +-} +- +-/* Return non-zero if one or more of the controls in the cluster has a new +- value that differs from the current value. */ +-static int cluster_changed(struct v4l2_ctrl *master) +-{ +- bool changed = false; +- unsigned idx; +- int i; +- +- for (i = 0; i < master->ncontrols; i++) { +- struct v4l2_ctrl *ctrl = master->cluster[i]; +- bool ctrl_changed = false; +- +- if (ctrl == NULL) +- continue; +- +- if (ctrl->flags & V4L2_CTRL_FLAG_EXECUTE_ON_WRITE) +- changed = ctrl_changed = true; +- +- /* +- * Set has_changed to false to avoid generating +- * the event V4L2_EVENT_CTRL_CH_VALUE +- */ +- if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) { +- ctrl->has_changed = false; +- continue; +- } +- +- for (idx = 0; !ctrl_changed && idx < ctrl->elems; idx++) +- ctrl_changed = !ctrl->type_ops->equal(ctrl, idx, +- ctrl->p_cur, ctrl->p_new); +- ctrl->has_changed = ctrl_changed; +- changed |= ctrl->has_changed; +- } +- return changed; +-} +- +-/* Control range checking */ +-static int check_range(enum v4l2_ctrl_type type, +- s64 min, s64 max, u64 step, s64 def) +-{ +- switch (type) { +- case V4L2_CTRL_TYPE_BOOLEAN: +- if (step != 1 || max > 1 || min < 0) +- return -ERANGE; +- fallthrough; +- case V4L2_CTRL_TYPE_U8: +- case V4L2_CTRL_TYPE_U16: +- case V4L2_CTRL_TYPE_U32: +- case V4L2_CTRL_TYPE_INTEGER: +- case V4L2_CTRL_TYPE_INTEGER64: +- if (step == 0 || min > max || def < min || def > max) +- return -ERANGE; +- return 0; +- case V4L2_CTRL_TYPE_BITMASK: +- if (step || min || !max || (def & ~max)) +- return -ERANGE; +- return 0; +- case V4L2_CTRL_TYPE_MENU: +- case V4L2_CTRL_TYPE_INTEGER_MENU: +- if (min > max || def < min || def > max) +- return -ERANGE; +- /* Note: step == menu_skip_mask for menu controls. +- So here we check if the default value is masked out. */ +- if (step && ((1 << def) & step)) +- return -EINVAL; +- return 0; +- case V4L2_CTRL_TYPE_STRING: +- if (min > max || min < 0 || step < 1 || def) +- return -ERANGE; +- return 0; +- default: +- return 0; +- } +-} +- +-/* Validate a new control */ +-static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new) +-{ +- unsigned idx; +- int err = 0; +- +- for (idx = 0; !err && idx < ctrl->elems; idx++) +- err = ctrl->type_ops->validate(ctrl, idx, p_new); +- return err; +-} +- +-static inline u32 node2id(struct list_head *node) +-{ +- return list_entry(node, struct v4l2_ctrl_ref, node)->ctrl->id; +-} +- +-/* Set the handler's error code if it wasn't set earlier already */ +-static inline int handler_set_err(struct v4l2_ctrl_handler *hdl, int err) +-{ +- if (hdl->error == 0) +- hdl->error = err; +- return err; +-} +- +-/* Initialize the handler */ +-int v4l2_ctrl_handler_init_class(struct v4l2_ctrl_handler *hdl, +- unsigned nr_of_controls_hint, +- struct lock_class_key *key, const char *name) +-{ +- mutex_init(&hdl->_lock); +- hdl->lock = &hdl->_lock; +- lockdep_set_class_and_name(hdl->lock, key, name); +- INIT_LIST_HEAD(&hdl->ctrls); +- INIT_LIST_HEAD(&hdl->ctrl_refs); +- INIT_LIST_HEAD(&hdl->requests); +- INIT_LIST_HEAD(&hdl->requests_queued); +- hdl->request_is_queued = false; +- hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8; +- hdl->buckets = kvmalloc_array(hdl->nr_of_buckets, +- sizeof(hdl->buckets[0]), +- GFP_KERNEL | __GFP_ZERO); +- hdl->error = hdl->buckets ? 0 : -ENOMEM; +- media_request_object_init(&hdl->req_obj); +- return hdl->error; +-} +-EXPORT_SYMBOL(v4l2_ctrl_handler_init_class); +- +-/* Free all controls and control refs */ +-void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl) +-{ +- struct v4l2_ctrl_ref *ref, *next_ref; +- struct v4l2_ctrl *ctrl, *next_ctrl; +- struct v4l2_subscribed_event *sev, *next_sev; +- +- if (hdl == NULL || hdl->buckets == NULL) +- return; +- +- /* +- * If the main handler is freed and it is used by handler objects in +- * outstanding requests, then unbind and put those objects before +- * freeing the main handler. +- * +- * The main handler can be identified by having a NULL ops pointer in +- * the request object. +- */ +- if (!hdl->req_obj.ops && !list_empty(&hdl->requests)) { +- struct v4l2_ctrl_handler *req, *next_req; +- +- list_for_each_entry_safe(req, next_req, &hdl->requests, requests) { +- media_request_object_unbind(&req->req_obj); +- media_request_object_put(&req->req_obj); +- } +- } +- mutex_lock(hdl->lock); +- /* Free all nodes */ +- list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) { +- list_del(&ref->node); +- kfree(ref); +- } +- /* Free all controls owned by the handler */ +- list_for_each_entry_safe(ctrl, next_ctrl, &hdl->ctrls, node) { +- list_del(&ctrl->node); +- list_for_each_entry_safe(sev, next_sev, &ctrl->ev_subs, node) +- list_del(&sev->node); +- kvfree(ctrl); +- } +- kvfree(hdl->buckets); +- hdl->buckets = NULL; +- hdl->cached = NULL; +- hdl->error = 0; +- mutex_unlock(hdl->lock); +- mutex_destroy(&hdl->_lock); +-} +-EXPORT_SYMBOL(v4l2_ctrl_handler_free); +- +-/* For backwards compatibility: V4L2_CID_PRIVATE_BASE should no longer +- be used except in G_CTRL, S_CTRL, QUERYCTRL and QUERYMENU when dealing +- with applications that do not use the NEXT_CTRL flag. +- +- We just find the n-th private user control. It's O(N), but that should not +- be an issue in this particular case. */ +-static struct v4l2_ctrl_ref *find_private_ref( +- struct v4l2_ctrl_handler *hdl, u32 id) +-{ +- struct v4l2_ctrl_ref *ref; +- +- id -= V4L2_CID_PRIVATE_BASE; +- list_for_each_entry(ref, &hdl->ctrl_refs, node) { +- /* Search for private user controls that are compatible with +- VIDIOC_G/S_CTRL. */ +- if (V4L2_CTRL_ID2WHICH(ref->ctrl->id) == V4L2_CTRL_CLASS_USER && +- V4L2_CTRL_DRIVER_PRIV(ref->ctrl->id)) { +- if (!ref->ctrl->is_int) +- continue; +- if (id == 0) +- return ref; +- id--; +- } +- } +- return NULL; +-} +- +-/* Find a control with the given ID. */ +-static struct v4l2_ctrl_ref *find_ref(struct v4l2_ctrl_handler *hdl, u32 id) +-{ +- struct v4l2_ctrl_ref *ref; +- int bucket; +- +- id &= V4L2_CTRL_ID_MASK; +- +- /* Old-style private controls need special handling */ +- if (id >= V4L2_CID_PRIVATE_BASE) +- return find_private_ref(hdl, id); +- bucket = id % hdl->nr_of_buckets; +- +- /* Simple optimization: cache the last control found */ +- if (hdl->cached && hdl->cached->ctrl->id == id) +- return hdl->cached; +- +- /* Not in cache, search the hash */ +- ref = hdl->buckets ? hdl->buckets[bucket] : NULL; +- while (ref && ref->ctrl->id != id) +- ref = ref->next; +- +- if (ref) +- hdl->cached = ref; /* cache it! */ +- return ref; +-} +- +-/* Find a control with the given ID. Take the handler's lock first. */ +-static struct v4l2_ctrl_ref *find_ref_lock( +- struct v4l2_ctrl_handler *hdl, u32 id) +-{ +- struct v4l2_ctrl_ref *ref = NULL; +- +- if (hdl) { +- mutex_lock(hdl->lock); +- ref = find_ref(hdl, id); +- mutex_unlock(hdl->lock); +- } +- return ref; +-} +- +-/* Find a control with the given ID. */ +-struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id) +-{ +- struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id); +- +- return ref ? ref->ctrl : NULL; +-} +-EXPORT_SYMBOL(v4l2_ctrl_find); +- +-/* Allocate a new v4l2_ctrl_ref and hook it into the handler. */ +-static int handler_new_ref(struct v4l2_ctrl_handler *hdl, +- struct v4l2_ctrl *ctrl, +- struct v4l2_ctrl_ref **ctrl_ref, +- bool from_other_dev, bool allocate_req) +-{ +- struct v4l2_ctrl_ref *ref; +- struct v4l2_ctrl_ref *new_ref; +- u32 id = ctrl->id; +- u32 class_ctrl = V4L2_CTRL_ID2WHICH(id) | 1; +- int bucket = id % hdl->nr_of_buckets; /* which bucket to use */ +- unsigned int size_extra_req = 0; +- +- if (ctrl_ref) +- *ctrl_ref = NULL; +- +- /* +- * Automatically add the control class if it is not yet present and +- * the new control is not a compound control. +- */ +- if (ctrl->type < V4L2_CTRL_COMPOUND_TYPES && +- id != class_ctrl && find_ref_lock(hdl, class_ctrl) == NULL) +- if (!v4l2_ctrl_new_std(hdl, NULL, class_ctrl, 0, 0, 0, 0)) +- return hdl->error; +- +- if (hdl->error) +- return hdl->error; +- +- if (allocate_req) +- size_extra_req = ctrl->elems * ctrl->elem_size; +- new_ref = kzalloc(sizeof(*new_ref) + size_extra_req, GFP_KERNEL); +- if (!new_ref) +- return handler_set_err(hdl, -ENOMEM); +- new_ref->ctrl = ctrl; +- new_ref->from_other_dev = from_other_dev; +- if (size_extra_req) +- new_ref->p_req.p = &new_ref[1]; +- +- INIT_LIST_HEAD(&new_ref->node); +- +- mutex_lock(hdl->lock); +- +- /* Add immediately at the end of the list if the list is empty, or if +- the last element in the list has a lower ID. +- This ensures that when elements are added in ascending order the +- insertion is an O(1) operation. */ +- if (list_empty(&hdl->ctrl_refs) || id > node2id(hdl->ctrl_refs.prev)) { +- list_add_tail(&new_ref->node, &hdl->ctrl_refs); +- goto insert_in_hash; +- } +- +- /* Find insert position in sorted list */ +- list_for_each_entry(ref, &hdl->ctrl_refs, node) { +- if (ref->ctrl->id < id) +- continue; +- /* Don't add duplicates */ +- if (ref->ctrl->id == id) { +- kfree(new_ref); +- goto unlock; +- } +- list_add(&new_ref->node, ref->node.prev); +- break; +- } +- +-insert_in_hash: +- /* Insert the control node in the hash */ +- new_ref->next = hdl->buckets[bucket]; +- hdl->buckets[bucket] = new_ref; +- if (ctrl_ref) +- *ctrl_ref = new_ref; +- if (ctrl->handler == hdl) { +- /* By default each control starts in a cluster of its own. +- * new_ref->ctrl is basically a cluster array with one +- * element, so that's perfect to use as the cluster pointer. +- * But only do this for the handler that owns the control. +- */ +- ctrl->cluster = &new_ref->ctrl; +- ctrl->ncontrols = 1; +- } +- +-unlock: +- mutex_unlock(hdl->lock); +- return 0; +-} +- +-/* Add a new control */ +-static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl, +- const struct v4l2_ctrl_ops *ops, +- const struct v4l2_ctrl_type_ops *type_ops, +- u32 id, const char *name, enum v4l2_ctrl_type type, +- s64 min, s64 max, u64 step, s64 def, +- const u32 dims[V4L2_CTRL_MAX_DIMS], u32 elem_size, +- u32 flags, const char * const *qmenu, +- const s64 *qmenu_int, const union v4l2_ctrl_ptr p_def, +- void *priv) +-{ +- struct v4l2_ctrl *ctrl; +- unsigned sz_extra; +- unsigned nr_of_dims = 0; +- unsigned elems = 1; +- bool is_array; +- unsigned tot_ctrl_size; +- unsigned idx; +- void *data; +- int err; +- +- if (hdl->error) +- return NULL; +- +- while (dims && dims[nr_of_dims]) { +- elems *= dims[nr_of_dims]; +- nr_of_dims++; +- if (nr_of_dims == V4L2_CTRL_MAX_DIMS) +- break; +- } +- is_array = nr_of_dims > 0; +- +- /* Prefill elem_size for all types handled by std_type_ops */ +- switch ((u32)type) { +- case V4L2_CTRL_TYPE_INTEGER64: +- elem_size = sizeof(s64); +- break; +- case V4L2_CTRL_TYPE_STRING: +- elem_size = max + 1; +- break; +- case V4L2_CTRL_TYPE_U8: +- elem_size = sizeof(u8); +- break; +- case V4L2_CTRL_TYPE_U16: +- elem_size = sizeof(u16); +- break; +- case V4L2_CTRL_TYPE_U32: +- elem_size = sizeof(u32); +- break; +- case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS: +- elem_size = sizeof(struct v4l2_ctrl_mpeg2_slice_params); +- break; +- case V4L2_CTRL_TYPE_MPEG2_QUANTIZATION: +- elem_size = sizeof(struct v4l2_ctrl_mpeg2_quantization); +- break; +- case V4L2_CTRL_TYPE_FWHT_PARAMS: +- elem_size = sizeof(struct v4l2_ctrl_fwht_params); +- break; +- case V4L2_CTRL_TYPE_H264_SPS: +- elem_size = sizeof(struct v4l2_ctrl_h264_sps); +- break; +- case V4L2_CTRL_TYPE_H264_PPS: +- elem_size = sizeof(struct v4l2_ctrl_h264_pps); +- break; +- case V4L2_CTRL_TYPE_H264_SCALING_MATRIX: +- elem_size = sizeof(struct v4l2_ctrl_h264_scaling_matrix); +- break; +- case V4L2_CTRL_TYPE_H264_SLICE_PARAMS: +- elem_size = sizeof(struct v4l2_ctrl_h264_slice_params); +- break; +- case V4L2_CTRL_TYPE_H264_DECODE_PARAMS: +- elem_size = sizeof(struct v4l2_ctrl_h264_decode_params); +- break; +- case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS: +- elem_size = sizeof(struct v4l2_ctrl_h264_pred_weights); +- break; +- case V4L2_CTRL_TYPE_VP8_FRAME: +- elem_size = sizeof(struct v4l2_ctrl_vp8_frame); +- break; +- case V4L2_CTRL_TYPE_HEVC_SPS: +- elem_size = sizeof(struct v4l2_ctrl_hevc_sps); +- break; +- case V4L2_CTRL_TYPE_HEVC_PPS: +- elem_size = sizeof(struct v4l2_ctrl_hevc_pps); +- break; +- case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS: +- elem_size = sizeof(struct v4l2_ctrl_hevc_slice_params); +- break; +- case V4L2_CTRL_TYPE_HDR10_CLL_INFO: +- elem_size = sizeof(struct v4l2_ctrl_hdr10_cll_info); +- break; +- case V4L2_CTRL_TYPE_HDR10_MASTERING_DISPLAY: +- elem_size = sizeof(struct v4l2_ctrl_hdr10_mastering_display); +- break; +- case V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX: +- elem_size = sizeof(struct v4l2_ctrl_hevc_scaling_matrix); +- break; +- case V4L2_CTRL_TYPE_AREA: +- elem_size = sizeof(struct v4l2_area); +- break; +- default: +- if (type < V4L2_CTRL_COMPOUND_TYPES) +- elem_size = sizeof(s32); +- break; +- } +- tot_ctrl_size = elem_size * elems; +- +- /* Sanity checks */ +- if (id == 0 || name == NULL || !elem_size || +- id >= V4L2_CID_PRIVATE_BASE || +- (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) || +- (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) { +- handler_set_err(hdl, -ERANGE); +- return NULL; +- } +- err = check_range(type, min, max, step, def); +- if (err) { +- handler_set_err(hdl, err); +- return NULL; +- } +- if (is_array && +- (type == V4L2_CTRL_TYPE_BUTTON || +- type == V4L2_CTRL_TYPE_CTRL_CLASS)) { +- handler_set_err(hdl, -EINVAL); +- return NULL; +- } +- +- sz_extra = 0; +- if (type == V4L2_CTRL_TYPE_BUTTON) +- flags |= V4L2_CTRL_FLAG_WRITE_ONLY | +- V4L2_CTRL_FLAG_EXECUTE_ON_WRITE; +- else if (type == V4L2_CTRL_TYPE_CTRL_CLASS) +- flags |= V4L2_CTRL_FLAG_READ_ONLY; +- else if (type == V4L2_CTRL_TYPE_INTEGER64 || +- type == V4L2_CTRL_TYPE_STRING || +- type >= V4L2_CTRL_COMPOUND_TYPES || +- is_array) +- sz_extra += 2 * tot_ctrl_size; +- +- if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const) +- sz_extra += elem_size; +- +- ctrl = kvzalloc(sizeof(*ctrl) + sz_extra, GFP_KERNEL); +- if (ctrl == NULL) { +- handler_set_err(hdl, -ENOMEM); +- return NULL; +- } +- +- INIT_LIST_HEAD(&ctrl->node); +- INIT_LIST_HEAD(&ctrl->ev_subs); +- ctrl->handler = hdl; +- ctrl->ops = ops; +- ctrl->type_ops = type_ops ? type_ops : &std_type_ops; +- ctrl->id = id; +- ctrl->name = name; +- ctrl->type = type; +- ctrl->flags = flags; +- ctrl->minimum = min; +- ctrl->maximum = max; +- ctrl->step = step; +- ctrl->default_value = def; +- ctrl->is_string = !is_array && type == V4L2_CTRL_TYPE_STRING; +- ctrl->is_ptr = is_array || type >= V4L2_CTRL_COMPOUND_TYPES || ctrl->is_string; +- ctrl->is_int = !ctrl->is_ptr && type != V4L2_CTRL_TYPE_INTEGER64; +- ctrl->is_array = is_array; +- ctrl->elems = elems; +- ctrl->nr_of_dims = nr_of_dims; +- if (nr_of_dims) +- memcpy(ctrl->dims, dims, nr_of_dims * sizeof(dims[0])); +- ctrl->elem_size = elem_size; +- if (type == V4L2_CTRL_TYPE_MENU) +- ctrl->qmenu = qmenu; +- else if (type == V4L2_CTRL_TYPE_INTEGER_MENU) +- ctrl->qmenu_int = qmenu_int; +- ctrl->priv = priv; +- ctrl->cur.val = ctrl->val = def; +- data = &ctrl[1]; +- +- if (!ctrl->is_int) { +- ctrl->p_new.p = data; +- ctrl->p_cur.p = data + tot_ctrl_size; +- } else { +- ctrl->p_new.p = &ctrl->val; +- ctrl->p_cur.p = &ctrl->cur.val; +- } +- +- if (type >= V4L2_CTRL_COMPOUND_TYPES && p_def.p_const) { +- ctrl->p_def.p = ctrl->p_cur.p + tot_ctrl_size; +- memcpy(ctrl->p_def.p, p_def.p_const, elem_size); +- } +- +- for (idx = 0; idx < elems; idx++) { +- ctrl->type_ops->init(ctrl, idx, ctrl->p_cur); +- ctrl->type_ops->init(ctrl, idx, ctrl->p_new); +- } +- +- if (handler_new_ref(hdl, ctrl, NULL, false, false)) { +- kvfree(ctrl); +- return NULL; +- } +- mutex_lock(hdl->lock); +- list_add_tail(&ctrl->node, &hdl->ctrls); +- mutex_unlock(hdl->lock); +- return ctrl; +-} +- +-struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl, +- const struct v4l2_ctrl_config *cfg, void *priv) +-{ +- bool is_menu; +- struct v4l2_ctrl *ctrl; +- const char *name = cfg->name; +- const char * const *qmenu = cfg->qmenu; +- const s64 *qmenu_int = cfg->qmenu_int; +- enum v4l2_ctrl_type type = cfg->type; +- u32 flags = cfg->flags; +- s64 min = cfg->min; +- s64 max = cfg->max; +- u64 step = cfg->step; +- s64 def = cfg->def; +- +- if (name == NULL) +- v4l2_ctrl_fill(cfg->id, &name, &type, &min, &max, &step, +- &def, &flags); +- +- is_menu = (type == V4L2_CTRL_TYPE_MENU || +- type == V4L2_CTRL_TYPE_INTEGER_MENU); +- if (is_menu) +- WARN_ON(step); +- else +- WARN_ON(cfg->menu_skip_mask); +- if (type == V4L2_CTRL_TYPE_MENU && !qmenu) { +- qmenu = v4l2_ctrl_get_menu(cfg->id); +- } else if (type == V4L2_CTRL_TYPE_INTEGER_MENU && !qmenu_int) { +- handler_set_err(hdl, -EINVAL); +- return NULL; +- } +- +- ctrl = v4l2_ctrl_new(hdl, cfg->ops, cfg->type_ops, cfg->id, name, +- type, min, max, +- is_menu ? cfg->menu_skip_mask : step, def, +- cfg->dims, cfg->elem_size, +- flags, qmenu, qmenu_int, cfg->p_def, priv); +- if (ctrl) +- ctrl->is_private = cfg->is_private; +- return ctrl; +-} +-EXPORT_SYMBOL(v4l2_ctrl_new_custom); +- +-/* Helper function for standard non-menu controls */ +-struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl, +- const struct v4l2_ctrl_ops *ops, +- u32 id, s64 min, s64 max, u64 step, s64 def) +-{ +- const char *name; +- enum v4l2_ctrl_type type; +- u32 flags; +- +- v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags); +- if (type == V4L2_CTRL_TYPE_MENU || +- type == V4L2_CTRL_TYPE_INTEGER_MENU || +- type >= V4L2_CTRL_COMPOUND_TYPES) { +- handler_set_err(hdl, -EINVAL); +- return NULL; +- } +- return v4l2_ctrl_new(hdl, ops, NULL, id, name, type, +- min, max, step, def, NULL, 0, +- flags, NULL, NULL, ptr_null, NULL); +-} +-EXPORT_SYMBOL(v4l2_ctrl_new_std); +- +-/* Helper function for standard menu controls */ +-struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl, +- const struct v4l2_ctrl_ops *ops, +- u32 id, u8 _max, u64 mask, u8 _def) +-{ +- const char * const *qmenu = NULL; +- const s64 *qmenu_int = NULL; +- unsigned int qmenu_int_len = 0; +- const char *name; +- enum v4l2_ctrl_type type; +- s64 min; +- s64 max = _max; +- s64 def = _def; +- u64 step; +- u32 flags; +- +- v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags); +- +- if (type == V4L2_CTRL_TYPE_MENU) +- qmenu = v4l2_ctrl_get_menu(id); +- else if (type == V4L2_CTRL_TYPE_INTEGER_MENU) +- qmenu_int = v4l2_ctrl_get_int_menu(id, &qmenu_int_len); +- +- if ((!qmenu && !qmenu_int) || (qmenu_int && max > qmenu_int_len)) { +- handler_set_err(hdl, -EINVAL); +- return NULL; +- } +- return v4l2_ctrl_new(hdl, ops, NULL, id, name, type, +- 0, max, mask, def, NULL, 0, +- flags, qmenu, qmenu_int, ptr_null, NULL); +-} +-EXPORT_SYMBOL(v4l2_ctrl_new_std_menu); +- +-/* Helper function for standard menu controls with driver defined menu */ +-struct v4l2_ctrl *v4l2_ctrl_new_std_menu_items(struct v4l2_ctrl_handler *hdl, +- const struct v4l2_ctrl_ops *ops, u32 id, u8 _max, +- u64 mask, u8 _def, const char * const *qmenu) +-{ +- enum v4l2_ctrl_type type; +- const char *name; +- u32 flags; +- u64 step; +- s64 min; +- s64 max = _max; +- s64 def = _def; +- +- /* v4l2_ctrl_new_std_menu_items() should only be called for +- * standard controls without a standard menu. +- */ +- if (v4l2_ctrl_get_menu(id)) { +- handler_set_err(hdl, -EINVAL); +- return NULL; +- } +- +- v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags); +- if (type != V4L2_CTRL_TYPE_MENU || qmenu == NULL) { +- handler_set_err(hdl, -EINVAL); +- return NULL; +- } +- return v4l2_ctrl_new(hdl, ops, NULL, id, name, type, +- 0, max, mask, def, NULL, 0, +- flags, qmenu, NULL, ptr_null, NULL); +- +-} +-EXPORT_SYMBOL(v4l2_ctrl_new_std_menu_items); +- +-/* Helper function for standard compound controls */ +-struct v4l2_ctrl *v4l2_ctrl_new_std_compound(struct v4l2_ctrl_handler *hdl, +- const struct v4l2_ctrl_ops *ops, u32 id, +- const union v4l2_ctrl_ptr p_def) +-{ +- const char *name; +- enum v4l2_ctrl_type type; +- u32 flags; +- s64 min, max, step, def; +- +- v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags); +- if (type < V4L2_CTRL_COMPOUND_TYPES) { +- handler_set_err(hdl, -EINVAL); +- return NULL; +- } +- return v4l2_ctrl_new(hdl, ops, NULL, id, name, type, +- min, max, step, def, NULL, 0, +- flags, NULL, NULL, p_def, NULL); +-} +-EXPORT_SYMBOL(v4l2_ctrl_new_std_compound); +- +-/* Helper function for standard integer menu controls */ +-struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl, +- const struct v4l2_ctrl_ops *ops, +- u32 id, u8 _max, u8 _def, const s64 *qmenu_int) +-{ +- const char *name; +- enum v4l2_ctrl_type type; +- s64 min; +- u64 step; +- s64 max = _max; +- s64 def = _def; +- u32 flags; +- +- v4l2_ctrl_fill(id, &name, &type, &min, &max, &step, &def, &flags); +- if (type != V4L2_CTRL_TYPE_INTEGER_MENU) { +- handler_set_err(hdl, -EINVAL); +- return NULL; +- } +- return v4l2_ctrl_new(hdl, ops, NULL, id, name, type, +- 0, max, 0, def, NULL, 0, +- flags, NULL, qmenu_int, ptr_null, NULL); +-} +-EXPORT_SYMBOL(v4l2_ctrl_new_int_menu); +- +-/* Add the controls from another handler to our own. */ +-int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl, +- struct v4l2_ctrl_handler *add, +- bool (*filter)(const struct v4l2_ctrl *ctrl), +- bool from_other_dev) +-{ +- struct v4l2_ctrl_ref *ref; +- int ret = 0; +- +- /* Do nothing if either handler is NULL or if they are the same */ +- if (!hdl || !add || hdl == add) +- return 0; +- if (hdl->error) +- return hdl->error; +- mutex_lock(add->lock); +- list_for_each_entry(ref, &add->ctrl_refs, node) { +- struct v4l2_ctrl *ctrl = ref->ctrl; +- +- /* Skip handler-private controls. */ +- if (ctrl->is_private) +- continue; +- /* And control classes */ +- if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS) +- continue; +- /* Filter any unwanted controls */ +- if (filter && !filter(ctrl)) +- continue; +- ret = handler_new_ref(hdl, ctrl, NULL, from_other_dev, false); +- if (ret) +- break; +- } +- mutex_unlock(add->lock); +- return ret; +-} +-EXPORT_SYMBOL(v4l2_ctrl_add_handler); +- +-bool v4l2_ctrl_radio_filter(const struct v4l2_ctrl *ctrl) +-{ +- if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_TX) +- return true; +- if (V4L2_CTRL_ID2WHICH(ctrl->id) == V4L2_CTRL_CLASS_FM_RX) +- return true; +- switch (ctrl->id) { +- case V4L2_CID_AUDIO_MUTE: +- case V4L2_CID_AUDIO_VOLUME: +- case V4L2_CID_AUDIO_BALANCE: +- case V4L2_CID_AUDIO_BASS: +- case V4L2_CID_AUDIO_TREBLE: +- case V4L2_CID_AUDIO_LOUDNESS: +- return true; +- default: +- break; +- } +- return false; +-} +-EXPORT_SYMBOL(v4l2_ctrl_radio_filter); +- +-/* Cluster controls */ +-void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls) +-{ +- bool has_volatiles = false; +- int i; +- +- /* The first control is the master control and it must not be NULL */ +- if (WARN_ON(ncontrols == 0 || controls[0] == NULL)) +- return; +- +- for (i = 0; i < ncontrols; i++) { +- if (controls[i]) { +- controls[i]->cluster = controls; +- controls[i]->ncontrols = ncontrols; +- if (controls[i]->flags & V4L2_CTRL_FLAG_VOLATILE) +- has_volatiles = true; +- } +- } +- controls[0]->has_volatiles = has_volatiles; +-} +-EXPORT_SYMBOL(v4l2_ctrl_cluster); +- +-void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls, +- u8 manual_val, bool set_volatile) +-{ +- struct v4l2_ctrl *master = controls[0]; +- u32 flag = 0; +- int i; +- +- v4l2_ctrl_cluster(ncontrols, controls); +- WARN_ON(ncontrols <= 1); +- WARN_ON(manual_val < master->minimum || manual_val > master->maximum); +- WARN_ON(set_volatile && !has_op(master, g_volatile_ctrl)); +- master->is_auto = true; +- master->has_volatiles = set_volatile; +- master->manual_mode_value = manual_val; +- master->flags |= V4L2_CTRL_FLAG_UPDATE; +- +- if (!is_cur_manual(master)) +- flag = V4L2_CTRL_FLAG_INACTIVE | +- (set_volatile ? V4L2_CTRL_FLAG_VOLATILE : 0); +- +- for (i = 1; i < ncontrols; i++) +- if (controls[i]) +- controls[i]->flags |= flag; +-} +-EXPORT_SYMBOL(v4l2_ctrl_auto_cluster); +- +-/* Activate/deactivate a control. */ +-void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active) +-{ +- /* invert since the actual flag is called 'inactive' */ +- bool inactive = !active; +- bool old; +- +- if (ctrl == NULL) +- return; +- +- if (inactive) +- /* set V4L2_CTRL_FLAG_INACTIVE */ +- old = test_and_set_bit(4, &ctrl->flags); +- else +- /* clear V4L2_CTRL_FLAG_INACTIVE */ +- old = test_and_clear_bit(4, &ctrl->flags); +- if (old != inactive) +- send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS); +-} +-EXPORT_SYMBOL(v4l2_ctrl_activate); +- +-void __v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed) +-{ +- bool old; +- +- if (ctrl == NULL) +- return; +- +- lockdep_assert_held(ctrl->handler->lock); +- +- if (grabbed) +- /* set V4L2_CTRL_FLAG_GRABBED */ +- old = test_and_set_bit(1, &ctrl->flags); +- else +- /* clear V4L2_CTRL_FLAG_GRABBED */ +- old = test_and_clear_bit(1, &ctrl->flags); +- if (old != grabbed) +- send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_FLAGS); +-} +-EXPORT_SYMBOL(__v4l2_ctrl_grab); +- +-/* Log the control name and value */ +-static void log_ctrl(const struct v4l2_ctrl *ctrl, +- const char *prefix, const char *colon) +-{ +- if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY)) +- return; +- if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS) +- return; +- +- pr_info("%s%s%s: ", prefix, colon, ctrl->name); +- +- ctrl->type_ops->log(ctrl); +- +- if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE | +- V4L2_CTRL_FLAG_GRABBED | +- V4L2_CTRL_FLAG_VOLATILE)) { +- if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE) +- pr_cont(" inactive"); +- if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED) +- pr_cont(" grabbed"); +- if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) +- pr_cont(" volatile"); +- } +- pr_cont("\n"); +-} +- +-/* Log all controls owned by the handler */ +-void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl, +- const char *prefix) +-{ +- struct v4l2_ctrl *ctrl; +- const char *colon = ""; +- int len; +- +- if (hdl == NULL) +- return; +- if (prefix == NULL) +- prefix = ""; +- len = strlen(prefix); +- if (len && prefix[len - 1] != ' ') +- colon = ": "; +- mutex_lock(hdl->lock); +- list_for_each_entry(ctrl, &hdl->ctrls, node) +- if (!(ctrl->flags & V4L2_CTRL_FLAG_DISABLED)) +- log_ctrl(ctrl, prefix, colon); +- mutex_unlock(hdl->lock); +-} +-EXPORT_SYMBOL(v4l2_ctrl_handler_log_status); +- +-int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd) +-{ +- v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name); +- return 0; +-} +-EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status); +- +-/* Call s_ctrl for all controls owned by the handler */ +-int __v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl) +-{ +- struct v4l2_ctrl *ctrl; +- int ret = 0; +- +- if (hdl == NULL) +- return 0; +- +- lockdep_assert_held(hdl->lock); +- +- list_for_each_entry(ctrl, &hdl->ctrls, node) +- ctrl->done = false; +- +- list_for_each_entry(ctrl, &hdl->ctrls, node) { +- struct v4l2_ctrl *master = ctrl->cluster[0]; +- int i; +- +- /* Skip if this control was already handled by a cluster. */ +- /* Skip button controls and read-only controls. */ +- if (ctrl->done || ctrl->type == V4L2_CTRL_TYPE_BUTTON || +- (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)) +- continue; +- +- for (i = 0; i < master->ncontrols; i++) { +- if (master->cluster[i]) { +- cur_to_new(master->cluster[i]); +- master->cluster[i]->is_new = 1; +- master->cluster[i]->done = true; +- } +- } +- ret = call_op(master, s_ctrl); +- if (ret) +- break; +- } +- +- return ret; +-} +-EXPORT_SYMBOL_GPL(__v4l2_ctrl_handler_setup); +- +-int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl) +-{ +- int ret; +- +- if (hdl == NULL) +- return 0; +- +- mutex_lock(hdl->lock); +- ret = __v4l2_ctrl_handler_setup(hdl); +- mutex_unlock(hdl->lock); +- +- return ret; +-} +-EXPORT_SYMBOL(v4l2_ctrl_handler_setup); +- +-/* Implement VIDIOC_QUERY_EXT_CTRL */ +-int v4l2_query_ext_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_query_ext_ctrl *qc) +-{ +- const unsigned next_flags = V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND; +- u32 id = qc->id & V4L2_CTRL_ID_MASK; +- struct v4l2_ctrl_ref *ref; +- struct v4l2_ctrl *ctrl; +- +- if (hdl == NULL) +- return -EINVAL; +- +- mutex_lock(hdl->lock); +- +- /* Try to find it */ +- ref = find_ref(hdl, id); +- +- if ((qc->id & next_flags) && !list_empty(&hdl->ctrl_refs)) { +- bool is_compound; +- /* Match any control that is not hidden */ +- unsigned mask = 1; +- bool match = false; +- +- if ((qc->id & next_flags) == V4L2_CTRL_FLAG_NEXT_COMPOUND) { +- /* Match any hidden control */ +- match = true; +- } else if ((qc->id & next_flags) == next_flags) { +- /* Match any control, compound or not */ +- mask = 0; +- } +- +- /* Find the next control with ID > qc->id */ +- +- /* Did we reach the end of the control list? */ +- if (id >= node2id(hdl->ctrl_refs.prev)) { +- ref = NULL; /* Yes, so there is no next control */ +- } else if (ref) { +- /* We found a control with the given ID, so just get +- the next valid one in the list. */ +- list_for_each_entry_continue(ref, &hdl->ctrl_refs, node) { +- is_compound = ref->ctrl->is_array || +- ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES; +- if (id < ref->ctrl->id && +- (is_compound & mask) == match) +- break; +- } +- if (&ref->node == &hdl->ctrl_refs) +- ref = NULL; +- } else { +- /* No control with the given ID exists, so start +- searching for the next largest ID. We know there +- is one, otherwise the first 'if' above would have +- been true. */ +- list_for_each_entry(ref, &hdl->ctrl_refs, node) { +- is_compound = ref->ctrl->is_array || +- ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES; +- if (id < ref->ctrl->id && +- (is_compound & mask) == match) +- break; +- } +- if (&ref->node == &hdl->ctrl_refs) +- ref = NULL; +- } +- } +- mutex_unlock(hdl->lock); +- +- if (!ref) +- return -EINVAL; +- +- ctrl = ref->ctrl; +- memset(qc, 0, sizeof(*qc)); +- if (id >= V4L2_CID_PRIVATE_BASE) +- qc->id = id; +- else +- qc->id = ctrl->id; +- strscpy(qc->name, ctrl->name, sizeof(qc->name)); +- qc->flags = user_flags(ctrl); +- qc->type = ctrl->type; +- qc->elem_size = ctrl->elem_size; +- qc->elems = ctrl->elems; +- qc->nr_of_dims = ctrl->nr_of_dims; +- memcpy(qc->dims, ctrl->dims, qc->nr_of_dims * sizeof(qc->dims[0])); +- qc->minimum = ctrl->minimum; +- qc->maximum = ctrl->maximum; +- qc->default_value = ctrl->default_value; +- if (ctrl->type == V4L2_CTRL_TYPE_MENU +- || ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU) +- qc->step = 1; +- else +- qc->step = ctrl->step; +- return 0; +-} +-EXPORT_SYMBOL(v4l2_query_ext_ctrl); +- +-/* Implement VIDIOC_QUERYCTRL */ +-int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc) +-{ +- struct v4l2_query_ext_ctrl qec = { qc->id }; +- int rc; +- +- rc = v4l2_query_ext_ctrl(hdl, &qec); +- if (rc) +- return rc; +- +- qc->id = qec.id; +- qc->type = qec.type; +- qc->flags = qec.flags; +- strscpy(qc->name, qec.name, sizeof(qc->name)); +- switch (qc->type) { +- case V4L2_CTRL_TYPE_INTEGER: +- case V4L2_CTRL_TYPE_BOOLEAN: +- case V4L2_CTRL_TYPE_MENU: +- case V4L2_CTRL_TYPE_INTEGER_MENU: +- case V4L2_CTRL_TYPE_STRING: +- case V4L2_CTRL_TYPE_BITMASK: +- qc->minimum = qec.minimum; +- qc->maximum = qec.maximum; +- qc->step = qec.step; +- qc->default_value = qec.default_value; +- break; +- default: +- qc->minimum = 0; +- qc->maximum = 0; +- qc->step = 0; +- qc->default_value = 0; +- break; +- } +- return 0; +-} +-EXPORT_SYMBOL(v4l2_queryctrl); +- +-/* Implement VIDIOC_QUERYMENU */ +-int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm) +-{ +- struct v4l2_ctrl *ctrl; +- u32 i = qm->index; +- +- ctrl = v4l2_ctrl_find(hdl, qm->id); +- if (!ctrl) +- return -EINVAL; +- +- qm->reserved = 0; +- /* Sanity checks */ +- switch (ctrl->type) { +- case V4L2_CTRL_TYPE_MENU: +- if (ctrl->qmenu == NULL) +- return -EINVAL; +- break; +- case V4L2_CTRL_TYPE_INTEGER_MENU: +- if (ctrl->qmenu_int == NULL) +- return -EINVAL; +- break; +- default: +- return -EINVAL; +- } +- +- if (i < ctrl->minimum || i > ctrl->maximum) +- return -EINVAL; +- +- /* Use mask to see if this menu item should be skipped */ +- if (ctrl->menu_skip_mask & (1ULL << i)) +- return -EINVAL; +- /* Empty menu items should also be skipped */ +- if (ctrl->type == V4L2_CTRL_TYPE_MENU) { +- if (ctrl->qmenu[i] == NULL || ctrl->qmenu[i][0] == '\0') +- return -EINVAL; +- strscpy(qm->name, ctrl->qmenu[i], sizeof(qm->name)); +- } else { +- qm->value = ctrl->qmenu_int[i]; +- } +- return 0; +-} +-EXPORT_SYMBOL(v4l2_querymenu); +- +-static int v4l2_ctrl_request_clone(struct v4l2_ctrl_handler *hdl, +- const struct v4l2_ctrl_handler *from) +-{ +- struct v4l2_ctrl_ref *ref; +- int err = 0; +- +- if (WARN_ON(!hdl || hdl == from)) +- return -EINVAL; +- +- if (hdl->error) +- return hdl->error; +- +- WARN_ON(hdl->lock != &hdl->_lock); +- +- mutex_lock(from->lock); +- list_for_each_entry(ref, &from->ctrl_refs, node) { +- struct v4l2_ctrl *ctrl = ref->ctrl; +- struct v4l2_ctrl_ref *new_ref; +- +- /* Skip refs inherited from other devices */ +- if (ref->from_other_dev) +- continue; +- err = handler_new_ref(hdl, ctrl, &new_ref, false, true); +- if (err) +- break; +- } +- mutex_unlock(from->lock); +- return err; +-} +- +-static void v4l2_ctrl_request_queue(struct media_request_object *obj) +-{ +- struct v4l2_ctrl_handler *hdl = +- container_of(obj, struct v4l2_ctrl_handler, req_obj); +- struct v4l2_ctrl_handler *main_hdl = obj->priv; +- +- mutex_lock(main_hdl->lock); +- list_add_tail(&hdl->requests_queued, &main_hdl->requests_queued); +- hdl->request_is_queued = true; +- mutex_unlock(main_hdl->lock); +-} +- +-static void v4l2_ctrl_request_unbind(struct media_request_object *obj) +-{ +- struct v4l2_ctrl_handler *hdl = +- container_of(obj, struct v4l2_ctrl_handler, req_obj); +- struct v4l2_ctrl_handler *main_hdl = obj->priv; +- +- mutex_lock(main_hdl->lock); +- list_del_init(&hdl->requests); +- if (hdl->request_is_queued) { +- list_del_init(&hdl->requests_queued); +- hdl->request_is_queued = false; +- } +- mutex_unlock(main_hdl->lock); +-} +- +-static void v4l2_ctrl_request_release(struct media_request_object *obj) +-{ +- struct v4l2_ctrl_handler *hdl = +- container_of(obj, struct v4l2_ctrl_handler, req_obj); +- +- v4l2_ctrl_handler_free(hdl); +- kfree(hdl); +-} +- +-static const struct media_request_object_ops req_ops = { +- .queue = v4l2_ctrl_request_queue, +- .unbind = v4l2_ctrl_request_unbind, +- .release = v4l2_ctrl_request_release, +-}; +- +-struct v4l2_ctrl_handler *v4l2_ctrl_request_hdl_find(struct media_request *req, +- struct v4l2_ctrl_handler *parent) +-{ +- struct media_request_object *obj; +- +- if (WARN_ON(req->state != MEDIA_REQUEST_STATE_VALIDATING && +- req->state != MEDIA_REQUEST_STATE_QUEUED)) +- return NULL; +- +- obj = media_request_object_find(req, &req_ops, parent); +- if (obj) +- return container_of(obj, struct v4l2_ctrl_handler, req_obj); +- return NULL; +-} +-EXPORT_SYMBOL_GPL(v4l2_ctrl_request_hdl_find); +- +-struct v4l2_ctrl * +-v4l2_ctrl_request_hdl_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id) +-{ +- struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id); +- +- return (ref && ref->valid_p_req) ? ref->ctrl : NULL; +-} +-EXPORT_SYMBOL_GPL(v4l2_ctrl_request_hdl_ctrl_find); +- +-static int v4l2_ctrl_request_bind(struct media_request *req, +- struct v4l2_ctrl_handler *hdl, +- struct v4l2_ctrl_handler *from) +-{ +- int ret; +- +- ret = v4l2_ctrl_request_clone(hdl, from); +- +- if (!ret) { +- ret = media_request_object_bind(req, &req_ops, +- from, false, &hdl->req_obj); +- if (!ret) { +- mutex_lock(from->lock); +- list_add_tail(&hdl->requests, &from->requests); +- mutex_unlock(from->lock); +- } +- } +- return ret; +-} +- +-/* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS: +- +- It is not a fully atomic operation, just best-effort only. After all, if +- multiple controls have to be set through multiple i2c writes (for example) +- then some initial writes may succeed while others fail. Thus leaving the +- system in an inconsistent state. The question is how much effort you are +- willing to spend on trying to make something atomic that really isn't. +- +- From the point of view of an application the main requirement is that +- when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an +- error should be returned without actually affecting any controls. +- +- If all the values are correct, then it is acceptable to just give up +- in case of low-level errors. +- +- It is important though that the application can tell when only a partial +- configuration was done. The way we do that is through the error_idx field +- of struct v4l2_ext_controls: if that is equal to the count field then no +- controls were affected. Otherwise all controls before that index were +- successful in performing their 'get' or 'set' operation, the control at +- the given index failed, and you don't know what happened with the controls +- after the failed one. Since if they were part of a control cluster they +- could have been successfully processed (if a cluster member was encountered +- at index < error_idx), they could have failed (if a cluster member was at +- error_idx), or they may not have been processed yet (if the first cluster +- member appeared after error_idx). +- +- It is all fairly theoretical, though. In practice all you can do is to +- bail out. If error_idx == count, then it is an application bug. If +- error_idx < count then it is only an application bug if the error code was +- EBUSY. That usually means that something started streaming just when you +- tried to set the controls. In all other cases it is a driver/hardware +- problem and all you can do is to retry or bail out. +- +- Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that +- never modifies controls the error_idx is just set to whatever control +- has an invalid value. +- */ +- +-/* Prepare for the extended g/s/try functions. +- Find the controls in the control array and do some basic checks. */ +-static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl, +- struct v4l2_ext_controls *cs, +- struct v4l2_ctrl_helper *helpers, +- struct video_device *vdev, +- bool get) +-{ +- struct v4l2_ctrl_helper *h; +- bool have_clusters = false; +- u32 i; +- +- for (i = 0, h = helpers; i < cs->count; i++, h++) { +- struct v4l2_ext_control *c = &cs->controls[i]; +- struct v4l2_ctrl_ref *ref; +- struct v4l2_ctrl *ctrl; +- u32 id = c->id & V4L2_CTRL_ID_MASK; +- +- cs->error_idx = i; +- +- if (cs->which && +- cs->which != V4L2_CTRL_WHICH_DEF_VAL && +- cs->which != V4L2_CTRL_WHICH_REQUEST_VAL && +- V4L2_CTRL_ID2WHICH(id) != cs->which) { +- dprintk(vdev, +- "invalid which 0x%x or control id 0x%x\n", +- cs->which, id); +- return -EINVAL; +- } +- +- /* Old-style private controls are not allowed for +- extended controls */ +- if (id >= V4L2_CID_PRIVATE_BASE) { +- dprintk(vdev, +- "old-style private controls not allowed\n"); +- return -EINVAL; +- } +- ref = find_ref_lock(hdl, id); +- if (ref == NULL) { +- dprintk(vdev, "cannot find control id 0x%x\n", id); +- return -EINVAL; +- } +- h->ref = ref; +- ctrl = ref->ctrl; +- if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED) { +- dprintk(vdev, "control id 0x%x is disabled\n", id); +- return -EINVAL; +- } +- +- if (ctrl->cluster[0]->ncontrols > 1) +- have_clusters = true; +- if (ctrl->cluster[0] != ctrl) +- ref = find_ref_lock(hdl, ctrl->cluster[0]->id); +- if (ctrl->is_ptr && !ctrl->is_string) { +- unsigned tot_size = ctrl->elems * ctrl->elem_size; +- +- if (c->size < tot_size) { +- /* +- * In the get case the application first +- * queries to obtain the size of the control. +- */ +- if (get) { +- c->size = tot_size; +- return -ENOSPC; +- } +- dprintk(vdev, +- "pointer control id 0x%x size too small, %d bytes but %d bytes needed\n", +- id, c->size, tot_size); +- return -EFAULT; +- } +- c->size = tot_size; +- } +- /* Store the ref to the master control of the cluster */ +- h->mref = ref; +- /* Initially set next to 0, meaning that there is no other +- control in this helper array belonging to the same +- cluster */ +- h->next = 0; +- } +- +- /* We are done if there were no controls that belong to a multi- +- control cluster. */ +- if (!have_clusters) +- return 0; +- +- /* The code below figures out in O(n) time which controls in the list +- belong to the same cluster. */ +- +- /* This has to be done with the handler lock taken. */ +- mutex_lock(hdl->lock); +- +- /* First zero the helper field in the master control references */ +- for (i = 0; i < cs->count; i++) +- helpers[i].mref->helper = NULL; +- for (i = 0, h = helpers; i < cs->count; i++, h++) { +- struct v4l2_ctrl_ref *mref = h->mref; +- +- /* If the mref->helper is set, then it points to an earlier +- helper that belongs to the same cluster. */ +- if (mref->helper) { +- /* Set the next field of mref->helper to the current +- index: this means that that earlier helper now +- points to the next helper in the same cluster. */ +- mref->helper->next = i; +- /* mref should be set only for the first helper in the +- cluster, clear the others. */ +- h->mref = NULL; +- } +- /* Point the mref helper to the current helper struct. */ +- mref->helper = h; +- } +- mutex_unlock(hdl->lock); +- return 0; +-} +- +-/* Handles the corner case where cs->count == 0. It checks whether the +- specified control class exists. If that class ID is 0, then it checks +- whether there are any controls at all. */ +-static int class_check(struct v4l2_ctrl_handler *hdl, u32 which) +-{ +- if (which == 0 || which == V4L2_CTRL_WHICH_DEF_VAL || +- which == V4L2_CTRL_WHICH_REQUEST_VAL) +- return 0; +- return find_ref_lock(hdl, which | 1) ? 0 : -EINVAL; +-} +- +-/* +- * Get extended controls. Allocates the helpers array if needed. +- * +- * Note that v4l2_g_ext_ctrls_common() with 'which' set to +- * V4L2_CTRL_WHICH_REQUEST_VAL is only called if the request was +- * completed, and in that case valid_p_req is true for all controls. +- */ +-static int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl, +- struct v4l2_ext_controls *cs, +- struct video_device *vdev) +-{ +- struct v4l2_ctrl_helper helper[4]; +- struct v4l2_ctrl_helper *helpers = helper; +- int ret; +- int i, j; +- bool is_default, is_request; +- +- is_default = (cs->which == V4L2_CTRL_WHICH_DEF_VAL); +- is_request = (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL); +- +- cs->error_idx = cs->count; +- cs->which = V4L2_CTRL_ID2WHICH(cs->which); +- +- if (hdl == NULL) +- return -EINVAL; +- +- if (cs->count == 0) +- return class_check(hdl, cs->which); +- +- if (cs->count > ARRAY_SIZE(helper)) { +- helpers = kvmalloc_array(cs->count, sizeof(helper[0]), +- GFP_KERNEL); +- if (helpers == NULL) +- return -ENOMEM; +- } +- +- ret = prepare_ext_ctrls(hdl, cs, helpers, vdev, true); +- cs->error_idx = cs->count; +- +- for (i = 0; !ret && i < cs->count; i++) +- if (helpers[i].ref->ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY) +- ret = -EACCES; +- +- for (i = 0; !ret && i < cs->count; i++) { +- struct v4l2_ctrl *master; +- bool is_volatile = false; +- u32 idx = i; +- +- if (helpers[i].mref == NULL) +- continue; +- +- master = helpers[i].mref->ctrl; +- cs->error_idx = i; +- +- v4l2_ctrl_lock(master); +- +- /* +- * g_volatile_ctrl will update the new control values. +- * This makes no sense for V4L2_CTRL_WHICH_DEF_VAL and +- * V4L2_CTRL_WHICH_REQUEST_VAL. In the case of requests +- * it is v4l2_ctrl_request_complete() that copies the +- * volatile controls at the time of request completion +- * to the request, so you don't want to do that again. +- */ +- if (!is_default && !is_request && +- ((master->flags & V4L2_CTRL_FLAG_VOLATILE) || +- (master->has_volatiles && !is_cur_manual(master)))) { +- for (j = 0; j < master->ncontrols; j++) +- cur_to_new(master->cluster[j]); +- ret = call_op(master, g_volatile_ctrl); +- is_volatile = true; +- } +- +- if (ret) { +- v4l2_ctrl_unlock(master); +- break; +- } +- +- /* +- * Copy the default value (if is_default is true), the +- * request value (if is_request is true and p_req is valid), +- * the new volatile value (if is_volatile is true) or the +- * current value. +- */ +- do { +- struct v4l2_ctrl_ref *ref = helpers[idx].ref; +- +- if (is_default) +- ret = def_to_user(cs->controls + idx, ref->ctrl); +- else if (is_request && ref->valid_p_req) +- ret = req_to_user(cs->controls + idx, ref); +- else if (is_volatile) +- ret = new_to_user(cs->controls + idx, ref->ctrl); +- else +- ret = cur_to_user(cs->controls + idx, ref->ctrl); +- idx = helpers[idx].next; +- } while (!ret && idx); +- +- v4l2_ctrl_unlock(master); +- } +- +- if (cs->count > ARRAY_SIZE(helper)) +- kvfree(helpers); +- return ret; +-} +- +-static struct media_request_object * +-v4l2_ctrls_find_req_obj(struct v4l2_ctrl_handler *hdl, +- struct media_request *req, bool set) +-{ +- struct media_request_object *obj; +- struct v4l2_ctrl_handler *new_hdl; +- int ret; +- +- if (IS_ERR(req)) +- return ERR_CAST(req); +- +- if (set && WARN_ON(req->state != MEDIA_REQUEST_STATE_UPDATING)) +- return ERR_PTR(-EBUSY); +- +- obj = media_request_object_find(req, &req_ops, hdl); +- if (obj) +- return obj; +- if (!set) +- return ERR_PTR(-ENOENT); +- +- new_hdl = kzalloc(sizeof(*new_hdl), GFP_KERNEL); +- if (!new_hdl) +- return ERR_PTR(-ENOMEM); +- +- obj = &new_hdl->req_obj; +- ret = v4l2_ctrl_handler_init(new_hdl, (hdl->nr_of_buckets - 1) * 8); +- if (!ret) +- ret = v4l2_ctrl_request_bind(req, new_hdl, hdl); +- if (ret) { +- kfree(new_hdl); +- +- return ERR_PTR(ret); +- } +- +- media_request_object_get(obj); +- return obj; +-} +- +-int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct video_device *vdev, +- struct media_device *mdev, struct v4l2_ext_controls *cs) +-{ +- struct media_request_object *obj = NULL; +- struct media_request *req = NULL; +- int ret; +- +- if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL) { +- if (!mdev || cs->request_fd < 0) +- return -EINVAL; +- +- req = media_request_get_by_fd(mdev, cs->request_fd); +- if (IS_ERR(req)) +- return PTR_ERR(req); +- +- if (req->state != MEDIA_REQUEST_STATE_COMPLETE) { +- media_request_put(req); +- return -EACCES; +- } +- +- ret = media_request_lock_for_access(req); +- if (ret) { +- media_request_put(req); +- return ret; +- } +- +- obj = v4l2_ctrls_find_req_obj(hdl, req, false); +- if (IS_ERR(obj)) { +- media_request_unlock_for_access(req); +- media_request_put(req); +- return PTR_ERR(obj); +- } +- +- hdl = container_of(obj, struct v4l2_ctrl_handler, +- req_obj); +- } +- +- ret = v4l2_g_ext_ctrls_common(hdl, cs, vdev); +- +- if (obj) { +- media_request_unlock_for_access(req); +- media_request_object_put(obj); +- media_request_put(req); +- } +- return ret; +-} +-EXPORT_SYMBOL(v4l2_g_ext_ctrls); +- +-/* Helper function to get a single control */ +-static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c) +-{ +- struct v4l2_ctrl *master = ctrl->cluster[0]; +- int ret = 0; +- int i; +- +- /* Compound controls are not supported. The new_to_user() and +- * cur_to_user() calls below would need to be modified not to access +- * userspace memory when called from get_ctrl(). +- */ +- if (!ctrl->is_int && ctrl->type != V4L2_CTRL_TYPE_INTEGER64) +- return -EINVAL; +- +- if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY) +- return -EACCES; +- +- v4l2_ctrl_lock(master); +- /* g_volatile_ctrl will update the current control values */ +- if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) { +- for (i = 0; i < master->ncontrols; i++) +- cur_to_new(master->cluster[i]); +- ret = call_op(master, g_volatile_ctrl); +- new_to_user(c, ctrl); +- } else { +- cur_to_user(c, ctrl); +- } +- v4l2_ctrl_unlock(master); +- return ret; +-} +- +-int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control) +-{ +- struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id); +- struct v4l2_ext_control c; +- int ret; +- +- if (ctrl == NULL || !ctrl->is_int) +- return -EINVAL; +- ret = get_ctrl(ctrl, &c); +- control->value = c.value; +- return ret; +-} +-EXPORT_SYMBOL(v4l2_g_ctrl); +- +-s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl) +-{ +- struct v4l2_ext_control c; +- +- /* It's a driver bug if this happens. */ +- if (WARN_ON(!ctrl->is_int)) +- return 0; +- c.value = 0; +- get_ctrl(ctrl, &c); +- return c.value; +-} +-EXPORT_SYMBOL(v4l2_ctrl_g_ctrl); +- +-s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl) +-{ +- struct v4l2_ext_control c; +- +- /* It's a driver bug if this happens. */ +- if (WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64)) +- return 0; +- c.value64 = 0; +- get_ctrl(ctrl, &c); +- return c.value64; +-} +-EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64); +- +- +-/* Core function that calls try/s_ctrl and ensures that the new value is +- copied to the current value on a set. +- Must be called with ctrl->handler->lock held. */ +-static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master, +- bool set, u32 ch_flags) +-{ +- bool update_flag; +- int ret; +- int i; +- +- /* Go through the cluster and either validate the new value or +- (if no new value was set), copy the current value to the new +- value, ensuring a consistent view for the control ops when +- called. */ +- for (i = 0; i < master->ncontrols; i++) { +- struct v4l2_ctrl *ctrl = master->cluster[i]; +- +- if (ctrl == NULL) +- continue; +- +- if (!ctrl->is_new) { +- cur_to_new(ctrl); +- continue; +- } +- /* Check again: it may have changed since the +- previous check in try_or_set_ext_ctrls(). */ +- if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)) +- return -EBUSY; +- } +- +- ret = call_op(master, try_ctrl); +- +- /* Don't set if there is no change */ +- if (ret || !set || !cluster_changed(master)) +- return ret; +- ret = call_op(master, s_ctrl); +- if (ret) +- return ret; +- +- /* If OK, then make the new values permanent. */ +- update_flag = is_cur_manual(master) != is_new_manual(master); +- +- for (i = 0; i < master->ncontrols; i++) { +- /* +- * If we switch from auto to manual mode, and this cluster +- * contains volatile controls, then all non-master controls +- * have to be marked as changed. The 'new' value contains +- * the volatile value (obtained by update_from_auto_cluster), +- * which now has to become the current value. +- */ +- if (i && update_flag && is_new_manual(master) && +- master->has_volatiles && master->cluster[i]) +- master->cluster[i]->has_changed = true; +- +- new_to_cur(fh, master->cluster[i], ch_flags | +- ((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0)); +- } +- return 0; +-} +- +-/* Validate controls. */ +-static int validate_ctrls(struct v4l2_ext_controls *cs, +- struct v4l2_ctrl_helper *helpers, +- struct video_device *vdev, +- bool set) +-{ +- unsigned i; +- int ret = 0; +- +- cs->error_idx = cs->count; +- for (i = 0; i < cs->count; i++) { +- struct v4l2_ctrl *ctrl = helpers[i].ref->ctrl; +- union v4l2_ctrl_ptr p_new; +- +- cs->error_idx = i; +- +- if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY) { +- dprintk(vdev, +- "control id 0x%x is read-only\n", +- ctrl->id); +- return -EACCES; +- } +- /* This test is also done in try_set_control_cluster() which +- is called in atomic context, so that has the final say, +- but it makes sense to do an up-front check as well. Once +- an error occurs in try_set_control_cluster() some other +- controls may have been set already and we want to do a +- best-effort to avoid that. */ +- if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)) { +- dprintk(vdev, +- "control id 0x%x is grabbed, cannot set\n", +- ctrl->id); +- return -EBUSY; +- } +- /* +- * Skip validation for now if the payload needs to be copied +- * from userspace into kernelspace. We'll validate those later. +- */ +- if (ctrl->is_ptr) +- continue; +- if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64) +- p_new.p_s64 = &cs->controls[i].value64; +- else +- p_new.p_s32 = &cs->controls[i].value; +- ret = validate_new(ctrl, p_new); +- if (ret) +- return ret; +- } +- return 0; +-} +- +-/* Obtain the current volatile values of an autocluster and mark them +- as new. */ +-static void update_from_auto_cluster(struct v4l2_ctrl *master) +-{ +- int i; +- +- for (i = 1; i < master->ncontrols; i++) +- cur_to_new(master->cluster[i]); +- if (!call_op(master, g_volatile_ctrl)) +- for (i = 1; i < master->ncontrols; i++) +- if (master->cluster[i]) +- master->cluster[i]->is_new = 1; +-} +- +-/* Try or try-and-set controls */ +-static int try_set_ext_ctrls_common(struct v4l2_fh *fh, +- struct v4l2_ctrl_handler *hdl, +- struct v4l2_ext_controls *cs, +- struct video_device *vdev, bool set) +-{ +- struct v4l2_ctrl_helper helper[4]; +- struct v4l2_ctrl_helper *helpers = helper; +- unsigned i, j; +- int ret; +- +- cs->error_idx = cs->count; +- +- /* Default value cannot be changed */ +- if (cs->which == V4L2_CTRL_WHICH_DEF_VAL) { +- dprintk(vdev, "%s: cannot change default value\n", +- video_device_node_name(vdev)); +- return -EINVAL; +- } +- +- cs->which = V4L2_CTRL_ID2WHICH(cs->which); +- +- if (hdl == NULL) { +- dprintk(vdev, "%s: invalid null control handler\n", +- video_device_node_name(vdev)); +- return -EINVAL; +- } +- +- if (cs->count == 0) +- return class_check(hdl, cs->which); +- +- if (cs->count > ARRAY_SIZE(helper)) { +- helpers = kvmalloc_array(cs->count, sizeof(helper[0]), +- GFP_KERNEL); +- if (!helpers) +- return -ENOMEM; +- } +- ret = prepare_ext_ctrls(hdl, cs, helpers, vdev, false); +- if (!ret) +- ret = validate_ctrls(cs, helpers, vdev, set); +- if (ret && set) +- cs->error_idx = cs->count; +- for (i = 0; !ret && i < cs->count; i++) { +- struct v4l2_ctrl *master; +- u32 idx = i; +- +- if (helpers[i].mref == NULL) +- continue; +- +- cs->error_idx = i; +- master = helpers[i].mref->ctrl; +- v4l2_ctrl_lock(master); +- +- /* Reset the 'is_new' flags of the cluster */ +- for (j = 0; j < master->ncontrols; j++) +- if (master->cluster[j]) +- master->cluster[j]->is_new = 0; +- +- /* For volatile autoclusters that are currently in auto mode +- we need to discover if it will be set to manual mode. +- If so, then we have to copy the current volatile values +- first since those will become the new manual values (which +- may be overwritten by explicit new values from this set +- of controls). */ +- if (master->is_auto && master->has_volatiles && +- !is_cur_manual(master)) { +- /* Pick an initial non-manual value */ +- s32 new_auto_val = master->manual_mode_value + 1; +- u32 tmp_idx = idx; +- +- do { +- /* Check if the auto control is part of the +- list, and remember the new value. */ +- if (helpers[tmp_idx].ref->ctrl == master) +- new_auto_val = cs->controls[tmp_idx].value; +- tmp_idx = helpers[tmp_idx].next; +- } while (tmp_idx); +- /* If the new value == the manual value, then copy +- the current volatile values. */ +- if (new_auto_val == master->manual_mode_value) +- update_from_auto_cluster(master); +- } +- +- /* Copy the new caller-supplied control values. +- user_to_new() sets 'is_new' to 1. */ +- do { +- struct v4l2_ctrl *ctrl = helpers[idx].ref->ctrl; +- +- ret = user_to_new(cs->controls + idx, ctrl); +- if (!ret && ctrl->is_ptr) { +- ret = validate_new(ctrl, ctrl->p_new); +- if (ret) +- dprintk(vdev, +- "failed to validate control %s (%d)\n", +- v4l2_ctrl_get_name(ctrl->id), ret); +- } +- idx = helpers[idx].next; +- } while (!ret && idx); +- +- if (!ret) +- ret = try_or_set_cluster(fh, master, +- !hdl->req_obj.req && set, 0); +- if (!ret && hdl->req_obj.req && set) { +- for (j = 0; j < master->ncontrols; j++) { +- struct v4l2_ctrl_ref *ref = +- find_ref(hdl, master->cluster[j]->id); +- +- new_to_req(ref); +- } +- } +- +- /* Copy the new values back to userspace. */ +- if (!ret) { +- idx = i; +- do { +- ret = new_to_user(cs->controls + idx, +- helpers[idx].ref->ctrl); +- idx = helpers[idx].next; +- } while (!ret && idx); +- } +- v4l2_ctrl_unlock(master); +- } +- +- if (cs->count > ARRAY_SIZE(helper)) +- kvfree(helpers); +- return ret; +-} +- +-static int try_set_ext_ctrls(struct v4l2_fh *fh, +- struct v4l2_ctrl_handler *hdl, +- struct video_device *vdev, +- struct media_device *mdev, +- struct v4l2_ext_controls *cs, bool set) +-{ +- struct media_request_object *obj = NULL; +- struct media_request *req = NULL; +- int ret; +- +- if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL) { +- if (!mdev) { +- dprintk(vdev, "%s: missing media device\n", +- video_device_node_name(vdev)); +- return -EINVAL; +- } +- +- if (cs->request_fd < 0) { +- dprintk(vdev, "%s: invalid request fd %d\n", +- video_device_node_name(vdev), cs->request_fd); +- return -EINVAL; +- } +- +- req = media_request_get_by_fd(mdev, cs->request_fd); +- if (IS_ERR(req)) { +- dprintk(vdev, "%s: cannot find request fd %d\n", +- video_device_node_name(vdev), cs->request_fd); +- return PTR_ERR(req); +- } +- +- ret = media_request_lock_for_update(req); +- if (ret) { +- dprintk(vdev, "%s: cannot lock request fd %d\n", +- video_device_node_name(vdev), cs->request_fd); +- media_request_put(req); +- return ret; +- } +- +- obj = v4l2_ctrls_find_req_obj(hdl, req, set); +- if (IS_ERR(obj)) { +- dprintk(vdev, +- "%s: cannot find request object for request fd %d\n", +- video_device_node_name(vdev), +- cs->request_fd); +- media_request_unlock_for_update(req); +- media_request_put(req); +- return PTR_ERR(obj); +- } +- hdl = container_of(obj, struct v4l2_ctrl_handler, +- req_obj); +- } +- +- ret = try_set_ext_ctrls_common(fh, hdl, cs, vdev, set); +- if (ret) +- dprintk(vdev, +- "%s: try_set_ext_ctrls_common failed (%d)\n", +- video_device_node_name(vdev), ret); +- +- if (obj) { +- media_request_unlock_for_update(req); +- media_request_object_put(obj); +- media_request_put(req); +- } +- +- return ret; +-} +- +-int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, +- struct video_device *vdev, +- struct media_device *mdev, +- struct v4l2_ext_controls *cs) +-{ +- return try_set_ext_ctrls(NULL, hdl, vdev, mdev, cs, false); +-} +-EXPORT_SYMBOL(v4l2_try_ext_ctrls); +- +-int v4l2_s_ext_ctrls(struct v4l2_fh *fh, +- struct v4l2_ctrl_handler *hdl, +- struct video_device *vdev, +- struct media_device *mdev, +- struct v4l2_ext_controls *cs) +-{ +- return try_set_ext_ctrls(fh, hdl, vdev, mdev, cs, true); +-} +-EXPORT_SYMBOL(v4l2_s_ext_ctrls); +- +-/* Helper function for VIDIOC_S_CTRL compatibility */ +-static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags) +-{ +- struct v4l2_ctrl *master = ctrl->cluster[0]; +- int ret; +- int i; +- +- /* Reset the 'is_new' flags of the cluster */ +- for (i = 0; i < master->ncontrols; i++) +- if (master->cluster[i]) +- master->cluster[i]->is_new = 0; +- +- ret = validate_new(ctrl, ctrl->p_new); +- if (ret) +- return ret; +- +- /* For autoclusters with volatiles that are switched from auto to +- manual mode we have to update the current volatile values since +- those will become the initial manual values after such a switch. */ +- if (master->is_auto && master->has_volatiles && ctrl == master && +- !is_cur_manual(master) && ctrl->val == master->manual_mode_value) +- update_from_auto_cluster(master); +- +- ctrl->is_new = 1; +- return try_or_set_cluster(fh, master, true, ch_flags); +-} +- +-/* Helper function for VIDIOC_S_CTRL compatibility */ +-static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, +- struct v4l2_ext_control *c) +-{ +- int ret; +- +- v4l2_ctrl_lock(ctrl); +- user_to_new(c, ctrl); +- ret = set_ctrl(fh, ctrl, 0); +- if (!ret) +- cur_to_user(c, ctrl); +- v4l2_ctrl_unlock(ctrl); +- return ret; +-} +- +-int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl, +- struct v4l2_control *control) +-{ +- struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id); +- struct v4l2_ext_control c = { control->id }; +- int ret; +- +- if (ctrl == NULL || !ctrl->is_int) +- return -EINVAL; +- +- if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY) +- return -EACCES; +- +- c.value = control->value; +- ret = set_ctrl_lock(fh, ctrl, &c); +- control->value = c.value; +- return ret; +-} +-EXPORT_SYMBOL(v4l2_s_ctrl); +- +-int __v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val) +-{ +- lockdep_assert_held(ctrl->handler->lock); +- +- /* It's a driver bug if this happens. */ +- if (WARN_ON(!ctrl->is_int)) +- return -EINVAL; +- ctrl->val = val; +- return set_ctrl(NULL, ctrl, 0); +-} +-EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl); +- +-int __v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val) +-{ +- lockdep_assert_held(ctrl->handler->lock); +- +- /* It's a driver bug if this happens. */ +- if (WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64)) +- return -EINVAL; +- *ctrl->p_new.p_s64 = val; +- return set_ctrl(NULL, ctrl, 0); +-} +-EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_int64); +- +-int __v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl *ctrl, const char *s) +-{ +- lockdep_assert_held(ctrl->handler->lock); +- +- /* It's a driver bug if this happens. */ +- if (WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING)) +- return -EINVAL; +- strscpy(ctrl->p_new.p_char, s, ctrl->maximum + 1); +- return set_ctrl(NULL, ctrl, 0); +-} +-EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string); +- +-int __v4l2_ctrl_s_ctrl_compound(struct v4l2_ctrl *ctrl, +- enum v4l2_ctrl_type type, const void *p) +-{ +- lockdep_assert_held(ctrl->handler->lock); +- +- /* It's a driver bug if this happens. */ +- if (WARN_ON(ctrl->type != type)) +- return -EINVAL; +- memcpy(ctrl->p_new.p, p, ctrl->elems * ctrl->elem_size); +- return set_ctrl(NULL, ctrl, 0); +-} +-EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_compound); +- +-void v4l2_ctrl_request_complete(struct media_request *req, +- struct v4l2_ctrl_handler *main_hdl) +-{ +- struct media_request_object *obj; +- struct v4l2_ctrl_handler *hdl; +- struct v4l2_ctrl_ref *ref; +- +- if (!req || !main_hdl) +- return; +- +- /* +- * Note that it is valid if nothing was found. It means +- * that this request doesn't have any controls and so just +- * wants to leave the controls unchanged. +- */ +- obj = media_request_object_find(req, &req_ops, main_hdl); +- if (!obj) +- return; +- hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj); +- +- list_for_each_entry(ref, &hdl->ctrl_refs, node) { +- struct v4l2_ctrl *ctrl = ref->ctrl; +- struct v4l2_ctrl *master = ctrl->cluster[0]; +- unsigned int i; +- +- if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) { +- v4l2_ctrl_lock(master); +- /* g_volatile_ctrl will update the current control values */ +- for (i = 0; i < master->ncontrols; i++) +- cur_to_new(master->cluster[i]); +- call_op(master, g_volatile_ctrl); +- new_to_req(ref); +- v4l2_ctrl_unlock(master); +- continue; +- } +- if (ref->valid_p_req) +- continue; +- +- /* Copy the current control value into the request */ +- v4l2_ctrl_lock(ctrl); +- cur_to_req(ref); +- v4l2_ctrl_unlock(ctrl); +- } +- +- mutex_lock(main_hdl->lock); +- WARN_ON(!hdl->request_is_queued); +- list_del_init(&hdl->requests_queued); +- hdl->request_is_queued = false; +- mutex_unlock(main_hdl->lock); +- media_request_object_complete(obj); +- media_request_object_put(obj); +-} +-EXPORT_SYMBOL(v4l2_ctrl_request_complete); +- +-int v4l2_ctrl_request_setup(struct media_request *req, +- struct v4l2_ctrl_handler *main_hdl) +-{ +- struct media_request_object *obj; +- struct v4l2_ctrl_handler *hdl; +- struct v4l2_ctrl_ref *ref; +- int ret = 0; +- +- if (!req || !main_hdl) +- return 0; +- +- if (WARN_ON(req->state != MEDIA_REQUEST_STATE_QUEUED)) +- return -EBUSY; +- +- /* +- * Note that it is valid if nothing was found. It means +- * that this request doesn't have any controls and so just +- * wants to leave the controls unchanged. +- */ +- obj = media_request_object_find(req, &req_ops, main_hdl); +- if (!obj) +- return 0; +- if (obj->completed) { +- media_request_object_put(obj); +- return -EBUSY; +- } +- hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj); +- +- list_for_each_entry(ref, &hdl->ctrl_refs, node) +- ref->req_done = false; +- +- list_for_each_entry(ref, &hdl->ctrl_refs, node) { +- struct v4l2_ctrl *ctrl = ref->ctrl; +- struct v4l2_ctrl *master = ctrl->cluster[0]; +- bool have_new_data = false; +- int i; +- +- /* +- * Skip if this control was already handled by a cluster. +- * Skip button controls and read-only controls. +- */ +- if (ref->req_done || (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)) +- continue; +- +- v4l2_ctrl_lock(master); +- for (i = 0; i < master->ncontrols; i++) { +- if (master->cluster[i]) { +- struct v4l2_ctrl_ref *r = +- find_ref(hdl, master->cluster[i]->id); +- +- if (r->valid_p_req) { +- have_new_data = true; +- break; +- } +- } +- } +- if (!have_new_data) { +- v4l2_ctrl_unlock(master); +- continue; +- } +- +- for (i = 0; i < master->ncontrols; i++) { +- if (master->cluster[i]) { +- struct v4l2_ctrl_ref *r = +- find_ref(hdl, master->cluster[i]->id); +- +- req_to_new(r); +- master->cluster[i]->is_new = 1; +- r->req_done = true; +- } +- } +- /* +- * For volatile autoclusters that are currently in auto mode +- * we need to discover if it will be set to manual mode. +- * If so, then we have to copy the current volatile values +- * first since those will become the new manual values (which +- * may be overwritten by explicit new values from this set +- * of controls). +- */ +- if (master->is_auto && master->has_volatiles && +- !is_cur_manual(master)) { +- s32 new_auto_val = *master->p_new.p_s32; +- +- /* +- * If the new value == the manual value, then copy +- * the current volatile values. +- */ +- if (new_auto_val == master->manual_mode_value) +- update_from_auto_cluster(master); +- } +- +- ret = try_or_set_cluster(NULL, master, true, 0); +- v4l2_ctrl_unlock(master); +- +- if (ret) +- break; +- } +- +- media_request_object_put(obj); +- return ret; +-} +-EXPORT_SYMBOL(v4l2_ctrl_request_setup); +- +-void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv) +-{ +- if (ctrl == NULL) +- return; +- if (notify == NULL) { +- ctrl->call_notify = 0; +- return; +- } +- if (WARN_ON(ctrl->handler->notify && ctrl->handler->notify != notify)) +- return; +- ctrl->handler->notify = notify; +- ctrl->handler->notify_priv = priv; +- ctrl->call_notify = 1; +-} +-EXPORT_SYMBOL(v4l2_ctrl_notify); +- +-int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl, +- s64 min, s64 max, u64 step, s64 def) +-{ +- bool value_changed; +- bool range_changed = false; +- int ret; +- +- lockdep_assert_held(ctrl->handler->lock); +- +- switch (ctrl->type) { +- case V4L2_CTRL_TYPE_INTEGER: +- case V4L2_CTRL_TYPE_INTEGER64: +- case V4L2_CTRL_TYPE_BOOLEAN: +- case V4L2_CTRL_TYPE_MENU: +- case V4L2_CTRL_TYPE_INTEGER_MENU: +- case V4L2_CTRL_TYPE_BITMASK: +- case V4L2_CTRL_TYPE_U8: +- case V4L2_CTRL_TYPE_U16: +- case V4L2_CTRL_TYPE_U32: +- if (ctrl->is_array) +- return -EINVAL; +- ret = check_range(ctrl->type, min, max, step, def); +- if (ret) +- return ret; +- break; +- default: +- return -EINVAL; +- } +- if ((ctrl->minimum != min) || (ctrl->maximum != max) || +- (ctrl->step != step) || ctrl->default_value != def) { +- range_changed = true; +- ctrl->minimum = min; +- ctrl->maximum = max; +- ctrl->step = step; +- ctrl->default_value = def; +- } +- cur_to_new(ctrl); +- if (validate_new(ctrl, ctrl->p_new)) { +- if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64) +- *ctrl->p_new.p_s64 = def; +- else +- *ctrl->p_new.p_s32 = def; +- } +- +- if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64) +- value_changed = *ctrl->p_new.p_s64 != *ctrl->p_cur.p_s64; +- else +- value_changed = *ctrl->p_new.p_s32 != *ctrl->p_cur.p_s32; +- if (value_changed) +- ret = set_ctrl(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE); +- else if (range_changed) +- send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE); +- return ret; +-} +-EXPORT_SYMBOL(__v4l2_ctrl_modify_range); +- +-static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems) +-{ +- struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id); +- +- if (ctrl == NULL) +- return -EINVAL; +- +- v4l2_ctrl_lock(ctrl); +- list_add_tail(&sev->node, &ctrl->ev_subs); +- if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS && +- (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL)) { +- struct v4l2_event ev; +- u32 changes = V4L2_EVENT_CTRL_CH_FLAGS; +- +- if (!(ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)) +- changes |= V4L2_EVENT_CTRL_CH_VALUE; +- fill_event(&ev, ctrl, changes); +- /* Mark the queue as active, allowing this initial +- event to be accepted. */ +- sev->elems = elems; +- v4l2_event_queue_fh(sev->fh, &ev); +- } +- v4l2_ctrl_unlock(ctrl); +- return 0; +-} +- +-static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev) +-{ +- struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id); +- +- if (ctrl == NULL) +- return; +- +- v4l2_ctrl_lock(ctrl); +- list_del(&sev->node); +- v4l2_ctrl_unlock(ctrl); +-} +- +-void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new) +-{ +- u32 old_changes = old->u.ctrl.changes; +- +- old->u.ctrl = new->u.ctrl; +- old->u.ctrl.changes |= old_changes; +-} +-EXPORT_SYMBOL(v4l2_ctrl_replace); +- +-void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new) +-{ +- new->u.ctrl.changes |= old->u.ctrl.changes; +-} +-EXPORT_SYMBOL(v4l2_ctrl_merge); +- +-const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = { +- .add = v4l2_ctrl_add_event, +- .del = v4l2_ctrl_del_event, +- .replace = v4l2_ctrl_replace, +- .merge = v4l2_ctrl_merge, +-}; +-EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops); +- +-int v4l2_ctrl_log_status(struct file *file, void *fh) +-{ +- struct video_device *vfd = video_devdata(file); +- struct v4l2_fh *vfh = file->private_data; +- +- if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev) +- v4l2_ctrl_handler_log_status(vfh->ctrl_handler, +- vfd->v4l2_dev->name); +- return 0; +-} +-EXPORT_SYMBOL(v4l2_ctrl_log_status); +- +-int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh, +- const struct v4l2_event_subscription *sub) +-{ +- if (sub->type == V4L2_EVENT_CTRL) +- return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops); +- return -EINVAL; +-} +-EXPORT_SYMBOL(v4l2_ctrl_subscribe_event); +- +-int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh, +- struct v4l2_event_subscription *sub) +-{ +- if (!sd->ctrl_handler) +- return -EINVAL; +- return v4l2_ctrl_subscribe_event(fh, sub); +-} +-EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event); +- +-__poll_t v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait) +-{ +- struct v4l2_fh *fh = file->private_data; +- +- poll_wait(file, &fh->wait, wait); +- if (v4l2_event_pending(fh)) +- return EPOLLPRI; +- return 0; +-} +-EXPORT_SYMBOL(v4l2_ctrl_poll); +- +-int v4l2_ctrl_new_fwnode_properties(struct v4l2_ctrl_handler *hdl, +- const struct v4l2_ctrl_ops *ctrl_ops, +- const struct v4l2_fwnode_device_properties *p) +-{ +- if (p->orientation != V4L2_FWNODE_PROPERTY_UNSET) { +- u32 orientation_ctrl; +- +- switch (p->orientation) { +- case V4L2_FWNODE_ORIENTATION_FRONT: +- orientation_ctrl = V4L2_CAMERA_ORIENTATION_FRONT; +- break; +- case V4L2_FWNODE_ORIENTATION_BACK: +- orientation_ctrl = V4L2_CAMERA_ORIENTATION_BACK; +- break; +- case V4L2_FWNODE_ORIENTATION_EXTERNAL: +- orientation_ctrl = V4L2_CAMERA_ORIENTATION_EXTERNAL; +- break; +- default: +- return -EINVAL; +- } +- if (!v4l2_ctrl_new_std_menu(hdl, ctrl_ops, +- V4L2_CID_CAMERA_ORIENTATION, +- V4L2_CAMERA_ORIENTATION_EXTERNAL, 0, +- orientation_ctrl)) +- return hdl->error; +- } +- +- if (p->rotation != V4L2_FWNODE_PROPERTY_UNSET) { +- if (!v4l2_ctrl_new_std(hdl, ctrl_ops, +- V4L2_CID_CAMERA_SENSOR_ROTATION, +- p->rotation, p->rotation, 1, +- p->rotation)) +- return hdl->error; +- } +- +- return hdl->error; +-} +-EXPORT_SYMBOL(v4l2_ctrl_new_fwnode_properties); |