Linux 设备驱动模型

Linux系统将设备和驱动归一到设备驱动模型中了来管理

 设备驱动程序功能：

　　　　1，对硬件设备初始化和释放

　　　　2，对设备进行管理，包括实参设置，以及提供对设备的统一操作接口

　　　　3，读取应用程序传递给设备文件的数据或回送应用程序请求的数据

　　　　4，检测或处理设备出现的错误

 

设备驱动模型提供了硬件的抽象包括：

1，电源管理

　　其实，电源管理就是一些设备不工作的时候，让它歇一会，休眠一会（最低消耗），达到省电的目的

　　它的一个重要的功能是：

　　　省电模式下，使系统中的设备以一定的先后顺序挂起

　　　在全速工作模式下，使系统的设备以一定的先后顺序恢复运行

　　　　　　就是这个意思，一条总线上有n个设备，只用当n个设备都挂起的时候，那个总线才能挂起。但是，只要有一个设备恢复，总线就得恢复

2，即插即用设备支持

　　这个大家都深有体会，你把PS/2的鼠标，键盘拔出来，然后再插上去，看看是不是没反应了。但是把USB的鼠标键盘拔下来再插上去，可以继续用

　　这就是传说中的即插即用的支持

3，与用户空间的通信

　　　和用户间通信的方式很多，以前大名鼎鼎的proc文件系统，就是一个鲜明的代表。它给了用户一双千里眼。但是proc还是被后来者sysfs文件系统给拿下了，从此改朝换代。

　　虽然proc依然在世，但是它的影响力已经下降。同时不得不说，proc得到过天下，肯定是有它的过人之处，那里sysfs可能会受挫。但是强者依然不是那么好动摇的

 

Linux设备驱动模型有几个基本数据结构模型：kobject，kset，subsystem

 

kobject：这是设备驱动模型的基础，就想是一座楼的地板砖和砖头。sysfs是它的子子孙孙，父父爷爷撑起来的

 

struct kobject

{

　　　　const char *name;     //显示在sysfs中的名称

　　　　struct list_head entry; 　　//下一个kobject结构

　　　　struct kobject *parent;　　　//指向父kobject结构体，如果存在

　　　　struct kset 　　*kset;　　　　//指向kset集合

　　　　struct kobj_type　　*ktype;  //指向kobject类型描述符

　　　　struct sysfs_dirent *sd;        //对应sysfs的文件目录

　　　　struct kref kref;　　　　　　　　//kobject引用计数

　　　　unsigned int state_initialized:1;  //是否初始化

　　　　unsigned int state_in_sysfs:1;   //是否加入sysfs

　　　　unsigned int state_add_uevent_sent:1;  //是否支持热插

　　　　unsigned int state_remove_uevent_sent:1; //是否支持热拔

}

void  kobject_init(struct kobject *kobj,struct kobj_type *ktype)

{

　　char * err_str;

　　if(!kobj)

　　{

　　　　err_str = "invalid kobject pointer!"

　　　　goto error;

　　}

　　if(!ktype)

　　{

　　　　err_str = "must have a ktype to be initialized properly!\n";

　　　　goto error;

　　}

　　if(kobj->state_initialized)

　　{

　　　　printk(KERN_ERR"kobject (%p): tried to init an initialized"

　　　　　　　　　　　　　　　　　　　　"object ,something is seriously wrong.\n",kobj);

　　　　dump_stack();

　　}

 

　　kobject_init_internal(kobj);         //初始化kobject的内部成员

　　kobj->ktype = ktype ;　　　　//为kobject绑定一个ktype属性   

　　return ;

error:

　　　printk(KERN_ERR"kobject (%p) : %s\n",kobj,err_str);

　　　dump_stack();

}

 

static void kobject_init_internal(struct koject *kobj)

{

　　if(!kobj)

　　　　return ;

　　kref_init(&kobj->kerf);

　　INIT_LIST_HEAD(&kobj->entry);

　　kobj->state_in_sysfs = 0;

　　kobj->state_add_uevent_sent = 0;

　　kobj->state_remove_uevent_sent = 0;

　　kobj->state_initialized = 1;

}

 

