[net-next-2.6.git] / drivers / input / keyboard / matrix_keypad.c

/*
 *  GPIO driven matrix keyboard driver
 *
 *  Copyright (c) 2008 Marek Vasut <marek.vasut@gmail.com>
 *
 *  Based on corgikbd.c
 *
 *  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/types.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/jiffies.h>
#include <linux/module.h>
#include <linux/gpio.h>
#include <linux/input/matrix_keypad.h>
#include <linux/slab.h>

struct matrix_keypad {
	const struct matrix_keypad_platform_data *pdata;
	struct input_dev *input_dev;
	unsigned short *keycodes;
	unsigned int row_shift;

	DECLARE_BITMAP(disabled_gpios, MATRIX_MAX_ROWS);

	uint32_t last_key_state[MATRIX_MAX_COLS];
	struct delayed_work work;
	spinlock_t lock;
	bool scan_pending;
	bool stopped;
	bool gpio_all_disabled;
};

/*
 * NOTE: normally the GPIO has to be put into HiZ when de-activated to cause
 * minmal side effect when scanning other columns, here it is configured to
 * be input, and it should work on most platforms.
 */
static void __activate_col(const struct matrix_keypad_platform_data *pdata,
			   int col, bool on)
{
	bool level_on = !pdata->active_low;

	if (on) {
		gpio_direction_output(pdata->col_gpios[col], level_on);
	} else {
		gpio_set_value_cansleep(pdata->col_gpios[col], !level_on);
		gpio_direction_input(pdata->col_gpios[col]);
	}
}

static void activate_col(const struct matrix_keypad_platform_data *pdata,
			 int col, bool on)
{
	__activate_col(pdata, col, on);

	if (on && pdata->col_scan_delay_us)
		udelay(pdata->col_scan_delay_us);
}

static void activate_all_cols(const struct matrix_keypad_platform_data *pdata,
			      bool on)
{
	int col;

	for (col = 0; col < pdata->num_col_gpios; col++)
		__activate_col(pdata, col, on);
}

static bool row_asserted(const struct matrix_keypad_platform_data *pdata,
			 int row)
{
	return gpio_get_value_cansleep(pdata->row_gpios[row]) ?
			!pdata->active_low : pdata->active_low;
}

static void enable_row_irqs(struct matrix_keypad *keypad)
{
	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	int i;

	if (pdata->clustered_irq > 0)
		enable_irq(pdata->clustered_irq);
	else {
		for (i = 0; i < pdata->num_row_gpios; i++)
			enable_irq(gpio_to_irq(pdata->row_gpios[i]));
	}
}

static void disable_row_irqs(struct matrix_keypad *keypad)
{
	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	int i;

	if (pdata->clustered_irq > 0)
		disable_irq_nosync(pdata->clustered_irq);
	else {
		for (i = 0; i < pdata->num_row_gpios; i++)
			disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
	}
}

/*
 * This gets the keys from keyboard and reports it to input subsystem
 */
static void matrix_keypad_scan(struct work_struct *work)
{
	struct matrix_keypad *keypad =
		container_of(work, struct matrix_keypad, work.work);
	struct input_dev *input_dev = keypad->input_dev;
	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	uint32_t new_state[MATRIX_MAX_COLS];
	int row, col, code;

	/* de-activate all columns for scanning */
	activate_all_cols(pdata, false);

	memset(new_state, 0, sizeof(new_state));

	/* assert each column and read the row status out */
	for (col = 0; col < pdata->num_col_gpios; col++) {

		activate_col(pdata, col, true);

		for (row = 0; row < pdata->num_row_gpios; row++)
			new_state[col] |=
				row_asserted(pdata, row) ? (1 << row) : 0;

		activate_col(pdata, col, false);
	}

	for (col = 0; col < pdata->num_col_gpios; col++) {
		uint32_t bits_changed;

		bits_changed = keypad->last_key_state[col] ^ new_state[col];
		if (bits_changed == 0)
			continue;

		for (row = 0; row < pdata->num_row_gpios; row++) {
			if ((bits_changed & (1 << row)) == 0)
				continue;

			code = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
			input_event(input_dev, EV_MSC, MSC_SCAN, code);
			input_report_key(input_dev,
					 keypad->keycodes[code],
					 new_state[col] & (1 << row));
		}
	}
	input_sync(input_dev);

	memcpy(keypad->last_key_state, new_state, sizeof(new_state));

	activate_all_cols(pdata, true);

	/* Enable IRQs again */
	spin_lock_irq(&keypad->lock);
	keypad->scan_pending = false;
	enable_row_irqs(keypad);
	spin_unlock_irq(&keypad->lock);
}

