尽管LDD3中说对多数程序员掌握设备驱动模型不是必要的，但对于嵌入式Linux的底层程序员而言，对设备驱动模型的学习非常重要。 Linux设备模型的目的：为内核建立一个统一的设备模型，从而又一个对系统结构的一般性抽象描述。换句话说，Linux设备模型提取了设备操作的共同属性，进行抽象，并将这部分共同的属性在内核中实现，而为需要新添加设备或驱动提供一般性的统一接口，这使得驱动程序的开发变得更简单了，而程序员只需要去学习接口就行了。 在正式进入设备驱动模型的学习之前，有必要把documentation/filesystems/sysfs.txt读一遍（不能偷懒）。sysfs.txt主要描述/sys目录的创建及其属性，sys目录描述了设备驱动模型的层次关系，我们可以简略看一下/sys目录，
block：所有块设备 devices：系统所有设备（块设备特殊），对应struct device的层次结构 bus：系统中所有总线类型（指总线类型而不是总线设备，总线设备在devices下），bus的每个子目录都包含 --devices：包含到devices目录中设备的软链接 --drivers：与bus类型匹配的驱动程序 class：系统中设备类型（如声卡、网卡、显卡等） fs：一些文件系统，具体可参考filesystems /fuse.txt中例子 dev：包含2个子目录 --char：字符设备链接，链接到devices目录，以:命名 --block：块设备链接 Linux设备模型学习分为：Linux设备底层模型，描述设备的底层层次实现（kobject）；Linux上层容器，包括总线类型（bus_type）、设备（device）和驱动（device_driver）。

====Linux设备底层模型 ====

谨记：像上面看到的一样，设备模型是层次的结构，层次的每一个节点都是通过kobject实现的。在文件上则体现在sysfs文件系统。

kobject结构

内核中存在struct kobject数据结构，每个加载到系统中的kobject都唯一对应/sys或者子目录中的一个文件夹。可以这样说，许多kobject结构就构成设备模型的层次结构。每个kobject对应一个或多个struct attribute描述属性的结构。 点击(此处)折叠或打开

1. struct kobject{
   
2. constchar*name;/*对应sysfs的目录名*/
   
3. struct list_head entry;/*kobjetct双向链表*/
   
4. struct kobject*parent;/*指向kset中的kobject，相当于指向父目录*/
   
5. struct kset*kset;/*指向所属的kset*/
   
6. struct kobj_type*ktype;/*负责对kobject结构跟踪*/
   
7. struct sysfs_dirent*sd;
   
8. struct kref kref;/*kobject引用计数*/
   
9. unsignedintstate_initialized:1;
   
10. unsignedintstate_in_sysfs:1;
    
11. unsignedintstate_add_uevent_sent:1;
    
12. unsignedintstate_remove_uevent_sent:1;
    
13. unsignedintuevent_suppress:1;
    
14. };

kobject结构是组成设备模型的基本结构，最初kobject设计只用来跟踪模块引用计数，现已增加支持， ——sysfs表述：在sysfs中的每个对象都有对应的kobject —— 数据结构关联：通过链接将不同的层次数据关联 —— 热插拔事件处理：kobject子系统将产生的热插拔事件通知用户空间 kobject一般不单独使用，而是嵌入到上层结构（比如struct device，struct device_driver）当中使用。kobject的创建者需要直接或间接设置的成员有：ktype、kset和parent。kset我们后面再说，parent设置为NULL时，kobject默认创建到/sys顶层目录下，否则创建到对应的kobject目录中。重点来分析ktype成员的类型， 点击(此处)折叠或打开

1. #include<kobject.h>
   
2. struct kobj_type{
   
3. void(*release)(struct kobject*kobj);/*释放*/
   
4. conststruct sysfs_ops*sysfs_ops;/*默认属性实现*/
   
5. struct attribute**default_attrs;/*默认属性*/
   
6. conststruct kobj_ns_type_operations*(*child_ns_type)(struct kobject*kobj);
   
7. constvoid*(*namespace)(struct kobject*kobj);
   
8. };

ktype包含了释放设备、默认属性以及属性的实现方法几个重要成员。每个kobject必须有一个release方法，并且kobject在该方法被调用之前必须保持不变（处于稳定状态）。默认属性的结构如下， 点击(此处)折叠或打开

1. #include<linux/sysfs.h>
   
2. struct attribute{
   
3. constchar*name;/*属性名称*/
   
4. mode_t mode;/*属性保护：只读设为S_IRUGO，可写设为S_IWUSR*/
   
5. }

kobj_type中的default_attrs为二级结构指针，可以对每个kobject使用多个默认属性，最后一个属性使用NULL填充。struct sysfs_ops结构则如下， 点击(此处)折叠或打开

