Skip to content

Commit

Permalink
Input: matrix_keypad - add support for clustered irq
Browse files Browse the repository at this point in the history 
This one adds support of a combined irq source for the whole matrix keypad.
This can be useful if all rows and columns of the keypad are e.g. connected
to a GPIO expander, which only has one interrupt line for all events on
every single GPIO.

Signed-off-by: Luotao Fu <l.fu@pengutronix.de>
Acked-by: Eric Miao <eric.y.miao@gmail.com>
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
  • Loading branch information
Luotao Fu authored and Dmitry Torokhov committed Jun 10, 2010
1 parent 1719ec4 commit fb76dd1
Show file tree
Hide file tree
Showing 2 changed files with 86 additions and 28 deletions.
108 changes: 80 additions & 28 deletions drivers/input/keyboard/matrix_keypad.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,6 +37,7 @@ struct matrix_keypad {
spinlock_t lock;
bool scan_pending;
bool stopped;
bool gpio_all_disabled;
};

/*
Expand Down Expand Up @@ -87,17 +88,25 @@ static void enable_row_irqs(struct matrix_keypad *keypad)
const struct matrix_keypad_platform_data *pdata = keypad->pdata;
int i;

for (i = 0; i < pdata->num_row_gpios; i++)
enable_irq(gpio_to_irq(pdata->row_gpios[i]));
if (pdata->clustered_irq > 0)
enable_irq(pdata->clustered_irq);
else {
for (i = 0; i < pdata->num_row_gpios; i++)
enable_irq(gpio_to_irq(pdata->row_gpios[i]));
}
}

static void disable_row_irqs(struct matrix_keypad *keypad)
{
const struct matrix_keypad_platform_data *pdata = keypad->pdata;
int i;

for (i = 0; i < pdata->num_row_gpios; i++)
disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
if (pdata->clustered_irq > 0)
disable_irq_nosync(pdata->clustered_irq);
else {
for (i = 0; i < pdata->num_row_gpios; i++)
disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
}
}

/*
Expand Down Expand Up @@ -216,45 +225,69 @@ static void matrix_keypad_stop(struct input_dev *dev)
}

#ifdef CONFIG_PM
static int matrix_keypad_suspend(struct device *dev)
static void matrix_keypad_enable_wakeup(struct matrix_keypad *keypad)
{
struct platform_device *pdev = to_platform_device(dev);
struct matrix_keypad *keypad = platform_get_drvdata(pdev);
const struct matrix_keypad_platform_data *pdata = keypad->pdata;
unsigned int gpio;
int i;

matrix_keypad_stop(keypad->input_dev);
if (pdata->clustered_irq > 0) {
if (enable_irq_wake(pdata->clustered_irq) == 0)
keypad->gpio_all_disabled = true;
} else {

if (device_may_wakeup(&pdev->dev)) {
for (i = 0; i < pdata->num_row_gpios; i++) {
if (!test_bit(i, keypad->disabled_gpios)) {
unsigned int gpio = pdata->row_gpios[i];
gpio = pdata->row_gpios[i];

if (enable_irq_wake(gpio_to_irq(gpio)) == 0)
__set_bit(i, keypad->disabled_gpios);
}
}
}

return 0;
}

static int matrix_keypad_resume(struct device *dev)
static void matrix_keypad_disable_wakeup(struct matrix_keypad *keypad)
{
struct platform_device *pdev = to_platform_device(dev);
struct matrix_keypad *keypad = platform_get_drvdata(pdev);
const struct matrix_keypad_platform_data *pdata = keypad->pdata;
unsigned int gpio;
int i;

if (device_may_wakeup(&pdev->dev)) {
if (pdata->clustered_irq > 0) {
if (keypad->gpio_all_disabled) {
disable_irq_wake(pdata->clustered_irq);
keypad->gpio_all_disabled = false;
}
} else {
for (i = 0; i < pdata->num_row_gpios; i++) {
if (test_and_clear_bit(i, keypad->disabled_gpios)) {
unsigned int gpio = pdata->row_gpios[i];

gpio = pdata->row_gpios[i];
disable_irq_wake(gpio_to_irq(gpio));
}
}
}
}

static int matrix_keypad_suspend(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct matrix_keypad *keypad = platform_get_drvdata(pdev);

matrix_keypad_stop(keypad->input_dev);

if (device_may_wakeup(&pdev->dev))
matrix_keypad_enable_wakeup(keypad);

return 0;
}

static int matrix_keypad_resume(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct matrix_keypad *keypad = platform_get_drvdata(pdev);

if (device_may_wakeup(&pdev->dev))
matrix_keypad_disable_wakeup(keypad);

matrix_keypad_start(keypad->input_dev);

Expand Down Expand Up @@ -296,17 +329,31 @@ static int __devinit init_matrix_gpio(struct platform_device *pdev,
gpio_direction_input(pdata->row_gpios[i]);
}

for (i = 0; i < pdata->num_row_gpios; i++) {
err = request_irq(gpio_to_irq(pdata->row_gpios[i]),
if (pdata->clustered_irq > 0) {
err = request_irq(pdata->clustered_irq,
matrix_keypad_interrupt,
IRQF_DISABLED |
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
pdata->clustered_irq_flags,
"matrix-keypad", keypad);
if (err) {
dev_err(&pdev->dev,
"Unable to acquire interrupt for GPIO line %i\n",
pdata->row_gpios[i]);
goto err_free_irqs;
"Unable to acquire clustered interrupt\n");
goto err_free_rows;
}
} else {
for (i = 0; i < pdata->num_row_gpios; i++) {
err = request_irq(gpio_to_irq(pdata->row_gpios[i]),
matrix_keypad_interrupt,
IRQF_DISABLED |
IRQF_TRIGGER_RISING |
IRQF_TRIGGER_FALLING,
"matrix-keypad", keypad);
if (err) {
dev_err(&pdev->dev,
"Unable to acquire interrupt "
"for GPIO line %i\n",
pdata->row_gpios[i]);
goto err_free_irqs;
}
}
}

Expand Down Expand Up @@ -418,11 +465,16 @@ static int __devexit matrix_keypad_remove(struct platform_device *pdev)

device_init_wakeup(&pdev->dev, 0);

for (i = 0; i < pdata->num_row_gpios; i++) {
free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
gpio_free(pdata->row_gpios[i]);
if (pdata->clustered_irq > 0) {
free_irq(pdata->clustered_irq, keypad);
} else {
for (i = 0; i < pdata->num_row_gpios; i++)
free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
}

for (i = 0; i < pdata->num_row_gpios; i++)
gpio_free(pdata->row_gpios[i]);

for (i = 0; i < pdata->num_col_gpios; i++)
gpio_free(pdata->col_gpios[i]);

Expand Down
6 changes: 6 additions & 0 deletions include/linux/input/matrix_keypad.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,6 +41,9 @@ struct matrix_keymap_data {
* @col_scan_delay_us: delay, measured in microseconds, that is
* needed before we can keypad after activating column gpio
* @debounce_ms: debounce interval in milliseconds
* @clustered_irq: may be specified if interrupts of all row/column GPIOs
* are bundled to one single irq
* @clustered_irq_flags: flags that are needed for the clustered irq
* @active_low: gpio polarity
* @wakeup: controls whether the device should be set up as wakeup
* source
Expand All @@ -63,6 +66,9 @@ struct matrix_keypad_platform_data {
/* key debounce interval in milli-second */
unsigned int debounce_ms;

unsigned int clustered_irq;
unsigned int clustered_irq_flags;

bool active_low;
bool wakeup;
bool no_autorepeat;
Expand Down

0 comments on commit fb76dd1

Please sign in to comment.