linux设备驱动归纳总结（八）：3.设备管理的分层与面向对象思想【转】

linux设备驱动归纳总结（八）：3.设备管理的分层与面向对象思想

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

前面的内容介绍了总线、设备和驱动函数的关系和操作。从这节开始，介绍设备管理中的分层思想和面向对象思想（名字是我自己瞎编的，《LDD》上指的是结构体内嵌）。可以理解是平台类设备(platform)的一个过度。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

一、设备管理的分层

回想一下之前的设备和驱动函数注册时，它们是自己指定所属的总线。但是，内核开发人员觉得，这样的方法不好，应该由总线来提供设备和驱动的注册函数。当设备和驱动需要注册到指定总线时，那就必须使用该总线为设备和驱动提供的注册函数。

所以，将上一节的bus.c修改如下：

/*8th_devModule_3/1st/bus.c*/
21 /*总线提供的设备注册函数*/
22 int usb_device_register(struct device *dev)
23 {
24     dev->bus = &usb_bus; //设备device的总线为usb_bus
25     return device_register(dev); //注册此device
26 }
27 void usb_device_unregister(struct device *dev)
28 {
29     device_unregister(dev);
30 }
31 EXPORT_SYMBOL(usb_device_register);
32 EXPORT_SYMBOL(usb_device_unregister);
33 /*总线提供的驱动注册函数*/
34 int usb_driver_register(struct device_driver *drv)
35 {
36     drv->bus = &usb_bus; //设置driver的总线为usb_bus
37     return driver_register(drv); //注册此driver
38 }
39 void usb_driver_unregister(struct device_driver *drv)
40 {
41     driver_unregister(drv);
42 }
43 EXPORT_SYMBOL(usb_driver_register);
44 EXPORT_SYMBOL(usb_driver_unregister);
再写一个bus.h，让设备和驱动函数包含该头文件后能够使用总线提供的驱动函数。
/*8th_devModule_3/1st/bus.h*/
1 #ifndef _BUS_H
2 #define _BUS_H
3
4 int usb_device_register(struct device *dev);
5 void usb_device_unregister(struct device *dev);
6
7 int usb_driver_register(struct device_driver *drv);
8 void usb_driver_unregister(struct device_driver *drv);
9 #endif /* _BUS_H */
上面的程序可以看到，其实也没干什么事情，只是由总线来封装并且向设备和驱动函数提供注册函数，便于管理。而不像以前，设备和驱动只要知道总线的名字，就能注册到指定的总线中。
再修改一下设备和驱动函数的代码：
/*8th_devModule_3/1st/device.c*/
11 /*结构体中不需要指定总线的成员，交由usb_device_register来完成*/
12 struct device usb_device = {
13     .bus_id = "usb_mouse",
14     .release = usb_dev_release, //必须要都有release函数，不然卸载时会出错
15 };
16
17 static int __init usb_device_init(void)
18 {
19     int ret;
20
21     ret = usb_device_register(&usb_device);
22     if(ret){
23     printk("device register failed!\n");
24     return ret;
25     }
26
27     printk("usb device init\n");
28     return 0;
29 }
30
31 static void __exit usb_device_exit(void)
32 {
33     usb_device_unregister(&usb_device);
34     printk("usb device bye!\n");
35 }
 
/*8th_devModule_3/1st/driver.c*/
24 /*结构体中不需要指定总线的成员，交由usb_device_register来完成*/
25 struct device_driver usb_driver = {
26     .name = "usb_mouse", //在/sys/中的驱动目录名字
27     .probe = usb_driver_probe,
28     .remove = usb_driver_remove,
29 };
30
31 static int __init usb_driver_init(void)
32 {
33     int ret;
34     /*驱动注册，注册成功后在/sys/bus/usb/driver目录下创建目录usb_mouse*/
35     ret = usb_driver_register(&usb_driver);
36     if(ret){
37     printk("driver register failed!\n");
38     return ret;
39     }
40     printk("usb driver init\n");
41     return 0;
42 }
43
44 static void __exit usb_driver_exit(void)
45 {
46     usb_driver_unregister(&usb_driver);
47     printk("usb driver bye!\n");
48 }
修改完毕，验证一下，效果和之前的一样，我也不详细解释：
[root: 1st]# insmod bus.ko
usb bus init
[root: 1st]# insmod device.ko
usb device init
[root: 1st]# insmod driver.ko
match success
match success
init usb mouse
usb driver init
[root: 1st]# rmmod device
remove mouse driver
release
usb device bye!
[root: 1st]# rmmod driver
usb driver bye!
[root: 1st]# rmmod bus
usb bus bye!
 
二、面向对象思想——结构内嵌
 
device结构体分别包含了设备模型的基本信息。然后，大多数的子系统还会记录该结构体以外但与设备相关的信息。因此，单纯用一个device结构来表示设备是很少见的，而是把device结构体内嵌到其他的结构体中。当然，device_driver也是一样。
 
