程序博客网 > 阿里巴巴程序员工资待遇

Linux设备驱动工程师之路——设备模型（下）上层模型

来源：互联网 发布：阿里巴巴程序员工资待遇 编辑：程序博客网 时间：2024/06/06 08:29

Linux设备驱动工程师之路——设备模型（下）上层模型

K-Style

转载请注明来自于衡阳师范学院08电2  Y-Kee http://blog.csdn.net/ayangke,QQ:843308498

 

一、重要知识点：

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

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

         1.总线

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

         总线描述

 

[html] view plain copy
  1.         struct bus_type {  
  2.          const char                  *name;//总线名称  
  3.          struct bus_attribute        *bus_attrs//总线属性  
  4.          struct device_attribute   *dev_attrs;//设备属性  
  5.          struct driver_attribute    *drv_attrs;//驱动属性  
  6.          int (*match)(struct device *dev, struct device_driver *drv);  
  7.          int (*uevent)(struct device *dev, struct kobj_uevent_env *env);  
  8.          int (*probe)(struct device *dev);  
  9.          int (*remove)(struct device *dev);  
  10.          void (*shutdown)(struct device *dev);  
  11.          int (*suspend)(struct device *dev, pm_message_t state);  
  12.          int (*suspend_late)(struct device *dev, pm_message_t state);  
  13.          int (*resume_early)(struct device *dev);  
  14.          int (*resume)(struct device *dev);  
  15.          struct dev_pm_ops *pm;  
  16.          struct bus_type_private *p;  
  17. };  

bus_type的bus_type_private 成员

[html] view plain copy
  1. struct bus_type_private {  
  2. struct kset subsys;  
  3. struct kset *drivers_kset;  
  4. struct kset *devices_kset;  
  5. struct klist klist_devices;  
  6. struct klist klist_drivers;  
  7. struct blocking_notifier_head bus_notifier;  
  8. unsigned int drivers_autoprobe:1;  
  9. struct bus_type *bus;  
  10. };  


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

总线的注册：

int bus_register(structbus_type *bus);

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

我们在深入看这个函数

[html] view plain copy
  1. int bus_register(struct bus_type *bus)  
  2. {  
  3. int retval;  
  4. struct bus_type_private *priv;  
  5. priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL);  
  6. if (!priv)  
  7. return -ENOMEM;  
  8. priv->bus = bus;  
  9. bus->p = priv;  
[html] view plain copy
  1. BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);  
  2. retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);  
  3. if (retval)  
  4. goto out;  
  5.   
  6. priv->subsys.kobj.kset = bus_kset;  
  7. priv->subsys.kobj.ktype = &bus_ktype;  
  8. priv->drivers_autoprobe = 1;  
  9.   
  10. retval = kset_register(&priv->subsys);  
  11. if (retval)  
  12. goto out;  
  13.   
  14. retval = bus_create_file(bus, &bus_attr_uevent);  
  15. if (retval)  
  16. goto bus_uevent_fail;  
  17.   
  18.   
  19. priv->devices_kset = kset_create_and_add("devices", NULL,  
  20. &priv->subsys.kobj);  
  21. if (!priv->devices_kset) {  
  22. retval = -ENOMEM;  
  23. goto bus_devices_fail;  
  24. }  
  25.   
  26.   
  27. priv->drivers_kset = kset_create_and_add("drivers", NULL,  
  28. &priv->subsys.kobj);  
  29. if (!priv->drivers_kset) {  
  30. retval = -ENOMEM;  
  31. goto bus_drivers_fail;  
  32. }  
  33.   
  34.   
  35. klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);  
  36. klist_init(&priv->klist_drivers, NULL, NULL);  
  37.   
  38. retval = add_probe_files(bus);  
  39. if (retval)  
  40. goto bus_probe_files_fail;  
  41.   
  42. retval = bus_add_attrs(bus);  
  43. if (retval)  
  44. goto bus_attrs_fail;  
  45.   
  46. pr_debug("bus: '%s': registered\n", bus->name);  
  47. return 0;  
  48.   
  49. bus_attrs_fail:  
  50. remove_probe_files(bus);  
  51. bus_probe_files_fail:  
  52. kset_unregister(bus->p->drivers_kset);  
  53. bus_drivers_fail:  
  54. kset_unregister(bus->p->devices_kset);  
  55. bus_devices_fail:  
  56. bus_remove_file(bus, &bus_attr_uevent);  
  57. bus_uevent_fail:  
  58. kset_unregister(&bus->p->subsys);  
  59. kfree(bus->p);  
  60. out:  
  61. return retval;  
  62. }  


