Linux 设备总线驱动模型

古城微笑少年丶 2022-06-02 02:26 269阅读 0赞

尽管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 结构可能的层次结构如图：

![SouthEast][]

关于 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三个部分进行详细的分析。

![SouthEast 1][]

一、总线

内核通过 bus\_register 进行 Bus  注册，那么它注册到了哪里，“根”在哪？ 答案是 bus\_kest

\[cpp\]  [view plain][]  [copy][view plain]

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

\[cpp\]  [view plain][]  [copy][view plain]

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;  
6.    
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);  
12.   
13.     int (\*suspend)(struct device \*dev, pm\_message\_t state);  
14.     int (\*resume)(struct device \*dev);  
15.   
16.     const struct dev\_pm\_ops \*pm;  
17.   
18.     struct bus\_type\_private \*p;  
19. \};

\[cpp\]  [view plain][]  [copy][view plain]

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. \};

\[cpp\]  [view plain][]  [copy][view plain]

1.  int bus\_register(struct bus\_type \*bus)  
2.  \{  
3.      int retval;  
4.      struct bus\_type\_private \*priv;  
5.    
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);  
14.   
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;  
22.       
23.     priv->drivers\_autoprobe = 1;  
24.       
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);  
30.   
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);  
40.   
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);  
44.   
45.     return 0;  
46.   
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 内核

\[cpp\]  [view plain][]  [copy][view plain]

1.  /\* 
2.   \* Definitions for the virtual LDD bus. 
3.   \* 
4.   \* lddbus.h 
5.   \*/  
6.    
7.  extern struct device ldd\_bus;  
8.  extern struct bus\_type ldd\_bus\_type;  
9.    
10.   
11. /\* 
12.  \* The LDD driver type. 
13.  \*/  
14.   
15. struct ldd\_driver \{  
16.     char \*version;  
17.     struct module \*module;  
18.     struct device\_driver driver;  
19.     struct driver\_attribute version\_attr;  
20. \};  
21.   
22. \#define to\_ldd\_driver(drv) container\_of(drv, struct ldd\_driver, driver);  
23.   
24. /\* 
25.  \* A device type for things "plugged" into the LDD bus. 
26.  \*/  
27.   
28. struct ldd\_device \{  
29.     char \*name;  
30.     struct ldd\_driver \*driver;  
31.     struct device dev;  
32. \};  
33.   
34. \#define to\_ldd\_device(dev) container\_of(dev, struct ldd\_device, dev);  
35.   
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 \*);

\[cpp\]  [view plain][]  [copy][view plain]

