嵌入式Linux驱动笔记(十七)------详解V4L2框架(UVC驱动)

你好！这里是风筝的博客，

欢迎和我一起交流。

---

Video for Linux 2，简称V4l2，是Linux内核中关于视频设备的内核驱动框架，为上层的访问底层的视频设备提供了统一的接口。凡是内核中的子系统都有抽象底层硬件的差异，为上层提供统一的接口和提取出公共代码避免代码冗余等好处。

首先来看看所有的v4l2驱动都必须要有的几个组成部分：
– 用来描述每一个v4l2设备实例状态的结构(struct v4l2_device)。
– 用来初始化和控制子设备的方法(struct v4l2_subdev)。
– 要能创建设备节点(/dev/videoX、/dev/vbiX 和 /dev/radioX)并且能够对该节点所持有的数据进行跟踪(structvideo_device)。
– 为每一个被打开的节点维护一个文件句柄(structv4l2_fh)。
– 视频缓冲区的处理(videobuf或者videobuf2 framework)。

用一个比较粗糙的图来表现他们之间的关系，大致为：
设备实例(v4l2_device)
|__子设备实例(v4l2_subdev)
|__视频设备节点(video_device)
|__文件访问控制(v4l2_fh)
|__视频缓冲的处理(videobuf/videobuf2)

许多驱动需要与子设备通信。这些设备可以完成各种任务，但通常他们负责 音视频复用和编解码。如网络摄像头的子设备通常是传感器和摄像头控制器。
这些一般为 I2C 接口设备，但并不一定都是。为了给驱动提供调用子设备的 统一接口，v4l2_subdev 结构体（v4l2-subdev.h）产生了。
在别的文章看到的图，觉得还不错，贴一下：

可以看出：
每个子设备驱动都必须有一个 v4l2_subdev 结构体（实际的硬件设备都被抽象为v4l2_subdev），代表一个简单的子设备，也可以嵌入到一个更大的结构体中，与更多设备状态 信息保存在一起。
v4l2_device在v4l2框架中充当所有v4l2_subdev的父设备，管理着注册在其下的子设备。
因为子设备千差万别，所以v4l2-device又向上层提供一个标准的接口。所以可以认为v4l2-device就是一个中间层。

在说v4l2之前，先说下uvc吧：
USB video class（又称为USB video device class or UVC）就是USB device class视频产品在不需要安装任何的驱动程序下即插即用，包括摄像头、数字摄影机、模拟视频转换器、电视卡及静态视频相机。

V4L2就是用来管理UVC设备的并且能够提供视频相关的一些API

我们以Linux kernel 4.8.17为例，分析下实现过程：
drivers\media\usb\uvc\uvc_driver.c文件：

