V4l2初识-----------浅析video_register_device

Posted 2021-02-04 -glb

在V4l2初识（一）中，我们已经知道当插上一个摄像头的时候，在uvc_driver.c中最终会调用函数video_register_device函数。接下来我们就简要分析这个函数做了哪些事情，揭开其神秘面纱。

参考原文：https://blog.csdn.net/leesagacious/article/details/49948163 

/* Register video devices. Note that if video_register_device fails,
the release() callback of the video_device structure is *not* called, so
the caller is responsible for freeing any data. Usually that means that
you call video_device_release() on failure. */

/*注册video_device，注意如果注册失败，video_device结构体中的release函数不会被调用， 调用者负责释放所有的数据，通常是调用video_device_release()函数来释放*/

static inline int  video_register_device(struct video_device *vdev,int type, int nr)
{
　　return __video_register_device(vdev, type, nr, 1, vdev->fops->owner);
}

参数一：video_devide ------即我们想要注册的video_device结构体

参数二：type-----------要注册的device类型，其中包括：     

　　　　define VFL_TYPE_GRABBER  0   图像采集设备，包括阿摄像头、调谐器 

　　　　define VFL_TYPE_VBI1          1    从视频消隐的时间段取得信息的设备(1)

　　　　#define VFL_TYPE_RADIO 2           无线电设备 

　　　　#define VFL_TYPE_SUBDEV 3        视频传播设备 

　　　　#define VFL_TYPE_MAX 4      

参数三：int nr------------device node number   

　　      0 == /dev/video 0       1 == /dev/video1     ........    -1 == first free

