[deliverable/linux.git] / drivers / input / keyboard / omap-keypad.c

/*
 * linux/drivers/input/keyboard/omap-keypad.c
 *
 * OMAP Keypad Driver
 *
 * Copyright (C) 2003 Nokia Corporation
 * Written by Timo Teräs <ext-timo.teras@nokia.com>
 *
 * Added support for H2 & H3 Keypad
 * Copyright (C) 2004 Texas Instruments
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/types.h>
#include <linux/input.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <asm/gpio.h>
#include <plat/keypad.h>
#include <plat/menelaus.h>
#include <asm/irq.h>
#include <mach/hardware.h>
#include <asm/io.h>
#include <plat/mux.h>

#undef NEW_BOARD_LEARNING_MODE

static void omap_kp_tasklet(unsigned long);
static void omap_kp_timer(unsigned long);

static unsigned char keypad_state[8];
static DEFINE_MUTEX(kp_enable_mutex);
static int kp_enable = 1;
static int kp_cur_group = -1;

struct omap_kp {
	struct input_dev *input;
	struct timer_list timer;
	int irq;
	unsigned int rows;
	unsigned int cols;
	unsigned long delay;
	unsigned int debounce;
	unsigned short keymap[];
};

static DECLARE_TASKLET_DISABLED(kp_tasklet, omap_kp_tasklet, 0);

static unsigned int *row_gpios;
static unsigned int *col_gpios;

#ifdef CONFIG_ARCH_OMAP2
static void set_col_gpio_val(struct omap_kp *omap_kp, u8 value)
{
	int col;

	for (col = 0; col < omap_kp->cols; col++)
		gpio_set_value(col_gpios[col], value & (1 << col));
}

static u8 get_row_gpio_val(struct omap_kp *omap_kp)
{
	int row;
	u8 value = 0;

	for (row = 0; row < omap_kp->rows; row++) {
		if (gpio_get_value(row_gpios[row]))
			value |= (1 << row);
	}
	return value;
}
#else
#define		set_col_gpio_val(x, y)	do {} while (0)
#define		get_row_gpio_val(x)	0
#endif

static irqreturn_t omap_kp_interrupt(int irq, void *dev_id)
{
	struct omap_kp *omap_kp = dev_id;

	/* disable keyboard interrupt and schedule for handling */
	if (cpu_is_omap24xx()) {
		int i;

		for (i = 0; i < omap_kp->rows; i++) {
			int gpio_irq = gpio_to_irq(row_gpios[i]);
			/*
			 * The interrupt which we're currently handling should
			 * be disabled _nosync() to avoid deadlocks waiting
			 * for this handler to complete.  All others should
			 * be disabled the regular way for SMP safety.
			 */
			if (gpio_irq == irq)
				disable_irq_nosync(gpio_irq);
			else
				disable_irq(gpio_irq);
		}
	} else
		/* disable keyboard interrupt and schedule for handling */
		omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);

	tasklet_schedule(&kp_tasklet);

	return IRQ_HANDLED;
}

static void omap_kp_timer(unsigned long data)
{
	tasklet_schedule(&kp_tasklet);
}

static void omap_kp_scan_keypad(struct omap_kp *omap_kp, unsigned char *state)
{
	int col = 0;

	/* read the keypad status */
	if (cpu_is_omap24xx()) {
		/* read the keypad status */
		for (col = 0; col < omap_kp->cols; col++) {
			set_col_gpio_val(omap_kp, ~(1 << col));
			state[col] = ~(get_row_gpio_val(omap_kp)) & 0xff;
		}
		set_col_gpio_val(omap_kp, 0);

	} else {
		/* disable keyboard interrupt and schedule for handling */
		omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);

		/* read the keypad status */
		omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
		for (col = 0; col < omap_kp->cols; col++) {
			omap_writew(~(1 << col) & 0xff,
				    OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);

			udelay(omap_kp->delay);

			state[col] = ~omap_readw(OMAP1_MPUIO_BASE +
						 OMAP_MPUIO_KBR_LATCH) & 0xff;
		}
		omap_writew(0x00, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
		udelay(2);
	}
}

