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/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 
32 struct gpio_keys_button_data {
33 	struct gpio_desc *gpiod;
34 	int last_state;
35 	int count;
36 	int threshold;
37 };
38 
39 struct 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 
48 static 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 
72 static 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 
92 static 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 
128 static 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 
137 static 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 
146 static struct gpio_keys_platform_data *
147 gpio_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 			/* legacy name */
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 
204 static 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 
224 static const struct of_device_id gpio_keys_polled_of_match[] = {
225 	{ .compatible = "gpio-keys-polled", },
226 	{ },
227 };
228 MODULE_DEVICE_TABLE(of, gpio_keys_polled_of_match);
229 
230 static 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 			/* No legacy static platform data */
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 			 * Legacy GPIO number so request the GPIO here and
322 			 * convert it to descriptor.
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 	/* report initial state of the buttons */
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 
380 static 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 };
387 module_platform_driver(gpio_keys_polled_driver);
388 
389 MODULE_LICENSE("GPL v2");
390 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
391 MODULE_DESCRIPTION("Polled GPIO Buttons driver");
392 MODULE_ALIAS("platform:" DRV_NAME);
393