v4l2的结构体之ioctl

向右看齐 2022-11-10 14:57 228阅读 0赞

# v4l2的结构体之ioctl #

# struct v4l2\_ioctl\_ops #

## 介绍 ##

在应用程序获取视频数据的流程中，都是通过 ioctl 命令与驱动程序进行交互，结合实际需求，实现struct v4l2\_ioctl\_ops相关的成员即可。

## 定义 ##

struct v4l2_fh;
    
    /**
     * struct v4l2_ioctl_ops - describe operations for each V4L2 ioctl
     *
     * @vidioc_querycap: pointer to the function that implements
     *	:ref:`VIDIOC_QUERYCAP <vidioc_querycap>` ioctl
     * @vidioc_enum_fmt_vid_cap: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FMT <vidioc_enum_fmt>` ioctl logic
     *	for video capture in single plane mode
     * @vidioc_enum_fmt_vid_overlay: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FMT <vidioc_enum_fmt>` ioctl logic
     *	for video overlay
     * @vidioc_enum_fmt_vid_out: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FMT <vidioc_enum_fmt>` ioctl logic
     *	for video output in single plane mode
     * @vidioc_enum_fmt_vid_cap_mplane: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FMT <vidioc_enum_fmt>` ioctl logic
     *	for video capture in multiplane mode
     * @vidioc_enum_fmt_vid_out_mplane: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FMT <vidioc_enum_fmt>` ioctl logic
     *	for video output in multiplane mode
     * @vidioc_enum_fmt_sdr_cap: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FMT <vidioc_enum_fmt>` ioctl logic
     *	for Software Defined Radio capture
     * @vidioc_enum_fmt_sdr_out: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FMT <vidioc_enum_fmt>` ioctl logic
     *	for Software Defined Radio output
     * @vidioc_enum_fmt_meta_cap: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FMT <vidioc_enum_fmt>` ioctl logic
     *	for metadata capture
     * @vidioc_g_fmt_vid_cap: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for video capture
     *	in single plane mode
     * @vidioc_g_fmt_vid_overlay: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for video overlay
     * @vidioc_g_fmt_vid_out: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for video out
     *	in single plane mode
     * @vidioc_g_fmt_vid_out_overlay: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for video overlay output
     * @vidioc_g_fmt_vbi_cap: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for raw VBI capture
     * @vidioc_g_fmt_vbi_out: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for raw VBI output
     * @vidioc_g_fmt_sliced_vbi_cap: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for sliced VBI capture
     * @vidioc_g_fmt_sliced_vbi_out: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for sliced VBI output
     * @vidioc_g_fmt_vid_cap_mplane: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for video capture
     *	in multiple plane mode
     * @vidioc_g_fmt_vid_out_mplane: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for video out
     *	in multiplane plane mode
     * @vidioc_g_fmt_sdr_cap: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for Software Defined
     *	Radio capture
     * @vidioc_g_fmt_sdr_out: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for Software Defined
     *	Radio output
     * @vidioc_g_fmt_meta_cap: pointer to the function that implements
     *	:ref:`VIDIOC_G_FMT <vidioc_g_fmt>` ioctl logic for metadata capture
     * @vidioc_s_fmt_vid_cap: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for video capture
     *	in single plane mode
     * @vidioc_s_fmt_vid_overlay: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for video overlay
     * @vidioc_s_fmt_vid_out: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for video out
     *	in single plane mode
     * @vidioc_s_fmt_vid_out_overlay: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for video overlay output
     * @vidioc_s_fmt_vbi_cap: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for raw VBI capture
     * @vidioc_s_fmt_vbi_out: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for raw VBI output
     * @vidioc_s_fmt_sliced_vbi_cap: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for sliced VBI capture
     * @vidioc_s_fmt_sliced_vbi_out: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for sliced VBI output
     * @vidioc_s_fmt_vid_cap_mplane: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for video capture
     *	in multiple plane mode
     * @vidioc_s_fmt_vid_out_mplane: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for video out
     *	in multiplane plane mode
     * @vidioc_s_fmt_sdr_cap: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for Software Defined
     *	Radio capture
     * @vidioc_s_fmt_sdr_out: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for Software Defined
     *	Radio output
     * @vidioc_s_fmt_meta_cap: pointer to the function that implements
     *	:ref:`VIDIOC_S_FMT <vidioc_g_fmt>` ioctl logic for metadata capture
     * @vidioc_try_fmt_vid_cap: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for video capture
     *	in single plane mode
     * @vidioc_try_fmt_vid_overlay: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for video overlay
     * @vidioc_try_fmt_vid_out: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for video out
     *	in single plane mode
     * @vidioc_try_fmt_vid_out_overlay: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for video overlay
     *	output
     * @vidioc_try_fmt_vbi_cap: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for raw VBI capture
     * @vidioc_try_fmt_vbi_out: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for raw VBI output
     * @vidioc_try_fmt_sliced_vbi_cap: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for sliced VBI
     *	capture
     * @vidioc_try_fmt_sliced_vbi_out: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for sliced VBI output
     * @vidioc_try_fmt_vid_cap_mplane: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for video capture
     *	in multiple plane mode
     * @vidioc_try_fmt_vid_out_mplane: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for video out
     *	in multiplane plane mode
     * @vidioc_try_fmt_sdr_cap: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for Software Defined
     *	Radio capture
     * @vidioc_try_fmt_sdr_out: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for Software Defined
     *	Radio output
     * @vidioc_try_fmt_meta_cap: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_FMT <vidioc_g_fmt>` ioctl logic for metadata capture
     * @vidioc_reqbufs: pointer to the function that implements
     *	:ref:`VIDIOC_REQBUFS <vidioc_reqbufs>` ioctl
     * @vidioc_querybuf: pointer to the function that implements
     *	:ref:`VIDIOC_QUERYBUF <vidioc_querybuf>` ioctl
     * @vidioc_qbuf: pointer to the function that implements
     *	:ref:`VIDIOC_QBUF <vidioc_qbuf>` ioctl
     * @vidioc_expbuf: pointer to the function that implements
     *	:ref:`VIDIOC_EXPBUF <vidioc_expbuf>` ioctl
     * @vidioc_dqbuf: pointer to the function that implements
     *	:ref:`VIDIOC_DQBUF <vidioc_qbuf>` ioctl
     * @vidioc_create_bufs: pointer to the function that implements
     *	:ref:`VIDIOC_CREATE_BUFS <vidioc_create_bufs>` ioctl
     * @vidioc_prepare_buf: pointer to the function that implements
     *	:ref:`VIDIOC_PREPARE_BUF <vidioc_prepare_buf>` ioctl
     * @vidioc_overlay: pointer to the function that implements
     *	:ref:`VIDIOC_OVERLAY <vidioc_overlay>` ioctl
     * @vidioc_g_fbuf: pointer to the function that implements
     *	:ref:`VIDIOC_G_FBUF <vidioc_g_fbuf>` ioctl
     * @vidioc_s_fbuf: pointer to the function that implements
     *	:ref:`VIDIOC_S_FBUF <vidioc_g_fbuf>` ioctl
     * @vidioc_streamon: pointer to the function that implements
     *	:ref:`VIDIOC_STREAMON <vidioc_streamon>` ioctl
     * @vidioc_streamoff: pointer to the function that implements
     *	:ref:`VIDIOC_STREAMOFF <vidioc_streamon>` ioctl
     * @vidioc_g_std: pointer to the function that implements
     *	:ref:`VIDIOC_G_STD <vidioc_g_std>` ioctl
     * @vidioc_s_std: pointer to the function that implements
     *	:ref:`VIDIOC_S_STD <vidioc_g_std>` ioctl
     * @vidioc_querystd: pointer to the function that implements
     *	:ref:`VIDIOC_QUERYSTD <vidioc_querystd>` ioctl
     * @vidioc_enum_input: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_INPUT <vidioc_g_input>` ioctl
     * @vidioc_g_input: pointer to the function that implements
     *	:ref:`VIDIOC_G_INPUT <vidioc_g_input>` ioctl
     * @vidioc_s_input: pointer to the function that implements
     *	:ref:`VIDIOC_S_INPUT <vidioc_g_input>` ioctl
     * @vidioc_enum_output: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_OUTPUT <vidioc_g_output>` ioctl
     * @vidioc_g_output: pointer to the function that implements
     *	:ref:`VIDIOC_G_OUTPUT <vidioc_g_output>` ioctl
     * @vidioc_s_output: pointer to the function that implements
     *	:ref:`VIDIOC_S_OUTPUT <vidioc_g_output>` ioctl
     * @vidioc_queryctrl: pointer to the function that implements
     *	:ref:`VIDIOC_QUERYCTRL <vidioc_queryctrl>` ioctl
     * @vidioc_query_ext_ctrl: pointer to the function that implements
     *	:ref:`VIDIOC_QUERY_EXT_CTRL <vidioc_queryctrl>` ioctl
     * @vidioc_g_ctrl: pointer to the function that implements
     *	:ref:`VIDIOC_G_CTRL <vidioc_g_ctrl>` ioctl
     * @vidioc_s_ctrl: pointer to the function that implements
     *	:ref:`VIDIOC_S_CTRL <vidioc_g_ctrl>` ioctl
     * @vidioc_g_ext_ctrls: pointer to the function that implements
     *	:ref:`VIDIOC_G_EXT_CTRLS <vidioc_g_ext_ctrls>` ioctl
     * @vidioc_s_ext_ctrls: pointer to the function that implements
     *	:ref:`VIDIOC_S_EXT_CTRLS <vidioc_g_ext_ctrls>` ioctl
     * @vidioc_try_ext_ctrls: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_EXT_CTRLS <vidioc_g_ext_ctrls>` ioctl
     * @vidioc_querymenu: pointer to the function that implements
     *	:ref:`VIDIOC_QUERYMENU <vidioc_queryctrl>` ioctl
     * @vidioc_enumaudio: pointer to the function that implements
     *	:ref:`VIDIOC_ENUMAUDIO <vidioc_enumaudio>` ioctl
     * @vidioc_g_audio: pointer to the function that implements
     *	:ref:`VIDIOC_G_AUDIO <vidioc_g_audio>` ioctl
     * @vidioc_s_audio: pointer to the function that implements
     *	:ref:`VIDIOC_S_AUDIO <vidioc_g_audio>` ioctl
     * @vidioc_enumaudout: pointer to the function that implements
     *	:ref:`VIDIOC_ENUMAUDOUT <vidioc_enumaudout>` ioctl
     * @vidioc_g_audout: pointer to the function that implements
     *	:ref:`VIDIOC_G_AUDOUT <vidioc_g_audout>` ioctl
     * @vidioc_s_audout: pointer to the function that implements
     *	:ref:`VIDIOC_S_AUDOUT <vidioc_g_audout>` ioctl
     * @vidioc_g_modulator: pointer to the function that implements
     *	:ref:`VIDIOC_G_MODULATOR <vidioc_g_modulator>` ioctl
     * @vidioc_s_modulator: pointer to the function that implements
     *	:ref:`VIDIOC_S_MODULATOR <vidioc_g_modulator>` ioctl
     * @vidioc_cropcap: pointer to the function that implements
     *	:ref:`VIDIOC_CROPCAP <vidioc_cropcap>` ioctl
     * @vidioc_g_crop: pointer to the function that implements
     *	:ref:`VIDIOC_G_CROP <vidioc_g_crop>` ioctl
     * @vidioc_s_crop: pointer to the function that implements
     *	:ref:`VIDIOC_S_CROP <vidioc_g_crop>` ioctl
     * @vidioc_g_selection: pointer to the function that implements
     *	:ref:`VIDIOC_G_SELECTION <vidioc_g_selection>` ioctl
     * @vidioc_s_selection: pointer to the function that implements
     *	:ref:`VIDIOC_S_SELECTION <vidioc_g_selection>` ioctl
     * @vidioc_g_jpegcomp: pointer to the function that implements
     *	:ref:`VIDIOC_G_JPEGCOMP <vidioc_g_jpegcomp>` ioctl
     * @vidioc_s_jpegcomp: pointer to the function that implements
     *	:ref:`VIDIOC_S_JPEGCOMP <vidioc_g_jpegcomp>` ioctl
     * @vidioc_g_enc_index: pointer to the function that implements
     *	:ref:`VIDIOC_G_ENC_INDEX <vidioc_g_enc_index>` ioctl
     * @vidioc_encoder_cmd: pointer to the function that implements
     *	:ref:`VIDIOC_ENCODER_CMD <vidioc_encoder_cmd>` ioctl
     * @vidioc_try_encoder_cmd: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_ENCODER_CMD <vidioc_encoder_cmd>` ioctl
     * @vidioc_decoder_cmd: pointer to the function that implements
     *	:ref:`VIDIOC_DECODER_CMD <vidioc_decoder_cmd>` ioctl
     * @vidioc_try_decoder_cmd: pointer to the function that implements
     *	:ref:`VIDIOC_TRY_DECODER_CMD <vidioc_decoder_cmd>` ioctl
     * @vidioc_g_parm: pointer to the function that implements
     *	:ref:`VIDIOC_G_PARM <vidioc_g_parm>` ioctl
     * @vidioc_s_parm: pointer to the function that implements
     *	:ref:`VIDIOC_S_PARM <vidioc_g_parm>` ioctl
     * @vidioc_g_tuner: pointer to the function that implements
     *	:ref:`VIDIOC_G_TUNER <vidioc_g_tuner>` ioctl
     * @vidioc_s_tuner: pointer to the function that implements
     *	:ref:`VIDIOC_S_TUNER <vidioc_g_tuner>` ioctl
     * @vidioc_g_frequency: pointer to the function that implements
     *	:ref:`VIDIOC_G_FREQUENCY <vidioc_g_frequency>` ioctl
     * @vidioc_s_frequency: pointer to the function that implements
     *	:ref:`VIDIOC_S_FREQUENCY <vidioc_g_frequency>` ioctl
     * @vidioc_enum_freq_bands: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FREQ_BANDS <vidioc_enum_freq_bands>` ioctl
     * @vidioc_g_sliced_vbi_cap: pointer to the function that implements
     *	:ref:`VIDIOC_G_SLICED_VBI_CAP <vidioc_g_sliced_vbi_cap>` ioctl
     * @vidioc_log_status: pointer to the function that implements
     *	:ref:`VIDIOC_LOG_STATUS <vidioc_log_status>` ioctl
     * @vidioc_s_hw_freq_seek: pointer to the function that implements
     *	:ref:`VIDIOC_S_HW_FREQ_SEEK <vidioc_s_hw_freq_seek>` ioctl
     * @vidioc_g_register: pointer to the function that implements
     *	:ref:`VIDIOC_DBG_G_REGISTER <vidioc_dbg_g_register>` ioctl
     * @vidioc_s_register: pointer to the function that implements
     *	:ref:`VIDIOC_DBG_S_REGISTER <vidioc_dbg_g_register>` ioctl
     * @vidioc_g_chip_info: pointer to the function that implements
     *	:ref:`VIDIOC_DBG_G_CHIP_INFO <vidioc_dbg_g_chip_info>` ioctl
     * @vidioc_enum_framesizes: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FRAMESIZES <vidioc_enum_framesizes>` ioctl
     * @vidioc_enum_frameintervals: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_FRAMEINTERVALS <vidioc_enum_frameintervals>` ioctl
     * @vidioc_s_dv_timings: pointer to the function that implements
     *	:ref:`VIDIOC_S_DV_TIMINGS <vidioc_g_dv_timings>` ioctl
     * @vidioc_g_dv_timings: pointer to the function that implements
     *	:ref:`VIDIOC_G_DV_TIMINGS <vidioc_g_dv_timings>` ioctl
     * @vidioc_query_dv_timings: pointer to the function that implements
     *	:ref:`VIDIOC_QUERY_DV_TIMINGS <vidioc_query_dv_timings>` ioctl
     * @vidioc_enum_dv_timings: pointer to the function that implements
     *	:ref:`VIDIOC_ENUM_DV_TIMINGS <vidioc_enum_dv_timings>` ioctl
     * @vidioc_dv_timings_cap: pointer to the function that implements
     *	:ref:`VIDIOC_DV_TIMINGS_CAP <vidioc_dv_timings_cap>` ioctl
     * @vidioc_g_edid: pointer to the function that implements
     *	:ref:`VIDIOC_G_EDID <vidioc_g_edid>` ioctl
     * @vidioc_s_edid: pointer to the function that implements
     *	:ref:`VIDIOC_S_EDID <vidioc_g_edid>` ioctl
     * @vidioc_subscribe_event: pointer to the function that implements
     *	:ref:`VIDIOC_SUBSCRIBE_EVENT <vidioc_subscribe_event>` ioctl
     * @vidioc_unsubscribe_event: pointer to the function that implements
     *	:ref:`VIDIOC_UNSUBSCRIBE_EVENT <vidioc_unsubscribe_event>` ioctl
     * @vidioc_default: pointed used to allow other ioctls
     */
    struct v4l2_ioctl_ops {
    	/* ioctl callbacks */
    
    	/* VIDIOC_QUERYCAP handler */
    	int (*vidioc_querycap)(struct file *file, void *fh,
    			       struct v4l2_capability *cap);
    
    	/* VIDIOC_ENUM_FMT handlers */
    	int (*vidioc_enum_fmt_vid_cap)(struct file *file, void *fh,
    				       struct v4l2_fmtdesc *f);
    	int (*vidioc_enum_fmt_vid_overlay)(struct file *file, void *fh,
    					   struct v4l2_fmtdesc *f);
    	int (*vidioc_enum_fmt_vid_out)(struct file *file, void *fh,
    				       struct v4l2_fmtdesc *f);
    	int (*vidioc_enum_fmt_vid_cap_mplane)(struct file *file, void *fh,
    					      struct v4l2_fmtdesc *f);
    	int (*vidioc_enum_fmt_vid_out_mplane)(struct file *file, void *fh,
    					      struct v4l2_fmtdesc *f);
    	int (*vidioc_enum_fmt_sdr_cap)(struct file *file, void *fh,
    				       struct v4l2_fmtdesc *f);
    	int (*vidioc_enum_fmt_sdr_out)(struct file *file, void *fh,
    				       struct v4l2_fmtdesc *f);
    	int (*vidioc_enum_fmt_meta_cap)(struct file *file, void *fh,
    					struct v4l2_fmtdesc *f);
    
    	/* VIDIOC_G_FMT handlers */
    	int (*vidioc_g_fmt_vid_cap)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_g_fmt_vid_overlay)(struct file *file, void *fh,
    					struct v4l2_format *f);
    	int (*vidioc_g_fmt_vid_out)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_g_fmt_vid_out_overlay)(struct file *file, void *fh,
    					    struct v4l2_format *f);
    	int (*vidioc_g_fmt_vbi_cap)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_g_fmt_vbi_out)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_g_fmt_sliced_vbi_cap)(struct file *file, void *fh,
    					   struct v4l2_format *f);
    	int (*vidioc_g_fmt_sliced_vbi_out)(struct file *file, void *fh,
    					   struct v4l2_format *f);
    	int (*vidioc_g_fmt_vid_cap_mplane)(struct file *file, void *fh,
    					   struct v4l2_format *f);
    	int (*vidioc_g_fmt_vid_out_mplane)(struct file *file, void *fh,
    					   struct v4l2_format *f);
    	int (*vidioc_g_fmt_sdr_cap)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_g_fmt_sdr_out)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_g_fmt_meta_cap)(struct file *file, void *fh,
    				     struct v4l2_format *f);
    
    	/* VIDIOC_S_FMT handlers */
    	int (*vidioc_s_fmt_vid_cap)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_s_fmt_vid_overlay)(struct file *file, void *fh,
    					struct v4l2_format *f);
    	int (*vidioc_s_fmt_vid_out)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_s_fmt_vid_out_overlay)(struct file *file, void *fh,
    					    struct v4l2_format *f);
    	int (*vidioc_s_fmt_vbi_cap)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_s_fmt_vbi_out)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_s_fmt_sliced_vbi_cap)(struct file *file, void *fh,
    					   struct v4l2_format *f);
    	int (*vidioc_s_fmt_sliced_vbi_out)(struct file *file, void *fh,
    					   struct v4l2_format *f);
    	int (*vidioc_s_fmt_vid_cap_mplane)(struct file *file, void *fh,
    					   struct v4l2_format *f);
    	int (*vidioc_s_fmt_vid_out_mplane)(struct file *file, void *fh,
    					   struct v4l2_format *f);
    	int (*vidioc_s_fmt_sdr_cap)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_s_fmt_sdr_out)(struct file *file, void *fh,
    				    struct v4l2_format *f);
    	int (*vidioc_s_fmt_meta_cap)(struct file *file, void *fh,
    				     struct v4l2_format *f);
    
    	/* VIDIOC_TRY_FMT handlers */
    	int (*vidioc_try_fmt_vid_cap)(struct file *file, void *fh,
    				      struct v4l2_format *f);
    	int (*vidioc_try_fmt_vid_overlay)(struct file *file, void *fh,
    					  struct v4l2_format *f);
    	int (*vidioc_try_fmt_vid_out)(struct file *file, void *fh,
    				      struct v4l2_format *f);
    	int (*vidioc_try_fmt_vid_out_overlay)(struct file *file, void *fh,
    					     struct v4l2_format *f);
    	int (*vidioc_try_fmt_vbi_cap)(struct file *file, void *fh,
    				      struct v4l2_format *f);
    	int (*vidioc_try_fmt_vbi_out)(struct file *file, void *fh,
    				      struct v4l2_format *f);
    	int (*vidioc_try_fmt_sliced_vbi_cap)(struct file *file, void *fh,
    					     struct v4l2_format *f);
    	int (*vidioc_try_fmt_sliced_vbi_out)(struct file *file, void *fh,
    					     struct v4l2_format *f);
    	int (*vidioc_try_fmt_vid_cap_mplane)(struct file *file, void *fh,
    					     struct v4l2_format *f);
    	int (*vidioc_try_fmt_vid_out_mplane)(struct file *file, void *fh,
    					     struct v4l2_format *f);
    	int (*vidioc_try_fmt_sdr_cap)(struct file *file, void *fh,
    				      struct v4l2_format *f);
    	int (*vidioc_try_fmt_sdr_out)(struct file *file, void *fh,
    				      struct v4l2_format *f);
    	int (*vidioc_try_fmt_meta_cap)(struct file *file, void *fh,
    				       struct v4l2_format *f);
    
    	/* Buffer handlers */
    	int (*vidioc_reqbufs)(struct file *file, void *fh,
    			      struct v4l2_requestbuffers *b);
    	int (*vidioc_querybuf)(struct file *file, void *fh,
    			       struct v4l2_buffer *b);
    	int (*vidioc_qbuf)(struct file *file, void *fh,
    			   struct v4l2_buffer *b);
    	int (*vidioc_expbuf)(struct file *file, void *fh,
    			     struct v4l2_exportbuffer *e);
    	int (*vidioc_dqbuf)(struct file *file, void *fh,
    			    struct v4l2_buffer *b);
    
    	int (*vidioc_create_bufs)(struct file *file, void *fh,
    				  struct v4l2_create_buffers *b);
    	int (*vidioc_prepare_buf)(struct file *file, void *fh,
    				  struct v4l2_buffer *b);
    
    	int (*vidioc_overlay)(struct file *file, void *fh, unsigned int i);
    	int (*vidioc_g_fbuf)(struct file *file, void *fh,
    			     struct v4l2_framebuffer *a);
    	int (*vidioc_s_fbuf)(struct file *file, void *fh,
    			     const struct v4l2_framebuffer *a);
    
    		/* Stream on/off */
    	int (*vidioc_streamon)(struct file *file, void *fh,
    			       enum v4l2_buf_type i);
    	int (*vidioc_streamoff)(struct file *file, void *fh,
    				enum v4l2_buf_type i);
    
    		/*
    		 * Standard handling
    		 *
    		 * Note: ENUMSTD is handled by videodev.c
    		 */
    	int (*vidioc_g_std)(struct file *file, void *fh, v4l2_std_id *norm);
    	int (*vidioc_s_std)(struct file *file, void *fh, v4l2_std_id norm);
    	int (*vidioc_querystd)(struct file *file, void *fh, v4l2_std_id *a);
    
    		/* Input handling */
    	int (*vidioc_enum_input)(struct file *file, void *fh,
    				 struct v4l2_input *inp);
    	int (*vidioc_g_input)(struct file *file, void *fh, unsigned int *i);
    	int (*vidioc_s_input)(struct file *file, void *fh, unsigned int i);
    
    		/* Output handling */
    	int (*vidioc_enum_output)(struct file *file, void *fh,
    				  struct v4l2_output *a);
    	int (*vidioc_g_output)(struct file *file, void *fh, unsigned int *i);
    	int (*vidioc_s_output)(struct file *file, void *fh, unsigned int i);
    
    		/* Control handling */
    	int (*vidioc_queryctrl)(struct file *file, void *fh,
    				struct v4l2_queryctrl *a);
    	int (*vidioc_query_ext_ctrl)(struct file *file, void *fh,
    				     struct v4l2_query_ext_ctrl *a);
    	int (*vidioc_g_ctrl)(struct file *file, void *fh,
    			     struct v4l2_control *a);
    	int (*vidioc_s_ctrl)(struct file *file, void *fh,
    			     struct v4l2_control *a);
    	int (*vidioc_g_ext_ctrls)(struct file *file, void *fh,
    				  struct v4l2_ext_controls *a);
    	int (*vidioc_s_ext_ctrls)(struct file *file, void *fh,
    				  struct v4l2_ext_controls *a);
    	int (*vidioc_try_ext_ctrls)(struct file *file, void *fh,
    				    struct v4l2_ext_controls *a);
    	int (*vidioc_querymenu)(struct file *file, void *fh,
    				struct v4l2_querymenu *a);
    
    	/* Audio ioctls */
    	int (*vidioc_enumaudio)(struct file *file, void *fh,
    				struct v4l2_audio *a);
    	int (*vidioc_g_audio)(struct file *file, void *fh,
    			      struct v4l2_audio *a);
    	int (*vidioc_s_audio)(struct file *file, void *fh,
    			      const struct v4l2_audio *a);
    
    	/* Audio out ioctls */
    	int (*vidioc_enumaudout)(struct file *file, void *fh,
    				 struct v4l2_audioout *a);
    	int (*vidioc_g_audout)(struct file *file, void *fh,
    			       struct v4l2_audioout *a);
    	int (*vidioc_s_audout)(struct file *file, void *fh,
    			       const struct v4l2_audioout *a);
    	int (*vidioc_g_modulator)(struct file *file, void *fh,
    				  struct v4l2_modulator *a);
    	int (*vidioc_s_modulator)(struct file *file, void *fh,
    				  const struct v4l2_modulator *a);
    	/* Crop ioctls */
    	int (*vidioc_cropcap)(struct file *file, void *fh,
    			      struct v4l2_cropcap *a);
    	int (*vidioc_g_crop)(struct file *file, void *fh,
    			     struct v4l2_crop *a);
    	int (*vidioc_s_crop)(struct file *file, void *fh,
    			     const struct v4l2_crop *a);
    	int (*vidioc_g_selection)(struct file *file, void *fh,
    				  struct v4l2_selection *s);
    	int (*vidioc_s_selection)(struct file *file, void *fh,
    				  struct v4l2_selection *s);
    	/* Compression ioctls */
    	int (*vidioc_g_jpegcomp)(struct file *file, void *fh,
    				 struct v4l2_jpegcompression *a);
    	int (*vidioc_s_jpegcomp)(struct file *file, void *fh,
    				 const struct v4l2_jpegcompression *a);
    	int (*vidioc_g_enc_index)(struct file *file, void *fh,
    				  struct v4l2_enc_idx *a);
    	int (*vidioc_encoder_cmd)(struct file *file, void *fh,
    				  struct v4l2_encoder_cmd *a);
    	int (*vidioc_try_encoder_cmd)(struct file *file, void *fh,
    				      struct v4l2_encoder_cmd *a);
    	int (*vidioc_decoder_cmd)(struct file *file, void *fh,
    				  struct v4l2_decoder_cmd *a);
    	int (*vidioc_try_decoder_cmd)(struct file *file, void *fh,
    				      struct v4l2_decoder_cmd *a);
    
    	/* Stream type-dependent parameter ioctls */
    	int (*vidioc_g_parm)(struct file *file, void *fh,
    			     struct v4l2_streamparm *a);
    	int (*vidioc_s_parm)(struct file *file, void *fh,
    			     struct v4l2_streamparm *a);
    
    	/* Tuner ioctls */
    	int (*vidioc_g_tuner)(struct file *file, void *fh,
    			      struct v4l2_tuner *a);
    	int (*vidioc_s_tuner)(struct file *file, void *fh,
    			      const struct v4l2_tuner *a);
    	int (*vidioc_g_frequency)(struct file *file, void *fh,
    				  struct v4l2_frequency *a);
    	int (*vidioc_s_frequency)(struct file *file, void *fh,
    				  const struct v4l2_frequency *a);
    	int (*vidioc_enum_freq_bands)(struct file *file, void *fh,
    				      struct v4l2_frequency_band *band);
    
    	/* Sliced VBI cap */
    	int (*vidioc_g_sliced_vbi_cap)(struct file *file, void *fh,
    				       struct v4l2_sliced_vbi_cap *a);
    
    	/* Log status ioctl */
    	int (*vidioc_log_status)(struct file *file, void *fh);
    
    	int (*vidioc_s_hw_freq_seek)(struct file *file, void *fh,
    				     const struct v4l2_hw_freq_seek *a);
    
    	/* Debugging ioctls */
    #ifdef CONFIG_VIDEO_ADV_DEBUG
    	int (*vidioc_g_register)(struct file *file, void *fh,
    				 struct v4l2_dbg_register *reg);
    	int (*vidioc_s_register)(struct file *file, void *fh,
    				 const struct v4l2_dbg_register *reg);
    
    	int (*vidioc_g_chip_info)(struct file *file, void *fh,
    				  struct v4l2_dbg_chip_info *chip);
    #endif
    
    	int (*vidioc_enum_framesizes)(struct file *file, void *fh,
    				      struct v4l2_frmsizeenum *fsize);
    
    	int (*vidioc_enum_frameintervals)(struct file *file, void *fh,
    					  struct v4l2_frmivalenum *fival);
    
    	/* DV Timings IOCTLs */
    	int (*vidioc_s_dv_timings)(struct file *file, void *fh,
    				   struct v4l2_dv_timings *timings);
    	int (*vidioc_g_dv_timings)(struct file *file, void *fh,
    				   struct v4l2_dv_timings *timings);
    	int (*vidioc_query_dv_timings)(struct file *file, void *fh,
    				       struct v4l2_dv_timings *timings);
    	int (*vidioc_enum_dv_timings)(struct file *file, void *fh,
    				      struct v4l2_enum_dv_timings *timings);
    	int (*vidioc_dv_timings_cap)(struct file *file, void *fh,
    				     struct v4l2_dv_timings_cap *cap);
    	int (*vidioc_g_edid)(struct file *file, void *fh,
    			     struct v4l2_edid *edid);
    	int (*vidioc_s_edid)(struct file *file, void *fh,
    			     struct v4l2_edid *edid);
    
    	int (*vidioc_subscribe_event)(struct v4l2_fh *fh,
    				      const struct v4l2_event_subscription *sub);
    	int (*vidioc_unsubscribe_event)(struct v4l2_fh *fh,
    					const struct v4l2_event_subscription *sub);
    
    	/* For other private ioctls */
    	long (*vidioc_default)(struct file *file, void *fh,
    			       bool valid_prio, unsigned int cmd, void *arg);
    };

