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

最新推荐文章于 2024-09-18 08:47:26 发布

angle_birds

最新推荐文章于 2024-09-18 08:47:26 发布

阅读量1.1k

点赞数

文章标签： linux struct class null list each

linux 专栏收录该内容

150 篇文章 0 订阅

订阅专栏

===============================
本文系本站原创,欢迎转载!
转载请注明出处:http://www.cnblogs.com/gdt-a20

===============================

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

三、device的注册

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

 1 struct device {
 2     struct device        *parent;
 3     struct device_private    *p;                                              //私有属性结构，重点
 4     struct kobject kobj;
 5     const char        *init_name; /* initial name of the device */
 6     struct device_type    *type;
 7     struct mutex        mutex;    /* mutex to synchronize calls to
 8                      * its driver.
 9 */
10     struct bus_type    *bus;        /* type of bus device is on */            //所在bus
11     struct device_driver *driver;    /* which driver has allocated this    //匹配的driver
12                        device */
13     void        *platform_data;    /* Platform specific data, device
14                        core doesn't touch it */
15     struct dev_pm_info    power;
16 #ifdef CONFIG_NUMA
17     int        numa_node;    /* NUMA node this device is close to */
18 #endif
19     u64        *dma_mask;    /* dma mask (if dma'able device) */
20     u64        coherent_dma_mask;/* Like dma_mask, but for
21                          alloc_coherent mappings as
22                          not all hardware supports
23                          64 bit addresses for consistent
24                          allocations such descriptors. */
25     struct device_dma_parameters *dma_parms;
26     struct list_head    dma_pools;    /* dma pools (if dma'ble) */
27     struct dma_coherent_mem    *dma_mem; /* internal for coherent mem
28                          override */
29     /* arch specific additions */
30     struct dev_archdata    archdata;
31 #ifdef CONFIG_OF
32     struct device_node    *of_node;
33 #endif
34     dev_t            devt;    /* dev_t, creates the sysfs "dev" */
35     spinlock_t        devres_lock;
36     struct list_head    devres_head;
37     struct klist_node    knode_class;
38     struct class        *class;
39     const struct attribute_group **groups;    /* optional groups */
40     void    (*release)(struct device *dev);
41 };
42 //重点看一下私有属性结构
43 struct device_private {
44     struct klist klist_children;             //子集结构
45     struct klist_node knode_parent;          //父级挂接点
46     struct klist_node knode_driver;          //driver挂接点
47     struct klist_node knode_bus;             //bus挂接点
48     void *driver_data;
49     struct device *device;                   //回指
50 };

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

  1 int device_register(struct device *dev)
  2 {
  3     device_initialize(dev);                //初始化dev
  4     return device_add(dev);                //添加dev
  5 }
  6 /******************************
  7 * 先看一下device_initialize(dev)
  8 ******************************/
  9 void device_initialize(struct device *dev)
 10 {
 11     dev->kobj.kset = devices_kset;                  //可见device和bus都有其起始的kset，而driver没有
 12     kobject_init(&dev->kobj, &device_ktype);        //初始化这个kobj并建立层次关系以及属性文件，此时
 13     INIT_LIST_HEAD(&dev->dma_pools);                //是放到了总的device文件目录下面
 14     mutex_init(&dev->mutex);
 15     lockdep_set_novalidate_class(&dev->mutex);
 16     spin_lock_init(&dev->devres_lock);
 17     INIT_LIST_HEAD(&dev->devres_head);
 18     device_pm_init(dev);
 19     set_dev_node(dev, -1);
 20 }
 21 /******************************
 22 * 再来看一下device_add(dev)
 23 ******************************/
 24 int device_add(struct device *dev)
 25 {
 26     struct device *parent = NULL;
 27     struct class_interface *class_intf;
 28     int error = -EINVAL;
 29     dev = get_device(dev);
 30     if (!dev)
 31         goto done;
 32     if (!dev->p) {
 33         error = device_private_init(dev);                        //初始化dev的私有成员，及其链表操作函数
 34         if (error)
 35             goto done;
 36     }
 37     /*
 38      * for statically allocated devices, which should all be converted
 39      * some day, we need to initialize the name. We prevent reading back
 40      * the name, and force the use of dev_name()
 41 */
 42     if (dev->init_name) {
 43         dev_set_name(dev, "%s", dev->init_name);                 //设置名字，给kobj
 44         dev->init_name = NULL;
 45     }
 46     if (!dev_name(dev)) {                                         //名字为空出错退出
 47         error = -EINVAL;
 48         goto name_error;
 49     }
 50     pr_debug("device: '%s': %s/n", dev_name(dev), __func__);
 51     parent = get_device(dev->parent);                          //返回父节点，如果有返回，没有返回NULL
 52     setup_parent(dev, parent);                   
 53     /* use parent numa_node */
 54     if (parent)
 55         set_dev_node(dev, dev_to_node(parent));
 56     /* first, register with generic layer. */
 57     /* we require the name to be set before, and pass NULL */
 58     error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);   //初始化kobj与其父节点的连接
 59     if (error)
 60         goto Error;
 61     /* notify platform of device entry */
 62     if (platform_notify)
 63         platform_notify(dev);
 64     error = device_create_file(dev, &uevent_attr);             //产生属性文件
 65     if (error)
 66         goto attrError;
 67     if (MAJOR(dev->devt)) {
 68         error = device_create_file(dev, &devt_attr);             //在sys下产生dev属性文件
 69         if (error)
 70             goto ueventattrError;
 71         error = device_create_sys_dev_entry(dev);
 72         if (error)
 73             goto devtattrError;
 74         devtmpfs_create_node(dev);                               
 75     }
 76     error = device_add_class_symlinks(dev);                    
 77     if (error)
 78         goto SymlinkError;
 79     error = device_add_attrs(dev);                             //增加属性文件
 80     if (error)
 81         goto AttrsError;
 82     error = bus_add_device(dev);                               //把device的bus节点挂到bus的设备节点上
 83     if (error)
 84         goto BusError;
 85     error = dpm_sysfs_add(dev);
 86     if (error)
 87         goto DPMError;
 88     device_pm_add(dev);
 89     /* Notify clients of device addition.  This call must come
 90      * after dpm_sysf_add() and before kobject_uevent().
 91 */
 92     if (dev->bus)
 93         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
 94                          BUS_NOTIFY_ADD_DEVICE, dev);
 95     kobject_uevent(&dev->kobj, KOBJ_ADD);
 96     bus_probe_device(dev);                                    //匹配driver
 97     if (parent)
 98         klist_add_tail(&dev->p->knode_parent,                 //把该设备的节点挂到其父节点的链表
 99                    &parent->p->klist_children);
