[mirror_ubuntu-jammy-kernel.git] / drivers / input / keyboard / gpio_keys.c

/*
 * Driver for keys on GPIO lines capable of generating interrupts.
 *
 * 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/module.h>

#include <linux/init.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/sched.h>
#include <linux/pm.h>
#include <linux/sysctl.h>
#include <linux/proc_fs.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/gpio_keys.h>
#include <linux/workqueue.h>
#include <linux/gpio.h>

struct gpio_button_data {
	struct gpio_keys_button *button;
	struct input_dev *input;
	struct timer_list timer;
	struct work_struct work;
};

struct gpio_keys_drvdata {
	struct input_dev *input;
	struct gpio_button_data data[0];
};

static void gpio_keys_report_event(struct work_struct *work)
{
	struct gpio_button_data *bdata =
		container_of(work, struct gpio_button_data, work);
	struct gpio_keys_button *button = bdata->button;
	struct input_dev *input = bdata->input;
	unsigned int type = button->type ?: EV_KEY;
	int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low;

	input_event(input, type, button->code, !!state);
	input_sync(input);
}

static void gpio_keys_timer(unsigned long _data)
{
	struct gpio_button_data *data = (struct gpio_button_data *)_data;

	schedule_work(&data->work);
}

static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
{
	struct gpio_button_data *bdata = dev_id;
	struct gpio_keys_button *button = bdata->button;

	BUG_ON(irq != gpio_to_irq(button->gpio));

	if (button->debounce_interval)
		mod_timer(&bdata->timer,
			jiffies + msecs_to_jiffies(button->debounce_interval));
	else
		schedule_work(&bdata->work);

	return IRQ_HANDLED;
}

static int __devinit gpio_keys_setup_key(struct device *dev,
					 struct gpio_button_data *bdata,
					 struct gpio_keys_button *button)
{
	char *desc = button->desc ? button->desc : "gpio_keys";
	int irq, error;

	setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata);
	INIT_WORK(&bdata->work, gpio_keys_report_event);

	error = gpio_request(button->gpio, desc);
	if (error < 0) {
		dev_err(dev, "failed to request GPIO %d, error %d\n",
			button->gpio, error);
		goto fail2;
	}

	error = gpio_direction_input(button->gpio);
	if (error < 0) {
		dev_err(dev, "failed to configure"
			" direction for GPIO %d, error %d\n",
			button->gpio, error);
		goto fail3;
	}

	irq = gpio_to_irq(button->gpio);
	if (irq < 0) {
		error = irq;
		dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n",
			button->gpio, error);
		goto fail3;
	}

	error = request_irq(irq, gpio_keys_isr,
			    IRQF_SHARED |
			    IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
			    desc, bdata);
	if (error) {
		dev_err(dev, "Unable to claim irq %d; error %d\n",
			irq, error);
		goto fail3;
	}

	return 0;

fail3:
	gpio_free(button->gpio);
fail2:
	return error;
}

static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
	struct gpio_keys_drvdata *ddata;
	struct device *dev = &pdev->dev;
	struct input_dev *input;
	int i, error;
	int wakeup = 0;

	ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
			pdata->nbuttons * sizeof(struct gpio_button_data),
			GFP_KERNEL);
	input = input_allocate_device();
	if (!ddata || !input) {
		dev_err(dev, "failed to allocate state\n");
		error = -ENOMEM;
		goto fail1;
	}

	platform_set_drvdata(pdev, ddata);

	input->name = pdev->name;
	input->phys = "gpio-keys/input0";
	input->dev.parent = &pdev->dev;

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

	/* Enable auto repeat feature of Linux input subsystem */
	if (pdata->rep)
		__set_bit(EV_REP, input->evbit);

	ddata->input = input;

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

		bdata->input = input;
		bdata->button = button;

		error = gpio_keys_setup_key(dev, bdata, button);
		if (error)
			goto fail2;

		if (button->wakeup)
			wakeup = 1;

		input_set_capability(input, type, button->code);
	}

	error = input_register_device(input);
	if (error) {
		dev_err(dev, "Unable to register input device, "
			"error: %d\n", error);
		goto fail2;
	}

	device_init_wakeup(&pdev->dev, wakeup);

	return 0;

 fail2:
	while (--i >= 0) {
		free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
		if (pdata->buttons[i].debounce_interval)
			del_timer_sync(&ddata->data[i].timer);
		cancel_work_sync(&ddata->data[i].work);
		gpio_free(pdata->buttons[i].gpio);
	}

	platform_set_drvdata(pdev, NULL);
 fail1:
	input_free_device(input);
	kfree(ddata);

	return error;
}

