感兴趣可以加QQ群85486140，大家一起交流相互学习下！
文章目录
1.v4l2_device_register
v4l2的设备注册其实没有注册设备或者设备驱动，只是将v4l2的大结构体与其他设备进行捆绑。如下面是v4l2注册设备的过程。
int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
{
if (v4l2_dev == NULL)
return -EINVAL;
INIT_LIST_HEAD(&v4l2_dev->subdevs);
spin_lock_init(&v4l2_dev->lock);
mutex_init(&v4l2_dev->ioctl_lock);
v4l2_prio_init(&v4l2_dev->prio);
kref_init(&v4l2_dev->ref);
//上面都是做一些初始化工作，
get_device(dev);
//下面将当前设备的对象，赋值给v4l2_dev->dev中，这样的话当前的设备就成了v4l2设备，由于当前设备已经注册过了设备文件，所以后续不需要在重新注册设备文件。
v4l2_dev->dev = dev;
if (dev == NULL) {
/* If dev == NULL, then name must be filled in by the caller */
if (WARN_ON(!v4l2_dev->name[0]))
return -EINVAL;
return 0;
}
/* Set name to driver name + device name if it is empty. */
/* 如果v4l2设备的名字为空，则会将当前设备的名字拷贝为v4l2设备中。*/
if (!v4l2_dev->name[0])
snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s %s",
dev->driver->name, dev_name(dev));
//下面是非常重要的一步，即将v4l2设备对象，保存到dev设备中，这个dev可以是platform、char、block等设，我们可以使用dev_get_drvdata(dev)获取到v4l2对象。
if (!dev_get_drvdata(dev))
dev_set_drvdata(dev, v4l2_dev);
return 0;
}
这里上面代码比较简单，这需要知道此函数功能是将当前设备和v4l2设备捆绑，并保存v4l2设备对象到当前设备的driverdata中。此函数的作用就是将当前设备驱动和v4l2对象进行捆绑，便于挂接子设备
2.video_register_device注册过程
2.1注册过程
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);
}
上面方法又封装了一层，转而调用下面的方法
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;
int minor_cnt = VIDEO_NUM_DEVICES;
const char *name_base;
//这里省略若干查找空闲次设备号的过程--------------
/* Part 1: check device type */
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\n",
__func__, type);
return -EINVAL;
}
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;
}
#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. */
/* 查找到第一个空闲的minor号,可以理解成是次设备号*/
for (i = 0; i < VIDEO_NUM_DEVICES; i++)
if (video_device[i] == NULL)//所有注册的video_device都会保存到这个数组中
break;
if (i == VIDEO_NUM_DEVICES) {
mutex_unlock(&videodev_lock);
printk(KERN_ERR "could not get a free minor\n");
return -ENFILE;
}
#endif
//minor_offset一般是0，i就是查找到的空闲次设备号，这里总的次设备支持到256个
vdev->minor = i + minor_offset;//这里记录下次设备号
//这里num会保存到session_id中，唯一表示一个任务。一般情况下nr == minor
vdev->num = nr;
devnode_set(vdev);//将标准位置为已用。
/* Should not happen since we thought this minor was free */
WARN_ON(video_device[vdev->minor] != NULL);
/* 下面这个方法字面意思看起来是获取一个index，但是查看源代码会发现
“这里会去查找不是直系的设备空闲号”，就是说只有video_device不为空，而且v4l2 parent
对象相同都会认为是同类，直接跳过相应的index号*/
vdev->index = get_index(vdev);
/* 下面要重点了，这里根据次设备号将当前video_device保存到video_device[]数组中*/
video_device[vdev->minor] = vdev;
mutex_unlock(&videodev_lock);
/* Part 3: Initialize the character device */
/* 分配字符设备文件*/
vdev->cdev = cdev_alloc();
//务必留意这个ioctl,后面子设备中的ioctl都是通过这里查找的。
vdev->cdev->ops = &v4l2_fops;
vdev->cdev->owner = owner;
ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
/* Part 4: register the device with sysfs */
vdev->dev.class = &video_class;//根目录sys中有对应的属性可操作。
vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);//主设备号为81
vdev->dev.parent = vdev->dev_parent;//这里一般是v4l2_device对象
dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
ret = device_register(&vdev->dev);//注册该video_device到kernel中。
vdev->dev.release = v4l2_device_release;
/* Increase v4l2_device refcount */
/* 下面这一步很关键，增加v4l2设备对象引用计数*/
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\n",
__func__);
}
#endif
/* Part 6: Activate this minor. The char device can now be used. */
set_bit(V4L2_FL_REGISTERED, &vdev->flags);
由这里可以发现，创建video_device时，也创建了一个字符设备。并将该设备的parent节点指定为v4l2_device所依附的那个节点。主要需要注意下面几点。
- 1.根据设备类型确定设备名字和次设备数量
由于系统可能包含很多媒体设备，所以v4l2核心将0～255次设备编号划分了区域如下所示：其中VFL_TYPE_GRABBER一般表示提供数据的设备如camera.
| 类型 | 次设备号区间 | 设备基名称 |
|---|---|---|
| VFL_TYPE_GRABBER | 0~63 | “video” |
| VFL_TYPE_VBI | 224～255 | “vbi” |
| VFL_TYPE_RADIO | 64~127 | “radio” |
| 其它(含VFL_TYPE_SUBDEV) | 128~223 | 含“v4l-subdev” |
- 2.确定设备编号，注册字符设备驱动。这里我曾今迷糊了,我以为下面这会注册２个设备到kernel中，后来才发现我错了。这是注册字符设备的一种方式。
ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
ret = device_register(&vdev->dev);
- 3.确定设备的入口
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);
上面能发现，如果不是SUBDEV才能进来，注意上面name一般代表真实的设备名称，最后一行可以看到将入口注册到v4l2_device包含的media_device设备中了。而SUBDEV设备的注册一般都是设备驱动中赋值，如下是高通eeprom子设备。
e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM;
e_ctrl->msm_sd.sd.entity.name = video_device_node_name(vdev);
上面group_id在判断该设备类型时，起到确定作用。要注意。
2.2 video在系统中的位置
struct v4l2_device ------| struct video_device
| |------------引用----------> |----*v4l2_dev
| |
|-->ctrlhandler<------------挂载------------------|----ctrl_handler
|--->media->entry-list<------------挂载-----------|----->entry
3.subdev注册过程
3.1 v4l2_device_register_subdev()注册过程
这里只是将子设备挂接到v4l2_device的subdevs链表上，还没有真正的注册设备节点。真正注册设备节点的是v4l2_device_register_subdev_nodes方法。下面会介绍。
int v4l2_device_register_subdev(struct v4l2_device *v4l2_dev,
struct v4l2_subdev *sd)
{
#if defined(CONFIG_MEDIA_CONTROLLER)
//获取到子设备的入口对象，方面后面注册到media_device上面。
struct media_entity *entity = &sd->entity;
#endif
int err;
//此处省略一些错误检查代码
/*
* The reason to acquire the module here is to avoid unloading
* a module of sub-device which is registered to a media
* device. To make it possible to unload modules for media
* devices that also register sub-devices, do not
* try_module_get() such sub-device owners.
*/
sd->owner_v4l2_dev = v4l2_dev->dev && v4l2_dev->dev->driver &&
sd->owner == v4l2_dev->dev->driver->owner;
if (!sd->owner_v4l2_dev && !try_module_get(sd->owner))
return -ENODEV;
//下面v4l2_dev一般为系统根v4l2_device设备。
sd->v4l2_dev = v4l2_dev;
//这里对应具体的子设备，可以发现调用了registered()回调，如果有需要可以在对应的设备驱动中实现。
if (sd->internal_ops && sd->internal_ops->registered) {
err = sd->internal_ops->registered(sd);
if (err)
goto error_module;
}
//印证了之前说的，子设备的ctrl_handler都会挂载到根设备v4l2_device的ctrl_handler上面。
/* This just returns 0 if either of the two args is NULL */
err = v4l2_ctrl_add_handler(v4l2_dev->ctrl_handler, sd->ctrl_handler, NULL);
if (err)
goto error_unregister;
#if defined(CONFIG_MEDIA_CONTROLLER)
/* Register the entity. */
if (v4l2_dev->mdev) {
//上面将
err = media_device_register_entity(v4l2_dev->mdev, entity);
if (err < 0)
goto error_unregister;
}
#endif
spin_lock(&v4l2_dev->lock);
//将子设备链接到跟设备的,subdevs链表上。
list_add_tail(&sd->list, &v4l2_dev->subdevs);
spin_unlock(&v4l2_dev->lock);
return 0;
error_unregister:
if (sd->internal_ops && sd->internal_ops->unregistered)
sd->internal_ops->unregistered(sd);
error_module:
if (!sd->owner_v4l2_dev)
module_put(sd->owner);
sd->v4l2_dev = NULL;
return err;
}
EXPORT_SYMBOL_GPL(v4l2_device_register_subdev);
- 获取到子设备的entity对象，并将当前根设备对象赋值给subdev->v4l2_dev域。
- 将子设备的ctrl_handler对象，添加到根设备的
v4l2_dev->ctrl_handler域。 - 将子设备的entity注册到根设备上的media_device设备中。
3.2 v4l2_device_register_subdev_nodes()注册设备节点
int v4l2_device_register_subdev_nodes(struct v4l2_device *v4l2_dev)
{
struct video_device *vdev;
struct v4l2_subdev *sd;
int err;
/* Register a device node for every subdev marked with the
* V4L2_SUBDEV_FL_HAS_DEVNODE flag.
*/
list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
if (!(sd->flags & V4L2_SUBDEV_FL_HAS_DEVNODE))
continue;
vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
if (!vdev) {
err = -ENOMEM;
goto clean_up;
}
video_set_drvdata(vdev, sd);
strlcpy(vdev->name, sd->name, sizeof(vdev->name));
vdev->v4l2_dev = v4l2_dev;
vdev->fops = &v4l2_subdev_fops;
vdev->release = v4l2_device_release_subdev_node;
vdev->ctrl_handler = sd->ctrl_handler;
err = __video_register_device(vdev, VFL_TYPE_SUBDEV, -1, 1,
sd->owner);
if (err < 0) {
kfree(vdev);
goto clean_up;
}
#if defined(CONFIG_MEDIA_CONTROLLER)
sd->entity.info.v4l.major = VIDEO_MAJOR;
sd->entity.info.v4l.minor = vdev->minor;
#endif
sd->devnode = vdev;
}
return 0;
clean_up:
list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
if (!sd->devnode)
break;
video_unregister_device(sd->devnode);
}
return err;
}
EXPORT_SYMBOL_GPL(v4l2_device_register_subdev_nodes);
上面这个方法才是真正注册设备节点的地方，不过一般请看下不这样用，一般稍微修改一下v4l2_device_register_subdev方法，或者直接重新写一个注册方法，在注册设备到v4l2_device根设备上的同时注册设备文件到系统中。
3.３ subdev在系统中的位置
struct v4l2_device
|
|-------->subdevs <-----> list <-----> list <-----> list
| | |
|---------------| |--------------|
|struct sub_dev | |struct sub_dev|
|---------------| |--------------|
子设备就这样一个一个挂在v4l2_device设备上了。
4.media_device_register()多媒体设备注册
其实这里又用宏转了一下,THIS_MODULE就是代表当前模块的struct module对象，也就代表当前驱动的实例对象。
#define media_device_register(mdev) __media_device_register(mdev, THIS_MODULE)
__media_device_register(mdev, THIS_MODULE)
/**
* media_device_register - register a media device
* @mdev: The media device
*
* The caller is responsible for initializing the media device before
* registration. The following fields must be set:
*
* - dev must point to the parent device
* - model must be filled with the device model name
*/
int __must_check __media_device_register(struct media_device *mdev,
struct module *owner)
{
int ret; if (WARN_ON(mdev->dev == NULL || mdev->model[0] == 0))
return -EINVAL;
mdev->entity_id = 1;
INIT_LIST_HEAD(&mdev->entities);
spin_lock_init(&mdev->lock);
mutex_init(&mdev->graph_mutex);
/*上面同样是一些变量的初始化*/
/* Register the device node. */
mdev->devnode.fops = &media_device_fops;
/*下面是绑定父设备，同上面的v4l2_devcie绑定的是同一个struct devie对象*/
mdev->devnode.parent = mdev->dev;
mdev->devnode.release = media_device_release;
ret = media_devnode_register(&mdev->devnode, owner);
//下面可以发现创建了属性文件，我们可以直接通过属性文件来操作这个文件节点。
//但是可惜的是，在属性接口中只发现了下面这样的代码，只打印了media_device的描述信息。
//“sprintf(buf, "%.*s\n", (int)sizeof(mdev->model), mdev->model);”
ret = device_create_file(&mdev->devnode.dev, &dev_attr_model);
//省略一些错误检测
return 0;
}
上面初始化了一些media_devnode的设备域。便于后续标准接口的调用。紧接着重量级的操作来了，注释部分写的也很精彩。
/**
* media_devnode_register - register a media device node
* @mdev: media device node structure we want to register
*
* The registration code assigns minor numbers and registers the new device node
* with the kernel. An error is returned if no free minor number can be found,
* or if the registration of the device node fails.
*
* Zero is returned on success.
* * Note that if the media_devnode_register call fails, the release() callback of
* the media_devnode structure is *not* called, so the caller is responsible for
* freeing any data.
*/
int __must_check media_devnode_register(struct media_devnode *mdev,
struct module *owner)
{
int minor;
int ret;
/* Part 1: Find a free minor number */
mutex_lock(&media_devnode_lock);
//获取可用的次设备编号。
minor = find_next_zero_bit(media_devnode_nums, MEDIA_NUM_DEVICES, 0);
if (minor == MEDIA_NUM_DEVICES) {
mutex_unlock(&media_devnode_lock);
pr_err("could not get a free minor\n");
return -ENFILE;
}
set_bit(minor, media_devnode_nums);
mutex_unlock(&media_devnode_lock);
//注意下面保存了次设备号，便于后续打开设备节点。
mdev->minor = minor;
/* Part 2: Initialize and register the character device */
cdev_init(&mdev->cdev, &media_devnode_fops);
mdev->cdev.owner = owner;
ret = cdev_add(&mdev->cdev, MKDEV(MAJOR(media_dev_t), mdev->minor), 1);
if (ret < 0) {
pr_err("%s: cdev_add failed\n", __func__);
goto error;
}
/* Part 3: Register the media device */
mdev->dev.bus = &media_bus_type;
mdev->dev.devt = MKDEV(MAJOR(media_dev_t), mdev->minor);
mdev->dev.release = media_devnode_release;
if (mdev->parent)
mdev->dev.parent = mdev->parent;
dev_set_name(&mdev->dev, "media%d", mdev->minor);
ret = device_register(&mdev->dev);
if (ret < 0) {
pr_err("%s: device_register failed\n", __func__);
goto error;
}
/* Part 4: Activate this minor. The char device can now be used. */
set_bit(MEDIA_FLAG_REGISTERED, &mdev->flags);
return 0;
error:
cdev_del(&mdev->cdev);
clear_bit(mdev->minor, media_devnode_nums);
return ret;
}
上面代码注册了一个字符设备驱动，上面代码注释可以发现函数分成4部分功能.
- part1:这一部分功能就是找一个空闲的次设备号。
1.MEDIA_NUM_DEVICES:该宏表示系统最大支持256个子设备.
2.media_devnode_nums:该全局变量用来表示所有位号是否已经使用了，这里可以理解成这个变量有256位，每一位都是一个标志。例如：我们得到一个次设备号是5，则该变量的第5位就会被置位。 - part2:这里会根据主设备号media_dev_t和次设备号，创建字符设备。并将该字符设备的owner赋值为当前模块，然后添加到字符设备集合中。
- part3：注册设备
- part4：置标志变量，表示该字符设备可以使用了。
5.总结
上面media_device在v4l2中只用于遍历子设备，就没有描述出media_device在系统中的位置，等后面需要时在分析吧。总结到目前了解到v4l2需要一个根节点v4l2_device来管理子设备，然后上层用户空间，根据根节点，来查找所有子设备。针对高通平台，双摄camera来说。系统中存在3个media设备，分别对应3个物理camera.每一个camera对应的子设备都是根据media设备查找获取到的。
2937
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