示例：

static const struct v4l2_ioctl_ops sun6i_video_ioctl_ops = {
    	.vidioc_querycap		= vidioc_querycap,
    	.vidioc_enum_fmt_vid_cap	= vidioc_enum_fmt_vid_cap,
    	.vidioc_g_fmt_vid_cap		= vidioc_g_fmt_vid_cap,
    	.vidioc_s_fmt_vid_cap		= vidioc_s_fmt_vid_cap,
    	.vidioc_try_fmt_vid_cap		= vidioc_try_fmt_vid_cap,
    
    	.vidioc_enum_input		= vidioc_enum_input,
    	.vidioc_s_input			= vidioc_s_input,
    	.vidioc_g_input			= vidioc_g_input,
    
    	.vidioc_reqbufs			= vb2_ioctl_reqbufs,
    	.vidioc_querybuf		= vb2_ioctl_querybuf,
    	.vidioc_qbuf			= vb2_ioctl_qbuf,
    	.vidioc_expbuf			= vb2_ioctl_expbuf,
    	.vidioc_dqbuf			= vb2_ioctl_dqbuf,
    	.vidioc_create_bufs		= vb2_ioctl_create_bufs,
    	.vidioc_prepare_buf		= vb2_ioctl_prepare_buf,
    	.vidioc_streamon		= vb2_ioctl_streamon,
    	.vidioc_streamoff		= vb2_ioctl_streamoff,
    
    	.vidioc_log_status		= v4l2_ctrl_log_status,
    	.vidioc_subscribe_event		= v4l2_ctrl_subscribe_event,
    	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
    };

