驱动之路-设备模型（下）上层模型

一、重要知识点：

         设备模型由总线、设备、驱动三要素组成。

底层模型决定上层模型，在总线，设备，驱动的结构体中你总是可以看到它们间接或者直接的包含了kobject结构或kset结构。

         1.总线

         总线是处理器和设备之间的通道，在设备模型中，所有设备都通过总线相连，甚至内部的虚拟“platform”总线。在linux设备模型中，总线由bus_type结构表示。定义在<linux/device>中。

         总线描述

 

•         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);  
•          int (*resume)(struct device *dev);  
•          struct dev_pm_ops *pm;  
•          struct bus_type_private *p;  
• };  

 

bus_type的bus_type_private 成员

 

• struct bus_type_private {  
• struct kset subsys;  
• struct kset *drivers_kset;  
• struct kset *devices_kset;  
• struct klist klist_devices;  
• struct klist klist_drivers;  
• struct blocking_notifier_head bus_notifier;  
• unsigned int drivers_autoprobe:1;  
• struct bus_type *bus;  
• };  

 

可以看出该结构体中包含了有device和dirver的kset对象。

总线的注册：

int bus_register(structbus_type *bus);

如果成功，新的总线将被添加到系统，在/sys/bus目录下可以看到。

我们在深入看这个函数

 

• int bus_register(struct bus_type *bus)  
• {  
• int retval;  
• struct bus_type_private *priv;  
• priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL);  
• if (!priv)  
• return -ENOMEM;  
• priv->busbus = bus;  
• bus->p = priv;  

• BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);  
• retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);  
• if (retval)  
• goto out;  
•   
• priv->subsys.kobj.kset = bus_kset;  
• priv->subsys.kobj.ktype = &bus_ktype;  
• priv->drivers_autoprobe = 1;  
•   
• retval = kset_register(&priv->subsys);  
• if (retval)  
• goto out;  
•   
• retval = bus_create_file(bus, &bus_attr_uevent);  
• if (retval)  
• goto bus_uevent_fail;  
•   
•   
• priv->devices_kset = kset_create_and_add("devices", NULL,  
• &priv->subsys.kobj);  
• if (!priv->devices_kset) {  
• retval = -ENOMEM;  
• goto bus_devices_fail;  
• }  
•   
•   
• priv->drivers_kset = kset_create_and_add("drivers", NULL,  
• &priv->subsys.kobj);  
• if (!priv->drivers_kset) {  
• retval = -ENOMEM;  
• goto bus_drivers_fail;  
• }  
•   
•   
• klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);  
• klist_init(&priv->klist_drivers, NULL, NULL);  
•   
• retval = add_probe_files(bus);  
• if (retval)  
• goto bus_probe_files_fail;  
•   
• retval = bus_add_attrs(bus);  
• if (retval)  
• goto bus_attrs_fail;  
•   
• pr_debug("bus: '%s': registered\n", bus->name);  
• return 0;  
•   
• bus_attrs_fail:  
• remove_probe_files(bus);  
• bus_probe_files_fail:  
• kset_unregister(bus->p->drivers_kset);  
• bus_drivers_fail:  
• kset_unregister(bus->p->devices_kset);  
• bus_devices_fail:  
• bus_remove_file(bus, &bus_attr_uevent);  
• bus_uevent_fail:  
• kset_unregister(&bus->p->subsys);  
• kfree(bus->p);  
• out:  
• return retval;  
• }  

 

从这里

priv->subsys.kobj.kset = bus_kset;
priv->subsys.kobj.ktype = &bus_ktype;

可以看得出总线初始化了自己的kset对象。

总线的删除

void bus_unregister(struct bus_type *bus);

总线的match方法

int (*match)(struct device *dev, struct device_driver *drv);

当一个新设备或者驱动被添加到这个总线时，该方法被调用，用于判断指定的驱动程序是否能处理指定的设备。若可以，则返回非0值。下面的测试程序采用匹配设备的dev->bus_id字符串和驱动的drv->name字符串是否相同来判断驱动是否能处理该设备。

总线uevent方法

int  (*uevent)(structdevice *dev, char **envp, int num_envp)

在为用户产生热插拔事件之前，这个方法允许总线添加环境变量。

总线属性由结构bus_attribute描述：

 

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_ATTR(name,mode, show, store)

在编译时创建和初始化bus_attribute结构，它将bus_attr_作为给定前缀来创建总线的真正名称。

如：static BUS_ATTR(version, S_IRUGO, show_bus_version, NULL);

将创建一个bus_attr_version结构体对象。

 

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

创建属性文件

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

删除属性文件

 