从这里

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.设备

[html] view plain copy
  1. struct device {  
  2. struct klist klist_children;  
  3. struct klist_nodeknode_parent;/* node in sibling list */  
  4. struct klist_nodeknode_driver;  
  5. struct klist_nodeknode_bus;  
  6. struct device *parent;  
  7. struct kobject kobj;  
  8. char bus_id[BUS_ID_SIZE];/* position on parent bus */  
  9. unsigned uevent_suppress:1;  
  10. const char *init_name; /* initial name of the device */  
  11. struct device_type*type;  
  12.   
  13. struct semaphoresem;/* semaphore to synchronize calls to  
  14. * its driver.  
  15. */  
  16. struct bus_type*bus;/* type of bus device is on */  
  17. struct device_driver *driver;/* which driver has allocated this  
  18.   device */  
  19. void *driver_data;/* data private to the driver */  
  20. void *platform_data;/* Platform specific data, device  
  21.   core doesn't touch it */  
  22. struct dev_pm_infopower;  
  23.   
  24.   
  25. #ifdef CONFIG_NUMA  
  26. int numa_node;/* NUMA node this device is close to */  
  27. #endif  
  28. u64 *dma_mask;/* dma mask (if dma'able device) */  
  29. u64 coherent_dma_mask;/* Like dma_mask, but for  
  30.     alloc_coherent mappings as  
  31.     not all hardware supports  
  32.     64 bit addresses for consistent  
  33.     allocations such descriptors. */  
  34.   
  35.   
  36. struct device_dma_parameters *dma_parms;  
  37.   
  38.   
  39. struct list_headdma_pools;/* dma pools (if dma'ble) */  
  40.   
  41.   
  42. struct dma_coherent_mem*dma_mem; /* internal for coherent mem  
  43.     override */  
  44. /* arch specific additions */  
  45. struct dev_archdataarchdata;  
  46.   
  47. dev_t devt;/* dev_t, creates the sysfs "dev" */  
  48.   
  49. spinlock_t devres_lock;  
  50. struct list_headdevres_head;  
  51.   
  52.   
  53. struct klist_nodeknode_class;  
  54. struct class *class;  
  55. struct attribute_group**groups;/* optional groups */  
  56.   
  57. void (*release)(struct device *dev);  
  58. };  


可以看出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描述：

[html] view plain copy
  1. struct device_driver {  
  2. const char *name;  
  3. struct bus_type*bus;  
  4.   
  5.   
  6. struct module *owner;  
  7. const char *mod_name;/* used for built-in modules */  
  8.   
  9.   
  10. int (*probe) (struct device *dev);  
  11. int (*remove) (struct device *dev);  
  12. void (*shutdown) (struct device *dev);  
  13. int (*suspend) (struct device *dev, pm_message_t state);  
  14. int (*resume) (struct device *dev);  
  15. struct attribute_group **groups;  
  16.   
  17.   
  18. struct dev_pm_ops *pm;  
  19.   
  20.   
  21. struct driver_private *p;  
  22. };  


在看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