说明  
将ioctl分类如下：

*  Query Capability:  
    查询设备支持的功能，只有VIDIOC\_QUERYCAP一个。
 *  优先级相关：  
    包括VIDIOC\_G\_PRIORITY,VIDIOC\_S\_PRIORITY,设置优先级。
 *  capture相关：视频捕获相关Ioctl。

<table> 
 <thead> 
  <tr> 
   <th>ID</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>VIDIOC_ENUM_FMT</td> 
   <td>枚举设备所支持的所有数据格式</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_FMT</td> 
   <td>设置数据格式</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_FMT</td> 
   <td>获取数据格式</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_TRY_FMT</td> 
   <td>与VIDIOC_S_FMT一样，但不会改变设备的状态</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_REQBUFS</td> 
   <td>向设备请求视频缓冲区，即初始化视频缓冲区</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_QUERYBUF</td> 
   <td>查询缓冲区的状态</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_QBUF</td> 
   <td>从设备获取一帧视频数据</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_DQBUF</td> 
   <td>将视频缓冲区归回给设备，</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_OVERLAY</td> 
   <td>开始或者停止overlay</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_FBUF</td> 
   <td>获取video overlay设备或OSD设备的framebuffer参数</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_FBUF</td> 
   <td>设置framebuffer参数</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_STREAMON</td> 
   <td>开始流I/O操作，capture or output device</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_STREAMOFF</td> 
   <td>关闭流I/O操作</td> 
  </tr> 
 </tbody> 
