1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/kernel.h>
19#include <linux/module.h>
20#include <linux/slab.h>
21#include <linux/input.h>
22#include <linux/input-polldev.h>
23#include <linux/ioport.h>
24#include <linux/platform_device.h>
25#include <linux/gpio.h>
26#include <linux/gpio/consumer.h>
27#include <linux/gpio_keys.h>
28#include <linux/property.h>
29
30#define DRV_NAME "gpio-keys-polled"
31
32struct gpio_keys_button_data {
33 struct gpio_desc *gpiod;
34 int last_state;
35 int count;
36 int threshold;
37};
38
39struct gpio_keys_polled_dev {
40 struct input_polled_dev *poll_dev;
41 struct device *dev;
42 const struct gpio_keys_platform_data *pdata;
43 unsigned long rel_axis_seen[BITS_TO_LONGS(REL_CNT)];
44 unsigned long abs_axis_seen[BITS_TO_LONGS(ABS_CNT)];
45 struct gpio_keys_button_data data[0];
46};
47
48static void gpio_keys_button_event(struct input_polled_dev *dev,
49 const struct gpio_keys_button *button,
50 int state)
51{
52 struct gpio_keys_polled_dev *bdev = dev->private;
53 struct input_dev *input = dev->input;
54 unsigned int type = button->type ?: EV_KEY;
55
56 if (type == EV_REL) {
57 if (state) {
58 input_event(input, type, button->code, button->value);
59 __set_bit(button->code, bdev->rel_axis_seen);
60 }
61 } else if (type == EV_ABS) {
62 if (state) {
63 input_event(input, type, button->code, button->value);
64 __set_bit(button->code, bdev->abs_axis_seen);
65 }
66 } else {
67 input_event(input, type, button->code, state);
68 input_sync(input);
69 }
70}
71
72static void gpio_keys_polled_check_state(struct input_polled_dev *dev,
73 const struct gpio_keys_button *button,
74 struct gpio_keys_button_data *bdata)
75{
76 int state;
77
78 state = gpiod_get_value_cansleep(bdata->gpiod);
79 if (state < 0) {
80 dev_err(dev->input->dev.parent,
81 "failed to get gpio state: %d\n", state);
82 } else {
83 gpio_keys_button_event(dev, button, state);
84
85 if (state != bdata->last_state) {
86 bdata->count = 0;
87 bdata->last_state = state;
88 }
89 }
90}
91
92static void gpio_keys_polled_poll(struct input_polled_dev *dev)
93{
94 struct gpio_keys_polled_dev *bdev = dev->private;
95 const struct gpio_keys_platform_data *pdata = bdev->pdata;
96 struct input_dev *input = dev->input;
97 int i;
98
99 memset(bdev->rel_axis_seen, 0, sizeof(bdev->rel_axis_seen));
100 memset(bdev->abs_axis_seen, 0, sizeof(bdev->abs_axis_seen));
101
102 for (i = 0; i < pdata->nbuttons; i++) {
103 struct gpio_keys_button_data *bdata = &bdev->data[i];
104
105 if (bdata->count < bdata->threshold) {
106 bdata->count++;
107 gpio_keys_button_event(dev, &pdata->buttons[i],
108 bdata->last_state);
109 } else {
110 gpio_keys_polled_check_state(dev, &pdata->buttons[i],
111 bdata);
112 }
113 }
114
115 for_each_set_bit(i, input->relbit, REL_CNT) {
116 if (!test_bit(i, bdev->rel_axis_seen))
117 input_event(input, EV_REL, i, 0);
118 }
119
120 for_each_set_bit(i, input->absbit, ABS_CNT) {
121 if (!test_bit(i, bdev->abs_axis_seen))
122 input_event(input, EV_ABS, i, 0);
123 }
124
125 input_sync(input);
126}
127
128static void gpio_keys_polled_open(struct input_polled_dev *dev)
129{
130 struct gpio_keys_polled_dev *bdev = dev->private;
131 const struct gpio_keys_platform_data *pdata = bdev->pdata;
132
133 if (pdata->enable)
134 pdata->enable(bdev->dev);
135}
136
137static void gpio_keys_polled_close(struct input_polled_dev *dev)
138{
139 struct gpio_keys_polled_dev *bdev = dev->private;
140 const struct gpio_keys_platform_data *pdata = bdev->pdata;
141
142 if (pdata->disable)
143 pdata->disable(bdev->dev);
144}
145
146static struct gpio_keys_platform_data *
147gpio_keys_polled_get_devtree_pdata(struct device *dev)
148{
149 struct gpio_keys_platform_data *pdata;
150 struct gpio_keys_button *button;
151 struct fwnode_handle *child;
152 int nbuttons;
153
154 nbuttons = device_get_child_node_count(dev);
155 if (nbuttons == 0)
156 return ERR_PTR(-EINVAL);
157
158 pdata = devm_kzalloc(dev, sizeof(*pdata) + nbuttons * sizeof(*button),
159 GFP_KERNEL);
160 if (!pdata)
161 return ERR_PTR(-ENOMEM);
162
163 button = (struct gpio_keys_button *)(pdata + 1);
164
165 pdata->buttons = button;
166 pdata->nbuttons = nbuttons;
167
168 pdata->rep = device_property_present(dev, "autorepeat");
169 device_property_read_u32(dev, "poll-interval", &pdata->poll_interval);
170
171 device_for_each_child_node(dev, child) {
172 if (fwnode_property_read_u32(child, "linux,code",
173 &button->code)) {
174 dev_err(dev, "button without keycode\n");
175 fwnode_handle_put(child);
176 return ERR_PTR(-EINVAL);
177 }
178
179 fwnode_property_read_string(child, "label", &button->desc);
180
181 if (fwnode_property_read_u32(child, "linux,input-type",
182 &button->type))
183 button->type = EV_KEY;
184
185 if (fwnode_property_read_u32(child, "linux,input-value",
186 (u32 *)&button->value))
187 button->value = 1;
188
189 button->wakeup =
190 fwnode_property_read_bool(child, "wakeup-source") ||
191
192 fwnode_property_read_bool(child, "gpio-key,wakeup");
193
194 if (fwnode_property_read_u32(child, "debounce-interval",
195 &button->debounce_interval))
196 button->debounce_interval = 5;
197
198 button++;
199 }
200
201 return pdata;
202}
203
204static void gpio_keys_polled_set_abs_params(struct input_dev *input,
205 const struct gpio_keys_platform_data *pdata, unsigned int code)
206{
207 int i, min = 0, max = 0;
208
209 for (i = 0; i < pdata->nbuttons; i++) {
210 const struct gpio_keys_button *button = &pdata->buttons[i];
211
212 if (button->type != EV_ABS || button->code != code)
213 continue;
214
215 if (button->value < min)
216 min = button->value;
217 if (button->value > max)
218 max = button->value;
219 }
220
221 input_set_abs_params(input, code, min, max, 0, 0);
222}
223
224static const struct of_device_id gpio_keys_polled_of_match[] = {
225 { .compatible = "gpio-keys-polled", },
226 { },
227};
228MODULE_DEVICE_TABLE(of, gpio_keys_polled_of_match);
229
230static int gpio_keys_polled_probe(struct platform_device *pdev)
231{
232 struct device *dev = &pdev->dev;
233 struct fwnode_handle *child = NULL;
234 const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
235 struct gpio_keys_polled_dev *bdev;
236 struct input_polled_dev *poll_dev;
237 struct input_dev *input;
238 size_t size;
239 int error;
240 int i;
241
242 if (!pdata) {
243 pdata = gpio_keys_polled_get_devtree_pdata(dev);
244 if (IS_ERR(pdata))
245 return PTR_ERR(pdata);
246 }
247
248 if (!pdata->poll_interval) {
249 dev_err(dev, "missing poll_interval value\n");
250 return -EINVAL;
251 }
252
253 size = sizeof(struct gpio_keys_polled_dev) +
254 pdata->nbuttons * sizeof(struct gpio_keys_button_data);
255 bdev = devm_kzalloc(dev, size, GFP_KERNEL);
256 if (!bdev) {
257 dev_err(dev, "no memory for private data\n");
258 return -ENOMEM;
259 }
260
261 poll_dev = devm_input_allocate_polled_device(dev);
262 if (!poll_dev) {
263 dev_err(dev, "no memory for polled device\n");
264 return -ENOMEM;
265 }
266
267 poll_dev->private = bdev;
268 poll_dev->poll = gpio_keys_polled_poll;
269 poll_dev->poll_interval = pdata->poll_interval;
270 poll_dev->open = gpio_keys_polled_open;
271 poll_dev->close = gpio_keys_polled_close;
272
273 input = poll_dev->input;
274
275 input->name = pdev->name;
276 input->phys = DRV_NAME"/input0";
277
278 input->id.bustype = BUS_HOST;
279 input->id.vendor = 0x0001;
280 input->id.product = 0x0001;
281 input->id.version = 0x0100;
282
283 __set_bit(EV_KEY, input->evbit);
284 if (pdata->rep)
285 __set_bit(EV_REP, input->evbit);
286
287 for (i = 0; i < pdata->nbuttons; i++) {
288 const struct gpio_keys_button *button = &pdata->buttons[i];
289 struct gpio_keys_button_data *bdata = &bdev->data[i];
290 unsigned int type = button->type ?: EV_KEY;
291
292 if (button->wakeup) {
293 dev_err(dev, DRV_NAME " does not support wakeup\n");
294 fwnode_handle_put(child);
295 return -EINVAL;
296 }
297
298 if (!dev_get_platdata(dev)) {
299
300 child = device_get_next_child_node(dev, child);
301 if (!child) {
302 dev_err(dev, "missing child device node\n");
303 return -EINVAL;
304 }
305
306 bdata->gpiod = devm_fwnode_get_gpiod_from_child(dev,
307 NULL, child,
308 GPIOD_IN,
309 button->desc);
310 if (IS_ERR(bdata->gpiod)) {
311 error = PTR_ERR(bdata->gpiod);
312 if (error != -EPROBE_DEFER)
313 dev_err(dev,
314 "failed to get gpio: %d\n",
315 error);
316 fwnode_handle_put(child);
317 return error;
318 }
319 } else if (gpio_is_valid(button->gpio)) {
320
321
322
323
324 unsigned flags = GPIOF_IN;
325
326 if (button->active_low)
327 flags |= GPIOF_ACTIVE_LOW;
328
329 error = devm_gpio_request_one(dev, button->gpio,
330 flags, button->desc ? : DRV_NAME);
331 if (error) {
332 dev_err(dev,
333 "unable to claim gpio %u, err=%d\n",
334 button->gpio, error);
335 return error;
336 }
337
338 bdata->gpiod = gpio_to_desc(button->gpio);
339 if (!bdata->gpiod) {
340 dev_err(dev,
341 "unable to convert gpio %u to descriptor\n",
342 button->gpio);
343 return -EINVAL;
344 }
345 }
346
347 bdata->last_state = -1;
348 bdata->threshold = DIV_ROUND_UP(button->debounce_interval,
349 pdata->poll_interval);
350
351 input_set_capability(input, type, button->code);
352 if (type == EV_ABS)
353 gpio_keys_polled_set_abs_params(input, pdata,
354 button->code);
355 }
356
357 fwnode_handle_put(child);
358
359 bdev->poll_dev = poll_dev;
360 bdev->dev = dev;
361 bdev->pdata = pdata;
362
363 error = input_register_polled_device(poll_dev);
364 if (error) {
365 dev_err(dev, "unable to register polled device, err=%d\n",
366 error);
367 return error;
368 }
369
370
371 for (i = 0; i < pdata->nbuttons; i++)
372 gpio_keys_polled_check_state(poll_dev, &pdata->buttons[i],
373 &bdev->data[i]);
374
375 input_sync(input);
376
377 return 0;
378}
379
380static struct platform_driver gpio_keys_polled_driver = {
381 .probe = gpio_keys_polled_probe,
382 .driver = {
383 .name = DRV_NAME,
384 .of_match_table = gpio_keys_polled_of_match,
385 },
386};
387module_platform_driver(gpio_keys_polled_driver);
388
389MODULE_LICENSE("GPL v2");
390MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
391MODULE_DESCRIPTION("Polled GPIO Buttons driver");
392MODULE_ALIAS("platform:" DRV_NAME);
393
