From patchwork Sat Mar 16 17:14:17 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 2282351 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 EFA3B4006E for ; Sat, 16 Mar 2013 17:13:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751569Ab3CPRNa (ORCPT ); Sat, 16 Mar 2013 13:13:30 -0400 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) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=x-received:from:to:cc:subject:date:message-id:x-mailer :x-gm-message-state; bh=GZIQHgnFaOlfm7iV2mqQ6G736cyqIGZoNjUkj9FENdY=; b=Mo1fV8KbLF7+uTSZ6NLjo7jxdckxhDFPRDYgGH07//Taik29VMczGnsPUNa7cV1kzZ K/Bwyg6Kmy2fF442q4ByEtUhqNFtdPBKma8JwgwHh9hzjNba8s8w/yC9cvZ5m8fJymyf pfPspot8ovc3dlQurJxG3tk1s167VWSmS6npksKOuCkqx8Dn/JDrufEiwgH8zUuwGQiB mUnDn2XgUTMYcIFKJsBNOyTeOOmksnfa+9Icer//3mx6Ysenf1Mj6WlvweDEICyQwemH aP/9OnfHsQJ9h4rjfu91XGOrSKmgljU9e7mvo/WcblZVswZ85U0MKm2kLylaMjEIpJ4S JQlw== X-Received: by 10.66.117.76 with SMTP id kc12mr2265653pab.96.1363454009251; Sat, 16 Mar 2013 10:13:29 -0700 (PDT) Received: from black.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [70.73.24.112]) by mx.google.com with ESMTPS id xl10sm1570147pac.15.2013.03.16.10.13.27 (version=TLSv1.1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Sat, 16 Mar 2013 10:13:28 -0700 (PDT) From: mathieu.poirier@linaro.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 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> X-Mailer: git-send-email 1.7.9.5 X-Gm-Message-State: ALoCoQkUUMUE7JL9x8rMIsktBzOXNL9hcrY/0l2c/Tt8fJuiS4Uadwzx2Z1niRXYE4fdBTaJEoXk Sender: linux-input-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.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)