</table>

*  TV视频标准：TV Standard

<table> 
 <thead> 
  <tr> 
   <th>ID</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>VIDIOC_ENUMSTD</td> 
   <td>枚举设备支持的所有标准</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_STD</td> 
   <td>获取当前正在使用的标准</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_STD</td> 
   <td>设置视频标准</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_QUERYSTD</td> 
   <td>有的设备支持自动侦测输入源的视频标准，此时使用此ioctl查询侦测到的视频标准</td> 
  </tr> 
 </tbody> 
</table>

*  input/output

<table> 
 <thead> 
  <tr> 
   <th>ID</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>VIDIOC_ENUMINPUT</td> 
   <td>枚举所有input端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_INPUT</td> 
   <td>获取当前正在使用的input端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_INPUT</td> 
   <td>设置将要使用的input端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_ENUMOUTPUT</td> 
   <td>枚举所有output端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_OUTPUT</td> 
   <td>获取当前正在使用的output端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_OUTPUT</td> 
   <td>设置将要使用的output端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_ENUMAUDIO</td> 
   <td>枚举所有audio input端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_AUDIO</td> 
   <td>获取当前正在使用的audio input端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_AUDIO</td> 
   <td>设置将要使用的audio input端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_ENUMAUDOUT</td> 
   <td>枚举所有audio output端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_AUDOUT</td> 
   <td>获取当前正在使用的audio output端口</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_AUDOUT</td> 
   <td>设置将要使用的audio output端口</td> 
  </tr> 
 </tbody> 
</table>

*  controls：设备特定的控制，例如设置对比度，亮度

<table> 
 <thead> 
  <tr> 
   <th>ID</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>VIDIOC_QUERYCTRL</td> 
   <td>查询指定control的详细信息</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_CTRL</td> 
   <td>获取指定control的值</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_CTRL</td> 
   <td>设置指定control的值</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_EXT_CTRLS</td> 
   <td>获取多个control的值</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_EXT_CTRLS</td> 
   <td>设置多个control的值</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_TRY_EXT_CTRLS</td> 
   <td>与VIDIOC_S_EXT_CTRLS相同，但是不改变设备状态</td> 
  </tr> 
  <tr> 
   <td>VIDIOC_QUERYMENU</td> 
   <td>查询menu</td> 
  </tr> 
 </tbody> 
</table>

*  其他杂项：

<table> 
 <thead> 
  <tr> 
   <th>ID</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>VIDIOC_G_MODULATOR</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_MODULATOR</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_CROP</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_CROP</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_SELECTION</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_SELECTION</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_CROPCAP</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_ENC_INDEX</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_ENCODER_CMD</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_TRY_ENCODER_CMD</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_DECODER_CMD</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_TRY_DECODER_CMD</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_PARM</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_PARM</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_TUNER</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_TUNER</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_FREQUENCY</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_FREQUENCY</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_SLICED_VBI_CAP</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_LOG_STATUS</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_DBG_G_CHIP_IDENT</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_HW_FREQ_SEEK</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_ENUM_FRAMESIZES</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_ENUM_FRAMEINTERVALS</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_ENUM_DV_PRESETS</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_DV_PRESET</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_DV_PRESET</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_QUERY_DV_PRESET</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_S_DV_TIMINGS</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_G_DV_TIMINGS</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_DQEVENT</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_SUBSCRIBE_EVENT</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_UNSUBSCRIBE_EVENT</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_CREATE_BUFS</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>VIDIOC_PREPARE_BUF</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

