From patchwork Mon Jan 21 13:15:14 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ivan Khoronzhuk X-Patchwork-Id: 2012251 Return-Path: X-Original-To: patchwork-linux-input@patchwork.kernel.org Delivered-To: patchwork-process-083081@patchwork1.kernel.org Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by patchwork1.kernel.org (Postfix) with ESMTP id D901C3FDD2 for ; Mon, 21 Jan 2013 13:16:32 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754034Ab3AUNQc (ORCPT ); Mon, 21 Jan 2013 08:16:32 -0500 Received: from devils.ext.ti.com ([198.47.26.153]:35137 "EHLO devils.ext.ti.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753987Ab3AUNQb (ORCPT ); Mon, 21 Jan 2013 08:16:31 -0500 Received: from dlelxv30.itg.ti.com ([172.17.2.17]) by devils.ext.ti.com (8.13.7/8.13.7) with ESMTP id r0LDFgfu028545; Mon, 21 Jan 2013 07:15:42 -0600 Received: from DFLE73.ent.ti.com (dfle73.ent.ti.com [128.247.5.110]) by dlelxv30.itg.ti.com (8.13.8/8.13.8) with ESMTP id r0LDFgE2017380; Mon, 21 Jan 2013 07:15:42 -0600 Received: from dlelxv22.itg.ti.com (172.17.1.197) by dfle73.ent.ti.com (128.247.5.110) with Microsoft SMTP Server id 14.1.323.3; Mon, 21 Jan 2013 07:15:42 -0600 Received: from uglx0177649.ucm2.emeaucm.ext.ti.com (uglx0177649.ucm2.emeaucm.ext.ti.com [10.167.145.128]) by dlelxv22.itg.ti.com (8.13.8/8.13.8) with ESMTP id r0LDFdSw017108; Mon, 21 Jan 2013 07:15:40 -0600 From: Ivan Khoronzhuk To: CC: , Bengt Jonsson , NeilBrown , Mark Brown , Bill Pemberton , Dmitry Torokhov , Ivan Khoronzhuk Subject: [RFC PATCH] Input: gpio_keys: Fix suspend/resume press event lost Date: Mon, 21 Jan 2013 15:15:14 +0200 Message-ID: <1358774114-8281-1-git-send-email-ivan.khoronzhuk@ti.com> X-Mailer: git-send-email 1.7.9.5 MIME-Version: 1.0 Sender: linux-input-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org Rebased on linux_omap/master. During suspend/resume the key press can be lost if time of resume sequence is significant. If press event cannot be remembered then the driver can read the current button state only in time of interrupt handling. But in some cases when time between IRQ and IRQ handler is significant we can read incorrect state. As a particular case, when device is in suspend we press wakupable key and up it back in a jiffy, the interrupt handler read the state of up but the interrupt source is press indeed. As a result, in a OS like android, we resume then suspend right away because the key state is not changed. This patch add to gpio_keys framework opportunity to recover lost of press key event at resuming. The variable "key_pressed" from gpio_button_data structure is not used for gpio keys, it is only used for gpio irq keys, so it is logically used to remember press lost while resuming. Signed-off-by: Ivan Khoronzhuk --- drivers/input/keyboard/gpio_keys.c | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c index b29ca65..33ac8c5 100644 --- a/drivers/input/keyboard/gpio_keys.c +++ b/drivers/input/keyboard/gpio_keys.c @@ -45,6 +45,7 @@ struct gpio_button_data { struct gpio_keys_drvdata { const struct gpio_keys_platform_data *pdata; struct input_dev *input; + int suspended; struct mutex disable_lock; struct gpio_button_data data[0]; }; @@ -326,14 +327,40 @@ static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata) { const struct gpio_keys_button *button = bdata->button; struct input_dev *input = bdata->input; + struct gpio_keys_drvdata *ddata = input_get_drvdata(input); unsigned int type = button->type ?: EV_KEY; int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low; + /* + * Don't generate input event while resuming, + * it will be generated at gpio_keys_resume function + */ + if (ddata->suspended) { + /* + * missed press event while resuming so set + * key_pressed flag to generate press and up events + * while gpio_keys_resume function. + */ + if (button->wakeup && state == 0) + bdata->key_pressed = 1; + return; + } + if (type == EV_ABS) { if (state) input_event(input, type, button->code, button->value); } else { - input_event(input, type, button->code, !!state); + /* + * missed press key, so generate press event then up event + */ + if (bdata->key_pressed) { + input_event(bdata->input, EV_KEY, button->code, 1); + input_sync(bdata->input); + input_event(bdata->input, EV_KEY, button->code, 0); + bdata->key_pressed = 0; + } else { + input_event(input, type, button->code, !!state); + } } input_sync(input); } @@ -822,6 +849,7 @@ static int gpio_keys_suspend(struct device *dev) mutex_unlock(&input->mutex); } + ddata->suspended = 1; return 0; } @@ -832,6 +860,7 @@ static int gpio_keys_resume(struct device *dev) int error = 0; int i; + ddata->suspended = 0; if (device_may_wakeup(dev)) { for (i = 0; i < ddata->pdata->nbuttons; i++) { struct gpio_button_data *bdata = &ddata->data[i];