[html] view plain copy
  1. #include <linux/device.h>  
  2. #include <linux/module.h>  
  3. #include <linux/kernel.h>  
  4. #include <linux/init.h>  
  5. #include <linux/string.h>  
  6.   
  7. MODULE_AUTHOR("David Xie");  
  8. MODULE_LICENSE("Dual BSD/GPL");  
  9.   
  10. static char *Version = "$Revision: 1.9 {1}quot;;  
  11.   
  12. static int my_match(struct device *dev, struct device_driver *driver)  
  13. {  
  14.     return !strncmp(dev->bus_id, driver->name, strlen(driver->name));  
  15. }  
  16.   
  17. static void my_bus_release(struct device *dev)  
  18. {  
  19.     printk(KERN_DEBUG "my bus release\n");  
  20. }  
  21.       
  22. struct device my_bus = {  
  23.     .bus_id   = "my_bus0",  
  24.     .release  = my_bus_release  
  25. };  
  26.   
  27.   
  28. struct bus_type my_bus_type = {  
  29.     .name = "my_bus",  
  30.     .match = my_match,  
  31. };  
  32.   
  33. EXPORT_SYMBOL(my_bus);  
  34. EXPORT_SYMBOL(my_bus_type);  
  35.   
  36.   
  37. /*  
  38.  * Export a simple attribute.  
  39.  */  
  40. static ssize_t show_bus_version(struct bus_type *bus, char *buf)  
  41. {  
  42.     return snprintf(buf, PAGE_SIZE, "%s\n", Version);  
  43. }  
  44.   
  45. static BUS_ATTR(version, S_IRUGO, show_bus_version, NULL);  
  46.   
  47.   
  48. static int __init my_bus_init(void)  
  49. {  
  50.     int ret;  
  51.           
  52.         /*注册总线*/  
  53.     ret = bus_register(&my_bus_type);  
  54.     if (ret)  
  55.         return ret;  
  56.           
  57.     /*创建属性文件*/    
  58.     if (bus_create_file(&my_bus_type, &bus_attr_version))  
  59.         printk(KERN_NOTICE "Fail to create version attribute!\n");  
  60.       
  61.     /*注册总线设备*/  
  62.     ret = device_register(&my_bus);  
  63.     if (ret)  
  64.         printk(KERN_NOTICE "Fail to register device:my_bus!\n");  
  65.           
  66.     return ret;  
  67. }  
  68.   
  69. static void my_bus_exit(void)  
  70. {  
  71.     device_unregister(&my_bus);  
  72.     bus_unregister(&my_bus_type);  
  73. }  
  74.   
  75. module_init(my_bus_init);  
  76. module_exit(my_bus_exit);  

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

测试结果：



2.DEVICE

[html] view plain copy
  1. #include <linux/device.h>  
  2. #include <linux/module.h>  
  3. #include <linux/kernel.h>  
  4. #include <linux/init.h>  
  5. #include <linux/string.h>  
  6.   
  7. MODULE_AUTHOR("David Xie");  
  8. MODULE_LICENSE("Dual BSD/GPL");  
  9.   
  10. extern struct device my_bus;   
  11. extern struct bus_type my_bus_type;  
  12.   
  13. /* Why need this ?*/  
  14. static void my_dev_release(struct device *dev)  
  15. {   
  16.       
  17. }  
  18.   
  19. struct device my_dev = {  
  20.     .bus = &my_bus_type,  
  21.     .parent = &my_bus,  
  22.     .release = my_dev_release,  
  23. };  
  24.   
  25. /*  
  26.  * Export a simple attribute.  
  27.  */  
  28. static ssize_t mydev_show(struct device *dev, char *buf)  
  29. {  
  30.     return sprintf(buf, "%s\n", "This is my device!");  
  31. }  
  32.   
  33. static DEVICE_ATTR(dev, S_IRUGO, mydev_show, NULL);  
  34.   
  35. static int __init my_device_init(void)  
  36. {  
  37.     int ret = 0;  
  38.           
  39.         /* 初始化设备 */  
  40.     strncpy(my_dev.bus_id, "my_dev", BUS_ID_SIZE);  
  41.           
  42.         /*注册设备*/  
  43.     device_register(&my_dev);  
  44.           
  45.     /*创建属性文件*/  
  46.     device_create_file(&my_dev, &dev_attr_dev);  
  47.       
  48.     return ret;   
  49.   
  50. }  
  51.   
  52. static void my_device_exit(void)  
  53. {  
  54.     device_unregister(&my_dev);  
  55. }  
  56.   
  57. module_init(my_device_init);  
  58. module_exit(my_device_exit);  

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

         测试结果：


