Linux攝像頭驅動學習之：（三）從零寫虛擬驅動（仿照vivi.c）

本文轉載自查看原文 2015-11-21 14:48 2025 仿照vivi.c寫虛擬視頻驅動/ Linux 驅動

本篇仿照vivi.c 寫虛擬視頻驅動，代碼（myvivi.c+fillbuf.c+Makefile）如下：

//==========================myvivi.c=======================================
/* 仿照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>

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時會導致此函數被調用,
* 它重新調整count和size
*/
static int myvivi_buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
{

*size = myvivi_format.fmt.pix.sizeimage;

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分配內存 */
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放入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不再使用隊列時, 用它來釋放內存 */
static void myvivi_buffer_release(struct videobuf_queue *vq,
struct videobuf_buffer *vb)
{
videobuf_vmalloc_free(vb);
vb->state = VIDEOBUF_NEEDS_INIT;
}

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: 初始化 */
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);
}

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;
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)
{
if (f->index >= 1)
return -EINVAL;

strcpy(f->description, "4:2:2, packed, 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 = 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
     */
v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2,
         &f->fmt.pix.height, 32, maxh, 0, 0);
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)
{
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;
}

static int myvivi_vidioc_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *p)
{
return (videobuf_reqbufs(&myvivi_vb_vidqueue, p));
}

static int myvivi_vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
{
return (videobuf_querybuf(&myvivi_vb_vidqueue, p));
}

static int myvivi_vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
{
return (videobuf_qbuf(&myvivi_vb_vidqueue, p));
}

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;
}

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,
};

static const struct v4l2_file_operations myvivi_fops = {
.owner  = THIS_MODULE,
    .open       = myvivi_open,
    .release    = myvivi_close,
    .mmap       = myvivi_mmap,
    .ioctl      = video_ioctl2, /* V4L2 ioctl handler */
    .poll       = myvivi_poll,
};

static struct video_device *myvivi_device;

static void myvivi_release(struct video_device *vdev)
{
}

static void myvivi_timer_function(unsigned long data)
{
    struct videobuf_buffer *vb;
void *vbuf;
struct timeval ts;

    /* 1. 構造數據: 從隊列頭部取出第1個videobuf, 填充數據
     */

    /* 1.1 從本地隊列取出第1個videobuf */
    if (list_empty(&myvivi_vb_local_queue)) {
        goto out;
    }

    vb = list_entry(myvivi_vb_local_queue.next,
             struct videobuf_buffer, queue);

    /* Nobody is waiting on this buffer, return */
    if (!waitqueue_active(&vb->done))
        goto out;

    /* 1.2 填充數據 */
    vbuf = videobuf_to_vmalloc(vb);
    //memset(vbuf, 0xff, vb->size);
    myvivi_fillbuff(vb);

    vb->field_count++;
    do_gettimeofday(&ts);
    vb->ts = ts;
    vb->state = VIDEOBUF_DONE;

/* 1.3 把videobuf從本地隊列中刪除 */
list_del(&vb->queue);

    /* 2. 喚醒進程: 喚醒videobuf->done上的進程 */
    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 */
myvivi_device->release = myvivi_release;

/* 2.2 */
myvivi_device->fops = &myvivi_fops;

/* 2.3 */
myvivi_device->ioctl_ops = &myvivi_ioctl_ops;

    /* 2.4 隊列操作
     * a. 定義/初始化一個隊列(會用到一個spinlock)
     */
    spin_lock_init(&myvivi_queue_slock);

/* 3. 注冊 */
error = video_register_device(myvivi_device, VFL_TYPE_GRABBER, -1);

/* 用定時器產生數據並喚醒進程 */
init_timer(&myvivi_timer);
myvivi_timer.function = myvivi_timer_function;

    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");

//==========================fillbuf.c=======================================
/* 仿照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>

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"

*size = myvivi_format.fmt.pix.sizeimage;

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);