gpio-keys.c分析

1. Driver for keys on GPIO lines capable of generating interrupts.
   
2.  *
   
3.  * Copyright 2005 Phil Blundell
   
4.  *
   
5.  * This program is free software; you can redistribute it and/or modify
   
6.  * it under the terms of the GNU General Public License version 2 as
   
7.  * published by the Free Software Foundation.
   
8.  */
   
9. 
   
10. #include <linux/module.h>
    
11. 
    
12. #include <linux/init.h>
    
13. #include <linux/fs.h>
    
14. #include <linux/interrupt.h>
    
15. #include <linux/irq.h>
    
16. #include <linux/sched.h>
    
17. #include <linux/pm.h>
    
18. #include <linux/sysctl.h>
    
19. #include <linux/proc_fs.h>
    
20. #include <linux/delay.h>
    
21. #include <linux/platform_device.h>
    
22. #include <linux/input.h>
    
23. #include <linux/gpio_keys.h>
    
24. #include <linux/workqueue.h>
    
25. 
    
26. #include <asm/gpio.h>
    
27. 
    
28. struct gpio_button_data {
    
29.     struct gpio_keys_button *button;
    
30.     struct input_dev *input;
    
31.     struct timer_list timer;
    
32.     struct work_struct work;
    
33. };
    
34. 
    
35. struct gpio_keys_drvdata {
    
36.     struct input_dev *input;
    
37.     struct gpio_button_data data[0];
    
38. };
    
39. 
    
40. static void gpio_keys_report_event(struct work_struct *work)/*中断下半部*/
    
41. {
    
42.     struct gpio_button_data *bdata =
    
43.         container_of(work, struct gpio_button_data, work);
    
44.     struct gpio_keys_button *button = bdata->button;
    
45.     struct input_dev *input = bdata->input;
    
46.     unsigned int type = button->type ?: EV_KEY;
    
47.     int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low;
    
48. ///获得按键信息，同时于active_low异或，主要还是根据上升沿下降沿判断按键状态
    
49.     input_event(input, type, button->code, !!state);
    
50.     input_sync(input);
    
51. }
    
52. 
    
53. static void gpio_keys_timer(unsigned long _data)
    
54. {
    
55.     struct gpio_button_data *data = (struct gpio_button_data *)_data;
    
56. 
    
57.     schedule_work(&data->work);//调度work
    
58. }
    
59. 
    
60. static irqreturn_t gpio_keys_isr(int irq, void *dev_id)/*中断服务例程*/
    
61. {
    
62.     struct gpio_button_data *bdata = dev_id;
    
63.     struct gpio_keys_button *button = bdata->button;
    
64. 
    
65.     BUG_ON(irq != gpio_to_irq(button->gpio));
    
66. 
    
67.     if (button->debounce_interval) /*检测是否在platform device设置了去抖动*/ 
    
68.         mod_timer(&bdata->timer,
    
69.             jiffies + msecs_to_jiffies(button->debounce_interval));
    
70.          /* 延迟msecs_to_jiffies(button->debounce_interval)个jiffies后执行schedule_work()*/ 
    
71.     else
    
72.         schedule_work(&bdata->work);//put work task in global workqueue，调度work
    
73. 
    
74.     return IRQ_HANDLED;
    
75. }
    
76. 
    
77. static int __devinit gpio_keys_probe(struct platform_device *pdev)
    
78. {
    
79.     struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
    
80.     struct gpio_keys_drvdata *ddata;
    
81.     struct input_dev *input;
    
82.     int i, error;
    
83.     int wakeup = 0;
    
84. 
    
85.     ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
    
86.             pdata->nbuttons * sizeof(struct gpio_button_data),
    
87.             GFP_KERNEL);
    
88.     input = input_allocate_device();
    
89.     if (!ddata || !input) {
    
90.         error = -ENOMEM;
    
91.         goto fail1;
    
92.     }
    
93. 
    
94.     platform_set_drvdata(pdev, ddata);
    
95. 
    
96.     input->name = pdev->name;//96行到103行，初始化input_dev一些属性
    
97.     input->phys = "gpio-keys/input0";
    
98.     input->dev.parent = &pdev->dev;
    
99. 
    
100.     input->id.bustype = BUS_HOST;//总线类型
     
101.     input->id.vendor = 0x0001;//生产商编号
     
102.     input->id.product = 0x0001;//产品编号
     
103.     input->id.version = 0x0100;//版本编号
     
104. 
     
105.     /* Enable auto repeat feature of Linux input subsystem */
     
106.     if (pdata->rep)
     
