[deliverable/linux.git] / drivers / input / keyboard / lpc32xx-keys.c

/*
 * NXP LPC32xx SoC Key Scan Interface
 *
 * Authors:
 *    Kevin Wells <kevin.wells@nxp.com>
 *    Roland Stigge <stigge@antcom.de>
 *
 * Copyright (C) 2010 NXP Semiconductors
 * Copyright (C) 2012 Roland Stigge
 *
 * 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.
 *
 *
 * This controller supports square key matrices from 1x1 up to 8x8
 */

#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/irq.h>
#include <linux/pm.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/input/matrix_keypad.h>

#define DRV_NAME				"lpc32xx_keys"

/*
 * Key scanner register offsets
 */
#define LPC32XX_KS_DEB(x)			((x) + 0x00)
#define LPC32XX_KS_STATE_COND(x)		((x) + 0x04)
#define LPC32XX_KS_IRQ(x)			((x) + 0x08)
#define LPC32XX_KS_SCAN_CTL(x)			((x) + 0x0C)
#define LPC32XX_KS_FAST_TST(x)			((x) + 0x10)
#define LPC32XX_KS_MATRIX_DIM(x)		((x) + 0x14) /* 1..8 */
#define LPC32XX_KS_DATA(x, y)			((x) + 0x40 + ((y) << 2))

#define LPC32XX_KSCAN_DEB_NUM_DEB_PASS(n)	((n) & 0xFF)

#define LPC32XX_KSCAN_SCOND_IN_IDLE		0x0
#define LPC32XX_KSCAN_SCOND_IN_SCANONCE		0x1
#define LPC32XX_KSCAN_SCOND_IN_IRQGEN		0x2
#define LPC32XX_KSCAN_SCOND_IN_SCAN_MATRIX	0x3

#define LPC32XX_KSCAN_IRQ_PENDING_CLR		0x1

#define LPC32XX_KSCAN_SCTRL_SCAN_DELAY(n)	((n) & 0xFF)

#define LPC32XX_KSCAN_FTST_FORCESCANONCE	0x1
#define LPC32XX_KSCAN_FTST_USE32K_CLK		0x2

#define LPC32XX_KSCAN_MSEL_SELECT(n)		((n) & 0xF)

struct lpc32xx_kscan_drv {
	struct input_dev *input;
	struct clk *clk;
	void __iomem *kscan_base;
	unsigned int irq;

	u32 matrix_sz;		/* Size of matrix in XxY, ie. 3 = 3x3 */
	u32 deb_clks;		/* Debounce clocks (based on 32KHz clock) */
	u32 scan_delay;		/* Scan delay (based on 32KHz clock) */

	unsigned short *keymap;	/* Pointer to key map for the scan matrix */
	unsigned int row_shift;

	u8 lastkeystates[8];
};

static void lpc32xx_mod_states(struct lpc32xx_kscan_drv *kscandat, int col)
{
	struct input_dev *input = kscandat->input;
	unsigned row, changed, scancode, keycode;
	u8 key;

	key = readl(LPC32XX_KS_DATA(kscandat->kscan_base, col));
	changed = key ^ kscandat->lastkeystates[col];
	kscandat->lastkeystates[col] = key;

	for (row = 0; changed; row++, changed >>= 1) {
		if (changed & 1) {
			/* Key state changed, signal an event */
			scancode = MATRIX_SCAN_CODE(row, col,
						    kscandat->row_shift);
			keycode = kscandat->keymap[scancode];
			input_event(input, EV_MSC, MSC_SCAN, scancode);
			input_report_key(input, keycode, key & (1 << row));
		}
	}
}

static irqreturn_t lpc32xx_kscan_irq(int irq, void *dev_id)
{
	struct lpc32xx_kscan_drv *kscandat = dev_id;
	int i;

	for (i = 0; i < kscandat->matrix_sz; i++)
		lpc32xx_mod_states(kscandat, i);

	writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));

	input_sync(kscandat->input);

	return IRQ_HANDLED;
}

static int lpc32xx_kscan_open(struct input_dev *dev)
{
	struct lpc32xx_kscan_drv *kscandat = input_get_drvdata(dev);
	int error;

	error = clk_prepare_enable(kscandat->clk);
	if (error)
		return error;

	writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));

	return 0;
}