static void omap_kp_tasklet(unsigned long data)
{
	struct omap_kp *omap_kp_data = (struct omap_kp *) data;
	unsigned short *keycodes = omap_kp_data->input->keycode;
	unsigned int row_shift = get_count_order(omap_kp_data->cols);
	unsigned char new_state[8], changed, key_down = 0;
	int col, row;
	int spurious = 0;

	/* check for any changes */
	omap_kp_scan_keypad(omap_kp_data, new_state);

	/* check for changes and print those */
	for (col = 0; col < omap_kp_data->cols; col++) {
		changed = new_state[col] ^ keypad_state[col];
		key_down |= new_state[col];
		if (changed == 0)
			continue;

		for (row = 0; row < omap_kp_data->rows; row++) {
			int key;
			if (!(changed & (1 << row)))
				continue;
#ifdef NEW_BOARD_LEARNING_MODE
			printk(KERN_INFO "omap-keypad: key %d-%d %s\n", col,
			       row, (new_state[col] & (1 << row)) ?
			       "pressed" : "released");
#else
			key = keycodes[MATRIX_SCAN_CODE(row, col, row_shift)];
			if (key < 0) {
				printk(KERN_WARNING
				      "omap-keypad: Spurious key event %d-%d\n",
				       col, row);
				/* We scan again after a couple of seconds */
				spurious = 1;
				continue;
			}

			if (!(kp_cur_group == (key & GROUP_MASK) ||
			      kp_cur_group == -1))
				continue;

			kp_cur_group = key & GROUP_MASK;
			input_report_key(omap_kp_data->input, key & ~GROUP_MASK,
					 new_state[col] & (1 << row));
#endif
		}
	}
	input_sync(omap_kp_data->input);
	memcpy(keypad_state, new_state, sizeof(keypad_state));

	if (key_down) {
                int delay = HZ / 20;
		/* some key is pressed - keep irq disabled and use timer
		 * to poll the keypad */
		if (spurious)
			delay = 2 * HZ;
		mod_timer(&omap_kp_data->timer, jiffies + delay);
	} else {
		/* enable interrupts */
		if (cpu_is_omap24xx()) {
			int i;
			for (i = 0; i < omap_kp_data->rows; i++)
				enable_irq(gpio_to_irq(row_gpios[i]));
		} else {
			omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
			kp_cur_group = -1;
		}
	}
}

static ssize_t omap_kp_enable_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%u\n", kp_enable);
}

static ssize_t omap_kp_enable_store(struct device *dev, struct device_attribute *attr,
				    const char *buf, size_t count)
{
	int state;

	if (sscanf(buf, "%u", &state) != 1)
		return -EINVAL;

	if ((state != 1) && (state != 0))
		return -EINVAL;

	mutex_lock(&kp_enable_mutex);
	if (state != kp_enable) {
		if (state)
			enable_irq(INT_KEYBOARD);
		else
			disable_irq(INT_KEYBOARD);
		kp_enable = state;
	}
	mutex_unlock(&kp_enable_mutex);

	return strnlen(buf, count);
}

static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, omap_kp_enable_show, omap_kp_enable_store);

#ifdef CONFIG_PM
static int omap_kp_suspend(struct platform_device *dev, pm_message_t state)
{
	/* Nothing yet */

	return 0;
}

static int omap_kp_resume(struct platform_device *dev)
{
	/* Nothing yet */

	return 0;
}
#else
#define omap_kp_suspend	NULL
#define omap_kp_resume	NULL
#endif

