Re: [PATCH, v2] input/imx2x: generic keypad handler for i.MX SoCs

[Sascha Hauer <s.hauer@pengutronix.de>]

Hi Holger,

On Fri, Apr 17, 2009 at 04:40:14PM +0200, Holger Schurig wrote:
> The i.MX21 SoC has a built-in keypad controller, which this driver
> utilizes. As the keypad usually doesn't connect to a standard PC
> keyboard, but to the keyboard of a PDA-like device, I wrote the
> driver in a keyboard-layout agnostic way.
> 
> Instead, the driver reports each row/column key press and release
> via a platform-data supplied function. Board-specific code can than
> decode the input events from this and submit them.
> 
> See the comments at the top of drivers/input/keyboard/mxc_keypad.c
> 
> Signed-off-by: Holger Schurig <hs4233@mail.mn-solutions.de>

Can you please split the mxc specific changes into a second patch? These
are likely leading to merge conflicts if they go via another tree.

Thanks
  Sascha


> 
> ---
> Changes from v1:
> * call release_mem_region() in error path
> * no IRQF_SAMPLE_RANDOM, input.c does it
> * removed input_free_device() after unregister_device()
> * added device_init_wakeup(&pdev->dev, 0) in remove path
>   (Thanks Trilok Soni)
> * added release_mem_region() to mxc_keypad_remove()
> * removed debugging call to mxc_keypad_open()
> 
> Changes from v2:
> * fixed clkdev name back, as input-devices don't register with a
>   stable device name
> 
> --- linux.orig/arch/arm/mach-mx2/devices.c
> +++ linux/arch/arm/mach-mx2/devices.c
> @@ -36,6 +36,7 @@
>  #include <mach/hardware.h>
>  #include <mach/common.h>
>  #include <mach/mmc.h>
> +#include <mach/mxc_keypad.h>
>  
>  #include "devices.h"
>  
> @@ -446,3 +447,31 @@
>  {
>  	return mxc_gpio_init(imx_gpio_ports, ARRAY_SIZE(imx_gpio_ports));
>  }
> +
> +#ifdef CONFIG_KEYBOARD_MXC
> +static struct resource mxc_resource_keypad[] = {
> +	[0] = {
> +		.start  = 0x10008000,
> +		.end    = 0x10008014,
> +		.flags  = IORESOURCE_MEM,
> +	},
> +	[1] = {
> +		.start  = MXC_INT_KPP,
> +		.end    = MXC_INT_KPP,
> +		.flags  = IORESOURCE_IRQ,
> +	},
> +};
> +
> +static struct platform_device mxc_device_keypad = {
> +	.name           = "mxc-keypad",
> +	.id             = -1,
> +	.resource       = mxc_resource_keypad,
> +	.num_resources  = ARRAY_SIZE(mxc_resource_keypad),
> +};
> +
> +struct mxc_keypad_platform_data;
> +void __init mxc_set_keypad_info(struct mxc_keypad_platform_data *info)
> +{
> +	mxc_register_device(&mxc_device_keypad, info);
> +}
> +#endif
> --- linux.orig/arch/arm/mach-mx2/devices.h
> +++ linux/arch/arm/mach-mx2/devices.h
> @@ -20,3 +20,4 @@
>  extern struct platform_device mxc_i2c_device1;
>  extern struct platform_device mxc_sdhc_device0;
>  extern struct platform_device mxc_sdhc_device1;
> +extern struct platform_device mxc_keypad;
> --- /dev/null
> +++ linux/arch/arm/plat-mxc/include/mach/mxc_keypad.h
> @@ -0,0 +1,20 @@
> +#ifndef __MACH_MXC_KEYPAD_H
> +#define __MACH_MXC_KEYPAD_H
> +
> +#include <linux/input.h>
> +
> +#define MAX_MATRIX_KEY_ROWS	(8)
> +#define MAX_MATRIX_KEY_COLS	(8)
> +
> +struct input_dev;
> +struct mxc_keypad_platform_data {
> +	u16 output_pins;
> +	u16 input_pins;
> +	void (*init)(struct input_dev *idev, struct platform_device *pdev);
> +	void (*exit)(struct platform_device *pdev);
> +	void (*handle_key)(struct input_dev *, int col, int row, int down);
> +};
> +
> +extern void mxc_set_keypad_info(struct mxc_keypad_platform_data *info);
> +
> +#endif
> --- linux.orig/drivers/input/keyboard/Kconfig
> +++ linux/drivers/input/keyboard/Kconfig
> @@ -250,6 +250,16 @@
>  	  To compile this driver as a module, choose M here: the
>  	  module will be called jornada720_kbd.
>  
> +config KEYBOARD_MXC
> +	tristate "Freescale MXC/IMX keypad support"
> +	depends on ARCH_MXC
> +	help
> +	  Say Y here if you have a keypad connected to your MXC/i.MX
> +	  SoC. Note that you also need board-support for this.
> +
> +	  To compile this driver as a module, choose M here: the
> +	  module will be called mxc_keypad.
> +
>  config KEYBOARD_OMAP
>  	tristate "TI OMAP keypad support"
>  	depends on (ARCH_OMAP1 || ARCH_OMAP2)
> --- linux.orig/drivers/input/keyboard/Makefile
> +++ linux/drivers/input/keyboard/Makefile
> @@ -18,6 +18,7 @@
>  obj-$(CONFIG_KEYBOARD_TOSA)		+= tosakbd.o
>  obj-$(CONFIG_KEYBOARD_HIL)		+= hil_kbd.o
>  obj-$(CONFIG_KEYBOARD_HIL_OLD)		+= hilkbd.o
> +obj-$(CONFIG_KEYBOARD_MXC)		+= mxc_keypad.o
>  obj-$(CONFIG_KEYBOARD_OMAP)		+= omap-keypad.o
>  obj-$(CONFIG_KEYBOARD_PXA27x)		+= pxa27x_keypad.o
>  obj-$(CONFIG_KEYBOARD_PXA930_ROTARY)	+= pxa930_rotary.o
> --- /dev/null
> +++ linux/drivers/input/keyboard/mxc_keypad.c
> @@ -0,0 +1,395 @@
> +/*
> + * Driver for the i.MX/MXC matrix keyboard controller.
> + *
> + * Copyright (c) 2009 by Holger Schurig <hs4233@mail.mn-solutions.de>
> + *
> + * 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.
> + */
> +
> +/*
> +
> +This driver is just a "generic" framework, it cannot produce input events on
> +it's own. That's because diverse board/devices have very different
> +keyboards (numeric, alphanumeric, cell phone like etc).
> +
> +Therefore, you'll do the actual scancode -> input event code conversion
> +in a function that you'll provide in your platform data:
> +
> +static struct mxc_keypad_platform_data tt8000_keypad_data = {
> +	.output_pins = 0x0f00,
> +	.input_pins  = 0x001f,
> +	.init        = tt8000_keypad_init,
> +	.exit        = tt8000_keypad_exit,
> +	.handle_key  = tt8000_keypad_key,
> +};
> +
> +static void tt8000_keypad_init(struct input_dev *input_dev,
> +	struct platform_device *pdev);
> +
> +This function is called before the input device registers, it can setup
> +primary/alternate GPIO functions and modify it, e.g. by setting
> +the propriate bits in input_dev->keybit.
> +
> +static void tt8000_keypad_exit(struct platform_device *pdev);
> +
> +The opposite function.
> +
> +static void tt8000_keypad_key(struct input_dev *input_dev,
> +	int row, int col, int down);
> +
> +Called for each key press or release event. Should determine
> +the input event code and sent it via input_report_key().
> +
> +*/
> +
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/init.h>
> +#include <linux/interrupt.h>
> +#include <linux/delay.h>
> +#include <linux/input.h>
> +#include <linux/device.h>
> +#include <linux/platform_device.h>
> +#include <linux/clk.h>
> +#include <linux/err.h>
> +
> +#include <asm/mach/arch.h>
> +#include <asm/mach/map.h>
> +
> +#include <mach/hardware.h>
> +#include <mach/mxc_keypad.h>
> +
> +#define KPCR		0x00
> +
> +#define KPSR		0x02
> +#define KPSR_KPP_EN	(1 << 10)
> +#define KPSR_KRIE	(1 << 9)
> +#define KPSR_KDIE	(1 << 8)
> +#define KPSR_KRSS	(1 << 3)
> +#define KPSR_KDSC	(1 << 2)
> +#define KPSR_KPKR	(1 << 1)
> +#define KPSR_KPKD	(1 << 0)
> +#define KPSR_INT_MASK	(KPSR_KRIE|KPSR_KDIE)
> +
> +#define KDDR		0x04
> +
> +#define KPDR		0x06
> +
> +
> +#define MAX_INPUTS	8
> +#define MAX_OUTPUTS	8
> +
> +
> +struct mxc_keypad {
> +	struct mxc_keypad_platform_data *pdata;
> +	struct resource *res;
> +	int irq;
> +	void __iomem *base;
> +
> +	struct clk *clk;
> +	struct input_dev *input_dev;
> +
> +	u16 keystate_prev[MAX_INPUTS];
> +};
> +
> +
> +static void mxc_keypad_scan(unsigned long data)
> +{
> +	struct mxc_keypad *kp = (struct mxc_keypad *)data;
> +	u16 col_bit, reg;
> +	int i, j;
> +	int snum = 0;
> +	u16 keystate_cur[MAX_INPUTS];
> +	u16 keystate_xor[MAX_INPUTS];
> +
> +	/* write ones to KPDR8:15, setting columns data */
> +	__raw_writew(kp->pdata->output_pins, kp->base + KPDR);
> +
> +	/* Quick-discharge by setting to totem-pole, */
> +	/* then turn back to open-drain */
> +	__raw_writew(kp->pdata->output_pins, kp->base + KPCR);
> +	wmb();
> +	udelay(2);
> +	__raw_writew(kp->pdata->output_pins |
> +		kp->pdata->input_pins, kp->base + KPCR);
> +
> +	col_bit = 1;
> +	while (col_bit) {
> +		if (col_bit & kp->pdata->output_pins) {
> +			__raw_writew(~col_bit, kp->base + KPDR);
> +			wmb();
> +			udelay(2);
> +			reg = ~__raw_readw(kp->base + KPDR);
> +			keystate_cur[snum] = reg & kp->pdata->input_pins;
> +
> +			if (snum++ >= MAX_INPUTS)
> +				break;
> +		}
> +		col_bit <<= 1;
> +	}
> +	for (i = 0; i < snum; i++) {
> +		keystate_xor[i] = kp->keystate_prev[i] ^ keystate_cur[i];
> +		for (j = 0; j < MAX_OUTPUTS; j++) {
> +			if (keystate_xor[i] & (1 << j)) {
> +				int down = !!(keystate_cur[i] & (1 << j));
> +				pr_debug("i,j: %d,%d, down %d\n", i, j, down);
> +				kp->pdata->handle_key(kp->input_dev,
> +					i, j, down);
> +			}
> +		}
> +		kp->keystate_prev[i] = keystate_cur[i];
> +	}
> +
> +	/* set columns back to 0 */
> +	__raw_writew(0, kp->base + KPDR);
> +
> +	/*
> +	 * Clear KPKD and KPKR status bit(s) by writing to a "1",
> +	 * set the KPKR synchronizer chain by writing "1" to KRSS register,
> +	 * clear the KPKD synchronizer chain by writing "1" to KDSC register
> +	 */
> +	reg = __raw_readw(kp->base + KPSR);
> +	reg |= KPSR_KPKD | KPSR_KPKR | KPSR_KRSS | KPSR_KDSC;
> +	__raw_writew(reg, kp->base + KPSR);
> +}
> +
> +
> +static irqreturn_t mxc_keypad_irq_handler(int irq, void *data)
> +{
> +	struct mxc_keypad *kp = data;
> +	u16 stat;
> +
> +	stat = __raw_readw(kp->base + KPSR);
> +	/* Toggle between depress- and release-interrupt */
> +	stat ^= KPSR_INT_MASK;
> +	/* clear interrupt status */
> +	stat |= KPSR_KPKD;
> +	stat |= KPSR_KPKR;
> +	__raw_writew(stat | KPSR_KPKD | KPSR_KPKR, kp->base + KPSR);
> +
> +	mxc_keypad_scan((unsigned long)kp);
> +
> +	pr_debug("KPCR: %04x (0f1f)\n", readw(kp->base + KPCR));
> +	pr_debug("KPSR: %04x (0502)\n", readw(kp->base + KPSR));
> +	pr_debug("KDDR: %04x (0f00)\n", readw(kp->base + KDDR));
> +	pr_debug("KPDR: %04x (705f)\n", readw(kp->base + KPDR));
> +
> +	return IRQ_HANDLED;
> +}
> +
> +#if 0
> +static int mxc_keypad_open(struct input_dev *dev)
> +{
> +	struct mxc_keypad *kp = input_get_drvdata(dev);
> +	struct clk *clk;
> +
> +	/* Enable unit clock */
> +	clk = clk_get(&pdev->dev, "kpp");
> +	if (IS_ERR(clk))
> +		return -ENODEV;
> +	clk_enable(clk);
> +
> +	/* configure keypad */
> +	__raw_writew(kp->pdata->output_pins |
> +		kp->pdata->input_pins, kp->base + KPCR);
> +	__raw_writew(0, kp->base + KPDR);
> +	__raw_writew(kp->pdata->output_pins, kp->base + KDDR);
> +	__raw_writew(KPSR_KPP_EN | KPSR_KDIE |
> +		KPSR_KPKD | KPSR_KRSS | KPSR_KDSC, kp->base + KPSR);
> +
> +	return 0;
> +}
> +
> +static void mxc_keypad_close(struct input_dev *dev)
> +{
> +	struct mxc_keypad *kp = input_get_drvdata(dev);
> +	u16 stat;
> +	struct clk *clk;
> +
> +	/* Mask interrupts */
> +	stat = __raw_readw(kp->base + KPSR);
> +	stat &= ~KPSR_INT_MASK;
> +	__raw_writew(stat | KPSR_KPKD | KPSR_KPKR, kp->base + KPSR);
> +
> +	clk = clk_get(&dev->dev, "kpp");
> +	if (clk)
> +		clk_disable(clk);
> +}
> +#endif
> +
> +static int __devinit mxc_keypad_probe(struct platform_device *pdev)
> +{
> +	struct mxc_keypad *kp;
> +	struct input_dev *input_dev;
> +	struct mxc_keypad_platform_data *pdata;
> +	struct resource *res;
> +	struct clk *clk;
> +	int irq, error;
> +
> +	pdata = pdev->dev.platform_data;
> +	if (!pdata || !pdata->handle_key)
> +		return -EINVAL;
> +
> +	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +	irq = platform_get_irq(pdev, 0);
> +	if (!res || !irq)
> +		return -ENXIO;
> +
> +	res = request_mem_region(res->start, resource_size(res), pdev->name);
> +	if (!res)
> +		return -EBUSY;
> +
> +	kp = kzalloc(sizeof(struct mxc_keypad), GFP_KERNEL);
> +	if (!kp) {
> +		error = -ENOMEM;
> +		goto failed_release;
> +	}
> +
> +	kp->res = res;
> +	kp->pdata = pdata;
> +
> +	/* Create and register the input driver. */
> +	input_dev = kp->input_dev = input_allocate_device();
> +	if (!input_dev) {
> +		dev_err(&pdev->dev, "input_allocate_device\n");
> +		error = -ENOMEM;
> +		goto failed_put_clk;
> +	}
> +
> +	kp->base = ioremap(res->start, resource_size(res));
> +	if (!kp->base) {
> +		dev_err(&pdev->dev, "ioremap\n");
> +		error = -ENOMEM;
> +		goto failed_free_dev;
> +	}
> +
> +	clk = clk_get(&pdev->dev, "kpp");
> +	if (IS_ERR(clk)) {
> +		error = -ENODEV;
> +		goto failed_unmap;
> +	}
> +
> +	input_dev->name = pdev->name;
> +	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_MASK(EV_KEY) | BIT_MASK(EV_REP);
> +	input_set_drvdata(input_dev, kp);
> +
> +	platform_set_drvdata(pdev, kp);
> +
> +	/* should call input_set_capability(input_dev, EV_KEY, code); */
> +	if (kp->pdata->init)
> +		kp->pdata->init(input_dev, pdev);
> +
> +	error = request_irq(irq, mxc_keypad_irq_handler,
> +		IRQF_DISABLED, pdev->name, kp);
> +	if (error) {
> +		dev_err(&pdev->dev, "request_irq\n");
> +		goto failed_clk_put;
> +	}
> +
> +	kp->irq = irq;
> +
> +	/* Register the input device */
> +	error = input_register_device(input_dev);
> +	if (error) {
> +		dev_err(&pdev->dev, "failed to register input device\n");
> +		goto failed_free_irq;
> +	}
> +
> +	device_init_wakeup(&pdev->dev, 1);
> +
> +	/* configure keypad */
> +	clk_enable(clk);
> +	__raw_writew(kp->pdata->output_pins |
> +		kp->pdata->input_pins, kp->base + KPCR);
> +	__raw_writew(0, kp->base + KPDR);
> +	__raw_writew(kp->pdata->output_pins, kp->base + KDDR);
> +	__raw_writew(KPSR_KPP_EN | KPSR_KDIE |
> +		KPSR_KPKD | KPSR_KRSS | KPSR_KDSC, kp->base + KPSR);
> +
> +	return 0;
> +
> +failed_free_irq:
> +	free_irq(irq, pdev);
> +	platform_set_drvdata(pdev, NULL);
> +failed_clk_put:
> +	clk_disable(clk);
> +	clk_put(clk);
> +failed_unmap:
> +	iounmap(kp->base);
> +failed_free_dev:
> +	input_free_device(input_dev);
> +failed_put_clk:
> +	kfree(kp);
> +failed_release:
> +	release_mem_region(res->start, resource_size(res));
> +	return error;
> +}
> +
> +static int __devexit mxc_keypad_remove(struct platform_device *pdev)
> +{
> +	struct mxc_keypad *kp = platform_get_drvdata(pdev);
> +
> +	device_init_wakeup(&pdev->dev, 0);
> +
> +	if (kp) {
> +		/* Mask interrupts */
> +		u16 stat = __raw_readw(kp->base + KPSR);
> +		stat &= ~KPSR_INT_MASK;
> +		__raw_writew(stat | KPSR_KPKD | KPSR_KPKR, kp->base + KPSR);
> +
> +		free_irq(kp->irq, pdev);
> +
> +		if (kp->pdata->exit)
> +			kp->pdata->exit(pdev);
> +
> +		if (kp->base)
> +			iounmap(kp->base);
> +
> +		clk_disable(kp->clk);
> +		clk_put(kp->clk);
> +
> +		input_unregister_device(kp->input_dev);
> +		release_mem_region(kp->res->start, resource_size(kp->res));
> +	}
> +
> +	platform_set_drvdata(pdev, NULL);
> +	kfree(kp);
> +	return 0;
> +}
> +
> +/* work with hotplug and coldplug */
> +MODULE_ALIAS("platform:mxc-keypad");
> +
> +static struct platform_driver mxc_keypad_driver = {
> +	.probe		= mxc_keypad_probe,
> +	.remove		= __devexit_p(mxc_keypad_remove),
> +	.driver		= {
> +		.name	= "mxc-keypad",
> +		.owner	= THIS_MODULE,
> +	},
> +};
> +
> +static int __init mxc_keypad_init(void)
> +{
> +	return platform_driver_register(&mxc_keypad_driver);
> +}
> +
> +static void __exit mxc_keypad_exit(void)
> +{
> +	platform_driver_unregister(&mxc_keypad_driver);
> +}
> +
> +module_init(mxc_keypad_init);
> +module_exit(mxc_keypad_exit);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_DESCRIPTION("i.MX Keypad Driver");
> +MODULE_AUTHOR("Holger Schurig <hs4233@@mail.mn-solutions.de>");
> --- linux.orig/arch/arm/mach-mx2/clock_imx21.c
> +++ linux/arch/arm/mach-mx2/clock_imx21.c
> @@ -932,7 +932,7 @@
>  	_REGISTER_CLOCK("imx-wdt.0", NULL, wdog_clk)
>  	_REGISTER_CLOCK(NULL, "gpio", gpio_clk)
>  	_REGISTER_CLOCK(NULL, "i2c", i2c_clk)
> -	_REGISTER_CLOCK("mxc-keypad", NULL, kpp_clk)
> +	_REGISTER_CLOCK(NULL, "kpp", kpp_clk)
>  	_REGISTER_CLOCK(NULL, "owire", owire_clk)
>  	_REGISTER_CLOCK(NULL, "rtc", rtc_clk)
>  };
> 

-- 
Pengutronix e.K.                           |                             |
Industrial Linux Solutions                 | http://www.pengutronix.de/  |
Peiner Str. 6-8, 31137 Hildesheim, Germany | Phone: +49-5121-206917-0    |
Amtsgericht Hildesheim, HRA 2686           | Fax:   +49-5121-206917-5555 |