v4l2子系统学习（三）编写虚拟摄像头驱动

1、声明

本文是在学习韦东山《驱动大全》V4L2子系统时，为梳理知识点和自己回看而记录，全部内容高度复制粘贴。

韦老师的《驱动大全》：商品详情

其对应的讲义资料：https://e.coding.net/weidongshan/linux/doc_and_source_for_drivers.git

2、前言

前面两章，我们基于v4l2在应用层实现了获取摄像头数据，了解了应用层中获取摄像头数据应该有的流程。接着，借着应用层的每一步操作来了解其驱动是如何实现的，从而了解整个v4l2的驱动框架。

从宏观的角度来看，前期的所有准备，无非就是想知道在编写设备驱动程序时要去分配设置哪个结构体，实现哪些关键函数。对于其它子系统的学习也是如此，再者，如今编写驱动的机会只会越来越少，学习驱动的首要目的还是为了养兵千日，用兵一时。

3、虚拟摄像头驱动编写

3.1、编写硬件相关代码

ioctl相关：

1、分配设置注册video_device结构体。

2、实现相关的ioctl函数（如获取设备能力、枚举格式、枚举分辨率、设置分辨率等）。

buffer相关：

3、分配设置vb2_queue结构体。

4、实现相关的vb2_ops函数（如queue_setup()、buf_queue()、start_streaming()、stop_streaming()等函数）。

数据传输：

5、实现start_streaming()、stop_streaming()

3.2、程序示例