100     if (dev->class) {
101         mutex_lock(&dev->class->p->class_mutex);
102         /* tie the class to the device */
103         klist_add_tail(&dev->knode_class,
104                    &dev->class->p->class_devices);
105         /* notify any interfaces that the device is here */
106         list_for_each_entry(class_intf,
107                     &dev->class->p->class_interfaces, node)
108             if (class_intf->add_dev)
109                 class_intf->add_dev(dev, class_intf);
110         mutex_unlock(&dev->class->p->class_mutex);
111     }
112 done:
113     put_device(dev);
114     return error;
115  DPMError:
116     bus_remove_device(dev);
117  BusError:
118     device_remove_attrs(dev);
119  AttrsError:
120     device_remove_class_symlinks(dev);
121  SymlinkError:
122     if (MAJOR(dev->devt))
123         devtmpfs_delete_node(dev);
124     if (MAJOR(dev->devt))
125         device_remove_sys_dev_entry(dev);
126  devtattrError:
127     if (MAJOR(dev->devt))
128         device_remove_file(dev, &devt_attr);
129  ueventattrError:
130     device_remove_file(dev, &uevent_attr);
131  attrError:
132     kobject_uevent(&dev->kobj, KOBJ_REMOVE);
133     kobject_del(&dev->kobj);
134  Error:
135     cleanup_device_parent(dev);
136     if (parent)
137         put_device(parent);
138 name_error:
139     kfree(dev->p);
140     dev->p = NULL;
141     goto done;
142 }
143 /***********************************************
144 * 重点看一下bus_probe_device匹配driver以及初始化过程
145 ***********************************************/
146 void bus_probe_device(struct device *dev)
147 {
148     struct bus_type *bus = dev->bus;
149     int ret;
150     if (bus && bus->p->drivers_autoprobe) {         //设置了自动匹配初始化那么就开始匹配
151         ret = device_attach(dev);
152         WARN_ON(ret < 0);
153     }
154 }
155 /******************
156 * 继续device_attach
157 ******************/
158 int device_attach(struct device *dev)
159 {
160     int ret = 0;
161     device_lock(dev);
162     if (dev->driver) {                            //默认指定了driver就直接绑定
163         ret = device_bind_driver(dev);
164         if (ret == 0)
165             ret = 1;
166         else {
167             dev->driver = NULL;
168             ret = 0;
169         }
170     } else {                                      //没有指定就进行遍历匹配
171         pm_runtime_get_noresume(dev);
172         ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
173         pm_runtime_put_sync(dev);
174     }
175     device_unlock(dev);
176     return ret;
177 }
178 /**************************
179 * 再来看device_bind_driver分支
180 **************************/
181 int device_bind_driver(struct device *dev)
182 {
183     int ret;
184     ret = driver_sysfs_add(dev);
185     if (!ret)
186         driver_bound(dev);              //主要是完成了将私有成员的driver节点挂到
187     return ret;                         //了driver的设备链表
188 }
189 /**************************
190 * 先看bus_for_each_drv分支
191 **************************/
192 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
193              void *data, int (*fn)(struct device_driver *, void *))
194 {
195     struct klist_iter i;
196     struct device_driver *drv;
197     int error = 0;
198     if (!bus)
199         return -EINVAL;
200     klist_iter_init_node(&bus->p->klist_drivers, &i,           //和driver遍历device类似，从头开始遍历bus的driver链表
201                  start ? &start->p->knode_bus : NULL);         //发现一个driver就调用fn即__device_attach进行匹配
202     while ((drv = next_driver(&i)) && !error)
203         error = fn(drv, data);
204     klist_iter_exit(&i);
205     return error;
206 }
207 /*********************************
208 * 最后来看一下__device_attach这个函数
209 *********************************/
210 static int __device_attach(struct device_driver *drv, void *data)
211 {
212     struct device *dev = data;
213     if (!driver_match_device(drv, dev))    
214         return 0;
215     return driver_probe_device(drv, dev);
216 }
217 /*
218   对比driver的注册最后调用的__driver_attach可以发现其实质是一样的，都最后归宿到了
219   这driver_match_device，driver_probe_device两个函数,本质参数的和谐做到了通用
220   性在这里就不继续分析了，不是很清楚的可以看前一篇文章driver最后一部分的分析  ^_^
221 */