1.  \#include <linux/device.h>  
2.  \#include <linux/module.h>  
3.  \#include <linux/kernel.h>  
4.  \#include <linux/init.h>  
5.  \#include <linux/string.h>  
6.  \#include "lddbus.h"  
7.    
8.  MODULE\_AUTHOR("Jonathan Corbet");  
9.  MODULE\_LICENSE("Dual BSD/GPL");  
10. static char \*Version = "$Revision: 1.9 $";  
11.   
12. //--------------------------------- bus ----------------------------------------  
13.   
14. static int ldd\_match(struct device \*dev, struct device\_driver \*drv)  
15. \{  
16.     struct ldd\_device \*pdev = to\_ldd\_device(dev);  
17.       
18.     return !strncmp(pdev->name, drv->name, strlen(drv->name));  
19. \}  
20.   
21. struct bus\_type ldd\_bus\_type = \{  
22.     .name = "ldd",  
23.     .match = ldd\_match,  
24. \};  
25.   
26. //--------------------------------- device --------------------------------------  
27.   
28. static ssize\_t show\_bus\_version(struct bus\_type \*bus, char \*buf)  
29. \{  
30.     return snprintf(buf, strlen(Version), "%s\\n", Version);  
31. \}  
32.   
33. static BUS\_ATTR(version, S\_IRUGO, show\_bus\_version, NULL);  
34.   
35. // parent device  
36. static void ldd\_bus\_release(struct device \*dev)  
37. \{  
38.     printk(KERN\_DEBUG "lddbus release\\n");  
39. \}  
40. static void ldd\_dev\_release(struct device \*dev)\{ \}  
41.   
42. struct device ldd\_bus = \{  
43.     .init\_name   = "ldd0",<span style="white-space:pre">  </span>// ldd0 就是总线的名字，这里改成 ldd\_bus 更恰当  
44.     .release  = ldd\_bus\_release  
45. \};  
46.   
47. int register\_ldd\_device(struct ldd\_device \*ldddev)  
48. \{  
49.       
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);  
56.   
57. void unregister\_ldd\_device(struct ldd\_device \*ldddev)  
58. \{  
59.     device\_unregister(&ldddev->dev);  
60. \}  
61. EXPORT\_SYMBOL(unregister\_ldd\_device);  
62.   
63. //--------------------------------- driver --------------------------------------  
64.   
65. static ssize\_t show\_version(struct device\_driver \*driver, char \*buf)  
66. \{  
67.     struct ldd\_driver \*ldriver = to\_ldd\_driver(driver);  
68.   
69.     sprintf(buf, "%s\\n", ldriver->version);  
70.     return strlen(buf);  
71. \}  
72.           
73. int register\_ldd\_driver(struct ldd\_driver \*driver)  
74. \{  
75.     int ret;  
76.       
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. \}  
88.   
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);  
95.   
96. //--------------------------------- bus ----------------------------------------  
97.   
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\\n");  
107.   
108.     return ret;  
109. \}  
110.   
111. static void ldd\_bus\_exit(void)  
112. \{  
113.     bus\_unregister(&ldd\_bus\_type);  
114. \}  
115.   
116. module\_init(ldd\_bus\_init);  
117. module\_exit(ldd\_bus\_exit);

![SouthEast 2][]

![SouthEast 3][]

insmod bus.ko 之后发现，/sys/bus 目录下多了一个 ldd目录，这个目录就是我们向内核注册的 总线 ldd ，该目录下有一个devices 和 drivers目录，因为现在并没有向该总线注册任何的驱动和设备，因此这两个文件夹是空的。

cat version 会调用show函数，显示我们在 Bus 中设置的属性。

二、driver

\[cpp\]  [view plain][]  [copy][view plain]

1.  struct device\_driver \{  
2.      const char      \*name;  
3.      struct bus\_type     \*bus;  
4.    
5.      struct module       \*owner;  
6.      const char      \*mod\_name;  /\* used for built-in modules \*/  
7.    
8.      bool suppress\_bind\_attrs;   /\* disables bind/unbind via sysfs \*/  
9.    
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.   
17.     const struct dev\_pm\_ops \*pm;  
18.   
19.     struct driver\_private \*p;  
20. \};

\[cpp\]  [view plain][]  [copy][view plain]

1.  int driver\_register(struct device\_driver \*drv)  
2.  \{  
3.      ret = bus\_add\_driver(drv);  
4.      ret = driver\_add\_groups(drv, drv->groups);  
5.  \}

\[cpp\]  [view plain][]  [copy][view plain]

1.  int bus\_add\_driver(struct device\_driver \*drv)  
2.  \{  
3.      struct bus\_type \*bus;  
4.      struct driver\_private \*priv;  
5.      int error = 0;  
6.    
7.      bus = bus\_get(drv->bus);  
8.    
9.      priv = kzalloc(sizeof(\*priv), GFP\_KERNEL);  
10.   
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);  
28.   
29.     error = driver\_add\_attrs(bus, drv);  
30.   
31.     if (!drv->suppress\_bind\_attrs) \{  
32.         error = add\_bind\_files(drv);  
33.     \}  
34.   
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);

下面来看个例子：

\[cpp\]  [view plain][]  [copy][view plain]

