/* 仿照linux2.6.31.14内核中的vivi.c */ #include <linux/module.h> #include <linux/delay.h> #include <linux/errno.h> #include <linux/fs.h> #include <linux/kernel.h> #include <linux/slab.h> #include <linux/mm.h> #include <linux/ioport.h> #include <linux/init.h> #include <linux/sched.h> #include <linux/pci.h> #include <linux/random.h> #include <linux/version.h> #include <linux/mutex.h> #include <linux/videodev2.h> #include <linux/dma-mapping.h> #include <linux/interrupt.h> #include <linux/kthread.h> #include <linux/highmem.h> #include <linux/freezer.h> #include <media/videobuf-vmalloc.h> #include <media/v4l2-device.h> #include <media/v4l2-ioctl.h> /* 当前摄像头所使用的格式，在vivi.c中该结构体是在函数的参数中，我们为了简单 * 使用全局变量。但是在内核的开发中，万不得已不使用全局变量，都要使用参数的形式传递 * 为了程序的聚拢型。 */ static struct v4l2_format myvivi_format; /* 队列操作1: 定义 */ static struct videobuf_queue myvivi_vb_vidqueue; static spinlock_t myvivi_queue_slock; static struct list_head myvivi_vb_local_queue; static struct timer_list myvivi_timer; #include "fillbuf.c" /* 参考documentations/video4linux/v4l2-framework.txt: * 参考drivers\media\video\videobuf-core.c ops->buf_setup - calculates the size of the video buffers and avoid they to waste more than some maximum limit of RAM; ops->buf_prepare - fills the video buffer structs and calls videobuf_iolock() to alloc and prepare mmaped memory; ops->buf_queue - advices the driver that another buffer were requested (by read() or by QBUF); ops->buf_release - frees any buffer that were allocated. * */ /* ------------------------------------------------------------------ Videobuf operations ------------------------------------------------------------------*/ /* APP调用ioctl VIDIOC_REQBUFS时会导致此函数被调用,(追驱动的ioctl的VIDIOC_REQBUFS命令得到结果) * 它重新调整count和size(有多少个buffer，每个buffer的大小是多少) */ static int myvivi_buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size) { *size = myvivi_format.fmt.pix.sizeimage; /* 如果传入的count为0的话就赋值为32*/ if (0 == *count) *count = 32; return 0; } /* APP调用ioctlVIDIOC_QBUF时导致此函数被调用, * 它会填充video_buffer结构体并调用videobuf_iolock来分配内存 * */ static int myvivi_buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb, enum v4l2_field field) { /* 0. 设置videobuf的一帧数据的信息 */ vb->size = myvivi_format.fmt.pix.sizeimage; vb->bytesperline = myvivi_format.fmt.pix.bytesperline; vb->width = myvivi_format.fmt.pix.width; vb->height = myvivi_format.fmt.pix.height; vb->field = field; /* 1. 做些准备工作 * 预先计算条纹，我们只是用第一个输入源 */ myvivi_precalculate_bars(0); #if 0 /* 2. 调用videobuf_iolock为类型为V4L2_MEMORY_USERPTR的videobuf分配内存 * 如果类型为V4L2_MEMORY_MMAP的话，就不会分配内存，只是会判断类型返回而已 * 因为我们的videobuf_buffer中的memory是V4L2_MEMORY_MMAP类型的，是不需要分配内存的, * 所以可以不使用videobuf_iolock函数。 */ if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { rc = videobuf_iolock(vq, &buf->vb, NULL); if (rc < 0) goto fail; } #endif /* 3. 设置状态，表示已经准备好了 */ vb->state = VIDEOBUF_PREPARED; return 0; } /* APP调用ioctl VIDIOC_QBUF时: * 1. 先调用buf_prepare进行一些准备工作 * 2. 把buf放入videobuf_queue中的stream队列 * 3. 调用buf_queue(起通知、记录作用) */ static void myvivi_buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb) { vb->state = VIDEOBUF_QUEUED; /* 把videobuf放入本地一个队列尾部 * 定时器处理函数就可以从本地队列取出videobuf */ list_add_tail(&vb->queue, &myvivi_vb_local_queue); } /* APP不再使用队列时, 用它来释放内存,在videobuf_queue_cancel中被调用 */ static void myvivi_buffer_release(struct videobuf_queue *vq, struct videobuf_buffer *vb) { /* 也可以使用free_buffer(vq, buf);这个函数是vivi.c中buffer_release中的函数 * 以下两个函数是从free_buffer中主要函数 */ videobuf_vmalloc_free(vb); /* 设置videobuf_buffer的状态为初始状态 */ vb->state = VIDEOBUF_NEEDS_INIT; } /* 通过追videobuf_queue_vmalloc_init函数可知，以下四个函数是必不可少的 * 可以通过在videobuf-core.c中搜索buf_setup来查看是在哪里被调用，另外三个函数同理 */ static struct videobuf_queue_ops myvivi_video_qops = { .buf_setup = myvivi_buffer_setup, /* 计算大小以免浪费 */ .buf_prepare = myvivi_buffer_prepare, .buf_queue = myvivi_buffer_queue, .buf_release = myvivi_buffer_release, }; /* ------------------------------------------------------------------ File operations for the device ------------------------------------------------------------------*/ static int myvivi_open(struct file *file) { /* 队列操作2: 初始化 * 参数V4L2_BUF_TYPE_VIDEO_CAPTURE是追函数得到的结果，并不是从vivi.c中抄过来的 * 倒数第2个参数是是队列中的buffer头部的大小，并不包含buffer中存放视频数据的大小 * 如果倒数第二个参数是其他的结构体把videobuf_buffer封装起来了，此时这个结构体 * 的第一个成员必输是videobuf_buffer，参考vivi.c * videobuf_queue_vmalloc_init函数是用于初始化vmalloc类型的缓存 */ videobuf_queue_vmalloc_init(&myvivi_vb_vidqueue, &myvivi_video_qops, NULL, &myvivi_queue_slock, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_INTERLACED, sizeof(struct videobuf_buffer), NULL); /* 倒数第2个参数是buffer的头部大小 */ myvivi_timer.expires = jiffies + 1; /* 只有真正用起来了才使用资源 */ add_timer(&myvivi_timer); return 0; } static int myvivi_close(struct file *file) { del_timer(&myvivi_timer); /* 停止和销毁队列 */ videobuf_stop(&myvivi_vb_vidqueue); videobuf_mmap_free(&myvivi_vb_vidqueue); return 0; } static int myvivi_mmap(struct file *file, struct vm_area_struct *vma) { return videobuf_mmap_mapper(&myvivi_vb_vidqueue, vma); } static unsigned int myvivi_poll(struct file *file, struct poll_table_struct *wait) { return videobuf_poll_stream(file, &myvivi_vb_vidqueue, wait); } /* 从vivi.c中拷贝过来然后进行修改 * 该函数的目的是表征这是一个摄像头设备 */ static int myvivi_vidioc_querycap(struct file *file, void *priv, struct v4l2_capability *cap) { strcpy(cap->driver, "myvivi"); strcpy(cap->card, "myvivi"); cap->version = 0x0001; //随便写 /* V4L2_CAP_VIDEO_CAPTURE表示这是一个摄像头设备，V4L2_CAP_STREAMING表明可以通过 * qbuf或者dbuf来获得数据，V4L2_CAP_READWRITE表示可以通过读写函数来获取数据，因此 * 这个摄像头驱动支持两种获取数据的格式 */ cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; return 0; } /* 列举支持哪种格式 */ static int myvivi_vidioc_enum_fmt_vid_cap(struct file *file, void *priv, struct v4l2_fmtdesc *f) { /* 我们只支持一种格式，应用程序查询时会使用v4l2_fmtdesc结构体，里面有index成员 * 从0开始使用for循环来一次查询所支持的格式 */ if (f->index >= 1) return -EINVAL; strcpy(f->description, "4:2:2, packed, YUYV"); /* 只支持yuyv */ f->pixelformat = V4L2_PIX_FMT_YUYV; return 0; } /* 返回当前所使用的格式 */ static int myvivi_vidioc_g_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *f) { memcpy(f, &myvivi_format, sizeof(myvivi_format)); return (0); } /* 测试驱动程序是否支持某种格式 */ static int myvivi_vidioc_try_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *f) { unsigned int maxw, maxh; enum v4l2_field field; /* 判断格式是否是我们驱动所支持的类型 */ if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV) return -EINVAL; /* field照抄vivi.c写法 */ field = f->fmt.pix.field; if (field == V4L2_FIELD_ANY) { field = V4L2_FIELD_INTERLACED; } else if (V4L2_FIELD_INTERLACED != field) { return -EINVAL; } /* 摄像头设备所支持的最大宽度和高度 */ maxw = 1024; maxh = 768; /* 调整format的width, height, * 计算bytesperline, sizeimage，照抄vivi.c */ v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2, &f->fmt.pix.height, 32, maxh, 0, 0); /* 像素深度为16，即每个像素有16位表示，>>3表示除以8，为什么不用/8,因为移位指令比除法指令快 */ f->fmt.pix.bytesperline = (f->fmt.pix.width * 16) >> 3; f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline; return 0; } static int myvivi_vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *f) { /* 该函数返回0表示支持这种格式，如果返回值小于0，表示不支持这种格式 * 该函数的作用只是对所设格式进行一下判断 */ int ret = myvivi_vidioc_try_fmt_vid_cap(file, NULL, f); if (ret < 0) return ret; memcpy(&myvivi_format, f, sizeof(myvivi_format)); return ret; } /* 请求buffer */ static int myvivi_vidioc_reqbufs(struct file *file, void *priv, struct v4l2_requestbuffers *p) { return (videobuf_reqbufs(&myvivi_vb_vidqueue, p)); } /* 查询buffer */ static int myvivi_vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p) { return (videobuf_querybuf(&myvivi_vb_vidqueue, p)); } /* 从队列中取出buffer */ static int myvivi_vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p) { return (videobuf_qbuf(&myvivi_vb_vidqueue, p)); } /* 从队列中取出buffer * v4l2框架中有videobuf_buffer和v4l2_buffer两个关于buffer的结构体，那么他们直接有什么联系呢? * videobuf_buffer是在v4l2框架中内核中表示摄像头buffer的结构体，而v4l2_buffer结构体是应用层 * 使用关于查询，申请，入队，出队的结构体，由此可知，这两个结构体使用的场合不同，当应用层通过 * ioctl来申请或者查询等操作buffer时，要传入v4l2_buffer结构体，这个结构体中有index成员，通过 * 应用层传入的index成员就可以来选择内核中的哪个videobuf_buffer结构体， * 从而就使两种结构体关联起来了 */ static int myvivi_vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p) { return (videobuf_dqbuf(&myvivi_vb_vidqueue, p, file->f_flags & O_NONBLOCK)); } static int myvivi_vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i) { return videobuf_streamon(&myvivi_vb_vidqueue); } static int myvivi_vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i) { videobuf_streamoff(&myvivi_vb_vidqueue); return 0; } /* 必不可少的11个ioctl */ static const struct v4l2_ioctl_ops myvivi_ioctl_ops = { // 表示它是一个摄像头设备 .vidioc_querycap = myvivi_vidioc_querycap, /* 用于列举、获得、测试、设置摄像头的数据的格式 */ .vidioc_enum_fmt_vid_cap = myvivi_vidioc_enum_fmt_vid_cap, .vidioc_g_fmt_vid_cap = myvivi_vidioc_g_fmt_vid_cap, .vidioc_try_fmt_vid_cap = myvivi_vidioc_try_fmt_vid_cap, .vidioc_s_fmt_vid_cap = myvivi_vidioc_s_fmt_vid_cap, /* 缓冲区操作: 申请/查询/放入队列/取出队列 * 以下对缓冲区的操作的函数都是使用内核提供的函数 */ .vidioc_reqbufs = myvivi_vidioc_reqbufs, .vidioc_querybuf = myvivi_vidioc_querybuf, .vidioc_qbuf = myvivi_vidioc_qbuf, .vidioc_dqbuf = myvivi_vidioc_dqbuf, // 启动/停止 .vidioc_streamon = myvivi_vidioc_streamon, .vidioc_streamoff = myvivi_vidioc_streamoff, }; /* 这个操作方法集中的所有的函数都是由v4l2框架中字符设备接口的file_operations中回调用的。 * 摄像头整体的框架就是接口层的file_operations操作方法会回调video_device中提供的 * v4l2_file_operations操作方法集中的函数 */ static const struct v4l2_file_operations myvivi_fops = { .owner = THIS_MODULE, .open = myvivi_open, .release = myvivi_close, /* 在v4l2框架中字符设备接口的file_operations中的mmap是直接调用video_device中 * 操作方法集中的mmap，因此我们必须填写这个函数，这个函数主要作用是分配存储摄像头 * 数据的缓冲区，前面申请的videobuf_buffer只是缓冲区的头部，并没有存放摄像头数据的缓冲区 */ .mmap = myvivi_mmap, /* video_ioctl2是V4l2-ioctl.c提供的标准ioctl，由摄像头驱动的框架可知，当应用层调用 * ioctl时会调用vl42中cdev中的ioctl，这个ioctl会调用video_device中fops的ioctl，就是 * video_ioctl2，在video_ioctl2中会调用video_device中的myvivi_ioctl_ops */ .ioctl = video_ioctl2, /* V4L2 ioctl handler */ .poll = myvivi_poll, }; static struct video_device *myvivi_device; static void myvivi_release(struct video_device *vdev) { } /* 在定时器处理函数中来填充videobuf_buffer * 对所有类型的驱动，填充缓冲区的流程都是如下方式: * 1.获取下一个buffer，并且确保有人正在等待这个buffer * 2.得到一个内存指针，然后将视频数据放到那个地方 * 3.标记buffer完成，并且唤醒等待的进程 */ static void myvivi_timer_function(unsigned long data) { struct videobuf_buffer *vb; void *vbuf; struct timeval ts; /* 1. 构造数据: 从队列头部取出第1个videobuf, 填充数据 */ /* 1.1 从本地队列取出第1个videobuf * 这个判断函数是非常有必要的，因为在open函数中就已经开启定时器了，在执行定时器 * 处理函数时，videobuf_buffer中的数据还没有数据呢，此时myvivi_vb_local_queue一定是 * 空的，此时就不应该在下面对该队列中的buffer操作 */ if (list_empty(&myvivi_vb_local_queue)) { goto out; } /* 从本地队列头部取出第一个buffer * 在myvivi_buffer_queue函数中把videobuf放入本地一个队列尾部，应用层获得的摄像头缓冲 * videobuf_buffer其实是从myvivi_vb_local_queue队列中获取的，而vivi.c中不是 * myvivi_vb_local_queue，而是在vivi_dmaqueue中的active队列中，因此可知，在linux2.6.31.14 * 的版本中的v4l2框架中，关于缓冲区其实是由两个队列来完成的，一个是由videobuf_queue来维护的 * videobuf_buffer,这个队列主要的作用是供应用程序来申请，分配，查询的数据缓存。 * 而另一个队列就是当应用层获取摄像头缓存时，从这个队列中取缓冲，并不是从videobuf_queue * 队列中取出摄像头缓冲。 */ vb = list_entry(myvivi_vb_local_queue.next, struct videobuf_buffer, queue); /* Nobody is waiting on this buffer, return */ /* 该函数判断之前是否有wait_event_interruptible将videobuf_buffer中的done挂入等待队列, * 如果没有的话就说明没有应用程序正在等在videobuf_buffer，即应用程序想要获得videobuf_buffer * 的摄像头数据， * 那么在哪里使用wait_event_interruptible函数呢?其实是在poll函数中，如果videobuf_buffer * 没有准备好数据，就会将videobuf_buffer中的done放入核心层进行休眠。 * wait_event_interruptible函数是如何实现的呢?该函数的第一个参数是一个wait_queue_head_t * 等待队列头，然后该函数会添加一个DEFINE_WAIT(__wait);将__wait添加到wait_queue_head_t中， * 因此判断wait_queue_head_t中的struct list_head task_list链接因子是否为空即可。 * 如果有用户调用wait_event_interruptible函数后，wait_queue_head_t中的 * struct list_head task_list链接因子不会为空。 * * 总之就是如果myvivi_vb_local_queue队列当中的buffer没有一个进程在其上等待的话， * 是不能被移除或者填充的。 * * 这个函数是非常有必要的，如果应用层没有使用select函数在等待获取videobuf_buffer * 时，就不应该对videobuf_buffer填充数据，然后删除videobuf_buffer和唤醒等待的进程 * */ if (!waitqueue_active(&vb->done)) goto out; /* 1.2 填充数据 */ /* 从videobuf_buffer中得到真正存储摄像头数据的缓存，应用程序就可以从这个缓存中取出 * 摄像头数据并显示,对于vmalloc类型的缓存使用videobuf_to_vmalloc函数来获得用于存放 * 摄像头数据的内存指针，如果是其他类型的缓存则需要使用其他函数来获得内存指针 */ vbuf = videobuf_to_vmalloc(vb); //memset(vbuf, 0xff, vb->size); myvivi_fillbuff(vb); vb->field_count++; do_gettimeofday(&ts); vb->ts = ts; /* 状态一定要改为VIDEOBUF_DONE，因为在poll函数中会判断videobuf_buffer的状态是否为VIDEOBUF_DONE */ vb->state = VIDEOBUF_DONE; /* 1.3 把videobuf从本地队列中删除 */ list_del(&vb->queue); /* 2. 唤醒进程: 唤醒videobuf->done上的进程 * 唤醒因为poll函数而休眠的进程 */ wake_up(&vb->done); out: /* 3. 修改timer的超时时间 : 30fps, 1秒里有30帧数据 * 每1/30 秒产生一帧数据 */ mod_timer(&myvivi_timer, jiffies + HZ/30); } static int myvivi_init(void) { int error; /* 1. 分配一个video_device结构体 */ myvivi_device = video_device_alloc(); /* 2. 设置 */ /* 2.1 这个release函数必须设置，否则在video_register_device注册时，在该函数中就会 * 判断时候有这个函数，如果没有的话就会返回。 * 在V4l2-dev.c中的 if (WARN_ON(!vdev->release))返回 */ myvivi_device->release = myvivi_release; /* 2.2 */ myvivi_device->fops = &myvivi_fops; /* 2.3 myvivi_fops中的ioctl最终会调用myvivi_device->ioctl_ops中对应的函数 */ myvivi_device->ioctl_ops = &myvivi_ioctl_ops; /* 2.4 队列操作 * a. 定义/初始化一个队列(会用到一个spinlock) */ spin_lock_init(&myvivi_queue_slock); /* 3. 注册 ,以下信息是通过追踪源代码得到的结论 * 参数-1表示分配第一个可用的号 * which device node number (0 == /dev/video0, 1 == /dev/video1, ... * -1 == first free) */ error = video_register_device(myvivi_device, VFL_TYPE_GRABBER, -1); /* 用定时器产生数据并唤醒进程 * 用定时器来模仿vivi.c中来创建内核线程来构造数据并唤醒进程 */ init_timer(&myvivi_timer); myvivi_timer.function = myvivi_timer_function; /* 初始化一个队列头，这个队列是用来管理可以向应用层提供摄像头数据缓存的buffer， * 也就是说应用层从驱动获得摄像头缓存就是从这个队列中获取的 */ INIT_LIST_HEAD(&myvivi_vb_local_queue); return error; } static void myvivi_exit(void) { video_unregister_device(myvivi_device); video_device_release(myvivi_device); } module_init(myvivi_init); module_exit(myvivi_exit); MODULE_LICENSE("GPL");
