linux设计平台设备驱动开发流程

wywywy

1平台总线概述
1.1平台总线概述
平台总线(Platform bus)是linux2.6内核加入的一种虚拟总线，是在linxu系统中最为重要的一种总线。
Linux系统中除了去支持这些实际的总线，USB总线，PCI总线，还支持虚拟总线，之前是自己创建总线并基于总线去创建驱动和设备。
linux提供了虚拟总线，平台总线(Platform bus)是linux为我们创建的虚拟总线，我们只需要去挂载驱动程序和设备。其同样具备总线的优势在于采用了总线的模型对设备与驱动进行了管理，这样提高了程序的可移植性
通过平台总线机制开发设备驱动的流程
创建和注册设备，将平台设备挂载到平台总线上
创建驱动
平台总线驱动与设备的匹配机制，前面自己创建总线，通过设备和驱动的名称匹配。platform大多数依然使用平台的设备和驱动名称相同进行匹配。
2.平台设备
平台设备使用struct platform_device来描述:

1. struct platform_device {
   
2. const char name; /设备名*/
   
3. int id; /设备编号，配合设备名使用/
   
4. struct device dev;
   
5. u32 num_resources;
   
6. struct resource resource; /设备资源*///基地址，中断号
   
7. }
   
8. 
   
9. struct resource {
   
10. resource_size_t start;
    
11. resource_size_t end;
    
12. const char *name;
    
13. unsigned long flags; /资源的类型///中断号，寄存器
    
14. struct resource *parent, *sibling, *child;
    
15. };

复制代码

2.2注册平台设备
注册平台设备，使用函数:
int platform_device_register(struct platform_device *pdev)

4.范例程序
将按键程序进行改写，采用平台设备方式编写。
key_dev.c

1. #include<linux/module.h>
   
2. #include<linux/init.h>
   
3. #include<linux/platform_device.h>
   
4. #define GPXCON  0x11000C20
   
5. #include<linux/interrupt.h>
   
6. #include<linux/irq.h>
   
7. #define GPXCON 0x11000C20
   
8. #define GPXDAT 0x11000C24
   
9. 
   
10. MODULE_LICENSE("GPL");
    
11. struct resource key_resource[]={
    
12.     [0]= {
    
13.         .start = GPXCON,
    
14.         .end = GPXCON+8,
    
15.         .flags = IORESOURCE_MEM,        
    
16.     },
    
17.     [1] = {
    
18.         .start = IRQ_EINT(9),
    
19.         .end = IRQ_EINT(10),
    
20.         .flags = IORESOURCE_IRQ,
    
21. 
    
22.     },
    
23. };
    
24. struct platform_device key_device = {
    
25.     .name = "my-key",
    
26.     .id = 0,
    
27.     .num_resources = 2,
    
28.     .resource = key_resource,
    
29. 
    
30. 
    
31. };
    
32. int keydev_init()
    
33. {
    
34.     platform_device_register(&key_device);
    
35. 
    
36. 
    
37. }
    
38. void keydev_exit()
    
39. {
    
40.     platform_device_unregister(&key_device);
    
41. 
    
42. 
    
43. }
    
44. module_init(keydev_init);
    
45. module_exit(keydev_exit);

复制代码

nsmod key_dev.ko
ls /sys/bus/platform/device
平台设备已经挂载到平台总线上
现在将平台驱动创建和注册
3.平台驱动
平台总线设备只是起到找到设备的作用，当匹配成功再按设备类型进行相应的注册。
3.1平台驱动描述
平台驱动使用struct platform_driver 描述：
struct platform_driver {
int (probe)(struct platform_device );//加载驱动，总线会将平台设备和设备驱动进行匹配，匹配成功则驱动调用probe。
int (remove)(struct platform_device );当设备移出时，驱动调用
……
}
3.2平台驱动注册
int platform_driver_register(struct platform_driver *)
下面将一个杂项设备采用平台设备的方式改写
key_drv

1. #include<linux/module.h>
   
2. #include<linux/init.h>
   
3. #include<linux/miscdevice.h>
   
4. #include<linux/fs.h>
   
5. #include<linux/interrupt.h>
   
6. #include<linux/io.h>
   
7. #include<linux/irq.h>
   
8. #include<linux/platform_device.h>
   
9. #include<linux/sched.h>
   
10. #include<linux/uaccess.h>
    
11. #include<linux/vmalloc.h>
    
12. #include<linux/slab.h>
    
13. MODULE_LICENSE("GPL");
    
14. 
    
15. unsigned int key_num = 0;
    
16. wait_queue_head_t key_queue;
    
17. struct work_struct *work1;
    
18. struct resource *res_irq;
    