static irqreturn_t matrix_keypad_interrupt(int irq, void *id)
{
	struct matrix_keypad *keypad = id;
	unsigned long flags;

	spin_lock_irqsave(&keypad->lock, flags);

	/*
	 * See if another IRQ beaten us to it and scheduled the
	 * scan already. In that case we should not try to
	 * disable IRQs again.
	 */
	if (unlikely(keypad->scan_pending || keypad->stopped))
		goto out;

	disable_row_irqs(keypad);
	keypad->scan_pending = true;
	schedule_delayed_work(&keypad->work,
		msecs_to_jiffies(keypad->pdata->debounce_ms));

out:
	spin_unlock_irqrestore(&keypad->lock, flags);
	return IRQ_HANDLED;
}

static int matrix_keypad_start(struct input_dev *dev)
{
	struct matrix_keypad *keypad = input_get_drvdata(dev);

	keypad->stopped = false;
	mb();

	/*
	 * Schedule an immediate key scan to capture current key state;
	 * columns will be activated and IRQs be enabled after the scan.
	 */
	schedule_delayed_work(&keypad->work, 0);

	return 0;
}

static void matrix_keypad_stop(struct input_dev *dev)
{
	struct matrix_keypad *keypad = input_get_drvdata(dev);

	keypad->stopped = true;
	mb();
	flush_work(&keypad->work.work);
	/*
	 * matrix_keypad_scan() will leave IRQs enabled;
	 * we should disable them now.
	 */
	disable_row_irqs(keypad);
}

#ifdef CONFIG_PM
static void matrix_keypad_enable_wakeup(struct matrix_keypad *keypad)
{
	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	unsigned int gpio;
	int i;

	if (pdata->clustered_irq > 0) {
		if (enable_irq_wake(pdata->clustered_irq) == 0)
			keypad->gpio_all_disabled = true;
	} else {

		for (i = 0; i < pdata->num_row_gpios; i++) {
			if (!test_bit(i, keypad->disabled_gpios)) {
				gpio = pdata->row_gpios[i];

				if (enable_irq_wake(gpio_to_irq(gpio)) == 0)
					__set_bit(i, keypad->disabled_gpios);
			}
		}
	}
}

static void matrix_keypad_disable_wakeup(struct matrix_keypad *keypad)
{
	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	unsigned int gpio;
	int i;

	if (pdata->clustered_irq > 0) {
		if (keypad->gpio_all_disabled) {
			disable_irq_wake(pdata->clustered_irq);
			keypad->gpio_all_disabled = false;
		}
	} else {
		for (i = 0; i < pdata->num_row_gpios; i++) {
			if (test_and_clear_bit(i, keypad->disabled_gpios)) {
				gpio = pdata->row_gpios[i];
				disable_irq_wake(gpio_to_irq(gpio));
			}
		}
	}
}

static int matrix_keypad_suspend(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct matrix_keypad *keypad = platform_get_drvdata(pdev);

	matrix_keypad_stop(keypad->input_dev);

	if (device_may_wakeup(&pdev->dev))
		matrix_keypad_enable_wakeup(keypad);

	return 0;
}

static int matrix_keypad_resume(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct matrix_keypad *keypad = platform_get_drvdata(pdev);

	if (device_may_wakeup(&pdev->dev))
		matrix_keypad_disable_wakeup(keypad);

	matrix_keypad_start(keypad->input_dev);

	return 0;
}

static const SIMPLE_DEV_PM_OPS(matrix_keypad_pm_ops,
				matrix_keypad_suspend, matrix_keypad_resume);
#endif

static int __devinit init_matrix_gpio(struct platform_device *pdev,
					struct matrix_keypad *keypad)
{
	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	int i, err = -EINVAL;

	/* initialized strobe lines as outputs, activated */
	for (i = 0; i < pdata->num_col_gpios; i++) {
		err = gpio_request(pdata->col_gpios[i], "matrix_kbd_col");
		if (err) {
			dev_err(&pdev->dev,
				"failed to request GPIO%d for COL%d\n",
				pdata->col_gpios[i], i);
			goto err_free_cols;
		}

		gpio_direction_output(pdata->col_gpios[i], !pdata->active_low);
	}