2.设备

 

• struct device {  
• struct klist klist_children;  
• struct klist_nodeknode_parent;/* node in sibling list */  
• struct klist_nodeknode_driver;  
• struct klist_nodeknode_bus;  
• struct device *parent;  
• struct kobject kobj;  
• char bus_id[BUS_ID_SIZE];/* position on parent bus */  
• unsigned uevent_suppress:1;  
• const char *init_name; /* initial name of the device */  
• struct device_type*type;  
•   
• struct semaphoresem;/* semaphore 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 *driver_data;/* data private to the driver */  
• void *platform_data;/* Platform specific data, device  
•   core doesn't touch it */  
• struct dev_pm_infopower;  
•   
•   
• #ifdef CONFIG_NUMA  
• int numa_node;/* NUMA node this device is close to */  
• #endif  
• 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. */  
•   
•   
• struct device_dma_parameters *dma_parms;  
•   
•   
• struct list_headdma_pools;/* dma pools (if dma'ble) */  
•   
•   
• struct dma_coherent_mem*dma_mem; /* internal for coherent mem  
•     override */  
• /* arch specific additions */  
• struct dev_archdataarchdata;  
•   
• dev_t devt;/* dev_t, creates the sysfs "dev" */  
•   
• spinlock_t devres_lock;  
• struct list_headdevres_head;  
•   
•   
• struct klist_nodeknode_class;  
• struct class *class;  
• struct attribute_group**groups;/* optional groups */  
•   
• void (*release)(struct device *dev);  
• };  

可以看出device结构体中也包含了一个kobject对象

 

intdevice_register(struct device *dev);

注册设备

vioddevice_unregister(struct device *dev)

注销设备

设备属性由struct device_attribute描述

structdevice_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 *dev, struct device_attibute *entry)

创建属性文件

void device_remove_file(struct device *dev, struct device_attibute *entry)

删除属性文件

3.驱动

驱动程序由struct device_driver描述：

 

• struct device_driver {  
• const char *name;  
• struct bus_type*bus;  
•   
•   
• struct module *owner;  
• const char *mod_name;/* used for built-in modules */  
•   
•   
• 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 **groups;  
•   
•   
• struct dev_pm_ops *pm;  
•   
•   
• struct driver_private *p;  
• };  

在看device_dirver的driver_private 对象

struct driver_private {
struct kobject kobj;
struct klist klist_devices;
struct klist_node knode_bus;
struct module_kobject *mkobj;
struct device_driver *driver;
};

 可以看出driver_private结构体中也包含了一个kobject对象。和连接设备的链表。

当总线的match返回非0值，也就是总线找到与驱动相匹配的设备时，驱动的probe的函数将被调用。

当设备从系统总删除是remove被调用。

当系统关机的时候shutdown被调用。

int driver_register(structdevice_driver *drv)

在总线上注册驱动

void driver_unregister(struct device_driver *drv)

载总线上注销驱动

         驱动的属性使用structdriver_attribute来描述

         structdriver_attribute{

                   structattribue attr;

                   ssize_t(*show)(struct device_driver *drv, const char *buf);

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

         }

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

         创建属性文件

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

         删除属性文件

 

二、测试模块

         1.BUS

• #include <linux/device.h>  
• #include <linux/module.h>  
• #include <linux/kernel.h>  
• #include <linux/init.h>  
• #include <linux/string.h>  
•   
• MODULE_AUTHOR("David Xie");  
• MODULE_LICENSE("Dual BSD/GPL");  
•   
• static char *Version = "$Revision: 1.9 {1}quot;;  
•   
• static int my_match(struct device *dev, struct device_driver *driver)  
• {  
•     return !strncmp(dev->bus_id, driver->name, strlen(driver->name));  
• }  
•   
• static void my_bus_release(struct device *dev)  
• {  
•     printk(KERN_DEBUG "my bus release\n");  
• }  
•       
• struct device my_bus = {  
•     .bus_id   = "my_bus0",  
•     .release  = my_bus_release  
• };  
•   
•   
• struct bus_type my_bus_type = {  
•     .name = "my_bus",  
•     .match = my_match,  
• };  
•   
• EXPORT_SYMBOL(my_bus);  
• EXPORT_SYMBOL(my_bus_type);  
•   
•   
• /*  
•  * Export a simple attribute.  
•  */  
• static ssize_t show_bus_version(struct bus_type *bus, char *buf)  
• {  
•     return snprintf(buf, PAGE_SIZE, "%s\n", Version);  
• }  
•   
• static BUS_ATTR(version, S_IRUGO, show_bus_version, NULL);  
•   
•   
• static int __init my_bus_init(void)  
• {  
•     int ret;  
•           
•         /*注册总线*/  
•     ret = bus_register(&my_bus_type);  
•     if (ret)  
•         return ret;  
•           
•     /*创建属性文件*/    
•     if (bus_create_file(&my_bus_type, &bus_attr_version))  
•         printk(KERN_NOTICE "Fail to create version attribute!\n");  
•       
•     /*注册总线设备*/  
•     ret = device_register(&my_bus);  
•     if (ret)  
•         printk(KERN_NOTICE "Fail to register device:my_bus!\n");  
•           
•     return ret;  
• }  
•   
• static void my_bus_exit(void)  
• {  
•     device_unregister(&my_bus);  
•     bus_unregister(&my_bus_type);  
• }  
•   
• module_init(my_bus_init);  
• module_exit(my_bus_exit);  