1.  \#include <linux/module.h>  
2.  \#include <linux/kernel.h>  
3.  \#include <linux/fs.h>  
4.  \#include <linux/init.h>  
5.  \#include <linux/device.h>  
6.  \#include <linux/sched.h>   
7.  \#include <asm/uaccess.h>  
8.  \#include <linux/io.h>  
9.  \#include "lddbus.h"  
10.   
11. struct ldd\_driver ldd\_drv = \{  
12.   
13.     .version    = "version 1.0",      
14.     .driver = \{  
15.         .name = "myldd",  
16.     \},  
17. \};  
18.   
19. static int ldd\_drv\_init(void)\{  
20.   
21.     register\_ldd\_driver(&ldd\_drv);  
22.     return 0;  
23. \}  
24.   
25. static void ldd\_drv\_exit(void)\{  
26.       
27.     unregister\_ldd\_driver(&ldd\_drv);  
28. \}  
29.   
30. module\_init(ldd\_drv\_init);  
31. module\_exit(ldd\_drv\_exit);  
32. MODULE\_LICENSE("GPL");

![SouthEast 4][]

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

三、device

\[cpp\]  [view plain][]  [copy][view plain]

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 semaphore    sem;    /\* semaphore to synchronize calls to                      
8.      struct bus\_type \*bus;       /\* type of bus device is on \*/  
9.      struct device\_driver \*driver;   /\* which driver has allocated this device \*/  
10.     void        \*platform\_data; /\* Platform specific data, device core doesn't touch it \*/  
11.     struct dev\_pm\_info  power;  
12.   
13.     /\* arch specific additions \*/  
14.     struct dev\_archdata archdata;  
15.     dev\_t           devt;   /\* dev\_t, creates the sysfs "dev" \*/  
16.     spinlock\_t      devres\_lock;  
17.     struct list\_head    devres\_head;  
18.     struct klist\_node   knode\_class;  
19.     struct class        \*class;  
20.     const struct attribute\_group \*\*groups;  /\* optional groups \*/  
21.     void    (\*release)(struct device \*dev);  
22. \};

\[cpp\]  [view plain][]  [copy][view plain]

1.  int device\_register(struct device \*dev)  
2.  \{  
3.      device\_initialize(dev);  
4.      return device\_add(dev);  
5.  \}

\[cpp\]  [view plain][]  [copy][view plain]

1.  void device\_initialize(struct device \*dev)  
2.  \{  
3.      // 设置 dev->kobj.kset 为 devices\_kset  
4.      dev->kobj.kset = devices\_kset;  
5.        
6.      kobject\_init(&dev->kobj, &device\_ktype);  
7.      INIT\_LIST\_HEAD(&dev->dma\_pools);  
8.      init\_MUTEX(&dev->sem);  
9.      spin\_lock\_init(&dev->devres\_lock);  
10.     INIT\_LIST\_HEAD(&dev->devres\_head);  
11.     device\_init\_wakeup(dev, 0);  
12.     device\_pm\_init(dev);  
13.     set\_dev\_node(dev, -1);  
14. \}

\[cpp\]  [view plain][]  [copy][view plain]

