linux设备注册-凯发app官方网站

int device_register(struct device *dev)
{
    device_initialize(dev);
    return device_add(dev);
}
export_symbol_gpl(device_register);

在device_register()函数中，分为两个步骤：

• （1）调用device_initialize()：该步骤用于初始化一个device。

• （2）调用device_add()：该函数用于将device添加到linux内核的device树中。

device_initialize分析

该函数接收一个struct device *dev参数，在该函数中初始化struct device结构中的几个重要成员：
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);
    #ifdef config_prove_locking
    mutex_init(&dev->lockdep_mutex);
    #endif
l   ockdep_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);
    #ifdef config_generic_msi_irq
    init_list_head(&dev->msi_list);
    #endif
    init_list_head(&dev->links.consumers);
    init_list_head(&dev->links.suppliers);
    init_list_head(&dev->links.defer_sync);
    dev->links.status = dl_dev_no_driver;
}
export_symbol_gpl(device_initialize);

• 设置dev->kobj.kset为device_kset。device_kset是一个struct kset类型的全局变量，用于向sysfs文件系统中导出目录：/sys/device/* 。

• 初始化dev中的kobject，并指定与这个对象相关联的ktype为device_type。

• 初始化dma_pools链表。

• 初始化struct device中的各种锁：

• 初始化device的电源管理：

• 如果在numa下，还会初始化设置device的numa_node为-1。

• 接着初始化device下的links中的链表：

在struct device 中的links表示链接到该设备的suppliers和consumers，由struct dev_links_info表示：

• 设置device下的links.status值为dl_dev_no_driver，表示此时还没有对应驱动attach到这个设备。

以上步骤则是device_initialize()初始化设备时完成的操作。

device_add分析

int device_add(struct device *dev)
{
    struct device *parent;
    struct kobject *kobj;
    struct class_interface *class_intf;
    int error = -einval;
    struct kobject *glue_dir = null;

    dev = get_device(dev);
    if (!dev)
        goto done;

    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->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 (is_err(kobj)) {
        error = ptr_err(kobj);
        goto parent_error;
    }
    if (kobj)
        dev->kobj.parent = kobj;

    /* use parent numa_node */
    if (parent && (dev_to_node(dev) == numa_no_node))
        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);
    if (error) {
        glue_dir = get_glue_dir(dev);
        goto error;
    }

    /* notify platform of device entry */
    error = device_platform_notify(dev, kobj_add);
    if (error)
        goto platform_error;

    error = device_create_file(dev, &dev_attr_uevent);
    if (error)
        goto attrerror;

    error = device_add_class_symlinks(dev);
    if (error)
        goto symlinkerror;
    error = device_add_attrs(dev);
    if (error)
        goto attrserror;
    error = bus_add_device(dev);
    if (error)
        goto buserror;
    error = dpm_sysfs_add(dev);
    if (error)
        goto dpmerror;
    device_pm_add(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);

    /*
    * check if any of the other devices (consumers) have been waiting for
    * this device (supplier) to be added so that they can create a device
    * link to it.
    *
    * this needs to happen after device_pm_add() because device_link_add()
    * requires the supplier be registered before it's called.
    *
    * but this also needs to happen before bus_probe_device() to make sure
    * waiting consumers can link to it before the driver is bound to the
    * device and the driver sync_state callback is called for this device.
    */
    if (dev->fwnode && !dev->fwnode->dev) {
        dev->fwnode->dev = dev;
        fw_devlink_link_device(dev);
    }

    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->p->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;
 sysentryerror:
    if (major(dev->devt))
        device_remove_file(dev, &dev_attr_dev);
 devattrerror:
    device_pm_remove(dev);
    dpm_sysfs_remove(dev);
 dpmerror:
    bus_remove_device(dev);
 buserror:
    device_remove_attrs(dev);
 attrserror:
    device_remove_class_symlinks(dev);
 symlinkerror:
    device_remove_file(dev, &dev_attr_uevent);
 attrerror:
    device_platform_notify(dev, kobj_remove);
platform_error:
    kobject_uevent(&dev->kobj, kobj_remove);
    glue_dir = get_glue_dir(dev);
    kobject_del(&dev->kobj);
 error:
    cleanup_glue_dir(dev, glue_dir);
parent_error:
    put_device(parent);
name_error:
    kfree(dev->p);
    dev->p = null;
goto done;
}
export_symbol_gpl(device_add);

• （1）调用get_device(dev)增加device的引用计数。

• （2）如果dev->p为null，则调用device_private_init()设置device的私有数据：

• （3）设置device的name：
•  如果开启支持pr_debug()函数，则会打印出对应的设备名称。

• （4）寻找父设备和父设备对应的kobj，并调用kobject_add()将dev->kobj添加到dev->kobj.parent：

• （5）使用device_create_file为device创建sysfs属性文件：

dev_attr_uevent是一个struct device_attribute类型的数据，该结构用于描述导出设备属性的接口，定义如下：
/* 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);
};