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

最新推荐文章于 2021-05-07 09:17:33 发布

u010550992

最新推荐文章于 2021-05-07 09:17:33 发布

阅读量603

点赞数

分类专栏： driver

driver 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

//本文转载地址：http://blog.csdn.net/gdt_a20/article/details/6427331

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

三、device的注册

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

[cpp]view plaincopy 
   
 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:

[cpp]view plaincopy 
   
 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最后一部分的分析  ^_^ 
 */    