1.  int device\_add(struct device \*dev)  
2.  \{  
3.      struct device \*parent = NULL;  
4.      struct class\_interface \*class\_intf;  
5.    
6.      dev = get\_device(dev);  
7.    
8.      if (!dev->p) \{  
9.          error = device\_private\_init(dev);  
10.     \}  
11.     // 如果设置了 init\_name 将 init\_name 设置为dev->kobj->name  
12.     if (dev->init\_name) \{  
13.         dev\_set\_name(dev, "%s", dev->init\_name);  
14.         dev->init\_name = NULL;  
15.     \}  
16.     // 将 parent\_device.kobj 设置为dev->kobj->parent   
17.     parent = get\_device(dev->parent);  
18.     setup\_parent(dev, parent);  // 这里需要根据 实例分析  
19.   
20.     /\* use parent numa\_node \*/  
21.     if (parent)  
22.         set\_dev\_node(dev, dev\_to\_node(parent));  
23.   
24.     // 在 xxxx 目录下创建目录   xxxx是其父设备 例如platform\_bus  
25.     // 如果没有device->parent 则在/sys/ 目录下创建  
26.     error = kobject\_add(&dev->kobj, dev->kobj.parent, NULL);  
27.   
28.     /\* notify platform of device entry \*/  
29.     if (platform\_notify)  
30.         platform\_notify(dev);  
31.     // 创建属性文件  
32.     error = device\_create\_file(dev, &uevent\_attr);  
33.   
34.     // 如果有主次设备号 创建dev 属性文件  
35.     if (MAJOR(dev->devt)) \{  
36.         error = device\_create\_file(dev, &devt\_attr);  
37.   
38.         error = device\_create\_sys\_dev\_entry(dev);  
39.   
40.         devtmpfs\_create\_node(dev);  
41.     \}  
42.     // 从 dev->class->p->class\_subsys.kobj 目录下创建到 /sys/devices/xxxx/subsystem 的软连接  
43.     error = device\_add\_class\_symlinks(dev);  
44.     // 设置属性文件  
45.     error = device\_add\_attrs(dev);  
46.   
47.     error = bus\_add\_device(dev);  
48.   
49.     error = dpm\_sysfs\_add(dev);  
50.   
51.     device\_pm\_add(dev);  
52.   
53.     /\* Notify clients of device addition.  This call must come 
54.      \* after dpm\_sysf\_add() and before kobject\_uevent(). 
55.      \*/  
56.     if (dev->bus)  
57.         blocking\_notifier\_call\_chain(&dev->bus->p->bus\_notifier,  
58.                          BUS\_NOTIFY\_ADD\_DEVICE, dev);  
59.   
60.     kobject\_uevent(&dev->kobj, KOBJ\_ADD);  
61.     bus\_probe\_device(dev); // device\_attach(dev); 匹配drv  
62.     if (parent)  
63.         klist\_add\_tail(&dev->p->knode\_parent,  
64.                    &parent->p->klist\_children);  
65.   
66.     if (dev->class) \{  
67.   
68.     \}  
69.   
70. \}

\[cpp\]  [view plain][]  [copy][view plain]

1.  int bus\_add\_device(struct device \*dev)  
2.  \{  
3.    
4.      if (bus) \{  
5.          // 创建属性文件  
6.          error = device\_add\_attrs(bus, dev);  
7.          // 创建 /sys/bus/$(bus->name)/devices/$(dev->name) 到 /sys/devices/$(dev->name) 的软连接  
8.          error = sysfs\_create\_link(&bus->p->devices\_kset->kobj,  
9.                          &dev->kobj, dev\_name(dev));  
10.         // 创建 /sys/devices/$(dev->name)/subsystem 到 /sys/bus/$(bus->name)/devices/$(dev->name) 的软连接  
11.         error = sysfs\_create\_link(&dev->kobj,  
12.                 &dev->bus->p->subsys.kobj, "subsystem");  
13.         // 创建 /sys/devices/$(dev->name)/bus 到 /sys/bus/$(bus->name)/devices/$(dev->name) 的软连接  
14.         error = make\_deprecated\_bus\_links(dev); // return sysfs\_create\_link(&dev->kobj, &dev->bus->p->subsys.kobj, "bus");  
15.         // 将 dev 加入 bus->p->klist\_devices 链表  
16.         klist\_add\_tail(&dev->p->knode\_bus, &bus->p->klist\_devices);  
17.     \}  
18.     return 0;  
19. \}