3.DRIVER

[html] view plain copy
  1. #include <linux/device.h>  
  2. #include <linux/module.h>  
  3. #include <linux/kernel.h>  
  4. #include <linux/init.h>  
  5. #include <linux/string.h>  
  6.   
  7. MODULE_AUTHOR("David Xie");  
  8. MODULE_LICENSE("Dual BSD/GPL");  
  9.   
  10. extern struct bus_type my_bus_type;  
  11.   
  12. static int my_probe(struct device *dev)  
  13. {  
  14.     printk("Driver found device which my driver can handle!\n");  
  15.     return 0;  
  16. }  
  17.   
  18. static int my_remove(struct device *dev)  
  19. {  
  20.     printk("Driver found device unpluged!\n");  
  21.     return 0;  
  22. }  
  23.   
  24. struct device_driver my_driver = {  
  25.     .name = "my_dev",  
  26.     .bus = &my_bus_type,  
  27.     .probe = my_probe,  
  28.         .remove = my_remove,  
  29. };  
  30.   
  31. /*  
  32.  * Export a simple attribute.  
  33.  */  
  34. static ssize_t mydriver_show(struct device_driver *driver, char *buf)  
  35. {  
  36.     return sprintf(buf, "%s\n", "This is my driver!");  
  37. }  
  38.   
  39. static DRIVER_ATTR(drv, S_IRUGO, mydriver_show, NULL);  
  40.   
  41. static int __init my_driver_init(void)  
  42. {  
  43.     int ret = 0;  
  44.           
  45.         /*注册驱动*/  
  46.     driver_register(&my_driver);  
  47.           
  48.     /*创建属性文件*/  
  49.     driver_create_file(&my_driver, &driver_attr_drv);  
  50.       
  51.     return ret;   
  52.   
  53. }  
  54.   
  55. static void my_driver_exit(void)  
  56. {  
  57.     driver_unregister(&my_driver);  
  58. }  
  59.   
  60. module_init(my_driver_init);  
  61. module_exit(my_driver_exit);  

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

 

测试结果：


0 0
阿里巴巴程序员工资待遇 阿里巴巴程序员工资待遇
原创粉丝点击
热门IT博客
淘宝权哪个平台直播淘宝权哪个平台直播
淘宝banner加链接淘宝banner加链接
mac 微信字体设置
mac app store没有wps
淘宝什么利润大好卖
经营淘宝店辛苦吗
蔡依林 知乎
db2 sql 加法
淘宝网第三方充值平台
app上传图片 java
淘宝工厂店都是真的吗
windows一直检查更新
部落冲突 法师数据
淘宝上的那些装修全包
数据变化趋势分析方法
语音王软件下载
网络小贷恐吓怎么解决
投稿系统源码
matlab矩阵计算器代码
aape淘宝有正品店铺嘛
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 哪里有大巴出租 出租旅游大巴车 婚庆大巴租赁 大巴车座套广告 12308汽车票 绵阳汽车票网上订票 daba 12308汽车票网上订票 汽车票 汽车票网上订票 网上订票 汽车巴士 汽车票购买 班车查询 长途客车 杭州萧山机场大巴 2019西安机场大巴发车时间表 杭州萧山机场大巴时刻表 大布 潘大帅减肥 黑大帅 大帅府 大帅 潘大帅 大帅府门票 沈阳大帅府 陶大帅 不良人大帅 张大帅 萧大帅 猛大帅 大帅府简介 大帅夫人 恭送大帅 特大帅老0 大帅传奇 黑大帅图片 回到民国当大帅 回民国当大帅 潘大帅在减肥 夫人大帅又在作死

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里