Linux设备驱动模型之我理解

gxm771208

原文地址：http://blog.chinaunix.net/uid-25627207-id-3343854.html 作者：hk2305621
接触和学习Linux已一年有余了. 对 Linux 的设备模型(bus+device+driver+sysfs+uevent)理解尚未深刻.所以,写份简单的代码强化理解.

我自己写的 bus, 和在 bus 上注册 device 和 driver. 并让 device 和 driver 成功的match. 还未实现 uevent 时间.正在抽空了解 netlink.

Linux 版本 2.6.38-8(Ubuntu 11.04), 参考LDD3.(正在编译 3.0.42的内核,抽空过来补全这个文章^_^)

我的总线:

1. 
   
2. /* my_bus.h */
   
3. 
   
4. extern struct bus_type my_bus_type;
   
5. 
   
6. struct my_driver {
   
7.     char *version;
   
8.     struct module *module;
   
9.     struct device_driver driver;
   
10.     struct driver_attribute version_attr;
    
11. };
    
12. 
    
13. #define to_my_driver(drv) \
    
14.     container_of(drv, struct my_driver, driver)
    
15.    
    
16. struct my_device {
    
17.     char *name;
    
18.     struct my_driver *driver;
    
19.     struct device device;
    
20. };
    
21. 
    
22. #define to_my_device(dev) \
    
23.     container_of(dev, struct my_device, device)
    
24. 
    
25. /* interface to device. */
    
26. extern int register_my_device(struct my_device *);
    
27. extern void unregister_my_device(struct my_device *);
    
28. 
    
29. /* interface to driver. */
    
30. extern int register_my_driver(struct my_driver *);
    
31. extern void unregister_my_driver(struct my_driver *);

复制代码

C语言中,习惯性将一些导出符号放在.h的头文件中. 我这里也不例外. 对于LInux设备驱动模型, 所有的设备和驱动都是挂接在总线上的.所以,既然有总线了,也就得声明要挂在这个总线上的设备的数据结构,和驱动的数据结构. 和对应的注册函数吧.^_^. 这就是所谓的接口.

my_driver数据结构相关介绍:

1. 
   
2. /* 我的驱动 */
   
3. struct my_driver {
   
4.     char *version; //my_driver的版本.用来输出到sysfs文件系统的.
   
5.     struct module *module;//基本每个数据结构都要有的.
   
6.     struct device_driver driver;//Linux设备驱动模型中,用来管理驱动的.
   
7.     struct driver_attribute version_attr;//my_driver的一个属性.用来输出到sysfs.
   
8. };
   
9. 
   
10. //通过 device_driver 得到 my_driver.
    
11. #define to_my_driver(drv) \
    
12.     container_of(drv, struct my_driver, driver)
    
13. 
    
14. /* interface to driver. */
    
15. extern int register_my_driver(struct my_driver *); //将my_driver注册到my_bus上.
    
16. extern void unregister_my_driver(struct my_driver *);//将my_driver从my_bus上取消注册.
    

复制代码

同样, 和 my_device 相关的部分介绍如下:

1. 
   
2. /* 我的设备 */
   
3. struct my_device {
   
4.     char *name; //my_device的名称. 用来在 my_driver 匹配时用.
   
5.     struct my_driver *driver; //my_device绑定的my_driver指针.
   
6.     struct device device; //Linux设备驱动模型中,用来管理设备.
   
7. };
   
8. 
   
9. /* 通过device得到my_device结构.*/
   
10. #define to_my_device(dev) \
    
11.     container_of(dev, struct my_device, device)
    
12. 
    
13. /* interface to device. */
    
14. extern int register_my_device(struct my_device *); //将my_device注册到my_bus上.
    
15. extern void unregister_my_device(struct my_device *);//将my_device从my_bus上取消注册.
    
16. my_bus.c
    
17. [code]
    
18.   /* my_bus.c   */
    
19. #include <linux/module.h>
    
20. #include <linux/device.h>
    
21. #include <linux/kernel.h>
    
22. #include <linux/init.h>
    
23. #include <linux/string.h>
    
24. 
    
25. #include "my_bus.h"
    
26. 
    
27. MODULE_LICENSE("Dual BSD/GPL");
    
28. 
    
29. #define MYBUS "mybus: "
    