## struct v4l2\_capability 与 VIDIOC\_QUERYCAP ##

struct v4l2_capability {
    	__u8	driver[16]; /* i.e. "sun6i-video" */
    	__u8	card[32];   /* i.e.  dev_name */
    	__u8	bus_info[32]; /* "PCI:" + pci_name(pci_dev) */
    	__u32   version;   /* should use KERNEL_VERSION() */
    	__u32	capabilities; /* Device capabilities */
    	__u32	device_caps;
    	__u32	reserved[3];
    };

其中域 capabilities 代表设备支持的操作模式，常见的值有 V4L2\_CAP\_VIDEO\_CAPTURE | V4L2\_CAP\_STREAMING 表示是一个视频捕捉设备并且具有数据流控制模式；另外 driver 域需要和 struct video\_device 中的 name 匹配。

## struct v4l2\_format 与 VIDIOC\_G\_FMT、VIDIOC\_S\_FMT、VIDIOC\_TRY\_FMT ##

struct v4l2_format {
    	__u32	 type;
    	union {
    		struct v4l2_pix_format		pix;     /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
    		struct v4l2_pix_format_mplane	pix_mp;  /* V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE */
    		struct v4l2_window		win;     /* V4L2_BUF_TYPE_VIDEO_OVERLAY */
    		struct v4l2_vbi_format		vbi;     /* V4L2_BUF_TYPE_VBI_CAPTURE */
    		struct v4l2_sliced_vbi_format	sliced;  /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */
    		struct v4l2_sdr_format		sdr;     /* V4L2_BUF_TYPE_SDR_CAPTURE */
    		struct v4l2_meta_format		meta;    /* V4L2_BUF_TYPE_META_CAPTURE */
    		__u8	raw_data[200];                   /* user-defined */
    	} fmt;
    };
    
    type如下：
    enum v4l2_buf_type {
    	V4L2_BUF_TYPE_VIDEO_CAPTURE        = 1,
    	V4L2_BUF_TYPE_VIDEO_OUTPUT         = 2,
    	V4L2_BUF_TYPE_VIDEO_OVERLAY        = 3,
    	V4L2_BUF_TYPE_VBI_CAPTURE          = 4,
    	V4L2_BUF_TYPE_VBI_OUTPUT           = 5,
    	V4L2_BUF_TYPE_SLICED_VBI_CAPTURE   = 6,
    	V4L2_BUF_TYPE_SLICED_VBI_OUTPUT    = 7,
    	V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
    	V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9,
    	V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE  = 10,
    	V4L2_BUF_TYPE_SDR_CAPTURE          = 11,
    	V4L2_BUF_TYPE_SDR_OUTPUT           = 12,
    	V4L2_BUF_TYPE_META_CAPTURE         = 13,
    	/* Deprecated, do not use */
    	V4L2_BUF_TYPE_PRIVATE              = 0x80,
    };
    
    
    /*
     *	V I D E O   I M A G E   F O R M A T
     */
    struct v4l2_pix_format {
    	__u32			width;
    	__u32			height;
    	__u32			pixelformat;
    	__u32			field;		/* enum v4l2_field */
    	__u32			bytesperline;	/* for padding, zero if unused */
    	__u32			sizeimage;
    	__u32			colorspace;	/* enum v4l2_colorspace */
    	__u32			priv;		/* private data, depends on pixelformat */
    	__u32			flags;		/* format flags (V4L2_PIX_FMT_FLAG_*) */
    	union {
    		/* enum v4l2_ycbcr_encoding */
    		__u32			ycbcr_enc;
    		/* enum v4l2_hsv_encoding */
    		__u32			hsv_enc;
    	};
    	__u32			quantization;	/* enum v4l2_quantization */
    	__u32			xfer_func;	/* enum v4l2_xfer_func */
    };
    
    
    struct v4l2_pix_format_mplane {
    	__u32				width;
    	__u32				height;
    	__u32				pixelformat;
    	__u32				field;
    	__u32				colorspace;
    
    	struct v4l2_plane_pix_format	plane_fmt[VIDEO_MAX_PLANES];
    	__u8				num_planes;
    	__u8				flags;
    	 union {
    		__u8				ycbcr_enc;
    		__u8				hsv_enc;
    	};
    	__u8				quantization;
    	__u8				xfer_func;
    	__u8				reserved[7];
    } __attribute__ ((packed));
    
    
    struct v4l2_window {
    	struct v4l2_rect        w;
    	__u32			field;	 /* enum v4l2_field */
    	__u32			chromakey;
    	struct v4l2_clip	__user *clips;
    	__u32			clipcount;
    	void			__user *bitmap;
    	__u8                    global_alpha;
    };
    
    /* Raw VBI */
    struct v4l2_vbi_format {
    	__u32	sampling_rate;		/* in 1 Hz */
    	__u32	offset;
    	__u32	samples_per_line;
    	__u32	sample_format;		/* V4L2_PIX_FMT_* */
    	__s32	start[2];
    	__u32	count[2];
    	__u32	flags;			/* V4L2_VBI_* */
    	__u32	reserved[2];		/* must be zero */
    };
    
    struct v4l2_sliced_vbi_format {
    	__u16   service_set;
    	/* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
    	   service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
    				 (equals frame lines 313-336 for 625 line video
    				  standards, 263-286 for 525 line standards) */
    	__u16   service_lines[2][24];
    	__u32   io_size;
    	__u32   reserved[2];            /* must be zero */
    };
    
    
    struct v4l2_sdr_format {
    	__u32				pixelformat;
    	__u32				buffersize;
    	__u8				reserved[24];
    } __attribute__ ((packed));
    
    struct v4l2_meta_format {
    	__u32				dataformat;
    	__u32				buffersize;
    } __attribute__ ((packed));

常见的捕获模式为 V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE 即视频捕捉模式，在此模式下 fmt 联合体采用域 v4l2\_pix\_format：其中 width 为视频的宽、height 为视频的高、pixelformat 为视频数据格式（常见的值有 V4L2\_PIX\_FMT\_YUV422P | V4L2\_PIX\_FMT\_RGB565）、bytesperline 为一行图像占用的字节数、sizeimage 则为图像占用的总字节数、colorspace 指定设备的颜色空间。

## struct v4l2\_requestbuffers 与 VIDIOC\_REQBUFS ##

/*
     *	M E M O R Y - M A P P I N G   B U F F E R S
     */
    struct v4l2_requestbuffers {
    	__u32			count;
    	__u32			type;		/* enum v4l2_buf_type */
    	__u32			memory;		/* enum v4l2_memory */
    	__u32			reserved[2];
    };
    
    enum v4l2_buf_type {
    	V4L2_BUF_TYPE_VIDEO_CAPTURE        = 1,
    	V4L2_BUF_TYPE_VIDEO_OUTPUT         = 2,
    	V4L2_BUF_TYPE_VIDEO_OVERLAY        = 3,
    	V4L2_BUF_TYPE_VBI_CAPTURE          = 4,
    	V4L2_BUF_TYPE_VBI_OUTPUT           = 5,
    	V4L2_BUF_TYPE_SLICED_VBI_CAPTURE   = 6,
    	V4L2_BUF_TYPE_SLICED_VBI_OUTPUT    = 7,
    	V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
    	V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9,
    	V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE  = 10,
    	V4L2_BUF_TYPE_SDR_CAPTURE          = 11,
    	V4L2_BUF_TYPE_SDR_OUTPUT           = 12,
    	V4L2_BUF_TYPE_META_CAPTURE         = 13,
    	/* Deprecated, do not use */
    	V4L2_BUF_TYPE_PRIVATE              = 0x80,
    };
    
    enum v4l2_memory {
    	V4L2_MEMORY_MMAP             = 1,
    	V4L2_MEMORY_USERPTR          = 2,
    	V4L2_MEMORY_OVERLAY          = 3,
    	V4L2_MEMORY_DMABUF           = 4,
    };

count 指定根据图像占用空间大小申请的缓存区个数，type 为视频捕获模式，memory 为内存区的使用方式。

## struct v4l2\_buffer与 VIDIOC\_QUERYBUF、VIDIOC\_QBUF、VIDIOC\_DQBUF ##

VIDIOC\_QUERYBUF 命令通过结构 v4l2\_buffer 查询驱动申请的内存区信息：

struct v4l2_buffer {
    	__u32			index;
    	__u32			type;
    	__u32			bytesused;
    	__u32			flags;
    	__u32			field;
    	struct timeval		timestamp;
    	struct v4l2_timecode	timecode;
    	__u32			sequence;
    
    	/* memory location */
    	__u32			memory;
    	union {
    		__u32           offset;
    		unsigned long   userptr;
    		struct v4l2_plane *planes;
    		__s32		fd;
    	} m;
    	__u32			length;
    	__u32			reserved2;
    	__u32			reserved;
    };

## enum v4l2\_buf\_type 与 VIDIOC\_STREAMON、VIDIOC\_STREAMOFF ##

这两个命令使用的只是一个整形数据，即 v4l2\_buf\_type，一般只要指定其值为 V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE 即可。

## struct v4l2\_queryctrl 与 VIDIOC\_QUERYCTRL ##

VIDIOC\_QUERYCTRL 命令通过结构 v4l2\_queryctrl 查询驱动是否支持该 id 代表的命令，并返回该命令的各种参数：