	for (i = 0; i < pdata->num_row_gpios; i++) {
		err = gpio_request(pdata->row_gpios[i], "matrix_kbd_row");
		if (err) {
			dev_err(&pdev->dev,
				"failed to request GPIO%d for ROW%d\n",
				pdata->row_gpios[i], i);
			goto err_free_rows;
		}

		gpio_direction_input(pdata->row_gpios[i]);
	}

	if (pdata->clustered_irq > 0) {
		err = request_irq(pdata->clustered_irq,
				matrix_keypad_interrupt,
				pdata->clustered_irq_flags,
				"matrix-keypad", keypad);
		if (err) {
			dev_err(&pdev->dev,
				"Unable to acquire clustered interrupt\n");
			goto err_free_rows;
		}
	} else {
		for (i = 0; i < pdata->num_row_gpios; i++) {
			err = request_irq(gpio_to_irq(pdata->row_gpios[i]),
					matrix_keypad_interrupt,
					IRQF_DISABLED |
					IRQF_TRIGGER_RISING |
					IRQF_TRIGGER_FALLING,
					"matrix-keypad", keypad);
			if (err) {
				dev_err(&pdev->dev,
					"Unable to acquire interrupt "
					"for GPIO line %i\n",
					pdata->row_gpios[i]);
				goto err_free_irqs;
			}
		}
	}

	/* initialized as disabled - enabled by input->open */
	disable_row_irqs(keypad);
	return 0;

err_free_irqs:
	while (--i >= 0)
		free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
	i = pdata->num_row_gpios;
err_free_rows:
	while (--i >= 0)
		gpio_free(pdata->row_gpios[i]);
	i = pdata->num_col_gpios;
err_free_cols:
	while (--i >= 0)
		gpio_free(pdata->col_gpios[i]);

	return err;
}

static int __devinit matrix_keypad_probe(struct platform_device *pdev)
{
	const struct matrix_keypad_platform_data *pdata;
	const struct matrix_keymap_data *keymap_data;
	struct matrix_keypad *keypad;
	struct input_dev *input_dev;
	unsigned short *keycodes;
	unsigned int row_shift;
	int err;

	pdata = pdev->dev.platform_data;
	if (!pdata) {
		dev_err(&pdev->dev, "no platform data defined\n");
		return -EINVAL;
	}

	keymap_data = pdata->keymap_data;
	if (!keymap_data) {
		dev_err(&pdev->dev, "no keymap data defined\n");
		return -EINVAL;
	}

	row_shift = get_count_order(pdata->num_col_gpios);

	keypad = kzalloc(sizeof(struct matrix_keypad), GFP_KERNEL);
	keycodes = kzalloc((pdata->num_row_gpios << row_shift) *
				sizeof(*keycodes),
			   GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!keypad || !keycodes || !input_dev) {
		err = -ENOMEM;
		goto err_free_mem;
	}

	keypad->input_dev = input_dev;
	keypad->pdata = pdata;
	keypad->keycodes = keycodes;
	keypad->row_shift = row_shift;
	keypad->stopped = true;
	INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan);
	spin_lock_init(&keypad->lock);

	input_dev->name		= pdev->name;
	input_dev->id.bustype	= BUS_HOST;
	input_dev->dev.parent	= &pdev->dev;
	input_dev->evbit[0]	= BIT_MASK(EV_KEY);
	if (!pdata->no_autorepeat)
		input_dev->evbit[0] |= BIT_MASK(EV_REP);
	input_dev->open		= matrix_keypad_start;
	input_dev->close	= matrix_keypad_stop;

	input_dev->keycode	= keycodes;
	input_dev->keycodesize	= sizeof(*keycodes);
	input_dev->keycodemax	= pdata->num_row_gpios << row_shift;

	matrix_keypad_build_keymap(keymap_data, row_shift,
				   input_dev->keycode, input_dev->keybit);

	input_set_capability(input_dev, EV_MSC, MSC_SCAN);
	input_set_drvdata(input_dev, keypad);

	err = init_matrix_gpio(pdev, keypad);
	if (err)
		goto err_free_mem;

	err = input_register_device(keypad->input_dev);
	if (err)
		goto err_free_mem;

	device_init_wakeup(&pdev->dev, pdata->wakeup);
	platform_set_drvdata(pdev, keypad);

	return 0;

