用一个.c文件来理解bus,driver,device,sysfs的关系和driver&device的bind过程

wangfeiyue

忙了一个下午，调成功了一个module.写出来可能对驱动新手有一定帮助。我本人就是新手，所以从源码中理解这些概念花了一定的功夫。
以下module可以验证device,driver,bus的关系及在sysfs的体系，及bus先match，driver再probe的过程。
同时追求代码最小化，可见bus,device,driver等对象在注册时哪些信息是必须的。

1. #include <linux/module.h>
   
2. #include <linux/kobject.h>
   
3. #include <linux/device.h>
   
4. 
   
5. /*未实现设备文件创建和文件系统驱动*/
   
6. 
   
7. static int my_bus_match(struct device* device, struct device_driver* driver);
   
8. static int my_driver_probe(struct device* dev);
   
9. static void unregister_all(void);
   
10. static int register_all(void);
    
11. 
    
12. MODULE_LICENSE("GPL");
    
13. 
    
14. struct bus_type my_bus_type =
    
15. {
    
16.   .name = "my_bus_type",
    
17.   .match= my_bus_match
    
18. };
    
19. 
    
20. struct my_device
    
21. {
    
22.   int id;
    
23.   struct device dev;
    
24.   int drv_id;
    
25. };
    
26. 
    
27. struct my_device_driver
    
28. {
    
29. int id;
    
30. struct device_driver drv;
    
31. };
    
32. 
    
33. struct my_device_driver my_driver_1 =
    
34. {
    
35.   .drv =
    
36.   {
    
37.     .name = "my_bus_driver_1",
    
38.     .probe = my_driver_probe,
    
39.     .bus = &my_bus_type,
    
40.   },
    
41.   .id = 1,
    
42. };
    
43. struct my_device_driver my_driver_2 =
    
44. {
    
45.   .drv =
    
46.   {
    
47.     .name = "my_bus_driver_2",
    
48.     .probe = my_driver_probe,
    
49.     .bus = &my_bus_type
    
50.   },
    
51.   .id = 2
    
52. };
    
53. 
    
54. struct my_device my_device_1 =
    
55. {
    
56.   .id=001,
    
57.   .drv_id = 1,
    
58.   .dev =
    
59.   {
    
60.     .bus = &my_bus_type,   
    
61.     .bus_id = "my_bus_id_1"
    
62.   }
    
63.   
    
64. };
    
65. struct my_device my_device_2 =
    
66. {
    
67.   .id=002,
    
68.   .drv_id = 2,
    
69.   .dev =
    
70.   {
    
71.     .bus = &my_bus_type,
    
72.     .bus_id = "my_bus_id_2"
    
73.   }
    
74. };
    
75. 
    
76. 
    
77. static int device_match_driver(struct my_device* mydev, struct my_device_driver* mydrv)
    
78. {
    
79.   printk("one match tested: dev_id=%d, dev.drv_id=%d, drv_id=%d, drv_name=%s\n", mydev->id,
    
80.          mydev->drv_id, mydrv->id, mydrv->drv.name );
    
81.   if(mydev->drv_id != mydrv->id)
    
82.        return 0;
    
83.   return 1;
    
84. }
    
85. 
    
86. static int my_bus_match(struct device* device, struct device_driver* driver)
    
87. {
    
88.   struct my_device* mydev = container_of(device, struct  my_device, dev);
    
89.   struct my_device_driver* mydrv = container_of(driver, struct my_device_driver, drv);
    
90.   printk("my_bus_match called\n");
    
91.   if(device_match_driver(mydev, mydrv))
    
92.   {
    
93.         printk("one matched group:dev_id=%d drv_id=%d\n", mydev->id, mydrv->id);
    
94.         return 1;
    
95.   }
    
96.   printk("device %d and driver %d not match\n", mydev->id, mydrv->id);
    
97.   return 0;
    
98. }
    
99. 
    
100. static int my_driver_probe(struct device* dev)
     
101. {
     
102.   struct my_device_driver* mydrv = container_of(dev->driver, struct my_device_driver, drv);
     
103.   struct my_device* mydev = container_of(dev, struct my_device, dev);
     
104.   printk("my_driver %s drive probe called\n", mydrv->drv.name);
     
105.   if(device_match_driver(mydev, mydrv))
     
106.       return 0;
     
107.   return 1;
     
108. }
     
109. const int errExist = -17;
     
110. int bus_is_registered = 0;
     
111. static int register_all()
     
112. {
     
113.   int res;
     
114.   res = bus_register(&my_bus_type);
     
115.   if(res)
     
116.   {
     
117.      printk("register my_bus_type failed\n");
     
118.      return res;
     
119.   }
     
120. 
     
121.   bus_is_registered = 1;
     
122. 
     
123.    /*register driver 1*/
     
124.    res = driver_register(&my_driver_1.drv);
     
125.    if(res)
     
126.    {
     
127.       printk("register my_driver_1 failed\n");
     
128.       return res;
     
129.    }
     
130.        
     
131.    /*register driver 2*/
     
132.    res  = driver_register(&my_driver_2.drv);  
     
133.    if(res)
     
134.    {
     
135.       printk("register my_driver_2 failed\n");
     
136.       return res;
     
137.    }
     
138.    
     
139.    /*add device 1*/
     
140.    res = device_register(&my_device_1.dev);
     
141.    if(res)
     
142.    {
     
143.      printk("register my_device_1 failed\n");
     
144.      return res;
     
145.    }
     
146.    res = device_register(&my_device_2.dev);
     
147.    if(res)
     
148.    {
     
149.      printk("register my_device_2 failed\n");
     
150.      return res;
     
151.    }
     
152.    return 0;
     
153. }
     
154. 
     
155. static int my_init(void)
     
156. {
     
157.   int res;
     
158.   printk("my_init called\n");
     
159.   if((res = register_all()))
     
160.   {
     
161.     if(res != errExist && bus_is_registered)
     
162.        bus_unregister(&my_bus_type);
     
163.   /* dangerous if call unregister_all();*/
     
164.         printk("res=%d\n",res);
     
165. 
     
166.     return res;
     
167.   }
     
168.   return 0;
     
169. }
     
170. 
     
171. static void unregister_all()
     
172. {
     
173. device_unregister(&my_device_1.dev);
     
174. device_unregister(&my_device_2.dev);
     
175. driver_unregister(&my_driver_1.drv);
     
176. driver_unregister(&my_driver_2.drv);
     
177. bus_unregister(&my_bus_type);
     
178. }
     
179. 
     
180. static void my_exit(void)
     
181. {
     
182. unregister_all();
     
183. }
     
184. 
     
185. module_init(my_init);
     
186. module_exit(my_exit);
     

复制代码

Roemer

:wink:
LDD 里面讲得也不错~