#include <linux/version.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/usb.h>
#include <media/v4l2-device.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-event.h>
#include <media/videobuf2-v4l2.h>
#include <media/videobuf2-vmalloc.h>extern unsigned char red[8230];
extern unsigned char blue[8267];
extern unsigned char green[8265];static int g_copy_cnt = 0;static struct list_head g_queued_bufs;
static struct timer_list g_virtual_timer;
static struct mutex g_vb_queue_lock;  /* Protects vb_queue and capt_file */
static struct mutex g_v4l2_lock;      /* Protects everything else *//* intermediate buffers with raw data from the USB device */
struct virtual_frame_buf {/* common v4l buffer stuff -- must be first */struct vb2_v4l2_buffer vb;struct list_head list;
};/* Private functions */
static struct virtual_frame_buf *virtual_get_next_buf(void)
{//unsigned long flags;struct virtual_frame_buf *buf = NULL;//spin_lock_irqsave(&s->queued_bufs_lock, flags);if (list_empty(&g_queued_bufs))goto leave;buf = list_entry(g_queued_bufs.next, struct virtual_frame_buf, list);list_del(&buf->list);
leave://spin_unlock_irqrestore(&s->queued_bufs_lock, flags);return buf;
}#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)
static void virtual_timer_expire(unsigned long data)
#else
static void virtual_timer_expire(struct timer_list *t)
#endif
{/* 从硬件上读到数据(使用red/green/blue数组来模拟) *//* 获得第1个空闲buffer */struct virtual_frame_buf *buf = virtual_get_next_buf();void *ptr;if (buf){/* 写入buffer */ptr = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);if (g_copy_cnt <= 60){memcpy(ptr, red, sizeof(red));vb2_set_plane_payload(&buf->vb.vb2_buf, 0, sizeof(red));}else if(g_copy_cnt <= 120){memcpy(ptr, green, sizeof(green));vb2_set_plane_payload(&buf->vb.vb2_buf, 0, sizeof(green));}else {memcpy(ptr, blue, sizeof(blue));vb2_set_plane_payload(&buf->vb.vb2_buf, 0, sizeof(blue));}/* vb2_buffer_done */vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);}g_copy_cnt++;if (g_copy_cnt > 180)g_copy_cnt = 0;/* 再次设置timer的超时时间 */mod_timer(&g_virtual_timer, jiffies + HZ/30);
}static int virtual_querycap(struct file *file, void *fh,struct v4l2_capability *cap)
{strlcpy(cap->driver, "100ask_virtual_video", sizeof(cap->driver));strlcpy(cap->card, "no-card", sizeof(cap->card));cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | V4L2_CAP_READWRITE ;cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;return 0;
}static int virtual_enum_fmt_cap(struct file *file, void *priv,struct v4l2_fmtdesc *f)
{if (f->index > 0)return -EINVAL;strlcpy(f->description, "100ask motion jpeg", sizeof(f->description));f->pixelformat = V4L2_PIX_FMT_MJPEG;return 0;
}static int virtual_s_fmt_cap(struct file *file, void *priv,struct v4l2_format *f)
{/* 分辨用户传入的参数是否可用* 如果不可用, 给APP提供最接近的、硬件支持的参数*/if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)return -EINVAL;if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)return -EINVAL;f->fmt.pix.width = 800;f->fmt.pix.height = 600;return 0;
}static int virtual_enum_framesizes(struct file *file, void *fh,struct v4l2_frmsizeenum *fsize)
{if (fsize->index > 0)return -EINVAL;fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;fsize->discrete.width = 800;fsize->discrete.height = 600;return 0;
}static int virtual_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
{struct v4l2_pix_format *pix = &f->fmt.pix;pix->width = 800;pix->height = 600;pix->field = V4L2_FIELD_NONE;pix->pixelformat = V4L2_PIX_FMT_MJPEG;pix->bytesperline = 0;return 0;
}static const struct v4l2_file_operations virtual_fops = {.owner                    = THIS_MODULE,.open                     = v4l2_fh_open,.release                  = vb2_fop_release,.read                     = vb2_fop_read,.poll                     = vb2_fop_poll,.mmap                     = vb2_fop_mmap,.unlocked_ioctl           = video_ioctl2,
};static const struct v4l2_ioctl_ops virtual_ioctl_ops = {.vidioc_querycap          = virtual_querycap,.vidioc_enum_fmt_vid_cap  = virtual_enum_fmt_cap,.vidioc_s_fmt_vid_cap     = virtual_s_fmt_cap,.vidioc_enum_framesizes   = virtual_enum_framesizes,.vidioc_g_fmt_vid_cap     = virtual_g_fmt,.vidioc_reqbufs           = vb2_ioctl_reqbufs,.vidioc_create_bufs       = vb2_ioctl_create_bufs,.vidioc_prepare_buf       = vb2_ioctl_prepare_buf,.vidioc_querybuf          = vb2_ioctl_querybuf,.vidioc_qbuf              = vb2_ioctl_qbuf,.vidioc_dqbuf             = vb2_ioctl_dqbuf,.vidioc_streamon          = vb2_ioctl_streamon,.vidioc_streamoff         = vb2_ioctl_streamoff,
};static struct video_device g_vdev = {.name                     = "100ask_virtual_video",.release                  = video_device_release_empty,.fops                     = &virtual_fops,			// v4l2接口层相关的ioctl操作函数.ioctl_ops                = &virtual_ioctl_ops,		// 与硬件相关的ioctl操作函数
};static struct v4l2_device g_v4l2_dev;static struct vb2_queue g_vb_queue;static int virtual_queue_setup(struct vb2_queue *vq,unsigned int *nbuffers,unsigned int *nplanes, unsigned int sizes[], struct device *alloc_devs[])
{/* 假装:至少需要8个buffer, 每个buffer只有1个plane *//* Need at least 8 buffers */if (vq->num_buffers + *nbuffers < 8)*nbuffers = 8 - vq->num_buffers;*nplanes = 1;sizes[0] = PAGE_ALIGN(800*600*2);return 0;
}static void virtual_buf_queue(struct vb2_buffer *vb)
{/* 把这个buffer告诉硬件相关的驱动程序 */struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);struct virtual_frame_buf *buf =container_of(vbuf, struct virtual_frame_buf, vb);//unsigned long flags;//spin_lock_irqsave(&s->queued_bufs_lock, flags);list_add_tail(&buf->list, &g_queued_bufs);		// 把buffer放到驱动程序里的链表//spin_unlock_irqrestore(&s->queued_bufs_lock, flags);
}static int virtual_start_streaming(struct vb2_queue *vq, unsigned int count)
{/* 启动硬件传输 *//* 使用timer来模拟硬件中断* 创建timer* 启动timer*/
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)setup_timer(&g_virtual_timer, virtual_timer_expire, 0);
#elsetimer_setup(&g_virtual_timer, virtual_timer_expire, 0);
#endifg_virtual_timer.expires = jiffies + HZ/30;add_timer(&g_virtual_timer);return 0;
}static void virtual_stop_streaming(struct vb2_queue *vq)
{/* 停止硬件传输 */del_timer(&g_virtual_timer);while (!list_empty(&g_queued_bufs)) {struct virtual_frame_buf *buf;buf = list_entry(g_queued_bufs.next,struct virtual_frame_buf, list);list_del(&buf->list);vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);}
}/* buffer管理要用到的vb2_ops */
static const struct vb2_ops virtul_vb2_ops = {.queue_setup            = virtual_queue_setup,		// APP调用ioctl VIDIOC_REQBUFS或VIDIOC_CREATE_BUFS时，驱动程序在分配内存之前，会调用此函数。.buf_queue              = virtual_buf_queue,		// 把buffer传送给驱动.start_streaming        = virtual_start_streaming,	// 启动硬件传输（操作硬件）.stop_streaming         = virtual_stop_streaming,	// 关闭硬件传输（操作硬件）.wait_prepare           = vb2_ops_wait_prepare,.wait_finish            = vb2_ops_wait_finish,
};static void virtual_video_release(struct v4l2_device *v)
{
}static int virtual_video_drv_init(void)
{int ret;/* 分配/设置/注册video_device */printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);/* 1、设置vb2_queue结构体 */g_vb_queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;g_vb_queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;g_vb_queue.drv_priv = NULL;g_vb_queue.buf_struct_size = sizeof(struct virtual_frame_buf);  /* 分配vb时, 分配的空间大小为buf_struct_size */g_vb_queue.ops = &virtul_vb2_ops;			// 设置buffer管理要用到的vb2_opsg_vb_queue.mem_ops = &vb2_vmalloc_memops;	// 设置buffer管理要用到的vb2_mem_opsg_vb_queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;ret = vb2_queue_init(&g_vb_queue);if (ret) {printk("Could not initialize vb2 queue\n");return -1;;}printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);mutex_init(&g_vb_queue_lock);/* 2、设置video_device结构体 */g_vdev.queue = &g_vb_queue;     g_vdev.queue->lock = &g_vb_queue_lock;/* Register the v4l2_device structure(辅助作用) */g_v4l2_dev.release = virtual_video_release;strcpy(g_v4l2_dev.name, "virtual_v4l2");ret = v4l2_device_register(NULL, &g_v4l2_dev);if (ret) {printk("Failed to register v4l2-device (%d)\n", ret);return -1;}printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);g_vdev.v4l2_dev = &g_v4l2_dev;g_vdev.lock = &g_v4l2_lock;mutex_init(&g_v4l2_lock);/* 3、注册video_device结构体 */ ret = video_register_device(&g_vdev, VFL_TYPE_GRABBER, -1);if (ret) {printk("Failed to register as video device (%d)\n", ret);return -1;}printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);INIT_LIST_HEAD(&g_queued_bufs);return 0;
}static void virtual_video_drv_exit(void)
{/* 反注册/释放video_device */v4l2_device_unregister(&g_v4l2_dev);video_unregister_device(&g_vdev);
}module_init(virtual_video_drv_init);
module_exit(virtual_video_drv_exit);MODULE_LICENSE("GPL");