Linux总线设备驱动实现过程(附代码)

小.易

总线驱动设备模型：

• 1、总线驱动设备模型只是提供一种机制，将驱动程序分为device和driver两部分并彼此建立联系
• 2、注册device过程：
•     a、将device放入bus的dev链表
•     b、从bus的drv链表取出每一个driver，用bus的match函数判断取出的driver能否支持这个device（判断name）
•     c、如果支持，调用该driver的probe函数（probe函数自由实现）
• 3、注册driver过程：
•     a、将driver放入bus的drv链表
•     b、从bus的dev链表取出每一个device，用bus的match函数判断这个driver能否支持取出的device（判断name）
•     c、如果支持，调用该driver的probe函数（probe函数自由实现）
  

在linux系统总线存在目录/sys/bus/

总线结构体：描述一个总线，管理device和driver，完成匹配
struct bus_type {
    const char        *name;                                                    /*总线名*/
    const char        *dev_name;
    struct device        *dev_root;
    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 (*resume)(struct device *dev);
    const struct dev_pm_ops *pm;
    struct iommu_ops *iommu_ops;
    struct subsys_private *p;

};
总线注册和注销
    int bus_register(struct bus_type *bus)
    void bus_unregister(struct bus_type *bus)

/=================================================================/
device对象
struct device {
    struct kobject kobj;　　//所有对象的父类
    const char        *init_name; // 在总线中会有一个名字，用于做匹配
    struct bus_type    *bus; //指向该device对象依附于总线的对象
    void        *platform_data; // 自定义的数据,指向任何类型数据
｝
device对象注册和注销的方法：
    int device_register(struct device *dev)
    void device_unregister(struct device *dev)
/=================================================================/
driver对象：描述设备驱动的方法(代码逻辑)
struct device_driver {
    const char        *name;
    // 在总线中会有一个名字，用于做匹配，在/sys/bus/mybus/drivers/名字
    struct bus_type        *bus;//指向该driver对象依附于总线的对象
    int (*probe) (struct device *dev); // 如果device和driver匹配之后，driver要做的事情
    int (*remove) (struct device *dev); // 如果device和driver从总线移除之后，driver要做的事情
}
driver对象注册和注销：
    int driver_register(struct device_driver *drv)
    void driver_unregister(struct device_driver *drv)

总线代码：

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. #include <linux/device.h>
   
4. 
   
5. 
   
6. int mybus_match(struct device *dev, struct device_driver *drv)
   
7. {
   
8.         //如果匹配成功，match方法一定要返回一个1， 失败返回0
   
9.         if(!strncmp(drv->name, dev->kobj.name, strlen(drv->name)))
   
10.         {
    
11.                 printk("match ok\n");
    
12.                 return 1;
    
13.         }else{
    
14.                 printk("match failed\n");
    
15.                 return 0;
    
16. 
    
17.         }
    
18.         return 0;
    
19. }
    
20. 
    
21. 
    
22. //实例化一个bus对象
    
23. struct bus_type mybus = {
    
24.         .name = "mybus",
    
25.         .match = mybus_match,
    
26. };
    
27. 
    
28. EXPORT_SYMBOL(mybus);//使用EXPORT_SYMBOL可以将一个函数以符号的方式导出给其他模块使用
    
29. 
    
30. static int __init mybus_init(void)
    
31. {
    
32.         printk("----------%s-------------\n", __FUNCTION__);
    
33.         int ret;
    
34. 
    
35.         //构建一个总线
    
36.         // /sys/bus/mybus
    
37.         ret = bus_register(&mybus);
    
38.         if(ret != 0)
    
39.         {
    
40.                 printk("bus_register error\n");
    
41.                 return ret;
    
42.         }
    
43.         return 0;
    
44. }
    
45. 
    
46. static void __exit mybus_exit(void)
    
47. {
    
48.         printk("----------%s-------------\n", __FUNCTION__);
    
49.         bus_unregister(&mybus);
    
50.         
    
51. }
    
52. 
    
53. module_init(mybus_init);
    
54. module_exit(mybus_exit);
    
55. MODULE_LICENSE("GPL");
    
56. 
    

复制代码

driver代码：

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. #include <linux/device.h>
   
4. #include <linux/io.h>
   
5. int mydrv_probe(struct device *dev)
   
6. {
   
7.         printk("----------%s-------------\n", __FUNCTION__);
   
8.         
   
9.         return 0;
   
10. }
    
11. 
    
12. int mydrv_remove(struct device *dev)
    
13. {
    
14. 
    
15.         printk("----------%s-------------\n", __FUNCTION__);
    
16.         return 0;
    
17. }
    
18. 
    
19. extern struct bus_type mybus;
    
20. 
    
21. struct device_driver mydrv = {
    
22.         .name = "my_dev_drv",
    
23.         .bus = &mybus,
    
24.         .probe = mydrv_probe,
    
25.         .remove = mydrv_remove,
    
26. };
    
27. 
    
28. 
    
29. static int __init mydrv_init(void)
    
30. {
    
31.         printk("----------%s-------------\n", __FUNCTION__);
    
32.         //将driver注册到总线中
    
33.         int ret;
    
34.         ret  = driver_register(&mydrv);
    
35.         if(ret < 0)
    
36.         {
    
37.                 printk("device_register error\n");
    
38.                 return ret;
    
39.         }
    
40.         
    
41. 
    
42.         return 0;
    
43. }
    
44. static void __exit mydrv_exit(void)
    
45. {
    
46. 
    
47.         printk("----------%s-------------\n", __FUNCTION__);
    
48.         driver_unregister(&mydrv);
    
49. }
    
50. 
    
51. 
    
52. 
    
53. 
    
54. 
    
55. module_init(mydrv_init);
    
56. module_exit(mydrv_exit);
    
57. MODULE_LICENSE("GPL");
    
58. 
    

复制代码

device代码：

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. #include <linux/device.h>
   
4. #include "dev_info.h"
   
5. extern struct bus_type mybus;
   
6. void        mydev_release(struct device *dev)
   
7. {
   
8. 
   
9.         printk("----------%s-------------\n", __FUNCTION__);
   
10. }
    
11. 
    
12. //构建一个device对象
    
13. struct device  mydev= {
    
14.         .init_name = "my_dev_drv",
    
15.         .bus = &mybus,
    
16.         .release = mydev_release,
    
17. };
    
18. 
    
19. 
    
20. 
    
21. static int __init mydev_init(void)
    
22. {
    
23.         printk("----------%s-------------\n", __FUNCTION__);
    
24.         //将device注册到总线中
    
25.         int ret;
    
26.         ret  = device_register(&mydev);
    
27.         if(ret < 0)
    
28.         {
    
29.                 printk("device_register error\n");
    
30.                 return ret;
    
31.         }
    
32.         
    
33. 
    
34.         return 0;
    
35. }
    
36. 
    
37. static void __exit mydev_exit(void)
    
38. {
    
39. 
    
40.         printk("----------%s-------------\n", __FUNCTION__);
    
41.         device_unregister(&mydev);
    
42. 
    
43. }
    
44. 
    
45. 
    
46. 
    
47. module_init(mydev_init);
    
48. module_exit(mydev_exit);
    
49. MODULE_LICENSE("GPL");
    
50. 
    

复制代码

---------------------
参考文章https://blog.csdn.net/hfutyyj/article/details/80248904