static void lpc32xx_kscan_close(struct input_dev *dev)
{
	struct lpc32xx_kscan_drv *kscandat = input_get_drvdata(dev);

	writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));
	clk_disable_unprepare(kscandat->clk);
}

static int lpc32xx_parse_dt(struct device *dev,
				      struct lpc32xx_kscan_drv *kscandat)
{
	struct device_node *np = dev->of_node;
	u32 rows = 0, columns = 0;
	int err;

	err = matrix_keypad_parse_of_params(dev, &rows, &columns);
	if (err)
		return err;
	if (rows != columns) {
		dev_err(dev, "rows and columns must be equal!\n");
		return -EINVAL;
	}

	kscandat->matrix_sz = rows;
	kscandat->row_shift = get_count_order(columns);

	of_property_read_u32(np, "nxp,debounce-delay-ms", &kscandat->deb_clks);
	of_property_read_u32(np, "nxp,scan-delay-ms", &kscandat->scan_delay);
	if (!kscandat->deb_clks || !kscandat->scan_delay) {
		dev_err(dev, "debounce or scan delay not specified\n");
		return -EINVAL;
	}

	return 0;
}

static int lpc32xx_kscan_probe(struct platform_device *pdev)
{
	struct lpc32xx_kscan_drv *kscandat;
	struct input_dev *input;
	struct resource *res;
	size_t keymap_size;
	int error;
	int irq;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		dev_err(&pdev->dev, "failed to get platform I/O memory\n");
		return -EINVAL;
	}

	irq = platform_get_irq(pdev, 0);
	if (irq < 0 || irq >= NR_IRQS) {
		dev_err(&pdev->dev, "failed to get platform irq\n");
		return -EINVAL;
	}

	kscandat = devm_kzalloc(&pdev->dev, sizeof(*kscandat),
				GFP_KERNEL);
	if (!kscandat)
		return -ENOMEM;

	error = lpc32xx_parse_dt(&pdev->dev, kscandat);
	if (error) {
		dev_err(&pdev->dev, "failed to parse device tree\n");
		return error;
	}

	keymap_size = sizeof(kscandat->keymap[0]) *
				(kscandat->matrix_sz << kscandat->row_shift);
	kscandat->keymap = devm_kzalloc(&pdev->dev, keymap_size, GFP_KERNEL);
	if (!kscandat->keymap)
		return -ENOMEM;

	kscandat->input = input = devm_input_allocate_device(&pdev->dev);
	if (!input) {
		dev_err(&pdev->dev, "failed to allocate input device\n");
		return -ENOMEM;
	}

	/* Setup key input */
	input->name		= pdev->name;
	input->phys		= "lpc32xx/input0";
	input->id.vendor	= 0x0001;
	input->id.product	= 0x0001;
	input->id.version	= 0x0100;
	input->open		= lpc32xx_kscan_open;
	input->close		= lpc32xx_kscan_close;
	input->dev.parent	= &pdev->dev;

	input_set_capability(input, EV_MSC, MSC_SCAN);

	error = matrix_keypad_build_keymap(NULL, NULL,
					   kscandat->matrix_sz,
					   kscandat->matrix_sz,
					   kscandat->keymap, kscandat->input);
	if (error) {
		dev_err(&pdev->dev, "failed to build keymap\n");
		return error;
	}

	input_set_drvdata(kscandat->input, kscandat);

	kscandat->kscan_base = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(kscandat->kscan_base))
		return PTR_ERR(kscandat->kscan_base);

	/* Get the key scanner clock */
	kscandat->clk = devm_clk_get(&pdev->dev, NULL);
	if (IS_ERR(kscandat->clk)) {
		dev_err(&pdev->dev, "failed to get clock\n");
		return PTR_ERR(kscandat->clk);
	}

	/* Configure the key scanner */
	error = clk_prepare_enable(kscandat->clk);
	if (error)
		return error;

	writel(kscandat->deb_clks, LPC32XX_KS_DEB(kscandat->kscan_base));
	writel(kscandat->scan_delay, LPC32XX_KS_SCAN_CTL(kscandat->kscan_base));
	writel(LPC32XX_KSCAN_FTST_USE32K_CLK,
	       LPC32XX_KS_FAST_TST(kscandat->kscan_base));
	writel(kscandat->matrix_sz,
	       LPC32XX_KS_MATRIX_DIM(kscandat->kscan_base));
	writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));
	clk_disable_unprepare(kscandat->clk);

	error = devm_request_irq(&pdev->dev, irq, lpc32xx_kscan_irq, 0,
				 pdev->name, kscandat);
	if (error) {
		dev_err(&pdev->dev, "failed to request irq\n");
		return error;
	}

	error = input_register_device(kscandat->input);
	if (error) {
		dev_err(&pdev->dev, "failed to register input device\n");
		return error;
	}

	platform_set_drvdata(pdev, kscandat);

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int lpc32xx_kscan_suspend(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct lpc32xx_kscan_drv *kscandat = platform_get_drvdata(pdev);
	struct input_dev *input = kscandat->input;

	mutex_lock(&input->mutex);

	if (input->users) {
		/* Clear IRQ and disable clock */
		writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));
		clk_disable_unprepare(kscandat->clk);
	}

	mutex_unlock(&input->mutex);
	return 0;
}