107.         __set_bit(EV_REP, input->evbit); 
     
108. /*    如果 设置了 __set_bit(EV_REP, input->evbit)
     
109.     也就是重复报告，它的工作机制是这样的：
     
110.     如果按键报告了input_event(input, type, button->code,1); 
     
111.     之后， 在250ms （可以改）后，依然没有报告 input_event(input, type, button->code,0)；
     
112.     则 input 会每隔 33ms 继续报告一次 input_event(input, type, button->code,2); 
     
113.     直到 报告了 input_event(input, type, button->code,0)； 
     
114.     才停止 ，这就是我们按住一个按键不松开时，会一直打印键值的原因；*/
     
115. 
     
116.     ddata->input = input;
     
117. 
     
118.     for (i = 0; i < pdata->nbuttons; i++) {//111-165对每个按键初始化GPIO，并初始化中断
     
119.         struct gpio_keys_button *button = &pdata->buttons[i];
     
120.         struct gpio_button_data *bdata = &ddata->data[i];
     
121.         int irq;
     
122.         unsigned int type = button->type ?: EV_KEY;
     
123. 
     
124.         bdata->input = input;
     
125.         bdata->button = button;
     
126.         setup_timer(&bdata->timer,
     
127.              gpio_keys_timer, (unsigned long)bdata);//设置timer的值，是一个宏，在<linux/timer.h>
     
128.         INIT_WORK(&bdata->work, gpio_keys_report_event);//初始化工作队列，ldk.p124
     
129. 
     
130.         error =Cbutton->gpio, button->desc ?: "gpio_keys");
     
131.         if (error < 0) {
     
132.             pr_err("gpio-keys: failed to request GPIO %d,"
     
133.                 " error %d\n", button->gpio, error);
     
134.             goto fail2;
     
135.         }
     
136. 
     
137.         error = gpio_direction_input(button->gpio);//配置gpio的方向
     
138.         if (error < 0) {
     
139.             pr_err("gpio-keys: failed to configure input"
     
140.                 " direction for GPIO %d, error %d\n",
     
141.                 button->gpio, error);
     
142.             gpio_free(button->gpio);
     
143.             goto fail2;
     
144.         }
     
145. 
     
146.         irq = gpio_to_irq(button->gpio);//将gpio口转化为一个中断号
     
147.         if (irq < 0) {
     
148.             error = irq;
     
149.             pr_err("gpio-keys: Unable to get irq number"
     
150.                 " for GPIO %d, error %d\n",
     
151.                 button->gpio, error);
     
152.             gpio_free(button->gpio);
     
153.             goto fail2;
     
154.         }
     
155. 
     
156.         error = request_irq(irq, gpio_keys_isr,
     
157.                  IRQF_SHARED |
     
158.                  IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
     
159.                  button->desc ? button->desc : "gpio_keys",
     
160.                  bdata);
     
161.         if (error) {
     
162.             pr_err("gpio-keys: Unable to claim irq %d; error %d\n",
     
163.                 irq, error);
     
164.             gpio_free(button->gpio);
     
165.             goto fail2;
     
166.         }
     
167. 
     
168.         if (button->wakeup)
     
169.             wakeup = 1;
     
170. 
     
171.         input_set_capability(input, type, button->code);
     
172.     }
     
173. 
     
174.     error = input_register_device(input);//注册input设备
     
175.     if (error) {
     
176.         pr_err("gpio-keys: Unable to register input device, "
     
177.             "error: %d\n", error);
     
178.         goto fail2;
     
179.     }
     
180. 
     
181.     device_init_wakeup(&pdev->dev, wakeup);//电源部分初始化
     
182. 
     
183.     return 0;
     
184. 
     
185.  fail2:
     
186.     while (--i >= 0) {
     
187.         free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
     
188.         if (pdata->buttons[i].debounce_interval)
     
189.             del_timer_sync(&ddata->data[i].timer);
     
190.         cancel_work_sync(&ddata->data[i].work);
     
191.         gpio_free(pdata->buttons[i].gpio);
     
192.     }
     
193. 
     
194.     platform_set_drvdata(pdev, NULL);
     
195.  fail1:
     
196.     input_free_device(input);
     
197.     kfree(ddata);
     
198. 
     
199.     return error;
     
200. }
     
201. 
     
202. static int __devexit gpio_keys_remove(struct platform_device *pdev)
     
203. {
     
204.     struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
     
205.     struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);
     
206.     struct input_dev *input = ddata->input;
     
207.     int i;
     
208. 
     
209.     device_init_wakeup(&pdev->dev, 0);
     
