尽管LDD3中说对多数程序员掌握设备驱动模型不是必要的，但对于嵌入式Linux的底层程序员而言，对设备驱动模型的学习非常重要。
    Linux设备模型的目的：为内核建立一个统一的设备模型，从而又一个对系统结构的一般性抽象描述。换句话说，Linux设备模型提取了设备操作的共同属性，进行抽象，并将这部分共同的属性在内核中实现，而为需要新添加设备或驱动提供一般性的统一接口，这使得驱动程序的开发变得更简单了，而程序员只需要去学习接口就行了。        在内核里，有各种各样的总线，如 usb_bus_type、spi_bus_type、pci_bus_type、platform_bus_type、i2c_bus_type 等，内核通过总线将设备与驱动分离。此文，基于 Linux2.6.32.2 简单分析设备驱动模型，以后看具体的总线设备模型时会更加清晰。    设备模型是层次的结构，层次的每一个节点都是通过kobject实现的。在文件上则体现在sysfs文件系统。    关于kobkect，前面的文章已经分析过了，如果不清楚请移步 http://blog.csdn.net/lizuobin2/article/details/51523693
    kobject 结构可能的层次结构如图：
    关于 uevet mdev 前面也说过了，请参考 http://blog.csdn.net/lizuobin2/article/details/51534385    对于整个 设备总线驱动模型 的样子，大概如下图吧，也并不复杂。简单来说，bus 负责维护 注册进来的devcie 与 driver ，每注册进来一个device 或者 driver 都会调用 Bus->match 函数 将device 与 driver 进行配对，并将它们加入链表，如果配对成功，调用Bus->probe或者driver->probe函数， 调用 kobject_uevent 函数设置环境变量，mdev进行创建设备节点等操作。后面，我们从 Bus driver 到 device三个部分进行详细的分析。
一、总线
    内核通过 bus_register 进行 Bus  注册，那么它注册到了哪里，“根”在哪？ 答案是 bus_kest 

1. int __init buses_init(void)
2. {
3. // /sys/bus 目录 这里创建的
4. bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);
5. if (!bus_kset)
6. return -ENOMEM;
7. return 0;
8. }

    bus 的类型为 bus_type

1. struct bus_type {
2. const char *name;
3. struct bus_attribute *bus_attrs;
4. struct device_attribute *dev_attrs;
5. struct driver_attribute *drv_attrs;
7. int (*match)(struct device *dev, struct device_driver *drv);
8. int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
9. int (*probe)(struct device *dev);
10. int (*remove)(struct device *dev);
11. void (*shutdown)(struct device *dev);
13. int (*suspend)(struct device *dev, pm_message_t state);
14. int (*resume)(struct device *dev);
16. const struct dev_pm_ops *pm;
18. struct bus_type_private *p;
19. };

1. struct bus_type_private {
2. struct kset subsys;
3. struct kset *drivers_kset;
4. struct kset *devices_kset;
5. struct klist klist_devices;
6. struct klist klist_drivers;
7. struct blocking_notifier_head bus_notifier;
8. unsigned int drivers_autoprobe:1;
9. struct bus_type *bus;
10. };