err_free_mem:
	input_free_device(input_dev);
	kfree(keycodes);
	kfree(keypad);
	return err;
}

static int __devexit matrix_keypad_remove(struct platform_device *pdev)
{
	struct matrix_keypad *keypad = platform_get_drvdata(pdev);
	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	int i;

	device_init_wakeup(&pdev->dev, 0);

	if (pdata->clustered_irq > 0) {
		free_irq(pdata->clustered_irq, keypad);
	} else {
		for (i = 0; i < pdata->num_row_gpios; i++)
			free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
	}

	for (i = 0; i < pdata->num_row_gpios; i++)
		gpio_free(pdata->row_gpios[i]);

	for (i = 0; i < pdata->num_col_gpios; i++)
		gpio_free(pdata->col_gpios[i]);

	input_unregister_device(keypad->input_dev);
	platform_set_drvdata(pdev, NULL);
	kfree(keypad->keycodes);
	kfree(keypad);

	return 0;
}

static struct platform_driver matrix_keypad_driver = {
	.probe		= matrix_keypad_probe,
	.remove		= __devexit_p(matrix_keypad_remove),
	.driver		= {
		.name	= "matrix-keypad",
		.owner	= THIS_MODULE,
#ifdef CONFIG_PM
		.pm	= &matrix_keypad_pm_ops,
#endif
	},
};

static int __init matrix_keypad_init(void)
{
	return platform_driver_register(&matrix_keypad_driver);
}

static void __exit matrix_keypad_exit(void)
{
	platform_driver_unregister(&matrix_keypad_driver);
}

module_init(matrix_keypad_init);
module_exit(matrix_keypad_exit);

MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
MODULE_DESCRIPTION("GPIO Driven Matrix Keypad Driver");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:matrix-keypad");
Commit	Line	Data
bab7614d EM	1	/*
	2	* GPIO driven matrix keyboard driver
	3	*
	4	* Copyright (c) 2008 Marek Vasut <marek.vasut@gmail.com>
	5	*
	6	* Based on corgikbd.c
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	*/
	13
	14	#include <linux/types.h>
	15	#include <linux/delay.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/init.h>
	18	#include <linux/input.h>
	19	#include <linux/irq.h>
	20	#include <linux/interrupt.h>
	21	#include <linux/jiffies.h>
	22	#include <linux/module.h>
	23	#include <linux/gpio.h>
	24	#include <linux/input/matrix_keypad.h>