int __video_register_device(struct video_device *vdev, int type, int nr,
int warn_if_nr_in_use, struct module *owner)
{
　　int i = 0;
　　int ret;
　　int minor_offset = 0;     //minor = i+minor_offset
　　int minor_cnt = VIDEO_NUM_DEVICES;  //用于设备节点序号
　　const char *name_base; //设备的名称会根据传入的type来选择

      /* A minor value of -1 marks this video device as never having been registered 

　　 次设备号为-1，表明这个设备还没有被注册 */

　　vdev->minor = -1;

     /* the release callback MUST be present 

　　 video_device一定要设置release函数，否则要出错返回*/

　　if (WARN_ON(!vdev->release))
　　　　return -EINVAL;

　　/* v4l2_fh support */
　　spin_lock_init(&vdev->fh_lock);       //获取自旋锁
　　INIT_LIST_HEAD(&vdev->fh_list);  //初始化链表头

　　/* Part 1: check device type 

　　根据传入的类型type，来选择设备的名称。后面会调用函数dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num)来设置设备的名称

     */
　　switch (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;
　　default:
　　　　printk(KERN_ERR "%s called with unknown type: %d ",__func__, type);
　return -EINVAL;
}

　　vdev->vfl_type = type;
　　vdev->cdev = NULL;
　　if (vdev->v4l2_dev) {
　　　　if (vdev->v4l2_dev->dev)
　　　　　　vdev->parent = vdev->v4l2_dev->dev;
　　if (vdev->ctrl_handler == NULL)                                                                                                                                                                      

　　/*在app应用程序中，可以通过Ioctl来设置、获得亮度等信息。那么驱动程序谁来接收/存储/ 设置到硬件，或从硬件中获得这些信息?
　　在驱动程序里面抽象出一个结构体V4L2_ctrl。
　　那么谁来管理v4l2_ctrl呢？
　　是利用v4l2_ctrl_handler进行管理的，它像链表一样，里面需要填充各个属 性，也可理解为设置各个属性。
　　在注册video_device之前的vivi_create_instance()函数中，
　　初始化v4l2_ctrl_handler
　　v4l2_ctrl_handler_init(hdl, 11);
　　创建v4l2_ctrl 并放入到v4l2_ctrl_handler链表
　　v4l2_ctrl_new_std()
　　v4l2_ctrl_new_custom()
　　dev->v4l2_dev.ctrl_handler = hdl;       //dev->v4l2_dev : v4l2_device 每一个v4l2设备都用这个结构来描述
　　下面的代码是将v4l2_ctrl_handler与video_device进行了关联
*/

　　vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
　　/* If the prio state pointer is NULL, then use the v4l2_device prio state. */
　　if (vdev->prio == NULL)
　　　　vdev->prio = &vdev->v4l2_dev->prio;
}

　/* Part 2: find a free minor, device node number and device index. */
　#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
　　/* Keep the ranges for the first four types for historical
　　* reasons.
　　* Newer devices (not yet in place) should use the range
　　* of 128-191 and just pick the first free minor there
　　* (new style).

　　根据传入的类型type，为选择次设备号、设备节点序号作准备。可见可见次设备号是分段使用的

　　 minor = i + minor_offset

      */
switch (type) {
　　case VFL_TYPE_GRABBER:
　　　　minor_offset = 0;
　　　　minor_cnt = 64;
　　　　break;
　　case VFL_TYPE_RADIO:
　　　　minor_offset = 64;
　　　　minor_cnt = 64;
　　　　break;
　　case VFL_TYPE_VBI:
　　　　minor_offset = 224;
　　　　minor_cnt = 32;
　　　　break;
　　default:
　　　　minor_offset = 128;
　　　　minor_cnt = 64;
　　　　break;
}
#endif

/* Pick a device node number */
　　mutex_lock(&videodev_lock);   //获取互斥锁

　　/*获取一个没有被使用的设备节点序号。如果上面传入的是-1，VFL_TYPE_GRABBER，它会从0-64中选择*/
　　nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
　　if (nr == minor_cnt)
　　　　nr = devnode_find(vdev, 0, minor_cnt);
　　if (nr == minor_cnt) {
　　　　printk(KERN_ERR "could not get a free device node number ");
　　mutex_unlock(&videodev_lock);
　　return -ENFILE;
　　}
#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
/* 1-on-1 mapping of device node number to minor number */
　　i = nr;
#else
　　/* The device node number and minor numbers are independent, so we just find the first free minor number.

　　static struct video_device *video_device[256];  从video_device[]数组中选择一个空缺项，这个空缺项的索引值放到i中 

　　为下面把video_device放入到video_device[i]中做准备，这个设计和registered_fb[]设计的类似

　　*/

　　for (i = 0; i < VIDEO_NUM_DEVICES; i++)
　　　　if (video_device[i] == NULL)
　　　　　　break;

　　　　　//检查i的值有没有超过256，否则出错返回
　　　　if (i == VIDEO_NUM_DEVICES) {
　　　　　　mutex_unlock(&videodev_lock);
　　　　　　printk(KERN_ERR "could not get a free minor ");
　　　　　　return -ENFILE;
　　　　}
#endif

　　/*设备的次设备号*/
　　vdev->minor = i + minor_offset;
　　vdev->num = nr;
　　devnode_set(vdev);

　　/* Should not happen since we thought this minor was free

　　再一次测试这个video_device[i]是否是空缺项*/

　　WARN_ON(video_device[vdev->minor] != NULL);
　　vdev->index = get_index(vdev);
　　mutex_unlock(&videodev_lock);   //释放互斥锁

　　/* Part 3: Initialize the character device

　　分配cdev结构体 cdev代表了字符设备的通用信息,通常被嵌入在一个更大的结构体中*/

　　vdev->cdev = cdev_alloc();
　　if (vdev->cdev == NULL) {
　　　　ret = -ENOMEM;
　　　　goto cleanup;
　　}

　　/*设置file_operations为v4l2_fops
　　用户层调用open、mmap、ioctl、read...的时候,这个v4l2_fops中的对应的方法会响应。

　　如 : 用户层调用mmap()，那么v4l2_fops中的v4l2_mmap()会被调用。
　　在v4l2_mmap()中，会调用具体设备提供的mmap函数

　　static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
　　{
　　　　....
　　　　ret = vdev->fops->mmap(filp, vm);
　　　　....
　　}
　　*/

　　vdev->cdev->ops = &v4l2_fops;
　　vdev->cdev->owner = owner;

　　　/*添加字符设备到系统*/
　　ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
　　if (ret < 0) {
　　　　printk(KERN_ERR "%s: cdev_add failed ", __func__);
　　　　kfree(vdev->cdev);
　　　　vdev->cdev = NULL;
　　　　goto cleanup;
　　}

　　/* Part 4: register the device with sysfs

　　填充video_device中的成员值       设置video_device所属的类，会在/sys/class/下创建目录*/

　　vdev->dev.class = &video_class;

　  /*通过主设备号和次设备号生成dev_t，表示的是一个设备号*/
　　vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
　　if (vdev->parent)
　　　　vdev->dev.parent = vdev->parent;

　　　/*设置设备的名称*/
　　dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);