1. struct sysfs_ops{
   
2. ssize_t(*show)(struct kobject*,struct attribute*,char*);
   
3. ssize_t(*store)(struct kobject*,struct attribute*,constchar*,size_t);
   
4. };

show方法用于将传入的指定属性编码后放到char *类型的buffer中，store则执行相反功能：将buffer中的编码信息解码后传递给struct attribute类型变量。两者都是返回实际的属性长度。 一个使用kobject的简单例子如下， 点击(此处)折叠或打开

1. #include<linux/module.h>
   
2. #include<linux/init.h>
   
3. #include<linux/device.h>
   
4. #include<linux/string.h>
   
5. #include<linux/sysfs.h>
   
6. #include<linux/kernel.h>
   
7. 
   
8. MODULE_AUTHOR("xhzuoxin");
   
9. MODULE_LICENSE("Dual BSD/GPL");
   
10. 
    
11. void my_obj_release(struct kobject*kobj)
    
12. {
    
13. printk("release ok.n");
    
14. }
    
15. 
    
16. ssize_t my_sysfs_show(struct kobject*kobj,struct attribute*attr,char*buf)
    
17. {
    
18. printk("my_sysfs_show.n");
    
19. printk("attrname:%s.n",attr->name);
    
20. sprintf(buf,"%s",attr->name);
    
21. return strlen(attr->name)+1;
    
22. }
    
23. 
    
24. ssize_t my_sysfs_store(struct kobject*kobj,struct attribute*attr,constchar*buf,
    
25. size_t count)
    
26. {
    
27. printk("my_sysfs_store.n");
    
28. printk("write:%sn",buf);
    
29. 
    
30. return count;
    
31. }
    
32. 
    
33. struct sysfs_ops my_sysfs_ops={
    
34. .show=my_sysfs_show,
    
35. .store=my_sysfs_store,
    
36. };
    
37. 
    
38. struct attribute my_attrs={
    
39. .name="zx_kobj",
    
40. .mode=S_IRWXUGO,
    
41. };
    
42. 
    
43. struct attribute*my_attrs_def[]={
    
44. &my_attrs,
    
45. NULL,
    
46. };
    
47. struct kobj_type my_ktype={
    
48. .release=my_obj_release,
    
49. .sysfs_ops=&my_sysfs_ops,
    
50. .default_attrs=my_attrs_def,
    
51. };
    
52. 
    
53. struct kobject my_kobj;
    
54. 
    
55. int__init kobj_test_init(void)
    
56. {
    
57. printk("kobj_test init.n");
    
58. kobject_init_and_add(&my_kobj,&my_ktype,NULL,"zx");
    
59. 
    
60. return 0;
    
61. }
    
62. 
    
63. void __exit kobj_test_exit(void)
    
64. {
    
65. printk("kobj_test exit.n");
    
66. kobject_del(&my_kobj);
    
67. }
    
68. 
    
69. module_init(kobj_test_init);
    
70. module_exit(kobj_test_exit);

例子中有两个函数，用于初始化添加和删除kobject结构， 点击(此处)折叠或打开

1. intkobject_init_and_add(struct kobject*kobj,struct kobj_type*ktype,
   
2. struct kobject*parent,constchar*fmt,...);/*fmt指定kobject名称*/
   
3. void kobject_del(struct kobject*kobj);

加载模块后，在/sys目录下增加了一个叫zx达到目录，zx目录下创建了一个属性文件zx_kobj，使用tree /sys/zx查看。 内核提供了许多与kobject结构相关的函数，如下： 点击(此处)折叠或打开

1. //kobject初始化函数
   
2. void kobject_init(struct kobject*kobj);
   
3. //设置指定kobject的名称
   
4. intkobject_set_name(struct kobject*kobj,constchar*format,...);
   
5. //将kobj 对象的引用计数加，同时返回该对象的指针
   
6. struct kobject*kobject_get(struct kobject*kobj);
   
7. //将kobj对象的引用计数减，如果引用计数降为，则调用kobject release()释放该kobject对象
   
8. void kobject_put(struct kobject*kobj);
   
9. //将kobj对象加入Linux设备层次。挂接该kobject对象到kset的list链中，增加父目录各级kobject的引//用计数，在其parent指向的目录下创建文件节点，并启动该类型内核对象的hotplug函数
   
10. intkobject_add(struct kobject*kobj);
    
11. //kobject注册函数,调用kobject init()初始化kobj，再调用kobject_add()完成该内核对象的注册
    
12. intkobject_register(struct kobject*kobj);
    
13. //从Linux设备层次(hierarchy)中删除kobj对象
    
14. void kobject_del(struct kobject*kobj);
    
15. //kobject注销函数.与kobject register()相反，它首先调用kobject del从设备层次中删除该对象，再调//用kobject put()减少该对象的引用计数，如果引用计数降为，则释放kobject对象
    
