linux设备模型之bus，device，driver分析二

===============================
本文系本站原创,欢迎转载!
转载请注明出处:http://blog.csdn.net/gdt_a20
===============================

  上篇分析了bus，driver的注册过程，这篇主要分析device的注册，并总结给出个流程图。

三、device的注册

   还是照例先看一下device的结构：

struct device {
    struct device       *parent;
    struct device_private   *p;                                              //私有属性结构，重点
    struct kobject kobj;
    const char      *init_name; /* initial name of the device */
    struct device_type  *type;
    struct mutex        mutex;  /* mutex to synchronize calls to
                     * its driver.
                     */
    struct bus_type *bus;       /* type of bus device is on */            //所在bus
    struct device_driver *driver;   /* which driver has allocated this    //匹配的driver
                       device */
    void        *platform_data; /* Platform specific data, device
                       core doesn't touch it */
    struct dev_pm_info  power;
#ifdef CONFIG_NUMA
    int     numa_node;  /* NUMA node this device is close to */
#endif
    u64     *dma_mask;  /* dma mask (if dma'able device) */
    u64     coherent_dma_mask;/* Like dma_mask, but for
                         alloc_coherent mappings as
                         not all hardware supports
                         64 bit addresses for consistent
                         allocations such descriptors. */
    struct device_dma_parameters *dma_parms;
    struct list_head    dma_pools;  /* dma pools (if dma'ble) */
    struct dma_coherent_mem *dma_mem; /* internal for coherent mem
                         override */
    /* arch specific additions */
    struct dev_archdata archdata;
#ifdef CONFIG_OF
    struct device_node  *of_node;
#endif
    dev_t           devt;   /* dev_t, creates the sysfs "dev" */
    spinlock_t      devres_lock;
    struct list_head    devres_head;
    struct klist_node   knode_class;
    struct class        *class;
    const struct attribute_group **groups;  /* optional groups */
    void    (*release)(struct device *dev);
};
//重点看一下私有属性结构
struct device_private {
    struct klist klist_children;             //子集结构
    struct klist_node knode_parent;          //父级挂接点
    struct klist_node knode_driver;          //driver挂接点
    struct klist_node knode_bus;             //bus挂接点
    void *driver_data;
    struct device *device;                   //回指
};

接下来详细看一下device的注册device_register:

int device_register(struct device *dev)
{
    device_initialize(dev);                //初始化dev
    return device_add(dev);                //添加dev
}
/******************************
* 先看一下device_initialize(dev)
******************************/
void device_initialize(struct device *dev)
{
    dev->kobj.kset = devices_kset;                  //可见device和bus都有其起始的kset，而driver没有
    kobject_init(&dev->kobj, &device_ktype);        //初始化这个kobj并建立层次关系以及属性文件，此时
    INIT_LIST_HEAD(&dev->dma_pools);                //是放到了总的device文件目录下面
    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_add(dev)
******************************/
int device_add(struct device *dev)
{
    struct device *parent = NULL;
    struct class_interface *class_intf;
    int error = -EINVAL;
    dev = get_device(dev);
    if (!dev)
        goto done;
    if (!dev->p) {
        error = device_private_init(dev);                        //初始化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);                 //设置名字，给kobj
        dev->init_name = NULL;
    }
    if (!dev_name(dev)) {                                         //名字为空出错退出
        error = -EINVAL;
        goto name_error;
    }
    pr_debug("device: '%s': %s/n", dev_name(dev), __func__);
    parent = get_device(dev->parent);                          //返回父节点，如果有返回，没有返回NULL
    setup_parent(dev, parent);
    /* 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);   //初始化kobj与其父节点的连接
    if (error)
        goto Error;
    /* notify platform of device entry */
    if (platform_notify)
        platform_notify(dev);
    error = device_create_file(dev, &uevent_attr);             //产生属性文件
    if (error)
        goto attrError;
    if (MAJOR(dev->devt)) {
        error = device_create_file(dev, &devt_attr);             //在sys下产生dev属性文件
        if (error)
            goto ueventattrError;
        error = device_create_sys_dev_entry(dev);
        if (error)
            goto devtattrError;
        devtmpfs_create_node(dev);
    }
    error = device_add_class_symlinks(dev);
    if (error)
        goto SymlinkError;
    error = device_add_attrs(dev);                             //增加属性文件
    if (error)
        goto AttrsError;
    error = bus_add_device(dev);                               //把device的bus节点挂到bus的设备节点上
    if (error)
        goto BusError;
    error = dpm_sysfs_add(dev);
    if (error)
        goto DPMError;
    device_pm_add(dev);
    /* Notify clients of device addition.  This call must come
     * after dpm_sysf_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);                                    //匹配driver
    if (parent)
        klist_add_tail(&dev->p->knode_parent,                 //把该设备的节点挂到其父节点的链表
                   &parent->p->klist_children);
    if (dev->class) {
        mutex_lock(&dev->class->p->class_mutex);
        /* tie the class to the device */
        klist_add_tail(&dev->knode_class,
                   &dev->class->p->class_devices);
        /* notify any interfaces that the device is here */
        list_for_each_entry(class_intf,
                    &dev->class->p->class_interfaces, node)
            if (class_intf->add_dev)
                class_intf->add_dev(dev, class_intf);
        mutex_unlock(&dev->class->p->class_mutex);
    }
done:
    put_device(dev);
    return error;
 DPMError:
    bus_remove_device(dev);
 BusError:
    device_remove_attrs(dev);
 AttrsError:
    device_remove_class_symlinks(dev);
 SymlinkError:
    if (MAJOR(dev->devt))
        devtmpfs_delete_node(dev);
    if (MAJOR(dev->devt))
        device_remove_sys_dev_entry(dev);
 devtattrError:
    if (MAJOR(dev->devt))
        device_remove_file(dev, &devt_attr);
 ueventattrError:
    device_remove_file(dev, &uevent_attr);
 attrError:
    kobject_uevent(&dev->kobj, KOBJ_REMOVE);
    kobject_del(&dev->kobj);
 Error:
    cleanup_device_parent(dev);
    if (parent)
        put_device(parent);
name_error:
    kfree(dev->p);
    dev->p = NULL;
    goto done;
}
/***********************************************
* 重点看一下bus_probe_device匹配driver以及初始化过程
***********************************************/
void bus_probe_device(struct device *dev)
{
    struct bus_type *bus = dev->bus;
    int ret;
    if (bus && bus->p->drivers_autoprobe) {         //设置了自动匹配初始化那么就开始匹配
        ret = device_attach(dev);
        WARN_ON(ret < 0);
    }
}
/******************
* 继续device_attach
******************/
int device_attach(struct device *dev)
{
    int ret = 0;
    device_lock(dev);
    if (dev->driver) {                            //默认指定了driver就直接绑定
        ret = device_bind_driver(dev);
        if (ret == 0)
            ret = 1;
        else {
            dev->driver = NULL;
            ret = 0;
        }
    } else {                                      //没有指定就进行遍历匹配
        pm_runtime_get_noresume(dev);
        ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
        pm_runtime_put_sync(dev);
    }
    device_unlock(dev);
    return ret;
}
/**************************
* 再来看device_bind_driver分支
**************************/
int device_bind_driver(struct device *dev)
{
    int ret;
    ret = driver_sysfs_add(dev);
    if (!ret)
        driver_bound(dev);              //主要是完成了将私有成员的driver节点挂到
    return ret;                         //了driver的设备链表
}
/**************************
* 先看bus_for_each_drv分支
**************************/
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,           //和driver遍历device类似，从头开始遍历bus的driver链表
                 start ? &start->p->knode_bus : NULL);         //发现一个driver就调用fn即__device_attach进行匹配
    while ((drv = next_driver(&i)) && !error)
        error = fn(drv, data);
    klist_iter_exit(&i);
    return error;
}
/*********************************
* 最后来看一下__device_attach这个函数
*********************************/
static int __device_attach(struct device_driver *drv, void *data)
{
    struct device *dev = data;
    if (!driver_match_device(drv, dev))
        return 0;
    return driver_probe_device(drv, dev);
}
/*
  对比driver的注册最后调用的__driver_attach可以发现其实质是一样的，都最后归宿到了
  这driver_match_device，driver_probe_device两个函数,本质参数的和谐做到了通用
  性在这里就不继续分析了，不是很清楚的可以看前一篇文章driver最后一部分的分析  ^_^
*/

以上便是device的注册，可以发现device和driver围绕着bus最后有种殊途同归的感觉，下面结合driver的流程给出一个框图

以便更明确其间的流程：