static int lpc32xx_kscan_resume(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct lpc32xx_kscan_drv *kscandat = platform_get_drvdata(pdev);
	struct input_dev *input = kscandat->input;
	int retval = 0;

	mutex_lock(&input->mutex);

	if (input->users) {
		/* Enable clock and clear IRQ */
		retval = clk_prepare_enable(kscandat->clk);
		if (retval == 0)
			writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));
	}

	mutex_unlock(&input->mutex);
	return retval;
}
#endif

static SIMPLE_DEV_PM_OPS(lpc32xx_kscan_pm_ops, lpc32xx_kscan_suspend,
			 lpc32xx_kscan_resume);

static const struct of_device_id lpc32xx_kscan_match[] = {
	{ .compatible = "nxp,lpc3220-key" },
	{},
};
MODULE_DEVICE_TABLE(of, lpc32xx_kscan_match);

static struct platform_driver lpc32xx_kscan_driver = {
	.probe		= lpc32xx_kscan_probe,
	.driver		= {
		.name	= DRV_NAME,
		.pm	= &lpc32xx_kscan_pm_ops,
		.of_match_table = lpc32xx_kscan_match,
	}
};

module_platform_driver(lpc32xx_kscan_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Kevin Wells <kevin.wells@nxp.com>");
MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
MODULE_DESCRIPTION("Key scanner driver for LPC32XX devices");
Commit	Line	Data
69690bec RS	1	/*
	2	* NXP LPC32xx SoC Key Scan Interface
	3	*
	4	* Authors:
	5	* Kevin Wells <kevin.wells@nxp.com>
	6	* Roland Stigge <stigge@antcom.de>
	7	*
	8	* Copyright (C) 2010 NXP Semiconductors
	9	* Copyright (C) 2012 Roland Stigge
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	*
	22	* This controller supports square key matrices from 1x1 up to 8x8
	23	*/
	24
	25	#include <linux/module.h>
	26	#include <linux/interrupt.h>
	27	#include <linux/slab.h>
	28	#include <linux/irq.h>
	29	#include <linux/pm.h>
	30	#include <linux/platform_device.h>
	31	#include <linux/input.h>
	32	#include <linux/clk.h>
	33	#include <linux/io.h>
	34	#include <linux/of.h>
	35	#include <linux/input/matrix_keypad.h>
	36
	37	#define DRV_NAME "lpc32xx_keys"
	38
	39	/*
	40	* Key scanner register offsets
	41	*/
	42	#define LPC32XX_KS_DEB(x) ((x) + 0x00)
	43	#define LPC32XX_KS_STATE_COND(x) ((x) + 0x04)
	44	#define LPC32XX_KS_IRQ(x) ((x) + 0x08)
	45	#define LPC32XX_KS_SCAN_CTL(x) ((x) + 0x0C)
	46	#define LPC32XX_KS_FAST_TST(x) ((x) + 0x10)
	47	#define LPC32XX_KS_MATRIX_DIM(x) ((x) + 0x14) /* 1..8 */
	48	#define LPC32XX_KS_DATA(x, y) ((x) + 0x40 + ((y) << 2))
	49
	50	#define LPC32XX_KSCAN_DEB_NUM_DEB_PASS(n) ((n) & 0xFF)
	51
	52	#define LPC32XX_KSCAN_SCOND_IN_IDLE 0x0
	53	#define LPC32XX_KSCAN_SCOND_IN_SCANONCE 0x1
	54	#define LPC32XX_KSCAN_SCOND_IN_IRQGEN 0x2
	55	#define LPC32XX_KSCAN_SCOND_IN_SCAN_MATRIX 0x3
	56
	57	#define LPC32XX_KSCAN_IRQ_PENDING_CLR 0x1
	58
	59	#define LPC32XX_KSCAN_SCTRL_SCAN_DELAY(n) ((n) & 0xFF)
	60
	61	#define LPC32XX_KSCAN_FTST_FORCESCANONCE 0x1
	62	#define LPC32XX_KSCAN_FTST_USE32K_CLK 0x2
	63
	64	#define LPC32XX_KSCAN_MSEL_SELECT(n) ((n) & 0xF)
65
66	struct lpc32xx_kscan_drv {
67	struct input_dev *input;
68	struct clk *clk;
69690bec RS	69	void __iomem *kscan_base;
	70	unsigned int irq;
	71
	72	u32 matrix_sz; /* Size of matrix in XxY, ie. 3 = 3x3 */
	73	u32 deb_clks; /* Debounce clocks (based on 32KHz clock) */
	74	u32 scan_delay; /* Scan delay (based on 32KHz clock) */
	75
	76	unsigned short keymap; / Pointer to key map for the scan matrix */
	77	unsigned int row_shift;
	78
	79	u8 lastkeystates[8];
	80	};
	81
	82	static void lpc32xx_mod_states(struct lpc32xx_kscan_drv *kscandat, int col)
	83	{
	84	struct input_dev *input = kscandat->input;
	85	unsigned row, changed, scancode, keycode;
	86	u8 key;
	87
	88	key = readl(LPC32XX_KS_DATA(kscandat->kscan_base, col));
	89	changed = key ^ kscandat->lastkeystates[col];
	90	kscandat->lastkeystates[col] = key;
	91
	92	for (row = 0; changed; row++, changed >>= 1) {
	93	if (changed & 1) {
	94	/* Key state changed, signal an event */
	95	scancode = MATRIX_SCAN_CODE(row, col,
	96	kscandat->row_shift);
	97	keycode = kscandat->keymap[scancode];
	98	input_event(input, EV_MSC, MSC_SCAN, scancode);
	99	input_report_key(input, keycode, key & (1 << row));
	100	}
	101	}
	102	}
	103
	104	static irqreturn_t lpc32xx_kscan_irq(int irq, void *dev_id)
	105	{
	106	struct lpc32xx_kscan_drv *kscandat = dev_id;
	107	int i;
	108
	109	for (i = 0; i < kscandat->matrix_sz; i++)
	110	lpc32xx_mod_states(kscandat, i);
	111
	112	writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));
	113
	114	input_sync(kscandat->input);
	115
	116	return IRQ_HANDLED;
	117	}
	118
	119	static int lpc32xx_kscan_open(struct input_dev *dev)
	120	{
	121	struct lpc32xx_kscan_drv *kscandat = input_get_drvdata(dev);
	122	int error;
	123
	124	error = clk_prepare_enable(kscandat->clk);
	125	if (error)
	126	return error;
	127
	128	writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));
	129
	130	return 0;
	131	}
	132
