赞
踩
USB摄像头驱动–UVC驱动的深入理解与编写
uvc_driver代码分析
嵌入式Linux驱动笔记(十七)------详解V4L2框架(UVC驱动)
对于linux内核4.13.0中,UVC驱动在drivers/media/usb/uvc/文件夹里,下面对uvc_driver.c进行分析。
该结构体相当于告诉内核我这是一个USB设备,需要进行USB设备的相关函数调用。(UVC:usb video class)这里进行usb的设置。
kernel/msm-4.14/drivers/media/usb/uvc/uvcvideo.h
struct uvc_driver {
struct usb_driver driver;
};
kernel/msm-4.14/include/linux/usb.h ----------- struct usb_driver标识usbcore的USB接口驱动程序
struct usb_driver { //驱动程序名称在USB驱动程序中应是唯一的,通常应与模块名称相同。 >---const char *name; //调用此函数以查看驱动程序是否愿意管理设备上的特定接口。 //如果是,probe返回零,并使用usb_set_intfdata()将特定于驱动程序的数据与接口关联。 //它还可以使用usb_set_interface()来指定适当的ALTSETING。 //如果不愿意管理接口,则返回-ENODEV,如果发生真正的IO错误,则返回适当的负errno值。 >---int (*probe) (struct usb_interface *intf, >--->--- const struct usb_device_id *id); //当接口不再可访问时调用,通常是因为其设备已(或正在)断开连接或驱动程序模块正在卸载。 >---void (*disconnect) (struct usb_interface *intf); >---int (*unlocked_ioctl) (struct usb_interface *intf, unsigned int code, >--->--->---void *buf); //当设备将由系统从系统睡眠或运行时挂起上下文挂起时调用。 //返回值将在系统睡眠上下文中被忽略,因此如果在这种情况下挂起失败,请不要尝试继续使用设备。 //相反,让恢复或重置恢复例程从故障中恢复。 >---int (*suspend) (struct usb_interface *intf, pm_message_t message); //当系统恢复设备时调用。 >---int (*resume) (struct usb_interface *intf); //当挂起的设备被重置而不是恢复时调用。 >---int (*reset_resume)(struct usb_interface *intf); >---int (*pre_reset)(struct usb_interface *intf); >---int (*post_reset)(struct usb_interface *intf); //USB驱动程序使用ID表支持热插拔。 //将其与MODULE_DEVICE_TABLE(usb,…)一起导出。必须设置此值,否则将永远不会调用驱动程序的探测函数。 >---const struct usb_device_id *id_table; >---struct usb_dynids dynids; >---struct usbdrv_wrap drvwrap; //驱动程序模型结构的包装器 >---unsigned int no_dynamic_id:1; >---unsigned int supports_autosuspend:1; >---unsigned int disable_hub_initiated_lpm:1; >---unsigned int soft_unbind:1; }; 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, // .id_table 表示该USB驱动支持哪些设备 .supports_autosuspend = 1, }, };
设置相当于将其中的函数定一下来,一开始可以写作空函数,以便判定框架是否正确。在probe函数中进行这个结构体的具体内容进行设置,包括分配video_device结构体,设置结构体,注册video_device结构体,fops结构体中需要进行ioctrl的具体操作进行设置。
uvc_probe
kzalloc //分配video_device
uvc_register_chains
uvc_register_terms
uvc_register_video
vdev->v4l2_dev = &dev->vdev; //设置video_device
vdev->fops = &uvc_fops;
vdev->ioctl_ops = &uvc_ioctl_ops;
vdev->release = uvc_release;
video_register_device //注册video_device
uvc_probe代码分析,当特定的usb设备被插入时,就会触发probe函数:
函数太长了,省略了部分内容,但是可以看出,主要的就是做几件事情:
【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状态
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; //完成产品相关信息的打印工作 /* #define uvc_trace(flag, msg...) \ do { \ if (uvc_trace_param & flag) \ printk(KERN_DEBUG "uvcvideo: " msg); \ } while (0) uvc_trace_param这个全局变量是通过用户空间来传值实现的 */ if (id->idVendor && id->idProduct) uvc_trace(UVC_TRACE_PROBE, "Probing known UVC device %s " "(%04x:%04x)\n", udev->devpath, id->idVendor, id->idProduct); else uvc_trace(UVC_TRACE_PROBE, "Probing generic UVC device %s\n", udev->devpath); /* Allocate memory for the device and initialize it. */ if ((dev = kzalloc(sizeof *dev, GFP_KERNEL)) == NULL) //【1】分配一个dev return -ENOMEM; /*初始化链表*/ INIT_LIST_HEAD(&dev->entities);//初始化entities(实体)链表 Terminal或Unit INIT_LIST_HEAD(&dev->chains);//初始化chains(链)链表 INIT_LIST_HEAD(&dev->streams);//初始化streams(视频流)链表 /*设置原子变量的值,以便后续做原子操作*/ atomic_set(&dev->nstreams, 0); atomic_set(&dev->users, 0); atomic_set(&dev->nmappings, 0); /* //以下两个函数在写法上使用container_of()只需要简单的操作就能返回原结构体 usb_get_dev():通过struct usb_device --> struct device --> struct kobject 增加引用计数 usb_get_intf():通过struct usb_interface --> struct device --> struct kobject 增加引用计数 同时将struct usb_device及其struct usb_interface赋值给uvc结构体中的struct usb_device 和struct usb_interface 结构体成员 */ dev->udev = usb_get_dev(udev); //【2】给dev设置各种参数,如dev->udevudev dev->intf = usb_get_intf(intf); /*通过接口找到接口描述符,这样得到接口数量*/ dev->intfnum = intf->cur_altsetting->desc.bInterfaceNumber; //quirks: 怪癖的意思,也就是说它某种特性与通常的USB设备不相同 /*uvc_quirks_param 这个全局变量来自用户空间的输入*/ dev->quirks = (uvc_quirks_param == -1) ? id->driver_info : uvc_quirks_param; /* 此段代码的主要功能是将strcut usb_device 中的一些产品的 信息(如产品号、版本号等)写入到struct uvc_device中, 主要涉及到 struct uvc_device -> char name[32] */ if (udev->product != NULL) strlcpy(dev->name, udev->product, sizeof dev->name); else snprintf(dev->name, sizeof dev->name, "UVC Camera (%04x:%04x)", le16_to_cpu(udev->descriptor.idVendor), le16_to_cpu(udev->descriptor.idProduct)); /* Parse the Video Class control descriptor. */ /*uvc解析usb视频类控制描述符*/ /*整个函数都是围绕着struct usb_host_interface 中的extra成员展开的*/ if (uvc_parse_control(dev) < 0) { //【3】调用uvc_parse_control函数分析设备的控制描述符 uvc_trace(UVC_TRACE_PROBE, "Unable to parse UVC " "descriptors.\n"); goto error; } uvc_printk(KERN_INFO, "Found UVC %u.%02x device %s (%04x:%04x)\n", dev->uvc_version >> 8, dev->uvc_version & 0xff, udev->product ? udev->product : "<unnamed>", le16_to_cpu(udev->descriptor.idVendor), le16_to_cpu(udev->descriptor.idProduct)); if (dev->quirks != id->driver_info) { uvc_printk(KERN_INFO, "Forcing device quirks to 0x%x by module " "parameter for testing purpose.\n", dev->quirks); uvc_printk(KERN_INFO, "Please report required quirks to the " "linux-uvc-devel mailing list.\n"); } /* Register the media and V4L2 devices. */ /* 以下的操作均为对 struct uvc_device --> struct media_device 的 成员进行赋值操作,赋值的成员如下: struct device *dev char model[32] char serial[40] char bus_info[32] u32 hw_revision u32 driver_version 然后使用了media_device_register()函数进行media设备的注册工作 */ #ifdef CONFIG_MEDIA_CONTROLLER dev->mdev.dev = &intf->dev; strlcpy(dev->mdev.model, dev->name, sizeof(dev->mdev.model)); if (udev->serial) strlcpy(dev->mdev.serial, udev->serial, sizeof(dev->mdev.serial)); strcpy(dev->mdev.bus_info, udev->devpath); dev->mdev.hw_revision = le16_to_cpu(udev->descriptor.bcdDevice); dev->mdev.driver_version = DRIVER_VERSION_NUMBER; /* 1.在下面的函数中发现了struct media_file_operations 其中有open、release、ioctl函数。 但是上述的函数都是空函数,没有任何意义 */ if (media_device_register(&dev->mdev) < 0) goto error; /* struct uvc_device --> strcut v412_device vdev -->struct media_device */ dev->vdev.mdev = &dev->mdev; #endif /* 【4】调用v4l2_device_register函数初始化v4l2_dev 【5】调用uvc_ctrl_init_device函数初始化uvc控制设备 【6】调用uvc_register_chains函数注册所有通道 【7】调用uvc_status_init函数初始化uvc状态 */ if (v4l2_device_register(&intf->dev, &dev->vdev) < 0) goto error; /* Initialize controls. */ if (uvc_ctrl_init_device(dev) < 0) goto error; /* Scan the device for video chains. */ if (uvc_scan_device(dev) < 0) goto error; /* Register video device nodes. */ /* 下面这个函数存在着以下调用关系 uvc_register_chains() --> uvc_register_terms() --> uvc_register_video() 函数初始化关系图如下:见笔记章节 其中uvc_register_video()函数非常重要! 因为这个函数中存在着 v4l2操作函数集(uvc_fops) 和 真正的ioctl操作 集(3.19以后的内核才存在vdev->ioctl_ops = &uvc_ioctl_ops;) vdev->fops = &uvc_fops; vdev->release = uvc_release; */ if (uvc_register_chains(dev) < 0) goto error; /* Save our data pointer in the interface data. */ usb_set_intfdata(intf, dev); /* Initialize the interrupt URB. */ /* uvc_status_init()这个函数主要有三个作用: 1.动态申请一个urb(interrupt urb) 2.给struct uvc_device --> _u8 *status 申请一个内存空间(作为urb的缓冲区) 3.初始化中断urb */ if ((ret = uvc_status_init(dev)) < 0) { uvc_printk(KERN_INFO, "Unable to initialize the status " "endpoint (%d), status interrupt will not be " "supported.\n", ret); } uvc_trace(UVC_TRACE_PROBE, "UVC device initialized.\n"); //打开usb设备的自动挂起功能,以便实现低功耗的要求 usb_enable_autosuspend(udev); return 0; error: uvc_unregister_video(dev); return -ENODEV; }
我们来一个个分析下:
【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函数设置背光,色温等等
————————————————————————————————————————————————
int uvc_ctrl_init_device(struct uvc_device *dev) { struct uvc_entity *entity; unsigned int i; /* Walk the entities list and instantiate controls */ list_for_each_entry(entity, &dev->entities, list) { struct uvc_control *ctrl; unsigned int bControlSize = 0;//控制位域大小 unsigned int ncontrols = 0;//控制组件个数 __u8 *bmControls = NULL;//控制位图 /*判断每次遍历到的实体的类型,并对类型相应的参数进行赋值*/ if (UVC_ENTITY_TYPE(entity) == UVC_VC_EXTENSION_UNIT) { bmControls = entity->extension.bmControls; bControlSize = entity->extension.bControlSize; } else if (UVC_ENTITY_TYPE(entity) == UVC_VC_PROCESSING_UNIT) { bmControls = entity->processing.bmControls; bControlSize = entity->processing.bControlSize; } else if (UVC_ENTITY_TYPE(entity) == UVC_ITT_CAMERA) { bmControls = entity->camera.bmControls; bControlSize = entity->camera.bControlSize; } /* Remove bogus/blacklisted controls 移除假的/黑名单控制组件*/ uvc_ctrl_prune_entity(dev, entity); /* Count supported controls and allocate the controls array */ for (i = 0; i < bControlSize; ++i) /* hweight8()函数的功能:能快速得出一个字段内有多少个bit是1 bmControls 中的每一位表示一种控制组件,所以我们只需要通过使用 hweight8()函数就可以得出我们控制组件的个数 又因为 bmControls 的数据类型为 __u8 所以我们将数据分为三组存储, 这就是这里需要用到for循环的原因(bmControls 这个数据实际存在24位) */ ncontrols += hweight8(bmControls[i]); if (ncontrols == 0) continue; /*给每一个实体中的所有要使用到的控制组件都申请一段内存*/ entity->controls = kzalloc(ncontrols * sizeof(*ctrl), GFP_KERNEL); if (entity->controls == NULL) return -ENOMEM; entity->ncontrols = ncontrols; /* Initialize all supported controls */ ctrl = entity->controls; for (i = 0; i < bControlSize * 8; ++i) { if (uvc_test_bit(bmControls, i) == 0) continue; ctrl->entity = entity; ctrl->index = i; uvc_ctrl_init_ctrl(dev, ctrl);//初始化uvc控制组件 ctrl++; } } return 0; }
static void uvc_ctrl_init_ctrl(struct uvc_device *dev, struct uvc_control *ctrl) { const struct uvc_control_info *info = uvc_ctrls; const struct uvc_control_info *iend = info + ARRAY_SIZE(uvc_ctrls); const struct uvc_control_mapping *mapping = uvc_ctrl_mappings; const struct uvc_control_mapping *mend = mapping + ARRAY_SIZE(uvc_ctrl_mappings); /* XU controls initialization requires querying the device for control * information. As some buggy UVC devices will crash when queried * repeatedly in a tight loop, delay XU controls initialization until * first use. */ if (UVC_ENTITY_TYPE(ctrl->entity) == UVC_VC_EXTENSION_UNIT) return; /* uvc_entity_match_guid()函数的主要作用: 1.首先通过传入的uvc_control中的实体成员判断其实体的类型,主要是筛选以下 四种类型(UVC_ITT_CAMERA、UCV_ITT_MEDIA_TRANSPORT_INPUT、UVC_VC_PROCESSING_UNIT、 UVC_VC_EXTENSION_UNIT) 2.然后将控制信息(uvc_control_info)中的实体标识与默认的类型标识做对比,如果一致 则不需要添加新的控制信息,否则需要使用uvc_ctrl_add_info()去添加 */ for (; info < iend; ++info) { if (uvc_entity_match_guid(ctrl->entity, info->entity) && ctrl->index == info->index) { uvc_ctrl_add_info(dev, ctrl, info); break; } } if (!ctrl->initialized) return; for (; mapping < mend; ++mapping) { if (uvc_entity_match_guid(ctrl->entity, mapping->entity) && ctrl->info.selector == mapping->selector) __uvc_ctrl_add_mapping(dev, ctrl, mapping); } }
/* struct uvc_entity 这个结构体描述的主要为uvc协议中的: IT、OT、PU、SU、EU、XU 这些实体 */ static int uvc_scan_device(struct uvc_device *dev) { struct uvc_video_chain *chain;//uvc视频链 struct uvc_entity *term;//uvc实体 /* 遍历整个实体链表 循环遍历每一个term中的list子项, &dev->entities为链表头 */ list_for_each_entry(term, &dev->entities, list) { /* 获取实体链表中的输出Terminal实体 通过struct uvc_entity --> __u16 type 来判断Terminal的类型 #define UVC_ENTITY_IS_TERM(entity) (((entity)->type & 0xff00) != 0) #define UVC_ENTITY_IS_OTERM(entity) \ (UVC_ENTITY_IS_TERM(entity) && \ ((entity)->type & 0x8000) == UVC_TERM_OUTPUT) 这里主要完成了两个判断: (其中的0x8000为判断Terminal类型的掩码,0xff00位判断实体类型的掩码) 1.判断这个实体是否为Terminal 2.判断这个实体是否为output Terminal */ if (!UVC_ENTITY_IS_OTERM(term)) continue; /* If the terminal is already included in a chain, skip it. * This can happen for chains that have multiple output * terminals, where all output terminals beside the first one * will be inserted in the chain in forward scans. */ if (term->chain.next || term->chain.prev) continue; chain = kzalloc(sizeof(*chain), GFP_KERNEL); if (chain == NULL) return -ENOMEM; /*初始化uvc视频链entities(实体)链表*/ INIT_LIST_HEAD(&chain->entities); mutex_init(&chain->ctrl_mutex); /*捆绑uvc视频链和uvc设备*/ chain->dev = dev; /* (自己的观点) uvc_scan_chain()这个函数主要作用扫描到的每个实体经过 类型判断及其相关信息打印后,将实体添加到uvc视频链 */ if (uvc_scan_chain(chain, term) < 0) { kfree(chain); continue; } uvc_trace(UVC_TRACE_PROBE, "Found a valid video chain (%s).\n", uvc_print_chain(chain)); list_add_tail(&chain->list, &dev->chains); } if (list_empty(&dev->chains)) { uvc_printk(KERN_INFO, "No valid video chain found.\n"); return -1; } return 0; }
接下来继续看【6】调用uvc_register_chains函数:
调用关系
uvc_register_chains
uvc_register_terms(dev, chain)
uvc_stream_by_id
uvc_register_video
uvc_mc_register_entities(chain)
static int uvc_register_terms(struct uvc_device *dev, struct uvc_video_chain *chain) { struct uvc_streaming *stream; struct uvc_entity *term; int ret; list_for_each_entry(term, &chain->entities, chain) { /*如果判断此实体的类型不是streaming的话则重新遍历*/ if (UVC_ENTITY_TYPE(term) != UVC_TT_STREAMING) continue; /*找到每个实体相对应的视频流(也就是说找到与之对应的 struct uvc_streaming 这个结构体)*/ stream = uvc_stream_by_id(dev, term->id); if (stream == NULL) { uvc_printk(KERN_INFO, "No streaming interface found " "for terminal %u.", term->id); continue; } /*将uvc视频链和uvc流中的uvc视频链进行绑定*/ stream->chain = chain; /*对其中的uvc视频流做初始化工作,并初始化视频设备且注册*/ ret = uvc_register_video(dev, stream); if (ret < 0) return ret; /*将uvc实体中的struct video_device和uvc流中的struct video_device进行绑定*/ term->vdev = stream->vdev; } return 0; }
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_list
INIT_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; struct uvc_format *format = NULL; struct uvc_frame *frame = NULL; unsigned int i; int ret; /*首先检查UVC视频流中是否有格式信息,如果没有则返回错误*/ if (stream->nformats == 0) { uvc_printk(KERN_INFO, "No supported video formats found.\n"); return -EINVAL; } atomic_set(&stream->active, 0); /* Initialize the video buffers queue. */ /*初始化队列,并且通过队列来管理视频缓冲区*/ uvc_queue_init(&stream->queue, stream->type, !uvc_no_drop_param); /* Alternate setting 0 should be the default, yet the XBox Live Vision * Cam (and possibly other devices) crash or otherwise misbehave if * they don't receive a SET_INTERFACE request before any other video * control request. */ /*这个函数功能在自己看来作用为:改变指定usb设备的接口设置*/ usb_set_interface(stream->dev->udev, stream->intfnum, 0); /* Set the streaming probe control with default streaming parameters * retrieved from the device. Webcams that don't suport GET_DEF * requests on the probe control will just keep their current streaming * parameters. */ /* uvc_get_video_ctrl()获得uvc流的默认参数设置,如果参数一切正常将返回0, 否则返回负值 uvc_set_video_ctrl()设置uvc视频控制 */ if (uvc_get_video_ctrl(stream, probe, 1, UVC_GET_DEF) == 0) uvc_set_video_ctrl(stream, probe, 1); /* Initialize the streaming parameters with the probe control current * value. This makes sure SET_CUR requests on the streaming commit * control will always use values retrieved from a successful GET_CUR * request on the probe control, as required by the UVC specification. */ /*获取当前的控制值,确认上面的设置是否正确*/ ret = uvc_get_video_ctrl(stream, probe, 1, UVC_GET_CUR); if (ret < 0) return ret; /* Check if the default format descriptor exists. Use the first * available format otherwise. */ for (i = stream->nformats; i > 0; --i) { format = &stream->format[i-1]; if (format->index == probe->bFormatIndex) break; } /*检查frame的选择数量,如果为0则返回错误值*/ if (format->nframes == 0) { uvc_printk(KERN_INFO, "No frame descriptor found for the " "default format.\n"); return -EINVAL; } /* Zero bFrameIndex might be correct. Stream-based formats (including * MPEG-2 TS and DV) do not support frames but have a dummy frame * descriptor with bFrameIndex set to zero. If the default frame * descriptor is not found, use the first available frame. */ for (i = format->nframes; i > 0; --i) { frame = &format->frame[i-1]; if (frame->bFrameIndex == probe->bFrameIndex) break; } //设置uvc视频流控制的格式索引为uvc格式的索引 probe->bFormatIndex = format->index; //设置uvc视频流控制的帧索引为uvc帧索引 probe->bFrameIndex = frame->bFrameIndex; /*设置UVC视频流的当前的UVC视频格式及其UVC视频帧*/ stream->cur_format = format; stream->cur_frame = frame; . . 省 略 . . return 0; }
————————————————————————————————————
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函数:就分析完了,我们最后剩一个了:
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
static int __init (void) { int ret; uvc_debugfs_init(); ret = usb_register(&uvc_driver.driver); if (ret < 0) { uvc_debugfs_cleanup(); return ret; } return 0; } /* use a define to avoid include chaining to get THIS_MODULE & friends */ #define usb_register(driver) \ >---usb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
register a USB interface driver
向USB核心注册USB接口驱动程序。每当添加新驱动程序时,将重新扫描未连接接口的列表,允许新驱动程序连接到任何已识别的接口.
返回:失败时为负错误代码,成功时为0。
注意:如果您希望驱动程序使用USB主号码,则必须调用USB_register_dev()以启用该功能。这个函数不再处理这个问题。
int usb_register_driver(struct usb_driver *new_driver, struct module *owner, const char *mod_name) { int retval = 0; if (usb_disabled()) return -ENODEV; new_driver->drvwrap.for_devices = 0; new_driver->drvwrap.driver.name = new_driver->name; new_driver->drvwrap.driver.bus = &usb_bus_type; new_driver->drvwrap.driver.probe = usb_probe_interface; new_driver->drvwrap.driver.remove = usb_unbind_interface; new_driver->drvwrap.driver.owner = owner; new_driver->drvwrap.driver.mod_name = mod_name; new_driver->drvwrap.driver.dev_groups = new_driver->dev_groups; spin_lock_init(&new_driver->dynids.lock); INIT_LIST_HEAD(&new_driver->dynids.list); retval = driver_register(&new_driver->drvwrap.driver); if (retval) goto out; retval = usb_create_newid_files(new_driver); if (retval) goto out_newid; pr_info("%s: registered new interface driver %s\n", usbcore_name, new_driver->name); out: return retval; out_newid: driver_unregister(&new_driver->drvwrap.driver); pr_err("%s: error %d registering interface driver %s\n", usbcore_name, retval, new_driver->name); goto out; } EXPORT_SYMBOL_GPL(usb_register_driver);
在probe()函数中,进行video的相关设置,其实就是给video外面套上一个usb的壳子,具体的核心还是fops以及ioctl_ops。
static const struct v4l2_file_operations myuvc_fops = { .owner = THIS_MODULE, .open = myuvc_open, .release = myuvc_close, .mmap = myuvc_mmap, .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */ .poll = myuvc_poll, }; myuvc_vdev->fops = &myuvc_fops;/*文件操作结构体,*/ myuvc_vdev->ioctl_ops = &myuvc_ioctl_ops;/*ioctl函数集*/ static const struct v4l2_ioctl_ops myuvc_ioctl_ops = { // 表示它是一个摄像头设备 /*在内核中函数名字可能改变,但是成员名字不会变*/ .vidioc_querycap = myuvc_vidioc_querycap, /* 用于列举、获得、测试、设置摄像头的数据的格式 */ .vidioc_enum_fmt_vid_cap = myuvc_vidioc_enum_fmt_vid_cap, .vidioc_g_fmt_vid_cap = myuvc_vidioc_g_fmt_vid_cap, .vidioc_try_fmt_vid_cap = myuvc_vidioc_try_fmt_vid_cap, .vidioc_s_fmt_vid_cap = myuvc_vidioc_s_fmt_vid_cap, /* 缓冲区操作: 申请/查询/放入队列/取出队列 */ .vidioc_reqbufs = myuvc_vidioc_reqbufs, .vidioc_querybuf = myuvc_vidioc_querybuf, .vidioc_qbuf = myuvc_vidioc_qbuf, .vidioc_dqbuf = myuvc_vidioc_dqbuf, /*查询/获得/设置属性*/ .vidioc_queryctrl = myuvc_ioctl_queryctrl, .vidioc_g_ctrl = myuvc_ioctl_g_ctrl, .vidioc_s_ctrl = myuvc_ioctl_s_ctrl, // 启动/停止 .vidioc_streamon = myuvc_vidioc_streamon, .vidioc_streamoff = myuvc_vidioc_streamoff, };
最重要的就是ioctl2,它使用video_usercopy()获得用户空间传进来的参数,调用__video_do_ioctl()在v4l2_ioctls[]数组里找到对应的uvc_ioctl_ops。
v4l2_ioctls[]数组定义是在内核中v4l2_ioctl.c中定义:
static struct v4l2_ioctl_info v4l2_ioctls[]
/** * struct usb_device - kernel's representation of a USB device * @devnum: device number; address on a USB bus * @devpath: device ID string for use in messages (e.g., /port/...) * @route: tree topology hex string for use with xHCI * @state: device state: configured, not attached, etc. * @speed: device speed: high/full/low (or error) * @rx_lanes: number of rx lanes in use, USB 3.2 adds dual-lane support * @tx_lanes: number of tx lanes in use, USB 3.2 adds dual-lane support * @ssp_rate: SuperSpeed Plus phy signaling rate and lane count * @tt: Transaction Translator info; used with low/full speed dev, highspeed hub * @ttport: device port on that tt hub * @toggle: one bit for each endpoint, with ([0] = IN, [1] = OUT) endpoints * @parent: our hub, unless we're the root * @bus: bus we're part of * @ep0: endpoint 0 data (default control pipe) * @dev: generic device interface * @descriptor: USB device descriptor * @bos: USB device BOS descriptor set * @config: all of the device's configs * @actconfig: the active configuration * @ep_in: array of IN endpoints * @ep_out: array of OUT endpoints * @rawdescriptors: raw descriptors for each config * @bus_mA: Current available from the bus * @portnum: parent port number (origin 1) * @level: number of USB hub ancestors * @devaddr: device address, XHCI: assigned by HW, others: same as devnum * @can_submit: URBs may be submitted * @persist_enabled: USB_PERSIST enabled for this device * @have_langid: whether string_langid is valid * @authorized: policy has said we can use it; * (user space) policy determines if we authorize this device to be * used or not. By default, wired USB devices are authorized. * WUSB devices are not, until we authorize them from user space. * FIXME -- complete doc * @authenticated: Crypto authentication passed * @wusb: device is Wireless USB * @lpm_capable: device supports LPM * @usb2_hw_lpm_capable: device can perform USB2 hardware LPM * @usb2_hw_lpm_besl_capable: device can perform USB2 hardware BESL LPM * @usb2_hw_lpm_enabled: USB2 hardware LPM is enabled * @usb2_hw_lpm_allowed: Userspace allows USB 2.0 LPM to be enabled * @usb3_lpm_u1_enabled: USB3 hardware U1 LPM enabled * @usb3_lpm_u2_enabled: USB3 hardware U2 LPM enabled * @string_langid: language ID for strings * @product: iProduct string, if present (static) * @manufacturer: iManufacturer string, if present (static) * @serial: iSerialNumber string, if present (static) * @filelist: usbfs files that are open to this device * @maxchild: number of ports if hub * @quirks: quirks of the whole device * @urbnum: number of URBs submitted for the whole device * @active_duration: total time device is not suspended * @connect_time: time device was first connected * @do_remote_wakeup: remote wakeup should be enabled * @reset_resume: needs reset instead of resume * @port_is_suspended: the upstream port is suspended (L2 or U3) * @wusb_dev: if this is a Wireless USB device, link to the WUSB * specific data for the device. * @slot_id: Slot ID assigned by xHCI * @removable: Device can be physically removed from this port * @l1_params: best effor service latency for USB2 L1 LPM state, and L1 timeout. * @u1_params: exit latencies for USB3 U1 LPM state, and hub-initiated timeout. * @u2_params: exit latencies for USB3 U2 LPM state, and hub-initiated timeout. * @lpm_disable_count: Ref count used by usb_disable_lpm() and usb_enable_lpm() * to keep track of the number of functions that require USB 3.0 Link Power * Management to be disabled for this usb_device. This count should only * be manipulated by those functions, with the bandwidth_mutex is held. * @hub_delay: cached value consisting of: * parent->hub_delay + wHubDelay + tTPTransmissionDelay (40ns) * Will be used as wValue for SetIsochDelay requests. * @use_generic_driver: ask driver core to reprobe using the generic driver. * * Notes: * Usbcore drivers should not set usbdev->state directly. Instead use * usb_set_device_state(). */ struct usb_device { int devnum; char devpath[16]; u32 route; enum usb_device_state state; enum usb_device_speed speed; unsigned int rx_lanes; unsigned int tx_lanes; enum usb_ssp_rate ssp_rate; struct usb_tt *tt; int ttport; unsigned int toggle[2]; struct usb_device *parent; struct usb_bus *bus; struct usb_host_endpoint ep0; struct device dev; struct usb_device_descriptor descriptor; struct usb_host_bos *bos; struct usb_host_config *config; struct usb_host_config *actconfig; struct usb_host_endpoint *ep_in[16]; struct usb_host_endpoint *ep_out[16]; char **rawdescriptors; unsigned short bus_mA; u8 portnum; u8 level; u8 devaddr; unsigned can_submit:1; unsigned persist_enabled:1; unsigned have_langid:1; unsigned authorized:1; unsigned authenticated:1; unsigned wusb:1; unsigned lpm_capable:1; unsigned usb2_hw_lpm_capable:1; unsigned usb2_hw_lpm_besl_capable:1; unsigned usb2_hw_lpm_enabled:1; unsigned usb2_hw_lpm_allowed:1; unsigned usb3_lpm_u1_enabled:1; unsigned usb3_lpm_u2_enabled:1; int string_langid; /* static strings from the device */ char *product; char *manufacturer; char *serial; struct list_head filelist; int maxchild; u32 quirks; atomic_t urbnum; unsigned long active_duration; #ifdef CONFIG_PM unsigned long connect_time; unsigned do_remote_wakeup:1; unsigned reset_resume:1; unsigned port_is_suspended:1; #endif struct wusb_dev *wusb_dev; int slot_id; struct usb2_lpm_parameters l1_params; struct usb3_lpm_parameters u1_params; struct usb3_lpm_parameters u2_params; unsigned lpm_disable_count; u16 hub_delay; unsigned use_generic_driver:1; };
struct uvc_device { struct usb_device *udev; //usb设备指针 struct usb_interface *intf; //usb接口指针 unsigned long warnings; __u32 quirks; int intfnum; //接口数 char name[32]; //设备名 enum uvc_device_state state; //uvc设备状态 atomic_t users; atomic_t nmappings; /* Video control interface */ __u16 uvc_version; //UVC协议版本 __u32 clock_frequency; //时钟频率 struct list_head entities; //uvc实体链表头(挂着uvc设备的Terminal和Unit) struct list_head chains; //uvc视频链链表头 /* Video Streaming interfaces */ struct list_head streams; //uvc视频流链表头 atomic_t nstreams;//uvc视频流个数 /* Status Interrupt Endpoint */ struct usb_host_endpoint *int_ep; //usb_host_endpoint对象 struct urb *int_urb; //中断urb __u8 *status; //uvc设备状态标志 struct input_dev *input; //输入设备 char input_phys[64]; //输入设备设备节点路径 };
struct uvc_streaming { struct list_head list; //uvc视频流链表头 struct uvc_device *dev; //uvc设备 struct video_device *vdev; //V4L2视频设备 struct uvc_video_chain *chain; //uvc视频链 atomic_t active; struct usb_interface *intf; //usb接口设备 int intfnum; //usb接口号 __u16 maxpsize; //最大包尺寸 struct uvc_streaming_header header; //uvc视频流头部 enum v4l2_buf_type type; //V4L2缓冲区类型 输入/输出 unsigned int nformats; //uvc格式个数 struct uvc_format *format; //uvc格式指针 struct uvc_streaming_control ctrl; //uvc数据流控制 struct uvc_format *cur_format; //当前uvc格式指针 struct uvc_frame *cur_frame; //当前uvc帧指针 struct mutex mutex; unsigned int frozen : 1; struct uvc_video_queue queue; //uvc视频队列 void (*decode) (struct urb *urb, struct uvc_streaming *video,struct uvc_buffer *buf);//解码函数 struct { __u8 header[256]; unsigned int header_size; int skip_payload; __u32 payload_size; __u32 max_payload_size; } bulk; struct urb *urb[UVC_URBS];//urb数组 char *urb_buffer[UVC_URBS]; //urb缓冲区 dma_addr_t urb_dma[UVC_URBS];//urb DMA缓冲区 unsigned int urb_size; __u32 sequence; __u8 last_fid; };
struct uvc_format { //uvc格式
__u8 type; //类型
__u8 index; //索引
__u8 bpp; //bits per pixel 每像素位数
__u8 colorspace; //颜色空间
__u32 fcc; //压缩格式
__u32 flags; //标记
char name[32]; //名字
unsigned int nframes; //所含uvc帧个数
struct uvc_frame *frame; //uvc帧指针
};
struct uvc_frame { //uvc帧
__u8 bFrameIndex; //帧索引号
__u8 bmCapabilities; //uvc帧兼容性
__u16 wWidth; //宽度
__u16 wHeight; //高度
__u32 dwMinBitRate; //最新位流
__u32 dwMaxBitRate; //最大位流
__u32 dwMaxVideoFrameBufferSize; //最大视频帧缓冲区
__u8 bFrameIntervalType; //间隙类型
__u32 dwDefaultFrameInterval; //默认帧间隙
__u32 *dwFrameInterval; //帧间隙指针
};
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。