设备
2.设备
379struct device {
380 struct device *parent;
381
382 struct device_private *p;
383
384 struct kobject kobj;
385 const char *init_name; /* initial name of thedevice */
386 struct device_type *type;
387
388 struct semaphore sem; /* semaphore to synchronizecalls to
389 * its driver.
390 */
391
392 struct bus_type *bus; /* type of bus device is on*/
393 struct device_driver *driver; /* which driver has allocatedthis
394 device */
395 void *platform_data; /* Platform specific data,device
396 core doesn't touch it */
397 struct dev_pm_info power;
398
399#ifdef CONFIG_NUMA
400 int numa_node; /* NUMA node this device isclose to */
401#endif
402 u64 *dma_mask; /* dma mask (if dma'abledevice) */
403 u64 coherent_dma_mask;/* Like dma_mask, but for
404 alloc_coherent mappingsas
405 not all hardwaresupports
406 64 bit addresses forconsistent
407 allocations suchdescriptors. */
408
409 struct device_dma_parameters *dma_parms;
410
411 struct list_head dma_pools; /* dma pools (ifdma'ble) */
412
413 struct dma_coherent_mem *dma_mem; /* internal for coherentmem
414 override */
415 /* arch specific additions */
416 struct dev_archdata archdata;
417
418 dev_t devt; /* dev_t, creates the sysfs"dev" */
419
420 spinlock_t devres_lock;
421 struct list_head devres_head;
422
423 struct klist_node knode_class;
424 struct class *class;
425 const struct attribute_group **groups; /* optional groups */
426
427 void (*release)(struct device *dev);
428};
parent代表设备的父设备，bus一看就知道代表设备挂载哪条总线上，driver代表设备的驱动。设备也有个私有数据结构。
66/**
67 * struct device_private - structure to hold the private to thedriver core portions of the device structure.
68 *
69 * @klist_children - klist containing all children of this device
70 * @knode_parent - node in sibling list
71 * @knode_driver - node in driver list
72 * @knode_bus - node in bus list
73 * @driver_data - private pointer for driver specific info. Willturn into a
74 * list soon.
75 * @device - pointer back to the struct class that this structure is
76 * associated with.
77 *
78 * Nothing outside of the driver core should ever touch these fields.
79 */
80struct device_private {
81 struct klist klist_children;
82 struct klist_node knode_parent;
83 struct klist_node knode_driver;
84 struct klist_node knode_bus;
85 void *driver_data;
86 struct device *device;
87};
klist_children代表子设备链表，然后是三个链表节点，分别用于父设备的子设备链表、驱动的设备链表和总线的设备链表。来看设备的注册函数
1016/**
1017 * device_register - register a device with the system.
1018 * @dev: pointer to the device structure
1019 *
1020 * This happens in two clean steps - initialize the device
1021 * and add it to the system. The two steps can be called
1022 * separately, but this is the easiest and most common.
1023 * I.e. you should only call the two helpers separately if
1024 * have a clearly defined need to use and refcount the device
1025 * before it is added to the hierarchy.
1026 *
1027 * NOTE: _Never_ directly free @dev after calling this function, even
1028 * if it returned an error! Always use put_device() to give up the
1029 * reference initialized in this function instead.
1030 */
1031int device_register(struct device *dev)
1032{
1033 device_initialize(dev);
1034 return device_add(dev);
1035}
一个一个的看，先看device_initialize
543/**
544 * device_initialize - init device structure.
545 * @dev: device.
546 *
547 * This prepares the device for use by other layers by initializing
548 * its fields.
549 * It is the first half of device_register(), if called by
550 * that function, though it can also be called separately, so one
551 * may use @dev's fields. In particular, get_device()/put_device()
552 * may be used for reference counting of @dev after calling this
553 * function.
554 *
555 * NOTE: Use put_device() to give up your reference instead offreeing
556 * @dev directly once you have called this function.
557 */
558void device_initialize(struct device *dev)
559{
560 dev->kobj.kset = devices_kset;
561 kobject_init(&dev->kobj, &device_ktype);
562 INIT_LIST_HEAD(&dev->dma_pools);
563 init_MUTEX(&dev->sem);
564 spin_lock_init(&dev->devres_lock);
565 INIT_LIST_HEAD(&dev->devres_head);
566 device_init_wakeup(dev, 0);
567 device_pm_init(dev);
568 set_dev_node(dev, -1);
569}
就是对设备做了一些初始化，至于初始化了什么东西，这里就不细说了。
867/**
868 * device_add - add device to device hierarchy.
869 * @dev: device.
870 *
871 * This is part 2 of device_register(), though may be called
872 * separately _iff_ device_initialize() has been called separately.
873 *
874 * This adds @dev to the kobject hierarchy via kobject_add(), adds it
875 * to the global and sibling lists for the device, then
876 * adds it to the other relevant subsystems of the driver model.
877 *
878 * NOTE: _Never_ directly free @dev after calling this function, even
879 * if it returned an error! Always use put_device() to give up your
880 * reference instead.
881 */
882int device_add(struct device *dev)
883{
884 struct device *parent = NULL;
885 struct class_interface *class_intf;
886 int error = -EINVAL;
887
888 dev = get_device(dev);
889 if (!dev)
890 goto done;
891
892 if (!dev->p) {
893 error = device_private_init(dev);
894 if (error)
895 goto done;
896 }
897
898 /*
899 * for statically allocated devices, which should all beconverted
900 * some day, we need to initialize the name. We preventreading back
901 * the name, and force the use of dev_name()
902 */
903 if (dev->init_name) {
904 dev_set_name(dev, "%s", dev->init_name);
905 dev->init_name = NULL;
906 }
907
908 if (!dev_name(dev))
909 goto name_error;
910
911 pr_debug("device: '%s': %s\n", dev_name(dev),__func__);
912
913 parent = get_device(dev->parent);
914 setup_parent(dev, parent);
915
916 /* use parent numa_node */
917 if (parent)
918 set_dev_node(dev, dev_to_node(parent));
919
920 /* first, register with generic layer. */
921 /* we require the name to be set before, and pass NULL */
922 error = kobject_add(&dev->kobj, dev->kobj.parent,NULL);
923 if (error)
924 goto Error;
925
926 /* notify platform of device entry */
927 if (platform_notify)
928 platform_notify(dev);
929
930 error = device_create_file(dev, &uevent_attr);
931 if (error)
932 goto attrError;
933
934 if (MAJOR(dev->devt)) {
935 error = device_create_file(dev, &devt_attr);
936 if (error)
937 goto ueventattrError;
938
939 error = device_create_sys_dev_entry(dev);
940 if (error)
941 goto devtattrError;
942
943 devtmpfs_create_node(dev);
944 }
945
946 error = device_add_class_symlinks(dev);
947 if (error)
948 goto SymlinkError;
949 error = device_add_attrs(dev);
950 if (error)
951 goto AttrsError;
952 error = bus_add_device(dev);
953 if (error)
954 goto BusError;
955 error = dpm_sysfs_add(dev);
956 if (error)
957 goto DPMError;
958 device_pm_add(dev);
959
960 /* Notify clients of device addition. This call must come
961 * after dpm_sysf_add() and before kobject_uevent().
962 */
963 if (dev->bus)
964 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
965 BUS_NOTIFY_ADD_DEVICE,dev);
966
967 kobject_uevent(&dev->kobj, KOBJ_ADD);
968 bus_probe_device(dev);
969 if (parent)
970 klist_add_tail(&dev->p->knode_parent,
971 &parent->p->klist_children);
972
973 if (dev->class) {
974 mutex_lock(&dev->class->p->class_mutex);
975 /* tie the class to the device */
976 klist_add_tail(&dev->knode_class,
977 &dev->class->p->class_devices);
978
979 /* notify any interfaces that the device is here */
980 list_for_each_entry(class_intf,
981 &dev->class->p->class_interfaces,node)
982 if (class_intf->add_dev)
983 class_intf->add_dev(dev,class_intf);
984 mutex_unlock(&dev->class->p->class_mutex);
985 }
986done:
987 put_device(dev);
988 return error;
989 DPMError:
990 bus_remove_device(dev);
991 BusError:
992 device_remove_attrs(dev);
993 AttrsError:
994 device_remove_class_symlinks(dev);
995 SymlinkError:
996 if (MAJOR(dev->devt))
997 device_remove_sys_dev_entry(dev);
998 devtattrError:
999 if (MAJOR(dev->devt))
1000 device_remove_file(dev, &devt_attr);
1001 ueventattrError:
1002 device_remove_file(dev, &uevent_attr);
1003 attrError:
1004 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1005 kobject_del(&dev->kobj);
1006 Error:
1007 cleanup_device_parent(dev);
1008 if (parent)
1009 put_device(parent);
1010name_error:
1011 kfree(dev->p);
1012 dev->p = NULL;
1013 goto done;
1014}
这个函数有点吓人，还是同以前一样，抓住主要的看就行了，来看两个函数，bus_add_device和bus_probe_device
458/**
459 * bus_add_device - add device to bus
460 * @dev: device being added
461 *
462 * - Add device's bus attributes.
463 * - Create links to device's bus.
464 * - Add the device to its bus's list of devices.
465 */
466int bus_add_device(struct device *dev)
467{
468 struct bus_type *bus = bus_get(dev->bus);
469 int error = 0;
470
471 if (bus) {
472 pr_debug("bus: '%s': add device %s\n",bus->name, dev_name(dev));
473 error = device_add_attrs(bus, dev);
474 if (error)
475 goto out_put;
476 error =sysfs_create_link(&bus->p->devices_kset->kobj,
477 &dev->kobj,dev_name(dev));
478 if (error)
479 goto out_id;
480 error = sysfs_create_link(&dev->kobj,
481 &dev->bus->p->subsys.kobj,"subsystem");
482 if (error)
483 goto out_subsys;
484 error = make_deprecated_bus_links(dev);
485 if (error)
486 goto out_deprecated;
487 klist_add_tail(&dev->p->knode_bus,&bus->p->klist_devices);
488 }
489 return 0;
490
491out_deprecated:
492 sysfs_remove_link(&dev->kobj, "subsystem");
493out_subsys:
494 sysfs_remove_link(&bus->p->devices_kset->kobj,dev_name(dev));
495out_id:
496 device_remove_attrs(bus, dev);
497out_put:
498 bus_put(dev->bus);
499 return error;
500}
我们看这一句
487 klist_add_tail(&dev->p->knode_bus,&bus->p->klist_devices);
就是将设备添加到总线的设备链表里面。
502/**
503 * bus_probe_device - probe drivers for a new device
504 * @dev: device to probe
505 *
506 * - Automatically probe for a driver if the bus allows it.
507 */
508void bus_probe_device(struct device *dev)
509{
510 struct bus_type *bus = dev->bus;
511 int ret;
512
513 if (bus && bus->p->drivers_autoprobe) {
514 ret = device_attach(dev);
515 WARN_ON(ret < 0);
516 }
517}
224/**
225 * device_attach - try to attach device to a driver.
226 * @dev: device.
227 *
228 * Walk the list of drivers that the bus has and call
229 * driver_probe_device() for each pair. If a compatible
230 * pair is found, break out and return.
231 *
232 * Returns 1 if the device was bound to a driver;
233 * 0 if no matching driver was found;
234 * -ENODEV if the device is not registered.
235 *
236 * When called for a USB interface, @dev->parent->sem must beheld.
237 */
238int device_attach(struct device *dev)
239{
240 int ret = 0;
241
242 down(&dev->sem);
243 if (dev->driver) {
244 ret = device_bind_driver(dev);
245 if (ret == 0)
246 ret = 1;
247 else {
248 dev->driver = NULL;
249 ret = 0;
250 }
251 } else {
252 pm_runtime_get_noresume(dev);
253 ret = bus_for_each_drv(dev->bus, NULL, dev,__device_attach);
254 pm_runtime_put_sync(dev);
255 }
256 up(&dev->sem);
257 return ret;
258}
259EXPORT_SYMBOL_GPL(device_attach);
因为驱动可以支持多个设备，所以驱动有一个设备链表。这里先判断设备是否已经指定了驱动，如果设备已经指定了驱动，那就调用device_bind_driver函数将设备添加到设备指定驱动的设备链表中。
76/**
77 * device_bind_driver - bind a driver to one device.
78 * @dev: device.
79 *
80 * Allow manual attachment of a driver to a device.
81 * Caller must have already set @dev->driver.
82 *
83 * Note that this does not modify the bus reference count
84 * nor take the bus's rwsem. Please verify those are accounted
85 * for before calling this. (It is ok to call with no other effort
86 * from a driver's probe() method.)
87 *
88 * This function must be called with @dev->sem held.
89 */
90int device_bind_driver(struct device *dev)
91{
92 int ret;
93
94 ret = driver_sysfs_add(dev);
95 if (!ret)
96 driver_bound(dev);
97 return ret;
98}
99EXPORT_SYMBOL_GPL(device_bind_driver);
32static void driver_bound(struct device *dev)
33{
34 if (klist_node_attached(&dev->p->knode_driver)) {
35 printk(KERN_WARNING "%s: device %s alreadybound\n",
36 __func__, kobject_name(&dev->kobj));
37 return;
38 }
39
40 pr_debug("driver: '%s': %s: bound to device '%s'\n",dev_name(dev),
41 __func__, dev->driver->name);
42
43 if (dev->bus)
44 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
45 BUS_NOTIFY_BOUND_DRIVER,dev);
46
47 klist_add_tail(&dev->p->knode_driver,&dev->driver->p->klist_devices);
48}
如果设备还没有指定驱动，那就调用bus_for_each_drv函数去遍历总线的驱动链表，找到一个驱动，就调用__device_attach函数。
375/**
376 * bus_for_each_drv - driver iterator
377 * @bus: bus we're dealing with.
378 * @start: driver to start iterating on.
379 * @data: data to pass to the callback.
380 * @fn: function to call for each driver.
381 *
382 * This is nearly identical to the device iterator above.
383 * We iterate over each driver that belongs to @bus, and call
384 * @fn for each. If @fn returns anything but 0, we break out
385 * and return it. If @start is not NULL, we use it as the head
386 * of the list.
387 *
388 * NOTE: we don't return the driver that returns a non-zero
389 * value, nor do we leave the reference count incremented for that
390 * driver. If the caller needs to know that info, it must set it
391 * in the callback. It must also be sure to increment the refcount
392 * so it doesn't disappear before returning to the caller.
393 */
394int bus_for_each_drv(struct bus_type *bus, struct device_driver*start,
395 void *data, int (*fn)(struct device_driver *,void *))
396{
397 struct klist_iter i;
398 struct device_driver *drv;
399 int error = 0;
400
401 if (!bus)
402 return -EINVAL;
403
404 klist_iter_init_node(&bus->p->klist_drivers, &i,
405 start ? &start->p->knode_bus :NULL);
406 while ((drv = next_driver(&i)) && !error)
407 error = fn(drv, data);
408 klist_iter_exit(&i);
409 return error;
410}
411EXPORT_SYMBOL_GPL(bus_for_each_drv);
214static int __device_attach(struct device_driver *drv, void *data)
215{
216 struct device *dev = data;
217
218 if (!driver_match_device(drv, dev))
219 return 0;
220
221 return driver_probe_device(drv, dev);
222}
120static inline int driver_match_device(struct device_driver *drv,
121 struct device *dev)
122{
123 return drv->bus->match ? drv->bus->match(dev,drv) : 1;
124}
我们看先是调用driver_match_device函数去匹配一个设备和驱动，怎样去匹配的呢，就是调用总线的match函数。如果匹配未成功，返回0，如果匹配成功，调用接下来的函数driver_probe_device。
185/**
186 * driver_probe_device - attempt to bind device & driver together
187 * @drv: driver to bind a device to
188 * @dev: device to try to bind to the driver
189 *
190 * This function returns -ENODEV if the device is not registered,
191 * 1 if the device is bound sucessfully and 0 otherwise.
192 *
193 * This function must be called with @dev->sem held. When calledfor a
194 * USB interface, @dev->parent->sem must be held as well.
195 */
196int driver_probe_device(struct device_driver *drv, struct device*dev)
197{
198 int ret = 0;
199
200 if (!device_is_registered(dev))
201 return -ENODEV;
202
203 pr_debug("bus: '%s': %s: matched device %s with driver%s\n",
204 drv->bus->name, __func__, dev_name(dev),drv->name);
205
206 pm_runtime_get_noresume(dev);
207 pm_runtime_barrier(dev);
208 ret = really_probe(dev, drv);
209 pm_runtime_put_sync(dev);
210
211 return ret;
212}
104static int really_probe(struct device *dev, struct device_driver*drv)
105{
106 int ret = 0;
107
108 atomic_inc(&probe_count);
109 pr_debug("bus: '%s': %s: probing driver %s with device%s\n",
110 drv->bus->name, __func__, drv->name,dev_name(dev));
111 WARN_ON(!list_empty(&dev->devres_head));
112
113 dev->driver = drv;
114 if (driver_sysfs_add(dev)) {
115 printk(KERN_ERR "%s: driver_sysfs_add(%s)failed\n",
116 __func__, dev_name(dev));
117 goto probe_failed;
118 }
119
120 if (dev->bus->probe) {
121 ret = dev->bus->probe(dev);
122 if (ret)
123 goto probe_failed;
124 } else if (drv->probe) {
125 ret = drv->probe(dev);
126 if (ret)
127 goto probe_failed;
128 }
129
130 driver_bound(dev);
131 ret = 1;
132 pr_debug("bus: '%s': %s: bound device %s to driver%s\n",
133 drv->bus->name, __func__, dev_name(dev),drv->name);
134 goto done;
135
136probe_failed:
137 devres_release_all(dev);
138 driver_sysfs_remove(dev);
139 dev->driver = NULL;
140
141 if (ret != -ENODEV && ret != -ENXIO) {
142 /* driver matched but the probe failed */
143 printk(KERN_WARNING
144 "%s: probe of %s failed with error %d\n",
145 drv->name, dev_name(dev), ret);
146 }
147 /*
148 * Ignore errors returned by ->probe so that the nextdriver can try
149 * its luck.
150 */
151 ret = 0;
152done:
153 atomic_dec(&probe_count);
154 wake_up(&probe_waitqueue);
155 return ret;
156}
因为前面已经匹配成功了，总线已经为设备找到了一个驱动，所以说先指定设备的驱动就是该驱动，如果总线定义了probe函数，就先调用总线的probe函数，如果驱动定义了probe函数，就调用驱动的probe函数，最后还是会调用driver_bound函数将这个设备添加到设备指定驱动的设备链表中。至此，设备注册过程完成。再来看设备的注销函数device_unregister
1129/**
1130 * device_unregister - unregister device from system.
1131 * @dev: device going away.
1132 *
1133 * We do this in two parts, like we do device_register(). First,
1134 * we remove it from all the subsystems with device_del(), then
1135 * we decrement the reference count via put_device(). If that
1136 * is the final reference count, the device will be cleaned up
1137 * via device_release() above. Otherwise, the structure will
1138 * stick around until the final reference to the device is dropped.
1139 */
1140void device_unregister(struct device *dev)
1141{
1142 pr_debug("device: '%s': %s\n", dev_name(dev),__func__);
1143 device_del(dev);
1144 put_device(dev);
1145}
1061/**
1062 * device_del - delete device from system.
1063 * @dev: device.
1064 *
1065 * This is the first part of the device unregistration
1066 * sequence. This removes the device from the lists we control
1067 * from here, has it removed from the other driver model
1068 * subsystems it was added to in device_add(), and removes it
1069 * from the kobject hierarchy.
1070 *
1071 * NOTE: this should be called manually _iff_ device_add() was
1072 * also called manually.
1073 */
1074void device_del(struct device *dev)
1075{
1076 struct device *parent = dev->parent;
1077 struct class_interface *class_intf;
1078
1079 /* Notify clients of device removal. This call must come
1080 * before dpm_sysfs_remove().
1081 */
1082 if (dev->bus)
1083 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1084 BUS_NOTIFY_DEL_DEVICE,dev);
1085 device_pm_remove(dev);
1086 dpm_sysfs_remove(dev);
1087 if (parent)
1088 klist_del(&dev->p->knode_parent);
1089 if (MAJOR(dev->devt)) {
1090 devtmpfs_delete_node(dev);
1091 device_remove_sys_dev_entry(dev);
1092 device_remove_file(dev, &devt_attr);
1093 }
1094 if (dev->class) {
1095 device_remove_class_symlinks(dev);
1096
1097 mutex_lock(&dev->class->p->class_mutex);
1098 /* notify any interfaces that the device is now gone*/
1099 list_for_each_entry(class_intf,
1100 &dev->class->p->class_interfaces,node)
1101 if (class_intf->remove_dev)
1102 class_intf->remove_dev(dev,class_intf);
1103 /* remove the device from the class list */
1104 klist_del(&dev->knode_class);
1105 mutex_unlock(&dev->class->p->class_mutex);
1106 }
1107 device_remove_file(dev, &uevent_attr);
1108 device_remove_attrs(dev);
1109 bus_remove_device(dev);
1110
1111 /*
1112 * Some platform devices are driven without driver attached
1113 * and managed resources may have been acquired. Make sure
1114 * all resources are released.
1115 */
1116 devres_release_all(dev);
1117
1118 /* Notify the platform of the removal, in case they
1119 * need to do anything...
1120 */
1121 if (platform_notify_remove)
1122 platform_notify_remove(dev);
1123 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1124 cleanup_device_parent(dev);
1125 kobject_del(&dev->kobj);
1126 put_device(parent);
1127}
只看bus_remove_device函数
519/**
520 * bus_remove_device - remove device from bus
521 * @dev: device to be removed
522 *
523 * - Remove symlink from bus's directory.
524 * - Delete device from bus's list.
525 * - Detach from its driver.
526 * - Drop reference taken in bus_add_device().
527 */
528void bus_remove_device(struct device *dev)
529{
530 if (dev->bus) {
531 sysfs_remove_link(&dev->kobj, "subsystem");
532 remove_deprecated_bus_links(dev);
533 sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
534 dev_name(dev));
535 device_remove_attrs(dev->bus, dev);
536 if (klist_node_attached(&dev->p->knode_bus))
537 klist_del(&dev->p->knode_bus);
538
539 pr_debug("bus: '%s': remove device %s\n",
540 dev->bus->name, dev_name(dev));
541 device_release_driver(dev);
542 bus_put(dev->bus);
543 }
544}
将设备从总线的设备链表中删除掉，然后是device_release_driver。
341/**
342 * device_release_driver - manually detach device from driver.
343 * @dev: device.
344 *
345 * Manually detach device from driver.
346 * When called for a USB interface, @dev->parent->sem must beheld.
347 */
348void device_release_driver(struct device *dev)
349{
350 /*
351 * If anyone calls device_release_driver() recursively from
352 * within their ->remove callback for the same device,they
353 * will deadlock right here.
354 */
355 down(&dev->sem);
356 __device_release_driver(dev);
357 up(&dev->sem);
358}
359EXPORT_SYMBOL_GPL(device_release_driver);
305/*
306 * __device_release_driver() must be called with @dev->sem held.
307 * When called for a USB interface, @dev->parent->sem must beheld as well.
308 */
309static void __device_release_driver(struct device *dev)
310{
311 struct device_driver *drv;
312
313 drv = dev->driver;
314 if (drv) {
315 pm_runtime_get_noresume(dev);
316 pm_runtime_barrier(dev);
317
318 driver_sysfs_remove(dev);
319
320 if (dev->bus)
321 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
322 BUS_NOTIFY_UNBIND_DRIVER,
323 dev);
324
325 if (dev->bus && dev->bus->remove)
326 dev->bus->remove(dev);
327 else if (drv->remove)
328 drv->remove(dev);
329 devres_release_all(dev);
330 dev->driver = NULL;
331 klist_remove(&dev->p->knode_driver);
332 if (dev->bus)
333 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
334 BUS_NOTIFY_UNBOUND_DRIVER,
335 dev);
336
337 pm_runtime_put_sync(dev);
338 }
339}
我们看，如果总线定义了remove函数，就调用总线的remove函数，如果驱动定义了remove函数，就调用驱动的remove函数，然后将设备从驱动的设备链表中删除掉。
我总结了有三个除名，一是父设备中除名，二是总线中除名，三是驱动中除名。
