]>
Commit | Line | Data |
---|---|---|
0e7d0c86 GJ |
1 | /* |
2 | * Driver for buttons on GPIO lines not capable of generating interrupts | |
3 | * | |
4 | * Copyright (C) 2007-2010 Gabor Juhos <juhosg@openwrt.org> | |
5 | * Copyright (C) 2010 Nuno Goncalves <nunojpg@gmail.com> | |
6 | * | |
7 | * This file was based on: /drivers/input/misc/cobalt_btns.c | |
8 | * Copyright (C) 2007 Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp> | |
9 | * | |
10 | * also was based on: /drivers/input/keyboard/gpio_keys.c | |
11 | * Copyright 2005 Phil Blundell | |
12 | * | |
13 | * This program is free software; you can redistribute it and/or modify | |
14 | * it under the terms of the GNU General Public License version 2 as | |
15 | * published by the Free Software Foundation. | |
16 | */ | |
17 | ||
18 | #include <linux/kernel.h> | |
19 | #include <linux/module.h> | |
20 | #include <linux/init.h> | |
21 | #include <linux/slab.h> | |
22 | #include <linux/input.h> | |
23 | #include <linux/input-polldev.h> | |
24 | #include <linux/ioport.h> | |
25 | #include <linux/platform_device.h> | |
26 | #include <linux/gpio.h> | |
27 | #include <linux/gpio_keys.h> | |
a2f25245 APS |
28 | #include <linux/of_platform.h> |
29 | #include <linux/of_gpio.h> | |
0e7d0c86 GJ |
30 | |
31 | #define DRV_NAME "gpio-keys-polled" | |
32 | ||
33 | struct gpio_keys_button_data { | |
34 | int last_state; | |
35 | int count; | |
36 | int threshold; | |
37 | int can_sleep; | |
38 | }; | |
39 | ||
40 | struct gpio_keys_polled_dev { | |
41 | struct input_polled_dev *poll_dev; | |
42 | struct device *dev; | |
2976f247 | 43 | const struct gpio_keys_platform_data *pdata; |
0e7d0c86 GJ |
44 | struct gpio_keys_button_data data[0]; |
45 | }; | |
46 | ||
47 | static void gpio_keys_polled_check_state(struct input_dev *input, | |
48 | struct gpio_keys_button *button, | |
49 | struct gpio_keys_button_data *bdata) | |
50 | { | |
51 | int state; | |
52 | ||
53 | if (bdata->can_sleep) | |
54 | state = !!gpio_get_value_cansleep(button->gpio); | |
55 | else | |
56 | state = !!gpio_get_value(button->gpio); | |
57 | ||
58 | if (state != bdata->last_state) { | |
59 | unsigned int type = button->type ?: EV_KEY; | |
60 | ||
61 | input_event(input, type, button->code, | |
62 | !!(state ^ button->active_low)); | |
63 | input_sync(input); | |
64 | bdata->count = 0; | |
65 | bdata->last_state = state; | |
66 | } | |
67 | } | |
68 | ||
69 | static void gpio_keys_polled_poll(struct input_polled_dev *dev) | |
70 | { | |
71 | struct gpio_keys_polled_dev *bdev = dev->private; | |
2976f247 | 72 | const struct gpio_keys_platform_data *pdata = bdev->pdata; |
0e7d0c86 GJ |
73 | struct input_dev *input = dev->input; |
74 | int i; | |
75 | ||
2976f247 | 76 | for (i = 0; i < pdata->nbuttons; i++) { |
0e7d0c86 GJ |
77 | struct gpio_keys_button_data *bdata = &bdev->data[i]; |
78 | ||
79 | if (bdata->count < bdata->threshold) | |
80 | bdata->count++; | |
81 | else | |
82 | gpio_keys_polled_check_state(input, &pdata->buttons[i], | |
83 | bdata); | |
84 | } | |
85 | } | |
86 | ||
87 | static void gpio_keys_polled_open(struct input_polled_dev *dev) | |
88 | { | |
89 | struct gpio_keys_polled_dev *bdev = dev->private; | |
2976f247 | 90 | const struct gpio_keys_platform_data *pdata = bdev->pdata; |
0e7d0c86 GJ |
91 | |
92 | if (pdata->enable) | |
93 | pdata->enable(bdev->dev); | |
94 | } | |
95 | ||
96 | static void gpio_keys_polled_close(struct input_polled_dev *dev) | |
97 | { | |
98 | struct gpio_keys_polled_dev *bdev = dev->private; | |
2976f247 | 99 | const struct gpio_keys_platform_data *pdata = bdev->pdata; |
0e7d0c86 GJ |
100 | |
101 | if (pdata->disable) | |
102 | pdata->disable(bdev->dev); | |
103 | } | |
104 | ||
a2f25245 APS |
105 | #ifdef CONFIG_OF |
106 | static struct gpio_keys_platform_data * __devinit | |
107 | gpio_keys_polled_get_devtree_pdata(struct device *dev) | |
108 | { | |
109 | struct device_node *node, *pp; | |
110 | struct gpio_keys_platform_data *pdata; | |
111 | struct gpio_keys_button *button; | |
112 | int error; | |
113 | int nbuttons; | |
114 | int i; | |
115 | ||
116 | node = dev->of_node; | |
117 | if (!node) | |
118 | return NULL; | |
119 | ||
120 | nbuttons = of_get_child_count(node); | |
121 | if (nbuttons == 0) | |
122 | return NULL; | |
123 | ||
124 | pdata = kzalloc(sizeof(*pdata) + nbuttons * (sizeof *button), | |
125 | GFP_KERNEL); | |
126 | if (!pdata) { | |
127 | error = -ENOMEM; | |
128 | goto err_out; | |
129 | } | |
130 | ||
131 | pdata->buttons = (struct gpio_keys_button *)(pdata + 1); | |
8757145a | 132 | pdata->nbuttons = nbuttons; |
a2f25245 APS |
133 | |
134 | pdata->rep = !!of_get_property(node, "autorepeat", NULL); | |
135 | of_property_read_u32(node, "poll-interval", &pdata->poll_interval); | |
136 | ||
137 | i = 0; | |
138 | for_each_child_of_node(node, pp) { | |
139 | enum of_gpio_flags flags; | |
140 | ||
141 | if (!of_find_property(pp, "gpios", NULL)) { | |
142 | pdata->nbuttons--; | |
143 | dev_warn(dev, "Found button without gpios\n"); | |
144 | continue; | |
145 | } | |
146 | ||
147 | button = &pdata->buttons[i++]; | |
148 | ||
149 | button->gpio = of_get_gpio_flags(pp, 0, &flags); | |
150 | button->active_low = flags & OF_GPIO_ACTIVE_LOW; | |
151 | ||
152 | if (of_property_read_u32(pp, "linux,code", &button->code)) { | |
153 | dev_err(dev, "Button without keycode: 0x%x\n", | |
154 | button->gpio); | |
155 | error = -EINVAL; | |
156 | goto err_free_pdata; | |
157 | } | |
158 | ||
159 | button->desc = of_get_property(pp, "label", NULL); | |
160 | ||
161 | if (of_property_read_u32(pp, "linux,input-type", &button->type)) | |
162 | button->type = EV_KEY; | |
163 | ||
164 | button->wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL); | |
165 | ||
166 | if (of_property_read_u32(pp, "debounce-interval", | |
167 | &button->debounce_interval)) | |
168 | button->debounce_interval = 5; | |
169 | } | |
170 | ||
171 | if (pdata->nbuttons == 0) { | |
172 | error = -EINVAL; | |
173 | goto err_free_pdata; | |
174 | } | |
175 | ||
176 | return pdata; | |
177 | ||
178 | err_free_pdata: | |
179 | kfree(pdata); | |
180 | err_out: | |
181 | return ERR_PTR(error); | |
182 | } | |
183 | ||
184 | static struct of_device_id gpio_keys_polled_of_match[] = { | |
185 | { .compatible = "gpio-keys-polled", }, | |
186 | { }, | |
187 | }; | |
188 | MODULE_DEVICE_TABLE(of, gpio_keys_polled_of_match); | |
189 | ||
190 | #else | |
191 | ||
192 | static inline struct gpio_keys_platform_data * | |
193 | gpio_keys_polled_get_devtree_pdata(struct device *dev) | |
194 | { | |
195 | return NULL; | |
196 | } | |
197 | #endif | |
198 | ||
0e7d0c86 GJ |
199 | static int __devinit gpio_keys_polled_probe(struct platform_device *pdev) |
200 | { | |
0e7d0c86 | 201 | struct device *dev = &pdev->dev; |
2976f247 | 202 | const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev); |
0e7d0c86 GJ |
203 | struct gpio_keys_polled_dev *bdev; |
204 | struct input_polled_dev *poll_dev; | |
205 | struct input_dev *input; | |
206 | int error; | |
207 | int i; | |
208 | ||
a2f25245 APS |
209 | if (!pdata) { |
210 | pdata = gpio_keys_polled_get_devtree_pdata(dev); | |
211 | if (IS_ERR(pdata)) | |
212 | return PTR_ERR(pdata); | |
213 | if (!pdata) { | |
214 | dev_err(dev, "missing platform data\n"); | |
215 | return -EINVAL; | |
216 | } | |
217 | } | |
218 | ||
219 | if (!pdata->poll_interval) { | |
220 | dev_err(dev, "missing poll_interval value\n"); | |
221 | error = -EINVAL; | |
222 | goto err_free_pdata; | |
223 | } | |
0e7d0c86 GJ |
224 | |
225 | bdev = kzalloc(sizeof(struct gpio_keys_polled_dev) + | |
226 | pdata->nbuttons * sizeof(struct gpio_keys_button_data), | |
227 | GFP_KERNEL); | |
228 | if (!bdev) { | |
229 | dev_err(dev, "no memory for private data\n"); | |
a2f25245 APS |
230 | error = -ENOMEM; |
231 | goto err_free_pdata; | |
0e7d0c86 GJ |
232 | } |
233 | ||
234 | poll_dev = input_allocate_polled_device(); | |
235 | if (!poll_dev) { | |
236 | dev_err(dev, "no memory for polled device\n"); | |
237 | error = -ENOMEM; | |
238 | goto err_free_bdev; | |
239 | } | |
240 | ||
241 | poll_dev->private = bdev; | |
242 | poll_dev->poll = gpio_keys_polled_poll; | |
243 | poll_dev->poll_interval = pdata->poll_interval; | |
244 | poll_dev->open = gpio_keys_polled_open; | |
245 | poll_dev->close = gpio_keys_polled_close; | |
246 | ||
247 | input = poll_dev->input; | |
248 | ||
249 | input->evbit[0] = BIT(EV_KEY); | |
250 | input->name = pdev->name; | |
251 | input->phys = DRV_NAME"/input0"; | |
252 | input->dev.parent = &pdev->dev; | |
253 | ||
254 | input->id.bustype = BUS_HOST; | |
255 | input->id.vendor = 0x0001; | |
256 | input->id.product = 0x0001; | |
257 | input->id.version = 0x0100; | |
258 | ||
259 | for (i = 0; i < pdata->nbuttons; i++) { | |
260 | struct gpio_keys_button *button = &pdata->buttons[i]; | |
261 | struct gpio_keys_button_data *bdata = &bdev->data[i]; | |
262 | unsigned int gpio = button->gpio; | |
263 | unsigned int type = button->type ?: EV_KEY; | |
264 | ||
265 | if (button->wakeup) { | |
266 | dev_err(dev, DRV_NAME " does not support wakeup\n"); | |
267 | error = -EINVAL; | |
268 | goto err_free_gpio; | |
269 | } | |
270 | ||
271 | error = gpio_request(gpio, | |
272 | button->desc ? button->desc : DRV_NAME); | |
273 | if (error) { | |
274 | dev_err(dev, "unable to claim gpio %u, err=%d\n", | |
275 | gpio, error); | |
276 | goto err_free_gpio; | |
277 | } | |
278 | ||
279 | error = gpio_direction_input(gpio); | |
280 | if (error) { | |
281 | dev_err(dev, | |
282 | "unable to set direction on gpio %u, err=%d\n", | |
283 | gpio, error); | |
284 | goto err_free_gpio; | |
285 | } | |
286 | ||
287 | bdata->can_sleep = gpio_cansleep(gpio); | |
288 | bdata->last_state = -1; | |
289 | bdata->threshold = DIV_ROUND_UP(button->debounce_interval, | |
290 | pdata->poll_interval); | |
291 | ||
292 | input_set_capability(input, type, button->code); | |
293 | } | |
294 | ||
295 | bdev->poll_dev = poll_dev; | |
296 | bdev->dev = dev; | |
297 | bdev->pdata = pdata; | |
298 | platform_set_drvdata(pdev, bdev); | |
299 | ||
300 | error = input_register_polled_device(poll_dev); | |
301 | if (error) { | |
302 | dev_err(dev, "unable to register polled device, err=%d\n", | |
303 | error); | |
304 | goto err_free_gpio; | |
305 | } | |
306 | ||
307 | /* report initial state of the buttons */ | |
308 | for (i = 0; i < pdata->nbuttons; i++) | |
309 | gpio_keys_polled_check_state(input, &pdata->buttons[i], | |
a2f25245 | 310 | &bdev->data[i]); |
0e7d0c86 GJ |
311 | |
312 | return 0; | |
313 | ||
314 | err_free_gpio: | |
315 | while (--i >= 0) | |
316 | gpio_free(pdata->buttons[i].gpio); | |
317 | ||
318 | input_free_polled_device(poll_dev); | |
319 | ||
320 | err_free_bdev: | |
321 | kfree(bdev); | |
0e7d0c86 | 322 | platform_set_drvdata(pdev, NULL); |
a2f25245 APS |
323 | |
324 | err_free_pdata: | |
325 | /* If we have no platform_data, we allocated pdata dynamically. */ | |
326 | if (!dev_get_platdata(&pdev->dev)) | |
327 | kfree(pdata); | |
328 | ||
0e7d0c86 GJ |
329 | return error; |
330 | } | |
331 | ||
332 | static int __devexit gpio_keys_polled_remove(struct platform_device *pdev) | |
333 | { | |
334 | struct gpio_keys_polled_dev *bdev = platform_get_drvdata(pdev); | |
2976f247 | 335 | const struct gpio_keys_platform_data *pdata = bdev->pdata; |
0e7d0c86 GJ |
336 | int i; |
337 | ||
338 | input_unregister_polled_device(bdev->poll_dev); | |
339 | ||
340 | for (i = 0; i < pdata->nbuttons; i++) | |
341 | gpio_free(pdata->buttons[i].gpio); | |
342 | ||
343 | input_free_polled_device(bdev->poll_dev); | |
344 | ||
a2f25245 APS |
345 | /* |
346 | * If we had no platform_data, we allocated pdata dynamically and | |
347 | * must free it here. | |
348 | */ | |
349 | if (!dev_get_platdata(&pdev->dev)) | |
350 | kfree(pdata); | |
351 | ||
0e7d0c86 GJ |
352 | kfree(bdev); |
353 | platform_set_drvdata(pdev, NULL); | |
354 | ||
355 | return 0; | |
356 | } | |
357 | ||
358 | static struct platform_driver gpio_keys_polled_driver = { | |
359 | .probe = gpio_keys_polled_probe, | |
1cb0aa88 | 360 | .remove = gpio_keys_polled_remove, |
0e7d0c86 GJ |
361 | .driver = { |
362 | .name = DRV_NAME, | |
363 | .owner = THIS_MODULE, | |
a2f25245 | 364 | .of_match_table = of_match_ptr(gpio_keys_polled_of_match), |
0e7d0c86 GJ |
365 | }, |
366 | }; | |
5146c84f | 367 | module_platform_driver(gpio_keys_polled_driver); |
0e7d0c86 GJ |
368 | |
369 | MODULE_LICENSE("GPL v2"); | |
370 | MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>"); | |
371 | MODULE_DESCRIPTION("Polled GPIO Buttons driver"); | |
372 | MODULE_ALIAS("platform:" DRV_NAME); |