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

/*
 *  Keyboard driver for Sharp Tosa models (SL-6000x)
 *
 *  Copyright (c) 2005 Dirk Opfer
 *  Copyright (c) 2007 Dmitry Baryshkov
 *
 *  Based on xtkbd.c/locomkbd.c/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/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/slab.h>

#include <mach/gpio.h>
#include <mach/tosa.h>

#define KB_ROWMASK(r)		(1 << (r))
#define SCANCODE(r, c)		(((r)<<4) + (c) + 1)
#define NR_SCANCODES		SCANCODE(TOSA_KEY_SENSE_NUM - 1, TOSA_KEY_STROBE_NUM - 1) + 1

#define SCAN_INTERVAL		(HZ/10)

#define KB_DISCHARGE_DELAY	10
#define KB_ACTIVATE_DELAY	10

static unsigned short tosakbd_keycode[NR_SCANCODES] = {
0,
0, KEY_W, 0, 0, 0, KEY_K, KEY_BACKSPACE, KEY_P,
0, 0, 0, 0, 0, 0, 0, 0,
KEY_Q, KEY_E, KEY_T, KEY_Y, 0, KEY_O, KEY_I, KEY_COMMA,
0, 0, 0, 0, 0, 0, 0, 0,
KEY_A, KEY_D, KEY_G, KEY_U, 0, KEY_L, KEY_ENTER, KEY_DOT,
0, 0, 0, 0, 0, 0, 0, 0,
KEY_Z, KEY_C, KEY_V, KEY_J, TOSA_KEY_ADDRESSBOOK, TOSA_KEY_CANCEL, TOSA_KEY_CENTER, TOSA_KEY_OK,
KEY_LEFTSHIFT, 0, 0, 0, 0, 0, 0, 0,
KEY_S, KEY_R, KEY_B, KEY_N, TOSA_KEY_CALENDAR, TOSA_KEY_HOMEPAGE, KEY_LEFTCTRL, TOSA_KEY_LIGHT,
0, KEY_RIGHTSHIFT, 0, 0, 0, 0, 0, 0,
KEY_TAB, KEY_SLASH, KEY_H, KEY_M, TOSA_KEY_MENU, 0, KEY_UP, 0,
0, 0, TOSA_KEY_FN, 0, 0, 0, 0, 0,
KEY_X, KEY_F, KEY_SPACE, KEY_APOSTROPHE, TOSA_KEY_MAIL, KEY_LEFT, KEY_DOWN, KEY_RIGHT,
0, 0, 0,
};

struct tosakbd {
	unsigned short keycode[ARRAY_SIZE(tosakbd_keycode)];
	struct input_dev *input;
	bool suspended;
	spinlock_t lock; /* protect kbd scanning */
	struct timer_list timer;
};


/* Helper functions for reading the keyboard matrix
 * Note: We should really be using the generic gpio functions to alter
 *       GPDR but it requires a function call per GPIO bit which is
 *       excessive when we need to access 12 bits at once, multiple times.
 * These functions must be called within local_irq_save()/local_irq_restore()
 * or similar.
 */
#define GET_ROWS_STATUS(c)	((GPLR2 & TOSA_GPIO_ALL_SENSE_BIT) >> TOSA_GPIO_ALL_SENSE_RSHIFT)

static inline void tosakbd_discharge_all(void)
{
	/* STROBE All HiZ */
	GPCR1  = TOSA_GPIO_HIGH_STROBE_BIT;
	GPDR1 &= ~TOSA_GPIO_HIGH_STROBE_BIT;
	GPCR2  = TOSA_GPIO_LOW_STROBE_BIT;
	GPDR2 &= ~TOSA_GPIO_LOW_STROBE_BIT;
}

static inline void tosakbd_activate_all(void)
{
	/* STROBE ALL -> High */
	GPSR1  = TOSA_GPIO_HIGH_STROBE_BIT;
	GPDR1 |= TOSA_GPIO_HIGH_STROBE_BIT;
	GPSR2  = TOSA_GPIO_LOW_STROBE_BIT;
	GPDR2 |= TOSA_GPIO_LOW_STROBE_BIT;

	udelay(KB_DISCHARGE_DELAY);

	/* STATE CLEAR */
	GEDR2 |= TOSA_GPIO_ALL_SENSE_BIT;
}

