Commit b3ab5787 authored by Nikita Shubin's avatar Nikita Shubin Committed by Arnd Bergmann
Browse files

input: keypad: ep93xx: add DT support for Cirrus EP93xx 



- drop flags, they were not used anyway
- add OF ID match table
- process "autorepeat", "debounce-delay-ms", prescale from device tree
- drop platform data usage and it's header
- keymap goes from device tree now on

Signed-off-by: default avatarNikita Shubin <nikita.shubin@maquefel.me>
Acked-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
Acked-by: default avatarVinod Koul <vkoul@kernel.org>
Signed-off-by: default avatarArnd Bergmann <arnd@arndb.de>
parent 9cefdd1a

arch/arm/mach-ep93xx/core.c

+0 −46
Original line number Diff line number Diff line
@@ -697,52 +697,6 @@ void __init ep93xx_register_keypad(struct ep93xx_keypad_platform_data *data) 
	platform_device_register(&ep93xx_keypad_device);

}



int ep93xx_keypad_acquire_gpio(struct platform_device *pdev)

{

	int err;

	int i;



	for (i = 0; i < 8; i++) {

		err = gpio_request(EP93XX_GPIO_LINE_C(i), dev_name(&pdev->dev));

		if (err)

			goto fail_gpio_c;

		err = gpio_request(EP93XX_GPIO_LINE_D(i), dev_name(&pdev->dev));

		if (err)

			goto fail_gpio_d;

	}



	/* Enable the keypad controller; GPIO ports C and D used for keypad */

	ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_KEYS |

				 EP93XX_SYSCON_DEVCFG_GONK);



	return 0;



fail_gpio_d:

	gpio_free(EP93XX_GPIO_LINE_C(i));

fail_gpio_c:

	for (--i; i >= 0; --i) {

		gpio_free(EP93XX_GPIO_LINE_C(i));

		gpio_free(EP93XX_GPIO_LINE_D(i));

	}

	return err;

}

EXPORT_SYMBOL(ep93xx_keypad_acquire_gpio);



void ep93xx_keypad_release_gpio(struct platform_device *pdev)

{

	int i;



	for (i = 0; i < 8; i++) {

		gpio_free(EP93XX_GPIO_LINE_C(i));

		gpio_free(EP93XX_GPIO_LINE_D(i));

	}



	/* Disable the keypad controller; GPIO ports C and D used for GPIO */

	ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_KEYS |

			       EP93XX_SYSCON_DEVCFG_GONK);

}

EXPORT_SYMBOL(ep93xx_keypad_release_gpio);



/*************************************************************************

 * EP93xx I2S audio peripheral handling

 *************************************************************************/

drivers/input/keyboard/ep93xx_keypad.c

+22 −52
Original line number Diff line number Diff line
@@ -6,20 +6,13 @@ 
 *

 * Based on the pxa27x matrix keypad controller by Rodolfo Giometti.

 *

 * NOTE:

 *

 * The 3-key reset is triggered by pressing the 3 keys in

 * Row 0, Columns 2, 4, and 7 at the same time.  This action can

 * be disabled by setting the EP93XX_KEYPAD_DISABLE_3_KEY flag.

 *

 * Normal operation for the matrix does not autorepeat the key press.

 * This action can be enabled by setting the EP93XX_KEYPAD_AUTOREPEAT

 * flag.

 */



#include <linux/bits.h>

#include <linux/mod_devicetable.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/property.h>

#include <linux/interrupt.h>

#include <linux/clk.h>

#include <linux/io.h>
@@ -27,7 +20,6 @@ 
#include <linux/input/matrix_keypad.h>

#include <linux/slab.h>

#include <linux/soc/cirrus/ep93xx.h>

#include <linux/platform_data/keypad-ep93xx.h>

#include <linux/pm_wakeirq.h>



