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

原创 于 2012-03-08 16:14:37 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#struct #module #file #null #测试 #parameters

本文深入解析了Linux设备模型的关键组成部分，包括总线、设备及驱动的结构与交互方式。介绍了核心结构体如bus_type、device和device_driver的功能，并通过示例代码展示了如何实现自定义总线、设备和驱动。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、重要知识点：

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

底层模型决定上层模型，在总线，设备，驱动的结构体中你总是可以看到它们间接或者直接的包含了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总线

 

测试结果：


评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值