linux内核学习设备模型之第二层device_register

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

来自: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;
    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(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;
}

相关文章推荐

linux内核学习(21)设备模型之第二层device_register

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

linux内核学习(22)设备模型之第二层bus_register

 注册总线。来自:dirvers/base/bus.c:int bus_register(struct bus_type *bus){    int retval;    struct bus_ty...

linux内核学习(23)设备模型之第二层driver_register

终于说到最后一个注册了,今天也是年末了,可是我依然战斗在一线的感觉!说完这个,我也得放松一会儿。学习内核也接近大半个月了,收获颇多,不过还有太多东西需要我在继续努力了,虽然博客的流量不是很理想,表明关...

linux内核学习设备模型之第二层driver_register

来自:drivers/base/driver.c: int driver_register(struct device_driver *drv) {     int ret;     stru...

linux内核学习 设备模型之第二层bus_register

注册总线。 来自:dirvers/base/bus.c: int bus_register(struct bus_type *bus) { int retval; struct b...

linux内核学习(20)设备模型第二层之一

设备模型第二层也是非常重要的一层,为各种设备打好了基础,由于我之前在分析的过程中发现,如果每个细节都一起抠,可能很难将设备模型的概貌理解清楚,因此,我将采用从整体到局部的方法分析设备模型第二层,还是因...

linux内核学习设备模型第二层之一

设备模型第二层也是非常重要的一层,为各种设备打好了基础,由于我之前在分析的过程中发现,如果每个细节都一起抠,可能很难将设备模型的概貌理解清楚,因此,我将采用从整体到局部的方法分析设备模型第二层,还是因...

Linux内核学习设备模型第一层

设备模型第一层:   一、重要结构体概述:   1、kobject对象: struct kobject { const char *name; //名字 struct list_head...

linux内核学习(16)设备模型第一层

设备模型第一层: 一、重要结构体概述: 1、kobject对象:struct kobject { const char *name; //名字struct list_head entry; //作为父...

linux内核学习(18)设备模型之第一层sysfs关系图

很就没跟大家聊天了,上次聊还是分析完内核启动全过程的事情。这几次发的都是我目前学习设备模型的心得,把它都总结了起来,然后放到博客中供大家学习与探讨。如果你还记得当时分析到了driver_init()这...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:linux内核学习设备模型之第二层device_register
举报原因:
原因补充:

(最多只允许输入30个字)