30. #define PRINT(x...) printk(KERN_ALERT MYBUS x);
    
31. 
    
32. static char *Version = "$Revision: 1.9 $";
    
33. 
    
34. static ssize_t show_bus_version(struct bus_type *bus, char *buf)
    
35. {
    
36.     PRINT("%s\n", __func__);
    
37.     return snprintf(buf, PAGE_SIZE, "my_bus: %s\n", Version);
    
38. }
    
39. 
    
40. static BUS_ATTR(version, S_IRUGO, show_bus_version, NULL);
    
41. 
    
42. static void my_bus_release(struct device *dev)
    
43. {
    
44.     PRINT("%s\n", __func__);
    
45. }
    
46. 
    
47. static int my_bus_match(struct device *dev, struct device_driver *drv)
    
48. {
    
49.     struct my_device *device = to_my_device(dev);
    
50.     PRINT("%s\n", __func__);
    
51. 
    
52.     return !strncmp(device->name, drv->name, strlen(drv->name));
    
53. }
    
54. 
    
55. static int my_bus_hotplug(struct device *dev, struct kobj_uevent_env *env){
    
56.     PRINT("%s\n", __func__);
    
57.     return 0;
    
58. }
    
59. 
    
60. struct bus_type my_bus_type = {
    
61.     .name = "my_bus",
    
62.     .match = my_bus_match,
    
63.     .uevent = my_bus_hotplug
    
64. };
    
65. 
    
66. static struct device my_bus = {
    
67.     .init_name = "my_bus0",
    
68.     .release = my_bus_release
    
69. };
    
70. 
    
71. /* interface to device. */
    
72. int register_my_device(struct my_device *device)
    
73. {
    
74.     PRINT("%s\n", __func__);
    
75.     device->device.bus = &my_bus_type;
    
76.     device->device.parent = &my_bus;
    
77.     device->device.release = my_bus_release;
    
78. 
    
79.     //strncpy(device->device.bus_id, device->name, BUS_ID_SIZE);
    
80. 
    
81.     return device_register(&device->device);
    
82. }
    
83. EXPORT_SYMBOL(register_my_device);
    
84. 
    
85. void unregister_my_device(struct my_device *device)
    
86. {
    
87.     PRINT("%s\n", __func__);
    
88.     device_unregister(&device->device);
    
89. }
    
90. EXPORT_SYMBOL(unregister_my_device);
    
91. 
    
92. static ssize_t show_version(struct device_driver *driver, char *buf)
    
93. {
    
94.     struct my_driver *drv = to_my_driver(driver);
    
95. 
    
96.     PRINT("%s\n", __func__);
    
97.     sprintf(buf, "%s\n", drv->version);
    
98. 
    
99.     return strlen(buf);
    
100. }
     
101. 
     
102. /* interface to driver. */
     
103. int register_my_driver(struct my_driver *driver)
     
104. {
     
105.     int ret = 0;
     
106.    
     
107.     PRINT("%s\n", __func__);
     
108. 
     
109.     driver->driver.bus = &my_bus_type;
     
110.     ret = driver_register(&driver->driver);
     
111.     if (ret) {
     
112.         PRINT("%s, driver_register %s failed!!!\n", __func__, driver->driver.name);
     
113.         return ret;
     
114.     }
     
115. 
     
116.     driver->version_attr.attr.name = "version";
     
117.     //driver->version_attr.attr.owner = driver->module;
     
118.     driver->version_attr.attr.mode = S_IRUGO;
     
119.     driver->version_attr.show = show_version;
     
120. 
     
121.     return driver_create_file(&driver->driver, &driver->version_attr);
     
122. }
     
123. EXPORT_SYMBOL(register_my_driver);
     
124. 
     
125. void unregister_my_driver(struct my_driver *driver)
     
126. {
     
127.     PRINT("%s\n", __func__);
     
128.     driver_unregister(&driver->driver);
     
129. }
     
130. EXPORT_SYMBOL(unregister_my_driver);
     
131. 
     
132. 
     
133. static int __init my_bus_init(void)
     
