From patchwork Tue Nov 3 15:06:25 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ulf Hansson X-Patchwork-Id: 315226 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_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH, MAILING_LIST_MULTI, SIGNED_OFF_BY, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, 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 6F60AC2D0A3 for ; Tue, 3 Nov 2020 15:07:45 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1820A223EA for ; Tue, 3 Nov 2020 15:07:45 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="bhgffm5o" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728183AbgKCPHo (ORCPT ); Tue, 3 Nov 2020 10:07:44 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53022 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728103AbgKCPGm (ORCPT ); Tue, 3 Nov 2020 10:06:42 -0500 Received: from mail-lf1-x142.google.com (mail-lf1-x142.google.com [IPv6:2a00:1450:4864:20::142]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CBD4FC0613D1 for ; Tue, 3 Nov 2020 07:06:41 -0800 (PST) Received: by mail-lf1-x142.google.com with SMTP id l28so22571603lfp.10 for ; Tue, 03 Nov 2020 07:06:41 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ueiVlvCkRERA4jFBXY1LOeFsJ+G2JGqDIygbStmt2x4=; b=bhgffm5oQBW+6fiSHYCs6cMG+QkEaPHFd8ayqp4qY5zdtYkfBN2A+kFDYhKWnmfXzC j31r1S3NxiL6kuZsmKzUYk3FcmMlgywkkt8fF5kDxv0SV8wOTLMywc9VNNorK9LWJbdY c0jaEBrXboRtNdLTy2dEGzEl5e95vlr7fOWCbiREMddju+X5bn7IIePh1uxU2R01scl5 Vtqvr6G3wMJPKZWQG4Vm6V5zPfQXKqWrs2bMn3vqRN6Xbh6KEfiZXqyBxcpJ08QUjLYt BQhwZ1okgi1J9Cn3QOOVooDMLTvpRiX52jRnjz2T3hlha2XPCUFAsKXH1QyhVIfpEn3o keMA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ueiVlvCkRERA4jFBXY1LOeFsJ+G2JGqDIygbStmt2x4=; b=iX06mYNVZFsTRBlHG8W8jfU2EgHBoTSpvLPd3kqico+sKJo3ScD2Cj8lHMHpDvw4a/ sh3X6/8jnTJM+ZKb46ts2eyJLw4xJeedZIBtERQgzF37AeFghRkJPAG5lgjPPwDFYQ45 A3puAyYfq4zJ3s/GaUn+RWCJBwLBxRyzKQdSm//YJ6Hq6VcDy+87Vmyuax0tmN9lK44S AVvV5ctSiulygQIvVUR+1nOf5vRqXk9+BMGofMG0z5Kj1vcnVpIpLXntbLah97tmWdnZ 2eYZRbngWga79ownFyL2Lzi7GT200DCr/zzclaq5Jgf4effb0zYX5fHkBrAwF9USU5Z/ rokQ== X-Gm-Message-State: AOAM531sLiXBQsb4MZr/k+1Spz1PNLjpnxhCmHugxiQGnXAnCBBNfL6w YBOkP+4Vb9PNlIQAHBU/apDLDQ== X-Google-Smtp-Source: ABdhPJzvL548jIVHWEK3wkLNGd36Uico9ujbUgT1crbH/MUPdlT1HtTLICOjJpYtlqeLXhhVMoqNnQ== X-Received: by 2002:a19:7e85:: with SMTP id z127mr4717457lfc.493.1604415998774; Tue, 03 Nov 2020 07:06:38 -0800 (PST) Received: from localhost.localdomain (h-155-4-131-134.NA.cust.bahnhof.se. [155.4.131.134]) by smtp.gmail.com with ESMTPSA id a25sm3522169lfo.141.2020.11.03.07.06.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 03 Nov 2020 07:06:36 -0800 (PST) From: Ulf Hansson To: "Rafael J . Wysocki" , Sudeep Holla , Lorenzo Pieralisi , linux-pm@vger.kernel.org Cc: Daniel Lezcano , Lina Iyer , Lukasz Luba , Vincent Guittot , Stephen Boyd , Bjorn Andersson , Alexandre Torgue , Ulf Hansson , linux-arm-kernel@lists.infradead.org, Thomas Gleixner Subject: [PATCH v2 1/3] PM: domains: Rename pm_genpd_syscore_poweroff|poweron() Date: Tue, 3 Nov 2020 16:06:25 +0100 Message-Id: <20201103150627.233438-2-ulf.hansson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201103150627.233438-1-ulf.hansson@linaro.org> References: <20201103150627.233438-1-ulf.hansson@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org To better describe what the pm_genpd_syscore_poweroff|poweron() functions actually do, let's rename them to dev_pm_genpd_suspend|resume() and update the rather few callers of them accordingly (a couple of clocksource drivers). Moreover, let's take the opportunity to add some documentation of these exported functions, as that is currently missing. Cc: Daniel Lezcano Cc: Thomas Gleixner Signed-off-by: Ulf Hansson --- Changes in v2: - New patch. --- drivers/base/power/domain.c | 35 +++++++++++++++++++++-------------- drivers/clocksource/sh_cmt.c | 8 ++++---- drivers/clocksource/sh_mtu2.c | 4 ++-- drivers/clocksource/sh_tmu.c | 8 ++++---- include/linux/pm_domain.h | 8 ++++---- 5 files changed, 35 insertions(+), 28 deletions(-) diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c index 743268996336..9b4881b67683 100644 --- a/drivers/base/power/domain.c +++ b/drivers/base/power/domain.c @@ -1363,14 +1363,7 @@ static void genpd_complete(struct device *dev) genpd_unlock(genpd); } -/** - * genpd_syscore_switch - Switch power during system core suspend or resume. - * @dev: Device that normally is marked as "always on" to switch power for. - * - * This routine may only be called during the system core (syscore) suspend or - * resume phase for devices whose "always on" flags are set. - */ -static void genpd_syscore_switch(struct device *dev, bool suspend) +static void genpd_switch_state(struct device *dev, bool suspend) { struct generic_pm_domain *genpd; @@ -1387,17 +1380,31 @@ static void genpd_syscore_switch(struct device *dev, bool suspend) } } -void pm_genpd_syscore_poweroff(struct device *dev) +/** + * dev_pm_genpd_suspend - Synchronously try to suspend the genpd for @dev + * @dev: The device that is attached to the genpd, that can be suspended. + * + * This routine should typically be called for a device that needs to be + * suspended during the syscore suspend phase. + */ +void dev_pm_genpd_suspend(struct device *dev) { - genpd_syscore_switch(dev, true); + genpd_switch_state(dev, true); } -EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweroff); +EXPORT_SYMBOL_GPL(dev_pm_genpd_suspend); -void pm_genpd_syscore_poweron(struct device *dev) +/** + * dev_pm_genpd_resume - Synchronously try to resume the genpd for @dev + * @dev: The device that is attached to the genpd, which needs to be resumed. + * + * This routine should typically be called for a device that needs to be resumed + * during the syscore resume phase. + */ +void dev_pm_genpd_resume(struct device *dev) { - genpd_syscore_switch(dev, false); + genpd_switch_state(dev, false); } -EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweron); +EXPORT_SYMBOL_GPL(dev_pm_genpd_resume); #else /* !CONFIG_PM_SLEEP */ diff --git a/drivers/clocksource/sh_cmt.c b/drivers/clocksource/sh_cmt.c index 760777458a90..7275d95de435 100644 --- a/drivers/clocksource/sh_cmt.c +++ b/drivers/clocksource/sh_cmt.c @@ -658,7 +658,7 @@ static void sh_cmt_clocksource_suspend(struct clocksource *cs) return; sh_cmt_stop(ch, FLAG_CLOCKSOURCE); - pm_genpd_syscore_poweroff(&ch->cmt->pdev->dev); + dev_pm_genpd_suspend(&ch->cmt->pdev->dev); } static void sh_cmt_clocksource_resume(struct clocksource *cs) @@ -668,7 +668,7 @@ static void sh_cmt_clocksource_resume(struct clocksource *cs) if (!ch->cs_enabled) return; - pm_genpd_syscore_poweron(&ch->cmt->pdev->dev); + dev_pm_genpd_resume(&ch->cmt->pdev->dev); sh_cmt_start(ch, FLAG_CLOCKSOURCE); } @@ -760,7 +760,7 @@ static void sh_cmt_clock_event_suspend(struct clock_event_device *ced) { struct sh_cmt_channel *ch = ced_to_sh_cmt(ced); - pm_genpd_syscore_poweroff(&ch->cmt->pdev->dev); + dev_pm_genpd_suspend(&ch->cmt->pdev->dev); clk_unprepare(ch->cmt->clk); } @@ -769,7 +769,7 @@ static void sh_cmt_clock_event_resume(struct clock_event_device *ced) struct sh_cmt_channel *ch = ced_to_sh_cmt(ced); clk_prepare(ch->cmt->clk); - pm_genpd_syscore_poweron(&ch->cmt->pdev->dev); + dev_pm_genpd_resume(&ch->cmt->pdev->dev); } static int sh_cmt_register_clockevent(struct sh_cmt_channel *ch, diff --git a/drivers/clocksource/sh_mtu2.c b/drivers/clocksource/sh_mtu2.c index bfccb31e94ad..169a1fccc497 100644 --- a/drivers/clocksource/sh_mtu2.c +++ b/drivers/clocksource/sh_mtu2.c @@ -297,12 +297,12 @@ static int sh_mtu2_clock_event_set_periodic(struct clock_event_device *ced) static void sh_mtu2_clock_event_suspend(struct clock_event_device *ced) { - pm_genpd_syscore_poweroff(&ced_to_sh_mtu2(ced)->mtu->pdev->dev); + dev_pm_genpd_suspend(&ced_to_sh_mtu2(ced)->mtu->pdev->dev); } static void sh_mtu2_clock_event_resume(struct clock_event_device *ced) { - pm_genpd_syscore_poweron(&ced_to_sh_mtu2(ced)->mtu->pdev->dev); + dev_pm_genpd_resume(&ced_to_sh_mtu2(ced)->mtu->pdev->dev); } static void sh_mtu2_register_clockevent(struct sh_mtu2_channel *ch, diff --git a/drivers/clocksource/sh_tmu.c b/drivers/clocksource/sh_tmu.c index d41df9ba3725..b00dec0655cb 100644 --- a/drivers/clocksource/sh_tmu.c +++ b/drivers/clocksource/sh_tmu.c @@ -292,7 +292,7 @@ static void sh_tmu_clocksource_suspend(struct clocksource *cs) if (--ch->enable_count == 0) { __sh_tmu_disable(ch); - pm_genpd_syscore_poweroff(&ch->tmu->pdev->dev); + dev_pm_genpd_suspend(&ch->tmu->pdev->dev); } } @@ -304,7 +304,7 @@ static void sh_tmu_clocksource_resume(struct clocksource *cs) return; if (ch->enable_count++ == 0) { - pm_genpd_syscore_poweron(&ch->tmu->pdev->dev); + dev_pm_genpd_resume(&ch->tmu->pdev->dev); __sh_tmu_enable(ch); } } @@ -394,12 +394,12 @@ static int sh_tmu_clock_event_next(unsigned long delta, static void sh_tmu_clock_event_suspend(struct clock_event_device *ced) { - pm_genpd_syscore_poweroff(&ced_to_sh_tmu(ced)->tmu->pdev->dev); + dev_pm_genpd_suspend(&ced_to_sh_tmu(ced)->tmu->pdev->dev); } static void sh_tmu_clock_event_resume(struct clock_event_device *ced) { - pm_genpd_syscore_poweron(&ced_to_sh_tmu(ced)->tmu->pdev->dev); + dev_pm_genpd_resume(&ced_to_sh_tmu(ced)->tmu->pdev->dev); } static void sh_tmu_register_clockevent(struct sh_tmu_channel *ch, diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h index 1ad0ec481416..a8f93328daec 100644 --- a/include/linux/pm_domain.h +++ b/include/linux/pm_domain.h @@ -280,11 +280,11 @@ static inline int dev_pm_genpd_remove_notifier(struct device *dev) #endif #ifdef CONFIG_PM_GENERIC_DOMAINS_SLEEP -void pm_genpd_syscore_poweroff(struct device *dev); -void pm_genpd_syscore_poweron(struct device *dev); +void dev_pm_genpd_suspend(struct device *dev); +void dev_pm_genpd_resume(struct device *dev); #else -static inline void pm_genpd_syscore_poweroff(struct device *dev) {} -static inline void pm_genpd_syscore_poweron(struct device *dev) {} +static inline void dev_pm_genpd_suspend(struct device *dev) {} +static inline void dev_pm_genpd_resume(struct device *dev) {} #endif /* OF PM domain providers */ From patchwork Tue Nov 3 15:06:26 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ulf Hansson X-Patchwork-Id: 315227 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_SIGNED, DKIM_VALID, DKIM_VALID_AU, 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 48B0BC61DD8 for ; Tue, 3 Nov 2020 15:07:42 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id ECCBC221FB for ; Tue, 3 Nov 2020 15:07:41 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="aKENhJfJ" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728168AbgKCPHl (ORCPT ); Tue, 3 Nov 2020 10:07:41 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53024 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728158AbgKCPGm (ORCPT ); Tue, 3 Nov 2020 10:06:42 -0500 Received: from mail-lj1-x244.google.com (mail-lj1-x244.google.com [IPv6:2a00:1450:4864:20::244]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0C030C0617A6 for ; Tue, 3 Nov 2020 07:06:42 -0800 (PST) Received: by mail-lj1-x244.google.com with SMTP id p15so19436012ljj.8 for ; Tue, 03 Nov 2020 07:06:41 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Kdoh+vwsEl16Yv/ER7Hhev3sO3MvjrueZiYq3HqyYgg=; b=aKENhJfJOgbz3Z80D8/HTRaDGis97wYnQ7c6Vk5LMIdkp8+btBMJV85vwFmdaGqtZF vFuuCdmCgskoX9lAVsxq/VPlWhlkNHoVsfpTfzgaX/qylT3wlmo/wmvTOWqjEWXQOGZO C+Ym+Aa5KsYsi+XPAU2q7FVpk4MUL/mqpaSCcABHwobDjgiiAY54kWsCwAUjl4rel6LN 5a4j7hHlgD8opdaOnLOipRT3Dm36PXH1KvC08Ht+19WwE4t76ZeMwJAE2gz715MYk9z+ FP8b0XmmZLYrVI7AvWawpeKptZfmj1Tj2VAjFaFRJ9z4rLGSuwc7VB8er4C12yb2fg9Y lREg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Kdoh+vwsEl16Yv/ER7Hhev3sO3MvjrueZiYq3HqyYgg=; b=mygmEM+mUtI4HOzLkKO838ZCW6fvfMuf+AJSGxFcuQjqI4iERBpZm3Z6PsRqxycJPZ jXdmXg6jAK0ZeSacnifgJcc8pvpLK/0NnPjijTSdYV+hdgkP793o4J8nqpojPAL7cSwC uWmY/fIVkiAU7KijyeGEeOBO0JTDeDFNxXGk1pP/B/VmKo6WftJjAfyVCOpYqhcz1dVu YeyPXkz1F52t+HJHctx+s7nvmaqV8iF1qcuGswpwMJ4873ckmTjmNXHBJA3u+XfMilEg U6LJxB4yuFQwYsAHXO2np2OEMhApD792+DZB6UnZamw/YZWkIERq9FMSG6eiQ1h0yh6+ R98Q== X-Gm-Message-State: AOAM532tVZ2in5dmovgmea2z5fPQsaQZOI0aTdwcFAnuCmfGe2jdfJ1h SkR6gBD50GYho7JziF91fL4EyVsma6s8UQ== X-Google-Smtp-Source: ABdhPJxL5L/dqtMLU8eglrRK4+pkCsIeAA+kIcRq8/oJXsL1Sx/dg6nEod+1dvGOt0AnvFCnoqtwgg== X-Received: by 2002:a2e:7c17:: with SMTP id x23mr9593284ljc.366.1604416000443; Tue, 03 Nov 2020 07:06:40 -0800 (PST) Received: from localhost.localdomain (h-155-4-131-134.NA.cust.bahnhof.se. [155.4.131.134]) by smtp.gmail.com with ESMTPSA id a25sm3522169lfo.141.2020.11.03.07.06.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 03 Nov 2020 07:06:39 -0800 (PST) From: Ulf Hansson To: "Rafael J . Wysocki" , Sudeep Holla , Lorenzo Pieralisi , linux-pm@vger.kernel.org Cc: Daniel Lezcano , Lina Iyer , Lukasz Luba , Vincent Guittot , Stephen Boyd , Bjorn Andersson , Alexandre Torgue , Ulf Hansson , linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 2/3] PM: domains: Enable dev_pm_genpd_suspend|resume() for suspend-to-idle Date: Tue, 3 Nov 2020 16:06:26 +0100 Message-Id: <20201103150627.233438-3-ulf.hansson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201103150627.233438-1-ulf.hansson@linaro.org> References: <20201103150627.233438-1-ulf.hansson@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org The dev_pm_genpd_suspend|resume() have so far only been used during the syscore suspend/resume phases. However, during suspend-to-idle, where the syscore phases doesn't exist, similar operations are sometimes needed. An existing example are the timekeeping_suspend|resume() functions, which are being called both through a registered syscore ops during the syscore phases, but also as regular functions calls from cpuidle (via tick_freeze()) during suspend-to-idle. For similar reasons, let's enable the dev_pm_genpd_suspend|resume() APIs to be re-used for corresponding CPU devices that are attached to a genpd, during suspend-to-idle. Signed-off-by: Ulf Hansson --- Changes in v2: - Renamed and add documentation of the APIs. - Updated the commit message and its header. --- drivers/base/power/domain.c | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c index 9b4881b67683..4a55f3c949ae 100644 --- a/drivers/base/power/domain.c +++ b/drivers/base/power/domain.c @@ -1366,18 +1366,27 @@ static void genpd_complete(struct device *dev) static void genpd_switch_state(struct device *dev, bool suspend) { struct generic_pm_domain *genpd; + bool use_lock; genpd = dev_to_genpd_safe(dev); if (!genpd) return; + use_lock = genpd_is_irq_safe(genpd); + + if (use_lock) + genpd_lock(genpd); + if (suspend) { genpd->suspended_count++; - genpd_sync_power_off(genpd, false, 0); + genpd_sync_power_off(genpd, use_lock, 0); } else { - genpd_sync_power_on(genpd, false, 0); + genpd_sync_power_on(genpd, use_lock, 0); genpd->suspended_count--; } + + if (use_lock) + genpd_unlock(genpd); } /** @@ -1385,7 +1394,9 @@ static void genpd_switch_state(struct device *dev, bool suspend) * @dev: The device that is attached to the genpd, that can be suspended. * * This routine should typically be called for a device that needs to be - * suspended during the syscore suspend phase. + * suspended during the syscore suspend phase. It may also be called during + * suspend-to-idle to suspend a corresponding CPU device that is attached to a + * genpd. */ void dev_pm_genpd_suspend(struct device *dev) { @@ -1398,7 +1409,8 @@ EXPORT_SYMBOL_GPL(dev_pm_genpd_suspend); * @dev: The device that is attached to the genpd, which needs to be resumed. * * This routine should typically be called for a device that needs to be resumed - * during the syscore resume phase. + * during the syscore resume phase. It may also be called during suspend-to-idle + * to resume a corresponding CPU device that is attached to a genpd. */ void dev_pm_genpd_resume(struct device *dev) { From patchwork Tue Nov 3 15:06:27 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ulf Hansson X-Patchwork-Id: 320421 Delivered-To: patches@linaro.org Received: by 2002:a92:7b12:0:0:0:0:0 with SMTP id w18csp4658174ilc; Tue, 3 Nov 2020 07:06:43 -0800 (PST) X-Received: by 2002:a2e:9b58:: with SMTP id o24mr8081999ljj.94.1604416003526; Tue, 03 Nov 2020 07:06:43 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1604416003; cv=none; d=google.com; s=arc-20160816; b=RhMjbx4Rfwy9SzHgGNMGACc+XnwoF7GsCRAGWCaynQ/dlTk9FiXZ11hZCwi2twqyd1 OwgPdEBp25ogjkGhAKPl2jAnyM+MmPV1agvFVUqlROvoTUUcbh9o7jaEnPybvLSicDve tWDDD2mNaJzF1q0PKFEldbG41Aj1Av18nmjBiG8GIC4fcDJgLUcFln2k+eSdXTfFIXS+ BPGKcBrxi1qD04fzJAQSC7UBO4/FLkp1nJQmZ8WWJ+wYc6FNH+5poNYzKMrWWURBsvQy xqBXAGk8dHgRzutJyaunTVaGHrz2ireI+XwaY9VwXgIWNugOQV7V0VvGnyscE7936K3F 0YtQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature; bh=z2aikAnlU4Rv0xJ54ndQnr8H+vElIy0SKy9Omrer1Ow=; b=ia9ISukaJKXoBbO3YFJw8EwuPao3DBPwbqmzlMXvyzpjD3tQb5Wzen/Rl3Dmg1jaVo uim/7F4yeKFBv+Z42xb9cG4uSPbrn/C44G03HOSf3zE7VnKsDdhkq8k0B5IklwFd95wG VivqCjgE4RKc4aWMT96LrRqdfjuuCcrEhdvavrf5jHbTHP0119C8ZIA5sMu3vGY9S8y4 D71vnLuf/xZJp2o3GY4wqCxpwB503offpQ+zv8IsKa5jWFKsjvujZZs2qzKi+b5CBIPY OQ98bgwNfRo+oscJwp0dt35Y5PpfvP9ZzGuwRFHnp/fR70nDonVwKS1JderIudabZLnU Rbhw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b="ysK/IoiT"; spf=pass (google.com: domain of ulf.hansson@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=ulf.hansson@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id n2sor1971510lfd.24.2020.11.03.07.06.43 for (Google Transport Security); Tue, 03 Nov 2020 07:06:43 -0800 (PST) Received-SPF: pass (google.com: domain of ulf.hansson@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b="ysK/IoiT"; spf=pass (google.com: domain of ulf.hansson@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=ulf.hansson@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=z2aikAnlU4Rv0xJ54ndQnr8H+vElIy0SKy9Omrer1Ow=; b=ysK/IoiTp/UV3EPWH4UVFRHclwAjajJUvSrrM3LNcbaoGkicwm6doZuxeL3S7sfb32 DMFErTSnQPcB0MgRCAtgupil1fcRLbb/LpGIBHCMUfHOsWw9qzbQxWIGEC67sBhHFAer PDJ9z0Fcss7tqgwKKqbQgOpcdfRU+m6wbJZbaEljBcMhGeiN0O0pERIMF+E2xxDGATeT JrjkX3Cju0HiFYns0PYd1VSMF6Yu9XGNMtlesWDovCfEjuzW3UrVQ+KcbZum6o7hIvFq b27ldA7bQuHFTP0JoBqJcNNJM4rZpxEIgYrP2VCwickkqKCeq7rQvpP4TzbYkbbO2MjF aJog== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=z2aikAnlU4Rv0xJ54ndQnr8H+vElIy0SKy9Omrer1Ow=; b=sdhDVaFxBQOOKYWrPKq7OcQAVBp7ciVJDZyb50JRdeLnvyl1HImBciMt9qsUFPAaO4 ADSocB4EHhy7MGZGhz/++LdlcllDOSSaz/yTUQM+npTSkmkOSABI8ClLvBZsYKDta+xy UUMMfyd7Y07+AYXt4yDNtzNpPYviN0fZCl+h+i6tQ/Yr70PSYvEfa1OI8Pbgnxg/Q/WH yKCBpVJh4TTChEaGa+yoRg3kY7ZvgZuIoFC1vg7BE97H7kLV2ecSZRwhaYYFBHHH3CIY QiDcr6CibLUntrsRBCU5QMoNQg7M7isv4yWI+LCWqSvlKjNhBwf5lvLo+VYSQLd/ANVH nPZw== X-Gm-Message-State: AOAM531VAm46pErA3v753JsZjgSy9l9+PzjlxQQmydsqqSTz7lEm3xve mAIG2rck3uChCznb0p61gjnKFxLt X-Google-Smtp-Source: ABdhPJzaNwaa4JfoulcPt1J10kPgf3A10Pfy/kvKPYlSj4ezifUxRuTpYUt3gCD3A1Gn05zKdnj4Gw== X-Received: by 2002:a19:ca4b:: with SMTP id h11mr8466061lfj.6.1604416002518; Tue, 03 Nov 2020 07:06:42 -0800 (PST) Return-Path: Received: from localhost.localdomain (h-155-4-131-134.NA.cust.bahnhof.se. [155.4.131.134]) by smtp.gmail.com with ESMTPSA id a25sm3522169lfo.141.2020.11.03.07.06.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 03 Nov 2020 07:06:41 -0800 (PST) From: Ulf Hansson To: "Rafael J . Wysocki" , Sudeep Holla , Lorenzo Pieralisi , linux-pm@vger.kernel.org Cc: Daniel Lezcano , Lina Iyer , Lukasz Luba , Vincent Guittot , Stephen Boyd , Bjorn Andersson , Alexandre Torgue , Ulf Hansson , linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 3/3] cpuidle: psci: Enable suspend-to-idle for PSCI OSI mode Date: Tue, 3 Nov 2020 16:06:27 +0100 Message-Id: <20201103150627.233438-4-ulf.hansson@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201103150627.233438-1-ulf.hansson@linaro.org> References: <20201103150627.233438-1-ulf.hansson@linaro.org> MIME-Version: 1.0 To select domain idlestates for cpuidle-psci when OSI mode has been enabled, the PM domains via genpd are being managed through runtime PM. This works fine for the regular idlepath, but it doesn't during system wide suspend. More precisely, the domain idlestates becomes temporarily disabled, which is because the PM core disables runtime PM for devices during system wide suspend. Later in the system suspend phase, genpd intends to deal with this from its ->suspend_noirq() callback, but this doesn't work as expected for a device corresponding to a CPU, because the domain idlestates needs to be selected on a per CPU basis (the PM core doesn't invoke the callbacks like that). To address this problem, let's enable the syscore flag for the corresponding CPU device that becomes successfully attached to its PM domain (applicable only in OSI mode). This informs the PM core to skip invoke the system wide suspend/resume callbacks for the device, thus also prevents genpd from screwing up its internal state of it. Moreover, to properly select a domain idlestate for the CPUs during suspend-to-idle, let's assign a specific ->enter_s2idle() callback for the corresponding domain idlestate (applicable only in OSI mode). From that callback, let's invoke dev_pm_genpd_suspend|resume(), as this allows a domain idlestate to be selected for the current CPU by genpd. Signed-off-by: Ulf Hansson --- Changes in v2: - Rebased upon recent changes. - Updated the commit message. --- drivers/cpuidle/cpuidle-psci-domain.c | 2 ++ drivers/cpuidle/cpuidle-psci.c | 34 +++++++++++++++++++++++---- 2 files changed, 32 insertions(+), 4 deletions(-) -- 2.25.1 diff --git a/drivers/cpuidle/cpuidle-psci-domain.c b/drivers/cpuidle/cpuidle-psci-domain.c index 4a031c62f92a..ff2c3f8e4668 100644 --- a/drivers/cpuidle/cpuidle-psci-domain.c +++ b/drivers/cpuidle/cpuidle-psci-domain.c @@ -327,6 +327,8 @@ struct device *psci_dt_attach_cpu(int cpu) if (cpu_online(cpu)) pm_runtime_get_sync(dev); + dev_pm_syscore_device(dev, true); + return dev; } diff --git a/drivers/cpuidle/cpuidle-psci.c b/drivers/cpuidle/cpuidle-psci.c index d928b37718bd..b51b5df08450 100644 --- a/drivers/cpuidle/cpuidle-psci.c +++ b/drivers/cpuidle/cpuidle-psci.c @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include @@ -52,8 +53,9 @@ static inline int psci_enter_state(int idx, u32 state) return CPU_PM_CPU_IDLE_ENTER_PARAM(psci_cpu_suspend_enter, idx, state); } -static int psci_enter_domain_idle_state(struct cpuidle_device *dev, - struct cpuidle_driver *drv, int idx) +static int __psci_enter_domain_idle_state(struct cpuidle_device *dev, + struct cpuidle_driver *drv, int idx, + bool s2idle) { struct psci_cpuidle_data *data = this_cpu_ptr(&psci_cpuidle_data); u32 *states = data->psci_states; @@ -66,7 +68,12 @@ static int psci_enter_domain_idle_state(struct cpuidle_device *dev, return -1; /* Do runtime PM to manage a hierarchical CPU toplogy. */ - RCU_NONIDLE(pm_runtime_put_sync_suspend(pd_dev)); + rcu_irq_enter_irqson(); + if (s2idle) + dev_pm_genpd_suspend(pd_dev); + else + pm_runtime_put_sync_suspend(pd_dev); + rcu_irq_exit_irqson(); state = psci_get_domain_state(); if (!state) @@ -74,7 +81,12 @@ static int psci_enter_domain_idle_state(struct cpuidle_device *dev, ret = psci_cpu_suspend_enter(state) ? -1 : idx; - RCU_NONIDLE(pm_runtime_get_sync(pd_dev)); + rcu_irq_enter_irqson(); + if (s2idle) + dev_pm_genpd_resume(pd_dev); + else + pm_runtime_get_sync(pd_dev); + rcu_irq_exit_irqson(); cpu_pm_exit(); @@ -83,6 +95,19 @@ static int psci_enter_domain_idle_state(struct cpuidle_device *dev, return ret; } +static int psci_enter_domain_idle_state(struct cpuidle_device *dev, + struct cpuidle_driver *drv, int idx) +{ + return __psci_enter_domain_idle_state(dev, drv, idx, false); +} + +static int psci_enter_s2idle_domain_idle_state(struct cpuidle_device *dev, + struct cpuidle_driver *drv, + int idx) +{ + return __psci_enter_domain_idle_state(dev, drv, idx, true); +} + static int psci_idle_cpuhp_up(unsigned int cpu) { struct device *pd_dev = __this_cpu_read(psci_cpuidle_data.dev); @@ -170,6 +195,7 @@ static int psci_dt_cpu_init_topology(struct cpuidle_driver *drv, * deeper states. */ drv->states[state_count - 1].enter = psci_enter_domain_idle_state; + drv->states[state_count - 1].enter_s2idle = psci_enter_s2idle_domain_idle_state; psci_cpuidle_use_cpuhp = true; return 0;