210. 
     
211.     for (i = 0; i < pdata->nbuttons; i++) {
     
212.         int irq = gpio_to_irq(pdata->buttons[i].gpio);
     
213.         free_irq(irq, &ddata->data[i]);//释放中断号
     
214.         if (pdata->buttons[i].debounce_interval)
     
215.             del_timer_sync(&ddata->data[i].timer);//删除定时器
     
216.         cancel_work_sync(&ddata->data[i].work);
     
217.         gpio_free(pdata->buttons[i].gpio);释放gpio
     
218.     }
     
219. 
     
220.     input_unregister_device(input);释放input设备
     
221. 
     
222.     return 0;
     
223. }
     
224. 
     
225. 
     
226. #ifdef CONFIG_PM
     
227. static int gpio_keys_suspend(struct device *dev)
     
228. {
     
229.     struct platform_device *pdev = to_platform_device(dev);
     
230.     struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
     
231.     int i;
     
232. 
     
233.     if (device_may_wakeup(&pdev->dev)) {
     
234.         for (i = 0; i < pdata->nbuttons; i++) {
     
235.             struct gpio_keys_button *button = &pdata->buttons[i];
     
236.             if (button->wakeup) {
     
237.                 int irq = gpio_to_irq(button->gpio);
     
238.                 enable_irq_wake(irq);
     
239.             }
     
240.         }
     
241.     }
     
242. 
     
243.     return 0;
     
244. }
     
245. 
     
246. static int gpio_keys_resume(struct device *dev)
     
247. {
     
248.     struct platform_device *pdev = to_platform_device(dev);
     
249.     struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
     
250.     int i;
     
251. 
     
252.     if (device_may_wakeup(&pdev->dev)) {
     
253.         for (i = 0; i < pdata->nbuttons; i++) {
     
254.             struct gpio_keys_button *button = &pdata->buttons[i];
     
255.             if (button->wakeup) {
     
256.                 int irq = gpio_to_irq(button->gpio);
     
257.                 disable_irq_wake(irq);
     
258.             }
     
259.         }
     
260.     }
     
261. 
     
262.     return 0;
     
263. }
     
264. 
     
265. static const struct dev_pm_ops gpio_keys_pm_ops = {
     
266.     .suspend = gpio_keys_suspend,
     
267.     .resume = gpio_keys_resume,
     
268. };
     
269. #endif
     
270. 
     
271. static struct platform_driver gpio_keys_device_driver = {
     
272.     .probe = gpio_keys_probe,
     
273.     .remove = __devexit_p(gpio_keys_remove),
     
274.     .driver = {
     
275.         .name = "gpio-keys",
     
276.         .owner = THIS_MODULE,
     
277. #ifdef CONFIG_PM
     
278.         .pm = &gpio_keys_pm_ops,
     
279. #endif
     
280.     }
     
281. };
     
282. 
     
283. static int __init gpio_keys_init(void)
     
284. {
     
285.     return platform_driver_register(&gpio_keys_device_driver);
     
286. }
     
287. 
     
288. static void __exit gpio_keys_exit(void)
     
289. {
     
290.     platform_driver_unregister(&gpio_keys_device_driver);
     
291. }
     
292. 
     
293. module_init(gpio_keys_init);
     
294. module_exit(gpio_keys_exit);
     
295. 
     
296. MODULE_LICENSE("GPL");
     
297. MODULE_AUTHOR("Phil Blundell <[e-mail]>");
     
298. MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs");
     
299. MODULE_ALIAS("platform:gpio-keys");
     
300. 
     
301. 
     
302. 附：两个结构体
     
303. 1.    struct gpio_keys_button { 
     
304. 2.     /*Configuration parameters */ 
     
305. 3.     int code; /* 输入事件代码(KEY_*, SW_*) */ 
     
306. 4.     int gpio; /* gpio口 */ 
     
307. 5.     int active_low; /* 低电平有效*/ 
     
308. 6.     char *desc; /* 功能描述 */ 
     
309. 7.     int type; /* 输入事件类型(EV_KEY, EV_SW) */ 
     
310. 8.     int wakeup; /* configure thebutton as a wake-up source */ 
     
311. 9.     int debounce_interval; /* 去抖动间隔，单位微秒*/ 
     
312. 10.    }; 
     
313. 11.     
     
314. 12.    struct gpio_keys_platform_data { 
     
315. 13.     struct gpio_keys_button *buttons; 
     
316. 14.     int nbuttons; 
     
317. 15.     unsignedint rep:1; /* enable inputsubsystem auto repeat */ 
     
318. 16.    };