从零写一个摄像头驱动（四）

1、装载驱动时发现，模块缺少依赖

解决方法：
　　1、先安装Ubantu里面自带的vivi程序，它会把它所依赖的驱动程序安装进来/

　　2、sudo rmmod vivi.ko

　　3、ls /dev/video*
　　4、xawtv -c /dev/video* 
　　我写的myvivi.ko编译出来之后，对应的是video1

/*APP在调用ioctl VIDIOC_QBUF时导致此函数被调用
 *它会填充Video_buffer结构体(头部)，并调用videobuf_iolock来分配内存
 *实际上是用mmap函数分配内存的
 */
static int
myvivi_buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
                        enum v4l2_field field)
{
    /* 1.做些准备工作 */
#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

队列的内存实际上是调用 fops中的mmap函数分配的，

加入mmap，并实现myvivi_mmap

编译加载后，运行，原来的错误信息消失了

，现在请求buf,分配buf, 队列操作等函数已经实现，现在缺少的是：怎么构造生产数据?

再次根据系统提示的信息修改代码

加入摄像头启动/关闭函数

加入v4l2_poll函数（select）来查询数据

运行后发现，无法退出界面，是因为 如果poll没有查询到数据则在队列buf->done上休眠，

下一步构造数据唤醒进程。

在vivi.c中，实际上是创建了一个内核线程，线程平时是休眠的。

调用关系如下：

vivi_open
　　vivi_start_thread
　　　　vivi_thread　/*创建内核线程*/　　　
　　　　　for (;;) {
　　　　　　　vivi_sleep(fh); /* 平时是休眠的 */　　　　　　　
　　　　　　　　/* Calculate time to wake up */
　　　　　　　　　timeout = msecs_to_jiffies(frames_to_ms(1));
　　　　　　　　　vivi_thread_tick(fh);
　　　　　　　　　　　　vivi_fillbuff(fh, buf); /*填充buf数据*/
　　　　　　　　　　　　wake_up(&buf->vb.done); /*填充完后唤醒vb.done*/
　　　　　　　　　/*会休眠指定时间，时间到了会重新运行，调用vivi_thread_tick*/
　　　　　　　　　schedule_timeout_interruptible(timeout);

为简单操作，使用定时器唤醒进程

用定时器产生数据并唤醒进程

在入口函数里面初始化timer

/*仿照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; /* 自己定义v4l2_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; /*定义一个timer，然后初始化*/

#include "fillbuf.c"

/* ------------------------------------------------------------------
    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在调用ioctl VIDIOC_QBUF时导致此函数被调用
 *它会填充Video_buffer结构体(头部)，并调用videobuf_iolock来分配内存
 *实际上是用mmap函数分配内存的
 */
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.pixelformat;
    vb->bytesperline = myvivi_format.fmt.pix.pixelformat;
    vb->width  = fh->width;
    vb->height = fh->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结构体，说明状态已经准备好 */
    vb->state = VIDEOBUF_PREPARED;

    return 0;
}

/*APP在调用ioctl VIDIOC_QBUF时
 *1.先调用buffer_prepare进行准备工作
 *2.把buf放入队列
 *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; //状态改为初始状态
}


/* 在内核文档的v4l2-framework中查找
 * buf_setup /buf_prepare/buf_queue/buf_release
 *以上四个函数设置好后，videobuf_queue_ops结构体就设置好了
 */
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: 
     *初始化
     *  1).    定义队列:myvivi_vb_vidqueue            
     *  2). 设置队列操作函数结构体，并实现里面的操作函数:myvivi_video_qops
     *  3). 定义队列所需的自旋锁,并在入口处初始化
     *  4). 设置buffer头部大小
     * ---------设置好队列相关初始化后，继续完成有关于队列与缓冲区的ioctl操作----------
     */
    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);  /* 倒数第二个参数是buffer头部大小 */

    myvivi_timer.expires = jiffies + 1; /*expires为定时器到时时间，*/
    add_timer(&myvivi_timer); /*在用到vivitimer时才去分配，故放在open，非入口函数*/

    return 0;
}


static int myvivi_close(struct file *file)
{
    videobuf_stop(&myvivi_vb_vidqueue);
    videobuf_mmap_free(&myvivi_vb_vidqueue);
    del_timer(&myvivi_timer);
    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) /* index为格式的种数，在此判断条件设置为1 */
        return -EINVAL;

    strcpy(f->description, "4:2:2, packed, YUYV");
    f->pixelformat = V4L2_PIX_FMT_YUYV; //s设置支持一种格式
    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;
    /* 把传进来的参数复制到myvivi_format */
    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)
{
    return videobuf_streamoff(&myvivi_vb_vidqueue);
}


static const struct v4l2_ioctl_ops myvivi_ioctl_ops = {

    //摄像头驱动程序必需的11个ioctl:
    // 表示它是一个摄像头设备
    .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 最终会调用到ioctl_ops里面的ioctl*/   
    .poll      = myvivi_poll,
    
};


/*  video_device结构体用于在/dev目录下生成设备节点文件，把操作设备的接口暴露给用户空间 */
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. 构造数据:从队列头部取出第一个videobuf,填充数据*/
    
        /* 如果链表是空的，表明还没有应用程序关心里面的数据->跳出 */
     if (list_empty(&myvivi_vb_local_queue)) {
        goto out; //
    }
        /* 1.1 从队列myvivi_vb_local_queue的头部取出第一个videobuf*/
    vb = list_entry(myvivi_vb_local_queue.next,
             struct videobuf_buffer, queue);

        /* 本地队列中没有队列等待唤醒，跳出 */
    if (!waitqueue_active(&vb->done))
        goto out;

        /* 1.2 填充数据 */
        vbuf = videobuf_to_vmalloc(vb);
        //memset(vbuf, 0, vb->size); //为新分配的vbuf内存填充数据(为申请的内存做初始化工作)
        myvivi_fillbuff(vb);
        
        /* 填充后要将状态标志为DONE，状态会在poll函数中进行判断 */
        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; //结构体中要有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.注册 */
    /* nr: device node number */
    error = video_register_device(myvivi_device,VFL_TYPE_GRABBER, -1);

    /*用定时器产生数据并唤醒进程*/
    init_timer(&myvivi_timer); //初始化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);
}

/*修饰入口出口函数，使用insmod,rmmod时就会调用对应函数*/
module_init(myvivi_init);
module_exit(myvivi_exit);

/*加入GPL协议，通用性公开许可证(General Public License)*/
MODULE_LICENSE("GPL");