status = device_register(&client->dev) 分析-----转

这篇文章也是从别的地方转载的，我的目的是搞清楚：当调用device_register()函数向系统注册一个设备的时候，我注册进去的设备是如何和他父设备关联起来的，以及如何加入到他所在的总线设备中的，但针对这个问题，好像通过这篇文章了解的并不透彻。但具体到代码分析的最后关于设备和驱动是如何绑定的，这并不是我这篇文章的重点，但大概看了一下，有点类型i2c总线上设备和驱动的匹配过程。

看下图：

 

在分析程序的过程中看到了把kobj->kset赋值为(kset)device_kset(即图中黑线实现的部分),但没有看到什么时候把dev->kobj->parent赋值为device_kset->kobj(图中的红线实现的部分)，在调用函数setup_parent()中是对dev->kobject->parent赋值了，但不明白在setup_parent()函数中是怎么找到device_kset的。说实在话，对setup_parent()函数不明白，也没分析清楚。（在此补充一下，分析了一下setup_parent()函数，实现了红线的部分）

 

这篇文章将那个3个注册函数说说，把整个设备模型框架搭建起来，当然，是重点部分了。在这之前希望你已经懂得总线、设备、驱动的数据结构及其里面的有关数据结构。关于调用的函数，如果显示为粗体，那么在下面我有分析。

 

转载于：http://student.csdn.net/space.php?uid=111596&do=blog&id=56043

来自：drivers/base/core.c
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所属集合，devices_kset其实在第一层，sys/devices/
    kobject_init(&dev->kobj, &device_ktype);       //初始化设备的kobject
    INIT_LIST_HEAD(&dev->dma_pools);           //初始化设备的DMA池，用于传递大数据
    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);
}

int device_add(struct device *dev)
{
    struct device *parent = NULL;
    struct class_interface *class_intf;
    int error = -EINVAL;

    dev = get_device(dev);         //增加设备的kobject的引用计数
    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);         //设置设备kobject的名称
        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);         //增加父设备kobject的引用
    setup_parent(dev, parent);                    //设置该设备kobject父对象（父对象是谁呢）

    /* 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);          //将设备kobject添加进父对象设备模型
    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);
        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;

   调用bus_add_device在sysfs中添加两个链接：一个在总线目录下指向设备，另一个在设备的目录下指向总线子系统。
    error = bus_add_device(dev);          //将设备添加进总线中
    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试图自动探测设备。如果能够找到合适的驱动程序，则将设备添加到bus->klist_devices.设备还需要添加到父结点的子结点链表中，图中蓝色线的实现部分（此前，设备知道其父结点，但父结点不知道子结点的存在）

    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->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;
}

 

int device_private_init(struct device *dev)
{
    dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
    if (!dev->p)
        return -ENOMEM;
    dev->p->device = dev;                                                //指向设备自己
    klist_init(&dev->p->klist_children, klist_children_get,
           klist_children_put);             //初始化设备私有成员的子设备链表，还有两个函数，关于增加和减少子设备引用计数的
    return 0;
}

static void setup_parent(struct device *dev, struct device *parent)
{
    struct kobject *kobj;
    kobj = get_device_parent(dev, parent);        //得到设备kobject的父对象
    if (kobj)
        dev->kobj.parent = kobj;
}

int bus_add_device(struct device *dev)
{
    struct bus_type *bus = bus_get(dev->bus);
    int error = 0;

    if (bus) {
        pr_debug("bus: '%s': add device %s/n", bus->name, dev_name(dev));
        error = device_add_attrs(bus, dev);
        if (error)
            goto out_put;
        error = sysfs_create_link(&bus->p->devices_kset->kobj,
                        &dev->kobj, dev_name(dev));
        if (error)
            goto out_id;
        error = sysfs_create_link(&dev->kobj,
                &dev->bus->p->subsys.kobj, "subsystem");
        if (error)
            goto out_subsys;
        error = make_deprecated_bus_links(dev);
        if (error)
            goto out_deprecated;
        klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);      //关键点了，将设备添加进总线的设备链表
    }
    return 0;

out_deprecated:
    sysfs_remove_link(&dev->kobj, "subsystem");
out_subsys:
    sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));
out_id:
    device_remove_attrs(bus, dev);
out_put:
    bus_put(dev->bus);
    return error;
}

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);
    }
}

int device_attach(struct device *dev)
{
    int ret = 0;

    device_lock(dev);          //锁住设备
    if (dev->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;
}

int device_bind_driver(struct device *dev)
{
    int ret;

    ret = driver_sysfs_add(dev);    
    if (!ret)
        driver_bound(dev);   //驱动绑定设备
    return ret;
}

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);   //初始化i结构体
    while ((drv = next_driver(&i)) && !error)   //遍历总线上的驱动
        error = fn(drv, data);                            //将驱动和设备进行匹配，这里的fn=__device_attach
    klist_iter_exit(&i);
    return error;
}

 

static int __device_attach(struct device_driver *drv, void *data)
{
    struct device *dev = data;

    if (!driver_match_device(drv, dev))     //现用总线上的match匹配函数进行低级匹配
        return 0;

    return driver_probe_device(drv, dev);   //在来高级匹配
}

 

static inline int driver_match_device(struct device_driver *drv,  struct device *dev)
{
    return drv->bus->match ? drv->bus->match(dev, drv) : 1;      //看到没，这里要调用总线上定义的match函数
}

 

int driver_probe_device(struct device_driver *drv, struct device *dev)
{
    int ret = 0;

    if (!device_is_registered(dev))  //设备是否注册
        return -ENODEV;

    pr_debug("bus: '%s': %s: matched device %s with driver %s/n",
         drv->bus->name, __func__, dev_name(dev), drv->name);

    pm_runtime_get_noresume(dev);
    pm_runtime_barrier(dev);
    ret = really_probe(dev, drv);  //调用真正的匹配
    pm_runtime_put_sync(dev);

    return ret;
}

 

static int really_probe(struct device *dev, struct device_driver *drv)
{
    int ret = 0;

    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 (driver_sysfs_add(dev)) {
        printk(KERN_ERR "%s: driver_sysfs_add(%s) failed/n",
            __func__, dev_name(dev));
        goto probe_failed;
    }

    if (dev->bus->probe) {         //现用总线上定义的probe函数尝试一下
        ret = dev->bus->probe(dev);
        if (ret)
            goto probe_failed;
    } else if (drv->probe) {       //如果不行，在用驱动上的probe尝试
        ret = drv->probe(dev);
        if (ret)
            goto probe_failed;
    }

    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;

probe_failed:
    devres_release_all(dev);
    driver_sysfs_remove(dev);
    dev->driver = NULL;

    if (ret != -ENODEV && ret != -ENXIO) {
        /* driver matched but the probe failed */
        printk(KERN_WARNING
               "%s: probe of %s failed with error %d/n",
               drv->name, dev_name(dev), ret);
    }
    /*
     * Ignore errors returned by ->probe so that the next driver can try
     * its luck.
     */
    ret = 0;
done:
    atomic_dec(&probe_count);
    wake_up(&probe_waitqueue);
    return ret;
}