1. int bus_register(struct bus_type *bus)
2. {
3. int retval;
4. struct bus_type_private *priv;
6. priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL);
7. /* 1. bus 与 prv 相互建立联系 */
8. // 私有数据 .bus -> bus 本身
9. priv->bus = bus;
10. // bus->p 指向 priv
11. bus->p = priv;
12. // 内核通知链
13. BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
15. /* 设置 bus->prv->subsys->kobj */
16. // 设置 priv->subsys.kobj.name = bus->name 对应于/sys/ 目录下的目录名
17. retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
18. // 所有的 priv->subsys.kobj.kset 指向 bus_kse 对应于图中④与六的关系
19. priv->subsys.kobj.kset = bus_kset;
20. // 所有的priv->subsys.kobj.ktype 等于 bus_ktype
21. priv->subsys.kobj.ktype = &bus_ktype;
23. priv->drivers_autoprobe = 1;
25. /* 注册 kset (bus->prv->subsys priv->devices_kset priv->drivers_kset) */
26. // 注册 priv->subsys ，由于 priv->subsys.kobj.kset = bus_kset，所以会在 /sys/bus/目录下创建 目录 如/sys/bus/plateform
27. retval = kset_register(&priv->subsys);
28. // sysfs_create_file(&bus->p->subsys.kobj, &bus_attr_uevent->attr);
29. retval = bus_create_file(bus, &bus_attr_uevent);
31. // 由于 priv->subsys.kobj.kset = bus_kset ，因此会创建 /sys/bus/XXX/devices 目录 如 /sys/bus/plateform/devices
32. priv->devices_kset = kset_create_and_add("devices", NULL,
33. &priv->subsys.kobj);
34. // 同理 创建 /sys/bus/XXX/devices 目录 如 /sys/bus/plateform/drivers
35. priv->drivers_kset = kset_create_and_add("drivers", NULL,
36. &priv->subsys.kobj);
37. // 初始化 klist_devices 并设置get put 函数 初始化 klist_drivers 不知为何没有get put ?
38. klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
39. klist_init(&priv->klist_drivers, NULL, NULL);
41. retval = add_probe_files(bus); // static inline int add_probe_files(struct bus_type *bus) { return 0; }
42. // 添加 bus->attrs 属性文件
43. retval = bus_add_attrs(bus);
45. return 0;
47. }

目前，能通过 bus_register 函数处理的工作有：    1、将 Bus 与 priv 相互建立联系
    2、BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
    3、设置 bus->priv->subsys(kset).kobj 的名字为 bus->name
    4、设置 bus->priv->subsys(kset).kobj.kset 指向 bus_kset
    5、设置 bus->priv->subsys(kset).kobj.ktype 为 bus_ktype ，提供 show store 函数
    6、设置 bus->priv->drivers_autoprobe = 1;
    7、注册 bus->priv->subsys(kset)   对应于图中④与⑥的关系    由于4，且没有指定bus->priv->subsys(kset).kobj.Parent，会将 bus_kest.kobj 设置为 bus->priv->subsys(kset).kobj.Parent 因此，会将bus->priv->subsys(kset).kobj.entry 加入 bus_kest 链表，且会在/sys/bus目录下创建相应的总线目录/sys/bus/$(bus->name)，例如 /sys/bus/platform 
    8、创建 bus_attr_uevent->attr 属性文件
    9、创建并注册 devices_kset ，devices_kset.kobj.parent = bus->priv->subsys.kobj ,名字为 device ，因此会创建 /sys/bus/$(bus->name)/devices
    10、创建并注册 drivers_kset ，drivers_kset.kobj.parent = bus->priv->subsys.kobj ,名字为 drivers ，因此会创建 /sys/bus/$(bus->name)/drivers
    11、初始化 bus->priv->klist_devices 链表
    12、初始化 bus->priv->klist_drivers 链表
    13、创建 bus->bus_attrs 属性文件

下面来看个例子 ，修改自LDD3 。基于Linux 2.6.32.2 内核

1. /*
2. * Definitions for the virtual LDD bus.
3. *
4. * lddbus.h
5. */
7. extern struct device ldd_bus;
8. extern struct bus_type ldd_bus_type;
11. /*
12. * The LDD driver type.
13. */
15. struct ldd_driver {
16. char *version;
17. struct module *module;
18. struct device_driver driver;
19. struct driver_attribute version_attr;
20. };
22. #define to_ldd_driver(drv) container_of(drv, struct ldd_driver, driver);
24. /*
25. * A device type for things "plugged" into the LDD bus.
26. */
28. struct ldd_device {
29. char *name;
30. struct ldd_driver *driver;
31. struct device dev;
32. };
34. #define to_ldd_device(dev) container_of(dev, struct ldd_device, dev);
36. extern int register_ldd_device(struct ldd_device *);
37. extern void unregister_ldd_device(struct ldd_device *);
38. extern int register_ldd_driver(struct ldd_driver *);
39. extern void unregister_ldd_driver(struct ldd_driver *);

