V4L2驱动框架

最新推荐文章于 2025-02-03 16:01:13 发布
最新推荐文章于 2025-02-03 16:01:13 发布
阅读量7.5k 收藏 6
点赞数
分类专栏： linux 文章标签： 框架 struct file video list audio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/shaolyh/article/details/6680650
版权
V4L2驱动框架

主设备号： 81

次设备号：
    0-63
    64-67
    192-223
    224-255

/dev/videoX    

应用层
————————————
char驱动
————————————
V4L2
————————————
具体的驱动
————————————
硬件




应用层的操作都需要有底层V4L2驱动的支持。内核中有一些非常完善的例子。比如：linux-2.6.26内核目录drivers/media/video/vivi.c中的驱动代码实例。


1、V4L2驱动注册、注销函数
static int __init videodev_init(void)        //注册256个视频设备
{
        dev_t dev = MKDEV(VIDEO_MAJOR, 0);
        int ret;

        printk(KERN_INFO "Linux video capture interface: v2.00\n");
        ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
        if (ret < 0) {
                printk(KERN_WARNING "videodev: unable to get major %d\n", VIDEO_MAJOR);
                return ret;
        }

        ret = class_register(&video_class);
        if (ret < 0) {
                unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
                printk(KERN_WARNING "video_dev: class_register failed\n");
                return -EIO;
        }

        return 0;
}

static void __exit videodev_exit(void)
{
        dev_t dev = MKDEV(VIDEO_MAJOR, 0);

        class_unregister(&video_class);
        unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
}

module_init(videodev_init)
module_exit(videodev_exit)


2、函数实现

2.1
Video核心层（drivers/media/video/videodev.c）提供了注册函数供具体的V4L2驱动调用:
int video_register_device(struct video_device *vfd, int type, int nr)
    —video_device: 要构建的核心数据结构
    —Type: 表示设备类型，此设备号的基地址受此变量的影响
    —Nr: 如果end-base>nr>0 ：次设备号=base（基准值，受type影响）+nr；否则：系统自动分配合适的次设备号

函数内部调用
static int __video_register_device(struct video_device *vdev, int type, int nr, int warn_if_nr_in_use)
具体驱动只需要构建video_device结构，然后调用注册函数既可。

2.2
Video核心层（drivers/media/video/videodev.c）提供了注销函数
void video_unregister_device(struct video_device *vdev)

核心定义设备数组，其中VIDEO_NUM_DEVICES 为 256 是最大设备数
static struct video_device *video_device[VIDEO_NUM_DEVICES];

2.3
V4L2提供了统一的应用层接口

static const struct file_operations v4l2_fops = {
        .owner = THIS_MODULE,
        .read = v4l2_read,
        .write = v4l2_write,
        .open = v4l2_open,
        .mmap = v4l2_mmap,
        .unlocked_ioctl = v4l2_ioctl,
#ifdef CONFIG_COMPAT
        .compat_ioctl = v4l2_compat_ioctl32,
#endif
        .release = v4l2_release,
        .poll = v4l2_poll,
        .llseek = no_llseek,
};
v4l2_read定义如下
static ssize_t v4l2_read(struct file *filp, char __user *buf, size_t sz, loff_t *off)
{
        struct video_device *vdev = video_devdata(filp);
        int ret = -ENODEV;

        if (!vdev->fops->read)
                return -EINVAL;
        if (vdev->lock && mutex_lock_interruptible(vdev->lock))
                return -ERESTARTSYS;
        if (video_is_registered(vdev))
                ret = vdev->fops->read(filp, buf, sz, off);
        if (vdev->lock)
                mutex_unlock(vdev->lock);
        return ret;
}

函数内部调用的    vdev->fops->read  由具体的V4L2驱动实现


驱动开发

定义最重要的数据结构体struct video_device，
其中，重要的是
const struct v4l2_file_operations *fops;    //帧缓冲操作

