第十篇?关于设备驱动模型platform设备驱动示例

前些天，把案件驱动改成了input子系统，今天学习下platform子系统。
在linux2.6以后的设备驱动模型中，需关心总线、设备和驱动这3个实体。
1.总线：总线将设备和驱动绑定。在系统通过某一总线每注册一个设备的时候，会寻找与之匹配的驱动。同样，在系统每注册一个驱动的时候，会寻找与之匹配的设备，而匹配由总线完成。
总线中重要的结构体是：这个一般不需要我们来操作，系统会把需要的总线初始化好。

1. struct bus_type {
   
2. .
   
3. .
   
4. const char                *name;
   
5. .
   
6. .
   
7. }

复制代码

2.设备：就是要操作的硬件的描述。

重要的结构体：

1. struct device {
   
2. .
   
3. .
   
4. struct bus_type        *bus;                /* type of bus device is on */
   
5. struct device_driver *driver;        /* which driver has allocated this
   
6.                                            device */
   
7. void                *platform_data;        /* Platform specific data, device
   
8.                                            core doesn't touch it */
   
9. .
   
10. .
    
11. 
    
12. }

复制代码

对应的注册和卸载函数:

1. device_register(struct device * dev)
   
2. device_unregister(struct device * dev)

复制代码

3.设备驱动：具体操作硬件的操作函数。

1. struct device_driver {
   
2. .
   
3. .
   
4. const char                *name;
   
5. struct bus_type                *bus;
   
6. int (*probe) (struct device *dev);
   
7. int (*remove) (struct device *dev);
   
8. .
   
9. .
   
10. }

复制代码

对应的注册和卸载函数：

1. driver_register(struct device_driver * drv)
   
2. driver_unregister(struct device_driver * drv)

复制代码

-------------------------------------------------------------------------------------------------
本次设计到的platform总线，类似于继承了上述的设备和设备驱动。
在设备层对应的重要的数据结构为（我直接实例化了这个数据结构的重要成员变量）：

1. struct  platform_device pt_platform_dev =
   
2. {
   
3.         .name = "pt2262",
   
4.         .resource = pt2262_resource,
   
5.         .num_resources = ARRAY_SIZE(pt2262_resource),
   
6.         .dev =
   
7.         {
   
8.                 .platform_data = pt2262_devs,       
   
9.                 .release = pt2262_release,
   
10.         }
    
11. };

复制代码

对应的注册和注销函数

1. platform_driver_unregister(&pt_platform_drv);
   
2. platform_device_unregister(&pt_platform_dev);

复制代码

在设备驱动层对应的重要的数据结构为（我也直接实例化了这个数据结构的重要成员变量）：

1. struct platform_driver pt_platform_drv =
   
2. {
   
3.         .driver =
   
4.         {
   
5.                 .name = "pt2262",
   
6.                 .owner = THIS_MODULE,
   
7.         },
   
8.         .probe = pt_probe,
   
9.         .remove = pt_remove,
   
10. };

复制代码

对应的注册和注销函数

1. ret = platform_driver_register(&pt_platform_drv);
   
2. platform_driver_unregister(&pt_platform_drv);

复制代码

以上关于platform部分，我都是从我的代码中直接复制下来的。
完整的代码如下：

1. #include
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. #include
   
7. #include
   
8. 
   
9. #include "pt2262.h"
   
10. 
    
11. const int gpio_num[4]={49,60,51,50};
    
12. 
    
13. MODULE_LICENSE("GPL");
    
14. 
    
15. struct resource pt2262_resource[]=
    
16. {
    
17.         {
    
18.                 .flags = IORESOURCE_IRQ,
    
19.         },
    
20.         {
    
21.                 .flags = IORESOURCE_IRQ,
    
22.         },
    
23.         {
    
24.                 .flags = IORESOURCE_IRQ,
    
25.         },
    
26.         {
    
27. //                .start = gpio_to_irq(gpio_num[3]),
    
28. //                .end = gpio_to_irq(gpio_num[3]),
    
29.                 .flags = IORESOURCE_IRQ,
    
30.         }
    
31. };
    
32. 
    
33. struct pt2262_dev pt2262_devs[] =
    
34. {
    
35.         {
    
36.                 .desc = "A",
    
37.                 .gpio = 49,
    
38.                 .code = KEY_A,
    
39.         },
    
40.         {
    
41.                 .desc = "B",
    
42.                 .gpio = 60,
    
43.                 .code = KEY_B,
    
44.         },
    
45.         {
    
46.                 .desc = "C",
    
47.                 .gpio = 51,
    
48.                 .code = KEY_C,
    
49.         },
    
50.         {
    
51.                 .desc = "D",
    
52.                 .gpio = 50,
    
53.                 .code = KEY_D,
    
54.         }
    
55. 
    
56. };
    