/*
@@ -61,12 +53,16 @@ 
#define KEY_REG_KEY1_MASK	GENMASK(5, 0)

#define KEY_REG_KEY1_SHIFT	0



#define EP93XX_MATRIX_ROWS		(8)

#define EP93XX_MATRIX_COLS		(8)



#define EP93XX_MATRIX_SIZE	(EP93XX_MATRIX_ROWS * EP93XX_MATRIX_COLS)



struct ep93xx_keypad {

	struct ep93xx_keypad_platform_data *pdata;

	struct input_dev *input_dev;

	struct clk *clk;

	unsigned int debounce;

	u16 prescale;



	void __iomem *mmio_base;
@@ -133,23 +129,11 @@ static irqreturn_t ep93xx_keypad_irq_handler(int irq, void *dev_id) 


static void ep93xx_keypad_config(struct ep93xx_keypad *keypad)

{

	struct ep93xx_keypad_platform_data *pdata = keypad->pdata;

	unsigned int val = 0;



	clk_set_rate(keypad->clk, pdata->clk_rate);



	if (pdata->flags & EP93XX_KEYPAD_DISABLE_3_KEY)

		val |= KEY_INIT_DIS3KY;

	if (pdata->flags & EP93XX_KEYPAD_DIAG_MODE)

		val |= KEY_INIT_DIAG;

	if (pdata->flags & EP93XX_KEYPAD_BACK_DRIVE)

		val |= KEY_INIT_BACK;

	if (pdata->flags & EP93XX_KEYPAD_TEST_MODE)

		val |= KEY_INIT_T2;



	val |= ((pdata->debounce << KEY_INIT_DBNC_SHIFT) & KEY_INIT_DBNC_MASK);

	val |= (keypad->debounce << KEY_INIT_DBNC_SHIFT) & KEY_INIT_DBNC_MASK;



	val |= ((pdata->prescale << KEY_INIT_PRSCL_SHIFT) & KEY_INIT_PRSCL_MASK);

	val |= (keypad->prescale << KEY_INIT_PRSCL_SHIFT) & KEY_INIT_PRSCL_MASK;



	__raw_writel(val, keypad->mmio_base + KEY_INIT);

}
@@ -220,17 +204,10 @@ static int ep93xx_keypad_resume(struct device *dev) 
static DEFINE_SIMPLE_DEV_PM_OPS(ep93xx_keypad_pm_ops,

				ep93xx_keypad_suspend, ep93xx_keypad_resume);



static void ep93xx_keypad_release_gpio_action(void *_pdev)

{

	struct platform_device *pdev = _pdev;



	ep93xx_keypad_release_gpio(pdev);

}



static int ep93xx_keypad_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct ep93xx_keypad *keypad;

	const struct matrix_keymap_data *keymap_data;

	struct input_dev *input_dev;

	int err;
@@ -238,14 +215,6 @@ static int ep93xx_keypad_probe(struct platform_device *pdev) 
	if (!keypad)

		return -ENOMEM;



	keypad->pdata = dev_get_platdata(&pdev->dev);

	if (!keypad->pdata)

		return -EINVAL;



	keymap_data = keypad->pdata->keymap_data;

	if (!keymap_data)

		return -EINVAL;



	keypad->irq = platform_get_irq(pdev, 0);

	if (keypad->irq < 0)

		return keypad->irq;
@@ -254,19 +223,13 @@ static int ep93xx_keypad_probe(struct platform_device *pdev) 
	if (IS_ERR(keypad->mmio_base))

		return PTR_ERR(keypad->mmio_base);



	err = ep93xx_keypad_acquire_gpio(pdev);

	if (err)

		return err;



	err = devm_add_action_or_reset(&pdev->dev,

				       ep93xx_keypad_release_gpio_action, pdev);

	if (err)

		return err;



	keypad->clk = devm_clk_get(&pdev->dev, NULL);

	if (IS_ERR(keypad->clk))

		return PTR_ERR(keypad->clk);



	device_property_read_u32(dev, "debounce-delay-ms", &keypad->debounce);

	device_property_read_u16(dev, "cirrus,prescale", &keypad->prescale);



	input_dev = devm_input_allocate_device(&pdev->dev);

	if (!input_dev)

		return -ENOMEM;
@@ -278,13 +241,13 @@ static int ep93xx_keypad_probe(struct platform_device *pdev) 
	input_dev->open = ep93xx_keypad_open;

	input_dev->close = ep93xx_keypad_close;



	err = matrix_keypad_build_keymap(keymap_data, NULL,

	err = matrix_keypad_build_keymap(NULL, NULL,

					 EP93XX_MATRIX_ROWS, EP93XX_MATRIX_COLS,

					 keypad->keycodes, input_dev);

	if (err)

		return err;



	if (keypad->pdata->flags & EP93XX_KEYPAD_AUTOREPEAT)

	if (device_property_read_bool(&pdev->dev, "autorepeat"))

		__set_bit(EV_REP, input_dev->evbit);

	input_set_drvdata(input_dev, keypad);
@@ -313,10 +276,17 @@ static void ep93xx_keypad_remove(struct platform_device *pdev) 
	dev_pm_clear_wake_irq(&pdev->dev);

}



static const struct of_device_id ep93xx_keypad_of_ids[] = {

	{ .compatible = "cirrus,ep9307-keypad" },

	{ /* sentinel */ }

};

MODULE_DEVICE_TABLE(of, ep93xx_keypad_of_ids);



static struct platform_driver ep93xx_keypad_driver = {

	.driver		= {

		.name	= "ep93xx-keypad",

		.pm	= pm_sleep_ptr(&ep93xx_keypad_pm_ops),

		.of_match_table = ep93xx_keypad_of_ids,

	},

	.probe		= ep93xx_keypad_probe,

	.remove_new	= ep93xx_keypad_remove,

include/linux/soc/cirrus/ep93xx.h

+0 −4
Original line number Diff line number Diff line
@@ -41,8 +41,6 @@ int ep93xx_pwm_acquire_gpio(struct platform_device *pdev); 
void ep93xx_pwm_release_gpio(struct platform_device *pdev);

int ep93xx_ide_acquire_gpio(struct platform_device *pdev);

void ep93xx_ide_release_gpio(struct platform_device *pdev);

int ep93xx_keypad_acquire_gpio(struct platform_device *pdev);

void ep93xx_keypad_release_gpio(struct platform_device *pdev);

int ep93xx_i2s_acquire(void);

void ep93xx_i2s_release(void);

unsigned int ep93xx_chip_revision(void);
@@ -52,8 +50,6 @@ static inline int ep93xx_pwm_acquire_gpio(struct platform_device *pdev) { return 
static inline void ep93xx_pwm_release_gpio(struct platform_device *pdev) {}

static inline int ep93xx_ide_acquire_gpio(struct platform_device *pdev) { return 0; }

static inline void ep93xx_ide_release_gpio(struct platform_device *pdev) {}

static inline int ep93xx_keypad_acquire_gpio(struct platform_device *pdev) { return 0; }

static inline void ep93xx_keypad_release_gpio(struct platform_device *pdev) {}

static inline int ep93xx_i2s_acquire(void) { return 0; }

static inline void ep93xx_i2s_release(void) {}

static inline unsigned int ep93xx_chip_revision(void) { return 0; }