static int __devexit gpio_keys_remove(struct platform_device *pdev)
{
	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
	struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);
	struct input_dev *input = ddata->input;
	int i;

	device_init_wakeup(&pdev->dev, 0);

	for (i = 0; i < pdata->nbuttons; i++) {
		int irq = gpio_to_irq(pdata->buttons[i].gpio);
		free_irq(irq, &ddata->data[i]);
		if (pdata->buttons[i].debounce_interval)
			del_timer_sync(&ddata->data[i].timer);
		cancel_work_sync(&ddata->data[i].work);
		gpio_free(pdata->buttons[i].gpio);
	}

	input_unregister_device(input);

	return 0;
}


#ifdef CONFIG_PM
static int gpio_keys_suspend(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
	int i;

	if (device_may_wakeup(&pdev->dev)) {
		for (i = 0; i < pdata->nbuttons; i++) {
			struct gpio_keys_button *button = &pdata->buttons[i];
			if (button->wakeup) {
				int irq = gpio_to_irq(button->gpio);
				enable_irq_wake(irq);
			}
		}
	}

	return 0;
}

static int gpio_keys_resume(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
	int i;

	if (device_may_wakeup(&pdev->dev)) {
		for (i = 0; i < pdata->nbuttons; i++) {
			struct gpio_keys_button *button = &pdata->buttons[i];
			if (button->wakeup) {
				int irq = gpio_to_irq(button->gpio);
				disable_irq_wake(irq);
			}
		}
	}

	return 0;
}

static const struct dev_pm_ops gpio_keys_pm_ops = {
	.suspend	= gpio_keys_suspend,
	.resume		= gpio_keys_resume,
};
#endif

static struct platform_driver gpio_keys_device_driver = {
	.probe		= gpio_keys_probe,
	.remove		= __devexit_p(gpio_keys_remove),
	.driver		= {
		.name	= "gpio-keys",
		.owner	= THIS_MODULE,
#ifdef CONFIG_PM
		.pm	= &gpio_keys_pm_ops,
#endif
	}
};

static int __init gpio_keys_init(void)
{
	return platform_driver_register(&gpio_keys_device_driver);
}

static void __exit gpio_keys_exit(void)
{
	platform_driver_unregister(&gpio_keys_device_driver);
}

module_init(gpio_keys_init);
module_exit(gpio_keys_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs");
MODULE_ALIAS("platform:gpio-keys");
Commit	Line	Data
78a56aab PB	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>
78a56aab PB	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>
49015bee	24	#include <linux/gpio_keys.h>
da0d03fe	25	#include <linux/workqueue.h>
111bc59c	26	#include <linux/gpio.h>
78a56aab	27
a33466e3 DB	28	struct gpio_button_data {
	29	struct gpio_keys_button *button;
	30	struct input_dev *input;
ca865a77	31	struct timer_list timer;
da0d03fe	32	struct work_struct work;
a33466e3 DB	33	};
	34
	35	struct gpio_keys_drvdata {
	36	struct input_dev *input;
	37	struct gpio_button_data data[0];
	38	};
	39
da0d03fe	40	static void gpio_keys_report_event(struct work_struct *work)
a33466e3	41	{
da0d03fe JN	42	struct gpio_button_data *bdata =
da0d03fe JN	43	container_of(work, struct gpio_button_data, work);
ce25d7e9 UKK	44	struct gpio_keys_button *button = bdata->button;
ce25d7e9 UKK	45	struct input_dev *input = bdata->input;
a33466e3 DB	46	unsigned int type = button->type ?: EV_KEY;
	47	int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low;
	48
	49	input_event(input, type, button->code, !!state);
	50	input_sync(input);
	51	}
	52
da0d03fe	53	static void gpio_keys_timer(unsigned long _data)
ca865a77 JN	54	{
	55	struct gpio_button_data data = (struct gpio_button_data )_data;
	56
da0d03fe	57	schedule_work(&data->work);
ca865a77 JN	58	}
ca865a77 JN	59
78a56aab PB	60	static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
78a56aab PB	61	{
57ffe9d5 UKK	62	struct gpio_button_data *bdata = dev_id;
57ffe9d5 UKK	63	struct gpio_keys_button *button = bdata->button;
78a56aab	64
57ffe9d5	65	BUG_ON(irq != gpio_to_irq(button->gpio));
84767d00	66
ca865a77 JN	67	if (button->debounce_interval)
	68	mod_timer(&bdata->timer,
	69	jiffies + msecs_to_jiffies(button->debounce_interval));
	70	else
da0d03fe	71	schedule_work(&bdata->work);
78a56aab	72
57ffe9d5	73	return IRQ_HANDLED;
78a56aab PB	74	}
78a56aab PB	75
bc8f1eaf BD	76	static int __devinit gpio_keys_setup_key(struct device *dev,
	77	struct gpio_button_data *bdata,
	78	struct gpio_keys_button *button)
	79	{
	80	char *desc = button->desc ? button->desc : "gpio_keys";
	81	int irq, error;
	82
	83	setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata);
	84	INIT_WORK(&bdata->work, gpio_keys_report_event);
	85
	86	error = gpio_request(button->gpio, desc);
	87	if (error < 0) {
	88	dev_err(dev, "failed to request GPIO %d, error %d\n",
	89	button->gpio, error);
	90	goto fail2;
	91	}
	92
	93	error = gpio_direction_input(button->gpio);
	94	if (error < 0) {
	95	dev_err(dev, "failed to configure"
	96	" direction for GPIO %d, error %d\n",
	97	button->gpio, error);
	98	goto fail3;
	99	}
	100
	101	irq = gpio_to_irq(button->gpio);
	102	if (irq < 0) {
	103	error = irq;
	104	dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n",
	105	button->gpio, error);
	106	goto fail3;
	107	}
	108
	109	error = request_irq(irq, gpio_keys_isr,
	110	IRQF_SHARED \|
	111	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING,
	112	desc, bdata);
	113	if (error) {
	114	dev_err(dev, "Unable to claim irq %d; error %d\n",
	115	irq, error);
	116	goto fail3;
	117	}
	118
	119	return 0;
	120
	121	fail3:
	122	gpio_free(button->gpio);
	123	fail2:
	124	return error;
	125	}
	126