1. #include
2. #include
3. #include
4. #include
5. #include
6. #include "lddbus.h"
8. MODULE_AUTHOR("Jonathan Corbet");
9. MODULE_LICENSE("Dual BSD/GPL");
10. static char *Version = "$Revision: 1.9 $";
12. //--------------------------------- bus ----------------------------------------
14. static int ldd_match(struct device *dev, struct device_driver *drv)
15. {
16. struct ldd_device *pdev = to_ldd_device(dev);
18. return !strncmp(pdev->name, drv->name, strlen(drv->name));
19. }
21. struct bus_type ldd_bus_type = {
22. .name = "ldd",
23. .match = ldd_match,
24. };
26. //--------------------------------- device --------------------------------------
28. static ssize_t show_bus_version(struct bus_type *bus, char *buf)
29. {
30. return snprintf(buf, strlen(Version), "%s ", Version);
31. }
33. static BUS_ATTR(version, S_IRUGO, show_bus_version, NULL);
35. // parent device
36. static void ldd_bus_release(struct device *dev)
37. {
38. printk(KERN_DEBUG "lddbus release ");
39. }
40. static void ldd_dev_release(struct device *dev){ }
42. struct device ldd_bus = {
43. .init_name = "ldd0","white-space:pre"> // ldd0 就是总线的名字，这里改成 ldd_bus 更恰当
44. .release = ldd_bus_release
45. };
47. int register_ldd_device(struct ldd_device *ldddev)
48. {
50. ldddev->dev.bus = &ldd_bus_type;
51. ldddev->dev.parent = &ldd_bus;
52. ldddev->dev.release = ldd_dev_release;
53. return device_register(&ldddev->dev);
54. }
55. EXPORT_SYMBOL(register_ldd_device);
57. void unregister_ldd_device(struct ldd_device *ldddev)
58. {
59. device_unregister(&ldddev->dev);
60. }
61. EXPORT_SYMBOL(unregister_ldd_device);
63. //--------------------------------- driver --------------------------------------
65. static ssize_t show_version(struct device_driver *driver, char *buf)
66. {
67. struct ldd_driver *ldriver = to_ldd_driver(driver);
69. sprintf(buf, "%s ", ldriver->version);
70. return strlen(buf);
71. }
73. int register_ldd_driver(struct ldd_driver *driver)
74. {
75. int ret;
77. driver->driver.bus = &ldd_bus_type;
78. ret = driver_register(&driver->driver);
79. if (ret)
80. return ret;
81. driver->version_attr.attr.name = "version";
82. driver->version_attr.attr.owner = driver->module;
83. driver->version_attr.attr.mode = S_IRUGO;
84. driver->version_attr.show = show_version;
85. driver->version_attr.store = NULL;
86. return driver_create_file(&driver->driver, &driver->version_attr);
87. }
89. void unregister_ldd_driver(struct ldd_driver *driver)
90. {
91. driver_unregister(&driver->driver);
92. }
93. EXPORT_SYMBOL(register_ldd_driver);
94. EXPORT_SYMBOL(unregister_ldd_driver);
96. //--------------------------------- bus ----------------------------------------
98. static int __init ldd_bus_init(void)
99. {
100. int ret;
101. device_register(&ldd_bus);
102. ret = bus_register(&ldd_bus_type);
103. if (ret)
104. return ret;
105. if (bus_create_file(&ldd_bus_type, &bus_attr_version))
106. printk(KERN_NOTICE "Unable to create version attribute ");
108. return ret;
109. }
111. static void ldd_bus_exit(void)
112. {
113. bus_unregister(&ldd_bus_type);
114. }
116. module_init(ldd_bus_init);
117. module_exit(ldd_bus_exit);

    insmod bus.ko 之后发现，/sys/bus 目录下多了一个 ldd目录，这个目录就是我们向内核注册的 总线 ldd ，该目录下有一个devices 和 drivers目录，因为现在并没有向该总线注册任何的驱动和设备，因此这两个文件夹是空的。    cat version 会调用show函数，显示我们在 Bus 中设置的属性。二、driver

1. struct device_driver {
2. const char *name;
3. struct bus_type *bus;
5. struct module *owner;
6. const char *mod_name; /* used for built-in modules */
8. bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
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;
17. const struct dev_pm_ops *pm;
19. struct driver_private *p;
20. };

1. int driver_register(struct device_driver *drv)
2. {
3. ret = bus_add_driver(drv);
4. ret = driver_add_groups(drv, drv->groups);
5. }