134. {
     
135.     int ret = 0;
     
136. 
     
137.     ret = bus_register(&my_bus_type);
     
138.     if (ret) {
     
139.         PRINT("%s, bus_register failed!\n", __func__);
     
140.         goto bus_register_failed;
     
141.     }
     
142. 
     
143.     ret = bus_create_file(&my_bus_type, &bus_attr_version);
     
144.     if (ret) {
     
145.         PRINT("%s, bus_create_file failure...!\n", __func__);
     
146.         goto bus_create_file_failed;
     
147.     }
     
148. 
     
149.     ret = device_register(&my_bus);
     
150.     if (ret) {
     
151.         PRINT("%s, device_register failure...!\n", __func__);
     
152.         goto device_register_failed;
     
153.     }
     
154. 
     
155.     PRINT("%s, bus & device register succeed!\n", __func__);
     
156.     return 0;
     
157.    
     
158. device_register_failed:
     
159. bus_create_file_failed:
     
160.     bus_unregister(&my_bus_type);
     
161. bus_register_failed:
     
162.     return ret;
     
163. }
     
164. 
     
165. static void __exit my_bus_exit(void)
     
166. {
     
167.     PRINT("%s!\n", __func__);
     
168.     device_unregister(&my_bus);
     
169.     bus_unregister(&my_bus_type);
     
170. }
     
171. 
     
172. module_init(my_bus_init);
     
173. module_exit(my_bus_exit);

复制代码

my_bus.c 是实现 my_bus 的主要文件. 其实一条总线, 在 Linux 设备驱动模型中, 它也是一个设备. 所以, 需要声明 my_bus_type 的同时, 还要声明 my_bus 这个设备.(注:C语言中,非导出符号在文件中声明时用static标明.所以, 在my_bus.c中, 你将看到大多数的函数都是static.)

注册 my_bus 的步骤.
1. 声明my_bus_type, 类型为 bus_type. 作为总线.

1. 
   
2. struct bus_type my_bus_type = {
   
3.     .name    = "my_bus",      //总线名称.
   
4.     .match   = my_bus_match,  //用来匹配设备和驱动的函数.
   
5.     .uevent  = my_bus_hotplug //用来发送uevent到用户空间.
   
6. };

复制代码

2. 声明my_bus,类型为 struct device, 因为my_bus也是一种设备.

1. 
   
2. static struct device my_bus = {
   
3.     .init_name = "my_bus0", //my_bus设备的名称.在device_add函数里会将init_name复制到kobject中.
   
4.     .release = my_bus_release //取消注册的设备的时候要调用的函数.
   
5. };

复制代码

3. 调用 bus_register(&my_bus_type) 将 my_bus_type 这个总线类型注册到系统.
4. 调用 device_register(&my_bus) 将总线设备注册到系统.
(步骤3和4都在my_bus_init函数中.)

1. 
   
2. static int __init my_bus_init(void)
   
3. {
   
4.     int ret = 0;
   
5. 
   
6.     ret = bus_register(&my_bus_type); //注册my_bus_type到Linux设备驱动模型中.
   
7.     if (ret) {
   
8.         PRINT("%s, bus_register failed!\n", __func__);
   
9.         goto bus_register_failed;
   
10.     }
    
11. 
    
12.     ret = bus_create_file(&my_bus_type, &bus_attr_version);//创建my_bus的一个属性.在sysfs中体现.
    
13.     if (ret) {
    
14.         PRINT("%s, bus_create_file failure...!\n", __func__);
    
15.         goto bus_create_file_failed;
    
16.     }
    
17. 
    
18.     ret = device_register(&my_bus); //注册my_bus到Linux设备驱动模型中.
    
19.     if (ret) {
    
20.         PRINT("%s, device_register failure...!\n", __func__);
    
21.         goto device_register_failed;
    
22.     }
    
23. 
    
24.     PRINT("%s, bus & device register succeed!\n", __func__);
    
25.     return 0;
    
26.    
    
27. device_register_failed:
    
28. bus_create_file_failed:
    
29.     bus_unregister(&my_bus_type);
    
30. bus_register_failed:
    
31.     return ret;
    
32. }

复制代码

上面四个步骤, 就将一条总线注册到 Linux设备驱动模型中.

编译并将 my_bus.ko 插入到到系统后,
可以通过命令 ls /sys/bus/  会看到 my_bus 文件夹.
通过命令 ls /sys/device/ 会看到 my_bus0 文件夹.
<感慨下, 把自己知道的东西写出来,比写代码难多了.>