static int __devinit omap_kp_probe(struct platform_device *pdev)
{
	struct omap_kp *omap_kp;
	struct input_dev *input_dev;
	struct omap_kp_platform_data *pdata =  pdev->dev.platform_data;
	int i, col_idx, row_idx, irq_idx, ret;
	unsigned int row_shift, keycodemax;

	if (!pdata->rows || !pdata->cols || !pdata->keymap_data) {
		printk(KERN_ERR "No rows, cols or keymap_data from pdata\n");
		return -EINVAL;
	}

	row_shift = get_count_order(pdata->cols);
	keycodemax = pdata->rows << row_shift;

	omap_kp = kzalloc(sizeof(struct omap_kp) +
			keycodemax * sizeof(unsigned short), GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!omap_kp || !input_dev) {
		kfree(omap_kp);
		input_free_device(input_dev);
		return -ENOMEM;
	}

	platform_set_drvdata(pdev, omap_kp);

	omap_kp->input = input_dev;

	/* Disable the interrupt for the MPUIO keyboard */
	if (!cpu_is_omap24xx())
		omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);

	if (pdata->delay)
		omap_kp->delay = pdata->delay;

	if (pdata->row_gpios && pdata->col_gpios) {
		row_gpios = pdata->row_gpios;
		col_gpios = pdata->col_gpios;
	}

	omap_kp->rows = pdata->rows;
	omap_kp->cols = pdata->cols;

	if (cpu_is_omap24xx()) {
		/* Cols: outputs */
		for (col_idx = 0; col_idx < omap_kp->cols; col_idx++) {
			if (gpio_request(col_gpios[col_idx], "omap_kp_col") < 0) {
				printk(KERN_ERR "Failed to request"
				       "GPIO%d for keypad\n",
				       col_gpios[col_idx]);
				goto err1;
			}
			gpio_direction_output(col_gpios[col_idx], 0);
		}
		/* Rows: inputs */
		for (row_idx = 0; row_idx < omap_kp->rows; row_idx++) {
			if (gpio_request(row_gpios[row_idx], "omap_kp_row") < 0) {
				printk(KERN_ERR "Failed to request"
				       "GPIO%d for keypad\n",
				       row_gpios[row_idx]);
				goto err2;
			}
			gpio_direction_input(row_gpios[row_idx]);
		}
	} else {
		col_idx = 0;
		row_idx = 0;
	}

	setup_timer(&omap_kp->timer, omap_kp_timer, (unsigned long)omap_kp);

	/* get the irq and init timer*/
	tasklet_enable(&kp_tasklet);
	kp_tasklet.data = (unsigned long) omap_kp;

	ret = device_create_file(&pdev->dev, &dev_attr_enable);
	if (ret < 0)
		goto err2;

	/* setup input device */
	input_dev->name = "omap-keypad";
	input_dev->phys = "omap-keypad/input0";
	input_dev->dev.parent = &pdev->dev;

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

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

	ret = matrix_keypad_build_keymap(pdata->keymap_data, NULL,
					 pdata->rows, pdata->cols,
					 omap_kp->keymap, input_dev);
	if (ret < 0)
		goto err3;

	ret = input_register_device(omap_kp->input);
	if (ret < 0) {
		printk(KERN_ERR "Unable to register omap-keypad input device\n");
		goto err3;
	}

	if (pdata->dbounce)
		omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_GPIO_DEBOUNCING);

	/* scan current status and enable interrupt */
	omap_kp_scan_keypad(omap_kp, keypad_state);
	if (!cpu_is_omap24xx()) {
		omap_kp->irq = platform_get_irq(pdev, 0);
		if (omap_kp->irq >= 0) {
			if (request_irq(omap_kp->irq, omap_kp_interrupt, 0,
					"omap-keypad", omap_kp) < 0)
				goto err4;
		}
		omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
	} else {
		for (irq_idx = 0; irq_idx < omap_kp->rows; irq_idx++) {
			if (request_irq(gpio_to_irq(row_gpios[irq_idx]),
					omap_kp_interrupt,
					IRQF_TRIGGER_FALLING,
					"omap-keypad", omap_kp) < 0)
				goto err5;
		}
	}
	return 0;
err5:
	for (i = irq_idx - 1; i >=0; i--)
		free_irq(row_gpios[i], omap_kp);
err4:
	input_unregister_device(omap_kp->input);
	input_dev = NULL;
err3:
	device_remove_file(&pdev->dev, &dev_attr_enable);
err2:
	for (i = row_idx - 1; i >=0; i--)
		gpio_free(row_gpios[i]);
err1:
	for (i = col_idx - 1; i >=0; i--)
		gpio_free(col_gpios[i]);

	kfree(omap_kp);
	input_free_device(input_dev);

	return -EINVAL;
}

