| Message ID | 20200228171223.11444-4-tony@atomide.com (mailing list archive) |
|---|---|
| State | Superseded |
| Headers | show |
| Series | Lost key-up interrupt handling for omap4-keypad | expand |
On Fri, Feb 28, 2020 at 09:12:23AM -0800, Tony Lindgren wrote: > We only have partial errata i689 implemented with Commit 6c3516fed7b6 > ("Input: omap-keypad - fix keyboard debounce configuration"). We are > still missing the check for lost key-up interrupts as described in the > omap4 silicon errata documentation as Errata ID i689 "1.32 Keyboard Key > Up Event Can Be Missed": > > "When a key is released for a time shorter than the debounce time, > in-between 2 key press (KP1 and KP2), the keyboard state machine will go > to idle mode and will never detect the key release (after KP1, and also > after KP2), and thus will never generate a new IRQ indicating the key > release." > > Let's check the keyboard state with delayed_work after each event. And > if the problem state is detect, let's clear all events. > > Cc: Arthur Demchenkov <spinal.by@gmail.com> > Cc: Merlijn Wajer <merlijn@wizzup.org> > Cc: Pavel Machek <pavel@ucw.cz> > Cc: Sebastian Reichel <sre@kernel.org> > Signed-off-by: Tony Lindgren <tony@atomide.com> > --- > drivers/input/keyboard/omap4-keypad.c | 56 ++++++++++++++++++++++++--- > 1 file changed, 50 insertions(+), 6 deletions(-) > > diff --git a/drivers/input/keyboard/omap4-keypad.c b/drivers/input/keyboard/omap4-keypad.c > --- a/drivers/input/keyboard/omap4-keypad.c > +++ b/drivers/input/keyboard/omap4-keypad.c > @@ -71,6 +71,8 @@ struct omap4_keypad { > void __iomem *base; > bool irq_wake_enabled; > unsigned int irq; > + struct delayed_work key_work; > + struct mutex lock; /* for key scan */ I think having threaded interrupt and delayed work together defeats the purpose of having threaded interrupt. If you want to add a delay before repeating scan I think you can add it directly in omap4_keypad_irq_thread_fn(). Or is there a concern that we will not rely quickly enough on additional key presses? It is unclear to me if additional key press within the debounce time will result in additional interrupt. Thanks.
* Dmitry Torokhov <dmitry.torokhov@gmail.com> [200306 19:11]: > On Fri, Feb 28, 2020 at 09:12:23AM -0800, Tony Lindgren wrote: > > We only have partial errata i689 implemented with Commit 6c3516fed7b6 > > ("Input: omap-keypad - fix keyboard debounce configuration"). We are > > still missing the check for lost key-up interrupts as described in the > > omap4 silicon errata documentation as Errata ID i689 "1.32 Keyboard Key > > Up Event Can Be Missed": > > > > "When a key is released for a time shorter than the debounce time, > > in-between 2 key press (KP1 and KP2), the keyboard state machine will go > > to idle mode and will never detect the key release (after KP1, and also > > after KP2), and thus will never generate a new IRQ indicating the key > > release." > > > > Let's check the keyboard state with delayed_work after each event. And > > if the problem state is detect, let's clear all events. > > > > Cc: Arthur Demchenkov <spinal.by@gmail.com> > > Cc: Merlijn Wajer <merlijn@wizzup.org> > > Cc: Pavel Machek <pavel@ucw.cz> > > Cc: Sebastian Reichel <sre@kernel.org> > > Signed-off-by: Tony Lindgren <tony@atomide.com> > > --- > > drivers/input/keyboard/omap4-keypad.c | 56 ++++++++++++++++++++++++--- > > 1 file changed, 50 insertions(+), 6 deletions(-) > > > > diff --git a/drivers/input/keyboard/omap4-keypad.c b/drivers/input/keyboard/omap4-keypad.c > > --- a/drivers/input/keyboard/omap4-keypad.c > > +++ b/drivers/input/keyboard/omap4-keypad.c > > @@ -71,6 +71,8 @@ struct omap4_keypad { > > void __iomem *base; > > bool irq_wake_enabled; > > unsigned int irq; > > + struct delayed_work key_work; > > + struct mutex lock; /* for key scan */ > > I think having threaded interrupt and delayed work together defeats the > purpose of having threaded interrupt. If you want to add a delay before > repeating scan I think you can add it directly in > omap4_keypad_irq_thread_fn(). Or is there a concern that we will not > rely quickly enough on additional key presses? It is unclear to me if > additional key press within the debounce time will result in additional > interrupt. Well if we wait in threaded interrupt, we won't see a new interrupt. So yes, an additional key press will still produce an interrupt. After a key press has been detected, we need to set a timer that checks the keyboard controller state after it has idled. Then check for a potentially stuck state, and clear all down events if the state is idle with keys down. I don't think we can really use runtime PM autosuspend delay here as we already keep the device enabled with clock autogated so there's nothing to do. If we now added runtime PM calls, we'd end up in mode with clocks completely disabled. Maybe some tinkering of usage counts in the interrupt handler would allow using PM runtime though :) Regards, Tony
diff --git a/drivers/input/keyboard/omap4-keypad.c b/drivers/input/keyboard/omap4-keypad.c --- a/drivers/input/keyboard/omap4-keypad.c +++ b/drivers/input/keyboard/omap4-keypad.c @@ -71,6 +71,8 @@ struct omap4_keypad { void __iomem *base; bool irq_wake_enabled; unsigned int irq; + struct delayed_work key_work; + struct mutex lock; /* for key scan */ unsigned int rows; unsigned int cols; @@ -119,16 +121,22 @@ static irqreturn_t omap4_keypad_irq_handler(int irq, void *dev_id) return IRQ_NONE; } -static irqreturn_t omap4_keypad_irq_thread_fn(int irq, void *dev_id) +static bool omap4_keypad_scan_keys(struct omap4_keypad *keypad_data, bool clear) { - struct omap4_keypad *keypad_data = dev_id; struct input_dev *input_dev = keypad_data->input; unsigned char key_state[ARRAY_SIZE(keypad_data->key_state)]; unsigned int col, row, code, changed; - u32 *new_state = (u32 *) key_state; - - *new_state = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE31_0); - *(new_state + 1) = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE63_32); + u32 *rows_lo = (u32 *)key_state; + u32 *rows_hi = rows_lo + 1; + + mutex_lock(&keypad_data->lock); + if (clear) { + *rows_lo = 0; + *rows_hi = 0; + } else { + *rows_lo = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE31_0); + *rows_hi = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE63_32); + } for (row = 0; row < keypad_data->rows; row++) { changed = key_state[row] ^ keypad_data->key_state[row]; @@ -151,6 +159,20 @@ static irqreturn_t omap4_keypad_irq_thread_fn(int irq, void *dev_id) memcpy(keypad_data->key_state, key_state, sizeof(keypad_data->key_state)); + mutex_unlock(&keypad_data->lock); + + return *rows_lo || *rows_hi; +} + +static irqreturn_t omap4_keypad_irq_thread_fn(int irq, void *dev_id) +{ + struct omap4_keypad *keypad_data = dev_id; + bool events; + + events = omap4_keypad_scan_keys(keypad_data, false); + if (events) + schedule_delayed_work(&keypad_data->key_work, + msecs_to_jiffies(50)); /* clear pending interrupts */ kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS, @@ -159,6 +181,25 @@ static irqreturn_t omap4_keypad_irq_thread_fn(int irq, void *dev_id) return IRQ_HANDLED; } +/* + * Errata ID i689 "1.32 Keyboard Key Up Event Can Be Missed". + * Interrupt may not happen for key-up events. + */ +static void omap4_keypad_work(struct work_struct *work) +{ + struct omap4_keypad *keypad_data = + container_of(work, struct omap4_keypad, key_work.work); + bool events; + u32 active; + + active = kbd_readl(keypad_data, OMAP4_KBD_STATEMACHINE); + if (active) + return; + + dev_dbg(keypad_data->input->dev.parent, "idle with events\n"); + events = omap4_keypad_scan_keys(keypad_data, true); +} + static int omap4_keypad_open(struct input_dev *input) { struct omap4_keypad *keypad_data = input_get_drvdata(input); @@ -251,6 +292,8 @@ static int omap4_keypad_probe(struct platform_device *pdev) } keypad_data->irq = irq; + mutex_init(&keypad_data->lock); + INIT_DELAYED_WORK(&keypad_data->key_work, omap4_keypad_work); error = omap4_keypad_parse_dt(&pdev->dev, keypad_data); if (error) @@ -387,6 +430,7 @@ static int omap4_keypad_remove(struct platform_device *pdev) struct resource *res; free_irq(keypad_data->irq, keypad_data); + cancel_delayed_work_sync(&keypad_data->key_work); pm_runtime_disable(&pdev->dev);
We only have partial errata i689 implemented with Commit 6c3516fed7b6 ("Input: omap-keypad - fix keyboard debounce configuration"). We are still missing the check for lost key-up interrupts as described in the omap4 silicon errata documentation as Errata ID i689 "1.32 Keyboard Key Up Event Can Be Missed": "When a key is released for a time shorter than the debounce time, in-between 2 key press (KP1 and KP2), the keyboard state machine will go to idle mode and will never detect the key release (after KP1, and also after KP2), and thus will never generate a new IRQ indicating the key release." Let's check the keyboard state with delayed_work after each event. And if the problem state is detect, let's clear all events. Cc: Arthur Demchenkov <spinal.by@gmail.com> Cc: Merlijn Wajer <merlijn@wizzup.org> Cc: Pavel Machek <pavel@ucw.cz> Cc: Sebastian Reichel <sre@kernel.org> Signed-off-by: Tony Lindgren <tony@atomide.com> --- drivers/input/keyboard/omap4-keypad.c | 56 ++++++++++++++++++++++++--- 1 file changed, 50 insertions(+), 6 deletions(-)