编写帧缓冲驱动的主要工作就是编写fops各个成员函数

编写具体驱动方法步骤:
1、构建具体驱动的struct video_device;
3、构建具体驱动的struct fops,并定义相关的操作函数；

4、定义具体驱动的XXX_probe。




struct video_device
{
        /* device ops */
        const struct v4l2_file_operations *fops;

        /* sysfs */
        struct device dev;              /* v4l device */
        struct cdev *cdev;              /* character device */

        /* Set either parent or v4l2_dev if your driver uses v4l2_device */
        struct device *parent;          /* device parent */
        struct v4l2_device *v4l2_dev;   /* v4l2_device parent */

        /* Control handler associated with this device node. May be NULL. */
        struct v4l2_ctrl_handler *ctrl_handler;

        /* device info */
        char name[32];
        int vfl_type;
        /* 'minor' is set to -1 if the registration failed */
        int minor;
        u16 num;
        /* use bitops to set/clear/test flags */
        unsigned long flags;
        /* attribute to differentiate multiple indices on one physical device */
        int index;

        /* V4L2 file handles */
        spinlock_t              fh_lock; /* Lock for all v4l2_fhs */
        struct list_head        fh_list; /* List of struct v4l2_fh */

        int debug;                      /* Activates debug level*/

        /* Video standard vars */
        v4l2_std_id tvnorms;            /* Supported tv norms */
        v4l2_std_id current_norm;       /* Current tvnorm */

        /* callbacks */
        void (*release)(struct video_device *vdev);

        /* ioctl callbacks */
        const struct v4l2_ioctl_ops *ioctl_ops;