78a56aab PB	127	static int __devinit gpio_keys_probe(struct platform_device *pdev)
	128	{
	129	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
a33466e3	130	struct gpio_keys_drvdata *ddata;
db19fd8b	131	struct device *dev = &pdev->dev;
78a56aab PB	132	struct input_dev *input;
78a56aab PB	133	int i, error;
e15b0213	134	int wakeup = 0;
78a56aab	135
a33466e3 DB	136	ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
	137	pdata->nbuttons * sizeof(struct gpio_button_data),
	138	GFP_KERNEL);
78a56aab	139	input = input_allocate_device();
a33466e3	140	if (!ddata \|\| !input) {
db19fd8b	141	dev_err(dev, "failed to allocate state\n");
a33466e3 DB	142	error = -ENOMEM;
	143	goto fail1;
	144	}
78a56aab	145
a33466e3	146	platform_set_drvdata(pdev, ddata);
78a56aab PB	147
	148	input->name = pdev->name;
	149	input->phys = "gpio-keys/input0";
469ba4df	150	input->dev.parent = &pdev->dev;
78a56aab PB	151
	152	input->id.bustype = BUS_HOST;
	153	input->id.vendor = 0x0001;
	154	input->id.product = 0x0001;
	155	input->id.version = 0x0100;
	156
b67b4b11 DC	157	/* Enable auto repeat feature of Linux input subsystem */
	158	if (pdata->rep)
	159	__set_bit(EV_REP, input->evbit);
	160
