Linux kernel驱动相关抽象概念及其实现 之“bus，device，driver”
bus，device，driver三个很重要的概念贯穿Linux内核驱动架构，特转载一篇博文：
（转载自http://blog.csdn.net/gdt_a20/article/details/6425894）
内核的开发者将总线，设备，驱动这三者用软件思想抽象了出来，巧妙的建立了其间的关系，使之更形象化。结合前面所学的知识，总的来说其三者间的关系为bus有两条链表，分别用于挂接设备和驱动，指定了其自身bus的device或者driver最后都会分别连接到对应bus的这两条链表上，而总线又有其始端，为bus_kset，一个driver可以对应于几个设备，因此driver同样有其设备链表，用于挂接可以操作的设备，其自身也有bus挂接点，用于将自身挂接到对应bus（每个driver只属于一条总线），而对于device，一个设备只属于一条总线，只能有一个driver与其对应，因此对于device，都是单一的，一个driver挂接点，一个bus挂接点，device与bus相同的是都有始端，device为devices_kset，因此device的注册同时会出现在对应的bus目录和device总目录下。好了，下面就以源码为例分别分析一下bus，device，driver的注册过程。
一、bus的注册
bus的注册比较简单，首先来看一下bus的结构：
1 struct bus_type { 2 const char *name; //名字 3 struct bus_attribute *bus_attrs; //bus属性集 4 struct device_attribute *dev_attrs; //device属性集 5 struct driver_attribute *drv_attrs; //driver属性集 6 int (*match)(struct device *dev, struct device_driver *drv); 7 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 8 int (*probe)(struct device *dev); 9 int (*remove)(struct device *dev); 10 void (*shutdown)(struct device *dev); 11 int (*suspend)(struct device *dev, pm_message_t state); 12 int (*resume)(struct device *dev); 13 const struct dev_pm_ops *pm; 14 struct bus_type_private *p; //bus的私有成员 15 }; 16 //其中重点看一下私有成员结构体： 17 struct bus_type_private { 18 struct kset subsys; //bus内嵌的kset，代表其自身 19 struct kset *drivers_kset; 20 struct kset *devices_kset; 21 struct klist klist_devices; //包含devices链表及其操作函数 22 struct klist klist_drivers; //driver链表及其操作函数 23 struct blocking_notifier_head bus_notifier; 24 unsigned int drivers_autoprobe:1; //匹配成功自动初始化标志 25 struct bus_type *bus; 26 };
无论是bus，driver，还是device其本身特征都放在私有成员里，其注册时，都会申请并填充这个结构体，下面具体分析一下bus的注册流程，从bus_register开始：
1 int bus_register(struct bus_type *bus) 2 { 3 int retval; 4 struct bus_type_private *priv; 5 priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL); //进入时bus_type->bus_type_private为NULL 6 if (!priv) //该函数主要是对其的设置 7 return -ENOMEM; 8 priv->bus = bus; //私有成员的bus回指该bus 9 bus->p = priv; //初始化bus->p,即其私有属性 10 BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier); 11 retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name); //设置该bus的名字，bus是kset的封装 12 if (retval) 13 goto out; 14 //bus_kset即为所有bus的总起始端点 15 //围绕bus内嵌的kset初始化，和kset的初始化时围绕 16 priv->subsys.kobj.kset = bus_kset; //kobj相似，没有parent时，就会用kset的kobj，此处即是 17 priv->subsys.kobj.ktype = &bus_ktype; //属性操作级别统一为bus_ktype 18 priv->drivers_autoprobe = 1; //设置该标志，当有driver注册时，会自动匹配devices 19 //上的设备并用probe初始化， 20 //当有device注册时也同样找到 driver并会初始化 21 retval = kset_register(&priv->subsys); //注册kset，创建目录结构，以及层次关系 22 if (retval) 23 goto out; 24 retval = bus_create_file(bus, &bus_attr_uevent); //当前bus目录下生成bus_attr_uevent属性文件 25 if (retval) 26 goto bus_uevent_fail; 27 priv->devices_kset = kset_create_and_add("devices", NULL, //初始化bus目录下的devices目录，里面级联了该bus下设备， 28 &priv->subsys.kobj); //仍然以kset为原型 29 if (!priv->devices_kset) { 30 retval = -ENOMEM; 31 goto bus_devices_fail; 32 } 33 priv->drivers_kset = kset_create_and_add("drivers", NULL, //初始化bus目录下的drivers目录，里面级联了该bus下设备的driver 34 &priv->subsys.kobj); 35 if (!priv->drivers_kset) { 36 retval = -ENOMEM; 37 goto bus_drivers_fail; 38 } 39 klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put); //初始化klist_devices里的操作函数成员 40 klist_init(&priv->klist_drivers, NULL, NULL); //klist_drivers里的操作函数置空 41 retval = add_probe_files(bus); //增加bus_attr_drivers_probe和bus_attr_drivers_autoprobe 42 if (retval) //属性文件 43 goto bus_probe_files_fail; 44 retval = bus_add_attrs(bus); //增加默认的属性文件 45 if (retval) 46 goto bus_attrs_fail; 47 pr_debug("bus: '%s': registered/n", bus->name); 48 return 0; 49 bus_attrs_fail: //以下为错误处理 50 remove_probe_files(bus); 51 bus_probe_files_fail: 52 kset_unregister(bus->p->drivers_kset); 53 bus_drivers_fail: 54 kset_unregister(bus->p->devices_kset); 55 bus_devices_fail: 56 bus_remove_file(bus, &bus_attr_uevent); 57 bus_uevent_fail: 58 kset_unregister(&bus->p->subsys); 59 out: 60 kfree(bus->p); 61 bus->p = NULL; 62 return retval; 63 }
由此可见，bus又是kset的封装，bus_register主要完成了其私有成员bus_type_private的初始化，并初始化了其下的两个目录devices和drivers，及其属性文件，bus有个自己的根目录也就是bus有个起始端点，是bus_kset，经过此番的注册，bus目录下将会出现我们注册的bus，并且其下会有device和driver两个子目录，代表它下面的driver和device链表。
二、driver的注册
下面看一下driver是怎么和bus关联起来的，首先看下driver的结构：
1 struct device_driver { 2 const char *name; //名字 3 struct bus_type *bus; //其所在的bus 4 struct module *owner; 5 const char *mod_name; /* used for built-in modules */ 6 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */ 7 #if defined(CONFIG_OF) 8 const struct of_device_id *of_match_table; 9 #endif 10 int (*probe) (struct device *dev); //匹配成功时可能会调用到的函数 11 int (*remove) (struct device *dev); 12 void (*shutdown) (struct device *dev); 13 int (*suspend) (struct device *dev, pm_message_t state); 14 int (*resume) (struct device *dev); 15 const struct attribute_group **groups; 16 const struct dev_pm_ops *pm; 17 struct driver_private *p; //私有成员，表示driver 18 }; 19 //重点看下driver的私有成员 20 struct driver_private { 21 struct kobject kobj; //代表driver自身 22 struct klist klist_devices; //可以操控的设备链表 23 struct klist_node knode_bus; //挂接到bus的节点 24 struct module_kobject *mkobj; //模块相关 25 struct device_driver *driver; //回指该driver 26 };
如同bus一样，重点的仍是可以代表其自身的私有属性，下面具体看一下driver的注册过程，从driver_register开始：
1 int driver_register(struct device_driver *drv) 2 { 3 int ret; 4 struct device_driver *other; 5 BUG_ON(!drv->bus->p); 6 if ((drv->bus->probe && drv->probe) || //driver和bus的同名操作函数如果同时存在，会出现警告 7 (drv->bus->remove && drv->remove) || //并且会优先选用bus的 8 (drv->bus->shutdown && drv->shutdown)) 9 printk(KERN_WARNING "Driver '%s' needs updating - please use " 10 "bus_type methods/n", drv->name); 11 other = driver_find(drv->name, drv->bus); //进入bus的driver链表，确认该driver是否已经注册 12 if (other) { 13 put_driver(other); //找到了再减少引用计数，并且报错退出 14 printk(KERN_ERR "Error: Driver '%s' is already registered, " 15 "aborting.../n", drv->name); 16 return -EBUSY; 17 } 18 ret = bus_add_driver(drv); //如果没有注册，那么把该driver加入所在bus 19 if (ret) 20 return ret; 21 ret = driver_add_groups(drv, drv->groups); 22 if (ret) 23 bus_remove_driver(drv); 24 return ret; 25 } 26 /**************************************************** 27 × 跟踪一下driver_find(drv->name, drv->bus) 28 ****************************************************/ 29 struct device_driver *driver_find(const char *name, struct bus_type *bus) 30 { 31 struct kobject *k = kset_find_obj(bus->p->drivers_kset, name); //bus->p->drivers_kset代表bus下 32 struct driver_private *priv; //的driver目录，此处会遍历bus的 33 //driver链表，通过driver内嵌的 34 if (k) { //kobj名字比较 35 priv = to_driver(k); 36 return priv->driver; //如果找到同名的kobj那么返回该driver 37 } 38 return NULL; 39 } 40 //看一下kset_find_obj吧: 41 struct kobject *kset_find_obj(struct kset *kset, const char *name) 42 { 43 struct kobject *k; 44 struct kobject *ret = NULL; 45 spin_lock(&kset->list_lock); 46 list_for_each_entry(k, &kset->list, entry) { //遍历bus下的driver链表，如果 47 if (kobject_name(k) && !strcmp(kobject_name(k), name)) { //找到那么返回找到的kobj，并且把 48 ret = kobject_get(k); //该driver的kobj引用计数+1 49 break; 50 } 51 } 52 spin_unlock(&kset->list_lock); 53 return ret; 54 } 55 /************************************************ 56 × 再来跟踪一下driver_register里面的另外一个函数 57 × bus_add_driver(drv) 58 ************************************************/ 59 int bus_add_driver(struct device_driver *drv) 60 { 61 struct bus_type *bus; 62 struct driver_private *priv; 63 int error = 0; 64 bus = bus_get(drv->bus); //取得其所在bus的指针 65 if (!bus) 66 return -EINVAL; 67 pr_debug("bus: '%s': add driver %s/n", bus->name, drv->name); //开始初始化这个driver的私有成员， 68 //和bus类似 69 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 70 if (!priv) { 71 error = -ENOMEM; 72 goto out_put_bus; 73 } 74 klist_init(&priv->klist_devices, NULL, NULL); //设备操作函数清空，设备链表初始化 75 priv->driver = drv; 76 drv->p = priv; 77 priv->kobj.kset = bus->p->drivers_kset; //kset指定到bus下面 78 error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL, //建立层次结构和属性文件 79 "%s", drv->name); 80 if (error) 81 goto out_unregister; 82 if (drv->bus->p->drivers_autoprobe) { //bus的自动匹配如果设置为真， 83 error = driver_attach(drv); //那么到bus的devices上去匹配设备 84 if (error) 85 goto out_unregister; 86 } 87 klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers); //把driver挂接到bus的driver链表 88 module_add_driver(drv->owner, drv); 89 error = driver_create_file(drv, &driver_attr_uevent); //以下添加该driver相关属性文件 90 if (error) { 91 printk(KERN_ERR "%s: uevent attr (%s) failed/n", 92 __func__, drv->name); 93 } 94 error = driver_add_attrs(bus, drv); 95 if (error) { 96 /* How the hell do we get out of this pickle? Give up */ 97 printk(KERN_ERR "%s: driver_add_attrs(%s) failed/n", 98 __func__, drv->name); 99 } 100 if (!drv->suppress_bind_attrs) { 101 error = add_bind_files(drv); 102 if (error) { 103 /* Ditto */ 104 printk(KERN_ERR "%s: add_bind_files(%s) failed/n", 105 __func__, drv->name); 106 } 107 } 108 kobject_uevent(&priv->kobj, KOBJ_ADD); 109 return 0; 110 out_unregister: 111 kobject_put(&priv->kobj); 112 kfree(drv->p); 113 drv->p = NULL; 114 out_put_bus: 115 bus_put(bus); 116 return error; 117 } 118 /**************************************************************** 119 × 接下来就剩下最终要的匹配函数driver_attach(drv)了，我们来看一下： 120 ****************************************************************/ 121 int driver_attach(struct device_driver *drv) //遍历bus的设备链表找到 122 { //合适的设备就调用__driver_attach， 123 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); //NULL表示从头开始遍历 124 } 125 //============ 126 int bus_for_each_dev(struct bus_type *bus, struct device *start, 127 void *data, int (*fn)(struct device *, void *)) 128 { 129 struct klist_iter i; 130 struct device *dev; 131 int error = 0; 132 if (!bus) 133 return -EINVAL; 134 klist_iter_init_node(&bus->p->klist_devices, &i, //进入bus的devices链表 135 (start ? &start->p->knode_bus : NULL)); 136 while ((dev = next_device(&i)) && !error) //设备存在则调用fn即__driver_attach 137 error = fn(dev, data); //进行匹配 138 klist_iter_exit(&i); 139 return error; 140 } 141 /********************************************* 142 × 接着看一下__driver_attach这个函数 143 *********************************************/ 144 static int __driver_attach(struct device *dev, void *data) 145 { 146 struct device_driver *drv = data; 147 if (!driver_match_device(drv, dev)) //进行匹配 148 return 0; 149 if (dev->parent) /* Needed for USB */ 150 device_lock(dev->parent); 151 device_lock(dev); 152 if (!dev->driver) //如果设备没有指定driver 153 driver_probe_device(drv, dev); //那么需要初始化匹配到的这个设备 154 device_unlock(dev); 155 if (dev->parent) 156 device_unlock(dev->parent); 157 return 0; 158 } 159 /********************************************* 160 × 又遇到两个分支，囧，先看一下driver_match_device 161 *********************************************/ 162 static inline int driver_match_device(struct device_driver *drv, //bus的match存在就用bus的 163 struct device *dev) //，否则就直接匹配成功... 164 { //match通常实现为首先扫描 165 return drv->bus->match ? drv->bus->match(dev, drv) : 1; //driver支持的id设备表，如果 166 } //为NULL就用名字进行匹配 167 /************************************ 168 × 再来看一下driver_probe_device这个函数 169 ************************************/ 170 int driver_probe_device(struct device_driver *drv, struct device *dev) 171 { 172 int ret = 0; 173 if (!device_is_registered(dev)) //判断该设备是否已经注册 174 return -ENODEV; 175 pr_debug("bus: '%s': %s: matched device %s with driver %s/n", 176 drv->bus->name, __func__, dev_name(dev), drv->name); 177 pm_runtime_get_noresume(dev); 178 pm_runtime_barrier(dev); 179 ret = really_probe(dev, drv); //调用really_probe 180 pm_runtime_put_sync(dev); 181 return ret; 182 } 183 /************************************ 184 × 看一下device_is_registered 185 ************************************/ 186 static inline int device_is_registered(struct device *dev) 187 { 188 return dev->kobj.state_in_sysfs; //在sysfs中表示已经注册 189 } 190 /************************************ 191 × 再看really_probe 192 ************************************/ 193 static int really_probe(struct device *dev, struct device_driver *drv) 194 { 195 int ret = 0; 196 atomic_inc(&probe_count); 197 pr_debug("bus: '%s': %s: probing driver %s with device %s/n", 198 drv->bus->name, __func__, drv->name, dev_name(dev)); 199 WARN_ON(!list_empty(&dev->devres_head)); 200 dev->driver = drv; //device的driver初始化成该driver 201 if (driver_sysfs_add(dev)) { 202 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed/n", 203 __func__, dev_name(dev)); 204 goto probe_failed; 205 } 206 //利用probe初始化设备 207 if (dev->bus->probe) { //如果bus的probe存在就用bus的， 208 ret = dev->bus->probe(dev); //如果bus的不存在driver的存在 209 if (ret) //再用driver的 210 goto probe_failed; 211 } else if (drv->probe) { 212 ret = drv->probe(dev); 213 if (ret) 214 goto probe_failed; 215 } 216 driver_bound(dev); //调用driver_bound进行绑定 217 ret = 1; 218 pr_debug("bus: '%s': %s: bound device %s to driver %s/n", 219 drv->bus->name, __func__, dev_name(dev), drv->name); 220 goto done; 221 probe_failed: 222 devres_release_all(dev); 223 driver_sysfs_remove(dev); 224 dev->driver = NULL; 225 if (ret != -ENODEV && ret != -ENXIO) { 226 /* driver matched but the probe failed */ 227 printk(KERN_WARNING 228 "%s: probe of %s failed with error %d/n", 229 drv->name, dev_name(dev), ret); 230 } 231 /* 232 * Ignore errors returned by ->probe so that the next driver can try 233 * its luck. 234 */ 235 ret = 0; 236 done: 237 atomic_dec(&probe_count); 238 wake_up(&probe_waitqueue); 239 return ret; 240 } 241 /********************************** 242 * 最后跟一下driver_bound(dev)这个函数 243 **********************************/ 244 static void driver_bound(struct device *dev) 245 { 246 if (klist_node_attached(&dev->p->knode_driver)) { //判断是否已经绑定 247 printk(KERN_WARNING "%s: device %s already bound/n", 248 __func__, kobject_name(&dev->kobj)); 249 return; 250 } 251 pr_debug("driver: '%s': %s: bound to device '%s'/n", dev_name(dev), 252 __func__, dev->driver->name); 253 klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices); //将设备添加 254 //到driver的链表 255 if (dev->bus) 256 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 257 BUS_NOTIFY_BOUND_DRIVER, dev); 258 } 259 //all end
总结一下，driver的注册，主要涉及将自身挂接到bus的driver链表，并将匹配到的设备加入自己的device链表，并且将匹配到的device的driver成员初始化为该driver，私有属性的driver节点也挂到driver的设备链表下，其中匹配函数是利用利用bus的match函数，该函数通常判断如果driver有id表，就查表匹配，如果没有就用driver和device名字匹配。当匹配成功后如果自动初始化标志允许则调用初始化函数probe，bus的probe优先级始终高于driver的，而一般bus的probe最终也是调用bus-->dev-->driver的probe。另外注意一点driver是没有总的起始端点的，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 */
以上便是device的注册，可以发现device和driver围绕着bus最后有种殊途同归的感觉，下面结合driver的流程给出一个框图
以便更明确其间的流程：