内核接口:

　　　　kobject_init();　　始化kobject

　　　　kobject_get();     增加kobject引用计数

　　　　kobject_put();　　减少kobject引用计数，计数为零时，调用kobject_release（）释放，它在kobj_type里面

　　　　kobject_set_name();   设置名字

　　　　kobject_rename();　　　　重命名

　　　　kobject_add()　　　　　　添加

　　　　

每个kobject都会有一个属性kobj_type

struct kobj_type

{

　　void (*release)(struct kobject *kobj);    //释放kobject和其他占用资源的函数

　　struct sysfs_ops *sysfs_ops;　　　　　　//操作属性的方法

　　struct attribute **default_attrs;  　　　　//属性数组

};

 

struct attribute

{

　　const char *name;　　　　　　　//属性的名称

　　struct module *owner;　　　　//只用拥有该属性的模块，已经不常使用

　　mode_t mode;　　　　　　　　//属性读写权限

};

 

struct sysfs_ops

{

　　ssize_t (*show)(struct kobject *,struct attribute *,char *);　　//读属性操作函数

　　ssize_t (*store)(struct kobject *,struct attribute *,const char *,size_t);  //写属性操作函数

};

 

struct kobject *kobject_get(struct kobject *kobj)

{

　　if(kobj)

　　　　kref_get(&kobj->kerf);

　　return kobj;

}

 

void kobject_put(struct kobject *kobj)

{

　　if(kobj)

　　{

　　　　　if(!kobj->state_initialized)

　　　　　　WARN(1,KERN_WARNING"kobject: ‘%s‘ (%p):is not initialized,yet kobject_put() is being called.\n",kobject_name(kobj),kobj);

　　　　　　kref_put(&kobj->kref,kobject_release);

　　}

}

 

 

 

 

 

通常kobject类型的default_attr成员定义了kobjet拥有的所有默认属性。但是特殊情况下，可以添加一些默认的属性：

添加属性文件：

int sysfs_create_file(struct kobject *kobj,const struct attribute  *attr);

删除属性文件：

void sysfs_remove_file(struct kobject  *kobj , const   struct attribute  *attr);

 

struct kset

{

　　struct list_head list;   //连接所包含的kobject对象的链表首地址

　　spinlock_t  list_lock;   //维护list链表的自旋锁

　　struct kobject kobj;  //内嵌kobject，说明kset本身也是一个目录

　　struct kset_uevent_ops *uevent_ops;     //热插拔事件

}; 

 

struct kset_uevent_ops

{

　　int (*filter)(struct kset *kset,struct kobject *kobj);

　　const char *(*name)(struct kset *kset,struct kobject *kobj);

　　int (*uevent)(struct kset *kset,struct kobject *kobj,struct kobj_uevent_ent *env);

};

 

kset和kobject关系：

1,kset集合包含了属于其的kobject结构体，kset.list链表用来 连接第一个和最后一个kobject对象。第一个kobject使用entry连接kset集合和第二个kobject对象。第二个kobject对象使用entry连接第一个kobject对象和第三个kobject对象，依次类推，最终形成了一个kobject对象的链表

2，所有的kobject结构的parent指针指向kset包含的kobject对象，构成一个父子层次关系

3，kobject的所有kset指针指向包含它的kset集合，所以通过kobject对象很容易就能找到kset集合

4，kobject的kobj_type指针指向自身的kobj_type，每一个kobject都有一个单独的kobj_type结构。另外在kset集合中也有一个kobject结构体，该结构体的XXX也指向一个kobj_type结构体。可知，kobj_type中定义了一组属性和操作属性的方法。这里注意：kset中kobj_type的优先级要高于kobject对象中的kobj_type的优先级。如果两个kobj_type都存在，那么优先调用kset中的函数。如果kset中的kobj_type为空，才调用各个kobject结构体本身对应的kobj_type中的函数

5，kset中的kobj也负责对kset的引用计数

 

kset操作

void kset_init(struct kset *k)  //初始化

{

　　kobject_init_internal(&k->kobj);

　　INIT_LIST_HEAD(&k->list);

　　spin_lock_init(&k->list_lock);

}

 