        /* serialization lock */
        struct mutex *lock;
};
================================================================================
struct v4l2_file_operations {
        struct module *owner;
        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
        ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
        unsigned int (*poll) (struct file *, struct poll_table_struct *);
        long (*ioctl) (struct file *, unsigned int, unsigned long);
        long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
        int (*mmap) (struct file *, struct vm_area_struct *);
        int (*open) (struct file *);
        int (*release) (struct file *);
};
================================================================================
struct device {
        struct device           *parent;
        struct device_private   *p;
        struct kobject kobj;
        const char              *init_name;/* initial name of the device */
        struct device_type      *type;
        struct mutex            mutex;      /* mutex to synchronize calls to its driver. */
        struct bus_type *bus;               /* type of bus device is on */
        struct device_driver     *driver;    /* which driver has allocated this device */
        void                *platform_data; /* Platform specific data, device core doesn't touch it */
        struct dev_pm_info      power;
#ifdef CONFIG_NUMA
        int                 numa_node;      /* NUMA node this device is close to */
#endif
        u64                 *dma_mask;      /* dma mask (if dma'able device) */
        u64                 coherent_dma_mask;/* Like dma_mask, but for alloc_coherent mappings as not all hardware supports 64 bit ses for consistent allocations such descriptors. */
        struct device_dma_parameters *dma_parms;
        struct list_head        dma_pools;      /* dma pools (if dma'ble) */
        struct dma_coherent_mem *dma_mem; /* internal for coherent mem override */
        /* arch specific additions */
        struct dev_archdata     archdata;
#ifdef CONFIG_OF
        struct device_node      *of_node;
#endif
        dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
        spinlock_t              devres_lock;
        struct list_head        devres_head;
        struct klist_node       knode_class;
        struct class            *class;
        const struct attribute_group **groups;  /* optional groups */
        void    (*release)(struct device *dev);
};
================================================================================
struct cdev {
        struct kobject kobj;
        struct module *owner;
        const struct file_operations *ops;
        struct list_head list;
        dev_t dev;
        unsigned int count;
};
================================================================================
struct v4l2_device {
        struct device *dev;    /* dev->driver_data points to this struct. Note: dev might be NULL if there is no parent device as is the case with e.g. ISA devices. */
        struct list_head subdevs;          /* used to keep track of the registered subdevs */
        spinlock_t lock;  /* lock this struct; can be used by the driver as well if this struct is embedded into a larger struct. */
        char name[V4L2_DEVICE_NAME_SIZE];        /* unique device name, by default the driver name + bus ID */
        void (*notify)(struct v4l2_subdev *sd, unsigned int notification, void *arg);        /* notify callback called by some sub-devices. */
        struct v4l2_ctrl_handler *ctrl_handler;        /* The control handler. May be NULL. */
        struct mutex ioctl_lock;        /* BKL replacement mutex. Temporary solution only. */
};
================================================================================
struct v4l2_ioctl_ops {
        /* ioctl callbacks */
        /* VIDIOC_QUERYCAP handler */
        int (*vidioc_querycap)(struct file *file, void *fh, struct v4l2_capability *cap);
        /* Priority handling */
        int (*vidioc_g_priority)   (struct file *file, void *fh, enum v4l2_priority *p);
        int (*vidioc_s_priority)   (struct file *file, void *fh, enum v4l2_priority p);
        /* 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_type_private)(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_type_private)(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_type_private)(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_type_private)(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_dqbuf)   (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, 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 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_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, 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, 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, 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, struct v4l2_crop *a);
        /* Compression ioctls */
        int (*vidioc_g_jpegcomp)       (struct file *file, void *fh, struct v4l2_jpegcompression *a);
        int (*vidioc_s_jpegcomp)       (struct file *file, void *fh, 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);
        /* 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, 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, struct v4l2_frequency *a);
        /* 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, 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, struct v4l2_dbg_register *reg);
#endif
        int (*vidioc_g_chip_ident)       (struct file *file, void *fh, struct v4l2_dbg_chip_ident *chip);
        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_enum_dv_presets)  (struct file *file, void *fh, struct v4l2_dv_enum_preset *preset);
        int (*vidioc_s_dv_preset)      (struct file *file, void *fh, struct v4l2_dv_preset *preset);
        int (*vidioc_g_dv_preset)      (struct file *file, void *fh, struct v4l2_dv_preset *preset);
        int (*vidioc_query_dv_preset)  (struct file *file, void *fh, struct v4l2_dv_preset *qpreset);
        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_subscribe_event)  (struct v4l2_fh *fh, struct v4l2_event_subscription *sub);
        int (*vidioc_unsubscribe_event)(struct v4l2_fh *fh, struct v4l2_event_subscription *sub);
        /* For other private ioctls */
        long (*vidioc_default)         (struct file *file, void *fh, int cmd, void *arg);
};

================================================================================

================================================================================

================================================================================

static struct ov7670_format_struct {
        enum v4l2_mbus_pixelcode mbus_code;
        enum v4l2_colorspace colorspace;
        struct regval_list *regs;
        int cmatrix[CMATRIX_LEN];
    int bpp;
} ov7670_format_struct ov7670_formats[] = {
    /* "YUYV 4:2:2"     */
        .desc        = "YUYV 4:2:2",
        .pixelformat    = V4L2_PIX_FMT_YUYV,
        .regs         = ov7670_fmt_yuv422,
        .cmatrix    = { 128, -128, 0, -34, -94, 128 },
        .bpp        = 2,
    /* "UYVY 4:2:2"     */
    /* "RGB 444"        */
    /* "RGB 565"        */
    /* "Raw RGB Bayer"  */
}
#define N_OV7670_FMTS ARRAY_SIZE(ov7670_formats)

struct v4l2_fmtdesc {
        __u32               index;             /* Format number      */
        enum v4l2_buf_type  type;              /* buffer type        */
        __u32               flags;
        __u8                description[32];   /* Description string */
        __u32               pixelformat;       /* Format fourcc      */
        __u32               reserved[4];
};
 
