From patchwork Wed Sep 2 23:25:45 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lina Iyer X-Patchwork-Id: 293049 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-12.8 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH, MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D0BCAC43461 for ; Wed, 2 Sep 2020 23:27:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id B0A86207D3 for ; Wed, 2 Sep 2020 23:27:19 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mg.codeaurora.org header.i=@mg.codeaurora.org header.b="iOvJYaeu" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726821AbgIBX1T (ORCPT ); Wed, 2 Sep 2020 19:27:19 -0400 Received: from mail29.static.mailgun.info ([104.130.122.29]:35991 "EHLO mail29.static.mailgun.info" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726814AbgIBX1S (ORCPT ); Wed, 2 Sep 2020 19:27:18 -0400 DKIM-Signature: a=rsa-sha256; v=1; c=relaxed/relaxed; d=mg.codeaurora.org; q=dns/txt; s=smtp; t=1599089238; h=Content-Transfer-Encoding: MIME-Version: References: In-Reply-To: Message-Id: Date: Subject: Cc: To: From: Sender; bh=jXEY6z5/Ir9K9+hi+VNDv+eb6ICgVav+y77gSTmbm+4=; b=iOvJYaeu+AA1WcACUc8cEHJif4/wUXLD14+N7qdVjw/2TvPXYDVXe847ksNRt8CCbf6VzWzu ijszwHRx+5hzSOQ8VFtepAiX0bVLUULLfLZ0vkA8O4L5v7Xgv5Opy9n/d2kTQtPT1lZgshJM 131DWQwWl742oqf2/OGd0ZoyFSw= X-Mailgun-Sending-Ip: 104.130.122.29 X-Mailgun-Sid: WyI1MzIzYiIsICJsaW51eC1hcm0tbXNtQHZnZXIua2VybmVsLm9yZyIsICJiZTllNGEiXQ== Received: from smtp.codeaurora.org (ec2-35-166-182-171.us-west-2.compute.amazonaws.com [35.166.182.171]) by smtp-out-n02.prod.us-east-1.postgun.com with SMTP id 5f502a3e885efaea0a4e22d1 (version=TLS1.2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256); Wed, 02 Sep 2020 23:26:50 GMT Received: by smtp.codeaurora.org (Postfix, from userid 1001) id D53B9C433A0; Wed, 2 Sep 2020 23:26:49 +0000 (UTC) Received: from codeaurora.org (i-global254.qualcomm.com [199.106.103.254]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: ilina) by smtp.codeaurora.org (Postfix) with ESMTPSA id 990F9C433CA; Wed, 2 Sep 2020 23:26:48 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org 990F9C433CA Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; spf=none smtp.mailfrom=ilina@codeaurora.org From: Lina Iyer To: rjw@rjwysocki.net, ulf.hansson@linaro.org, linux-pm@vger.kernel.org Cc: linux-arm-msm@vger.kernel.org, Lina Iyer Subject: [RFC PATCH 1/2] PM / runtime: register device's next wakeup Date: Wed, 2 Sep 2020 17:25:45 -0600 Message-Id: <20200902232546.31240-2-ilina@codeaurora.org> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200902232546.31240-1-ilina@codeaurora.org> References: <20200902232546.31240-1-ilina@codeaurora.org> MIME-Version: 1.0 Sender: linux-arm-msm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org Some devices have a predictable interrupt pattern while executing a particular usecase. An example would be the VSYNC interrupt on devices associated with displays. A 60 Hz display could cause a periodic interrupt every 16 ms. A PM domain that holds such a device could power off and on at similar intervals. But when the domain is a supplier for multiple such devices, the idle pattern for the domain is bit muddled, but still deducible. If the next wakeup is known for all devices in a domain, it becomes easy to find out the sleep duration for the domain. By allowing drivers to notify runtime PM of their device's future wakeup, we can make better PM domain governor idle state decisions when powering off the domain. For now, let's allow updating the device's next wake up as long as runtime PM is enabled. If the device is runtime suspended, the domain could be as well and we don't want to wake up the domain to recompute the domain idle state. As a first step, the onus is on the drivers to update their device's wakeup correctly before the device and the domain enter runtime idle. Signed-off-by: Lina Iyer --- drivers/base/power/runtime.c | 31 +++++++++++++++++++++++++++++++ include/linux/pm.h | 2 ++ include/linux/pm_runtime.h | 1 + 3 files changed, 34 insertions(+) diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c index 8143210a5c54..53c2b3d962bc 100644 --- a/drivers/base/power/runtime.c +++ b/drivers/base/power/runtime.c @@ -122,6 +122,33 @@ u64 pm_runtime_suspended_time(struct device *dev) } EXPORT_SYMBOL_GPL(pm_runtime_suspended_time); +/** + * pm_runtime_set_next_wakeup_event - Notify PM framework of an impending event. + * @dev: Device to handle + * @next: impending interrupt/wakeup for the device + */ +int pm_runtime_set_next_event(struct device *dev, ktime_t next) +{ + unsigned long flags; + int ret = -EINVAL; + + /* + * Note the next pending wakeup of a device, + * if the device does not have runtime PM enabled. + */ + spin_lock_irqsave(&dev->power.lock, flags); + if (!dev->power.disable_depth) { + if (ktime_before(ktime_get(), next)) { + dev->power.next_event = next; + ret = 0; + } + } + spin_unlock_irqrestore(&dev->power.lock, flags); + + return ret; +} +EXPORT_SYMBOL_GPL(pm_runtime_set_next_event); + /** * pm_runtime_deactivate_timer - Deactivate given device's suspend timer. * @dev: Device to handle. @@ -1380,6 +1407,9 @@ void __pm_runtime_disable(struct device *dev, bool check_resume) /* Update time accounting before disabling PM-runtime. */ update_pm_runtime_accounting(dev); + /* Reset the next wakeup for the device */ + dev->power.next_event = KTIME_MAX; + if (!dev->power.disable_depth++) __pm_runtime_barrier(dev); @@ -1609,6 +1639,7 @@ void pm_runtime_init(struct device *dev) dev->power.deferred_resume = false; INIT_WORK(&dev->power.work, pm_runtime_work); + dev->power.next_event = KTIME_MAX; dev->power.timer_expires = 0; hrtimer_init(&dev->power.suspend_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS); dev->power.suspend_timer.function = pm_suspend_timer_fn; diff --git a/include/linux/pm.h b/include/linux/pm.h index a30a4b54df52..9051658674a4 100644 --- a/include/linux/pm.h +++ b/include/linux/pm.h @@ -8,6 +8,7 @@ #ifndef _LINUX_PM_H #define _LINUX_PM_H +#include #include #include #include @@ -616,6 +617,7 @@ struct dev_pm_info { u64 active_time; u64 suspended_time; u64 accounting_timestamp; + ktime_t next_event; #endif struct pm_subsys_data *subsys_data; /* Owned by the subsystem. */ void (*set_latency_tolerance)(struct device *, s32); diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h index 6245caa18034..af6d35178335 100644 --- a/include/linux/pm_runtime.h +++ b/include/linux/pm_runtime.h @@ -59,6 +59,7 @@ extern void pm_runtime_get_suppliers(struct device *dev); extern void pm_runtime_put_suppliers(struct device *dev); extern void pm_runtime_new_link(struct device *dev); extern void pm_runtime_drop_link(struct device *dev); +extern int pm_runtime_set_next_event(struct device *dev, ktime_t next); /** * pm_runtime_get_if_in_use - Conditionally bump up runtime PM usage counter. From patchwork Wed Sep 2 23:25:46 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lina Iyer X-Patchwork-Id: 293050 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-12.8 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH, MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 902D7C433E2 for ; Wed, 2 Sep 2020 23:27:00 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 63D552078E for ; Wed, 2 Sep 2020 23:27:00 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mg.codeaurora.org header.i=@mg.codeaurora.org header.b="pe7gqPA6" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726853AbgIBX07 (ORCPT ); Wed, 2 Sep 2020 19:26:59 -0400 Received: from m43-7.mailgun.net ([69.72.43.7]:41827 "EHLO m43-7.mailgun.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726312AbgIBX07 (ORCPT ); Wed, 2 Sep 2020 19:26:59 -0400 DKIM-Signature: a=rsa-sha256; v=1; c=relaxed/relaxed; d=mg.codeaurora.org; q=dns/txt; s=smtp; t=1599089217; h=Content-Transfer-Encoding: MIME-Version: References: In-Reply-To: Message-Id: Date: Subject: Cc: To: From: Sender; bh=34yRl6SFaHTyY3yXT+BcH3cX7lVCd0YuybGYSb/eyPw=; b=pe7gqPA6j4Wyfhxh5f4d8Mu8M5TesVVyD6ZoYsBeKAHNCjC9jCNGrfdLDfaxi+WarMVu/EWF b1yFhXWm0Ox72RU/GhHTn7Qt5DKxQ6MiZI0fkvk5fJ/1+NmNmfpxgmVHud8lh08ABEkJJd4/ O6vtDKi4rEo4XqQpWDKn9aoRwPM= X-Mailgun-Sending-Ip: 69.72.43.7 X-Mailgun-Sid: WyI1MzIzYiIsICJsaW51eC1hcm0tbXNtQHZnZXIua2VybmVsLm9yZyIsICJiZTllNGEiXQ== Received: from smtp.codeaurora.org (ec2-35-166-182-171.us-west-2.compute.amazonaws.com [35.166.182.171]) by smtp-out-n01.prod.us-east-1.postgun.com with SMTP id 5f502a3b73afa3417eb8cc7f (version=TLS1.2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256); Wed, 02 Sep 2020 23:26:51 GMT Received: by smtp.codeaurora.org (Postfix, from userid 1001) id 49EC4C433A1; Wed, 2 Sep 2020 23:26:50 +0000 (UTC) Received: from codeaurora.org (i-global254.qualcomm.com [199.106.103.254]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: ilina) by smtp.codeaurora.org (Postfix) with ESMTPSA id 5A748C43391; Wed, 2 Sep 2020 23:26:49 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org 5A748C43391 Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; spf=none smtp.mailfrom=ilina@codeaurora.org From: Lina Iyer To: rjw@rjwysocki.net, ulf.hansson@linaro.org, linux-pm@vger.kernel.org Cc: linux-arm-msm@vger.kernel.org, Lina Iyer Subject: [RFC PATCH 2/2] PM / Domains: use device's next wakeup to determine domain idle state Date: Wed, 2 Sep 2020 17:25:46 -0600 Message-Id: <20200902232546.31240-3-ilina@codeaurora.org> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200902232546.31240-1-ilina@codeaurora.org> References: <20200902232546.31240-1-ilina@codeaurora.org> MIME-Version: 1.0 Sender: linux-arm-msm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org If the device's next event is known, determine if it is worthwhile entering a domain idle state. To find the next wakeup, traverse a domain for all child devices and find out the earliest wakeup value. A parent domain's next wakeup is the earliest of all its child devices and domains. The next wakeup is specified by devices in the domains before they devices are suspended. Update the domain governor logic to determine if it is worthwhile to enter an idle state based on the next wakeup for the domain along with other existing constraints. Signed-off-by: Lina Iyer --- drivers/base/power/domain_governor.c | 87 ++++++++++++++++++++++++++-- include/linux/pm_domain.h | 1 + 2 files changed, 82 insertions(+), 6 deletions(-) diff --git a/drivers/base/power/domain_governor.c b/drivers/base/power/domain_governor.c index 490ed7deb99a..a71d7281e9c1 100644 --- a/drivers/base/power/domain_governor.c +++ b/drivers/base/power/domain_governor.c @@ -117,6 +117,56 @@ static bool default_suspend_ok(struct device *dev) return td->cached_suspend_ok; } +static void update_domain_next_wakeup(struct generic_pm_domain *genpd, ktime_t now) +{ + ktime_t domain_wakeup = KTIME_MAX; + ktime_t next_wakeup; + struct pm_domain_data *pdd; + struct gpd_link *link; + + /* Find the earliest wakeup for all devices in the domain */ + list_for_each_entry(pdd, &genpd->dev_list, list_node) { + if (pdd->dev->power.next_event != KTIME_MAX && + !ktime_before(pdd->dev->power.next_event, now)) { + next_wakeup = READ_ONCE(pdd->dev->power.next_event); + if (ktime_before(next_wakeup, domain_wakeup)) + domain_wakeup = next_wakeup; + } + } + + /* Then find the earliest wakeup of from all the child domains */ + list_for_each_entry(link, &genpd->parent_links, parent_node) { + struct generic_pm_domain *sd = link->child; + + next_wakeup = sd->next_wakeup; + if (next_wakeup != KTIME_MAX && !ktime_before(next_wakeup, now)) + if (ktime_before(next_wakeup, domain_wakeup)) + domain_wakeup = next_wakeup; + } + + genpd->next_wakeup = domain_wakeup; +} + +static bool next_wakeup_allows_state(struct generic_pm_domain *genpd, + unsigned int state, ktime_t now) +{ + s64 idle_time_ns, min_sleep_ns; + ktime_t domain_wakeup = genpd->next_wakeup; + + if (domain_wakeup == KTIME_MAX) + return true; + + min_sleep_ns = genpd->states[state].power_off_latency_ns + + genpd->states[state].power_on_latency_ns + + genpd->states[state].residency_ns; + + idle_time_ns = ktime_to_ns(ktime_sub(domain_wakeup, now)); + if (idle_time_ns < min_sleep_ns) + return false; + + return true; +} + static bool __default_power_down_ok(struct dev_pm_domain *pd, unsigned int state) { @@ -210,6 +260,29 @@ static bool default_power_down_ok(struct dev_pm_domain *pd) { struct generic_pm_domain *genpd = pd_to_genpd(pd); struct gpd_link *link; + unsigned int state_idx; + ktime_t now = ktime_get(); + + /* + * Find the next wakeup from devices that can determine their own wakeup + * to find when the domain would wakeup and do it for every device down + * the hierarchy. It is not worth while to sleep if the state's residency + * cannot be met. + */ + update_domain_next_wakeup(genpd, now); + + /* Let's find out what domain idle state, the devices prefer */ + genpd->state_idx = state_idx = genpd->state_count - 1; + while (!next_wakeup_allows_state(genpd, state_idx, now)) { + if (!state_idx) { + genpd->cached_power_down_ok = false; + return false; + } + state_idx--; + } + + genpd->max_off_time_changed = + (state_idx == genpd->cached_power_down_state_idx); if (!genpd->max_off_time_changed) { genpd->state_idx = genpd->cached_power_down_state_idx; @@ -228,18 +301,20 @@ static bool default_power_down_ok(struct dev_pm_domain *pd) genpd->max_off_time_ns = -1; genpd->max_off_time_changed = false; genpd->cached_power_down_ok = true; - genpd->state_idx = genpd->state_count - 1; - /* Find a state to power down to, starting from the deepest. */ - while (!__default_power_down_ok(pd, genpd->state_idx)) { - if (genpd->state_idx == 0) { + /* Find a state to power down to, starting from the state + * determined by the next wakeup. + */ + while (!__default_power_down_ok(pd, state_idx)) { + if (state_idx == 0) { genpd->cached_power_down_ok = false; break; } - genpd->state_idx--; + state_idx--; } - genpd->cached_power_down_state_idx = genpd->state_idx; + genpd->state_idx = state_idx; + genpd->cached_power_down_state_idx = state_idx; return genpd->cached_power_down_ok; } diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h index ee11502a575b..9ea6f666967b 100644 --- a/include/linux/pm_domain.h +++ b/include/linux/pm_domain.h @@ -119,6 +119,7 @@ struct generic_pm_domain { unsigned int state); struct gpd_dev_ops dev_ops; s64 max_off_time_ns; /* Maximum allowed "suspended" time. */ + ktime_t next_wakeup; bool max_off_time_changed; bool cached_power_down_ok; bool cached_power_down_state_idx;