1 /*
2  * Driver for keys on GPIO lines capable of generating interrupts.
3  *
4  * Copyright 2005 Phil Blundell
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10 
11 #include <linux/module.h>
12 
13 #include <linux/init.h>
14 #include <linux/fs.h>
15 #include <linux/interrupt.h>
16 #include <linux/irq.h>
17 #include <linux/sched.h>
18 #include <linux/pm.h>
19 #include <linux/sysctl.h>
20 #include <linux/proc_fs.h>
21 #include <linux/delay.h>
22 #include <linux/platform_device.h>
23 #include <linux/input.h>
24 #include <linux/gpio_keys.h>
25 #include <linux/workqueue.h>
26 #include <linux/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 gpio_button_data *bdata)
41 {
42 	struct gpio_keys_button *button = bdata->button;
43 	struct input_dev *input = bdata->input;
44 	unsigned int type = button->type ?: EV_KEY;
45 	int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low;
46 
47 	input_event(input, type, button->code, !!state);
48 	input_sync(input);
49 }
50 
51 static void gpio_keys_work_func(struct work_struct *work)
52 {
53 	struct gpio_button_data *bdata =
54 		container_of(work, struct gpio_button_data, work);
55 
56 	gpio_keys_report_event(bdata);
57 }
58 
59 static void gpio_keys_timer(unsigned long _data)
60 {
61 	struct gpio_button_data *data = (struct gpio_button_data *)_data;
62 
63 	schedule_work(&data->work);
64 }
65 
66 static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
67 {
68 	struct gpio_button_data *bdata = dev_id;
69 	struct gpio_keys_button *button = bdata->button;
70 
71 	BUG_ON(irq != gpio_to_irq(button->gpio));
72 
73 	if (button->debounce_interval)
74 		mod_timer(&bdata->timer,
75 			jiffies + msecs_to_jiffies(button->debounce_interval));
76 	else
77 		schedule_work(&bdata->work);
78 
79 	return IRQ_HANDLED;
80 }
81 
82 static int __devinit gpio_keys_setup_key(struct device *dev,
83 					 struct gpio_button_data *bdata,
84 					 struct gpio_keys_button *button)
85 {
86 	char *desc = button->desc ? button->desc : "gpio_keys";
87 	int irq, error;
88 
89 	setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata);
90 	INIT_WORK(&bdata->work, gpio_keys_work_func);
91 
92 	error = gpio_request(button->gpio, desc);
93 	if (error < 0) {
94 		dev_err(dev, "failed to request GPIO %d, error %d\n",
95 			button->gpio, error);
96 		goto fail2;
97 	}
98 
99 	error = gpio_direction_input(button->gpio);
100 	if (error < 0) {
101 		dev_err(dev, "failed to configure"
102 			" direction for GPIO %d, error %d\n",
103 			button->gpio, error);
104 		goto fail3;
105 	}
106 
107 	irq = gpio_to_irq(button->gpio);
108 	if (irq < 0) {
109 		error = irq;
110 		dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n",
111 			button->gpio, error);
112 		goto fail3;
113 	}
114 
115 	error = request_irq(irq, gpio_keys_isr,
116 			    IRQF_SHARED |
117 			    IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
118 			    desc, bdata);
119 	if (error) {
120 		dev_err(dev, "Unable to claim irq %d; error %d\n",
121 			irq, error);
122 		goto fail3;
123 	}
124 
125 	return 0;
126 
127 fail3:
128 	gpio_free(button->gpio);
129 fail2:
130 	return error;
131 }
132 
133 static int __devinit gpio_keys_probe(struct platform_device *pdev)
134 {
135 	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
136 	struct gpio_keys_drvdata *ddata;
137 	struct device *dev = &pdev->dev;
138 	struct input_dev *input;
139 	int i, error;
140 	int wakeup = 0;
141 
142 	ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
143 			pdata->nbuttons * sizeof(struct gpio_button_data),
144 			GFP_KERNEL);
145 	input = input_allocate_device();
146 	if (!ddata || !input) {
147 		dev_err(dev, "failed to allocate state\n");
148 		error = -ENOMEM;
149 		goto fail1;
150 	}
151 
152 	platform_set_drvdata(pdev, ddata);
153 
154 	input->name = pdev->name;
155 	input->phys = "gpio-keys/input0";
156 	input->dev.parent = &pdev->dev;
157 
158 	input->id.bustype = BUS_HOST;
159 	input->id.vendor = 0x0001;
160 	input->id.product = 0x0001;
161 	input->id.version = 0x0100;
162 
163 	/* Enable auto repeat feature of Linux input subsystem */
164 	if (pdata->rep)
165 		__set_bit(EV_REP, input->evbit);
166 
167 	ddata->input = input;
168 
169 	for (i = 0; i < pdata->nbuttons; i++) {
170 		struct gpio_keys_button *button = &pdata->buttons[i];
171 		struct gpio_button_data *bdata = &ddata->data[i];
172 		unsigned int type = button->type ?: EV_KEY;
173 
174 		bdata->input = input;
175 		bdata->button = button;
176 
177 		error = gpio_keys_setup_key(dev, bdata, button);
178 		if (error)
179 			goto fail2;
180 
181 		if (button->wakeup)
182 			wakeup = 1;
183 
184 		input_set_capability(input, type, button->code);
185 	}
186 
187 	error = input_register_device(input);
188 	if (error) {
189 		dev_err(dev, "Unable to register input device, "
190 			"error: %d\n", error);
191 		goto fail2;
192 	}
193 
194 	/* get current state of buttons */
195 	for (i = 0; i < pdata->nbuttons; i++)
196 		gpio_keys_report_event(&ddata->data[i]);
197 	input_sync(input);
198 
199 	device_init_wakeup(&pdev->dev, wakeup);
200 
201 	return 0;
202 
203  fail2:
204 	while (--i >= 0) {
205 		free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
206 		if (pdata->buttons[i].debounce_interval)
207 			del_timer_sync(&ddata->data[i].timer);
208 		cancel_work_sync(&ddata->data[i].work);
209 		gpio_free(pdata->buttons[i].gpio);
210 	}
211 
212 	platform_set_drvdata(pdev, NULL);
213  fail1:
214 	input_free_device(input);
215 	kfree(ddata);
216 
217 	return error;
218 }
219 
220 static int __devexit gpio_keys_remove(struct platform_device *pdev)
221 {
222 	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
223 	struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);
224 	struct input_dev *input = ddata->input;
225 	int i;
226 
227 	device_init_wakeup(&pdev->dev, 0);
228 
229 	for (i = 0; i < pdata->nbuttons; i++) {
230 		int irq = gpio_to_irq(pdata->buttons[i].gpio);
231 		free_irq(irq, &ddata->data[i]);
232 		if (pdata->buttons[i].debounce_interval)
233 			del_timer_sync(&ddata->data[i].timer);
234 		cancel_work_sync(&ddata->data[i].work);
235 		gpio_free(pdata->buttons[i].gpio);
236 	}
237 
238 	input_unregister_device(input);
239 
240 	return 0;
241 }
242 
243 
244 #ifdef CONFIG_PM
245 static int gpio_keys_suspend(struct device *dev)
246 {
247 	struct platform_device *pdev = to_platform_device(dev);
248 	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
249 	int i;
250 
251 	if (device_may_wakeup(&pdev->dev)) {
252 		for (i = 0; i < pdata->nbuttons; i++) {
253 			struct gpio_keys_button *button = &pdata->buttons[i];
254 			if (button->wakeup) {
255 				int irq = gpio_to_irq(button->gpio);
256 				enable_irq_wake(irq);
257 			}
258 		}
259 	}
260 
261 	return 0;
262 }
263 
264 static int gpio_keys_resume(struct device *dev)
265 {
266 	struct platform_device *pdev = to_platform_device(dev);
267 	struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);
268 	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
269 	int i;
270 
271 	for (i = 0; i < pdata->nbuttons; i++) {
272 
273 		struct gpio_keys_button *button = &pdata->buttons[i];
274 		if (button->wakeup && device_may_wakeup(&pdev->dev)) {
275 			int irq = gpio_to_irq(button->gpio);
276 			disable_irq_wake(irq);
277 		}
278 
279 		gpio_keys_report_event(&ddata->data[i]);
280 	}
281 	input_sync(ddata->input);
282 
283 	return 0;
284 }
285 
286 static const struct dev_pm_ops gpio_keys_pm_ops = {
287 	.suspend	= gpio_keys_suspend,
288 	.resume		= gpio_keys_resume,
289 };
290 #endif
291 
292 static struct platform_driver gpio_keys_device_driver = {
293 	.probe		= gpio_keys_probe,
294 	.remove		= __devexit_p(gpio_keys_remove),
295 	.driver		= {
296 		.name	= "gpio-keys",
297 		.owner	= THIS_MODULE,
298 #ifdef CONFIG_PM
299 		.pm	= &gpio_keys_pm_ops,
300 #endif
301 	}
302 };
303 
304 static int __init gpio_keys_init(void)
305 {
306 	return platform_driver_register(&gpio_keys_device_driver);
307 }
308 
309 static void __exit gpio_keys_exit(void)
310 {
311 	platform_driver_unregister(&gpio_keys_device_driver);
312 }
313 
314 module_init(gpio_keys_init);
315 module_exit(gpio_keys_exit);
316 
317 MODULE_LICENSE("GPL");
318 MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
319 MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs");
320 MODULE_ALIAS("platform:gpio-keys");
321