struct uvc_driver uvc_driver = {    .driver = {        .name       = "uvcvideo",        .probe      = uvc_probe,//支持的video设备插入就会进入        .disconnect = uvc_disconnect,        .suspend    = uvc_suspend,        .resume     = uvc_resume,        .reset_resume   = uvc_reset_resume,        .id_table   = uvc_ids,        .supports_autosuspend = 1,    },};

当特定的usb设备被插入时，就会触发probe函数：

static int uvc_probe(struct usb_interface *intf,             const struct usb_device_id *id){    struct usb_device *udev = interface_to_usbdev(intf);    struct uvc_device *dev;    int ret;    /*省略部分内容*/    if ((dev = kzalloc(sizeof *dev, GFP_KERNEL)) == NULL)//【1】        return -ENOMEM;    /*省略部分内容*/    dev->udev = usb_get_dev(udev);//【2】    dev->intf = usb_get_intf(intf);    dev->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;    dev->quirks = (uvc_quirks_param == -1)            ? id->driver_info : uvc_quirks_param;    /*省略部分内容*/    /* Parse the Video Class control descriptor. */    if (uvc_parse_control(dev) < 0) {//【3】        uvc_trace(UVC_TRACE_PROBE, "Unable to parse UVC "            "descriptors.\n");        goto error;    }    /*省略部分内容*/    if (v4l2_device_register(&intf->dev, &dev->vdev) < 0)//【4】        goto error;    /* Initialize controls. */    if (uvc_ctrl_init_device(dev) < 0)//【5】        goto error;    /* Scan the device for video chains. */    if (uvc_scan_device(dev) < 0)        goto error;    /* Register video device nodes. */    if (uvc_register_chains(dev) < 0)//【6】        goto error;    /*省略部分内容*/    /* Initialize the interrupt URB. */    if ((ret = uvc_status_init(dev)) < 0) {//【7】uvc状态的处理由中断端点来控制处理    /*省略部分内容*/    return 0;error:    uvc_unregister_video(dev);    return -ENODEV;}

函数太长了，省略了部分内容，但是可以看出，主要的就是做几件事情：
【1】分配一个dev
【2】给dev设置各种参数，如dev->udevudev
【3】调用uvc_parse_control函数分析设备的控制描述符
【4】调用v4l2_device_register函数初始化v4l2_dev
【5】调用uvc_ctrl_init_device函数初始化uvc控制设备
【6】调用uvc_register_chains函数注册所有通道
【7】调用uvc_status_init函数初始化uvc状态

我们来一个个分析下：
【3】：调用uvc_parse_control函数
看下调用关系：

uvc_parse_control(dev)    uvc_parse_standard_control(dev, buffer, buflen)        uvc_parse_streaming(dev, intf)      

跟踪下uvc_parse_streaming函数：

static int uvc_parse_streaming(struct uvc_device *dev,    struct usb_interface *intf){    /*以下大部分内容省略，只显示重要的*/    struct uvc_streaming *streaming = NULL;    struct uvc_format *format;    struct uvc_frame *frame;    streaming = kzalloc(sizeof *streaming, GFP_KERNEL);    size = nformats * sizeof *format + nframes * sizeof *frame         + nintervals * sizeof *interval;    format = kzalloc(size, GFP_KERNEL);//申请format数组存放格式    streaming->format = format;//设置格式    streaming->nformats = nformats;//最多支持nformats种格式    ret = uvc_parse_format(dev, streaming, format,                &interval, buffer, buflen);//分析格式    list_add_tail(&streaming->list, &dev->streams);    return 0;}

这里面申请了streaming和format内存
streaming是uvc_streaming 结构体，视频流，很重要，大部分参数都是存在里面。这函数里申请了之后进行了很多设置，不过现在我省略了写。
format内存存放的是视频的格式，frame存放的是如分辨率
这里面都把他设置到了streaming里面（streaming->format = format;streaming->nformats = nformats;）
最后调用uvc_parse_format函数分析格式：

static int uvc_parse_format(){    fmtdesc = uvc_format_by_guid(&buffer[5]);//通过GUID找到格式format    /*里面还会对frame进行各种分析和设置，     *如设置format->nframes得出最多有多少种分辨率选择     *暂时忽略*/}

里面uvc_format_by_guid函数会从uvc_fmts数组中通过匹配guid找到格式：

static struct uvc_format_desc uvc_fmts[] = {    {        .name       = "YUV 4:2:2 (YUYV)",        .guid       = UVC_GUID_FORMAT_YUY2,        .fcc        = V4L2_PIX_FMT_YUYV,    },    {        .name       = "YUV 4:2:2 (YUYV)",        .guid       = UVC_GUID_FORMAT_YUY2_ISIGHT,        .fcc        = V4L2_PIX_FMT_YUYV,    },    {        .name       = "YUV 4:2:0 (NV12)",        .guid       = UVC_GUID_FORMAT_NV12,        .fcc        = V4L2_PIX_FMT_NV12,    },    {        .name       = "MJPEG",        .guid       = UVC_GUID_FORMAT_MJPEG,        .fcc        = V4L2_PIX_FMT_MJPEG,    },    /*后面省略......*/}

.
这样【3】的工作就完成了，我们来看下【4】的：

int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev){    INIT_LIST_HEAD(&v4l2_dev->subdevs);//用来管理v4l2_device 下的subdevs实例    spin_lock_init(&v4l2_dev->lock);    v4l2_prio_init(&v4l2_dev->prio);    kref_init(&v4l2_dev->ref);    get_device(dev);    v4l2_dev->dev = dev;    if (!v4l2_dev->name[0])        snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s %s",            dev->driver->name, dev_name(dev));    if (!dev_get_drvdata(dev))//dev->driver_data 域 为 NULL        dev_set_drvdata(dev, v4l2_dev);//就将其指向 v4l2_dev    return 0;}

简单，没啥好讲的，就是初始化v4l2_dev->subdevs子设备实例的链表，然后设置名字和设置dev->driver_data

看下【5】调用uvc_ctrl_init_device

int uvc_ctrl_init_device(struct uvc_device *dev){    /*省略了部分内容*/    list_for_each_entry(entity, &dev->entities, list) {        bmControls = entity->extension.bmControls;//控制位图        bControlSize = entity->extension.bControlSize;//控制位域大小        entity->controls = kcalloc(ncontrols, sizeof(*ctrl),                       GFP_KERNEL);//分配ncontrols个uvc控制内存        if (entity->controls == NULL)            return -ENOMEM;        entity->ncontrols = ncontrols;//设置uvc控制个数        /* Initialize all supported controls */        ctrl = entity->controls;//指向uvc控制数组        for (i = 0; i < bControlSize * 8; ++i) {            if (uvc_test_bit(bmControls, i) == 0)//跳过控制位域设置0的                continue;            ctrl->entity = entity;            ctrl->index = i;//设置控制位域索引            uvc_ctrl_init_ctrl(dev, ctrl);//初始化uvc控件            ctrl++;//uvc控制 指向下一个uvc控制数组项        }    }}

uvc_ctrl_init_device主要就是初始化控制参数，里面就会遍历uvc设备实体entities链表，然后设置位图和位域大小
最后还会调用uvc_ctrl_init_ctrl函数设置背光，色温等等

接下来继续看【6】调用uvc_register_chains函数:
调用关系：

uvc_register_chains    uvc_register_terms(dev, chain)        uvc_stream_by_id        uvc_register_video    uvc_mc_register_entities(chain)

uvc_stream_by_id函数会通过函数传入的id和dev->streams链表的header.bTerminalLink匹配，寻找到stream
这不是重点，我们的重点是uvc_register_video函数，找到stream会就要注册：

static int uvc_register_video(struct uvc_device *dev,        struct uvc_streaming *stream){    /*部分内容省略......*/    struct video_device *vdev = &stream->vdev;    ret = uvc_queue_init(&stream->queue, stream->type, !uvc_no_drop_param);//初始化队列    ret = uvc_video_init(stream);//初始化    uvc_debugfs_init_stream(stream);    vdev->v4l2_dev = &dev->vdev;    vdev->fops = &uvc_fops;//v4l2操作函数集    vdev->ioctl_ops = &uvc_ioctl_ops;//设置真正的ioctl操作集    vdev->release = uvc_release;//释放方法    vdev->prio = &stream->chain->prio;    strlcpy(vdev->name, dev->name, sizeof vdev->name);    video_set_drvdata(vdev, stream);//将uvc视频流作为v4l2设备的驱动数据    ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);//注册    return 0;}

这是非常重要的函数，我们来一点一点分析：
看下uvc_queue_init函数，队列初始化，队列这东西，我们视频传输时会调用到，在ioctl里操作：

static struct vb2_ops uvc_queue_qops = {    .queue_setup = uvc_queue_setup,    .buf_prepare = uvc_buffer_prepare,    .buf_queue = uvc_buffer_queue,    .buf_finish = uvc_buffer_finish,    .wait_prepare = vb2_ops_wait_prepare,    .wait_finish = vb2_ops_wait_finish,    .start_streaming = uvc_start_streaming,    .stop_streaming = uvc_stop_streaming,};int uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,            int drop_corrupted){    queue->queue.type = type;    queue->queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;    queue->queue.drv_priv = queue;    queue->queue.buf_struct_size = sizeof(struct uvc_buffer);    queue->queue.ops = &uvc_queue_qops;//stream->queue->queue.ops    queue->queue.mem_ops = &vb2_vmalloc_memops;    queue->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC        | V4L2_BUF_FLAG_TSTAMP_SRC_SOE;    queue->queue.lock = &queue->mutex;    ret = vb2_queue_init(&queue->queue);//初始化queue    mutex_init(&queue->mutex);    spin_lock_init(&queue->irqlock);    INIT_LIST_HEAD(&queue->irqqueue);//初始化stream->queue->irqqueue    queue->flags = drop_corrupted ? UVC_QUEUE_DROP_CORRUPTED : 0;    return 0;}

里面先对队列进行初始化设置，如设置type和ops。
这里queue->queue.ops = &uvc_queue_qops非常重要，之后我们调用vidioc_streamon回调函数时就是调用到这里的uvc_queue_qops结构体里的.start_streaming函数
这函数里对各种队列进行了初始化：

vb2_queue_init(&queue->queue)    q->buf_ops = &v4l2_buf_ops;    vb2_core_queue_init(struct vb2_queue *q)        INIT_LIST_HEAD(&q->queued_list);//stream->queue->queue->queued_list        INIT_LIST_HEAD(&q->done_list);//stream->queue->done_listINIT_LIST_HEAD(&queue->irqqueue);//初始化stream->queue->irqqueue

我们继续看回uvc_register_video函数，里面接着调用了uvc_video_init函数初始化UVC视频设备：

int uvc_video_init(struct uvc_streaming *stream){    /*省略部分内容*/    struct uvc_streaming_control *probe = &stream->ctrl;//获取uvc数据流的uvs数据流控制对象    if (uvc_get_video_ctrl(stream, probe, 1, UVC_GET_DEF) == 0)//先得到定义的控制参数        uvc_set_video_ctrl(stream, probe, 1);//再设置uvc视频控制    ret = uvc_get_video_ctrl(stream, probe, 1, UVC_GET_CUR);//最后在get一次    for (i = stream->nformats; i > 0; --i) {        format = &stream->format[i-1];//获取对应的uvc格式        if (format->index == probe->bFormatIndex)            break;    }    probe->bFormatIndex = format->index;//设置uvc视频流控制的格式索引为uvc格式的索引    probe->bFrameIndex = frame->bFrameIndex;//设置uvc视频流控制的分辨率索引为uvc分辨率的索引    stream->def_format = format;    stream->cur_format = format;//设置uvc格式为uvc数据流的cur_format成员    stream->cur_frame = frame;//设置uvc帧为uvc数据流的cur_frame成员    if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {//视频采集        if (stream->dev->quirks & UVC_QUIRK_BUILTIN_ISIGHT)            stream->decode = uvc_video_decode_isight;        else if (stream->intf->num_altsetting > 1)            stream->decode = uvc_video_decode_isoc;//同步方式        else            stream->decode = uvc_video_decode_bulk;//bluk方式    }     return 0;}

这里面内容就比较多了，先得到，然后设置uvc的控制参数，里面会操作urb发出usb数据。
然后通过probe->bFormatIndex索引找到使用的format格式和通过probe->bFrameIndex找到对应的frame分辨率，然后设置到stream里。
最后选择解码方式，如同步方式或者bluk方式，解码方式会在数据完成时被回调函数complete里调用。

再次回到uvc_register_video函数，没办法，这个函数太重要了：
里面继续：

    vdev->fops = &uvc_fops;//v4l2操作函数集    vdev->ioctl_ops = &uvc_ioctl_ops;//设置真正的ioctl操作集    vdev->release = uvc_release;//释放方法    ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);

里面就是vdev->v4l2_dev = &dev->vdev;这样v4l2_device就与video_device关联起来，也就是我们文章一开始那个图看到的。
然后设置fops操作函数vdev->fops = &uvc_fops，虽然这不是给用户空间使用的open、read、write函数，但是最后vdev->cdev->ops还是最调用到这个uvc_fops的，所以用户空间实际上的pen、read、write函数还是会在这调用。 然后ioctl操作函数最终是会调用到vdev->ioctl_ops = &uvc_ioctl_ops。可以说，V4L2最重要的就是各种形式的ioctl了，这里先不讲，下一节在分析看看。
然后最终就是我们的注册函数了：video_register_device里调用到__video_register_device函数：

int __video_register_device(struct video_device *vdev, int type, int nr,        int warn_if_nr_in_use, struct module *owner){    /*省略部分函数*/    vdev->minor = -1;//-1表明这个video device从未被注册过    switch (type) {//根据type选择设备名称    case VFL_TYPE_GRABBER:        name_base = "video";        break;    case VFL_TYPE_VBI:        name_base = "vbi";        break;    case VFL_TYPE_RADIO:        name_base = "radio";        break;    case VFL_TYPE_SUBDEV:        name_base = "v4l-subdev";        break;    case VFL_TYPE_SDR:        name_base = "swradio";        break;    default:        printk(KERN_ERR "%s called with unknown type: %d\n", __func__, type);        return -EINVAL;    }    switch (type) {//选择得到次设备号偏移值    case VFL_TYPE_GRABBER://用于视频输入/输出设备的 videoX        minor_offset = 0;        minor_cnt = 64;        break;    case VFL_TYPE_RADIO://用于广播调谐器的 radioX        minor_offset = 64;        minor_cnt = 64;        break;    case VFL_TYPE_VBI://用于垂直消隐数据的 vbiX (例如，隐藏式字幕，图文电视)        minor_offset = 224;        minor_cnt = 32;        break;    default:        minor_offset = 128;        minor_cnt = 64;        break;    }    nr = devnode_find(vdev, 0, minor_cnt);//获取一个没有被使用的设备节点序号    for (i = 0; i < VIDEO_NUM_DEVICES; i++)        if (video_device[i] == NULL)//从video_device[]数组中选择一个空缺项，这个空缺项的索引值放到i中            break;    vdev->minor = i + minor_offset;//设备的次设备号    video_device[vdev->minor] = vdev;//注意：将设置好的video_device放入到video_device[]    vdev->cdev->ops = &v4l2_fops;//操作用户空间操作函数集    ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);//添加字符设备到系统    ret = device_register(&vdev->dev);//设备注册    set_bit(V4L2_FL_REGISTERED, &vdev->flags);//将flags第0为设置为1，表示这个video_device是注册过的了    return 0;}

我们梳理一下里面做的事情：
1.确定设备名称，也就是我们在/dev/下生成的video啊，radio之类的
2.得到次设备的偏移值
3.找到一个空的video_device数组，把vdev存进去
4.设置vdev->cdev，这里就设置了vdev->cdev->ops = &v4l2_fops;里面就是真正的用户空间操作集合
5.注册video_device设备
6.就是标志此video_device以注册

最后【6】调用uvc_register_chains函数里还会调用一个uvc_mc_register_entities函数，里面继续调用uvc_mc_init_entity函数，这就是v4l2_device_register_subdev函数，进行注册v4l2_subdev，同时初始化然后连接到v4l2_dev->subdevs管理。

好了，【6】调用uvc_register_chains函数:就分析完了，我们最后剩一个了：

【7】调用uvc_status_init函数

int uvc_status_init(struct uvc_device *dev){    /*省略部分函数*/    struct usb_host_endpoint *ep = dev->int_ep;//获取usb_host_endpoint    uvc_input_init(dev);//初始化uvc输入设备,里面注册input设备    dev->status = kzalloc(UVC_MAX_STATUS_SIZE, GFP_KERNEL);//分配urb设备状态内存    dev->int_urb = usb_alloc_urb(0, GFP_KERNEL);//分配urb    pipe = usb_rcvintpipe(dev->udev, ep->desc.bEndpointAddress);//中断输入端点    usb_fill_int_urb(dev->int_urb, dev->udev, pipe,        dev->status, UVC_MAX_STATUS_SIZE, uvc_status_complete,        dev, interval);//填充中断urb    return 0;}

里面就是关于urb的一些东西了，看看就好。

最后，我们用户空间怎么才操作的？
看看__video_register_device函数里的：vdev->cdev->ops = &v4l2_fops;

static const struct file_operations v4l2_fops = {    .owner = THIS_MODULE,    .read = v4l2_read,    .write = v4l2_write,    .open = v4l2_open,    .get_unmapped_area = v4l2_get_unmapped_area,    .mmap = v4l2_mmap,    .unlocked_ioctl = v4l2_ioctl,#ifdef CONFIG_COMPAT    .compat_ioctl = v4l2_compat_ioctl32,#endif    .release = v4l2_release,    .poll = v4l2_poll,    .llseek = no_llseek,};

static int v4l2_open(struct inode *inode, struct file *filp){    /*省略部分函数*/    struct video_device *vdev;    vdev = video_devdata(filp);//根据次设备号从video_devices[]数组中得到video_device    if (vdev->fops->open) {        if (video_is_registered(vdev))            ret = vdev->fops->open(filp);//实际就是vdev->fops        else            ret = -ENODEV;    }}

记得我们之前把video_device放入到video_device[]吗？就是这里取了出来
然后调用vdev->fops->open(filp)
vdev->fops就是我们在uvc_register_video函数里设置的：
vdev->fops = &uvc_fops

const struct v4l2_file_operations uvc_fops = {//实际的用户操作    .owner      = THIS_MODULE,    .open       = uvc_v4l2_open,    .release    = uvc_v4l2_release,    .unlocked_ioctl = video_ioctl2,#ifdef CONFIG_COMPAT    .compat_ioctl32 = uvc_v4l2_compat_ioctl32,#endif    .read       = uvc_v4l2_read,    .mmap       = uvc_v4l2_mmap,    .poll       = uvc_v4l2_poll,#ifndef CONFIG_MMU    .get_unmapped_area = uvc_v4l2_get_unmapped_area,#endif};

至于这个uvc_fops 里的回调函数，特别是ioctl，这是V4L2的重头，就在下一章试着分析吧，我对这个也是比较模糊……

下一章：嵌入式Linux驱动笔记(十八)——浅析V4L2框架之ioctl