其实, 对于 Linux 设备驱动模型而言, 它管理的, 是 bus_type, device 和 device_driver 三大主体. 譬如我这里的my_bus, my_device, my_driver 都是 bus_type, device, device_driver 的拓展, 都离不开 bus_type, device, device_driver 这三个主体. 所以, 这也就是为什么对应的数据结构中间都要包含它们.(my_bus_type 本身就是 bus_type 类型.)

取消 my_bus 这条总线, 有两个步骤:
1. 取消 my_bus 设备的注册.
2. 取消 my_bus_type 的注册.

步骤1和2都是在 my_bus_exit 函数中.

1. 
   
2. static void __exit my_bus_exit(void)
   
3. {
   
4.     PRINT("%s!\n", __func__);
   
5.     device_unregister(&my_bus);
   
6.     bus_unregister(&my_bus_type);
   
7. }

复制代码

驱动的加载和卸载都是 module_init 和 module_exit 来实现的.

module_init(my_bus_init);
module_exit(my_bus_exit);
总线上的驱动和设备的匹配函数如下. 就是通过简单的驱动的名称和设备的名称一致即可.(Linux内核很多都是这样实现的.)

1. 
   
2. static int my_bus_match(struct device *dev, struct device_driver *drv)
   
3. {
   
4.     struct my_device *device = to_my_device(dev);
   
5.     PRINT("%s\n", __func__);
   
6. 
   
7.     return !strncmp(device->name, drv->name, strlen(drv->name));
   
8. }

复制代码

注册与卸载设备:
在 my_bus 上注册设备的过程, 就是将 my_device 结构体中 device 结构体进行赋值:
1. bus_type 成员设置为 my_bus_type
2. parent 设置为 my_bus.
3. release 函数设置为 my_bus_release.
然后调用 device_register 函数将 my_device 中的 device 结构加入到 Linux 设备驱动模型的管理中.

1. 
   
2. int register_my_device(struct my_device *device)
   
3. {
   
4.     PRINT("%s\n", __func__);
   
5.     device->device.bus = &my_bus_type;
   
6.     device->device.parent = &my_bus;
   
7.     device->device.release = my_bus_release;
   
8. 
   
9.     //strncpy(device->device.bus_id, device->name, BUS_ID_SIZE);
   
10. 
    
11.     return device_register(&device->device);
    
12. }
    
13. EXPORT_SYMBOL(register_my_device);

复制代码

卸载 my_bus 上的 my_device 过程:
1. 调用 device_unregister 函数将 my_device 中的 device 结构从 Linux 设备驱动模型中移除.

1. 
   
2. void unregister_my_device(struct my_device *device)
   
3. {
   
4.     PRINT("%s\n", __func__);
   
5.     device_unregister(&device->device);
   
6. }
   
7. EXPORT_SYMBOL(unregister_my_device);

复制代码

注册与卸载驱动:
在my_bus总线上注册驱动的过程, 也就是对 my_driver 中 device_driver 的处理过程.
1. 设置 device_driver 的成员 bus 为 my_bus_type.
2. 调用 driver_register 函数, 将 device_driver 添加到 Linux 设备驱动模型中管理.

1. 
   
2. int register_my_driver(struct my_driver *driver)
   
3. {
   
4.     int ret = 0;
   
5.    
   
6.     PRINT("%s\n", __func__);
   
7. 
   
8.     driver->driver.bus = &my_bus_type;
   
9.     ret = driver_register(&driver->driver);
   
10.     if (ret) {
    
11.         PRINT("%s, driver_register %s failed!!!\n", __func__, driver->driver.name);
    
12.         return ret;
    
13.     }
    
14. 
    
15.     driver->version_attr.attr.name = "version";
    
16.     //driver->version_attr.attr.owner = driver->module;
    
17.     driver->version_attr.attr.mode = S_IRUGO;
    
18.     driver->version_attr.show = show_version;
    
19. 
    
20.     return driver_create_file(&driver->driver, &driver->version_attr);
    
21. }
    
22. EXPORT_SYMBOL(register_my_driver);

复制代码

在my_bus总线上卸载驱动的过程, 也是对 my_driver 中 device_driver 的处理过程.
1. 调用driver_unregister函数将 device_driver 从 Linux 设备驱动模型中移除.

1. 
   
2. void unregister_my_driver(struct my_driver *driver)
   