a33466e3 DB	161	ddata->input = input;
a33466e3 DB	162
78a56aab	163	for (i = 0; i < pdata->nbuttons; i++) {
84767d00	164	struct gpio_keys_button *button = &pdata->buttons[i];
a33466e3	165	struct gpio_button_data *bdata = &ddata->data[i];
84767d00	166	unsigned int type = button->type ?: EV_KEY;
78a56aab	167
a33466e3	168	bdata->input = input;
74dd4393	169	bdata->button = button;
bc8f1eaf BD	170
	171	error = gpio_keys_setup_key(dev, bdata, button);
	172	if (error)
a33466e3	173	goto fail2;
84767d00	174
e15b0213 AS	175	if (button->wakeup)
	176	wakeup = 1;
	177
84767d00	178	input_set_capability(input, type, button->code);
78a56aab PB	179	}
	180
	181	error = input_register_device(input);
	182	if (error) {
db19fd8b	183	dev_err(dev, "Unable to register input device, "
006df302	184	"error: %d\n", error);
a33466e3	185	goto fail2;
78a56aab PB	186	}
78a56aab PB	187
e15b0213 AS	188	device_init_wakeup(&pdev->dev, wakeup);
e15b0213 AS	189
78a56aab PB	190	return 0;
78a56aab PB	191
a33466e3	192	fail2:
6a2e3911	193	while (--i >= 0) {
57ffe9d5	194	free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
ca865a77 JN	195	if (pdata->buttons[i].debounce_interval)
ca865a77 JN	196	del_timer_sync(&ddata->data[i].timer);
da0d03fe	197	cancel_work_sync(&ddata->data[i].work);
6a2e3911 HVR	198	gpio_free(pdata->buttons[i].gpio);
6a2e3911 HVR	199	}
78a56aab	200
006df302	201	platform_set_drvdata(pdev, NULL);
a33466e3	202	fail1:
78a56aab	203	input_free_device(input);
a33466e3	204	kfree(ddata);
78a56aab PB	205
	206	return error;
	207	}
	208
	209	static int __devexit gpio_keys_remove(struct platform_device *pdev)
	210	{
	211	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
a33466e3 DB	212	struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);
a33466e3 DB	213	struct input_dev *input = ddata->input;
78a56aab PB	214	int i;
78a56aab PB	215
e15b0213 AS	216	device_init_wakeup(&pdev->dev, 0);
e15b0213 AS	217
78a56aab	218	for (i = 0; i < pdata->nbuttons; i++) {
0d98f6bb	219	int irq = gpio_to_irq(pdata->buttons[i].gpio);
57ffe9d5	220	free_irq(irq, &ddata->data[i]);
ca865a77 JN	221	if (pdata->buttons[i].debounce_interval)
ca865a77 JN	222	del_timer_sync(&ddata->data[i].timer);
da0d03fe	223	cancel_work_sync(&ddata->data[i].work);
6a2e3911	224	gpio_free(pdata->buttons[i].gpio);
78a56aab PB	225	}
	226
	227	input_unregister_device(input);
	228
	229	return 0;
	230	}
	231
e15b0213 AS	232
e15b0213 AS	233	#ifdef CONFIG_PM
ae78e0e0	234	static int gpio_keys_suspend(struct device *dev)
e15b0213	235	{
ae78e0e0	236	struct platform_device *pdev = to_platform_device(dev);
e15b0213 AS	237	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
	238	int i;
	239
	240	if (device_may_wakeup(&pdev->dev)) {
	241	for (i = 0; i < pdata->nbuttons; i++) {
	242	struct gpio_keys_button *button = &pdata->buttons[i];
	243	if (button->wakeup) {
	244	int irq = gpio_to_irq(button->gpio);
	245	enable_irq_wake(irq);
	246	}
	247	}
	248	}
	249
	250	return 0;
	251	}
	252
ae78e0e0	253	static int gpio_keys_resume(struct device *dev)
e15b0213	254	{
ae78e0e0	255	struct platform_device *pdev = to_platform_device(dev);
e15b0213 AS	256	struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
	257	int i;
	258
	259	if (device_may_wakeup(&pdev->dev)) {
	260	for (i = 0; i < pdata->nbuttons; i++) {
	261	struct gpio_keys_button *button = &pdata->buttons[i];
	262	if (button->wakeup) {
	263	int irq = gpio_to_irq(button->gpio);
	264	disable_irq_wake(irq);
	265	}
	266	}
	267	}
	268
	269	return 0;
	270	}
ae78e0e0 MR	271
	272	static const struct dev_pm_ops gpio_keys_pm_ops = {
	273	.suspend = gpio_keys_suspend,
	274	.resume = gpio_keys_resume,
	275	};
e15b0213 AS	276	#endif
e15b0213 AS	277
9b07044c	278	static struct platform_driver gpio_keys_device_driver = {
78a56aab PB	279	.probe = gpio_keys_probe,
	280	.remove = __devexit_p(gpio_keys_remove),
	281	.driver = {
	282	.name = "gpio-keys",
d7b5247b	283	.owner = THIS_MODULE,
ae78e0e0 MR	284	#ifdef CONFIG_PM
	285	.pm = &gpio_keys_pm_ops,
	286	#endif
78a56aab PB	287	}
	288	};
	289
	290	static int __init gpio_keys_init(void)
	291	{
	292	return platform_driver_register(&gpio_keys_device_driver);
	293	}
	294
	295	static void __exit gpio_keys_exit(void)
	296	{
	297	platform_driver_unregister(&gpio_keys_device_driver);
	298	}
	299
	300	module_init(gpio_keys_init);
	301	module_exit(gpio_keys_exit);
	302
	303	MODULE_LICENSE("GPL");
	304	MODULE_AUTHOR("Phil Blundell <pb@handhelds.org>");
	305	MODULE_DESCRIPTION("Keyboard driver for CPU GPIOs");
d7b5247b	306	MODULE_ALIAS("platform:gpio-keys");