//每一个subdev驱动程序实例应该创建这个结构，无论是独立或在一个更大的结构之中。
struct v4l2_subdev {
        struct list_head list;
        struct module *owner;
        u32 flags;
        struct v4l2_device *v4l2_dev;
        const struct v4l2_subdev_ops *ops;
        /* name must be unique */
        char name[V4L2_SUBDEV_NAME_SIZE];
        /* can be used to group similar subdevs, value is driver-specific */
        u32 grp_id;
        /* pointer to private data */
        void *priv;
};
struct v4l2_pix_format {
        __u32                   width;
        __u32                   height;
        __u32                   pixelformat;
        enum v4l2_field         field;
        __u32                   bytesperline;   /* for padding, zero if unused */
        __u32                   sizeimage;
        enum v4l2_colorspace    colorspace;
        __u32                   priv;           /* private data, depends on pixelformat */
};  

struct v4l2_format {
        enum v4l2_buf_type type;
        union {
                struct v4l2_pix_format          pix;     /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
                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 */
                __u8    raw_data[200];                   /* user-defined */
        } fmt;
};

static struct ov7670_win_size {
        int     width;
        int     height;
        unsigned char com7_bit;
        int     hstart;         /* Start/stop values for the camera.  Note */
        int     hstop;          /* that they do not always make complete */
        int     vstart;         /* sense to humans, but evidently the sensor */
        int     vstop;          /* will do the right thing... */
        struct regval_list *regs; /* Regs to tweak */
                /* h/vref stuff */
} ov7670_win_sizes[] = {
    /* VGA */
    /* CIF */
    /* QVGA */
    /* QCIF */
}
#define N_WIN_SIZES (ARRAY_SIZE(ov7670_win_sizes))

