本篇是关于linux的设备模型，将会覆盖相关的绝大部分知识，以及实践操作。希望这篇材料让大家基本掌握linux驱动设备模型，从而写出更加优秀的linux驱动。
linux统一的设备模型，提供了对电源管理和系统关机 、用户空间的通讯、可热插拔设备 、设备类别 、对象生命期 的广泛支持。
Linux 设备模型代码负责所有这些方面, 驱动代码作者只需要充分信任这些代码即可，但是, 理解设备模型绝对是一个好事情.
Linux2.6内核引入了sysfs文件系统，是与proc同类别的文件系统。sysfs把连接在系统上的设备和总线组织成分级的文件,使其从用户空间可以访问到。
有疑问联系：perftrace@gmail.com
1Â kobject
Kobject 是基础的结构, 它保持设备模型在一起,实现了基本的面向对象管理机制,是设备模型的核心结构。它与sysfs文件系统紧密相连,在内核中注册的每个kobject对象对应sysfs文件系统中的一个目录。bus,devices,drivers都是典型的容器。这些容器通过kobject连接起来,形成了一个树状结构。Kobject通常是嵌入到其他结构中的，单独意义不大。
结构体定义如下，位于文件include/linux/kobject.h"：
struct kobject {
const char *name;//函数容器名称的字符串
struct list_head entry;//用于kobject所插入的链表指针
struct kobject *parent;//指向父kobject
struct kset *kset;//指向包含的kset
struct kobj_type *ktype;//指向kobject类型描述符
struct kernfs_node *sd; /* sysfs directory entry */
struct kref kref;//容器引用计数器
#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
struct delayed_work release;
#endif
unsigned int state_initialized:1;
unsigned int state_in_sysfs:1;
unsigned int state_add_uevent_sent:1;
unsigned int state_remove_uevent_sent:1;
unsigned int uevent_suppress:1;
};
kobject 结构常常用来连接对象到一个层级的结构中, parent 成员代表在层次中之上一级. 如果一个 kobject 表示一个 USB 设备, 它的 parent 指针可能指示这 个设备被插入的 hub. parent 指针的主要用途是在 sysfs 层次中定位对象.
这里不得不先将一个宏，因为kobject会嵌入在其他设备机构中，那么如果有一个 struct kobject 指针, 那如何得到包含它的上级结构的指针呢？
这个就是通过container_of 来实现的，通过向后反转来得到包含kobject的结构的指针。
/**
* container_of - cast a member of a structure out to the containing structure
* @ptr: the pointer to the member.
* @type: the type of the container struct this is embedded in.
* @member: the name of the member within the struct.
*
*/
#define container_of(ptr, type, member)
1.1 kobject初始化
kobject初始化需要调用kobject_init 设置 kobject 的引用计数为 1 ，kobject_set_name设置kobject名字。分配给 kobject 的名字( 用 kobject_set_name ) 是给 sysfs 目录使用的名字.
int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
kobject的其中一个关键函数是引用计数器操作,只要对这个对象的引用存在, 这个对象(和支持它的代码) 必须继续存在.操作一个 kobject 的引用计数的低级函数是
struct kobject *kobject_get(struct kobject *kobj)
void kobject_put(struct kobject *kobj)
1.2 kobject释放
每个 kobject 必须有一个释放函数, 并且这个 kobject 必须持续 ( 以一致的状态 ) 直到这个方法被调用. 当引用为０的时候就会调用release函数。
释放的具体release函数被关联到包含 kobject 的结构类型中。 这个类型用kobj_type 结构类型, 我们可以简单称为ktype，如下节所示。
2 kobj_type
kobj_type描述kobject类型,这样就不需要每个kobject分别定义自己特性结构体了，结构体如下：
struct kobj_type {
void (*release)(struct kobject *kobj);//析构行为函数
const struct sysfs_ops *sysfs_ops;//sysfs行为
struct attribute **default_attrs;
const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
const void *(*namespace)(struct kobject *kobj);
};
每一个 kobject 需要有一个关联的 kobj_type 结构。如果这个 kobject 是一个 kset 的成员, kobj_type 指针由 kset 提供. 可以通过函数get_ktype来获取kobject的kobj_type指针。
static inline struct kobj_type *get_ktype(struct kobject *kobj)
release函数是kobject的释放函数，当引用为０的时候会调用。
Sysfs_ops负责描述如何使用它们。结构体如下,就两个函数非常简单：
struct sysfs_ops {
ssize_t (*show)(struct kobject *, struct attribute *, char *);
ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t);
};
用户空间读取sysfs时调用show方法，在写操作时候调用store方法。
默认属性default_attrs负责将内核数据映射成sysfs中的文件,其中模式可以是S_IRUGO。
struct attribute {
const char *name;
umode_t mode;
#ifdef CONFIG_DEBUG_LOCK_ALLOC
bool ignore_lockdep:1;
struct lock_class_key *key;
struct lock_class_key skey;
#endif
};
name 是属性的名字( 会出现在kobject的sysfs目录中)。
如果你想添加一 个新属性到一个 kobject 的 sysfs 目录, 简单地填充一个属性结构并且传递它到:
sysfs_create_file(struct kobject *kobj,const struct attribute *attr)
去除属性使用函数sysfs_remove_file。
sysfs_remove_file(struct kobject *kobj, const struct attribute *attr)
上面这些事文本属性文件，还可以创建和删除二进制属性：
sysfs_create_bin_file(struct kobject *kobj, const struct bin_attribute *attr)
sysfs_remove_bin_file(struct kobject *kobj, const struct bin_attribute *attr)
这里的属性是使用bin_attribute结构体，里面分装了attribute。
3 kset
通过kset数据结构图可将kobjects组织成一颗层次树。Kset是同类kobjects的一个集合体，也就是说相关的kobjects包含在同类型的容器中。
其数据结构如下：
struct kset {
struct list_head list; //包含在kset的kobject链表
spinlock_t list_lock;
struct kobject kobj;
const struct kset_uevent_ops *uevent_ops;
}
Kset是把kobject集中到一个集合(相同ktype的kobject可以分组到不同的kset)，而ktype描述类型所共有的特性。一旦一个 kset 已被建立并且加入到系统, 会有一个 sysfs 目录给它.
可以通过kobject_add来将kobject添加到kset中,并在sysfs中出现，会创建一个目录。当一个 kobject 被传递给 kobject_add, 它的引用计数被递增,移出时清除这个引用。移除的函数是kobject_del。sysfs 层级常常匹配使用 kset 创建的内部层次，如果 parent 和 kset 都 是 NULL, sysfs 目录在*被创建。
一个 kset有名字, 存储于嵌入的 kobject.
如前面所说，kset 中的kojbect指向 kobject_type 结构优先于在 kobject 自身中的 ktype 成员.
最后我们需要知道的是，一个kset属于子系统subsystem。
我们先来看下上述这些的代码实战。
3.1 kset示例代码
摘自网上，编译执行后称为模块。因为没有指定parent对象，所以插入到内核后，会在/sys目录下生成一个文件夹叫做kobject_test ,该目录下有一个文件是kobject_config,可以往该文件读写会触发相关函数，具体见代码：
#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/stat.h>
MODULE_LICENSE("Dual BSD/GPL");
/*声明release、show、store函数*/
void obj_test_release(struct kobject *kobject);
ssize_t kobj_test_show(struct kobject *kobject, struct attribute *attr,char *buf);
ssize_t kobj_test_store(struct kobject *kobject,struct attribute *attr,const char *buf, size_t count);
/*对应于kobject的目录下的一个文件,Name成员就是文件名*/
struct attribute test_attr = {
.name = "kobj_config",
.mode = S_IRWXUGO,
};
static struct attribute *def_attrs[] = {
&test_attr,
NULL,
};
//kobject对象的操作
struct sysfs_ops obj_test_sysops =
{
.show = kobj_test_show,
.store = kobj_test_store,
};
/*定义kobject对象的一些属性及对应的操作*/
struct kobj_type ktype =
{
.release = obj_test_release,
.sysfs_ops=&obj_test_sysops,
.default_attrs=def_attrs,
};
/*release方法释放该kobject对象*/
void obj_test_release(struct kobject *kobject)
{
printk("object_test: release .\n");
}
/*当读文件时执行的操作*/
ssize_t kobj_test_show(struct kobject *kobject, struct attribute *attr,char *buf)
{
printk("have show.\n");
printk("attrname:%s.\n", attr->name);
sprintf(buf,"%s\n",attr->name);
return strlen(attr->name)+2;
}
/*当写文件时执行的操作*/
ssize_t kobj_test_store(struct kobject *kobject,struct attribute *attr,const char *buf, size_t count)
{
printk("havestore\n");
printk("write: %s\n",buf);
return count;
}
struct kobject kobj;//声明kobject对象
static int kobj_test_init(void)
{
printk("kboject test init.\n");
//初始化kobject对象kobj,并将其注册到linux系统
kobject_init_and_add(&kobj,&ktype,NULL,"kobject_test");
return 0;
}
static void kobj_test_exit(void)
{
printk("kobject test exit.\n");
kobject_del(&kobj);
}
module_init(kobj_test_init);
module_exit(kobj_test_exit);
4 符号链接
sysfs文件系统的树结构,反映它代表的kobjects的层次组织. 一个sysfs子树(/sys/devices )代表所有的系统已知的设备,而其他的子树( 在 /sys/bus 之下 )表示设备驱动.但是,不代表驱动和它们所管理的设备间的关系.
展示这些附加关系需要额外的指针, 指针在 sysfs 中通过符号连接实现。
/**
* sysfs_create_link - create symlink between two objects.
* @kobj: object whose directory we're creating the link in.
* @target: object we're pointing to.
* @name: name of the symlink.
*/
int sysfs_create_link(struct kobject *kobj, struct kobject *target,
const char *name)
移除符号：
int sysfs_create_link_nowarn(struct kobject *kobj, struct kobject *target, const char *name)
5 总线
总线是处理器和一个或多个设备之间的通道，所有的设备都通过一个总线连接. 总线可以插入另一个，例如一个 USB 控制器常常是一个 PCI 设备,总线由 bus_type 结构代表.
struct bus_type {
const char *name;//总线类型名字,用于在sysfs文件系统标识总线
const char *dev_name;
struct device *dev_root;
const struct attribute_group **bus_groups;
const struct attribute_group **dev_groups;
const struct attribute_group **drv_groups;
int (*match)(struct device *dev, struct device_driver *drv);//检测设备驱动是否支持特定方法
int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
int (*probe)(struct device *dev);
int (*remove)(struct device *dev);
void (*shutdown)(struct device *dev);
int (*online)(struct device *dev);
int (*offline)(struct device *dev);
int (*suspend)(struct device *dev, pm_message_t state);//进入低功耗的调用方法
int (*resume)(struct device *dev);//改变供电状态和恢复硬件上下文的方法
int (*num_vf)(struct device *dev);
const struct dev_pm_ops *pm;
const struct iommu_ops *iommu_ops;
struct subsys_private *p;
struct lock_class_key lock_key;
bool force_dma;
};
name 成员是总线的名字，一个总线包含 2 个 ksets, 代表已知总线的驱动和所有插入总线的设备, 每个总线是它自己的子系统,在成员subsys_private中。
注册总线通过函数bus_register，会在/sys/bus中出现：
/**
* bus_register - register a driver-core subsystem
* @bus: bus to register
*
* Once we have that, we register the bus with the kobject
* infrastructure, then register the children subsystems it has:
* the devices and drivers that belong to the subsystem.
*/
int bus_register(struct bus_type *bus)
注销使用函数bus_unregister
void bus_unregister(struct bus_type *bus)
在bus_type 结构定义的方法，允许总线代码作为一个设备核心和单独驱动之 间的中介，例如match匹配设备和驱动。
如果遍历总线上的设备和驱动呢？内核提供了很好的API函数，
/**
* bus_for_each_dev - device iterator.
* @bus: bus type.
* @start: device to start iterating from.
* @data: data for the callback.
* @fn: function to be called for each device.
*
* Iterate over @bus's list of devices, and call @fn for each,
* passing it @data. If @start is not NULL, we use that device to
* begin iterating from.
*
* We check the return of @fn each time. If it returns anything
* other than 0, we break out and return that value.
*
* NOTE: The device that returns a non-zero value is not retained
* in any way, nor is its refcount incremented. If the caller needs
* to retain this data, it should do so, and increment the reference
* count in the supplied callback.
*/
int bus_for_each_dev(struct bus_type *bus, struct device *start,
void *data, int (*fn)(struct device *, void *))
这个函数列举总线上的每个设备, 传递关联的设备结构给 fn, 连同作为 data 来传递的 值. 如果 start 是 NULL, 列举从总线的第一个设备开始; 否则列举从 start 之后的第 一个设备开始. 如果 fn 返回一个非零值, 列举停止并且那个值从 bus_for_each_dev 返 回.
遍历总线上的驱动使用函数bus_for_each_drv。功能基本同bus_for_each_dev，只不过遍历的是驱动。
5.1 总线属性
Linux 驱动模型中的每一层都提供一个添加属性的接口, 并且总线层不例外.
struct bus_attribute {
struct attribute attr;
ssize_t (*show)(struct bus_type *bus, char *buf);
ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
};
可以在编译时创建和初始化 bus_attribute 结构,使用BUS_ATTR(_name, _mode, _show, _store)
也可以使用类似kobject创建属性的方法
int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr)
6 设备
Linux 系统中的每个设备由一个 struct device 代表。
struct device {
struct device *parent;
struct device_private *p;
struct kobject kobj;
const char *init_name; /* initial name of the device */
const struct device_type *type;
struct mutex mutex; /* mutex to synchronize calls to
* its driver.
*/
struct bus_type *bus; /* type of bus device is on */
struct device_driver *driver; /* which driver has allocated this
device */
void *platform_data; /* Platform specific data, device
core doesn't touch it */
void *driver_data; /* Driver data, set and get with
dev_set/get_drvdata */
struct dev_links_info links;
struct dev_pm_info power;
struct dev_pm_domain *pm_domain;
#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
struct irq_domain *msi_domain;
#endif
#ifdef CONFIG_PINCTRL
struct dev_pin_info *pins;
#endif
#ifdef CONFIG_GENERIC_MSI_IRQ
struct list_head msi_list;
#endif
#ifdef CONFIG_NUMA
int numa_node; /* NUMA node this device is close to */
#endif
const struct dma_map_ops *dma_ops;
u64 *dma_mask; /* dma mask (if dma'able device) */
u64 coherent_dma_mask;/* Like dma_mask, but for
alloc_coherent mappings as
not all hardware supports
64 bit addresses for consistent
allocations such descriptors. */
unsigned long dma_pfn_offset;
struct device_dma_parameters *dma_parms;
struct list_head dma_pools; /* dma pools (if dma'ble) */
struct dma_coherent_mem *dma_mem; /* internal for coherent mem
override */
#ifdef CONFIG_DMA_CMA
struct cma *cma_area; /* contiguous memory area for dma
allocations */
#endif
/* arch specific additions */
struct dev_archdata archdata;
struct device_node *of_node; /* associated device tree node */
struct fwnode_handle *fwnode; /* firmware device node */
dev_t devt; /* dev_t, creates the sysfs "dev" */
u32 id; /* device instance */
spinlock_t devres_lock;
struct list_head devres_head;
struct klist_node knode_class;
struct class *class;
const struct attribute_group **groups; /* optional groups */
void (*release)(struct device *dev);
struct iommu_group *iommu_group;
struct iommu_fwspec *iommu_fwspec;
bool offline_disabled:1;
bool offline:1;
bool of_node_reused:1;
};
内核提供标准函数device_register将设备添加到内核数据结构中。
其中有成员
struct device *parent;
parent父设备是某种总线或者主控制器. 如果 parent 是 NULL, 设备是一个顶层设备.
struct kobject kobj;
kobj代表这个设备并且连接它到层次中的 kobject.
设备注册使用函数device_register,注销使用device_unregister。
/**
* device_register - register a device with the system.
* @dev: pointer to the device structure
*
* This happens in two clean steps - initialize the device
* and add it to the system. The two steps can be called
* separately, but this is the easiest and most common.
* I.e. you should only call the two helpers separately if
* have a clearly defined need to use and refcount the device
* before it is added to the hierarchy.
*
* For more information, see the kerneldoc for device_initialize()
* and device_add().
*
* NOTE: _Never_ directly free @dev after calling this function, even
* if it returned an error! Always use put_device() to give up the
* reference initialized in this function instead.
*/
int device_register(struct device *dev)
注册完毕后可以在/dev/devices目录下看到设备,如果是总线设备则在/dev/devices/[bus_id]/目录下，注销函数：
void device_unregister(struct device *dev)
6.1 设备属性
sysfs 中的设备入口可以有属性
struct device_attribute {
struct attribute attr;
ssize_t (*show)(struct device *dev, struct device_attribute *attr,
char *buf);
ssize_t (*store)(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count);
};
可以通过device_create_file和device_remove_file函数创建和删除。
int device_create_file(struct device *dev,
const struct device_attribute *attr)
void device_remove_file(struct device *dev,
const struct device_attribute *attr)
驱动和设备定义，甚至包括函数都是非常的类似。
7 驱动
struct device_driver {
const char *name;//驱动程序名字
struct bus_type *bus;//指向总线描述符的指针，总线链接所支持的设备
struct module *owner;//表示设备驱动程序模块
const char *mod_name; /* used for built-in modules */
bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
enum probe_type probe_type;
const struct of_device_id *of_match_table;
const struct acpi_device_id *acpi_match_table;
int (*probe) (struct device *dev); //探测设备方法
int (*remove) (struct device *dev); //移走设备方法
void (*shutdown) (struct device *dev);//设备关闭调用方法
int (*suspend) (struct device *dev, pm_message_t state);//低功率方法
int (*resume) (struct device *dev); //恢复方法
const struct attribute_group **groups;
const struct dev_pm_ops *pm;
void (*coredump) (struct device *dev);
struct driver_private *p;
};
设备驱动程序数据结构体
通过driver_register注册设备驱动程序。
通常被静态嵌入到更大的描述符中,例如pci_driver.
属性文件创建和删除如下：
/**
* driver_create_file - create sysfs file for driver.
* @drv: driver.
* @attr: driver attribute descriptor.
*/
int driver_create_file(struct device_driver *drv, const struct driver_attribute *attr)
void driver_remove_file(struct device_driver *drv, const struct driver_attribute *attr)
8 类
类是设备的高级视图, 它抽象出低级的实现细节。 驱动可以见到一个 SCSI 磁盘或者一个 ATA 磁盘, 但是在类的级别, 它们都 是磁盘.
所有的类都在 sysfs 中在 /sys/class 下出现. 因此, 例如, 所有的网络接口可在 /sys/class/net 下发现, 不管接口类型. 输入设备可在 /sys/class/input 下, 以及串 行设备在 /sys/class/tty. 一个例外是块设备,在 /sys/block和/sys/class/block中。
设备驱动模型中每个类是由一个class对象描述的。结构体：
struct class {
const char *name;
struct module *owner;
const struct attribute_group **class_groups;
const struct attribute_group **dev_groups;
struct kobject *dev_kobj;
int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
char *(*devnode)(struct device *dev, umode_t *mode);
void (*class_release)(struct class *class);
void (*dev_release)(struct device *dev);
int (*shutdown_pre)(struct device *dev);
const struct kobj_ns_type_operations *ns_type;
const void *(*namespace)(struct device *dev);
const struct dev_pm_ops *pm;
struct subsys_private *p;
};
每个类需要一个唯一的名字,是这个类在 /sys/class 中出现.
创建class使用class_create(owner, name) ，该函数会调用__class_create(owner, name, &__key);，
最后由__class_register函数来进行注册。
8.1 类属性
类的属性结构如下：
struct class_attribute {
struct attribute attr;
ssize_t (*show)(struct class *class, struct class_attribute *attr,
char *buf);
ssize_t (*store)(struct class *class, struct class_attribute *attr,
const char *buf, size_t count);
};
创建类属性文件：
class_create_file(struct class *class, const struct class_attribute *attr)
删除类属性文件：
class_remove_file(struct class *class, const struct class_attribute *attr)
类的真正目的是作为一个是该类成员的设备的容器
8.2 类接口
类子系统有一个在 Linux 设备模型其他部分找不到的概念. 这个机制称为一个接口称为class_interface.
struct class_interface {
struct list_head node;
struct class *class;
int (*add_dev) (struct device *, struct class_interface *);
void (*remove_dev) (struct device *, struct class_interface *);
};
接口通过函数注册和注销。
int class_interface_register(struct class_interface *class_intf)
void class_interface_unregister(struct class_interface *);
一个类设备被加入到class_interface 结构中指定的类时, 接口的 add 函数被调用. 这个函数可进行任何额外的设 置; 当设备被从类中去 除, remove 方法被调用来进行任何需要的清理.
9 udev
内核中创建统一驱动模型的主要原因是允许用户空间动态管理 /dev 树.
随着 Linux 内核开始安装到大型服务器, 许多用户遇到如何管理大量设备的问题.