　　/*利用device_register，注册字符设备驱动。这个地方和我们写的字符设备驱动程序是一样的*/
　　ret = device_register(&vdev->dev);
　　if (ret < 0) {
　　　　printk(KERN_ERR "%s: device_register failed ", __func__);
　　　　goto cleanup;
　　}
/* Register the release callback that will be called when the last reference to the device goes away. */
　　vdev->dev.release = v4l2_device_release;

　　if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
　　　　printk(KERN_WARNING "%s: requested %s%d, got %s ", __func__,name_base, nr, video_device_node_name(vdev));

/* Increase v4l2_device refcount */
　　if (vdev->v4l2_dev)
　　v4l2_device_get(vdev->v4l2_dev);

#if defined(CONFIG_MEDIA_CONTROLLER)
/* Part 5: Register the entity. */
　　if (vdev->v4l2_dev && vdev->v4l2_dev->mdev &&vdev->vfl_type != VFL_TYPE_SUBDEV) {
　　　　vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
　　　　vdev->entity.name = vdev->name;
　　　　vdev->entity.info.v4l.major = VIDEO_MAJOR;
　　　　vdev->entity.info.v4l.minor = vdev->minor;
　　　　ret = media_device_register_entity(vdev->v4l2_dev->mdev,&vdev->entity);
　　　　if (ret < 0)
　　　　　　printk(KERN_WARNING"%s: media_device_register_entity failed ",__func__);
　　}
#endif
/* Part 6: Activate this minor. The char device can now be used. */ 

　　/*将这个unsigned long flags 的第0 位 置1，表示这个video_device 是注册过的了，

　　在其他位置，会调用video_is_registeried( ) 来判断，其依据 还是测试这个flags的第0位。
　　video_is_registered( )
　　{
　　　　test_bit( V4L2_FL_REGISTERED, &vdev->flags )
　　}
　　*/                                                                                                                                                                                                                           

　　 //获取锁 ---- 访问临界区 -----释放锁

　　set_bit(V4L2_FL_REGISTERED, &vdev->flags);
　　mutex_lock(&videodev_lock);                                                                                                                                                                               

　　/*依据次设备号为下标，将设置好的video_device放入到video_device[]中，其他函数会依据次设备号从这个数组中获取对应的video_device,这个和registered_fb[]设计的类似   static struct video_device*video_device[256];*/

　　video_device[vdev->minor] = vdev;
　　mutex_unlock(&videodev_lock);

return 0;

cleanup:
　　mutex_lock(&videodev_lock);
　　if (vdev->cdev)
　　　　cdev_del(vdev->cdev);
　　　　devnode_clear(vdev);
　　mutex_unlock(&videodev_lock);
/* Mark this video device as never having been registered. */
　　vdev->minor = -1;
return ret;
}
EXPORT_SYMBOL(__video_register_device);

 

注1：VBI：

VBI= vertical blanking interval，也就是我们讲的场消隐期间。
VBI在电视处理中是用来是垂直扫描完成从屏幕底部回到屏幕顶部的时间。在这期间，没有任何的图像信息，在原来是基本废置不用的。后来，利用这期间来传输一些信息，比如CC，图文，VPS/PDC，GEMSTAR等等信息服务。