From mboxrd@z Thu Jan 1 00:00:00 1970 From: mathieu.poirier@linaro.org Subject: [PATCH v2] sysrq: supplementing reset sequence with timeout functionality Date: Sat, 16 Mar 2013 11:14:17 -0600 Message-ID: <1363454057-7409-1-git-send-email-mathieu.poirier@linaro.org> Return-path: Received: from mail-pb0-f41.google.com ([209.85.160.41]:33370 "EHLO mail-pb0-f41.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751313Ab3CPRN3 (ORCPT ); Sat, 16 Mar 2013 13:13:29 -0400 Received: by mail-pb0-f41.google.com with SMTP id um15so5159781pbc.14 for ; Sat, 16 Mar 2013 10:13:29 -0700 (PDT) Sender: linux-input-owner@vger.kernel.org List-Id: linux-input@vger.kernel.org To: dmitry.torokhov@gmail.com Cc: linux-input@vger.kernel.org, arve@android.com, kernel-team@android.com, john.stultz@linaro.org, mathieu.poirier@linaro.org From: "Mathieu J. Poirier" Some devices have too few buttons, which it makes it hard to have a reset combo that won't trigger automatically. As such a timeout functionality that requires the combination to be held for a given amount of time before triggering is introduced. If a key combo is recognized and held for a 'timeout' amount of time, the system triggers a reset. If the timeout value is omitted the driver simply ignores the functionality. Signed-off-by: Mathieu Poirier --- Changes for v2: - Replaced delayed_work with timer. - Made timer on per-device basis. - Removed unecessary parameter check macro. drivers/tty/sysrq.c | 40 +++++++++++++++++++++++++++++----------- 1 file changed, 29 insertions(+), 11 deletions(-) diff --git a/drivers/tty/sysrq.c b/drivers/tty/sysrq.c index 7953dfa..8e62062 100644 --- a/drivers/tty/sysrq.c +++ b/drivers/tty/sysrq.c @@ -42,6 +42,7 @@ #include #include #include +#include #include #include @@ -50,6 +51,9 @@ static int __read_mostly sysrq_enabled = SYSRQ_DEFAULT_ENABLE; static bool __read_mostly sysrq_always_enabled; +unsigned short platform_sysrq_reset_seq[] __weak = { KEY_RESERVED }; +int sysrq_downtime_ms __weak; + static bool sysrq_on(void) { return sysrq_enabled || sysrq_always_enabled; @@ -584,6 +588,7 @@ struct sysrq_state { int reset_seq_len; int reset_seq_cnt; int reset_seq_version; + struct timer_list keyreset_timeout; }; #define SYSRQ_KEY_RESET_MAX 20 /* Should be plenty */ @@ -617,7 +622,14 @@ static void sysrq_parse_reset_sequence(struct sysrq_state *state) state->reset_seq_version = sysrq_reset_seq_version; } -static bool sysrq_detect_reset_sequence(struct sysrq_state *state, +static void sysrq_handle_reset_request(struct sysrq_state *state) +{ + unsigned long expires = jiffies + msecs_to_jiffies(sysrq_downtime_ms); + state->keyreset_timeout.expires = expires; + add_timer(&state->keyreset_timeout); +} + +static void sysrq_detect_reset_sequence(struct sysrq_state *state, unsigned int code, int value) { if (!test_bit(code, state->reset_keybit)) { @@ -629,17 +641,22 @@ static bool sysrq_detect_reset_sequence(struct sysrq_state *state, state->reset_canceled = true; } else if (value == 0) { /* key release */ - if (--state->reset_seq_cnt == 0) + if (--state->reset_seq_cnt == 0) { state->reset_canceled = false; + del_timer(&state->keyreset_timeout); + } } else if (value == 1) { /* key press, not autorepeat */ if (++state->reset_seq_cnt == state->reset_seq_len && - !state->reset_canceled) { - return true; + !state->reset_canceled) { + sysrq_handle_reset_request(state); } } +} - return false; +static void sysrq_handle_reset_timeout(unsigned long data) +{ + __handle_sysrq(sysrq_xlate[KEY_B], false); } static void sysrq_reinject_alt_sysrq(struct work_struct *work) @@ -746,10 +763,8 @@ static bool sysrq_handle_keypress(struct sysrq_state *sysrq, if (was_active) schedule_work(&sysrq->reinject_work); - if (sysrq_detect_reset_sequence(sysrq, code, value)) { - /* Force emergency reboot */ - __handle_sysrq(sysrq_xlate[KEY_B], false); - } + /* Check for reset sequence */ + sysrq_detect_reset_sequence(sysrq, code, value); } else if (value == 0 && test_and_clear_bit(code, sysrq->key_down)) { /* @@ -810,6 +825,8 @@ static int sysrq_connect(struct input_handler *handler, sysrq->handle.handler = handler; sysrq->handle.name = "sysrq"; sysrq->handle.private = sysrq; + init_timer(&sysrq->keyreset_timeout); + sysrq->keyreset_timeout.function = sysrq_handle_reset_timeout; error = input_register_handle(&sysrq->handle); if (error) { @@ -839,6 +856,7 @@ static void sysrq_disconnect(struct input_handle *handle) input_close_device(handle); cancel_work_sync(&sysrq->reinject_work); + del_timer(&sysrq->keyreset_timeout); input_unregister_handle(handle); kfree(sysrq); } @@ -868,8 +886,6 @@ static struct input_handler sysrq_handler = { static bool sysrq_handler_registered; -unsigned short platform_sysrq_reset_seq[] __weak = { KEY_RESERVED }; - static inline void sysrq_register_handler(void) { unsigned short key; @@ -929,6 +945,8 @@ static struct kernel_param_ops param_ops_sysrq_reset_seq = { module_param_array_named(reset_seq, sysrq_reset_seq, sysrq_reset_seq, &sysrq_reset_seq_len, 0644); +module_param(sysrq_downtime_ms, int, 0644); + #else static inline void sysrq_register_handler(void) -- 1.7.9.5