133	static void lpc32xx_kscan_close(struct input_dev *dev)
134	{
135	struct lpc32xx_kscan_drv *kscandat = input_get_drvdata(dev);
136
137	writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));
138	clk_disable_unprepare(kscandat->clk);
139	}
140
5298cc4c	141	static int lpc32xx_parse_dt(struct device *dev,
69690bec RS	142	struct lpc32xx_kscan_drv *kscandat)
	143	{
	144	struct device_node *np = dev->of_node;
	145	u32 rows = 0, columns = 0;
43840415	146	int err;
69690bec	147
43840415 SG	148	err = matrix_keypad_parse_of_params(dev, &rows, &columns);
	149	if (err)
	150	return err;
	151	if (rows != columns) {
	152	dev_err(dev, "rows and columns must be equal!\n");
69690bec RS	153	return -EINVAL;
	154	}
	155
	156	kscandat->matrix_sz = rows;
	157	kscandat->row_shift = get_count_order(columns);
	158
	159	of_property_read_u32(np, "nxp,debounce-delay-ms", &kscandat->deb_clks);
	160	of_property_read_u32(np, "nxp,scan-delay-ms", &kscandat->scan_delay);
	161	if (!kscandat->deb_clks \|\| !kscandat->scan_delay) {
	162	dev_err(dev, "debounce or scan delay not specified\n");
	163	return -EINVAL;
	164	}
	165
	166	return 0;
	167	}
	168