接下来，我封装一下设备和驱动函数的结构体：
/*8th_devModule_3/2nd/bus.h*/
4 struct usb_device{ //在usb_device中包含device结构体
5     unsigned long phys, virt; //存放设备和物理地址和对应的虚拟地址
6     int irq; //存放设备的中断号
7     int VendorID, DeviceID; //存放设备的生产厂商编号和设备编号
8
9     struct device dev;
10 };
11
12 struct usb_driver{ //在usb_driver中包含device_driver结构体
13     int VendorID, DeviceID;
14
15     struct device_driver drv;
16 };
17
18 int usb_device_register(struct usb_device *usb_dev);
19 void usb_device_unregister(struct usb_device *usb_dev);
20
21 int usb_driver_register(struct usb_driver *usb_drv);
22 void usb_driver_unregister(struct usb_driver *usb_drv);
23 #endif /* _BUS_H */
在上面，我将设备结构体device内嵌到usb_device结构体中，该结构体中还有成员生产厂商编号和设备编号，在match函数会用来配对，成员irq、phys和virt在接下来的章节会用到。
同样的，驱动函数结构体device_driver被内嵌到usb_driver结构体中，该结构体中还有成员生产厂商编号和设备编号，在match函数中会用来匹配。
 
因为我定义了新的结构体，三个函数都的传参都有了稍稍的改变。
 
首先是bus.c：
/*8th_devModule_3/2nd/bus.c*/
7 int usb_bus_match(struct device *dev, struct device_driver *drv)
8 { /*使用container_of找出总线自己定义的结构体*/
9       struct usb_device *usb_dev = container_of(dev, struct usb_device, dev);
10     struct usb_driver *usb_drv = container_of(drv, struct usb_driver, drv);
11     /*配对函数判断驱动和设备的生产厂商编号和设备编号是否一致*/
12     if((usb_dev->VendorID == usb_drv->VendorID) &&
13                 (usb_dev->DeviceID == usb_drv->DeviceID)){
14         printk("match success\n");
15         return 1;
16     }else{
17         printk("match failed\n");
18         return 0;
19     }
20 }
bus.c中的配对函数被我修改了两部分：
1、通过container_of来获得usb_device和usb_driver结构体。
2、修改了配对了方法，通过判断两者生产厂商编号与设备号是否都一致。
 
因为定义了新的结构体，所以我将注册函数的参数也修改了。
/*8th_devModule_3/2nd/bus.c*/
26 /*总线提供的设备注册函数*/
27 int usb_device_register(struct usb_device *usb_dev)
28 {
29     usb_dev->dev.bus = &usb_bus; //设备device的总线为usb_bus
30     return device_register(&usb_dev->dev); //注册此device
31 }
32 void usb_device_unregister(struct usb_device *usb_dev)
33 {
34     device_unregister(&usb_dev->dev);
35 }
36 EXPORT_SYMBOL(usb_device_register);
37 EXPORT_SYMBOL(usb_device_unregister);
38 /*总线提供的驱动注册函数*/
39 int usb_driver_register(struct usb_driver *usb_drv)
40 {
41     usb_drv->drv.bus = &usb_bus; //设置driver的总线为usb_bus
42     return driver_register(&usb_drv->drv); //注册此driver
43 }
44 void usb_driver_unregister(struct usb_driver *usb_drv)
45 {
46     driver_unregister(&usb_drv->drv);
47 }
48 EXPORT_SYMBOL(usb_driver_register);
49 EXPORT_SYMBOL(usb_driver_unregister);
 
接着是device.c：
/*8th_evModule_3/2nd/device.c*/
12 struct usb_device mouse_dev = {
13     .VendorID = 0x1122,
14     .DeviceID = 0x3344,
15     .dev = {
16         .bus_id = "usb_mouse",
17         .release = usb_dev_release,
18     },
19 };
20
21 static int __init usb_device_init(void)
22 {
23     int ret;
24
25     ret = usb_device_register(&mouse_dev);
26     if(ret){
27         printk("device register failed!\n");
28         return ret;
29     }
30
31     printk("usb device init\n");
32     return 0;
33 }
34
35 static void __exit usb_device_exit(void)
36 {
37     usb_device_unregister(&mouse_dev);
38     printk("usb device bye!\n");
39 }
 
最后再看看driver.c：
/*8th_devModule_3/2nd/driver.c*/
25 struct usb_driver mouse_drv = {
26     .VendorID = 0x1122,
27     .DeviceID = 0x3344,
28     .drv = {
29         .name = "usb_mouse", //在/sys/中的驱动目录名字
30         .probe = usb_driver_probe,
31         .remove = usb_driver_remove,
32     },
33 };
34
35 static int __init usb_driver_init(void)
36 {
37     int ret;
38     /*驱动注册，注册成功后在/sys/bus/usb/driver目录下创建目录usb_mouse*/
39     ret = usb_driver_register(&mouse_drv);
40     if(ret){
41         printk("driver register failed!\n");
42         return ret;
43     }
44     printk("usb driver init\n");
45     return 0;
46 }
47
48 static void __exit usb_driver_exit(void)
49 {
50     usb_driver_unregister(&mouse_drv);
51     printk("usb driver bye!\n");
52 }
 
修改完毕，看看效果，其实就是和之前一模一样。
[root: /]# cd review_driver/8th_devModule/8th_devModule_3/2nd/
[root: 2nd]# insmod bus.ko
usb bus init
[root: 2nd]# insmod device.ko
usb device init
[root: 2nd]# insmod driver.ko
match success
match success
init usb mouse
usb driver init
[root: 2nd]# rmmod device
remove mouse driver
release
usb device bye!
[root: 2nd]# rmmod driver
usb driver bye!
[root: 2nd]# rmmod bus
usb bus bye!      

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

三、总结

这节内容并不多，其实就是修改修改一下原来的代码，等到我介绍平台类设备的时候你就会发现，其实平台类就是这样一步步封装起来的（当然比我的复杂）。