v4l2-framework
突围
01-03 1770
v4l2-framework. https://www.kernel.org/doc/Documentation/zh_CN/video4linux/v4l2-framework.txt Chinese translated version of Documentation/video4linux/v4l2-framework.txt If you have any comm
Android Camera 从应用层看V4L2驱动框架
weixin_49303682的博客
08-24 2179
V4L2可用于采集图片、视频和音频数据的通用 API 接口，配合适当的视频采集设备和相应的驱动程序，可以实现图片、视频、音频等的采集。 使用 V4L2 进行视频采集，一般分为 5 个步骤： （1） 打开设备，进行初始化参数设置，通过 V4L2 接口设置视频图像的采集 窗口、采集的点阵大小和格式； （2） 申请图像帧缓冲，并进行内存映射，将这些帧缓冲区从内核空间映射 到用户空间，便于应用程序读取、处理图像数据； （3） 将帧缓冲进行入队操作，启动视频采集； （4） 驱动开始视频数据的采集，应用程序从视频
V4L2视频驱动框架简述（转载）
诗筱涵的博客
02-03 1549
摘自：https://blog.youkuaiyun.com/LinuxArmbiggod/article/details/80310445 V4L2视频驱动框架简述 奶牛养殖场小马 2018-05-14 15:40:1013469 收藏 76 分类专栏： Linux驱动 版权 V4L2框架简述（结合高通平台） 1 硬件 1.1 硬件结构分析 1.2 电路分析 2 软件 2.1 v4l2驱动框架 2.1.1 v4l2驱动框架代码目录分布 2.1.2 v4l2驱动核心结构体 2.2 v...
V4L2视频驱动框架---v4l2_device管理模块简述
2501_90433463的博客
02-03 927
驱动需要与子设备进行通信，这些子设备一般情况下就是音频处理，编解码器等，camera常见的子设备有传感器和摄像头控制器，为了方便代码管理，内核 v4l2 提供了一个统一的接口给这些子设备，即 v4l2_subdev 结构体。struct video_device :保存管理v4l2_device设备（4vl2设备）数据，注册成功之后 以类似/dev/videoxxx的字符设备形式提供给上层，包含底层驱动结构体 v4l2_device 以及 为上层提供的接口 cdev。
V4l2框架分析
welljrj的博客
06-23 7272
1. V4L2框架概述 1.1 v4l2设备应用层流程 1.2 内核V4L2模块 2 2. video_device 2.1图像处理模块 2.2 video注册流程 3. videobuf2 3.1 与video device的关系: 3.2 buffer类型 3.3 vb2_ops回调函数 3.4 mmap 流程...
V4L2驱动程序架构
zhiqiang_miao的专栏
12-15 657
引用自：http://blog.chinaunix.net/uid-26101960-id-3297657.html V4L2简介 video4linux2(V4L2)是Linux内核中关于视频设备的内核驱动，它为Linux中视频设备访问提供了通用接口，在Linux系统中，V4L2驱动的Video设备节点路径通常/dev/video/中的videoX V4L2驱动对用户空间提
V4L2系列 之 V4L2驱动框架
小嵌同学的博客
04-23 4689
本篇文章主要介绍Linux内核中的V4L2框架，本篇文章所用内核版本：linux-4.19v4L2 (Video for Linux 2），是linux的一套视频框架，共主体位于内核，可以理解为是整个linux系统上面的视频源捕获驱动框架。其广泛应用在嵌入式设备、移动端以及个人电脑设备上面，市而上使用视频图像采集的设备如：手机、IPC、行车记录仪都会用到这个框架来进行视频采集。v4L2允许 应用程序 控制图像传感器以及传输格式，应用程序 借此完成拍照、预览、视频记录等图像传感器数据应用。
Linux之V4L2驱动框架
风间琉璃的博客
08-30 9412
V4L2(Video for linux two)是 Linux 内核中视频类设备的一套驱动框架，为视频类设备驱动开发和应用层提供了一套统一的接口规范。使用 V4L2 设备驱动框架注册的设备会在 Linux 系统/dev/目录下生成对应的设备节点文件，设备节点的名称通常为 videoX（X 标准一个数字编号:/dev/videox），每一个 videoX 设备文件就代表一个视频类设备。应用程序通过对 videoX 设备文件进行 I/O 操作来配置、使用设备类设备。...............
深入学习Linux摄像头（二）v4l2驱动框架
热门推荐
JT同学的博客
08-16 2万+
深入学习Linux摄像头系列 深入学习Linux摄像头（一）v4l2应用编程 深入学习Linux摄像头（二）v4l2驱动框架 深入学习Linux摄像头（三）虚拟摄像头驱动分析 深入学习Linux摄像头（五）三星平台fimc驱动详解一 深入学习Linux摄像头（六）三星平台fimc驱动详解二 深入学习Linux摄像头（二）v4l2驱动框架 文章目录深入学习Linux摄像头（二）v4l2驱动框架一、V...
Linux V4L2驱动框架分析之（三）：v4l2设备的缓存管理_v4l2 清空缓存队列
2401_89694232的博客
01-13 476
v4l2设备读取数据的方式有两种，一种是read方式，一种是streaming方式。一般在v4l2_file_operations的open回调里设置并调用vb2_queue_init函数初始化vb2_queue，最关健的要设置vb2_queue的ops、mem_ops成员。使用streaming方式，需要管理多块缓冲，内核通过vb2_queue来管理，vb2_queue即缓冲队列。根据具体设备使用缓存区的方式，选择对应的vb2_mem_ops。
v4l2驱动框架分析-2
sinat_37817094的博客
11-07 345
基于Linux的v4l2视频架构驱动编写
12-17
V4L2较V4L有较大的改动，并已成为2.6的标准接口，函盖video\dvb\FM...，多数驱动都在向V4l2迁移。更好地了解V4L2先从应 用入手，然后再深入到内核中结合物理设备／接口的规范实现相应的驱动。本文先就V4L2在视频捕捉或camera方面的应用框架
v4l2驱动详解
10-25
v4l2驱动详解，解释程序的结构，变量的组织关系
摄像头V4L2驱动框架
weixin_51332399的博客
06-10 314
编译之后arm-linux-gnueabihf-gcc ov5640_camera_app.c -o ov5640_camera_app，将上述的代码配置到内核之后，重新编译内核 make uImage LOADADDR=0xc2000000 -j4。上述的命令在开发板的终端执行完之后，得到了picturex.yuv但是这个图片不能直接打开，需要配置的驱动的代码DCMI(摄像头控制器)，V4L2的核心，ov5640到内核中。因为没有按照图片的格式来存储，这个文件中存储的是图像的原始数据，如果想查看需。
v4l2驱动框架
weixin_40535588的博客
08-09 294
参考：https://blog.youkuaiyun.com/duanlove/article/details/7853106
【Linux驱动】Linux--V4L2视频驱动框架
szembed的博客
04-11 2530
subdev的设计目的是为了多路复用，就是用一个v4l2_device可以挂接多个v4l2_subdev。依附在v4l2_device之下，并表示一个v4l2设备的子设备，一个v4l2_devide下可以有多个sub_device。v4l2_device里有一个v4l2_subdev链表，可以选择v4l2_device去控制哪一个v4l2_subdev。v4l2驱动框架主要的对象有video_device、v4l2_device、v4l2_subdev、videobuf。/* 实现各种系统调用 */
V4L2驱动框架详解
arvin_xiong的博客
06-29 926
④ video_device->ioctl_ops: 设置成v4l2_ioctl_ops结构, 该结构体成员为应用层操作video_device_fd句柄的ioctl(VIDEOC_XXX) ,所回调的函数指针。我们配置/dev/video主要通过使用ioctl(VIDEOC_XXX), 命令宏如:VIDIOC_S_FMT, VIDIOC_G_FMT, VIDIOC_REQBUFS, VIDIOC_QUERYBUF, VIDIOC_DQBUF, VIDIOC_STREAMOFF。性能最高,实现起来复杂。
Linux驱动学习--V4L2框架
文艺小少年的博客
04-18 1212
一、引言 V4L2是Video for linux2的简称,为linux中关于视频设备的内核驱动。在Linux中，视频设备是设备文件，可以像访问普通文件一样对其进行读写，摄像头在/dev/video0下。 V4L2在设计时，是要支持很多广泛的设备的，它们之中只有一部分在本质上是真正的视频设备。 主要有以下几种几种接口 视频采集接口(video capture interface):这种应用的设备...
v4l2驱动框架介绍
最新发布
03-20
<think>好的，我现在要介绍V4L2驱动框架。首先，我需要确认自己对V4L2的理解是否正确。V4L2是Video for Linux 2的缩写，是Linux内核中负责视频设备驱动的框架，主要用于摄像头、视频采集卡等设备。用户可能需要了解其架构、主要组件、工作流程以及应用场景。 接下来，我应该从基本概念入手，解释V4L2的作用和重要性。然后，需要分解其核心组件，比如设备节点、API接口、缓冲区管理等。可能还需要提到V4L2支持的设备类型，比如摄像头、收音机等，但重点在视频设备。 然后，驱动框架的结构是关键。用户可能想知道驱动开发者如何利用V4L2框架来开发驱动程序，比如结构体v4l2_device、v4l2_subdev的作用，以及如何注册设备到内核。这里需要确保术语准确，比如video_device结构体、媒体控制器框架的整合。 另外，用户可能对V4L2的用户空间接口感兴趣，比如如何使用ioctl调用与驱动交互，常见的命令如VIDIOC_QUERYCAP、VIDIOC_REQBUFS等。但用户的问题是驱动框架介绍，所以这部分可能需要简要提及，重点放在内核驱动部分。 可能还需要比较V4L2和其他框架的区别，比如与DRM框架的不同应用场景。不过如果用户没有提到，可能不需要深入。 需要检查是否有遗漏的部分，比如V4L2的子设备（subdev）概念，以及管道配置、视频数据流的处理流程（如DMA缓冲区、内存映射等）。此外，媒体控制器在复杂设备中的作用也很重要，比如多子设备的管理。 需要确保技术细节准确，比如V4L2驱动中的关键结构体和函数，例如v4l2_file_operations、v4l2_ioctl_ops等。同时，要说明驱动开发的基本步骤，如初始化、注册设备、设置操作集、处理缓冲区等。 可能需要注意避免过于深入代码细节，而保持框架层面的介绍。同时，要组织内容结构清晰，分点说明，帮助用户逐步理解。 最后，检查是否有错误，比如V4L2是否支持音频设备（其实主要是视频，但可能包括相关音频流），或者是否所有视频设备都通过V4L2驱动。需要确认这些点，确保信息准确。</think>V4L2（Video for Linux 2）是 Linux 内核中用于支持视频和音频设备的标准框架，主要用于摄像头、采集卡、TV调谐器等设备。以下是其核心介绍： --- ### 一、框架定位 - **作用**：提供统一的用户空间 API 和内核驱动模型，管理视频输入/输出、流媒体和控制功能。 - **适用设备**：摄像头、视频采集卡、编解码器、收音机、SDR（软件定义无线电）等。 --- ### 二、核心组件 1. **设备节点** 用户通过 `/dev/videoX` 节点访问设备，每个节点对应一个视频设备。 2. **内核对象** - `struct video_device`：表示一个视频设备，关联操作函数集（`v4l2_file_operations`）。 - `struct v4l2_subdev`：描述子设备（如传感器、ISP），支持模块化硬件设计。 - `struct v4l2_device`：管理主设备与子设备的层级关系。 3. **缓冲区管理** - 支持多种内存类型：DMA 缓冲区（`DMABUF`）、用户空间内存（`USERPTR`）等。 - 关键机制：通过 `videobuf2` 框架实现高效数据流传输。 --- ### 三、驱动开发流程 1. **初始化** - 注册 `v4l2_device` 主设备。 - 创建并配置 `video_device`，绑定操作集（如 `v4l2_ioctl_ops`）。 2. **子设备管理** - 使用 `v4l2_subdev` 注册传感器、ISP 等子模块。 - 通过媒体控制器框架（Media Controller）建立硬件管道链接。 3. **流控制** - 实现缓冲区申请（`VIDIOC_REQBUFS`）、启停流（`VIDIOC_STREAMON/OFF`）。 - 处理数据流中断或 DMA 传输。 --- ### 四、用户空间交互 - **IOCTL 命令**：用户通过 `ioctl()` 调用控制设备，例如： ```c VIDIOC_QUERYCAP // 查询设备能力 VIDIOC_S_FMT // 设置视频格式 VIDIOC_REQBUFS // 申请缓冲区 ``` - **数据流模式**：支持 `mmap()` 内存映射或 `read()` 直接读取。 --- ### 五、典型应用场景 1. **摄像头采集** 通过 `Video Capture` 接口获取图像数据。 2. **视频输出** 使用 `Video Output` 接口驱动显示器或编码器。 3. **复杂媒体链路** 结合媒体控制器配置多设备管道（如：传感器 → ISP → 编码器）。 --- ### 六、与其他框架的关系 - **与 DRM 框架**：DRM 负责显示输出，V4L2 负责采集输入。 - **与 Media Controller**：用于管理多子设备拓扑结构。 --- ### 七、示例驱动结构 ```c static struct video_device my_vdev = { .name = "my_camera", .fops = &my_fops, .ioctl_ops = &my_ioctl_ops, }; static int __init my_driver_init(void) { v4l2_device_register(NULL, &my_v4l2_dev); video_register_device(&my_vdev, VFL_TYPE_VIDEO, -1); // 注册子设备与配置媒体链路 } ``` --- 通过上述分层设计，V4L2 实现了硬件无关性，驱动开发者只需关注硬件特有操作，用户空间则可跨设备调用统一 API。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值