[linux-2.6-block.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>

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

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

/*
 * 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;

	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;

	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 = (row << 4) + col;
			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 int matrix_keypad_suspend(struct platform_device *pdev, pm_message_t state)
{
	struct matrix_keypad *keypad = platform_get_drvdata(pdev);
	const struct matrix_keypad_platform_data *pdata = keypad->pdata;
	int i;

	matrix_keypad_stop(keypad->input_dev);

	if (device_may_wakeup(&pdev->dev))
		for (i = 0; i < pdata->num_row_gpios; i++)
			enable_irq_wake(gpio_to_irq(pdata->row_gpios[i]));

	return 0;
}

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

	if (device_may_wakeup(&pdev->dev))
		for (i = 0; i < pdata->num_row_gpios; i++)
			disable_irq_wake(gpio_to_irq(pdata->row_gpios[i]));

	matrix_keypad_start(keypad->input_dev);

	return 0;
}
#else
#define matrix_keypad_suspend	NULL
#define matrix_keypad_resume	NULL
#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]);
	}

	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;
	int i;
	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;
	}

	if (!keymap_data->max_keymap_size) {
		dev_err(&pdev->dev, "invalid keymap data supplied\n");
		return -EINVAL;
	}

	keypad = kzalloc(sizeof(struct matrix_keypad), GFP_KERNEL);
	keycodes = kzalloc(keymap_data->max_keymap_size *
				sizeof(keypad->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->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) | 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	= keymap_data->max_keymap_size;

	for (i = 0; i < keymap_data->keymap_size; i++) {
		unsigned int key = keymap_data->keymap[i];
		unsigned int row = KEY_ROW(key);
		unsigned int col = KEY_COL(key);
		unsigned short code = KEY_VAL(key);

		keycodes[(row << 4) + col] = code;
		__set_bit(code, input_dev->keybit);
	}
	__clear_bit(KEY_RESERVED, 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);

	for (i = 0; i < pdata->num_row_gpios; i++) {
		free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
		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),
	.suspend	= matrix_keypad_suspend,
	.resume		= matrix_keypad_resume,
	.driver		= {
		.name	= "matrix-keypad",
		.owner	= THIS_MODULE,
	},
};

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