16. void kobject_unregister(struct kobject*kobj);

kset结构

我们先看上图，kobject通过kset组织成层次化的结构，kset将一系列相同类型的kobject使用（双向）链表连接起来，可以这样 认为，kset充当链表头作用，kset内部内嵌了一个kobject结构。内核中用kset数据结构表示为： 点击(此处)折叠或打开

1. #include<linux/kobject.h>
   
2. struct kset{
   
3. struct list_head list;/*用于连接kset中所有kobject的链表头*/
   
4. spinlock_t list_lock;/*扫描kobject组成的链表时使用的锁*/
   
5. struct kobject kobj;/*嵌入的kobject*/
   
6. conststruct kset_uevent_ops*uevent_ops;/*kset的uevent操作*/
   
7. };

与kobject相似，kset_init()完成指定kset的初始化，kset_get()和kset_put()分别增加和减少kset对象的引用计数。Kset_add()和kset_del()函数分别实现将指定keset对象加入设备层次和从其中删除；kset_register()函数完成kset的注册而kset_unregister()函数则完成kset的注销。

==== 设备模型上层容器 ====

这里要描述的上层容器包括总线类型（bus_type）、设备（device）和驱动（device_driver），这3个模型环环相扣，参考图9-2。为何称为容器？因为bus_type/device/device_driver结构都内嵌了Linux设备的底层模型（kobject结构）。为什么称为上层而不是顶层？因为实际的驱动设备结构往往内嵌bus_type/device/device_driver这些结构，比如pci，usb等。 总线类型、设备、驱动3者之间关系： 在继续之前，自我感觉需要区分2个概念：总线设备与总线类型。总线设备本质上是一种设备，也需要像设备一样进行初始化，但位于设备的最顶层，总线类型是一种在设备和驱动数据结构中都包含的的抽象的描述（如图9-2），总线类型在/sys/bus目录下对应实体，总线设备在/devices目录下对应实体。

总线类型bus_type

内核对总线类型的描述如下： 点击(此处)折叠或打开

1. struct bus_type{
   
2. constchar*name;/*总线类型名*/
   
3. struct bus_attribute*bus_attrs;/*总线的属性*/
   
4. struct device_attribute*dev_attrs;/*设备属性,为每个加入总线的设备建立属性链表*/
   
5. struct driver_attribute*drv_attrs;/*驱动属性,为每个加入总线的驱动建立属性链表*/
   
6. 
   
7. /*驱动与设备匹配函数:当一个新设备或者驱动被添加到这个总线时，这个方法会被调用一次或多次，若指定的驱动程序能够处理指定的设备，则返回非零值。必须在总线层使用这个函数,因为那里存在正确的逻辑，核心内核不知道如何为每个总线类型匹配设备和驱动程序*/
   
8. int(*match)(struct device*dev,struct device_driver*drv);
   
9. /*在为用户空间产生热插拔事件之前，这个方法允许总线添加环境变量（参数和 kset 的uevent方法相同）*/
   
10. int(*uevent)(struct device*dev,struct kobj_uevent_env*env);
    
11. int(*probe)(struct device*dev);/**/
    
12. int(*remove)(struct device*dev);/*设备移除调用操作*/
    
13. void(*shutdown)(struct device*dev);
    
14. 
    
15. int(*suspend)(struct device*dev,pm_message_t state);
    
16. int(*resume)(struct device*dev);
    
17. 
    
18. conststruct dev_pm_ops*pm;
    
19. 
    
20. struct subsys_private*p;/*一个很重要的域，包含了device链表和drivers链表*/
    
21. };

接着对bus_type中比较关注的几个成员进行简述， [1] struct bus_attribute结构，device_attribute与driver_attribute将分别在设备和驱动分析过程中看到， 点击(此处)折叠或打开

1. struct bus_attribute{
   
2. struct attribute attr;
   
3. ssize_t(*show)(struct bus_type*bus,char*buf);
   
4. ssize_t(*store)(struct bus_type*bus,constchar*buf,size_t count);
   
5. };

[2] subsys_private中包含了对加入总线的设备的链表描述和驱动程序的链表描述，省略的部分结构如下 点击(此处)折叠或打开

1. struct subsys_private{
   
2. struct kset subsys;
   
3. struct kset*devices_kset;/*使用kset构建关联的devices链表头*/
   
4. struct kset*drivers_kset;/*使用kset构建关联的drivers链表头*/
   
5. struct klist klist_devices;/*通过循环可访问devices_kset的链表*/
   
6. struct klist klist_drivers;/*通过循环可访问drivers_kset的链表*/
   
7. struct bus_type*bus;/*反指向关联的bus_type结构*/
   
8. ......
   
9. };