static int __devexit omap_kp_remove(struct platform_device *pdev)
{
	struct omap_kp *omap_kp = platform_get_drvdata(pdev);

	/* disable keypad interrupt handling */
	tasklet_disable(&kp_tasklet);
	if (cpu_is_omap24xx()) {
		int i;
		for (i = 0; i < omap_kp->cols; i++)
			gpio_free(col_gpios[i]);
		for (i = 0; i < omap_kp->rows; i++) {
			gpio_free(row_gpios[i]);
			free_irq(gpio_to_irq(row_gpios[i]), omap_kp);
		}
	} else {
		omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
		free_irq(omap_kp->irq, omap_kp);
	}

	del_timer_sync(&omap_kp->timer);
	tasklet_kill(&kp_tasklet);

	/* unregister everything */
	input_unregister_device(omap_kp->input);

	kfree(omap_kp);

	return 0;
}

static struct platform_driver omap_kp_driver = {
	.probe		= omap_kp_probe,
	.remove		= __devexit_p(omap_kp_remove),
	.suspend	= omap_kp_suspend,
	.resume		= omap_kp_resume,
	.driver		= {
		.name	= "omap-keypad",
		.owner	= THIS_MODULE,
	},
};
module_platform_driver(omap_kp_driver);

MODULE_AUTHOR("Timo Teräs");
MODULE_DESCRIPTION("OMAP Keypad Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:omap-keypad");
Commit	Line	Data
ad4e09b1 KS	1	/*
	2	* linux/drivers/input/keyboard/omap-keypad.c
	3	*
	4	* OMAP Keypad Driver
	5	*
	6	* Copyright (C) 2003 Nokia Corporation
96de0e25	7	* Written by Timo Teräs <ext-timo.teras@nokia.com>
ad4e09b1 KS	8	*
	9	* Added support for H2 & H3 Keypad
	10	* Copyright (C) 2004 Texas Instruments
	11	*
	12	* This program is free software; you can redistribute it and/or modify
	13	* it under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; either version 2 of the License, or
	15	* (at your option) any later version.
	16	*
	17	* This program is distributed in the hope that it will be useful,
	18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	* GNU General Public License for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License
	23	* along with this program; if not, write to the Free Software
	24	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	25	*/
	26
	27	#include <linux/module.h>
	28	#include <linux/init.h>
	29	#include <linux/interrupt.h>
	30	#include <linux/types.h>
	31	#include <linux/input.h>
	32	#include <linux/kernel.h>
	33	#include <linux/delay.h>
	34	#include <linux/platform_device.h>
	35	#include <linux/mutex.h>
	36	#include <linux/errno.h>
5a0e3ad6	37	#include <linux/slab.h>
1bc857f7	38	#include <asm/gpio.h>
ce491cf8 TL	39	#include <plat/keypad.h>
ce491cf8 TL	40	#include <plat/menelaus.h>
ad4e09b1	41	#include <asm/irq.h>
a09e64fb	42	#include <mach/hardware.h>
ad4e09b1	43	#include <asm/io.h>
ce491cf8	44	#include <plat/mux.h>
ad4e09b1 KS	45
	46	#undef NEW_BOARD_LEARNING_MODE
	47
	48	static void omap_kp_tasklet(unsigned long);
	49	static void omap_kp_timer(unsigned long);
	50
	51	static unsigned char keypad_state[8];
	52	static DEFINE_MUTEX(kp_enable_mutex);
	53	static int kp_enable = 1;
	54	static int kp_cur_group = -1;
	55
	56	struct omap_kp {
	57	struct input_dev *input;
	58	struct timer_list timer;
	59	int irq;
	60	unsigned int rows;
	61	unsigned int cols;
	62	unsigned long delay;
	63	unsigned int debounce;
1932811f	64	unsigned short keymap[];
ad4e09b1 KS	65	};
ad4e09b1 KS	66
7c8ad982	67	static DECLARE_TASKLET_DISABLED(kp_tasklet, omap_kp_tasklet, 0);
ad4e09b1	68
ad4e09b1 KS	69	static unsigned int *row_gpios;
	70	static unsigned int *col_gpios;
	71
	72	#ifdef CONFIG_ARCH_OMAP2
	73	static void set_col_gpio_val(struct omap_kp *omap_kp, u8 value)
	74	{
	75	int col;
93a22f8b DB	76
	77	for (col = 0; col < omap_kp->cols; col++)
	78	gpio_set_value(col_gpios[col], value & (1 << col));
ad4e09b1 KS	79	}
	80
	81	static u8 get_row_gpio_val(struct omap_kp *omap_kp)
	82	{
	83	int row;
	84	u8 value = 0;
	85
	86	for (row = 0; row < omap_kp->rows; row++) {
93a22f8b	87	if (gpio_get_value(row_gpios[row]))
ad4e09b1 KS	88	value \|= (1 << row);
	89	}
	90	return value;
	91	}
	92	#else
	93	#define set_col_gpio_val(x, y) do {} while (0)
	94	#define get_row_gpio_val(x) 0
	95	#endif
	96