5298cc4c	169	static int lpc32xx_kscan_probe(struct platform_device *pdev)
69690bec RS	170	{
	171	struct lpc32xx_kscan_drv *kscandat;
	172	struct input_dev *input;
	173	struct resource *res;
	174	size_t keymap_size;
	175	int error;
	176	int irq;
	177
	178	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	179	if (!res) {
	180	dev_err(&pdev->dev, "failed to get platform I/O memory\n");
	181	return -EINVAL;
	182	}
	183
	184	irq = platform_get_irq(pdev, 0);
	185	if (irq < 0 \|\| irq >= NR_IRQS) {
	186	dev_err(&pdev->dev, "failed to get platform irq\n");
	187	return -EINVAL;
	188	}
	189
dae7aa8d PG	190	kscandat = devm_kzalloc(&pdev->dev, sizeof(*kscandat),
	191	GFP_KERNEL);
	192	if (!kscandat)
69690bec	193	return -ENOMEM;
69690bec RS	194
	195	error = lpc32xx_parse_dt(&pdev->dev, kscandat);
	196	if (error) {
	197	dev_err(&pdev->dev, "failed to parse device tree\n");
dae7aa8d	198	return error;
69690bec RS	199	}
	200
	201	keymap_size = sizeof(kscandat->keymap[0]) *
	202	(kscandat->matrix_sz << kscandat->row_shift);
dae7aa8d PG	203	kscandat->keymap = devm_kzalloc(&pdev->dev, keymap_size, GFP_KERNEL);
	204	if (!kscandat->keymap)
	205	return -ENOMEM;
69690bec	206
dae7aa8d	207	kscandat->input = input = devm_input_allocate_device(&pdev->dev);
69690bec RS	208	if (!input) {
69690bec RS	209	dev_err(&pdev->dev, "failed to allocate input device\n");
dae7aa8d	210	return -ENOMEM;
69690bec RS	211	}
	212
	213	/* Setup key input */
	214	input->name = pdev->name;
	215	input->phys = "lpc32xx/input0";
	216	input->id.vendor = 0x0001;
	217	input->id.product = 0x0001;
	218	input->id.version = 0x0100;
	219	input->open = lpc32xx_kscan_open;
	220	input->close = lpc32xx_kscan_close;
	221	input->dev.parent = &pdev->dev;
	222
	223	input_set_capability(input, EV_MSC, MSC_SCAN);
	224
	225	error = matrix_keypad_build_keymap(NULL, NULL,
	226	kscandat->matrix_sz,
	227	kscandat->matrix_sz,
	228	kscandat->keymap, kscandat->input);
	229	if (error) {
	230	dev_err(&pdev->dev, "failed to build keymap\n");
dae7aa8d	231	return error;
69690bec RS	232	}
	233
	234	input_set_drvdata(kscandat->input, kscandat);
	235
dae7aa8d PG	236	kscandat->kscan_base = devm_ioremap_resource(&pdev->dev, res);
	237	if (IS_ERR(kscandat->kscan_base))
	238	return PTR_ERR(kscandat->kscan_base);
69690bec RS	239
69690bec RS	240	/* Get the key scanner clock */
dae7aa8d	241	kscandat->clk = devm_clk_get(&pdev->dev, NULL);
69690bec RS	242	if (IS_ERR(kscandat->clk)) {
69690bec RS	243	dev_err(&pdev->dev, "failed to get clock\n");
dae7aa8d	244	return PTR_ERR(kscandat->clk);
69690bec RS	245	}
	246
	247	/* Configure the key scanner */
	248	error = clk_prepare_enable(kscandat->clk);
	249	if (error)
dae7aa8d	250	return error;
69690bec RS	251
	252	writel(kscandat->deb_clks, LPC32XX_KS_DEB(kscandat->kscan_base));
	253	writel(kscandat->scan_delay, LPC32XX_KS_SCAN_CTL(kscandat->kscan_base));
	254	writel(LPC32XX_KSCAN_FTST_USE32K_CLK,
	255	LPC32XX_KS_FAST_TST(kscandat->kscan_base));
	256	writel(kscandat->matrix_sz,
	257	LPC32XX_KS_MATRIX_DIM(kscandat->kscan_base));
	258	writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));
	259	clk_disable_unprepare(kscandat->clk);
	260