/*  Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
     struct v4l2_queryctrl {
         __u32                id;            /* 命令编号 */
         __u32		      type;	/* enum v4l2_ctrl_type 命令值的类型 */
         __u8                 name[32];        /* 命令名称*/
         __s32                minimum;       /* 最小的命令值 */
         __s32                maximum;       /* 最大的命令值 */
         __s32                step;          /* 命令值变化的步长 */
         __s32                default_value; /* 默认的命令值 */
        __u32                flags;         /* 命令的标志 */
        __u32                reserved[2];   /* 命令值的位图表示 */
    };
    
    enum v4l2_ctrl_type {
        V4L2_CTRL_TYPE_INTEGER       = 1,   /* 整形 */
        V4L2_CTRL_TYPE_BOOLEAN       = 2,   /* 真值 */
        V4L2_CTRL_TYPE_MENU          = 3,   /* 菜单 */
        V4L2_CTRL_TYPE_BUTTON        = 4,   /* 无值 */
        V4L2_CTRL_TYPE_INTEGER64     = 5,   /* 后面三种不常用 */
        V4L2_CTRL_TYPE_CTRL_CLASS    = 6
        V4L2_CTRL_TYPE_STRING        = 7,
        V4L2_CTRL_TYPE_BITMASK       = 8,
        V4L2_CTRL_TYPE_INTEGER_MENU  = 9,
    
        /* Compound types are >= 0x0100 */
        V4L2_CTRL_COMPOUND_TYPES    = 0x0100,
        V4L2_CTRL_TYPE_U8	     = 0x0100,
        V4L2_CTRL_TYPE_U16	     = 0x0101,
        V4L2_CTRL_TYPE_U32	     = 0x0102,
    };

命令的标志取值如下：

/*  Control flags  */
    #define V4L2_CTRL_FLAG_DISABLED       0x0001
    #define V4L2_CTRL_FLAG_GRABBED        0x0002
    #define V4L2_CTRL_FLAG_READ_ONLY      0x0004
    #define V4L2_CTRL_FLAG_UPDATE         0x0008
    #define V4L2_CTRL_FLAG_INACTIVE       0x0010
    #define V4L2_CTRL_FLAG_SLIDER         0x0020
    #define V4L2_CTRL_FLAG_WRITE_ONLY     0x0040

id 是命令的编号，常见的命令有两种：一种以 V4L2\_CID\_BASE 为起始值，是公用命令；一种以 V4L2\_CID\_PRIVATE\_BASE 为起始值，是私有命令。在一般的应用中命令值可见如下：

#define V4L2_CID_BASE		(V4L2_CTRL_CLASS_USER | 0x900)
    #define V4L2_CID_USER_BASE		V4L2_CID_BASE
    #define V4L2_CID_USER_CLASS		(V4L2_CTRL_CLASS_USER | 1)
    #define V4L2_CID_BRIGHTNESS		(V4L2_CID_BASE+0)
    #define V4L2_CID_CONTRAST		(V4L2_CID_BASE+1) /* 对比度调节 */
    #define V4L2_CID_SATURATION		(V4L2_CID_BASE+2) /* 饱和度调节 */
    #define V4L2_CID_HUE			(V4L2_CID_BASE+3)
    #define V4L2_CID_AUDIO_VOLUME		(V4L2_CID_BASE+5) /* 音量调节 */
    #define V4L2_CID_AUDIO_BALANCE		(V4L2_CID_BASE+6)
    #define V4L2_CID_AUDIO_BASS		(V4L2_CID_BASE+7)
    #define V4L2_CID_AUDIO_TREBLE		(V4L2_CID_BASE+8)
    #define V4L2_CID_AUDIO_MUTE		(V4L2_CID_BASE+9) /* 静音设置 */
    #define V4L2_CID_AUDIO_LOUDNESS		(V4L2_CID_BASE+10)
    #define V4L2_CID_BLACK_LEVEL		(V4L2_CID_BASE+11) /* Deprecated */
    #define V4L2_CID_AUTO_WHITE_BALANCE	(V4L2_CID_BASE+12)
    #define V4L2_CID_DO_WHITE_BALANCE	(V4L2_CID_BASE+13) /* 白平衡调节 */
    #define V4L2_CID_RED_BALANCE		(V4L2_CID_BASE+14)
    #define V4L2_CID_BLUE_BALANCE		(V4L2_CID_BASE+15)
    #define V4L2_CID_GAMMA			(V4L2_CID_BASE+16) /* 伽马值调节 */
    #define V4L2_CID_WHITENESS		(V4L2_CID_GAMMA) /* Deprecated */
    #define V4L2_CID_EXPOSURE		(V4L2_CID_BASE+17) /* 曝光度调节 */
    #define V4L2_CID_AUTOGAIN		(V4L2_CID_BASE+18)
    #define V4L2_CID_GAIN			(V4L2_CID_BASE+19)
    #define V4L2_CID_HFLIP			(V4L2_CID_BASE+20)
    #define V4L2_CID_VFLIP			(V4L2_CID_BASE+21)

type 为命令值的类型（总共有7中类型的值），name 是命令的名称，reserved 则是命令值的位图表示，驱动会将所有的命令值都以 bit 的形式写到 64 位的域中，上层应用查询时可以根据位图判断命令支持的值。

## ioctl的实现video\_ioctl2 ##

源码来自linux-4.19.123。

long video_ioctl2(struct file *file,
    	       unsigned int cmd, unsigned long arg)
    {
    	return video_usercopy(file, cmd, arg, __video_do_ioctl);
    }

long
    video_usercopy(struct file *file, unsigned int cmd, unsigned long arg,
    	       v4l2_kioctl func)
    {
    	char	sbuf[128];
    	void    *mbuf = NULL;
    	void	*parg = (void *)arg;
    	long	err  = -EINVAL;
    	bool	has_array_args;
    	bool	always_copy = false;
    	size_t  array_size = 0;
    	void __user *user_ptr = NULL;
    	void	**kernel_ptr = NULL;
    	const size_t ioc_size = _IOC_SIZE(cmd);
    
    	/*  Copy arguments into temp kernel buffer  */
       /* 判断是否包含读写命令,如果是则将用户空间的参数值拷贝到内核 */
    	if (_IOC_DIR(cmd) != _IOC_NONE) {
               /* 判断参数大小是否超过128字节 */
    		if (ioc_size <= sizeof(sbuf)) {
    			parg = sbuf;
    		} else {
    			/* too big to allocate from stack */
                       /* 如果超过128字节则从堆中申请 */
    			mbuf = kvmalloc(ioc_size, GFP_KERNEL);
    			if (NULL == mbuf)
    				return -ENOMEM;
    			parg = mbuf;
    		}
    
    		err = -EFAULT;
    		if (_IOC_DIR(cmd) & _IOC_WRITE) {
    			unsigned int n = ioc_size;
    
    			/*
    			 * In some cases, only a few fields are used as input,
    			 * i.e. when the app sets "index" and then the driver
    			 * fills in the rest of the structure for the thing
    			 * with that index.  We only need to copy up the first
    			 * non-input field.
    			 */
                        /* 确认命令是否为支持命令 */
    			if (v4l2_is_known_ioctl(cmd)) {
                               /* 计算需要拷贝的有效数据长度,有的命令不需要全部拷贝 */
    				u32 flags = v4l2_ioctls[_IOC_NR(cmd)].flags;
    
    				if (flags & INFO_FL_CLEAR_MASK)
    					n = (flags & INFO_FL_CLEAR_MASK) >> 16;
    				always_copy = flags & INFO_FL_ALWAYS_COPY;
    			}
                        /* 从用户空间拷贝参数值 */
    			if (copy_from_user(parg, (void __user *)arg, n))
    				goto out;
    
    			/* zero out anything we don't copy from userspace */
                       /* 将剩下的空间清零 */
    			if (n < ioc_size)
    				memset((u8 *)parg + n, 0, ioc_size - n);
    		} else {
    			/* read-only ioctl */
                       /* 如果是只读命令则将整个buffer清零 */
    			memset(parg, 0, ioc_size);
    		}
    	}
    
        /* 特殊命令个性化操作 */
    	err = check_array_args(cmd, parg, &array_size, &user_ptr, &kernel_ptr);
    	if (err < 0)
    		goto out;
    	has_array_args = err;
    
    	if (has_array_args) {
    		/*
    		 * When adding new types of array args, make sure that the
    		 * parent argument to ioctl (which contains the pointer to the
    		 * array) fits into sbuf (so that mbuf will still remain
    		 * unused up to here).
    		 */
    		mbuf = kvmalloc(array_size, GFP_KERNEL);
    		err = -ENOMEM;
    		if (NULL == mbuf)
    			goto out_array_args;
    		err = -EFAULT;
    		if (copy_from_user(mbuf, user_ptr, array_size))
    			goto out_array_args;
    		*kernel_ptr = mbuf;
    	}
    
    	/* Handles IOCTL */
       /* 调用 v4l2_ioctl_ops 的成员函数处理命令 */
    	err = func(file, cmd, parg);
    	if (err == -ENOTTY || err == -ENOIOCTLCMD) {
    		err = -ENOTTY;
    		goto out;
    	}
    
    	if (err == 0) {
    		if (cmd == VIDIOC_DQBUF)
    			trace_v4l2_dqbuf(video_devdata(file)->minor, parg);
    		else if (cmd == VIDIOC_QBUF)
    			trace_v4l2_qbuf(video_devdata(file)->minor, parg);
    	}
    
    	if (has_array_args) {
    		*kernel_ptr = (void __force *)user_ptr;
    		if (copy_to_user(user_ptr, mbuf, array_size))
    			err = -EFAULT;
    		goto out_array_args;
    	}
    	/*
    	 * Some ioctls can return an error, but still have valid
    	 * results that must be returned.
    	 */
    	if (err < 0 && !always_copy)
    		goto out;
    
    out_array_args:
    	/*  Copy results into user buffer  */
      /* 如果包含读命令则将参数值拷贝到用户空间 */
    	switch (_IOC_DIR(cmd)) {
    	case _IOC_READ:
    	case (_IOC_WRITE | _IOC_READ):
    		if (copy_to_user((void __user *)arg, parg, ioc_size))
    			err = -EFAULT;
    		break;
    	}
    
    out:
    	kvfree(mbuf);
    	return err;
    }