57. 
    
58. void        pt2262_release(struct device *dev)
    
59. {
    
60.         printk(KERN_INFO "pt2262 release func.\n");       
    
61. }
    
62. 
    
63. struct  platform_device pt_platform_dev =
    
64. {
    
65.         .name = "pt2262",
    
66.         .resource = pt2262_resource,
    
67.         .num_resources = ARRAY_SIZE(pt2262_resource),
    
68.         .dev =
    
69.         {
    
70.                 .platform_data = pt2262_devs,       
    
71.                 .release = pt2262_release,
    
72.         }
    
73. };
    
74. 
    
75. irqreturn_t pt_irq_handler(int irq, void *pdev)
    
76. {       
    
77.         struct pt2262_dev * pt2262_devp = (struct pt2262_dev*)pdev;
    
78.         int i;
    
79.         for(i=0; i desc ,pt2262_devs[i].desc))
    
80.                 {
    
81.                         printk(KERN_INFO "pt2262's code is %d\tdesc is %s\ti is %d.\n", pt2262_devp->code, pt2262_devp->desc, i);       
    
82.                         break;
    
83.                 }
    
84.                 continue;               
    
85.         }
    
86.         return IRQ_HANDLED;
    
87. }
    
88. 
    
89. int pt_probe(struct platform_device *plat_pdev)
    
90. {
    
91.         int i,j,ret;
    
92.         char buf[16];
    
93.         struct pt2262_dev* pt2262_pdev_tmp = plat_pdev->dev.platform_data;
    
94.         for(i=0; i num_resources; i++)
    
95.         {
    
96.                 //j = plat_pdev->dev.platform_data
    
97.                 j = pt2262_pdev_tmp[i].gpio;
    
98.                 sprintf(buf, "pt_gpio_%d", j);
    
99.                 ret = gpio_request(j, buf);
    
100.                 if(ret resource)+i)->start = gpio_to_irq(j);
     
101.                 ((plat_pdev->resource)+i)->end = gpio_to_irq(j);
     
102.                 ret = request_irq(((plat_pdev->resource)+i)->start,pt_irq_handler,IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,"pt_irq_handler", pt2262_pdev_tmp+i);
     
103.                 if(ret num_resources);
     
104.         return ret;
     
105. fail:
     
106.         printk(KERN_ERR "failed to request %s\n",buf);
     
107.         return ret;
     
108. fail2:
     
109.         printk(KERN_ERR "failed to request irq %s\n",buf);
     
110.         return ret;
     
111. }
     
112. 
     
113. int pt_remove(struct platform_device *plat_pdev)
     
114. {
     
115.         int i;
     
116.         struct pt2262_dev* pt2262_pdev_tmp = plat_pdev->dev.platform_data;
     
117.         printk("pt_remove goodbye.\n");
     
118.         for(i=0; i num_resources; i++)
     
119.         {
     
120.                 free_irq(plat_pdev->resource[i].start, pt2262_pdev_tmp+i);
     
121.                 gpio_free((pt2262_pdev_tmp+i)->gpio);
     
122.         }
     
123.         return 0;
     
124. }
     
125. 
     
126. 
     
127. struct platform_driver pt_platform_drv =
     
128. {
     
129.         .driver =
     
130.         {
     
131.                 .name = "pt2262",
     
132.                 .owner = THIS_MODULE,
     
133.         },
     
134.         .probe = pt_probe,
     
135.         .remove = pt_remove,
     
136. };
     
137. 
     
138. int __init pt_init(void)
     
139. {
     
140.         int ret;
     
141.         ret = platform_device_register(&pt_platform_dev);       
     
142.         ret = platform_driver_register(&pt_platform_drv);       
     
143.         return ret;
     
144. }
     
145. module_init(pt_init);
     
146. 
     
147. void __exit pt_exit(void)
     
148. {
     
149.         platform_driver_unregister(&pt_platform_drv);
     
150.         platform_device_unregister(&pt_platform_dev);
     
151. }
     
152. module_exit(pt_exit);
     

复制代码

还有一个头文件pt2262.h：

1. #ifndef __PT2262_H__
   
2. #define __PT2262_H__
   
3. 
   
4. struct pt2262_dev
   
5. {
   
6.         char desc[8];
   
7.         int gpio;
   
8.         int code;
   
9. };
   
10. 
    
11. #endif
    

复制代码

安装之后的效果如下图：
在/sys/bus/platform/drivers目录下多出来pt2262这一项。