[deliverable/linux.git] / drivers / input / keyboard / gpio_keys_polled.c

/*
 *  Driver for buttons on GPIO lines not capable of generating interrupts
 *
 *  Copyright (C) 2007-2010 Gabor Juhos <juhosg@openwrt.org>
 *  Copyright (C) 2010 Nuno Goncalves <nunojpg@gmail.com>
 *
 *  This file was based on: /drivers/input/misc/cobalt_btns.c
 *	Copyright (C) 2007 Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
 *
 *  also was based on: /drivers/input/keyboard/gpio_keys.c
 *	Copyright 2005 Phil Blundell
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/input-polldev.h>
#include <linux/ioport.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <linux/gpio/consumer.h>
#include <linux/gpio_keys.h>
#include <linux/property.h>

#define DRV_NAME	"gpio-keys-polled"

struct gpio_keys_button_data {
	int last_state;
	int count;
	int threshold;
	int can_sleep;
};

struct gpio_keys_polled_dev {
	struct input_polled_dev *poll_dev;
	struct device *dev;
	const struct gpio_keys_platform_data *pdata;
	unsigned long rel_axis_seen[BITS_TO_LONGS(REL_CNT)];
	unsigned long abs_axis_seen[BITS_TO_LONGS(ABS_CNT)];
	struct gpio_keys_button_data data[0];
};

static void gpio_keys_button_event(struct input_polled_dev *dev,
				   struct gpio_keys_button *button,
				   int state)
{
	struct gpio_keys_polled_dev *bdev = dev->private;
	struct input_dev *input = dev->input;
	unsigned int type = button->type ?: EV_KEY;

	if (type == EV_REL) {
		if (state) {
			input_event(input, type, button->code, button->value);
			__set_bit(button->code, bdev->rel_axis_seen);
		}
	} else if (type == EV_ABS) {
		if (state) {
			input_event(input, type, button->code, button->value);
			__set_bit(button->code, bdev->abs_axis_seen);
		}
	} else {
		input_event(input, type, button->code, state);
		input_sync(input);
	}
}

static void gpio_keys_polled_check_state(struct input_polled_dev *dev,
					 struct gpio_keys_button *button,
					 struct gpio_keys_button_data *bdata)
{
	int state;

	if (bdata->can_sleep)
		state = !!gpiod_get_value_cansleep(button->gpiod);
	else
		state = !!gpiod_get_value(button->gpiod);

	gpio_keys_button_event(dev, button, state);

	if (state != bdata->last_state) {
		bdata->count = 0;
		bdata->last_state = state;
	}
}

static void gpio_keys_polled_poll(struct input_polled_dev *dev)
{
	struct gpio_keys_polled_dev *bdev = dev->private;
	const struct gpio_keys_platform_data *pdata = bdev->pdata;
	struct input_dev *input = dev->input;
	int i;

	memset(bdev->rel_axis_seen, 0, sizeof(bdev->rel_axis_seen));
	memset(bdev->abs_axis_seen, 0, sizeof(bdev->abs_axis_seen));

	for (i = 0; i < pdata->nbuttons; i++) {
		struct gpio_keys_button_data *bdata = &bdev->data[i];

		if (bdata->count < bdata->threshold) {
			bdata->count++;
			gpio_keys_button_event(dev, &pdata->buttons[i],
					       bdata->last_state);
		} else {
			gpio_keys_polled_check_state(dev, &pdata->buttons[i],
						     bdata);
		}
	}

	for_each_set_bit(i, input->relbit, REL_CNT) {
		if (!test_bit(i, bdev->rel_axis_seen))
			input_event(input, EV_REL, i, 0);
	}

	for_each_set_bit(i, input->absbit, ABS_CNT) {
		if (!test_bit(i, bdev->abs_axis_seen))
			input_event(input, EV_ABS, i, 0);
	}

	input_sync(input);
}

static void gpio_keys_polled_open(struct input_polled_dev *dev)
{
	struct gpio_keys_polled_dev *bdev = dev->private;
	const struct gpio_keys_platform_data *pdata = bdev->pdata;

	if (pdata->enable)
		pdata->enable(bdev->dev);
}

static void gpio_keys_polled_close(struct input_polled_dev *dev)
{
	struct gpio_keys_polled_dev *bdev = dev->private;
	const struct gpio_keys_platform_data *pdata = bdev->pdata;

	if (pdata->disable)
		pdata->disable(bdev->dev);
}

static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct device *dev)
{
	struct gpio_keys_platform_data *pdata;
	struct gpio_keys_button *button;
	struct fwnode_handle *child;
	int error;
	int nbuttons;

	nbuttons = device_get_child_node_count(dev);
	if (nbuttons == 0)
		return NULL;

	pdata = devm_kzalloc(dev, sizeof(*pdata) + nbuttons * sizeof(*button),
			     GFP_KERNEL);
	if (!pdata)
		return ERR_PTR(-ENOMEM);

	pdata->buttons = (struct gpio_keys_button *)(pdata + 1);

	pdata->rep = device_property_present(dev, "autorepeat");
	device_property_read_u32(dev, "poll-interval", &pdata->poll_interval);

	device_for_each_child_node(dev, child) {
		struct gpio_desc *desc;

		desc = devm_get_gpiod_from_child(dev, NULL, child);
		if (IS_ERR(desc)) {
			error = PTR_ERR(desc);
			if (error != -EPROBE_DEFER)
				dev_err(dev,
					"Failed to get gpio flags, error: %d\n",
					error);
			fwnode_handle_put(child);
			return ERR_PTR(error);
		}

		button = &pdata->buttons[pdata->nbuttons++];
		button->gpiod = desc;

		if (fwnode_property_read_u32(child, "linux,code", &button->code)) {
			dev_err(dev, "Button without keycode: %d\n",
				pdata->nbuttons - 1);
			fwnode_handle_put(child);
			return ERR_PTR(-EINVAL);
		}

		fwnode_property_read_string(child, "label", &button->desc);

		if (fwnode_property_read_u32(child, "linux,input-type",
					     &button->type))
			button->type = EV_KEY;

		if (fwnode_property_read_u32(child, "linux,input-value",
					     (u32 *)&button->value))
			button->value = 1;

		button->wakeup =
			fwnode_property_read_bool(child, "wakeup-source") ||
			/* legacy name */
			fwnode_property_read_bool(child, "gpio-key,wakeup");

		if (fwnode_property_read_u32(child, "debounce-interval",
					     &button->debounce_interval))
			button->debounce_interval = 5;
	}

	if (pdata->nbuttons == 0)
		return ERR_PTR(-EINVAL);

	return pdata;
}