static int check_array_args(unsigned int cmd, void *parg, size_t *array_size,
    			    void __user **user_ptr, void ***kernel_ptr)
    {
    	int ret = 0;
    
    	switch (cmd) {
    	case VIDIOC_PREPARE_BUF:
    	case VIDIOC_QUERYBUF:
    	case VIDIOC_QBUF:
    	case VIDIOC_DQBUF: {
    		struct v4l2_buffer *buf = parg;
    
    		if (V4L2_TYPE_IS_MULTIPLANAR(buf->type) && buf->length > 0) {
    			if (buf->length > VIDEO_MAX_PLANES) {
    				ret = -EINVAL;
    				break;
    			}
    			*user_ptr = (void __user *)buf->m.planes;
    			*kernel_ptr = (void **)&buf->m.planes;
    			*array_size = sizeof(struct v4l2_plane) * buf->length;
    			ret = 1;
    		}
    		break;
    	}
    
    	case VIDIOC_G_EDID:
    	case VIDIOC_S_EDID: {
    		struct v4l2_edid *edid = parg;
    
    		if (edid->blocks) {
    			if (edid->blocks > 256) {
    				ret = -EINVAL;
    				break;
    			}
    			*user_ptr = (void __user *)edid->edid;
    			*kernel_ptr = (void **)&edid->edid;
    			*array_size = edid->blocks * 128;
    			ret = 1;
    		}
    		break;
    	}
    
    	case VIDIOC_S_EXT_CTRLS:
    	case VIDIOC_G_EXT_CTRLS:
    	case VIDIOC_TRY_EXT_CTRLS: {
    		struct v4l2_ext_controls *ctrls = parg;
    
    		if (ctrls->count != 0) {
    			if (ctrls->count > V4L2_CID_MAX_CTRLS) {
    				ret = -EINVAL;
    				break;
    			}
    			*user_ptr = (void __user *)ctrls->controls;
    			*kernel_ptr = (void **)&ctrls->controls;
    			*array_size = sizeof(struct v4l2_ext_control)
    				    * ctrls->count;
    			ret = 1;
    		}
    		break;
    	}
    	}
    
    	return ret;
    }

static long __video_do_ioctl(struct file *file,
    		unsigned int cmd, void *arg)
    {
    	struct video_device *vfd = video_devdata(file);
    	struct mutex *lock; /* ioctl serialization mutex */
    	const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
    	bool write_only = false;
    	struct v4l2_ioctl_info default_info;
    	const struct v4l2_ioctl_info *info;
    	void *fh = file->private_data;
    	struct v4l2_fh *vfh = NULL;
    	int dev_debug = vfd->dev_debug;
    	long ret = -ENOTTY;
    
    	if (ops == NULL) {
    		pr_warn("%s: has no ioctl_ops.\n",
    				video_device_node_name(vfd));
    		return ret;
    	}
    
    	if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags))
    		vfh = file->private_data;
    
    	lock = v4l2_ioctl_get_lock(vfd, vfh, cmd, arg);
    
    	if (lock && mutex_lock_interruptible(lock))
    		return -ERESTARTSYS;
    
    	if (!video_is_registered(vfd)) {
    		ret = -ENODEV;
    		goto unlock;
    	}
    
    	if (v4l2_is_known_ioctl(cmd)) {
    		info = &v4l2_ioctls[_IOC_NR(cmd)];
    
    		if (!test_bit(_IOC_NR(cmd), vfd->valid_ioctls) &&
    		    !((info->flags & INFO_FL_CTRL) && vfh && vfh->ctrl_handler))
    			goto done;
    
    		if (vfh && (info->flags & INFO_FL_PRIO)) {
    			ret = v4l2_prio_check(vfd->prio, vfh->prio);
    			if (ret)
    				goto done;
    		}
    	} else {
    		default_info.ioctl = cmd;
    		default_info.flags = 0;
    		default_info.debug = v4l_print_default;
    		info = &default_info;
    	}
    
    	write_only = _IOC_DIR(cmd) == _IOC_WRITE;
    	if (info != &default_info) {
    		ret = info->func(ops, file, fh, arg);
    	} else if (!ops->vidioc_default) {
    		ret = -ENOTTY;
    	} else {
    		ret = ops->vidioc_default(file, fh,
    			vfh ? v4l2_prio_check(vfd->prio, vfh->prio) >= 0 : 0,
    			cmd, arg);
    	}
    
    done:
    	if (dev_debug & (V4L2_DEV_DEBUG_IOCTL | V4L2_DEV_DEBUG_IOCTL_ARG)) {
    		if (!(dev_debug & V4L2_DEV_DEBUG_STREAMING) &&
    		    (cmd == VIDIOC_QBUF || cmd == VIDIOC_DQBUF))
    			goto unlock;
    
    		v4l_printk_ioctl(video_device_node_name(vfd), cmd);
    		if (ret < 0)
    			pr_cont(": error %ld", ret);
    		if (!(dev_debug & V4L2_DEV_DEBUG_IOCTL_ARG))
    			pr_cont("\n");
    		else if (_IOC_DIR(cmd) == _IOC_NONE)
    			info->debug(arg, write_only);
    		else {
    			pr_cont(": ");
    			info->debug(arg, write_only);
    		}
    	}
    
    unlock:
    	if (lock)
    		mutex_unlock(lock);
    	return ret;
    }

static bool v4l2_is_known_ioctl(unsigned int cmd)
    {
    	if (_IOC_NR(cmd) >= V4L2_IOCTLS)
    		return false;
    	return v4l2_ioctls[_IOC_NR(cmd)].ioctl == cmd;
    }

v4l2\_ioctls定义如下：