5a0e3ad6	25	#include <linux/slab.h>
bab7614d EM	26
	27	struct matrix_keypad {
	28	const struct matrix_keypad_platform_data *pdata;
	29	struct input_dev *input_dev;
	30	unsigned short *keycodes;
d82f1c35	31	unsigned int row_shift;
bab7614d	32
dd219234 DT	33	DECLARE_BITMAP(disabled_gpios, MATRIX_MAX_ROWS);
dd219234 DT	34
bab7614d EM	35	uint32_t last_key_state[MATRIX_MAX_COLS];
bab7614d EM	36	struct delayed_work work;
dd219234	37	spinlock_t lock;
bab7614d EM	38	bool scan_pending;
bab7614d EM	39	bool stopped;
fb76dd10	40	bool gpio_all_disabled;
bab7614d EM	41	};
	42
	43	/*
	44	* NOTE: normally the GPIO has to be put into HiZ when de-activated to cause
	45	* minmal side effect when scanning other columns, here it is configured to
	46	* be input, and it should work on most platforms.
	47	*/
	48	static void __activate_col(const struct matrix_keypad_platform_data *pdata,
	49	int col, bool on)
	50	{
	51	bool level_on = !pdata->active_low;
	52
	53	if (on) {
	54	gpio_direction_output(pdata->col_gpios[col], level_on);
	55	} else {
	56	gpio_set_value_cansleep(pdata->col_gpios[col], !level_on);
	57	gpio_direction_input(pdata->col_gpios[col]);
	58	}
	59	}
	60
	61	static void activate_col(const struct matrix_keypad_platform_data *pdata,
	62	int col, bool on)
	63	{
	64	__activate_col(pdata, col, on);
	65
	66	if (on && pdata->col_scan_delay_us)
	67	udelay(pdata->col_scan_delay_us);
	68	}
	69
	70	static void activate_all_cols(const struct matrix_keypad_platform_data *pdata,
	71	bool on)
	72	{
	73	int col;
	74
	75	for (col = 0; col < pdata->num_col_gpios; col++)
	76	__activate_col(pdata, col, on);
	77	}
	78
	79	static bool row_asserted(const struct matrix_keypad_platform_data *pdata,
	80	int row)
	81	{
	82	return gpio_get_value_cansleep(pdata->row_gpios[row]) ?
	83	!pdata->active_low : pdata->active_low;
	84	}
	85
	86	static void enable_row_irqs(struct matrix_keypad *keypad)
	87	{
	88	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	89	int i;
	90
fb76dd10 LF	91	if (pdata->clustered_irq > 0)
	92	enable_irq(pdata->clustered_irq);
	93	else {
	94	for (i = 0; i < pdata->num_row_gpios; i++)
	95	enable_irq(gpio_to_irq(pdata->row_gpios[i]));
	96	}
bab7614d EM	97	}
	98
	99	static void disable_row_irqs(struct matrix_keypad *keypad)
	100	{
	101	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	102	int i;
	103
fb76dd10 LF	104	if (pdata->clustered_irq > 0)
	105	disable_irq_nosync(pdata->clustered_irq);
	106	else {
	107	for (i = 0; i < pdata->num_row_gpios; i++)
	108	disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
	109	}
bab7614d EM	110	}
	111
	112	/*
	113	* This gets the keys from keyboard and reports it to input subsystem
	114	*/
	115	static void matrix_keypad_scan(struct work_struct *work)
	116	{
	117	struct matrix_keypad *keypad =
	118	container_of(work, struct matrix_keypad, work.work);
	119	struct input_dev *input_dev = keypad->input_dev;
	120	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	121	uint32_t new_state[MATRIX_MAX_COLS];
	122	int row, col, code;
	123
	124	/* de-activate all columns for scanning */
	125	activate_all_cols(pdata, false);
	126
	127	memset(new_state, 0, sizeof(new_state));
	128
	129	/* assert each column and read the row status out */
	130	for (col = 0; col < pdata->num_col_gpios; col++) {
	131
	132	activate_col(pdata, col, true);
	133
	134	for (row = 0; row < pdata->num_row_gpios; row++)
	135	new_state[col] \|=
	136	row_asserted(pdata, row) ? (1 << row) : 0;
	137
	138	activate_col(pdata, col, false);
	139	}
	140
	141	for (col = 0; col < pdata->num_col_gpios; col++) {
	142	uint32_t bits_changed;
	143
	144	bits_changed = keypad->last_key_state[col] ^ new_state[col];
	145	if (bits_changed == 0)
	146	continue;
	147
	148	for (row = 0; row < pdata->num_row_gpios; row++) {
	149	if ((bits_changed & (1 << row)) == 0)
	150	continue;
	151
d82f1c35	152	code = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
bab7614d EM	153	input_event(input_dev, EV_MSC, MSC_SCAN, code);
	154	input_report_key(input_dev,
	155	keypad->keycodes[code],
	156	new_state[col] & (1 << row));
	157	}
	158	}
	159	input_sync(input_dev);
	160
	161	memcpy(keypad->last_key_state, new_state, sizeof(new_state));
	162
	163	activate_all_cols(pdata, true);
	164
	165	/* Enable IRQs again */
	166	spin_lock_irq(&keypad->lock);
	167	keypad->scan_pending = false;
	168	enable_row_irqs(keypad);
	169	spin_unlock_irq(&keypad->lock);
	170	}
	171
	172	static irqreturn_t matrix_keypad_interrupt(int irq, void *id)
	173	{
	174	struct matrix_keypad *keypad = id;
	175	unsigned long flags;
	176
	177	spin_lock_irqsave(&keypad->lock, flags);
	178
	179	/*
	180	* See if another IRQ beaten us to it and scheduled the
	181	* scan already. In that case we should not try to
	182	* disable IRQs again.
	183	*/
	184	if (unlikely(keypad->scan_pending \|\| keypad->stopped))
	185	goto out;
	186
	187	disable_row_irqs(keypad);
	188	keypad->scan_pending = true;
	189	schedule_delayed_work(&keypad->work,
	190	msecs_to_jiffies(keypad->pdata->debounce_ms));
	191
	192	out:
	193	spin_unlock_irqrestore(&keypad->lock, flags);
	194	return IRQ_HANDLED;
	195	}
	196
	197	static int matrix_keypad_start(struct input_dev *dev)
	198	{
	199	struct matrix_keypad *keypad = input_get_drvdata(dev);
	200
	201	keypad->stopped = false;
	202	mb();
	203
	204	/*
	205	* Schedule an immediate key scan to capture current key state;
	206	* columns will be activated and IRQs be enabled after the scan.
	207	*/
	208	schedule_delayed_work(&keypad->work, 0);
	209
	210	return 0;
	211	}
	212
	213	static void matrix_keypad_stop(struct input_dev *dev)
	214	{
	215	struct matrix_keypad *keypad = input_get_drvdata(dev);
	216
217	keypad->stopped = true;
218	mb();
219	flush_work(&keypad->work.work);
220	/*
221	* matrix_keypad_scan() will leave IRQs enabled;
222	* we should disable them now.
223	*/
224	disable_row_irqs(keypad);
225	}
226
227	#ifdef CONFIG_PM
fb76dd10	228	static void matrix_keypad_enable_wakeup(struct matrix_keypad *keypad)
bab7614d	229	{
bab7614d	230	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
fb76dd10	231	unsigned int gpio;
bab7614d EM	232	int i;
bab7614d EM	233
fb76dd10 LF	234	if (pdata->clustered_irq > 0) {
	235	if (enable_irq_wake(pdata->clustered_irq) == 0)
	236	keypad->gpio_all_disabled = true;
	237	} else {
bab7614d	238
dd219234 DT	239	for (i = 0; i < pdata->num_row_gpios; i++) {
dd219234 DT	240	if (!test_bit(i, keypad->disabled_gpios)) {
fb76dd10	241	gpio = pdata->row_gpios[i];
dd219234 DT	242
	243	if (enable_irq_wake(gpio_to_irq(gpio)) == 0)
	244	__set_bit(i, keypad->disabled_gpios);
	245	}
	246	}
	247	}
bab7614d EM	248	}
bab7614d EM	249
fb76dd10	250	static void matrix_keypad_disable_wakeup(struct matrix_keypad *keypad)
bab7614d	251	{
bab7614d	252	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
fb76dd10	253	unsigned int gpio;
bab7614d EM	254	int i;
bab7614d EM	255
fb76dd10 LF	256	if (pdata->clustered_irq > 0) {
	257	if (keypad->gpio_all_disabled) {
	258	disable_irq_wake(pdata->clustered_irq);
	259	keypad->gpio_all_disabled = false;
	260	}
	261	} else {
dd219234 DT	262	for (i = 0; i < pdata->num_row_gpios; i++) {
dd219234 DT	263	if (test_and_clear_bit(i, keypad->disabled_gpios)) {
fb76dd10	264	gpio = pdata->row_gpios[i];
dd219234 DT	265	disable_irq_wake(gpio_to_irq(gpio));
	266	}
	267	}
	268	}
fb76dd10 LF	269	}
	270
	271	static int matrix_keypad_suspend(struct device *dev)
	272	{
	273	struct platform_device *pdev = to_platform_device(dev);
	274	struct matrix_keypad *keypad = platform_get_drvdata(pdev);
	275
	276	matrix_keypad_stop(keypad->input_dev);
	277
	278	if (device_may_wakeup(&pdev->dev))
	279	matrix_keypad_enable_wakeup(keypad);
	280
	281	return 0;
	282	}
	283
	284	static int matrix_keypad_resume(struct device *dev)
	285	{
	286	struct platform_device *pdev = to_platform_device(dev);
	287	struct matrix_keypad *keypad = platform_get_drvdata(pdev);
	288
	289	if (device_may_wakeup(&pdev->dev))
	290	matrix_keypad_disable_wakeup(keypad);
bab7614d EM	291
	292	matrix_keypad_start(keypad->input_dev);
	293
	294	return 0;
	295	}