1. int bus_add_driver(struct device_driver *drv)
2. {
3. struct bus_type *bus;
4. struct driver_private *priv;
5. int error = 0;
7. bus = bus_get(drv->bus);
9. priv = kzalloc(sizeof(*priv), GFP_KERNEL);
11. klist_init(&priv->klist_devices, NULL, NULL);
12. priv->driver = drv;
13. drv->p = priv;
14. // 在/sys/bus/xxx/drivers 目录下创建目录
15. priv->kobj.kset = bus->p->drivers_kset;
16. error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
17. "%s", drv->name);
18. // 匹配 dev
19. if (drv->bus->p->drivers_autoprobe) {
20. error = driver_attach(drv);
21. }
22. // 将driver 加入 Bus->p->kist_drivers链表
23. klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
24. // 如果设置了drv->mod_name 根据名字寻找模块
25. module_add_driver(drv->owner, drv);
26. // 在/sys/bus/xxx/drivers/创建属性文件
27. error = driver_create_file(drv, &driver_attr_uevent);
29. error = driver_add_attrs(bus, drv);
31. if (!drv->suppress_bind_attrs) {
32. error = add_bind_files(drv);
33. }
35. kobject_uevent(&priv->kobj, KOBJ_ADD);
36. return 0;
37. }

详细说一下driver匹配device的过程    在向Bus注册一个driver时，会调用到 driver_attch(drv) 来寻找与之配对的 deivice    bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);    根据名字我们应该能猜测出来，调用Bus的每一个 dev 与 driver 进行  __driver_attach    在 __driver_attach 中，首先会调用到 driver_match_device 函数（return drv->bus->match ? drv->bus->match(dev, drv) : 1;）进行匹配，    如果匹配成功，则调用 driver_probe_device(drv, dev)，然后调用 really_probe(dev, drv)     really_probe 中干了四件大事    1、dev->driver = drv;         在dev 中记录driver ，配对成功了嘛，在男方族谱上记录一下女方的名字。。然而device_driver结构中并没有device成员，因此并没有在女方族谱上记录男方的名字。    2、driver_sysfs_add(dev)        在sysfs中该 dev.kobj 目录下创建与之匹配的driver的符号连接,名字为“driver”        在sysfs中该 driver.kobj 目录下创建与之匹配的device的符号连接,名字为 kobject_name(&dev->kobj)     3、调用 probe         if (dev->bus->probe) {
    ret = dev->bus->probe(dev);
        } else if (drv->probe) {
    ret = drv->probe(dev);
        }     4、driver_bound         klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);        如果 device 未绑定到一个 driver 链表，则将这个 device 放入 driver 链表中，看来一个device只能有一个driver，但是driver可以支持多个device总结一下 driver_register 的工作    1、初始化 drv->priv->klist_devices 链表，该链表保存该驱动所支持的devices
    2、drv 与 priv 相互建立联系
    3、设置 drv->priv->kobj.kset = bus->p->drivers_kset;
    4、创建并注册 drv->priv->kobj ,设置 drv->priv->kobj.ktype = driver_ktype ,drv->priv->kobj.name = drv->name , drv->priv->kobj.parent = bus->p->drivers_kset.kobj 因此，会创建 /sys/bus/$(bus->name)/drivers/$(drv->name) 目录
    5、调用 drv->bus->match(dev, drv) ，匹配dev ,匹配成功调用probe函数
    6、将driver 加入 Bus->p->kist_drivers链表
    7、创建属性文件
    8、kobject_uevent(&priv->kobj, KOBJ_ADD);下面来看个例子：

1. #include
2. #include
3. #include
4. #include
5. #include
6. #include
7. #include
8. #include
9. #include "lddbus.h"
11. struct ldd_driver ldd_drv = {
13. .version = "version 1.0",
14. .driver = {
15. .name = "myldd",
16. },
17. };
19. static int ldd_drv_init(void){
21. register_ldd_driver(&ldd_drv);
22. return 0;
23. }
25. static void ldd_drv_exit(void){
27. unregister_ldd_driver(&ldd_drv);
28. }
30. module_init(ldd_drv_init);
31. module_exit(ldd_drv_exit);
32. MODULE_LICENSE("GPL");

    insmod drv.ko 之后，我们会发现 /sys/bus/ldd/drivers 目录下多了一个 myldd 目录，这就是我们向内核注册的ldd总线上的myldd驱动程序。同样 cat version 会显示设定好的属性。三、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