vidioc_querycap浅析
源码欣赏
在前几篇博文中我们知道:
用户层调用ioctl(),经过v4l2_ioctl —->video_ioctl2——>__video_do_ioctl()。
__video_do_ioctl这个函数会根据cmd的不同来调用struct v4l2_ioctl_ops结构中定义的不同函数。
我们现在来讨论cmd为VIDIOC_QUERYCAP命令的过程。
static long __video_do_ioctl(struct file *file,unsigned int cmd, void *arg)
{
/*
根据次设备号为索引值从video_device[]中获取对应的video_device。
1 ： 那么 是在什么时候 填充上的呢?
这一点，像极了fb_info、fb_info[].套路都是一样的，都是在注册的时候添加到对应的数组中的.然后再其他函数中 在从该数组中 取出来.
详细对比 请见我以前博文的分析
http://blog.csdn.net/leesagacious/article/details/49851555
static inline int __must_check video_register_device(struct video_device *vdev,
int type, int nr)
{
return __video_register_device(vdev, type, nr, 1, vdev->fops->owner);
{
....
for (i = 0; i < VIDEO_NUM_DEVICES; i++)
if (video_device[i] == NULL)
break;
....
vdev->minor = i + minor_offset;
....
mutex_lock(&videodev_lock);
video_device[vdev->minor] = vdev;
mutex_unlock(&videodev_lock);
}
}
*/
struct video_device *vfd = video_devdata(file);
/**
根据上面获取的vfd，获取v4l2_ioctl_ops
下面的代码会根据cmd的不同来调用这个v4l2_ioctl_ops结构中定义的函数
*/
const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
/**
从打开文件的私有数据中获取到vivi_fh
那么，vivi_fh是在什么时候被赋值给file->private_data的呢?
这个赋值是发生在具体设备驱动的open函数中的，如vivi_open()
static int vivi_open(struct file *file)
{
struct vivi_fh *fh = NULL;
fh = kzalloc(sizeof(*fh), GFP_KERNEL); 这里其实已经为videobuf_queue分配好了空间
....
file->private_data = fh; //将vivi_fh赋值给file->private_data
....
}
*/
void *fh = file->private_data;
.....
/**
查看这个video_device是否提供了v4l2_ioctl_ops，否则出错返回
*/
if (ops == NULL) {
printk(KERN_WARNING "videodev: \"%s\" has no ioctl_ops.\n",
vfd->name);
return ret;
}
....
switch(cmd) //根据cmd来调用不同的函数
{
case VIDIOC_QUERYCAP:
struct v4l2_capability *cap = (struct v4l2_capability *)arg;
//如果具体设备的file_operations并没有定义vidioc_querycap这个函数
if (!ops->vidioc_querycap)
{
break;
}
/**
调用vidioc_querycap
参数 :
fh : vivi_fh 在vivi_open()中分配，并放入file->private_data
cap : 用户空间传入的struct v4l2_capability 指针
*/
ret = ops->vidioc_querycap(file, fh, cap);
}
}
下面看看被调用的vidioc_querycap()函数
/**
查询设备的性能。
参数 :
v4l2_capability : v4l2的能力描述符
返回值:
成功 返回 0 。cap变量中包含了该视频设备所支持的能力信息
如 : V4L2_CAP_VIDEO_CAPTURE 、V4L2_CAP_STREAMING....
失败 返回 -1
应用程序往往打开设备后就执行这个ioctl
用户空间:
用户层调用 ioctl(fd,VIDIOC_QUERYCAP,CAP)，这个函数会被执行。
当执行完成这个命令后，CAP变量中包含了该设备的能力信息。
代码:
#define ERR_EXIT(m)\
do{
perror(m);
exit(EXIT_FAILURE);\
}while(0)
struct v4l2_capability cap;
ret = ioctl(fd,VIDIOC_QUERYCAP,&cap);
if(ret == -1)
{
ERR_EXIT(ioctl);
}
*/
/*
应用程序用这个命令，用来判断它是否是一个视频捕获设备
*/
static int vidioc_querycap(struct file * file,void *priv,struct v4l2_capability *cap)
{
/**
先来看看这个v4l2_capability
struct v4l2_capability {
__u8 driver[16]; //驱动名字
__u8 card[32]; //设备名字
__u8 bus_info[32]; //设备在系统中的位置 Location of the device in the system
__u32 version; //驱动的版本号
__u32 capabilities; //设备能力集
__u32 reserved[4]; //保留字段，驱动必须要将这个数组设置为0
};
*/
struct vivi_fh *fh = priv;
//从vivi_fh中获取vivi_dev
struct vivi_dev *dev = fh->dev;
strcpy(cap->driver,"vivi"); //驱动的名字
strcpy(cap->card,"vivi"); //设备的名字
//设备在系统中的位置
strlcpy(cap->bus_info,dev->v4l2_dev.name,sizeof(cap->bus_info));
cap->version = VIVI_VERSION; //版本号
//能力集合
//V4L2_CAP_VIDEO_CAPTURE : 是一个视频捕捉设备
//V4L2_CAP_STREAMING ：支持ioctl系统调用来获取数据
//V4L2_CAP_READWRITE ：支持read/write系统调用来获取数据
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
return 0;
}
下面是 源码中调用的过程。
这个函数 就是 要调用 vdev->fops->unlocked_iotcl().
uvc :
uvc_init()
{
ret = usb_register(&uvc_driver.driver);
}
struct uvc_driver uvc_driver = {
.driver = {
.name = "uvcvideo",
.probe = uvc_probe,
.disconnect = uvc_disconnect,
.suspend = uvc_suspend,
.resume = uvc_resume,
.reset_resume = uvc_reset_resume,
.id_table = uvc_ids,
.supports_autosuspend = 1,
},
};
//probe被调用
static int uvc_probe(struct usb_interface *intf,const struct usb_device_id *id)
{
if (uvc_register_chains(dev) < 0){
goto error;
}
}
static int uvc_register_chains(struct uvc_device *dev)
{
list_for_each_entry(chain, &dev->chains, list) {
ret = uvc_register_terms(dev, chain);
if (ret < 0){
return ret;
}
}
}
static int uvc_register_terms(struct uvc_device *dev,struct uvc_video_chain *chain)
{
list_for_each_entry(term, &chain->entities, chain) {
ret = uvc_register_video(dev, stream);
}
}
static int uvc_register_video(struct uvc_device *dev,struct uvc_streaming *stream)
{
...
vdev = video_device_alloc();
vdev->v4l2_dev = &dev->vdev;
vdev->fops = &uvc_fops; //看 这个uvc_fops中定义的函数会被调用到
vdev->release = uvc_release;
strlcpy(vdev->name, dev->name, sizeof vdev->name);
..
ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
}
const struct v4l2_file_operations uvc_fops = {
.owner = THIS_MODULE,
.open = uvc_v4l2_open,
.release = uvc_v4l2_release,
.unlocked_ioctl = uvc_v4l2_ioctl, //这个函数。
#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
};
那么，这个函数终于被调用到了
static long uvc_v4l2_ioctl(struct file *file,unsigned int cmd, unsigned long arg)
{
if (uvc_trace_param & UVC_TRACE_IOCTL) {
uvc_printk(KERN_DEBUG, "uvc_v4l2_ioctl(");
v4l_printk_ioctl(cmd);
printk(")\n");
}
//这个函数会被调用
return video_usercopy(file, cmd, arg, uvc_v4l2_do_ioctl);
}
video_usercopy(struct file *file, unsigned int cmd, unsigned long arg,v4l2_kioctl func)
{
...
...
err = func(file, cmd, parg);
...
}
static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
{
struct video_device *vdev = video_devdata(file);
...
switch (cmd) {
case VIDIOC_QUERYCAP:
{
struct v4l2_capability *cap = arg;
/**
填充这个结构体
*/
memset(cap, 0, sizeof *cap);
strlcpy(cap->driver, "uvcvideo", sizeof cap->driver);
strlcpy(cap->card, vdev->name, sizeof cap->card);
usb_make_path(stream->dev->udev,cap->bus_info, sizeof(cap->bus_info));
cap->version = LINUX_VERSION_CODE;
if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE){
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE| V4L2_CAP_STREAMING;
}
else{
cap->capabilities = V4L2_CAP_VIDEO_OUTPUT| V4L2_CAP_STREAMING;
}
break;
}
case ...
case ...
}
}实验验证