int kset_register(struct kset *k); //注册函数

void kset_unregister(struct kset *k);  //注销函数

static inline struct kset *kset_get(struct kset *k);

static inline void kset_put(struct kset *k);

 

设备驱动模型的三大组件

总线：

　struct bus_type

{

　　const char *name;

　　struct bus_attribute *bus_attrs;

　　struct device_attribute *dev_attrs;

　　struct driver_attribute *drv_attrs;

　　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 (*suspend)(struct device *dev,pm_message_t state);

　　int (*suspend_late)(struct device *dev,pm_message_t state);

　　int (*resume_early)(struct device *dev);

　　

　　struct dev_pm_ops *pm;

　　struct bus_type_private *p;

};

 

struct bus_type_private

{

　　struct kset subsys;  //代表该bus子系统，里面的kobj是该bus的主kobj，也就是最顶层

　　struct kset *drivers_kset;  //挂载到该总线上的所有驱动集合

　　struct kset * devices_kset;  //挂载到该总线上的所有设备集合

　　struct klist klist_devices;  //所有的设备列表

　　struct klist klist_drivers;  //所有的驱动程序列表

　　struct block_notifier_head bus_notifier;

　　unsigned int drivers_autoprobe:1; //设置是否在驱动注册是，自动弹出设备

　　struct bus_type *bus;  //回指向包含自己的总线

};

 

int bus_register(struct bus_type *bus);

void bus_unregister(struct bus_type *bus);

 

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);

};

int bus_create_file(struct bus_type *bus,struct bus_attribute *attr);

void bus_remove_file(struct bus_type *bus,struct bus_attribute *attr);

 

设备：

　struct device

{

　　struct klist klist_children;   //连接子设备的链表

　　struct device *parent;     //指向父设备的指针

　　struct kobject kobj;      //内嵌的kobject

　　char bus_id[BUS_ID_SIZE];   //连接到总线上的位置

　　unsigned uevent_supress:1;  //是否支持热插拔事件

　　const char *init_name;       //设备的初始化名字

　　struct device_type *type;   //设备相关的特殊处理函数

　　struct bus_type *bus;    //指向连接的总线指针

　　struct device_driver *driver;  //指向该设备的驱动程序

　　void *driver_data;   //指向驱动程序私有数据的指针

　　struct dev_pm_info power;  //电源管理信息

　　dev_t devt;    //设备号

　　struct class *class; //指向设备所属类

　　struct attribute_group **groups; //设备的组属性

　　void (*release)(struct device *dev);  //释放设备描述符的回调函数

　　...

};

 

int device_register(struct device *dev);

void device_unregister(struct device *dev);

 

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);

};

 

int device_create_file(struct device *device,struct device_attribute);

void device_remove_file(struct device *dev,struct device_attribute *attr);

 

 

驱动：

struct device_driver

{

　　const char *name;　　//设备驱动名字

　　struct bus_type *bus;  //指向驱动属于的总线，总线上有很多设备

　　struct module *owner;   //设备驱动自身模块

　　const char *mod_name;  //设备驱动名字

　　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);

　　struct attribute_group **group;

　　struct dev_pm_ops *pm;

　　struct driver_private *p;

};

 

struct driver_private

{

　　struct kobject kobj;   //内嵌kobject结构，用来构建设备驱动程序模型

　　struct klist klist_devices;  //该驱动支持的所有设备链表

　　struct klist_node knode_bus;  //该驱动所属总线

　　struct module_kobject *mkobj;  //驱动的模块

　　struct device_driver *driver;  //指向驱动本身

};

 

int driver_register(struct device_driver *drv);

void driver_unregister(struct device_driver *drv);

 

struct driver_attribute

{

　　struct attribute attr;

　　ssize_t (*show)(struct device_driver *driver ,char *buf);

　　ssize_t (*store)(struct device_driver*driver,const char *buf,size_t count);

};

 

int driver_create_file(struct device_driver *drv,struct driver_attribute *attr);

void driver_remove_file(struct device_driver *drv,struct driver_attribute *attr);