bus_type通过扫描设备链表和驱动链表，使用mach方法查找匹配的设备和驱动，然后将struct device中的*driver设置为匹配的驱动，将struct device_driver中的device设置为匹配的设备，这就完成了将总线、设备和驱动3者之间的关联。 bus_type只有很少的成员必须提供初始化，大部分由设备模型核心控制。内核提供许多函数实现bus_type的注册注销等操作，新注册的总线可以再/sys/bus目录下看到。 点击(此处)折叠或打开

1. struct bus_type ldd_bus_type={/*bus_type初始化*/
   
2. .name="ldd",
   
3. .match=ldd_match,/*方法实现参见实例*/
   
4. .uevent=ldd_uevent,/*方法实现参见实例*/
   
5. };
   
6. ret=bus_register(&ldd_bus_type);/*注册，成功返回0*/
   
7. if(ret)
   
8. return ret;
   
9. void bus_unregister(struct bus_type*bus);/*注销*/

设备device

设备通过device结构描述， 点击(此处)折叠或打开

1. struct device{
   
2. struct device*parent;/*父设备，总线设备指定为NULL*/
   
3. struct device_private*p;/*包含设备链表，driver_data（驱动程序要使用数据）等信息*/
   
4. struct kobject kobj;
   
5. constchar*init_name;/*初始默认的设备名,但@device_add调用之后又重新设为NULL*/
   
6. struct device_type*type;
   
7. struct mutex mutex;/*mutextosynchronize callstoits driver*/
   
8. struct bus_type*bus;/*type of bus deviceison*/
   
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. #ifdef CONFIG_NUMA
    
14. intnuma_node;/*NUMA node this deviceiscloseto*/
    
15. #endif
    
16. u64*dma_mask;/*dma mask(ifdma'able device)*/
    
17. u64 coherent_dma_mask;/*Like dma_mask,butfor
    
18. alloc_coherent mappings as
    
19. notall hardware supports
    
20. 64 bit addressesforconsistent
    
21. allocations such descriptors.*/
    
22. struct device_dma_parameters*dma_parms;
    
23. struct list_head dma_pools;/*dma pools(ifdma'ble)*/
    
24. struct dma_coherent_mem*dma_mem;/*internalforcoherent mem override*/
    
25. /*arch specific additions*/
    
26. struct dev_archdata archdata;
    
27. #ifdef CONFIG_OF
    
28. struct device_node*of_node;
    
29. #endif
    
30. 
    
31. dev_t devt;/*dev_t,creates the sysfs"dev"设备号*/
    
32. spinlock_t devres_lock;
    
33. struct list_head devres_head;
    
34. struct klist_node knode_class;
    
35. structclass*class;
    
36. conststruct attribute_group**groups;/*optional groups*/
    
37. 
    
38. void(*release)(struct device*dev);
    
39. };

设备在sysfs文件系统中的入口可以有属性，这通过struct device_attribute单独描述，提供device_create_file类型函数添加属性。 点击(此处)折叠或打开

1. /*interfaceforexporting device attributes*/
   
2. struct device_attribute{
   
3. struct attribute attr;
   
4. ssize_t(*show)(struct device*dev,struct device_attribute*attr,
   
5. char*buf);
   
6. ssize_t(*store)(struct device*dev,struct device_attribute*attr,
   
7. constchar*buf,size_t count);
   
8. };

使用宏DEVICE_ATTR宏可以方便地再编译时构建设备属性，构建好属性之后就必须将属性添加到设备。 点击(此处)折叠或打开

1. /*最终生成变量dev_attr_##_name描述属性，
   
2. *比如DEVICE_ATTR(zx,S_IRUGO,show_method,NULL);
   
3. *则create_file中entry传入实参为dev_attr_zx*/
   
4. DEVICE_ATTR(_name,_mode,_show,_store);
   
5. /*属性文件的添加与删除使用以下函数*/
   
6. intdevice_create_file(struct device*device,struct device_attribute*entry);
   
7. void device_remove_file(struct device*dev,struct device_attribute*attr);

总线设备的注册：总线设备与一般设备一样，需要单独注册，与一般设备不同，总线设备的parent与bus域设为NULL。一般设备注册注销函数为 点击(此处)折叠或打开

1. intdevice_register(struct device*dev);/*成功返回0，需要检查返回值*/
   
2. void device_unregister(struct device*dev);

实际创建新设备时，不是直接使用device结构，而是将device结构嵌入到具体的设备结构当中，比如
点击(此处)折叠或打开

1. struct ldd_device{
   
2. char*name;/*设备名称*/
   
3. struct ldd_driver*driver;/*ldd设备关联的驱动*/
   
4. struct device dev;/*嵌入的device结构*/
   
5. };
   
6. /*同时提供根据device结构