3. {
   
4.     PRINT("%s\n", __func__);
   
5.     driver_unregister(&driver->driver);
   
6. }
   
7. EXPORT_SYMBOL(unregister_my_driver);

复制代码

EXPORT_SYMBOL 是用来导出符号的. 用 EXPORT_SYMBOL 导出的符号, 其他模块也可以使用.

属性(Attribute)
在 Linux 设备驱动模型中, 总线, 设备, 驱动的特性, 都是通过属性这一工具来呈现在 sysfs 文件系统中. 导出到用户空间的.

1. 声明一个属性 bus_attr_version.
static BUS_ATTR(version, S_IRUGO, show_bus_version, NULL);
在内核源码中, 会看到, BUS_ATTR 是一个宏, 基于 __ATTR 这个宏而来的, 只是在 __ATTR 宏的基础上, 赋予一些初值.BUS_ATTR 宏如下:
#define BUS_ATTR(_name, _mode, _show, _store)    \
struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
其中:
_mode 是属性在 sysfs 中对应文件的访问权限.
_show 是读取 sysfs 中对应文件时调用的方法.
_store 是写 sysfs 中对应的文件触发的方法.

2. 将属性和bus_type挂接. 那么, Linux 设备驱动模型会在 sysfs 文件系统下生成对应的文件.
__________________________________________________________________________________________
下面是测试 my_bus 总线使用的 驱动和设备的代码.

我的设备 my_device.c

1. 
   
2. #include <linux/module.h>
   
3. #include <linux/init.h>
   
4. #include <linux/string.h>
   
5. #include <linux/kernel.h>
   
6. #include <linux/device.h>
   
7. 
   
8. #include "my_bus.h"
   
9. 
   
10. #define MYDEVICE "my-device: "
    
11. #define PRINT(x...) printk(KERN_ALERT MYDEVICE x);
    
12. 
    
13. MODULE_LICENSE("Dual BSD/GPL");
    
14. 
    
15. static struct my_device device =
    
16. {
    
17.     .name = "hunk_device",
    
18.     .device = {
    
19.         .init_name = "my_device",
    
20.     }
    
21. };
    
22. 
    
23. static int __init my_device_init(void)
    
24. {
    
25.     int ret = 0;
    
26.    
    
27.     PRINT("%s\n", __func__);
    
28.     ret = register_my_device(&device);
    
29.     if (ret) {
    
30.         PRINT("%s failure..!\n", __func__);
    
31.         return ret;
    
32.     }
    
33.    
    
34.     return 0;
    
35. }
    
36. 
    
37. static void __exit my_device_exit(void)
    
38. {
    
39.     PRINT("%s\n", __func__);
    
40.     unregister_my_device(&device);
    
41. }
    
42. 
    
43. module_init(my_device_init);
    
44. module_exit(my_device_exit);

复制代码

我的驱动 my_driver.c

1. 
   
2. #include <linux/module.h>
   
3. #include <linux/init.h>
   
4. #include <linux/string.h>
   
5. #include <linux/kernel.h>
   
6. #include <linux/device.h>
   
7. 
   
8. #include "my_bus.h"
   
9. 
   
10. #define MYDRIVER "my-driver: "
    
11. #define PRINT(x...) printk(KERN_ALERT MYDRIVER x);
    
12. 
    
13. MODULE_LICENSE("Dual BSD/GPL");
    
14. 
    
15. static struct my_driver driver =
    
16. {
    
17.     .module = THIS_MODULE,
    
18.     .driver = {
    
19.         .name = "hunk_device",
    
20.         .owner = THIS_MODULE
    
21.     }
    
22. };
    
23. 
    
24. static int __init my_driver_init(void)
    
25. {
    
26.     int ret = 0;
    
27.    
    
28.     PRINT("%s\n", __func__);
    
29.     ret = register_my_driver(&device);
    
30.     if (ret) {
    
31.         PRINT("%s failure..!\n", __func__);
    
32.         return ret;
    
33.     }
    
34.    
    
35.     return 0;
    
36. }
    
37. 
    
38. static void __exit my_driver_exit(void)
    
39. {
    
40.     PRINT("%s\n", __func__);
    
41.     unregister_my_driver(&device);
    
42. }
    
43. 
    
44. module_init(my_driver_init);
    
45. module_exit(my_driver_exit);
    

复制代码