static void gpio_keys_polled_set_abs_params(struct input_dev *input,
	const struct gpio_keys_platform_data *pdata, unsigned int code)
{
	int i, min = 0, max = 0;

	for (i = 0; i < pdata->nbuttons; i++) {
		struct gpio_keys_button *button = &pdata->buttons[i];

		if (button->type != EV_ABS || button->code != code)
			continue;

		if (button->value < min)
			min = button->value;
		if (button->value > max)
			max = button->value;
	}
	input_set_abs_params(input, code, min, max, 0, 0);
}

static const struct of_device_id gpio_keys_polled_of_match[] = {
	{ .compatible = "gpio-keys-polled", },
	{ },
};
MODULE_DEVICE_TABLE(of, gpio_keys_polled_of_match);

static int gpio_keys_polled_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
	struct gpio_keys_polled_dev *bdev;
	struct input_polled_dev *poll_dev;
	struct input_dev *input;
	size_t size;
	int error;
	int i;

	if (!pdata) {
		pdata = gpio_keys_polled_get_devtree_pdata(dev);
		if (IS_ERR(pdata))
			return PTR_ERR(pdata);
		if (!pdata) {
			dev_err(dev, "missing platform data\n");
			return -EINVAL;
		}
	}

	if (!pdata->poll_interval) {
		dev_err(dev, "missing poll_interval value\n");
		return -EINVAL;
	}

	size = sizeof(struct gpio_keys_polled_dev) +
			pdata->nbuttons * sizeof(struct gpio_keys_button_data);
	bdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
	if (!bdev) {
		dev_err(dev, "no memory for private data\n");
		return -ENOMEM;
	}

	poll_dev = devm_input_allocate_polled_device(&pdev->dev);
	if (!poll_dev) {
		dev_err(dev, "no memory for polled device\n");
		return -ENOMEM;
	}

	poll_dev->private = bdev;
	poll_dev->poll = gpio_keys_polled_poll;
	poll_dev->poll_interval = pdata->poll_interval;
	poll_dev->open = gpio_keys_polled_open;
	poll_dev->close = gpio_keys_polled_close;

	input = poll_dev->input;

	input->name = pdev->name;
	input->phys = DRV_NAME"/input0";

	input->id.bustype = BUS_HOST;
	input->id.vendor = 0x0001;
	input->id.product = 0x0001;
	input->id.version = 0x0100;

	__set_bit(EV_KEY, input->evbit);
	if (pdata->rep)
		__set_bit(EV_REP, input->evbit);

	for (i = 0; i < pdata->nbuttons; i++) {
		struct gpio_keys_button *button = &pdata->buttons[i];
		struct gpio_keys_button_data *bdata = &bdev->data[i];
		unsigned int type = button->type ?: EV_KEY;

		if (button->wakeup) {
			dev_err(dev, DRV_NAME " does not support wakeup\n");
			return -EINVAL;
		}

		/*
		 * Legacy GPIO number so request the GPIO here and
		 * convert it to descriptor.
		 */
		if (!button->gpiod && gpio_is_valid(button->gpio)) {
			unsigned flags = GPIOF_IN;

			if (button->active_low)
				flags |= GPIOF_ACTIVE_LOW;

			error = devm_gpio_request_one(&pdev->dev, button->gpio,
					flags, button->desc ? : DRV_NAME);
			if (error) {
				dev_err(dev, "unable to claim gpio %u, err=%d\n",
					button->gpio, error);
				return error;
			}

			button->gpiod = gpio_to_desc(button->gpio);
		}

		if (IS_ERR(button->gpiod))
			return PTR_ERR(button->gpiod);

		bdata->can_sleep = gpiod_cansleep(button->gpiod);
		bdata->last_state = -1;
		bdata->threshold = DIV_ROUND_UP(button->debounce_interval,
						pdata->poll_interval);

		input_set_capability(input, type, button->code);
		if (type == EV_ABS)
			gpio_keys_polled_set_abs_params(input, pdata,
							button->code);
	}

	bdev->poll_dev = poll_dev;
	bdev->dev = dev;
	bdev->pdata = pdata;
	platform_set_drvdata(pdev, bdev);

	error = input_register_polled_device(poll_dev);
	if (error) {
		dev_err(dev, "unable to register polled device, err=%d\n",
			error);
		return error;
	}

	/* report initial state of the buttons */
	for (i = 0; i < pdata->nbuttons; i++)
		gpio_keys_polled_check_state(poll_dev, &pdata->buttons[i],
					     &bdev->data[i]);

	input_sync(input);

	return 0;
}

static struct platform_driver gpio_keys_polled_driver = {
	.probe	= gpio_keys_polled_probe,
	.driver	= {
		.name	= DRV_NAME,
		.of_match_table = gpio_keys_polled_of_match,
	},
};
module_platform_driver(gpio_keys_polled_driver);

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