创建一条名为my_bus_type的总线和一个名为my_bus的总线设备，注意总线也是一个设备，也需要注册。

测试结果：

 

2.DEVICE

• #include <linux/device.h>  
• #include <linux/module.h>  
• #include <linux/kernel.h>  
• #include <linux/init.h>  
• #include <linux/string.h>  
•   
• MODULE_AUTHOR("David Xie");  
• MODULE_LICENSE("Dual BSD/GPL");  
•   
• extern struct device my_bus;   
• extern struct bus_type my_bus_type;  
•   
• /* Why need this ?*/  
• static void my_dev_release(struct device *dev)  
• {   
•       
• }  
•   
• struct device my_dev = {  
•     .bus = &my_bus_type,  
•     .parent = &my_bus,  
•     .release = my_dev_release,  
• };  
•   
• /*  
•  * Export a simple attribute.  
•  */  
• static ssize_t mydev_show(struct device *dev, char *buf)  
• {  
•     return sprintf(buf, "%s\n", "This is my device!");  
• }  
•   
• static DEVICE_ATTR(dev, S_IRUGO, mydev_show, NULL);  
•   
• static int __init my_device_init(void)  
• {  
•     int ret = 0;  
•           
•         /* 初始化设备 */  
•     strncpy(my_dev.bus_id, "my_dev", BUS_ID_SIZE);  
•           
•         /*注册设备*/  
•     device_register(&my_dev);  
•           
•     /*创建属性文件*/  
•     device_create_file(&my_dev, &dev_attr_dev);  
•       
•     return ret;   
•   
• }  
•   
• static void my_device_exit(void)  
• {  
•     device_unregister(&my_dev);  
• }  
•   
• module_init(my_device_init);  
• module_exit(my_device_exit);  

注册一个bus_id即名字为my_dev的设备，该设备的bus成员指向上一步创建的my_bus_type总线，parent成员指向上一步创建的my_bus总线设备。

         测试结果：

 

3.DRIVER

• #include <linux/device.h>  
• #include <linux/module.h>  
• #include <linux/kernel.h>  
• #include <linux/init.h>  
• #include <linux/string.h>  
•   
• MODULE_AUTHOR("David Xie");  
• MODULE_LICENSE("Dual BSD/GPL");  
•   
• extern struct bus_type my_bus_type;  
•   
• static int my_probe(struct device *dev)  
• {  
•     printk("Driver found device which my driver can handle!\n");  
•     return 0;  
• }  
•   
• static int my_remove(struct device *dev)  
• {  
•     printk("Driver found device unpluged!\n");  
•     return 0;  
• }  
•   
• struct device_driver my_driver = {  
•     .name = "my_dev",  
•     .bus = &my_bus_type,  
•     .probe = my_probe,  
•         .remove = my_remove,  
• };  
•   
• /*  
•  * Export a simple attribute.  
•  */  
• static ssize_t mydriver_show(struct device_driver *driver, char *buf)  
• {  
•     return sprintf(buf, "%s\n", "This is my driver!");  
• }  
•   
• static DRIVER_ATTR(drv, S_IRUGO, mydriver_show, NULL);  
•   
• static int __init my_driver_init(void)  
• {  
•     int ret = 0;  
•           
•         /*注册驱动*/  
•     driver_register(&my_driver);  
•           
•     /*创建属性文件*/  
•     driver_create_file(&my_driver, &driver_attr_drv);  
•       
•     return ret;   
•   
• }  
•   
• static void my_driver_exit(void)  
• {  
•     driver_unregister(&my_driver);  
• }  
•   
• module_init(my_driver_init);  
• module_exit(my_driver_exit);  

创建一个名为“bus_dev”的驱动，并将bus成员指向第一步创建的my_bus_type总线

 

测试结果：