static struct v4l2_ioctl_info v4l2_ioctls[] = {
    	IOCTL_INFO(VIDIOC_QUERYCAP, v4l_querycap, v4l_print_querycap, 0),
    	IOCTL_INFO(VIDIOC_ENUM_FMT, v4l_enum_fmt, v4l_print_fmtdesc, INFO_FL_CLEAR(v4l2_fmtdesc, type)),
    	IOCTL_INFO(VIDIOC_G_FMT, v4l_g_fmt, v4l_print_format, 0),
    	IOCTL_INFO(VIDIOC_S_FMT, v4l_s_fmt, v4l_print_format, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_REQBUFS, v4l_reqbufs, v4l_print_requestbuffers, INFO_FL_PRIO | INFO_FL_QUEUE),
    	IOCTL_INFO(VIDIOC_QUERYBUF, v4l_querybuf, v4l_print_buffer, INFO_FL_QUEUE | INFO_FL_CLEAR(v4l2_buffer, length)),
    	IOCTL_INFO(VIDIOC_G_FBUF, v4l_stub_g_fbuf, v4l_print_framebuffer, 0),
    	IOCTL_INFO(VIDIOC_S_FBUF, v4l_stub_s_fbuf, v4l_print_framebuffer, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_OVERLAY, v4l_overlay, v4l_print_u32, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_QBUF, v4l_qbuf, v4l_print_buffer, INFO_FL_QUEUE),
    	IOCTL_INFO(VIDIOC_EXPBUF, v4l_stub_expbuf, v4l_print_exportbuffer, INFO_FL_QUEUE | INFO_FL_CLEAR(v4l2_exportbuffer, flags)),
    	IOCTL_INFO(VIDIOC_DQBUF, v4l_dqbuf, v4l_print_buffer, INFO_FL_QUEUE),
    	IOCTL_INFO(VIDIOC_STREAMON, v4l_streamon, v4l_print_buftype, INFO_FL_PRIO | INFO_FL_QUEUE),
    	IOCTL_INFO(VIDIOC_STREAMOFF, v4l_streamoff, v4l_print_buftype, INFO_FL_PRIO | INFO_FL_QUEUE),
    	IOCTL_INFO(VIDIOC_G_PARM, v4l_g_parm, v4l_print_streamparm, INFO_FL_CLEAR(v4l2_streamparm, type)),
    	IOCTL_INFO(VIDIOC_S_PARM, v4l_s_parm, v4l_print_streamparm, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_G_STD, v4l_stub_g_std, v4l_print_std, 0),
    	IOCTL_INFO(VIDIOC_S_STD, v4l_s_std, v4l_print_std, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_ENUMSTD, v4l_enumstd, v4l_print_standard, INFO_FL_CLEAR(v4l2_standard, index)),
    	IOCTL_INFO(VIDIOC_ENUMINPUT, v4l_enuminput, v4l_print_enuminput, INFO_FL_CLEAR(v4l2_input, index)),
    	IOCTL_INFO(VIDIOC_G_CTRL, v4l_g_ctrl, v4l_print_control, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_control, id)),
    	IOCTL_INFO(VIDIOC_S_CTRL, v4l_s_ctrl, v4l_print_control, INFO_FL_PRIO | INFO_FL_CTRL),
    	IOCTL_INFO(VIDIOC_G_TUNER, v4l_g_tuner, v4l_print_tuner, INFO_FL_CLEAR(v4l2_tuner, index)),
    	IOCTL_INFO(VIDIOC_S_TUNER, v4l_s_tuner, v4l_print_tuner, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_G_AUDIO, v4l_stub_g_audio, v4l_print_audio, 0),
    	IOCTL_INFO(VIDIOC_S_AUDIO, v4l_stub_s_audio, v4l_print_audio, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_QUERYCTRL, v4l_queryctrl, v4l_print_queryctrl, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_queryctrl, id)),
    	IOCTL_INFO(VIDIOC_QUERYMENU, v4l_querymenu, v4l_print_querymenu, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_querymenu, index)),
    	IOCTL_INFO(VIDIOC_G_INPUT, v4l_stub_g_input, v4l_print_u32, 0),
    	IOCTL_INFO(VIDIOC_S_INPUT, v4l_s_input, v4l_print_u32, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_G_EDID, v4l_stub_g_edid, v4l_print_edid, INFO_FL_ALWAYS_COPY),
    	IOCTL_INFO(VIDIOC_S_EDID, v4l_stub_s_edid, v4l_print_edid, INFO_FL_PRIO | INFO_FL_ALWAYS_COPY),
    	IOCTL_INFO(VIDIOC_G_OUTPUT, v4l_stub_g_output, v4l_print_u32, 0),
    	IOCTL_INFO(VIDIOC_S_OUTPUT, v4l_s_output, v4l_print_u32, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_ENUMOUTPUT, v4l_enumoutput, v4l_print_enumoutput, INFO_FL_CLEAR(v4l2_output, index)),
    	IOCTL_INFO(VIDIOC_G_AUDOUT, v4l_stub_g_audout, v4l_print_audioout, 0),
    	IOCTL_INFO(VIDIOC_S_AUDOUT, v4l_stub_s_audout, v4l_print_audioout, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_G_MODULATOR, v4l_g_modulator, v4l_print_modulator, INFO_FL_CLEAR(v4l2_modulator, index)),
    	IOCTL_INFO(VIDIOC_S_MODULATOR, v4l_s_modulator, v4l_print_modulator, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_G_FREQUENCY, v4l_g_frequency, v4l_print_frequency, INFO_FL_CLEAR(v4l2_frequency, tuner)),
    	IOCTL_INFO(VIDIOC_S_FREQUENCY, v4l_s_frequency, v4l_print_frequency, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_CROPCAP, v4l_cropcap, v4l_print_cropcap, INFO_FL_CLEAR(v4l2_cropcap, type)),
    	IOCTL_INFO(VIDIOC_G_CROP, v4l_g_crop, v4l_print_crop, INFO_FL_CLEAR(v4l2_crop, type)),
    	IOCTL_INFO(VIDIOC_S_CROP, v4l_s_crop, v4l_print_crop, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_G_SELECTION, v4l_g_selection, v4l_print_selection, INFO_FL_CLEAR(v4l2_selection, r)),
    	IOCTL_INFO(VIDIOC_S_SELECTION, v4l_s_selection, v4l_print_selection, INFO_FL_PRIO | INFO_FL_CLEAR(v4l2_selection, r)),
    	IOCTL_INFO(VIDIOC_G_JPEGCOMP, v4l_stub_g_jpegcomp, v4l_print_jpegcompression, 0),
    	IOCTL_INFO(VIDIOC_S_JPEGCOMP, v4l_stub_s_jpegcomp, v4l_print_jpegcompression, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_QUERYSTD, v4l_querystd, v4l_print_std, 0),
    	IOCTL_INFO(VIDIOC_TRY_FMT, v4l_try_fmt, v4l_print_format, 0),
    	IOCTL_INFO(VIDIOC_ENUMAUDIO, v4l_stub_enumaudio, v4l_print_audio, INFO_FL_CLEAR(v4l2_audio, index)),
    	IOCTL_INFO(VIDIOC_ENUMAUDOUT, v4l_stub_enumaudout, v4l_print_audioout, INFO_FL_CLEAR(v4l2_audioout, index)),
    	IOCTL_INFO(VIDIOC_G_PRIORITY, v4l_g_priority, v4l_print_u32, 0),
    	IOCTL_INFO(VIDIOC_S_PRIORITY, v4l_s_priority, v4l_print_u32, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_G_SLICED_VBI_CAP, v4l_g_sliced_vbi_cap, v4l_print_sliced_vbi_cap, INFO_FL_CLEAR(v4l2_sliced_vbi_cap, type)),
    	IOCTL_INFO(VIDIOC_LOG_STATUS, v4l_log_status, v4l_print_newline, 0),
    	IOCTL_INFO(VIDIOC_G_EXT_CTRLS, v4l_g_ext_ctrls, v4l_print_ext_controls, INFO_FL_CTRL),
    	IOCTL_INFO(VIDIOC_S_EXT_CTRLS, v4l_s_ext_ctrls, v4l_print_ext_controls, INFO_FL_PRIO | INFO_FL_CTRL),
    	IOCTL_INFO(VIDIOC_TRY_EXT_CTRLS, v4l_try_ext_ctrls, v4l_print_ext_controls, INFO_FL_CTRL),
    	IOCTL_INFO(VIDIOC_ENUM_FRAMESIZES, v4l_stub_enum_framesizes, v4l_print_frmsizeenum, INFO_FL_CLEAR(v4l2_frmsizeenum, pixel_format)),
    	IOCTL_INFO(VIDIOC_ENUM_FRAMEINTERVALS, v4l_stub_enum_frameintervals, v4l_print_frmivalenum, INFO_FL_CLEAR(v4l2_frmivalenum, height)),
    	IOCTL_INFO(VIDIOC_G_ENC_INDEX, v4l_stub_g_enc_index, v4l_print_enc_idx, 0),
    	IOCTL_INFO(VIDIOC_ENCODER_CMD, v4l_stub_encoder_cmd, v4l_print_encoder_cmd, INFO_FL_PRIO | INFO_FL_CLEAR(v4l2_encoder_cmd, flags)),
    	IOCTL_INFO(VIDIOC_TRY_ENCODER_CMD, v4l_stub_try_encoder_cmd, v4l_print_encoder_cmd, INFO_FL_CLEAR(v4l2_encoder_cmd, flags)),
    	IOCTL_INFO(VIDIOC_DECODER_CMD, v4l_stub_decoder_cmd, v4l_print_decoder_cmd, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_TRY_DECODER_CMD, v4l_stub_try_decoder_cmd, v4l_print_decoder_cmd, 0),
    	IOCTL_INFO(VIDIOC_DBG_S_REGISTER, v4l_dbg_s_register, v4l_print_dbg_register, 0),
    	IOCTL_INFO(VIDIOC_DBG_G_REGISTER, v4l_dbg_g_register, v4l_print_dbg_register, 0),
    	IOCTL_INFO(VIDIOC_S_HW_FREQ_SEEK, v4l_s_hw_freq_seek, v4l_print_hw_freq_seek, INFO_FL_PRIO),
    	IOCTL_INFO(VIDIOC_S_DV_TIMINGS, v4l_stub_s_dv_timings, v4l_print_dv_timings, INFO_FL_PRIO | INFO_FL_CLEAR(v4l2_dv_timings, bt.flags)),
    	IOCTL_INFO(VIDIOC_G_DV_TIMINGS, v4l_stub_g_dv_timings, v4l_print_dv_timings, 0),
    	IOCTL_INFO(VIDIOC_DQEVENT, v4l_dqevent, v4l_print_event, 0),
    	IOCTL_INFO(VIDIOC_SUBSCRIBE_EVENT, v4l_subscribe_event, v4l_print_event_subscription, 0),
    	IOCTL_INFO(VIDIOC_UNSUBSCRIBE_EVENT, v4l_unsubscribe_event, v4l_print_event_subscription, 0),
    	IOCTL_INFO(VIDIOC_CREATE_BUFS, v4l_create_bufs, v4l_print_create_buffers, INFO_FL_PRIO | INFO_FL_QUEUE),
    	IOCTL_INFO(VIDIOC_PREPARE_BUF, v4l_prepare_buf, v4l_print_buffer, INFO_FL_QUEUE),
    	IOCTL_INFO(VIDIOC_ENUM_DV_TIMINGS, v4l_stub_enum_dv_timings, v4l_print_enum_dv_timings, INFO_FL_CLEAR(v4l2_enum_dv_timings, pad)),
    	IOCTL_INFO(VIDIOC_QUERY_DV_TIMINGS, v4l_stub_query_dv_timings, v4l_print_dv_timings, INFO_FL_ALWAYS_COPY),
    	IOCTL_INFO(VIDIOC_DV_TIMINGS_CAP, v4l_stub_dv_timings_cap, v4l_print_dv_timings_cap, INFO_FL_CLEAR(v4l2_dv_timings_cap, pad)),
    	IOCTL_INFO(VIDIOC_ENUM_FREQ_BANDS, v4l_enum_freq_bands, v4l_print_freq_band, 0),
    	IOCTL_INFO(VIDIOC_DBG_G_CHIP_INFO, v4l_dbg_g_chip_info, v4l_print_dbg_chip_info, INFO_FL_CLEAR(v4l2_dbg_chip_info, match)),
    	IOCTL_INFO(VIDIOC_QUERY_EXT_CTRL, v4l_query_ext_ctrl, v4l_print_query_ext_ctrl, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_query_ext_ctrl, id)),
    };
    #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)