上篇主要对总线进行了一些梳理，现在来看看内核对于设备的处理过程。
struct device {
struct device *parent; /*指向父上游的指针*/
struct device_private *p;
struct kobject kobj; /*用它联系到sysfs中*/
const char *init_name; /* initial name of the device */
const struct device_type *type; /*设备属性文件*/
struct mutex mutex; /* mutex to synchronize calls to
* its driver.
*/
struct bus_type *bus; /*属于那条总线*/
struct device_driver *driver; /*那个驱动能匹配该设备*/
void *platform_data; /* Platform specific data, device
.
.
.
void (*release)(struct device *dev);
};
其中比较重要的是释放函数，当这个设备被删除时，内核调用该方法，所有的注册到内核的设备结构必须有也给释放方法。和总线一样，device也有一个联系总线，设备，驱动程序的数据结构。
/* interface for exporting device attributes */
struct device_attribute {
struct attribute attr;
ssize_t (*show)(struct device *dev, struct device_attribute *attr,
char *buf);
ssize_t (*store)(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count);
};
//定义DEVICE_ATTR （ _name ， _mode ， _show ， _store ） \
struct device_attribute dev_attr _ ## _ name = __ATTR （ _name ， _mode ， _show ， _store ）
该接口用于向外暴露设备属性。
同总线过程一样，device的初始化也是在driver_init完成初始化的：
int __init devices_init(void)
{
/*创建/sys目录下的devices目录*/
devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
if (!devices_kset)
return -ENOMEM;
/*创建/sys目录下的dev目录*/
dev_kobj = kobject_create_and_add("dev", NULL);
if (!dev_kobj)
goto dev_kobj_err;
/*创建dev目录下的block目录*/
sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
if (!sysfs_dev_block_kobj)
goto block_kobj_err;
/*创建dev目录的char目录*/
sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
if (!sysfs_dev_char_kobj)
goto char_kobj_err;
return 0;
char_kobj_err:
kobject_put(sysfs_dev_block_kobj);
block_kobj_err:
kobject_put(dev_kobj);
dev_kobj_err:
kset_unregister(devices_kset);
return -ENOMEM;
}
这个函数干的事情很明显，就是创建在sysfs中的设备目录和dev目录，还在dev目录下创建了block和char两个子目录。
下面分析下设备的注册过程:
int device_register(struct device *dev)
{
/*设备初始化*/
device_initialize(dev);
/*将设备添加到系统中*/
return device_add(dev);
}
void device_initialize(struct device *dev)
{
dev->kobj.kset = devices_kset;
kobject_init(&dev->kobj, &device_ktype);
INIT_LIST_HEAD(&dev->dma_pools);
mutex_init(&dev->mutex);
lockdep_set_novalidate_class(&dev->mutex);
spin_lock_init(&dev->devres_lock);
INIT_LIST_HEAD(&dev->devres_head);
device_pm_init(dev);
set_dev_node(dev, -1);
}
device_initialize主要是完成设备结构的初始化，把设备中能初始化的部分全部初始化。
int device_add(struct device *dev)
{
struct device *parent = NULL;
struct kobject *kobj;
struct class_interface *class_intf;
int error = -EINVAL;
/*增加设备的应用计数*/
dev = get_device(dev);
if (!dev)
goto done;
/*分配device_private 空间并初始化*/
if (!dev->p) {
error = device_private_init(dev);
if (error)
goto done;
}
/*
* for statically allocated devices, which should all be converted
* some day, we need to initialize the name. We prevent reading back
* the name, and force the use of dev_name()
*/
if (dev->init_name) {
dev_set_name(dev, "%s", dev->init_name);/*设置dev的名字*/
dev->init_name = NULL;
}
/* subsystems can specify simple device enumeration */
if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
if (!dev_name(dev)) {
error = -EINVAL;
goto name_error;
}
pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
parent = get_device(dev->parent);
kobj = get_device_parent(dev, parent);
if (kobj)
dev->kobj.parent = kobj;
/* use parent numa_node */
if (parent)
set_dev_node(dev, dev_to_node(parent));
/* first, register with generic layer. */
/* we require the name to be set before, and pass NULL */
error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);/*将设备加入到sys/中*/
if (error)
goto Error;
/* notify platform of device entry */
if (platform_notify)
platform_notify(dev);
/*创建uevent文件*/
error = device_create_file(dev, &dev_attr_uevent);
if (error)
goto attrError;
/*dev与class创建软链接*/
error = device_add_class_symlinks(dev);
if (error)
goto SymlinkError;
error = device_add_attrs(dev);
if (error)
goto AttrsError;
/*将设备加入到bus的设备链表中*/
error = bus_add_device(dev);
if (error)
goto BusError;
error = dpm_sysfs_add(dev);
if (error)
goto DPMError;
device_pm_add(dev);
/*没有设置主设备号，就创建dev*/
if (MAJOR(dev->devt)) {
error = device_create_file(dev, &dev_attr_dev);
if (error)
goto DevAttrError;
/*创建软链接*/
error = device_create_sys_dev_entry(dev);
if (error)
goto SysEntryError;
devtmpfs_create_node(dev);
}
/* Notify clients of device addition. This call must come
* after dpm_sysfs_add() and before kobject_uevent().
*/
if (dev->bus)
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
BUS_NOTIFY_ADD_DEVICE, dev);
kobject_uevent(&dev->kobj, KOBJ_ADD);
/*为设备寻找合适的驱动*/
bus_probe_device(dev);
if (parent)
klist_add_tail(&dev->p->knode_parent,
&parent->p->klist_children);
if (dev->class) {
mutex_lock(&dev->class->p->mutex);
/* tie the class to the device */
klist_add_tail(&dev->knode_class,
&dev->class->p->klist_devices);
/* notify any interfaces that the device is here */
list_for_each_entry(class_intf,
&dev->class->p->interfaces, node)
if (class_intf->add_dev)
class_intf->add_dev(dev, class_intf);
mutex_unlock(&dev->class->p->mutex);
}
done:
put_device(dev);
return error;
}
第8行：增加设备的引用计数
第12-17行：分配device_private空间并初始化
第24-36行：设置驱动的名字
第51行：将设备加入到sys文件系统中
第59行：创建设备属性uevent文件
第63行：创建dev和class的软链接
第70行：将设备加入到bus的设备链表中
第99行：为设备寻找合适的驱动，我们重点看下这个函数
void bus_probe_device(struct device *dev)
{
struct bus_type *bus = dev->bus;
struct subsys_interface *sif;
int ret;
if (!bus)
return;
/*允许设备自动探测驱动*/
if (bus->p->drivers_autoprobe) {
ret = device_attach(dev);
WARN_ON(ret < 0);
}
mutex_lock(&bus->p->mutex);
list_for_each_entry(sif, &bus->p->interfaces, node)
if (sif->add_dev)
sif->add_dev(dev, sif);
mutex_unlock(&bus->p->mutex);
}
第10行：drivers_autoprobe在总线注册时被设置为1，所以这里执行device_attach进行设备和驱动的匹配
int device_attach(struct device *dev)
{
int ret = 0;
device_lock(dev);
if (dev->driver) {
if (klist_node_attached(&dev->p->knode_driver)) {
ret = 1;
goto out_unlock;
}
ret = device_bind_driver(dev);
if (ret == 0)
ret = 1;
else {
dev->driver = NULL;
ret = 0;
}
} else {
/*进行驱动和设备的匹配*/
ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
pm_request_idle(dev);
}
out_unlock:
device_unlock(dev);
return ret;
}
device_attach函数中走到19行，进行设备和驱动的匹配:
int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
void *data, int (*fn)(struct device_driver *, void *))
{
struct klist_iter i;
struct device_driver *drv;
int error = 0;
if (!bus)
return -EINVAL;
klist_iter_init_node(&bus->p->klist_drivers, &i,
start ? &start->p->knode_bus : NULL);
while ((drv = next_driver(&i)) && !error)
error = fn(drv, data);
klist_iter_exit(&i);
return error;
}
第13-14行：遍历bus上所有的驱动，调用__device_attach进行匹配，为设备找驱动。
static int __device_attach(struct device_driver *drv, void *data)
{
struct device *dev = data;
/*调用bus-match函数进行匹配*/
if (!driver_match_device(drv, dev))
return 0;
/*
匹配成功以后执行probe
如果bus有probe函数，优先执行，
否则执行drvier的probe函数
*/
return driver_probe_device(drv, dev);
}
__device_attach调用driver_match_device进行匹配：
static inline int driver_match_device(struct device_driver *drv,
struct device *dev)
{
return drv->bus->match ? drv->bus->match(dev, drv) : 1;
}
匹配函数是在总线注册时，实现的match函数。在匹配成功后，调用probe函数:
int driver_probe_device(struct device_driver *drv, struct device *dev)
{
int ret = 0;
.
ret = really_probe(dev, drv);
.
return ret;
}
static int really_probe(struct device *dev, struct device_driver *drv)
{
int ret = 0;
int local_trigger_count = atomic_read(&deferred_trigger_count);
atomic_inc(&probe_count);
pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
drv->bus->name, __func__, drv->name, dev_name(dev));
WARN_ON(!list_empty(&dev->devres_head));
dev->driver = drv;
.
.
if (dev->bus->probe) {
ret = dev->bus->probe(dev);
if (ret)
goto probe_failed;
} else if (drv->probe) {
ret = drv->probe(dev);
if (ret)
goto probe_failed;
}
if (dev->pm_domain && dev->pm_domain->sync)
dev->pm_domain->sync(dev);
driver_bound(dev);
ret = 1;
pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
drv->bus->name, __func__, dev_name(dev), drv->name);
goto done;
.
.
}
really_probe函数中重点看17-25行，如果bus->probe不为空，则执行总线的probe函数，如果不存在，则查看drv->probe，不为空的话，执行驱动的probe函数。
下面来看下例子:
extern bus_type my_bus_type;
extern struct device my_bus;
static void my_dev_release(struct device *dev)
{
}
struct device my_dev = {
.bus = &my_bus_type,
.parent = &my_bus,
.release = my_dev_release,
};
static ssize_t mydev_show(struct device *dev, char * buf)
{
return sprintf(buf, "%s \n", "这是我的设备");
}
static DEVICE_ATTR(dev, S_IRUGO, mydev_show, NULL);
static int __init my_device_init(void)
{
int ret = 0 ;
/ *初始化设备* /
strncpy(my_dev.bus_id ， “my_dev” ， BUS_ID_SIZE ）;
/ *注册设备* /
device_register(&my_dev);
device_create_file (&my_dev, &dev_attr_dev);
return ret;
}