• V4L2(二)虚拟摄像头驱动vivi深入分析【转】


    转自:http://www.cnblogs.com/tureno/articles/6694463.html

    转载于: http://blog.csdn.net/lizuobin2/article/details/53006927

    本文基于:linux3.5

      前面一篇文章中,简单分析了 V4L2 大框架,本文借助内核中的虚拟摄像头驱动 vivi 来分析一个完整的摄像头驱动程序。vivi 相对于后面要分析的 usb 摄像头驱动程序,它没有真正的硬件相关层的操作,也就是说抛开了复杂的 usb 层的相关知识,便于理解 V4L2 驱动框架,侧重于驱动和应用的交互。

      前面我们提到,V4L2 的核心是 v4l2-dev.c 它向上提供统一的文件操作接口 v4l2_fops ,向下提供 video_device 注册接口 register_video_device ,作为一个具体的驱动,需要做的工作就是分配、设置、注册一个 video_device.框架很简单,复杂的是视频设备相关众多的 ioctl。

    一、vivi 框架分析

    1. static int __init vivi_init(void)  
    2. {  
    3.     ret = vivi_create_instance(i);  
    4.     ...  
    5.     return ret;  
    6. }  
    7. module_init(vivi_init);  

      vivi 分配了一个 video_device 指针,没有去设置而是直接让它指向了一个现成的 video_device 结构 vivi_template ,那么全部的工作都将围绕 vivi_template 展开。

    1. static int __init vivi_create_instance(int inst)  
    2. {  
    3.     struct vivi_dev *dev;  
    4.     struct video_device *vfd;  
    5.     struct v4l2_ctrl_handler *hdl;  
    6.     struct vb2_queue *q;  
    7.   
    8.     // 分配一个 vivi_dev 结构体  
    9.     dev = kzalloc(sizeof(*dev), GFP_KERNEL);  
    10.       
    11.     // v4l2_dev 初始化,并没有什么作用  
    12.     ret = v4l2_device_register(NULL, &dev->v4l2_dev);  
    13.       
    14.     // 设置 dev 的一些参数,比如图像格式、大小  
    15.     dev->fmt = &formats[0];  
    16.     dev->width = 640;  
    17.     dev->height = 480;  
    18.     dev->pixelsize = dev->fmt->depth / 8;  
    19.     ...  
    20.       
    21.     // vivi_dev->vb_vidq(vb2_queue) 初始化  
    22.     q = &dev->vb_vidq;  
    23.     memset(q, 0, sizeof(dev->vb_vidq));  
    24.     q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
    25.     q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;  
    26.     q->drv_priv = dev;  
    27.     q->buf_struct_size = sizeof(struct vivi_buffer);  
    28.       
    29.     // vivi_dev->vb_vidq(vb2_queue)->ops  
    30.     q->ops     = &vivi_video_qops;  
    31.       
    32.     // vivi_dev->vb_vidq(vb2_queue)->mem_ops  
    33.     q->mem_ops = &vb2_vmalloc_memops;  
    34.       
    35.     // 初始化一些锁之类的东西  
    36.     vb2_queue_init(q);  
    37.   
    38.     /* init video dma queues */  
    39.     INIT_LIST_HEAD(&dev->vidq.active);  
    40.     init_waitqueue_head(&dev->vidq.wq);  
    41.       
    42.     // 分配一个 video_device ,这才是重点  
    43.     vfd = video_device_alloc();  
    44.   
    45.     *vfd = vivi_template;  
    46.     vfd->debug = debug;  
    47.     vfd->v4l2_dev = &dev->v4l2_dev;  
    48.     set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);  
    49.   
    50.     vfd->lock = &dev->mutex;  
    51.       
    52.     // 注册 video_device !!!  
    53.     ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);  
    54.     // 把 vivi_dev 放入 video_device->dev->p->driver_data ,这个后边经常用到  
    55.     video_set_drvdata(vfd, dev);  
    56.   
    57.     /* Now that everything is fine, let's add it to device list */  
    58.     list_add_tail(&dev->vivi_devlist, &vivi_devlist);  
    59.   
    60.     if (video_nr != -1)  
    61.         video_nr++;  
    62.     // vivi_dev->vfd(video_device) =  vfd  
    63.     dev->vfd = vfd;  
    64.     v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s ",  
    65.           video_device_node_name(vfd));  
    66.     return 0;  
    67. }  

      用户空间调用的是 v4l2_fops ,但是最终会调用到 vivi_fops ,vivi_fops 中的 ioctl 调用 video_ioctl2

    1. static struct video_device vivi_template = {  
    2.     .name       = "vivi",  
    3.     .fops           = &vivi_fops,  
    4.     .ioctl_ops  = &vivi_ioctl_ops,  
    5.     .minor      = -1,  
    6.     .release    = video_device_release,  
    7.   
    8.     .tvnorms              = V4L2_STD_525_60,  
    9.     .current_norm         = V4L2_STD_NTSC_M,  
    10. };  

      video_register_device 过程就不详细分析了,前面的文章中分析过,大概就是向核心层注册 video_device 结构体,核心层注册字符设备并提供一个统一的 fops ,当用户空间 read write ioctl 等,最终还是会跳转到 video_device->fops ,还有一点就是核心层会把我们注册进来的 video_device 结构放入一个全局的 video_device数组。

    1. static const struct v4l2_file_operations vivi_fops = {  
    2.     .owner      = THIS_MODULE,  
    3.     .open           = v4l2_fh_open,  
    4.     .release        = vivi_close,  
    5.     .read           = vivi_read,  
    6.     .poll       = vivi_poll,  
    7.     .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */  
    8.     .mmap           = vivi_mmap,  
    9. };  

      这里,先看一下 v4l2_fh_open 函数

    1. int v4l2_fh_open(struct file *filp)  
    2. {  
    3.   // 前面注册时,我们将 video_device 结构体放入了全局数组 video_device ,现在通过     video_devdata 函数取出来,后面经常用到这种做法  
    4.     struct video_device *vdev = video_devdata(filp);  
    5.     // 分配一个 v4l2_fh 结构,放入file->private_data 中  
    6.     struct v4l2_fh *fh = kzalloc(sizeof(*fh), GFP_KERNEL);  
    7.     filp->private_data = fh;  
    8.     if (fh == NULL)  
    9.         return -ENOMEM;  
    10.     v4l2_fh_init(fh, vdev);  
    11.     v4l2_fh_add(fh);  
    12.     return 0;  
    13. }  

      1、我们随时可以通过 video_devdata 取出我们注册的 video_device 结构进行操作

      2、我们随时可以通过 file->private_data 取出 v4l2_fh 结构,虽然现在还不知道它有啥用

      下面来分析 ioctl ...首先来看一下调用过程 

    1. long video_ioctl2(struct file *file,  
    2.            unsigned int cmd, unsigned long arg)  
    3. {  
    4.     return video_usercopy(file, cmd, arg, __video_do_ioctl);  
    5. }  
    1. static long __video_do_ioctl(struct file *file,  
    2.         unsigned int cmd, void *arg)  
    3. {  
    4.     struct video_device *vfd = video_devdata(file);  
    5.     const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;  
    6.     void *fh = file->private_data;  
    7.     struct v4l2_fh *vfh = NULL;  
    8.     int use_fh_prio = 0;  
    9.     long ret = -ENOTTY;  
    10.   
    11.     if (ops == NULL) {  
    12.         printk(KERN_WARNING "videodev: "%s" has no ioctl_ops. ",  
    13.                 vfd->name);  
    14.         return ret;  
    15.     }  
    16.   
    17.     if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags)) {  
    18.         vfh = file->private_data;  
    19.         use_fh_prio = test_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);  
    20.     }  
    21.   
    22.     if (v4l2_is_known_ioctl(cmd)) {  
    23.         struct v4l2_ioctl_info *info = &v4l2_ioctls[_IOC_NR(cmd)];  
    24.   
    25.             if (!test_bit(_IOC_NR(cmd), vfd->valid_ioctls) &&  
    26.             !((info->flags & INFO_FL_CTRL) && vfh && vfh->ctrl_handler))  
    27.             return -ENOTTY;  
    28.   
    29.         if (use_fh_prio && (info->flags & INFO_FL_PRIO)) {  
    30.             ret = v4l2_prio_check(vfd->prio, vfh->prio);  
    31.             if (ret)  
    32.                 return ret;  
    33.         }  
    34.     }  
    35.   
    36.     if ((vfd->debug & V4L2_DEBUG_IOCTL) &&  
    37.                 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {  
    38.         v4l_print_ioctl(vfd->name, cmd);  
    39.         printk(KERN_CONT " ");  
    40.     }  
    41.   
    42.     switch (cmd) {  
    43.   
    44.     /* --- capabilities ------------------------------------------ */  
    45.     case VIDIOC_QUERYCAP:  
    46.     {  
    47.         struct v4l2_capability *cap = (struct v4l2_capability *)arg;  
    48.   
    49.         cap->version = LINUX_VERSION_CODE;  
    50.         ret = ops->vidioc_querycap(file, fh, cap);  
    51.         if (!ret)  
    52.             dbgarg(cmd, "driver=%s, card=%s, bus=%s, "  
    53.                     "version=0x%08x, "  
    54.                     "capabilities=0x%08x, "  
    55.                     "device_caps=0x%08x ",  
    56.                     cap->driver, cap->card, cap->bus_info,  
    57.                     cap->version,  
    58.                     cap->capabilities,  
    59.                     cap->device_caps);  
    60.         break;  
    61.     }  

      vivi 驱动就复杂在这些 ioctl 上,下面按照应用层与驱动的交互顺序来具体的分析这些 ioctl 。

    二、ioctl 深入分析

      应用空间的一个视频 app 与驱动的交互流程大致如下图所示:

      下面就根据流程,分析每一个 ioctl 在 vivi 中的具体实现。把以上的过程吃透,自己写一个虚拟摄像头程序应该就不成问题了。

     2.1 VIDIOC_QUERYCAP 查询设备能力

    应用层:

    1. struct v4l2_capability {  
    2.     __u8    driver[16]; /* i.e. "bttv" */  
    3.     __u8    card[32];   /* i.e. "Hauppauge WinTV" */  
    4.     __u8    bus_info[32];   /* "PCI:" + pci_name(pci_dev) */  
    5.     __u32   version;        <span style="white-space:pre">    </span>/* should use KERNEL_VERSION() */  
    6.     __u32   capabilities;   /* Device capabilities */  
    7.     __u32   reserved[4];  
    8. };  
    9.   
    10. struct v4l2_capability cap;  
    11. ret = ioctl(fd,VIDIOC_QUERYCAP,&cap);  
    12. if (ret < 0) {  
    13.     LOG("VIDIOC_QUERYCAP failed (%d) ", ret);  
    14.     return ret;  
    15. }  

    驱动层:

    1. void *fh = file->private_data;  
    2. ops->vidioc_querycap(file, fh, cap);  
    3. static int vidioc_querycap(struct file *file, void  *priv, struct v4l2_capability *cap)  
    4. {  
    5.     struct vivi_fh  *fh  = priv;  
    6.     struct vivi_dev *dev = fh->dev;  
    7.   
    8.   
    9.     // 这里只是将一些信息写回用户空间而已,非常简单  
    10.     strcpy(cap->driver, "vivi");    
    11.     strcpy(cap->card, "vivi");  
    12.     strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));  
    13.     cap->version =     VIVI_VERSION; cap->capabilities =V4L2_CAP_VIDEO_CAPTURE |V4L2_CAP_STREAMING     | V4L2_CAP_READWRITE;return 0;}  
    14. }  

      一般我们只关心 capabilities 成员,比如V4L2_CAP_VIDEO_CAPTURE 具有视频捕获能力,其它定义如下:

    1. /* Values for 'capabilities' field */  
    2. #define V4L2_CAP_VIDEO_CAPTURE      0x00000001  /* Is a video capture device */  
    3. #define V4L2_CAP_VIDEO_OUTPUT       0x00000002  /* Is a video output device */  
    4. #define V4L2_CAP_VIDEO_OVERLAY      0x00000004  /* Can do video overlay */  
    5. #define V4L2_CAP_VBI_CAPTURE        0x00000010  /* Is a raw VBI capture device */  
    6. #define V4L2_CAP_VBI_OUTPUT     0x00000020  /* Is a raw VBI output device */  
    7. #define V4L2_CAP_SLICED_VBI_CAPTURE 0x00000040  /* Is a sliced VBI capture device */  
    8. #define V4L2_CAP_SLICED_VBI_OUTPUT  0x00000080  /* Is a sliced VBI output device */  
    9. #define V4L2_CAP_RDS_CAPTURE        0x00000100  /* RDS data capture */  
    10. #define V4L2_CAP_VIDEO_OUTPUT_OVERLAY   0x00000200  /* Can do video output overlay */  
    11. #define V4L2_CAP_HW_FREQ_SEEK       0x00000400  /* Can do hardware frequency seek  */  
    12. #define V4L2_CAP_RDS_OUTPUT     0x00000800  /* Is an RDS encoder */  

     2.2 VIDIOC_ENUM_FMT 枚举(查询)设备支持的视频格式

    应用层:

    1. struct v4l2_fmtdesc {  
    2.     __u32           index;             /* Format number      */  
    3.     enum v4l2_buf_type  type;              /* buffer type        */  
    4.     __u32               flags;  
    5.     __u8            description[32];   /* Description string */  
    6.     __u32           pixelformat;       /* Format fourcc      */  
    7.     __u32           reserved[4];  
    8. };  
    9.   
    10. struct v4l2_fmtdesc fmtdesc;  
    11. fmtdesc.index=0;  
    12. fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;  
    13. while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)  
    14. {  
    15.     printf("SUPPORT %d.%s ",fmtdesc.index+1,fmtdesc.description);  
    16.     fmtdesc.index++;  
    17. }  

    驱动层:

    1. static struct vivi_fmt formats[] = {  
    2.     {  
    3.         .name     = "4:2:2, packed, YUYV",  
    4.         .fourcc   = V4L2_PIX_FMT_YUYV,  
    5.         .depth    = 16,  
    6.     },  
    7.     ...  
    8. }  
    9. static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,  
    10.                     struct v4l2_fmtdesc *f)  
    11. {  
    12.     struct vivi_fmt *fmt;  
    13.   
    14.     if (f->index >= ARRAY_SIZE(formats))  
    15.         return -EINVAL;  
    16.   
    17.     fmt = &formats[f->index];  
    18.   
    19.     strlcpy(f->description, fmt->name, sizeof(f->description));  
    20.     f->pixelformat = fmt->fourcc;  
    21.     return 0;  
    22. }  

      一般一个设备支持多种视频格式,比如 vivi 它所支持的格式存放在 formats 数组中,由于应用层并不知道设备支持多少种格式,也不知道某种格式具体存放在哪个数组项中,因此通过index从0开始尝试,对于驱动层来说就是遍历所有的数组项,返回每一个index对应的视频格式,比如 V4L2_PIX_FMT_YUYV .

     2.3 VIDIOC_S_FMT 设置视频格式

    应用层:

    1. struct v4l2_format {  
    2.     enum v4l2_buf_type type;  
    3.     union {  
    4.         struct v4l2_pix_format      pix;     /* V4L2_BUF_TYPE_VIDEO_CAPTURE */  
    5.         struct v4l2_window      win;     /* V4L2_BUF_TYPE_VIDEO_OVERLAY */  
    6.         struct v4l2_vbi_format      vbi;     /* V4L2_BUF_TYPE_VBI_CAPTURE */  
    7.         struct v4l2_sliced_vbi_format   sliced;  /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */  
    8.         __u8    raw_data[200];                   /* user-defined */  
    9.     } fmt;  
    10. };  
    11. struct v4l2_pix_format {  
    12.     __u32               width;  
    13.     __u32           height;  
    14.     __u32           pixelformat;  
    15.     enum v4l2_field     field;  
    16.     __u32               bytesperline;   /* for padding, zero if unused */  
    17.     __u32               sizeimage;  
    18.     enum v4l2_colorspace    colorspace;  
    19.     __u32           priv;       /* private data, depends on pixelformat */  
    20. };  
    21. struct v4l2_format fmt;  
    22. memset(&fmt, 0, sizeof(fmt));  
    23. fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//格式类型  
    24. fmt.fmt.pix.width //宽度  
    25. fmt.fmt.pix.height //高度  
    26. fmt.fmt.pix.pixelformat = VIDEO_FORMAT;//这一项必须是前面查询出来的某种格式,对应 vivi formats数组  
    27. fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;//好像是隔行扫描的意思  
    28. ret = ioctl(fd, VIDIOC_S_FMT, &fmt);  
    29. if (ret < 0) {  
    30.     LOG("VIDIOC_S_FMT failed (%d) ", ret);  
    31.     return ret;  
    32. }  

    驱动层:

    1. static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,  
    2.                     struct v4l2_format *f)  
    3. {  
    4.     struct vivi_dev *dev = video_drvdata(file);  
    5.     struct vb2_queue *q = &dev->vb_vidq;  
    6.   
    7.     int ret = vidioc_try_fmt_vid_cap(file, priv, f);  
    8.     //if (fmt->fourcc == f->fmt.pix.pixelformat)返回formats[k]  
    9.     dev->fmt = get_format(f);  
    10.     dev->pixelsize   = dev->fmt->depth / 8;  
    11.     dev->width       = f->fmt.pix.width;  
    12.     dev->height  = f->fmt.pix.height;  
    13.     dev->field       = f->fmt.pix.field;  
    14.   
    15.     return 0;  
    16. }  
    17. static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,  
    18.             struct v4l2_format *f)  
    19. {  
    20.     struct vivi_dev *dev = video_drvdata(file);  
    21.     struct vivi_fmt *fmt;  
    22.     enum v4l2_field field;  
    23.   
    24.     fmt = get_format(f);  
    25.   
    26.     field = f->fmt.pix.field;  
    27.   
    28.     if (field == V4L2_FIELD_ANY) {  
    29.         field = V4L2_FIELD_INTERLACED;  
    30.     }   
    31.   
    32.     f->fmt.pix.field = field;  
    33.     v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 2,  
    34.                   &f->fmt.pix.height, 32, MAX_HEIGHT, 0, 0);  
    35.     f->fmt.pix.bytesperline =  
    36.         (f->fmt.pix.width * fmt->depth) >> 3;  
    37.     f->fmt.pix.sizeimage =  
    38.         f->fmt.pix.height * f->fmt.pix.bytesperline;  
    39.     if (fmt->fourcc == V4L2_PIX_FMT_YUYV ||  
    40.         fmt->fourcc == V4L2_PIX_FMT_UYVY)  
    41.         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;  
    42.     else  
    43.         f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;  
    44.     return 0;  
    45. }  

      这里将应用层传进来的视频格式简单处理后存放进了一个 vivi_dev 结构,vivi_dev 哪里来的呢?,在一开始的时候 vivi_create_instance ,我们创建了一个 video_device 结构代表我们的设备,并设置了一个 vivi_dev 作为 video_device->dev->privatedata ,之后 register_video_device ,内核会自动将我们的 video_device 放入全局数组 video_device[] 中。

     2.4 VIDIOC_G_FMT 获得设置好的视频格式

    应用层:

    1. ret = ioctl(fd, VIDIOC_G_FMT, &fmt);  
    2. if (ret < 0) {  
    3.     LOG("VIDIOC_G_FMT failed (%d) ", ret);  
    4.     return ret;  
    5. }  
    6. // Print Stream Format  
    7. LOG("Stream Format Informations: ");  
    8. LOG(" type: %d ", fmt.type);  
    9. LOG("  %d ", fmt.fmt.pix.width);  
    10. LOG(" height: %d ", fmt.fmt.pix.height);  
    11. char fmtstr[8];  
    12. memset(fmtstr, 0, 8);  
    13. memcpy(fmtstr, &fmt.fmt.pix.pixelformat, 4);  
    14. LOG(" pixelformat: %s ", fmtstr);  
    15. LOG(" field: %d ", fmt.fmt.pix.field);  
    16. LOG(" bytesperline: %d ", fmt.fmt.pix.bytesperline);  
    17. LOG(" sizeimage: %d ", fmt.fmt.pix.sizeimage);  
    18. LOG(" colorspace: %d ", fmt.fmt.pix.colorspace);  
    19. LOG(" priv: %d ", fmt.fmt.pix.priv);  
    20. LOG(" raw_date: %s ", fmt.fmt.raw_data);  

    驱动层:

    1. static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,  
    2.                     struct v4l2_format *f)  
    3. {  
    4.     struct vivi_dev *dev = video_drvdata(file);  
    5. <span style="white-space:pre">    </span>// 把记录在 vivi_dev 中的参数写回用户空间  
    6.     f->fmt.pix.width        = dev->width;  
    7.     f->fmt.pix.height       = dev->height;  
    8.     f->fmt.pix.field        = dev->field;  
    9.     f->fmt.pix.pixelformat  = dev->fmt->fourcc;  
    10.     f->fmt.pix.bytesperline =  
    11.         (f->fmt.pix.width * dev->fmt->depth) >> 3;  
    12.     f->fmt.pix.sizeimage =  
    13.         f->fmt.pix.height * f->fmt.pix.bytesperline;  
    14.     if (dev->fmt->fourcc == V4L2_PIX_FMT_YUYV ||  
    15.         dev->fmt->fourcc == V4L2_PIX_FMT_UYVY)  
    16.         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;  
    17.     else  
    18.         f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;  
    19.     return 0;  
    20. }  

      将我们之前设置的格式返回而已。
      2.5 VIDIOC_REQBUFS 请求在内核空间分配视频缓冲区
        分配的内存位于内核空间,应用程序无法直接访问,需要通过调用mmap内存映射函数,把内核空间的内存映射到用户空间,应用才可以用用户空间地址来访问内核空间。
    应用层:

    1. struct v4l2_requestbuffers {  
    2.     __u32           count;  
    3.     __u32           type;       /* enum v4l2_buf_type */  
    4.     __u32           memory;     /* enum v4l2_memory */  
    5.     __u32           reserved[2];  
    6. };  
    7. struct v4l2_requestbuffers reqbuf;  
    8. reqbuf.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
    9. reqbuf.memory   = V4L2_MEMORY_MMAP;  
    10. reqbuf.count    = BUFFER_COUNT;  
    11. ret = ioctl(fd , VIDIOC_REQBUFS, &reqbuf);  
    12. if(ret < 0) {  
    13.     LOG("VIDIOC_REQBUFS failed (%d) ", ret);  
    14.     return ret;  
    15. }  

    驱动层:

    1. static int vidioc_reqbufs(struct file *file, void *priv,  
    2.               struct v4l2_requestbuffers *p)  
    3. {  
    4.     struct vivi_dev *dev = video_drvdata(file);  
    5.     return vb2_reqbufs(&dev->vb_vidq, p);    //核心层提供的标准函数  
    6. }  

      vb_vidq 是 vivi_dev 的一个成员,前面我们提到它有两个 ops ,一个是 ops 另一个是 mem_ops

    1. static struct vb2_ops vivi_video_qops = {  
    2.     .queue_setup    = queue_setup,  
    3.     .buf_init       = buffer_init,  
    4.     .buf_prepare    = buffer_prepare,  
    5.     .buf_finish         = buffer_finish,  
    6.     .buf_cleanup        = buffer_cleanup,  
    7.     .buf_queue      = buffer_queue,  
    8.     .start_streaming= start_streaming,  
    9.     .stop_streaming     = stop_streaming,  
    10.     .wait_prepare       = vivi_unlock,  
    11.     .wait_finish        = vivi_lock,  
    12. };  
    1. static int vidioc_reqbufs(struct file *file, void *priv,  
    2.               struct v4l2_requestbuffers *p)  
    3. {  
    4.     struct vivi_dev *dev = video_drvdata(file);  
    5.     return vb2_reqbufs(&dev->vb_vidq, p);    //核心层提供的标准函数  
    6. }  
    1. int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req)  
    2. {  
    3.     unsigned int num_buffers, allocated_buffers, num_planes = 0;  
    4.     int ret = 0;  
    5.     // 判断 re->count 是否小于 VIDEO_MAX_FRAME  
    6.     num_buffers = min_t(unsigned int, req->count, VIDEO_MAX_FRAME);  
    7.     memset(q->plane_sizes, 0, sizeof(q->plane_sizes));  
    8.     memset(q->alloc_ctx, 0, sizeof(q->alloc_ctx));  
    9.     q->memory = req->memory;  
    10.   
    11.     //(q)->ops->queue_setup(q,NULL,...)  
    12.     ret = call_qop(q, queue_setup, q, NULL, &num_buffers, &num_planes,  
    13.                q->plane_sizes, q->alloc_ctx);  
    14.     /* Finally, allocate buffers and video memory */  
    15.     ret = __vb2_queue_alloc(q, req->memory, num_buffers, num_planes);  
    16.   
    17.     allocated_buffers = ret;  
    18.   
    19.     q->num_buffers = allocated_buffers;  
    20.     req->count = allocated_buffers;  
    21.     return 0;  
    22. }  
    1. static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,  
    2.                 unsigned int *nbuffers, unsigned int *nplanes,  
    3.                 unsigned int sizes[], void *alloc_ctxs[])  
    4. {  
    5.     struct vivi_dev *dev = vb2_get_drv_priv(vq);  
    6.     unsigned long size;  
    7.     // 每一个buffer 的大小  
    8.     size = dev->width * dev->height * dev->pixelsize;  
    9.     if (0 == *nbuffers)  
    10.         *nbuffers = 32;  
    11.     // 如果申请的buffer过多,导致空间不够减少buffer  
    12.     while (size * *nbuffers > vid_limit * 1024 * 1024)  
    13.         (*nbuffers)--;  
    14.     *nplanes = 1;  
    15.     // 把总大小放入 vivi_dev->vb_vidq->plane_size[0]  
    16.     sizes[0] = size;  
    17.     return 0;  
    18. }  
    1. static int __vb2_queue_alloc(struct vb2_queue *q, enum v4l2_memory memory,  
    2.                  unsigned int num_buffers, unsigned int num_planes)  
    3. {  
    4.     unsigned int buffer;  
    5.     struct vb2_buffer *vb;  
    6.     int ret;  
    7.     // 分配多个 vb2_buffer 填充并放入 vivi_dev->vb_vidq->bufs[]  
    8.     for (buffer = 0; buffer < num_buffers; ++buffer) {  
    9.         /* Allocate videobuf buffer structures */  
    10.         vb = kzalloc(q->buf_struct_size, GFP_KERNEL);  
    11.           
    12.         /* Length stores number of planes for multiplanar buffers */  
    13.         if (V4L2_TYPE_IS_MULTIPLANAR(q->type))  
    14.             vb->v4l2_buf.length = num_planes;  
    15.   
    16.         vb->state = VB2_BUF_STATE_DEQUEUED;  
    17.         vb->vb2_queue = q;  
    18.         vb->num_planes = num_planes;  
    19.         vb->v4l2_buf.index = q->num_buffers + buffer;  
    20.         vb->v4l2_buf.type = q->type;  
    21.         vb->v4l2_buf.memory = memory;  
    22.   
    23.         /* Allocate video buffer memory for the MMAP type */  
    24.         if (memory == V4L2_MEMORY_MMAP) {  
    25.             ret = __vb2_buf_mem_alloc(vb);//核心提供的标准函数  
    26.             ret = call_qop(q, buf_init, vb);//q->ops->buf_init  
    27.         }  
    28.   
    29.         q->bufs[q->num_buffers + buffer] = vb;  
    30.     }  
    31.     __setup_offsets(q, buffer);  
    32.     return buffer;  
    33. }  
    1. static int __vb2_buf_mem_alloc(struct vb2_buffer *vb)  
    2. {  
    3.     struct vb2_queue *q = vb->vb2_queue;  
    4.     void *mem_priv;  
    5.     int plane;  
    6.   
    7.     /* num_planes == 1 */  
    8.     for (plane = 0; plane < vb->num_planes; ++plane) {  
    9.         mem_priv = call_memop(q, alloc, q->alloc_ctx[plane],  
    10.                       q->plane_sizes[plane]);  
    11.   
    12.         /* Associate allocator private data with this plane */  
    13.         vb->planes[plane].mem_priv = mem_priv;  
    14.         vb->v4l2_planes[plane].length = q->[plane];  
    15.     }  
    16.   
    17.     return 0;  
    18. }  
    1. static void *vb2_vmalloc_alloc(void *alloc_ctx, unsigned long size)  
    2. {  
    3.     struct vb2_vmalloc_buf *buf;  
    4.   
    5.     buf = kzalloc(sizeof(*buf), GFP_KERNEL);  
    6.   
    7.     buf->size = size;  
    8.     // 分配空间  
    9.     buf->vaddr = vmalloc_user(buf->size);  
    10.     buf->handler.refcount = &buf->refcount;  
    11.     buf->handler.put = vb2_vmalloc_put;  
    12.     buf->handler.arg = buf;  
    13.   
    14.     atomic_inc(&buf->refcount);  
    15.     return buf;  
    16. }  

      2.6 VIDIOC_QUERYBUF 查询分配好的 buffer 信息
        查询已经分配好的V4L2视频缓冲区的相关信息,包括缓冲区的使用状态、在内核空间的偏移地址、缓冲区长度等,然后应用程序根据这些信息使用mmap把内核空间地址映射到用户空间。
    应用层:

    1. struct v4l2_buffer {  
    2.     __u32                   index;  
    3.     enum v4l2_buf_type      type;  
    4.     __u32                   bytesused;  
    5.     __u32                   flags;  
    6.     enum v4l2_field         field;  
    7.     struct timeval          timestamp;  
    8.     struct v4l2_timecode    timecode;  
    9.     __u32                   sequence;  
    10.   
    11.     /* memory location */  
    12.     enum v4l2_memory        memory;  
    13.     union {  
    14.         __u32               offset;  
    15.         unsigned long       userptr;  
    16.     } m;  
    17.     __u32                   length;  
    18.     __u32                   input;  
    19.     __u32                   reserved;  
    20. };  
    21. v4l2_buffer buf;  
    22. buf.index = i;  
    23. buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
    24. buf.memory = V4L2_MEMORY_MMAP;  
    25. ret = ioctl(fd , VIDIOC_QUERYBUF, &buf);  
    26. if(ret < 0) {  
    27.     LOG("VIDIOC_QUERYBUF (%d) failed (%d) ", i, ret);  
    28.     return ret;  
    29. }  

    驱动层:

    1. ops->vidioc_querybuf(file, fh, p);  
    2. static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)  
    3. {  
    4.     struct vivi_dev *dev = video_drvdata(file);  
    5.     return vb2_querybuf(&dev->vb_vidq, p);  
    6. }  
    1. int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b)  
    2. {  
    3.     struct vb2_buffer *vb;  
    4.     // 取出 buf  
    5.     vb = q->bufs[b->index];  
    6.     // 将 buf 信息写回用户空间传递的 b  
    7.     return __fill_v4l2_buffer(vb, b);  
    8. }  
    1. static int __fill_v4l2_buffer(struct vb2_buffer *vb, struct v4l2_buffer *b)  
    2. {  
    3.     struct vb2_queue *q = vb->vb2_queue;  
    4.     int ret;  
    5.   
    6.     /* Copy back data such as timestamp, flags, input, etc. */  
    7.     memcpy(b, &vb->v4l2_buf, offsetof(struct v4l2_buffer, m));  
    8.     b->input = vb->v4l2_buf.input;  
    9.     b->reserved = vb->v4l2_buf.reserved;  
    10.   
    11.     if (V4L2_TYPE_IS_MULTIPLANAR(q->type)) {  
    12.         ret = __verify_planes_array(vb, b);  
    13.         if (ret)  
    14.             return ret;  
    15.   
    16.         /* 
    17.          * Fill in plane-related data if userspace provided an array 
    18.          * for it. The memory and size is verified above. 
    19.          */  
    20.         memcpy(b->m.planes, vb->v4l2_planes,  
    21.             b->length * sizeof(struct v4l2_plane));  
    22.   
    23.         if (q->memory == V4L2_MEMORY_DMABUF) {  
    24.             unsigned int plane;  
    25.             for (plane = 0; plane < vb->num_planes; ++plane)  
    26.                 b->m.planes[plane].m.fd = 0;  
    27.         }  
    28.     } else {  
    29.         /* 
    30.          * We use length and offset in v4l2_planes array even for 
    31.          * single-planar buffers, but userspace does not. 
    32.          */  
    33.         b->length = vb->v4l2_planes[0].length;  
    34.         b->bytesused = vb->v4l2_planes[0].bytesused;  
    35.         if (q->memory == V4L2_MEMORY_MMAP)  
    36.             b->m.offset = vb->v4l2_planes[0].m.mem_offset;  
    37.         else if (q->memory == V4L2_MEMORY_USERPTR)  
    38.             b->m.userptr = vb->v4l2_planes[0].m.userptr;  
    39.         else if (q->memory == V4L2_MEMORY_DMABUF)  
    40.             b->m.fd = 0;  
    41.     }  
    42.   
    43.     /* 
    44.      * Clear any buffer state related flags. 
    45.      */  
    46.     b->flags &= ~V4L2_BUFFER_STATE_FLAGS;  
    47.   
    48.     switch (vb->state) {  
    49.     case VB2_BUF_STATE_QUEUED:  
    50.     case VB2_BUF_STATE_ACTIVE:  
    51.         b->flags |= V4L2_BUF_FLAG_QUEUED;  
    52.         break;  
    53.     case VB2_BUF_STATE_ERROR:  
    54.         b->flags |= V4L2_BUF_FLAG_ERROR;  
    55.         /* fall through */  
    56.     case VB2_BUF_STATE_DONE:  
    57.         b->flags |= V4L2_BUF_FLAG_DONE;  
    58.         break;  
    59.     case VB2_BUF_STATE_PREPARED:  
    60.         b->flags |= V4L2_BUF_FLAG_PREPARED;  
    61.         break;  
    62.     case VB2_BUF_STATE_DEQUEUED:  
    63.         /* nothing */  
    64.         break;  
    65.     }  
    66.   
    67.     if (__buffer_in_use(q, vb))  
    68.         b->flags |= V4L2_BUF_FLAG_MAPPED;  
    69.   
    70.     return 0;  
    71. }  

    2.7 mmap
    应用层:

    1. v4l2_buffer framebuf[]  
    2. framebuf[i].length = buf.length;  
    3. framebuf[i].start = (char *) mmap(  
    4.     NULL,       // 欲指向内存的起始地址,一般为NULL,表示系统自动分配  
    5.     buf.length, //映射长度  
    6.     PROT_READ|PROT_WRITE,   //可读可写  
    7.     MAP_SHARED,     //对映射区的读写会写回内核空间,而且允许其它映射该内核空间地址的进程共享  
    8.     fd,   
    9.     buf.m.offset  
    10. );  
    11. if (framebuf[i].start == MAP_FAILED) {  
    12.     LOG("mmap (%d) failed: %s ", i, strerror(errno));  
    13.     return -1;  
    14. }  

    驱动层:

    1. static int vivi_mmap(struct file *file, struct vm_area_struct *vma)  
    2. {  
    3.     struct vivi_dev *dev = video_drvdata(file);  
    4.     int ret;  
    5.     ret = vb2_mmap(&dev->vb_vidq, vma);//核心层提供的函数  
    6.     return ret;  
    7. }  

    2.8 VIDIOC_QBUF 
      投放一个空的视频缓冲区到视频缓冲区输入队列,执行成功后,在启动视频设备拍摄图像时,相应的视频数据被保存到视频输入队列相应的视频缓冲区中。
    应用层:

    1. ret = ioctl(fd , VIDIOC_QBUF, &buf);  
    2. if (ret < 0) {  
    3.     LOG("VIDIOC_QBUF (%d) failed (%d) ", i, ret);  
    4.     return -1;  

    驱动层:

    1. static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)  
    2. {  
    3.     struct vivi_dev *dev = video_drvdata(file);  
    4.     return vb2_qbuf(&dev->vb_vidq, p);  
    5. }  
    1. int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)  
    2. {  
    3.     struct rw_semaphore *mmap_sem = NULL;  
    4.     struct vb2_buffer *vb;  
    5.     int ret = 0;  
    6.   
    7.     vb = q->bufs[b->index];  
    8.   
    9.     switch (vb->state) {  
    10.     case VB2_BUF_STATE_DEQUEUED:  
    11.         ret = __buf_prepare(vb, b);  
    12.     }  
    13.     // 将这个 buffer 挂入 q->queued_list  
    14.     list_add_tail(&vb->queued_entry, &q->queued_list);  
    15.     vb->state = VB2_BUF_STATE_QUEUED;  
    16.   
    17.     if (q->streaming)  
    18.         __enqueue_in_driver(vb);  
    19.   
    20.     /* Fill buffer information for the userspace */  
    21.     __fill_v4l2_buffer(vb, b);  
    22.   
    23. unlock:  
    24.     if (mmap_sem)  
    25.         up_read(mmap_sem);  
    26.     return ret;  
    27. }  

      实质上就是取出一个 vb2_buffer 挂入 vivi_dev->vb_vidq->queued_list
    2.9 VIDIOC_STREAMON
    应用层:

    1. enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
    2. ret = ioctl(fd, VIDIOC_STREAMON, &type);  
    3. if (ret < 0) {  
    4.     LOG("VIDIOC_STREAMON failed (%d) ", ret);  
    5.     return ret;  
    6. }  

    驱动层:

    1. static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)  
    2. {  
    3.     struct vivi_dev *dev = video_drvdata(file);  
    4.     return vb2_streamon(&dev->vb_vidq, i);  
    5. }  
    1. int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type)  
    2. {  
    3.     struct vb2_buffer *vb;  
    4.     int ret;  
    5.     vb->state = VB2_BUF_STATE_ACTIVE;  
    6.     // 在 queued_list 链表中取出每一个 buffer 调用buffer queue,对于vivi来说就是放入 vidq->active 链表  
    7.     list_for_each_entry(vb, &q->queued_list, queued_entry)  
    8.             __enqueue_in_driver(vb);  
    9.     ret = call_qop(q, start_streaming, q, atomic_read(&q->queued_count));  
    10.   
    11.     q->streaming = 1;  
    12.     return 0;  
    13. }  
    1. static void __enqueue_in_driver(struct vb2_buffer *vb)  
    2. {  
    3.     struct vb2_queue *q = vb->vb2_queue;  
    4.     vb->state = VB2_BUF_STATE_ACTIVE;  
    5.   
    6.     /* sync buffers */  
    7.     for (plane = 0; plane < vb->num_planes; ++plane)  
    8.     call_memop(q, prepare, vb->planes[plane].mem_priv);  
    9.   
    10.     q->ops->buf_queue(vb);//    list_add_tail(&buf->list, &vidq->active);      
    11. }  
    1. static int start_streaming(struct vb2_queue *vq, unsigned int count)  
    2. {  
    3.     struct vivi_dev *dev = vb2_get_drv_priv(vq);  
    4.     dprintk(dev, 1, "%s ", __func__);  
    5.     return vivi_start_generating(dev);  
    6. }  
    1. static int vivi_start_generating(struct vivi_dev *dev)  
    2. {  
    3.     struct vivi_dmaqueue *dma_q = &dev->vidq;  
    4.   
    5.     /* Resets frame counters */  
    6.     dev->ms = 0;  
    7.     dev->mv_count = 0;  
    8.     dev->jiffies = jiffies;  
    9.   
    10.     dma_q->frame = 0;  
    11.     dma_q->ini_jiffies = jiffies;  
    12.     // 创建一个内核线程,入口函数 vivi_thread  
    13.     dma_q->kthread = kthread_run(vivi_thread, dev, dev->v4l2_dev.name);  
    14.       
    15.     /* Wakes thread */  
    16.     wake_up_interruptible(&dma_q->wq);  
    17.   
    18.     return 0;  
    19. }  
    1. static int vivi_thread(void *data)  
    2. {  
    3.     struct vivi_dev *dev = data;  
    4.   
    5.     dprintk(dev, 1, "thread started ");  
    6.   
    7.     set_freezable();  
    8.   
    9.     for (;;) {  
    10.         vivi_sleep(dev);  
    11.   
    12.         if (kthread_should_stop())  
    13.             break;  
    14.     }  
    15.     dprintk(dev, 1, "thread: exit ");  
    16.     return 0;  
    17. }  
    1. static void vivi_sleep(struct vivi_dev *dev)  
    2. {  
    3.     struct vivi_dmaqueue *dma_q = &dev->vidq;  
    4.     int timeout;  
    5.     DECLARE_WAITQUEUE(wait, current);  
    6.   
    7.     add_wait_queue(&dma_q->wq, &wait);  
    8.     if (kthread_should_stop())  
    9.         goto stop_task;  
    10.   
    11.     /* Calculate time to wake up */  
    12.     timeout = msecs_to_jiffies(frames_to_ms(1));  
    13.   
    14.     vivi_thread_tick(dev);  
    15.   
    16.     schedule_timeout_interruptible(timeout);  
    17.   
    18. stop_task:  
    19.     remove_wait_queue(&dma_q->wq, &wait);  
    20.     try_to_freeze();  
    21. }  

      每次调用 vivi_sleep 这个线程都被挂入等待队列,调用 vivi_thread_tick 填充数据,然后休眠指定的时间自动唤醒,一直循环下去。这样就生成了一帧一帧的视频数据。

    1. static void vivi_thread_tick(struct vivi_dev *dev)  
    2. {  
    3.     struct vivi_dmaqueue *dma_q = &dev->vidq;  
    4.     struct vivi_buffer *buf;  
    5.     unsigned long flags = 0;  
    6.   
    7.     spin_lock_irqsave(&dev->slock, flags);  
    8.   
    9.     buf = list_entry(dma_q->active.next, struct vivi_buffer, list);  
    10.     list_del(&buf->list);  
    11.     spin_unlock_irqrestore(&dev->slock, flags);  
    12.   
    13.     do_gettimeofday(&buf->vb.v4l2_buf.timestamp);  
    14.   
    15.     /* 填充Buffer */  
    16.     vivi_fillbuff(dev, buf);  
    17.   
    18.     vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);  
    19. }  
    1. void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state)  
    2. {  
    3.     struct vb2_queue *q = vb->vb2_queue;  
    4.     unsigned long flags;  
    5.     unsigned int plane;  
    6.   
    7.     /* sync buffers */  
    8.     for (plane = 0; plane < vb->num_planes; ++plane)  
    9.         call_memop(q, finish, vb->planes[plane].mem_priv);  
    10.   
    11.     /* Add the buffer to the done buffers list */  
    12.     spin_lock_irqsave(&q->done_lock, flags);  
    13.     vb->state = state;  
    14.     list_add_tail(&vb->done_entry, &q->done_list);  
    15.     atomic_dec(&q->queued_count);  
    16. #ifdef CONFIG_SYNC  
    17.     sw_sync_timeline_inc(q->timeline, 1);  
    18. #endif  
    19.     spin_unlock_irqrestore(&q->done_lock, flags);  
    20.   
    21.     /* 应用程序select 时 poll_wait 里休眠,现在有数据了唤醒 */  
    22.     wake_up(&q->done_wq);  
    23. }  

      开始的时候我们将以一个 vb_buffer 挂入 vb_vidq->queued_list ,当启动视频传输之后,它被取出挂入 vb_vidq->vidq->active 队列,然后在内核线程中每一个 tick ,又将它取出填充视频数据之后,再挂入 vb_vidq->done_list ,唤醒正在休眠等待视频数据的应用程序。
    2.10 select
    驱动层:

    1. vivi_poll(struct file *file, struct poll_table_struct *wait)  
    2. {  
    3.     struct vivi_dev *dev = video_drvdata(file);  
    4.     struct vb2_queue *q = &dev->vb_vidq;  
    5.   
    6.     return vb2_poll(q, file, wait);  
    7. }  
    1. unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait)  
    2. {  
    3.     // 挂入休眠队列,是否休眠还要看返回值,大概没有数据就休眠,有数据就不休眠  
    4.     poll_wait(file, &q->done_wq, wait);  
    5.   
    6.     if (!list_empty(&q->done_list))  
    7.         vb = list_first_entry(&q->done_list, struct vb2_buffer,  
    8.                     done_entry);  
    9.     spin_unlock_irqrestore(&q->done_lock, flags);  
    10.   
    11.     if (vb && (vb->state == VB2_BUF_STATE_DONE  
    12.             || vb->state == VB2_BUF_STATE_ERROR)) {  
    13.         return (V4L2_TYPE_IS_OUTPUT(q->type)) ?  
    14.                 res | POLLOUT | POLLWRNORM :  
    15.                 res | POLLIN | POLLRDNORM;  
    16.     }  
    17.     return res;  
    18. }  

      唤醒之后,我们就可以去从视频输出队列中取出buffer,然后根据映射关系,在应用空间取出视频数据了
    2.11 VIDIOC_DQBUF
    应用层:

    1. ret = ioctl(fd, VIDIOC_DQBUF, &buf);  
    2. if (ret < 0) {  
    3.     LOG("VIDIOC_DQBUF failed (%d) ", ret);  
    4.     return ret;  
    5. }  
    1. static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)  
    2. {  
    3.     struct vivi_dev *dev = video_drvdata(file);  
    4.     return vb2_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK);  
    5. }  
    1. int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking)  
    2. {  
    3.     struct vb2_buffer *vb = NULL;  
    4.     int ret;  
    5.     // 等待在 q->done_list 取出第一个可用的 buffer  
    6.     ret = __vb2_get_done_vb(q, &vb, nonblocking);  
    7.   
    8.     ret = call_qop(q, buf_finish, vb);  
    9.   
    10.     /* 写回buffer的信息到用户空间,应用程序找个这个buffer的mmap之后的地址读数据 */  
    11.     __fill_v4l2_buffer(vb, b);  
    12.     /* Remove from videobuf queue */  
    13.     list_del(&vb->queued_entry);  
    14.   
    15.     vb->state = VB2_BUF_STATE_DEQUEUED;  
    16.     return 0;  
    17. }  
    1. static int __vb2_get_done_vb(struct vb2_queue *q, struct vb2_buffer **vb,int nonblocking)  
    2. {  
    3.     unsigned long flags;  
    4.     int ret;  
    5.     /* 
    6.     * Wait for at least one buffer to become available on the done_list. 
    7.     */  
    8.     ret = __vb2_wait_for_done_vb(q, nonblocking);  
    9.   
    10.   
    11.     spin_lock_irqsave(&q->done_lock, flags);  
    12.     *vb = list_first_entry(&q->done_list, struct vb2_buffer, done_entry);  
    13.     list_del(&(*vb)->done_entry);  
    14.     spin_unlock_irqrestore(&q->done_lock, flags);  
    15.     return 0;  
    16. }  
      1. static int buffer_finish(struct vb2_buffer *vb)  
      2. {  
      3.     struct vivi_dev *dev = vb2_get_drv_priv(vb->vb2_queue);  
      4.     dprintk(dev, 1, "%s ", __func__);  
      5.     return 0;  
      6. }
  • 相关阅读:
    webService基本概念、元素及简单编码实现
    云服务器、vps、虚拟主机的区别
    SOAP和WSDL的一些必要知识
    密码学基础
    oracle执行计划
    dubbo学习笔记:快速搭建
    dubbo和zookeeper的关系
    查看wifi密码
    自动保存图表
    自定义颜色
  • 原文地址:https://www.cnblogs.com/sky-heaven/p/7246610.html
Copyright © 2020-2023  润新知