总结一下 device\_register 函数的工作  
  
     1、设置 dev->kobj.kset 为 devices\_kset  
    2、设置 dev->kobj.ktype 为 device\_ktype  
    3、如果设置了 init\_name 将 init\_name 设置为dev->kobj->name  
    4、将 dev->kobj->parent 设置为 parent\_device.kobj   
    5、在 xxxx 目录下创建目录   xxxx是其父设备 例如platform\_bus 如果没有device->parent 则在/sys/ 目录下创建  
    6、platform\_notify  
    7、创建属性文件  
    8、如果设置了 设备号，则创建属性文件 dev   
    9、创建各种软连接，其中/sys/bus/xxx/devices/目录下 的目录 为 /sys/devices 目录的软件接  
    10、blocking\_notifier\_call\_chain  
    11、kobject\_uevent  
    12、bus\_probe\_device 匹配drv ，这个匹配过程和前面注册driver时是一样的，最终都会调用到 really\_probe ，匹配成功则调用probe函数，不再赘述。

下面来看个例子：

\[cpp\]  [view plain][]  [copy][view plain]

1.  \#include <linux/module.h>  
2.  \#include <linux/kernel.h>  
3.  \#include <linux/fs.h>  
4.  \#include <linux/init.h>  
5.  \#include <linux/device.h>  
6.  \#include <linux/sched.h>   
7.  \#include <asm/uaccess.h>  
8.  \#include "lddbus.h"  
9.    
10. static dev\_t devid;  
11.   
12. static struct ldd\_device ldd\_dev = \{  
13.     .name = "myldd",      
14.     .dev = \{          
15.         .init\_name = "myldd",  
16.     \},  
17. \};  
18.   
19. static int ldd\_dev\_init(void)\{  
20.       
21.     alloc\_chrdev\_region(&devid, 0, 1, "mylddtest");  
22.     //ldd\_dev.dev.devt = devid;  
23.     register\_ldd\_device(&ldd\_dev);  
24.     return 0;  
25. \}  
26.   
27. static void ldd\_dev\_exit(void)\{  
28.     unregister\_ldd\_device(&ldd\_dev);  
29. \}  
30.   
31. module\_init(ldd\_dev\_init);  
32. module\_exit(ldd\_dev\_exit);  
33. MODULE\_LICENSE("GPL");

![SouthEast 5][]

device 相对driver 要复杂一些，insmod dev.ko 之后，我们可以在/sys/devices 目录下看到新增了一个目录 ldd0（ldd\_bus） ，在 ldd0 （ldd\_bus）目录下看到我们向ldd总线注册的myldd设备（ldd0是 myldd 的父设备），在/sys/bus/ldd/devices/ 目录下同样可以看到 myldd , 因为这里的Myldd 是指向 /sys/devices/ldd0/myldd 的软连接。

/sys/devices/ldd0/myldd/driver 目录 与该设备匹配的驱动程序，我们在Bus->match中设置的匹配条件--名字相同。

我们并未看到属性文件 dev ，是因为我们没有指定Myldd设备的设备号，将 dev.c 代码中的 ldd\_dev.dev.devt = devid 注释去掉，卸载原来驱动，重新加载。

![SouthEast 6][]

我们会发现，现在有了属性文件 dev ，cat dev 显示的是该设备的设备号，在此条件之下，mdev 会帮我们创建设备节点，因此在 /dev 目录下已经有了设备节点。

至此，简单的设备总线驱动模型就结束了，虽然例子很简单，但我相信对以后的理解各类负责的总线设备驱动模型也是会有帮助的。

转自： http://blog.csdn.net/lizuobin2/

[SouthEast]: /images/20220602/3f00944b36ee4988a793343b4eb53089.png
[SouthEast 1]: /images/20220602/b045f122fd444d2e9c8d5f3843fe3847.png
[view plain]: http://blog.csdn.net/lizuobin2/article/details/51570196#
[SouthEast 2]: /images/20220602/905a27f9a6f44c66be2f22dade642fc4.png
[SouthEast 3]: /images/20220602/4ab21970e77c4edc8c2b1f0af31e3c4d.png
[SouthEast 4]: /images/20220602/5602d37a96b340d8ad2a4f39545cd82f.png
[SouthEast 5]: /images/20220602/ea10bb85182343ba921ecfb44d0cc650.png
[SouthEast 6]: /images/20220602/7f4d7c8e535a4574bbcecc76ff8c6bf5.png