7d12e780	97	static irqreturn_t omap_kp_interrupt(int irq, void *dev_id)
ad4e09b1 KS	98	{
	99	struct omap_kp *omap_kp = dev_id;
	100
	101	/* disable keyboard interrupt and schedule for handling */
	102	if (cpu_is_omap24xx()) {
	103	int i;
0f751719 BN	104
	105	for (i = 0; i < omap_kp->rows; i++) {
	106	int gpio_irq = gpio_to_irq(row_gpios[i]);
	107	/*
	108	* The interrupt which we're currently handling should
	109	* be disabled _nosync() to avoid deadlocks waiting
	110	* for this handler to complete. All others should
	111	* be disabled the regular way for SMP safety.
	112	*/
	113	if (gpio_irq == irq)
	114	disable_irq_nosync(gpio_irq);
	115	else
	116	disable_irq(gpio_irq);
	117	}
ad4e09b1 KS	118	} else
ad4e09b1 KS	119	/* disable keyboard interrupt and schedule for handling */
6175556f	120	omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
ad4e09b1 KS	121
	122	tasklet_schedule(&kp_tasklet);
	123
	124	return IRQ_HANDLED;
	125	}
	126
	127	static void omap_kp_timer(unsigned long data)
	128	{
	129	tasklet_schedule(&kp_tasklet);
	130	}
	131
	132	static void omap_kp_scan_keypad(struct omap_kp omap_kp, unsigned char state)
	133	{
	134	int col = 0;
	135
	136	/* read the keypad status */
	137	if (cpu_is_omap24xx()) {
ad4e09b1 KS	138	/* read the keypad status */
	139	for (col = 0; col < omap_kp->cols; col++) {
	140	set_col_gpio_val(omap_kp, ~(1 << col));
dde4ac07	141	state[col] = ~(get_row_gpio_val(omap_kp)) & 0xff;
ad4e09b1 KS	142	}
	143	set_col_gpio_val(omap_kp, 0);
	144
	145	} else {
	146	/* disable keyboard interrupt and schedule for handling */
6175556f	147	omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
ad4e09b1 KS	148
ad4e09b1 KS	149	/* read the keypad status */
6175556f	150	omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
ad4e09b1 KS	151	for (col = 0; col < omap_kp->cols; col++) {
ad4e09b1 KS	152	omap_writew(~(1 << col) & 0xff,
6175556f	153	OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
ad4e09b1 KS	154
	155	udelay(omap_kp->delay);
	156
6175556f	157	state[col] = ~omap_readw(OMAP1_MPUIO_BASE +
ad4e09b1 KS	158	OMAP_MPUIO_KBR_LATCH) & 0xff;
ad4e09b1 KS	159	}
6175556f	160	omap_writew(0x00, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
ad4e09b1 KS	161	udelay(2);
	162	}
	163	}
	164
ad4e09b1 KS	165	static void omap_kp_tasklet(unsigned long data)
	166	{
	167	struct omap_kp omap_kp_data = (struct omap_kp ) data;
da1f026b JK	168	unsigned short *keycodes = omap_kp_data->input->keycode;
da1f026b JK	169	unsigned int row_shift = get_count_order(omap_kp_data->cols);
ad4e09b1 KS	170	unsigned char new_state[8], changed, key_down = 0;
	171	int col, row;
	172	int spurious = 0;
	173
	174	/* check for any changes */
	175	omap_kp_scan_keypad(omap_kp_data, new_state);
	176
	177	/* check for changes and print those */
	178	for (col = 0; col < omap_kp_data->cols; col++) {
	179	changed = new_state[col] ^ keypad_state[col];
	180	key_down \|= new_state[col];
	181	if (changed == 0)
	182	continue;
	183
	184	for (row = 0; row < omap_kp_data->rows; row++) {
	185	int key;
	186	if (!(changed & (1 << row)))
	187	continue;
	188	#ifdef NEW_BOARD_LEARNING_MODE
	189	printk(KERN_INFO "omap-keypad: key %d-%d %s\n", col,
	190	row, (new_state[col] & (1 << row)) ?
	191	"pressed" : "released");
	192	#else
da1f026b	193	key = keycodes[MATRIX_SCAN_CODE(row, col, row_shift)];
ad4e09b1 KS	194	if (key < 0) {
	195	printk(KERN_WARNING
	196	"omap-keypad: Spurious key event %d-%d\n",
	197	col, row);
	198	/* We scan again after a couple of seconds */
	199	spurious = 1;
	200	continue;
	201	}
	202
	203	if (!(kp_cur_group == (key & GROUP_MASK) \|\|
	204	kp_cur_group == -1))
	205	continue;
	206
	207	kp_cur_group = key & GROUP_MASK;
	208	input_report_key(omap_kp_data->input, key & ~GROUP_MASK,
	209	new_state[col] & (1 << row));
	210	#endif
	211	}
	212	}
b27af563	213	input_sync(omap_kp_data->input);
ad4e09b1 KS	214	memcpy(keypad_state, new_state, sizeof(keypad_state));
	215
	216	if (key_down) {
	217	int delay = HZ / 20;
	218	/* some key is pressed - keep irq disabled and use timer
	219	* to poll the keypad */
	220	if (spurious)
	221	delay = 2 * HZ;
	222	mod_timer(&omap_kp_data->timer, jiffies + delay);
	223	} else {
	224	/* enable interrupts */
	225	if (cpu_is_omap24xx()) {
	226	int i;
	227	for (i = 0; i < omap_kp_data->rows; i++)
15f74b03	228	enable_irq(gpio_to_irq(row_gpios[i]));
ad4e09b1	229	} else {
6175556f	230	omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
ad4e09b1 KS	231	kp_cur_group = -1;
ad4e09b1 KS	232	}
9360353f	233	}
ad4e09b1 KS	234	}
	235
	236	static ssize_t omap_kp_enable_show(struct device *dev,
	237	struct device_attribute attr, char buf)
	238	{
	239	return sprintf(buf, "%u\n", kp_enable);
	240	}
	241
	242	static ssize_t omap_kp_enable_store(struct device dev, struct device_attribute attr,
	243	const char *buf, size_t count)
	244	{
	245	int state;
	246
	247	if (sscanf(buf, "%u", &state) != 1)
	248	return -EINVAL;
	249
	250	if ((state != 1) && (state != 0))
	251	return -EINVAL;
	252
	253	mutex_lock(&kp_enable_mutex);
	254	if (state != kp_enable) {
	255	if (state)
	256	enable_irq(INT_KEYBOARD);
	257	else
	258	disable_irq(INT_KEYBOARD);
	259	kp_enable = state;
	260	}
	261	mutex_unlock(&kp_enable_mutex);
	262
	263	return strnlen(buf, count);
	264	}
	265
	266	static DEVICE_ATTR(enable, S_IRUGO \| S_IWUSR, omap_kp_enable_show, omap_kp_enable_store);
	267
	268	#ifdef CONFIG_PM
	269	static int omap_kp_suspend(struct platform_device *dev, pm_message_t state)
	270	{
	271	/* Nothing yet */
	272
	273	return 0;
	274	}
	275
	276	static int omap_kp_resume(struct platform_device *dev)
	277	{
	278	/* Nothing yet */
	279
	280	return 0;
	281	}
	282	#else
	283	#define omap_kp_suspend NULL
	284	#define omap_kp_resume NULL
	285	#endif
	286
d63dab00	287	static int __devinit omap_kp_probe(struct platform_device *pdev)
ad4e09b1 KS	288	{
	289	struct omap_kp *omap_kp;
	290	struct input_dev *input_dev;
	291	struct omap_kp_platform_data *pdata = pdev->dev.platform_data;
	292	int i, col_idx, row_idx, irq_idx, ret;
da1f026b	293	unsigned int row_shift, keycodemax;
ad4e09b1	294
da1f026b JK	295	if (!pdata->rows \|\| !pdata->cols \|\| !pdata->keymap_data) {
da1f026b JK	296	printk(KERN_ERR "No rows, cols or keymap_data from pdata\n");
ad4e09b1 KS	297	return -EINVAL;
	298	}
	299
da1f026b JK	300	row_shift = get_count_order(pdata->cols);
	301	keycodemax = pdata->rows << row_shift;
	302
	303	omap_kp = kzalloc(sizeof(struct omap_kp) +
	304	keycodemax * sizeof(unsigned short), GFP_KERNEL);
ad4e09b1 KS	305	input_dev = input_allocate_device();
	306	if (!omap_kp \|\| !input_dev) {
	307	kfree(omap_kp);
	308	input_free_device(input_dev);
	309	return -ENOMEM;
	310	}
	311
	312	platform_set_drvdata(pdev, omap_kp);
	313
	314	omap_kp->input = input_dev;
	315
	316	/* Disable the interrupt for the MPUIO keyboard */
	317	if (!cpu_is_omap24xx())
6175556f	318	omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
ad4e09b1	319
ad4e09b1 KS	320	if (pdata->delay)
	321	omap_kp->delay = pdata->delay;
	322
	323	if (pdata->row_gpios && pdata->col_gpios) {
	324	row_gpios = pdata->row_gpios;
	325	col_gpios = pdata->col_gpios;
	326	}
	327
	328	omap_kp->rows = pdata->rows;
	329	omap_kp->cols = pdata->cols;
	330
	331	if (cpu_is_omap24xx()) {
	332	/* Cols: outputs */
	333	for (col_idx = 0; col_idx < omap_kp->cols; col_idx++) {
93a22f8b	334	if (gpio_request(col_gpios[col_idx], "omap_kp_col") < 0) {
ad4e09b1 KS	335	printk(KERN_ERR "Failed to request"
	336	"GPIO%d for keypad\n",
	337	col_gpios[col_idx]);
	338	goto err1;
	339	}
93a22f8b	340	gpio_direction_output(col_gpios[col_idx], 0);
ad4e09b1 KS	341	}
	342	/* Rows: inputs */
	343	for (row_idx = 0; row_idx < omap_kp->rows; row_idx++) {
93a22f8b	344	if (gpio_request(row_gpios[row_idx], "omap_kp_row") < 0) {
ad4e09b1 KS	345	printk(KERN_ERR "Failed to request"
	346	"GPIO%d for keypad\n",
	347	row_gpios[row_idx]);
	348	goto err2;
	349	}
93a22f8b	350	gpio_direction_input(row_gpios[row_idx]);
ad4e09b1	351	}
da3e4c88 DB	352	} else {
	353	col_idx = 0;
	354	row_idx = 0;
ad4e09b1 KS	355	}
	356
	357	setup_timer(&omap_kp->timer, omap_kp_timer, (unsigned long)omap_kp);
	358
	359	/* get the irq and init timer*/
	360	tasklet_enable(&kp_tasklet);
	361	kp_tasklet.data = (unsigned long) omap_kp;
	362
	363	ret = device_create_file(&pdev->dev, &dev_attr_enable);
	364	if (ret < 0)
	365	goto err2;
	366
	367	/* setup input device */
ad4e09b1 KS	368	input_dev->name = "omap-keypad";
ad4e09b1 KS	369	input_dev->phys = "omap-keypad/input0";
469ba4df	370	input_dev->dev.parent = &pdev->dev;
ad4e09b1 KS	371
	372	input_dev->id.bustype = BUS_HOST;
	373	input_dev->id.vendor = 0x0001;
	374	input_dev->id.product = 0x0001;
	375	input_dev->id.version = 0x0100;
	376
1932811f DT	377	if (pdata->rep)
	378	__set_bit(EV_REP, input_dev->evbit);
	379
	380	ret = matrix_keypad_build_keymap(pdata->keymap_data, NULL,
	381	pdata->rows, pdata->cols,
	382	omap_kp->keymap, input_dev);
	383	if (ret < 0)
	384	goto err3;
	385
ad4e09b1 KS	386	ret = input_register_device(omap_kp->input);
	387	if (ret < 0) {
	388	printk(KERN_ERR "Unable to register omap-keypad input device\n");
	389	goto err3;
	390	}
	391
	392	if (pdata->dbounce)
6175556f	393	omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_GPIO_DEBOUNCING);
ad4e09b1 KS	394
	395	/* scan current status and enable interrupt */
	396	omap_kp_scan_keypad(omap_kp, keypad_state);
	397	if (!cpu_is_omap24xx()) {
	398	omap_kp->irq = platform_get_irq(pdev, 0);
	399	if (omap_kp->irq >= 0) {
	400	if (request_irq(omap_kp->irq, omap_kp_interrupt, 0,
	401	"omap-keypad", omap_kp) < 0)
	402	goto err4;
	403	}
6175556f	404	omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
ad4e09b1 KS	405	} else {
ad4e09b1 KS	406	for (irq_idx = 0; irq_idx < omap_kp->rows; irq_idx++) {
15f74b03	407	if (request_irq(gpio_to_irq(row_gpios[irq_idx]),
9360353f	408	omap_kp_interrupt,
ad4e09b1	409	IRQF_TRIGGER_FALLING,
9360353f	410	"omap-keypad", omap_kp) < 0)
ad4e09b1 KS	411	goto err5;
	412	}
	413	}
	414	return 0;
	415	err5:
9360353f	416	for (i = irq_idx - 1; i >=0; i--)
60c8ba64	417	free_irq(row_gpios[i], omap_kp);
ad4e09b1 KS	418	err4:
	419	input_unregister_device(omap_kp->input);
	420	input_dev = NULL;
	421	err3:
	422	device_remove_file(&pdev->dev, &dev_attr_enable);
	423	err2:
da3e4c88	424	for (i = row_idx - 1; i >=0; i--)
93a22f8b	425	gpio_free(row_gpios[i]);
ad4e09b1	426	err1:
da3e4c88	427	for (i = col_idx - 1; i >=0; i--)
93a22f8b	428	gpio_free(col_gpios[i]);
ad4e09b1 KS	429
	430	kfree(omap_kp);
	431	input_free_device(input_dev);
	432
	433	return -EINVAL;
	434	}
	435
d63dab00	436	static int __devexit omap_kp_remove(struct platform_device *pdev)
ad4e09b1 KS	437	{
	438	struct omap_kp *omap_kp = platform_get_drvdata(pdev);
	439
	440	/* disable keypad interrupt handling */
	441	tasklet_disable(&kp_tasklet);
	442	if (cpu_is_omap24xx()) {
	443	int i;
	444	for (i = 0; i < omap_kp->cols; i++)
93a22f8b	445	gpio_free(col_gpios[i]);
ad4e09b1	446	for (i = 0; i < omap_kp->rows; i++) {
93a22f8b	447	gpio_free(row_gpios[i]);
60c8ba64	448	free_irq(gpio_to_irq(row_gpios[i]), omap_kp);
ad4e09b1 KS	449	}
ad4e09b1 KS	450	} else {
6175556f	451	omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
60c8ba64	452	free_irq(omap_kp->irq, omap_kp);
ad4e09b1 KS	453	}
	454
	455	del_timer_sync(&omap_kp->timer);
	456	tasklet_kill(&kp_tasklet);
	457
	458	/* unregister everything */
	459	input_unregister_device(omap_kp->input);
	460
	461	kfree(omap_kp);
	462
	463	return 0;
	464	}
	465
	466	static struct platform_driver omap_kp_driver = {
	467	.probe = omap_kp_probe,
d63dab00	468	.remove = __devexit_p(omap_kp_remove),
ad4e09b1 KS	469	.suspend = omap_kp_suspend,
	470	.resume = omap_kp_resume,
	471	.driver = {
	472	.name = "omap-keypad",
d7b5247b	473	.owner = THIS_MODULE,
ad4e09b1 KS	474	},
ad4e09b1 KS	475	};
5146c84f	476	module_platform_driver(omap_kp_driver);
ad4e09b1	477
96de0e25	478	MODULE_AUTHOR("Timo Teräs");
ad4e09b1 KS	479	MODULE_DESCRIPTION("OMAP Keypad Driver");
ad4e09b1 KS	480	MODULE_LICENSE("GPL");
d7b5247b	481	MODULE_ALIAS("platform:omap-keypad");