f72a28ab DT	296
	297	static const SIMPLE_DEV_PM_OPS(matrix_keypad_pm_ops,
	298	matrix_keypad_suspend, matrix_keypad_resume);
bab7614d EM	299	#endif
	300
	301	static int __devinit init_matrix_gpio(struct platform_device *pdev,
	302	struct matrix_keypad *keypad)
	303	{
	304	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	305	int i, err = -EINVAL;
	306
	307	/* initialized strobe lines as outputs, activated */
	308	for (i = 0; i < pdata->num_col_gpios; i++) {
	309	err = gpio_request(pdata->col_gpios[i], "matrix_kbd_col");
	310	if (err) {
	311	dev_err(&pdev->dev,
	312	"failed to request GPIO%d for COL%d\n",
	313	pdata->col_gpios[i], i);
	314	goto err_free_cols;
	315	}
	316
	317	gpio_direction_output(pdata->col_gpios[i], !pdata->active_low);
	318	}
	319
	320	for (i = 0; i < pdata->num_row_gpios; i++) {
	321	err = gpio_request(pdata->row_gpios[i], "matrix_kbd_row");
	322	if (err) {
	323	dev_err(&pdev->dev,
	324	"failed to request GPIO%d for ROW%d\n",
	325	pdata->row_gpios[i], i);
	326	goto err_free_rows;
	327	}
	328
	329	gpio_direction_input(pdata->row_gpios[i]);
	330	}
	331
fb76dd10 LF	332	if (pdata->clustered_irq > 0) {
fb76dd10 LF	333	err = request_irq(pdata->clustered_irq,
bab7614d	334	matrix_keypad_interrupt,
fb76dd10	335	pdata->clustered_irq_flags,
bab7614d EM	336	"matrix-keypad", keypad);
	337	if (err) {
	338	dev_err(&pdev->dev,
fb76dd10 LF	339	"Unable to acquire clustered interrupt\n");
	340	goto err_free_rows;
	341	}
	342	} else {
	343	for (i = 0; i < pdata->num_row_gpios; i++) {
	344	err = request_irq(gpio_to_irq(pdata->row_gpios[i]),
	345	matrix_keypad_interrupt,
	346	IRQF_DISABLED \|
	347	IRQF_TRIGGER_RISING \|
	348	IRQF_TRIGGER_FALLING,
	349	"matrix-keypad", keypad);
	350	if (err) {
	351	dev_err(&pdev->dev,
	352	"Unable to acquire interrupt "
	353	"for GPIO line %i\n",
	354	pdata->row_gpios[i]);
	355	goto err_free_irqs;
	356	}
bab7614d EM	357	}
	358	}
	359
	360	/* initialized as disabled - enabled by input->open */
	361	disable_row_irqs(keypad);
	362	return 0;
	363
	364	err_free_irqs:
	365	while (--i >= 0)
	366	free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
	367	i = pdata->num_row_gpios;
	368	err_free_rows:
	369	while (--i >= 0)
	370	gpio_free(pdata->row_gpios[i]);
	371	i = pdata->num_col_gpios;
	372	err_free_cols:
	373	while (--i >= 0)
	374	gpio_free(pdata->col_gpios[i]);
	375
	376	return err;
	377	}
	378
	379	static int __devinit matrix_keypad_probe(struct platform_device *pdev)
	380	{
	381	const struct matrix_keypad_platform_data *pdata;
	382	const struct matrix_keymap_data *keymap_data;
	383	struct matrix_keypad *keypad;
	384	struct input_dev *input_dev;
	385	unsigned short *keycodes;
d82f1c35	386	unsigned int row_shift;
bab7614d EM	387	int err;
	388
	389	pdata = pdev->dev.platform_data;
	390	if (!pdata) {
	391	dev_err(&pdev->dev, "no platform data defined\n");
	392	return -EINVAL;
	393	}
	394
	395	keymap_data = pdata->keymap_data;
	396	if (!keymap_data) {
	397	dev_err(&pdev->dev, "no keymap data defined\n");
	398	return -EINVAL;
	399	}
	400
d82f1c35	401	row_shift = get_count_order(pdata->num_col_gpios);
bab7614d EM	402
bab7614d EM	403	keypad = kzalloc(sizeof(struct matrix_keypad), GFP_KERNEL);
d82f1c35 EM	404	keycodes = kzalloc((pdata->num_row_gpios << row_shift) *
d82f1c35 EM	405	sizeof(*keycodes),
bab7614d EM	406	GFP_KERNEL);
	407	input_dev = input_allocate_device();
	408	if (!keypad \|\| !keycodes \|\| !input_dev) {
	409	err = -ENOMEM;
	410	goto err_free_mem;
	411	}
	412
	413	keypad->input_dev = input_dev;
	414	keypad->pdata = pdata;
	415	keypad->keycodes = keycodes;
d82f1c35	416	keypad->row_shift = row_shift;
bab7614d EM	417	keypad->stopped = true;
	418	INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan);
	419	spin_lock_init(&keypad->lock);
	420
	421	input_dev->name = pdev->name;
	422	input_dev->id.bustype = BUS_HOST;
	423	input_dev->dev.parent = &pdev->dev;