19. struct resource *res_mem;
    
20. struct timer_list key_timer;
    
21. unsigned int *key_base;
    
22. void work1_fun(struct work_struct *work)
    
23. {
    
24.     mod_timer(&key_timer,jiffies+(HZ/10));
    
25. }
    
26. void key_timer_func(unsigned long data)
    
27. {
    
28.     unsigned int key_val;
    
29.     key_val = readl(key_base+1)&(0x1<<1);
    
30.     if(key_val==0)
    
31.     {
    
32.         key_num = 1;
    
33.     }
    
34.     key_val = readl(key_base+1)&(0x1<<2);
    
35.     if(key_val==0)
    
36.     {
    
37.         key_num = 2;
    
38. 
    
39.     }
    
40. 
    
41.     wake_up(&key_queue);
    
42. 
    
43. }
    
44. irqreturn_t key_int(int irq,void *dev_id)
    
45. {
    
46.     //检测是否发生了按键中断
    
47. 
    
48. 
    
49.     //清除按键中断
    
50. 
    
51.     //提交下半部
    
52.     schedule_work(work1);
    
53.     return 0;
    
54. }
    
55. void keyint()
    
56. {
    
57. 
    
58.     writel(readl(key_base)&~(0xff<<4)|(0xff<<4),key_base);
    
59. }
    
60. ssize_t key_read(struct file *filp, char __user *buf, size_t size, loff_t *pos)
    
61. {
    
62.     wait_event(key_queue,key_num);
    
63.     printk("in kernel :key num is %d\n",key_num);
    
64.     copy_to_user(buf, &key_num, 4);
    
65.     key_num = 0;
    
66.     return 4;
    
67. }
    
68. 
    
69. int key_open(struct inode *node,struct file *filp)
    
70. {
    
71.     return 0;
    
72. }
    
73. 
    
74. struct file_operations key_fops =
    
75. {
    
76.     .open = key_open,
    
77.     .read = key_read,
    
78. };
    
79. struct miscdevice key_miscdev = {
    
80. 
    
81.     .minor = 200,
    
82.     .name = "my-key",
    
83.     .fops = &key_fops,
    
84. };
    
85. 
    
86. int key_probe(struct platform_device *pdev)
    
87. {
    
88.     int ret,size;
    
89.     ret = misc_register(&key_miscdev);
    
90.     if(ret!=0)
    
91.     printk("register fail!\n");
    
92.     res_irq = platform_get_resource(pdev,IORESOURCE_IRQ,0);
    
93.     request_irq(res_irq->start,key_int,IRQF_TRIGGER_FALLING,"key",(void *)1);
    
94.     request_irq(res_irq->end,key_int,IRQF_TRIGGER_FALLING,"key",(void *)2);
    
95.     size =res_mem->end -res_mem->start;
    
96.     key_base = ioremap(res_mem->start,size);//将物理基地址转化为虚拟地址
    
97. 
    
98.     keyint();
    
99.     work1 = kmalloc(sizeof(struct work_struct),GFP_KERNEL);//创建工作
    
100. 
     
101.     INIT_WORK(work1,work1_fun);
     
102. 
     
103. init_timer(&key_timer);//初始化定时器
     
104. 
     
105.     key_timer.function = key_timer_func;//添加超时函数
     
106. 
     
107.     add_timer(&key_timer);//向内核注册
     
108. 
     
109.     init_waitqueue_head(&key_queue);//初始化等待队列
     
110. 
     
111.     return ret;
     
112. }
     
113. int key_remove(struct platform_device *pdev)
     
114. {
     
115.     free_irq(res_irq->start, 0);
     
116.     free_irq(res_irq->end,0);
     
117.     iounmap(key_base);
     
118.      misc_deregister(&key_miscdev);
     
119.     return 0;
     
120. }
     
121. 
     
122. struct platform_driver key_driver = {
     
123.     .probe =key_probe,
     
124.     .remove =key_remove,
     
125.     .driver = {
     
126.             .name = "my-key",
     
127.      },
     
128. };
     
129. static int button_init()
     
130. {
     
131.     return  platform_driver_register(&key_driver);
     
132. 
     
133. }
     
134. static void button_exit()
     
135. {
     
136.     platform_driver_unregister(&key_driver);
     
137. }
     
138. module_init(button_init);
     
139. module_exit(button_exit);

复制代码

insmod key_dev.ko
insmod key_drv.ko
mknod /dev/mykey c 10 200
./key_app
应用程序运行成功，平台总线设备模型对程序进行了优化。驱动程序可能包含几个层次，从总线方式看可以分为平台设备，从功能上看属于字符设备。USB从总线看设备上看，从功能上看有属于网络设备。直接放内核。