dae7aa8d PG	261	error = devm_request_irq(&pdev->dev, irq, lpc32xx_kscan_irq, 0,
dae7aa8d PG	262	pdev->name, kscandat);
69690bec RS	263	if (error) {
69690bec RS	264	dev_err(&pdev->dev, "failed to request irq\n");
dae7aa8d	265	return error;
69690bec RS	266	}
	267
	268	error = input_register_device(kscandat->input);
	269	if (error) {
	270	dev_err(&pdev->dev, "failed to register input device\n");
dae7aa8d	271	return error;
69690bec RS	272	}
	273
	274	platform_set_drvdata(pdev, kscandat);
69690bec RS	275
	276	return 0;
	277	}
	278
	279	#ifdef CONFIG_PM_SLEEP
	280	static int lpc32xx_kscan_suspend(struct device *dev)
	281	{
	282	struct platform_device *pdev = to_platform_device(dev);
	283	struct lpc32xx_kscan_drv *kscandat = platform_get_drvdata(pdev);
	284	struct input_dev *input = kscandat->input;
	285
	286	mutex_lock(&input->mutex);
	287
	288	if (input->users) {
	289	/* Clear IRQ and disable clock */
	290	writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));
	291	clk_disable_unprepare(kscandat->clk);
	292	}
	293
	294	mutex_unlock(&input->mutex);
	295	return 0;
	296	}
	297
	298	static int lpc32xx_kscan_resume(struct device *dev)
	299	{
	300	struct platform_device *pdev = to_platform_device(dev);
	301	struct lpc32xx_kscan_drv *kscandat = platform_get_drvdata(pdev);
	302	struct input_dev *input = kscandat->input;
	303	int retval = 0;
	304
	305	mutex_lock(&input->mutex);
	306
	307	if (input->users) {
	308	/* Enable clock and clear IRQ */
	309	retval = clk_prepare_enable(kscandat->clk);
	310	if (retval == 0)
	311	writel(1, LPC32XX_KS_IRQ(kscandat->kscan_base));
	312	}
	313
	314	mutex_unlock(&input->mutex);
	315	return retval;
	316	}
	317	#endif
	318
	319	static SIMPLE_DEV_PM_OPS(lpc32xx_kscan_pm_ops, lpc32xx_kscan_suspend,
	320	lpc32xx_kscan_resume);
	321
	322	static const struct of_device_id lpc32xx_kscan_match[] = {
	323	{ .compatible = "nxp,lpc3220-key" },
	324	{},
	325	};
	326	MODULE_DEVICE_TABLE(of, lpc32xx_kscan_match);
	327
	328	static struct platform_driver lpc32xx_kscan_driver = {
	329	.probe = lpc32xx_kscan_probe,
69690bec RS	330	.driver = {
69690bec RS	331	.name = DRV_NAME,
69690bec	332	.pm = &lpc32xx_kscan_pm_ops,
39116e26	333	.of_match_table = lpc32xx_kscan_match,
69690bec RS	334	}
	335	};
	336
	337	module_platform_driver(lpc32xx_kscan_driver);
	338
	339	MODULE_LICENSE("GPL");
	340	MODULE_AUTHOR("Kevin Wells <kevin.wells@nxp.com>");
	341	MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
	342	MODULE_DESCRIPTION("Key scanner driver for LPC32XX devices");