9d32c305 HS	424	input_dev->evbit[0] = BIT_MASK(EV_KEY);
	425	if (!pdata->no_autorepeat)
	426	input_dev->evbit[0] \|= BIT_MASK(EV_REP);
bab7614d EM	427	input_dev->open = matrix_keypad_start;
	428	input_dev->close = matrix_keypad_stop;
	429
	430	input_dev->keycode = keycodes;
	431	input_dev->keycodesize = sizeof(*keycodes);
77a53fd2	432	input_dev->keycodemax = pdata->num_row_gpios << row_shift;
bab7614d	433
77a53fd2 DT	434	matrix_keypad_build_keymap(keymap_data, row_shift,
77a53fd2 DT	435	input_dev->keycode, input_dev->keybit);
bab7614d EM	436
	437	input_set_capability(input_dev, EV_MSC, MSC_SCAN);
	438	input_set_drvdata(input_dev, keypad);
	439
	440	err = init_matrix_gpio(pdev, keypad);
	441	if (err)
	442	goto err_free_mem;
	443
	444	err = input_register_device(keypad->input_dev);
	445	if (err)
	446	goto err_free_mem;
	447
	448	device_init_wakeup(&pdev->dev, pdata->wakeup);
	449	platform_set_drvdata(pdev, keypad);
	450
	451	return 0;
	452
	453	err_free_mem:
	454	input_free_device(input_dev);
	455	kfree(keycodes);
	456	kfree(keypad);
	457	return err;
	458	}
	459
	460	static int __devexit matrix_keypad_remove(struct platform_device *pdev)
	461	{
	462	struct matrix_keypad *keypad = platform_get_drvdata(pdev);
	463	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	464	int i;
	465
	466	device_init_wakeup(&pdev->dev, 0);
	467
fb76dd10 LF	468	if (pdata->clustered_irq > 0) {
	469	free_irq(pdata->clustered_irq, keypad);
	470	} else {
	471	for (i = 0; i < pdata->num_row_gpios; i++)
	472	free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
bab7614d EM	473	}
bab7614d EM	474
fb76dd10 LF	475	for (i = 0; i < pdata->num_row_gpios; i++)
	476	gpio_free(pdata->row_gpios[i]);
	477
bab7614d EM	478	for (i = 0; i < pdata->num_col_gpios; i++)
	479	gpio_free(pdata->col_gpios[i]);
	480
	481	input_unregister_device(keypad->input_dev);
	482	platform_set_drvdata(pdev, NULL);
	483	kfree(keypad->keycodes);
	484	kfree(keypad);
	485
	486	return 0;
	487	}
	488
	489	static struct platform_driver matrix_keypad_driver = {
	490	.probe = matrix_keypad_probe,
	491	.remove = __devexit_p(matrix_keypad_remove),
bab7614d EM	492	.driver = {
	493	.name = "matrix-keypad",
	494	.owner = THIS_MODULE,
f72a28ab DT	495	#ifdef CONFIG_PM
	496	.pm = &matrix_keypad_pm_ops,
	497	#endif
bab7614d EM	498	},
	499	};
	500
	501	static int __init matrix_keypad_init(void)
	502	{
	503	return platform_driver_register(&matrix_keypad_driver);
	504	}
	505
	506	static void __exit matrix_keypad_exit(void)
	507	{
	508	platform_driver_unregister(&matrix_keypad_driver);
	509	}
	510
	511	module_init(matrix_keypad_init);
	512	module_exit(matrix_keypad_exit);
	513
	514	MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
	515	MODULE_DESCRIPTION("GPIO Driven Matrix Keypad Driver");
	516	MODULE_LICENSE("GPL v2");
	517	MODULE_ALIAS("platform:matrix-keypad");