static inline void tosakbd_activate_col(int col)
{
	if (col <= 5) {
		/* STROBE col -> High, not col -> HiZ */
		GPSR1 = TOSA_GPIO_STROBE_BIT(col);
		GPDR1 = (GPDR1 & ~TOSA_GPIO_HIGH_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
	} else {
		/* STROBE col -> High, not col -> HiZ */
		GPSR2 = TOSA_GPIO_STROBE_BIT(col);
		GPDR2 = (GPDR2 & ~TOSA_GPIO_LOW_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
	}
}

static inline void tosakbd_reset_col(int col)
{
	if (col <= 5) {
		/* STROBE col -> Low */
		GPCR1 = TOSA_GPIO_STROBE_BIT(col);
		/* STROBE col -> out, not col -> HiZ */
		GPDR1 = (GPDR1 & ~TOSA_GPIO_HIGH_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
	} else {
		/* STROBE col -> Low */
		GPCR2 = TOSA_GPIO_STROBE_BIT(col);
		/* STROBE col -> out, not col -> HiZ */
		GPDR2 = (GPDR2 & ~TOSA_GPIO_LOW_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
	}
}
/*
 * The tosa keyboard only generates interrupts when a key is pressed.
 * So when a key is pressed, we enable a timer.  This timer scans the
 * keyboard, and this is how we detect when the key is released.
 */

/* Scan the hardware keyboard and push any changes up through the input layer */
static void tosakbd_scankeyboard(struct platform_device *dev)
{
	struct tosakbd *tosakbd = platform_get_drvdata(dev);
	unsigned int row, col, rowd;
	unsigned long flags;
	unsigned int num_pressed = 0;

	spin_lock_irqsave(&tosakbd->lock, flags);

	if (tosakbd->suspended)
		goto out;

	for (col = 0; col < TOSA_KEY_STROBE_NUM; col++) {
		/*
		 * Discharge the output driver capacitatance
		 * in the keyboard matrix. (Yes it is significant..)
		 */
		tosakbd_discharge_all();
		udelay(KB_DISCHARGE_DELAY);

		tosakbd_activate_col(col);
		udelay(KB_ACTIVATE_DELAY);

		rowd = GET_ROWS_STATUS(col);

		for (row = 0; row < TOSA_KEY_SENSE_NUM; row++) {
			unsigned int scancode, pressed;
			scancode = SCANCODE(row, col);
			pressed = rowd & KB_ROWMASK(row);

			if (pressed && !tosakbd->keycode[scancode])
				dev_warn(&dev->dev,
						"unhandled scancode: 0x%02x\n",
						scancode);

			input_report_key(tosakbd->input,
					tosakbd->keycode[scancode],
					pressed);
			if (pressed)
				num_pressed++;
		}

		tosakbd_reset_col(col);
	}

	tosakbd_activate_all();

	input_sync(tosakbd->input);

	/* if any keys are pressed, enable the timer */
	if (num_pressed)
		mod_timer(&tosakbd->timer, jiffies + SCAN_INTERVAL);

 out:
	spin_unlock_irqrestore(&tosakbd->lock, flags);
}

/*
 * tosa keyboard interrupt handler.
 */
static irqreturn_t tosakbd_interrupt(int irq, void *__dev)
{
	struct platform_device *dev = __dev;
	struct tosakbd *tosakbd = platform_get_drvdata(dev);

	if (!timer_pending(&tosakbd->timer)) {
		/** wait chattering delay **/
		udelay(20);
		tosakbd_scankeyboard(dev);
	}

	return IRQ_HANDLED;
}

/*
 * tosa timer checking for released keys
 */
static void tosakbd_timer_callback(unsigned long __dev)
{
	struct platform_device *dev = (struct platform_device *)__dev;

	tosakbd_scankeyboard(dev);
}

#ifdef CONFIG_PM
static int tosakbd_suspend(struct platform_device *dev, pm_message_t state)
{
	struct tosakbd *tosakbd = platform_get_drvdata(dev);
	unsigned long flags;

	spin_lock_irqsave(&tosakbd->lock, flags);
	tosakbd->suspended = true;
	spin_unlock_irqrestore(&tosakbd->lock, flags);

	del_timer_sync(&tosakbd->timer);

	return 0;
}

static int tosakbd_resume(struct platform_device *dev)
{
	struct tosakbd *tosakbd = platform_get_drvdata(dev);

	tosakbd->suspended = false;
	tosakbd_scankeyboard(dev);

	return 0;
}
#else
#define tosakbd_suspend		NULL
#define tosakbd_resume		NULL
#endif

static int __devinit tosakbd_probe(struct platform_device *pdev) {

	int i;
	struct tosakbd *tosakbd;
	struct input_dev *input_dev;
	int error;

	tosakbd = kzalloc(sizeof(struct tosakbd), GFP_KERNEL);
	if (!tosakbd)
		return -ENOMEM;

	input_dev = input_allocate_device();
	if (!input_dev) {
		kfree(tosakbd);
		return -ENOMEM;
	}

	platform_set_drvdata(pdev, tosakbd);

	spin_lock_init(&tosakbd->lock);

	/* Init Keyboard rescan timer */
	init_timer(&tosakbd->timer);
	tosakbd->timer.function = tosakbd_timer_callback;
	tosakbd->timer.data = (unsigned long) pdev;

	tosakbd->input = input_dev;

	input_set_drvdata(input_dev, tosakbd);
	input_dev->name = "Tosa Keyboard";
	input_dev->phys = "tosakbd/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;

	input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
	input_dev->keycode = tosakbd->keycode;
	input_dev->keycodesize = sizeof(tosakbd->keycode[0]);
	input_dev->keycodemax = ARRAY_SIZE(tosakbd_keycode);

	memcpy(tosakbd->keycode, tosakbd_keycode, sizeof(tosakbd_keycode));

	for (i = 0; i < ARRAY_SIZE(tosakbd_keycode); i++)
		__set_bit(tosakbd->keycode[i], input_dev->keybit);
	__clear_bit(KEY_RESERVED, input_dev->keybit);

	/* Setup sense interrupts - RisingEdge Detect, sense lines as inputs */
	for (i = 0; i < TOSA_KEY_SENSE_NUM; i++) {
		int gpio = TOSA_GPIO_KEY_SENSE(i);
		int irq;
		error = gpio_request(gpio, "tosakbd");
		if (error < 0) {
			printk(KERN_ERR "tosakbd: failed to request GPIO %d, "
				" error %d\n", gpio, error);
			goto fail;
		}

		error = gpio_direction_input(TOSA_GPIO_KEY_SENSE(i));
		if (error < 0) {
			printk(KERN_ERR "tosakbd: failed to configure input"
				" direction for GPIO %d, error %d\n",
				gpio, error);
			gpio_free(gpio);
			goto fail;
		}

		irq = gpio_to_irq(gpio);
		if (irq < 0) {
			error = irq;
			printk(KERN_ERR "gpio-keys: Unable to get irq number"
				" for GPIO %d, error %d\n",
				gpio, error);
			gpio_free(gpio);
			goto fail;
		}

		error = request_irq(irq, tosakbd_interrupt,
					IRQF_DISABLED | IRQF_TRIGGER_RISING,
					"tosakbd", pdev);

		if (error) {
			printk("tosakbd: Can't get IRQ: %d: error %d!\n",
					irq, error);
			gpio_free(gpio);
			goto fail;
		}
	}

	/* Set Strobe lines as outputs - set high */
	for (i = 0; i < TOSA_KEY_STROBE_NUM; i++) {
		int gpio = TOSA_GPIO_KEY_STROBE(i);
		error = gpio_request(gpio, "tosakbd");
		if (error < 0) {
			printk(KERN_ERR "tosakbd: failed to request GPIO %d, "
				" error %d\n", gpio, error);
			goto fail2;
		}

		error = gpio_direction_output(gpio, 1);
		if (error < 0) {
			printk(KERN_ERR "tosakbd: failed to configure input"
				" direction for GPIO %d, error %d\n",
				gpio, error);
			gpio_free(gpio);
			goto fail2;
		}

	}

	error = input_register_device(input_dev);
	if (error) {
		printk(KERN_ERR "tosakbd: Unable to register input device, "
			"error: %d\n", error);
		goto fail2;
	}

	printk(KERN_INFO "input: Tosa Keyboard Registered\n");

	return 0;

fail2:
	while (--i >= 0)
		gpio_free(TOSA_GPIO_KEY_STROBE(i));

	i = TOSA_KEY_SENSE_NUM;
fail:
	while (--i >= 0) {
		free_irq(gpio_to_irq(TOSA_GPIO_KEY_SENSE(i)), pdev);
		gpio_free(TOSA_GPIO_KEY_SENSE(i));
	}

	platform_set_drvdata(pdev, NULL);
	input_free_device(input_dev);
	kfree(tosakbd);

	return error;
}

static int __devexit tosakbd_remove(struct platform_device *dev)
{
	int i;
	struct tosakbd *tosakbd = platform_get_drvdata(dev);

	for (i = 0; i < TOSA_KEY_STROBE_NUM; i++)
		gpio_free(TOSA_GPIO_KEY_STROBE(i));

	for (i = 0; i < TOSA_KEY_SENSE_NUM; i++) {
		free_irq(gpio_to_irq(TOSA_GPIO_KEY_SENSE(i)), dev);
		gpio_free(TOSA_GPIO_KEY_SENSE(i));
	}

	del_timer_sync(&tosakbd->timer);

	input_unregister_device(tosakbd->input);

	kfree(tosakbd);

	return 0;
}

static struct platform_driver tosakbd_driver = {
	.probe		= tosakbd_probe,
	.remove		= __devexit_p(tosakbd_remove),
	.suspend	= tosakbd_suspend,
	.resume		= tosakbd_resume,
	.driver		= {
		.name	= "tosa-keyboard",
		.owner	= THIS_MODULE,
	},
};

static int __devinit tosakbd_init(void)
{
	return platform_driver_register(&tosakbd_driver);
}

static void __exit tosakbd_exit(void)
{
	platform_driver_unregister(&tosakbd_driver);
}

module_init(tosakbd_init);
module_exit(tosakbd_exit);

MODULE_AUTHOR("Dirk Opfer <Dirk@Opfer-Online.de>");
MODULE_DESCRIPTION("Tosa Keyboard Driver");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:tosa-keyboard");
Commit	Line	Data
93e9012f DES	1	/*
	2	* Keyboard driver for Sharp Tosa models (SL-6000x)
	3	*
	4	* Copyright (c) 2005 Dirk Opfer
	5	* Copyright (c) 2007 Dmitry Baryshkov
	6	*
	7	* Based on xtkbd.c/locomkbd.c/corgikbd.c
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/module.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/input.h>
	19	#include <linux/delay.h>
	20	#include <linux/interrupt.h>
5a0e3ad6	21	#include <linux/slab.h>
93e9012f	22
a09e64fb RK	23	#include <mach/gpio.h>
a09e64fb RK	24	#include <mach/tosa.h>
93e9012f DES	25
	26	#define KB_ROWMASK(r) (1 << (r))
	27	#define SCANCODE(r, c) (((r)<<4) + (c) + 1)
	28	#define NR_SCANCODES SCANCODE(TOSA_KEY_SENSE_NUM - 1, TOSA_KEY_STROBE_NUM - 1) + 1
	29
	30	#define SCAN_INTERVAL (HZ/10)
	31
	32	#define KB_DISCHARGE_DELAY 10
	33	#define KB_ACTIVATE_DELAY 10
	34
8fbac18e	35	static unsigned short tosakbd_keycode[NR_SCANCODES] = {
93e9012f DES	36	0,
	37	0, KEY_W, 0, 0, 0, KEY_K, KEY_BACKSPACE, KEY_P,
	38	0, 0, 0, 0, 0, 0, 0, 0,
	39	KEY_Q, KEY_E, KEY_T, KEY_Y, 0, KEY_O, KEY_I, KEY_COMMA,
	40	0, 0, 0, 0, 0, 0, 0, 0,
	41	KEY_A, KEY_D, KEY_G, KEY_U, 0, KEY_L, KEY_ENTER, KEY_DOT,
	42	0, 0, 0, 0, 0, 0, 0, 0,
	43	KEY_Z, KEY_C, KEY_V, KEY_J, TOSA_KEY_ADDRESSBOOK, TOSA_KEY_CANCEL, TOSA_KEY_CENTER, TOSA_KEY_OK,
	44	KEY_LEFTSHIFT, 0, 0, 0, 0, 0, 0, 0,
	45	KEY_S, KEY_R, KEY_B, KEY_N, TOSA_KEY_CALENDAR, TOSA_KEY_HOMEPAGE, KEY_LEFTCTRL, TOSA_KEY_LIGHT,
	46	0, KEY_RIGHTSHIFT, 0, 0, 0, 0, 0, 0,
	47	KEY_TAB, KEY_SLASH, KEY_H, KEY_M, TOSA_KEY_MENU, 0, KEY_UP, 0,
	48	0, 0, TOSA_KEY_FN, 0, 0, 0, 0, 0,
	49	KEY_X, KEY_F, KEY_SPACE, KEY_APOSTROPHE, TOSA_KEY_MAIL, KEY_LEFT, KEY_DOWN, KEY_RIGHT,
	50	0, 0, 0,
	51	};
	52
	53	struct tosakbd {
8fbac18e	54	unsigned short keycode[ARRAY_SIZE(tosakbd_keycode)];
93e9012f	55	struct input_dev *input;
8fbac18e	56	bool suspended;
93e9012f DES	57	spinlock_t lock; /* protect kbd scanning */
	58	struct timer_list timer;
	59	};
	60
	61
	62	/* Helper functions for reading the keyboard matrix
73b610af RK	63	* Note: We should really be using the generic gpio functions to alter
	64	* GPDR but it requires a function call per GPIO bit which is
	65	* excessive when we need to access 12 bits at once, multiple times.
93e9012f DES	66	* These functions must be called within local_irq_save()/local_irq_restore()
	67	* or similar.
	68	*/
	69	#define GET_ROWS_STATUS(c) ((GPLR2 & TOSA_GPIO_ALL_SENSE_BIT) >> TOSA_GPIO_ALL_SENSE_RSHIFT)
	70
	71	static inline void tosakbd_discharge_all(void)
	72	{
	73	/* STROBE All HiZ */
	74	GPCR1 = TOSA_GPIO_HIGH_STROBE_BIT;
	75	GPDR1 &= ~TOSA_GPIO_HIGH_STROBE_BIT;
	76	GPCR2 = TOSA_GPIO_LOW_STROBE_BIT;
	77	GPDR2 &= ~TOSA_GPIO_LOW_STROBE_BIT;
	78	}
	79
	80	static inline void tosakbd_activate_all(void)
	81	{
	82	/* STROBE ALL -> High */
	83	GPSR1 = TOSA_GPIO_HIGH_STROBE_BIT;
	84	GPDR1 \|= TOSA_GPIO_HIGH_STROBE_BIT;
	85	GPSR2 = TOSA_GPIO_LOW_STROBE_BIT;
	86	GPDR2 \|= TOSA_GPIO_LOW_STROBE_BIT;
	87
	88	udelay(KB_DISCHARGE_DELAY);
	89
	90	/* STATE CLEAR */
	91	GEDR2 \|= TOSA_GPIO_ALL_SENSE_BIT;
	92	}
	93
	94	static inline void tosakbd_activate_col(int col)
	95	{
	96	if (col <= 5) {
	97	/* STROBE col -> High, not col -> HiZ */
	98	GPSR1 = TOSA_GPIO_STROBE_BIT(col);
	99	GPDR1 = (GPDR1 & ~TOSA_GPIO_HIGH_STROBE_BIT) \| TOSA_GPIO_STROBE_BIT(col);
	100	} else {
	101	/* STROBE col -> High, not col -> HiZ */
	102	GPSR2 = TOSA_GPIO_STROBE_BIT(col);
	103	GPDR2 = (GPDR2 & ~TOSA_GPIO_LOW_STROBE_BIT) \| TOSA_GPIO_STROBE_BIT(col);
	104	}
	105	}
	106
	107	static inline void tosakbd_reset_col(int col)
	108	{
	109	if (col <= 5) {
	110	/* STROBE col -> Low */
	111	GPCR1 = TOSA_GPIO_STROBE_BIT(col);
	112	/* STROBE col -> out, not col -> HiZ */
	113	GPDR1 = (GPDR1 & ~TOSA_GPIO_HIGH_STROBE_BIT) \| TOSA_GPIO_STROBE_BIT(col);
	114	} else {
	115	/* STROBE col -> Low */
	116	GPCR2 = TOSA_GPIO_STROBE_BIT(col);
	117	/* STROBE col -> out, not col -> HiZ */
	118	GPDR2 = (GPDR2 & ~TOSA_GPIO_LOW_STROBE_BIT) \| TOSA_GPIO_STROBE_BIT(col);
	119	}
	120	}
	121	/*
	122	* The tosa keyboard only generates interrupts when a key is pressed.
	123	* So when a key is pressed, we enable a timer. This timer scans the
	124	* keyboard, and this is how we detect when the key is released.
	125	*/
	126
	127	/* Scan the hardware keyboard and push any changes up through the input layer */
	128	static void tosakbd_scankeyboard(struct platform_device *dev)
	129	{
130	struct tosakbd *tosakbd = platform_get_drvdata(dev);
131	unsigned int row, col, rowd;
132	unsigned long flags;
133	unsigned int num_pressed = 0;
134
135	spin_lock_irqsave(&tosakbd->lock, flags);
136
5550fbae DES	137	if (tosakbd->suspended)
	138	goto out;
	139
93e9012f DES	140	for (col = 0; col < TOSA_KEY_STROBE_NUM; col++) {
	141	/*
	142	* Discharge the output driver capacitatance
	143	* in the keyboard matrix. (Yes it is significant..)
	144	*/
	145	tosakbd_discharge_all();
	146	udelay(KB_DISCHARGE_DELAY);
	147
	148	tosakbd_activate_col(col);
	149	udelay(KB_ACTIVATE_DELAY);
	150
	151	rowd = GET_ROWS_STATUS(col);
	152
	153	for (row = 0; row < TOSA_KEY_SENSE_NUM; row++) {
	154	unsigned int scancode, pressed;
	155	scancode = SCANCODE(row, col);
	156	pressed = rowd & KB_ROWMASK(row);
	157
	158	if (pressed && !tosakbd->keycode[scancode])
	159	dev_warn(&dev->dev,
	160	"unhandled scancode: 0x%02x\n",
	161	scancode);
	162
	163	input_report_key(tosakbd->input,
	164	tosakbd->keycode[scancode],
	165	pressed);
	166	if (pressed)
	167	num_pressed++;
	168	}
	169
	170	tosakbd_reset_col(col);
	171	}
	172
	173	tosakbd_activate_all();
	174
	175	input_sync(tosakbd->input);
	176
	177	/* if any keys are pressed, enable the timer */
	178	if (num_pressed)
	179	mod_timer(&tosakbd->timer, jiffies + SCAN_INTERVAL);
	180
5550fbae	181	out:
93e9012f DES	182	spin_unlock_irqrestore(&tosakbd->lock, flags);
	183	}
	184
	185	/*
	186	* tosa keyboard interrupt handler.
	187	*/
	188	static irqreturn_t tosakbd_interrupt(int irq, void *__dev)
	189	{
	190	struct platform_device *dev = __dev;
	191	struct tosakbd *tosakbd = platform_get_drvdata(dev);
	192
	193	if (!timer_pending(&tosakbd->timer)) {
	194	/ wait chattering delay /
	195	udelay(20);
	196	tosakbd_scankeyboard(dev);
	197	}
	198
	199	return IRQ_HANDLED;
	200	}
	201
	202	/*
	203	* tosa timer checking for released keys
	204	*/
	205	static void tosakbd_timer_callback(unsigned long __dev)
	206	{
	207	struct platform_device dev = (struct platform_device )__dev;
5550fbae	208
93e9012f DES	209	tosakbd_scankeyboard(dev);
	210	}
	211
	212	#ifdef CONFIG_PM
	213	static int tosakbd_suspend(struct platform_device *dev, pm_message_t state)
	214	{
	215	struct tosakbd *tosakbd = platform_get_drvdata(dev);
5550fbae DES	216	unsigned long flags;
	217
	218	spin_lock_irqsave(&tosakbd->lock, flags);
8fbac18e	219	tosakbd->suspended = true;
5550fbae	220	spin_unlock_irqrestore(&tosakbd->lock, flags);
93e9012f DES	221
	222	del_timer_sync(&tosakbd->timer);
	223
	224	return 0;
	225	}
	226
	227	static int tosakbd_resume(struct platform_device *dev)
	228	{
5550fbae DES	229	struct tosakbd *tosakbd = platform_get_drvdata(dev);
5550fbae DES	230
8fbac18e	231	tosakbd->suspended = false;
93e9012f DES	232	tosakbd_scankeyboard(dev);
	233
	234	return 0;
	235	}
	236	#else
	237	#define tosakbd_suspend NULL
	238	#define tosakbd_resume NULL
	239	#endif
	240
	241	static int __devinit tosakbd_probe(struct platform_device *pdev) {
	242
	243	int i;
	244	struct tosakbd *tosakbd;
	245	struct input_dev *input_dev;
	246	int error;
	247
	248	tosakbd = kzalloc(sizeof(struct tosakbd), GFP_KERNEL);
	249	if (!tosakbd)
	250	return -ENOMEM;
	251
	252	input_dev = input_allocate_device();
	253	if (!input_dev) {
	254	kfree(tosakbd);
	255	return -ENOMEM;
	256	}
	257
	258	platform_set_drvdata(pdev, tosakbd);
	259
	260	spin_lock_init(&tosakbd->lock);
	261
	262	/* Init Keyboard rescan timer */
	263	init_timer(&tosakbd->timer);
	264	tosakbd->timer.function = tosakbd_timer_callback;
	265	tosakbd->timer.data = (unsigned long) pdev;
	266
	267	tosakbd->input = input_dev;
	268
	269	input_set_drvdata(input_dev, tosakbd);
	270	input_dev->name = "Tosa Keyboard";
	271	input_dev->phys = "tosakbd/input0";
	272	input_dev->dev.parent = &pdev->dev;
	273
	274	input_dev->id.bustype = BUS_HOST;
	275	input_dev->id.vendor = 0x0001;
	276	input_dev->id.product = 0x0001;
	277	input_dev->id.version = 0x0100;
	278
	279	input_dev->evbit[0] = BIT(EV_KEY) \| BIT(EV_REP);
	280	input_dev->keycode = tosakbd->keycode;
8fbac18e	281	input_dev->keycodesize = sizeof(tosakbd->keycode[0]);
93e9012f DES	282	input_dev->keycodemax = ARRAY_SIZE(tosakbd_keycode);
	283
	284	memcpy(tosakbd->keycode, tosakbd_keycode, sizeof(tosakbd_keycode));
	285
	286	for (i = 0; i < ARRAY_SIZE(tosakbd_keycode); i++)
	287	__set_bit(tosakbd->keycode[i], input_dev->keybit);
8fbac18e	288	__clear_bit(KEY_RESERVED, input_dev->keybit);
93e9012f DES	289
	290	/* Setup sense interrupts - RisingEdge Detect, sense lines as inputs */
	291	for (i = 0; i < TOSA_KEY_SENSE_NUM; i++) {
	292	int gpio = TOSA_GPIO_KEY_SENSE(i);
	293	int irq;
	294	error = gpio_request(gpio, "tosakbd");
	295	if (error < 0) {
	296	printk(KERN_ERR "tosakbd: failed to request GPIO %d, "
	297	" error %d\n", gpio, error);
	298	goto fail;
	299	}
	300
	301	error = gpio_direction_input(TOSA_GPIO_KEY_SENSE(i));
	302	if (error < 0) {
	303	printk(KERN_ERR "tosakbd: failed to configure input"
	304	" direction for GPIO %d, error %d\n",
	305	gpio, error);
	306	gpio_free(gpio);
	307	goto fail;
	308	}
	309
	310	irq = gpio_to_irq(gpio);
	311	if (irq < 0) {
	312	error = irq;
	313	printk(KERN_ERR "gpio-keys: Unable to get irq number"
	314	" for GPIO %d, error %d\n",
	315	gpio, error);
	316	gpio_free(gpio);
	317	goto fail;
	318	}
	319
	320	error = request_irq(irq, tosakbd_interrupt,
	321	IRQF_DISABLED \| IRQF_TRIGGER_RISING,
	322	"tosakbd", pdev);
	323
	324	if (error) {
	325	printk("tosakbd: Can't get IRQ: %d: error %d!\n",
	326	irq, error);
	327	gpio_free(gpio);
	328	goto fail;
	329	}
	330	}
	331
	332	/* Set Strobe lines as outputs - set high */
	333	for (i = 0; i < TOSA_KEY_STROBE_NUM; i++) {
	334	int gpio = TOSA_GPIO_KEY_STROBE(i);
	335	error = gpio_request(gpio, "tosakbd");
	336	if (error < 0) {
	337	printk(KERN_ERR "tosakbd: failed to request GPIO %d, "
	338	" error %d\n", gpio, error);
	339	goto fail2;
	340	}
	341
	342	error = gpio_direction_output(gpio, 1);
	343	if (error < 0) {
	344	printk(KERN_ERR "tosakbd: failed to configure input"
	345	" direction for GPIO %d, error %d\n",
	346	gpio, error);
	347	gpio_free(gpio);
8fbac18e	348	goto fail2;
93e9012f DES	349	}
	350
	351	}
	352
	353	error = input_register_device(input_dev);
	354	if (error) {
	355	printk(KERN_ERR "tosakbd: Unable to register input device, "
	356	"error: %d\n", error);
8fbac18e	357	goto fail2;
93e9012f DES	358	}
	359
	360	printk(KERN_INFO "input: Tosa Keyboard Registered\n");
	361
	362	return 0;
	363
	364	fail2:
	365	while (--i >= 0)
	366	gpio_free(TOSA_GPIO_KEY_STROBE(i));
	367
	368	i = TOSA_KEY_SENSE_NUM;
	369	fail:
	370	while (--i >= 0) {
	371	free_irq(gpio_to_irq(TOSA_GPIO_KEY_SENSE(i)), pdev);
	372	gpio_free(TOSA_GPIO_KEY_SENSE(i));
	373	}
	374
	375	platform_set_drvdata(pdev, NULL);
	376	input_free_device(input_dev);
	377	kfree(tosakbd);
	378
	379	return error;
	380	}
	381
5550fbae DES	382	static int __devexit tosakbd_remove(struct platform_device *dev)
5550fbae DES	383	{
93e9012f DES	384	int i;
	385	struct tosakbd *tosakbd = platform_get_drvdata(dev);
	386
	387	for (i = 0; i < TOSA_KEY_STROBE_NUM; i++)
	388	gpio_free(TOSA_GPIO_KEY_STROBE(i));
	389
	390	for (i = 0; i < TOSA_KEY_SENSE_NUM; i++) {
	391	free_irq(gpio_to_irq(TOSA_GPIO_KEY_SENSE(i)), dev);
	392	gpio_free(TOSA_GPIO_KEY_SENSE(i));
	393	}
	394
	395	del_timer_sync(&tosakbd->timer);
	396
	397	input_unregister_device(tosakbd->input);
	398
	399	kfree(tosakbd);
	400
	401	return 0;
	402	}
	403
	404	static struct platform_driver tosakbd_driver = {
	405	.probe = tosakbd_probe,
	406	.remove = __devexit_p(tosakbd_remove),
	407	.suspend = tosakbd_suspend,
	408	.resume = tosakbd_resume,
	409	.driver = {
	410	.name = "tosa-keyboard",
d7b5247b	411	.owner = THIS_MODULE,
93e9012f DES	412	},
	413	};
	414
	415	static int __devinit tosakbd_init(void)
	416	{
	417	return platform_driver_register(&tosakbd_driver);
	418	}
	419
	420	static void __exit tosakbd_exit(void)
	421	{
	422	platform_driver_unregister(&tosakbd_driver);
	423	}
	424
	425	module_init(tosakbd_init);
	426	module_exit(tosakbd_exit);
	427
	428	MODULE_AUTHOR("Dirk Opfer <Dirk@Opfer-Online.de>");
	429	MODULE_DESCRIPTION("Tosa Keyboard Driver");
	430	MODULE_LICENSE("GPL v2");
d7b5247b	431	MODULE_ALIAS("platform:tosa-keyboard");