From patchwork Tue Jun 27 10:40:32 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Abel Vesa X-Patchwork-Id: 13294336 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 86FC7EB64D9 for ; Tue, 27 Jun 2023 10:40:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230401AbjF0Kkr (ORCPT ); Tue, 27 Jun 2023 06:40:47 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50622 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229647AbjF0Kkq (ORCPT ); Tue, 27 Jun 2023 06:40:46 -0400 Received: from mail-wr1-x42e.google.com (mail-wr1-x42e.google.com [IPv6:2a00:1450:4864:20::42e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 11815E5B for ; Tue, 27 Jun 2023 03:40:45 -0700 (PDT) Received: by mail-wr1-x42e.google.com with SMTP id ffacd0b85a97d-307d58b3efbso3847294f8f.0 for ; Tue, 27 Jun 2023 03:40:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1687862443; x=1690454443; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:from:to:cc:subject:date:message-id:reply-to; bh=XNWf4XrzpOMeSduBCIvkxhctVOzqSSmAJ8R1LK8bH5w=; b=v0kohGNzQndW2yQwqx2w8zwRIoXdd0x63JIBhZR/Qo1PuXH+wh4+0Vqs7AaTXb8vAH tBlwNu76zMuSVaeWkKEVoV6AUIvN3mBi2M2bpMG3H5LQZyPBpPgtxwWx7Kby0/bm/1Pd 4wurTqEtwjL1R9QnX50LRsLPVET4OTGm43r/yftAsap1BE7kiz2XO+eRaQ6DnXsLkO6e 1m3/jDV2SokiIMCqdeQCb1xWVYEOA5mepuT9JhQSe38lAln9ZreztOarjZuSLm6gPh2k Ph3wGYfXlSxmd7kd8iZvPmRJRpwlz9Z1lIDKH9zdpt6GQzGj7sA9MrcxPemGfUdQALCH k/2A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1687862443; x=1690454443; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=XNWf4XrzpOMeSduBCIvkxhctVOzqSSmAJ8R1LK8bH5w=; b=CsmbhnW6HTnPiA7D9Ht+HXRXPrmz+Yu2MVDY75wNzLA4TGuHU7J7D8oq5mOKz02oMD lesQxRAdxBStgLAXB4H93PRF8FHa/0ZGotqOGWz2vSeRFKrMLlSb16Clyw6YZdrCZZQf KInIEj0gQDCcgtQLZp2Cn73CZqvZpmJXJI4x2d6fbDjwxlKjnVhj4i+BxLx0RzdWoC+1 RkqLYktslRbXDw9d0On4Dk0widDcvj0/T5TEGEAz4P/x5roGmtgvtYEXMciRDbVMZ6LC z1in9K2CXFIu3U+fn9NVnOcQztgit3ROApTXB7hoP9pbPZKBVq5YrH1MrPI2CL9VfMTc xRGw== X-Gm-Message-State: AC+VfDycgv3p1uq76pBRtOddz/Gz8Ewg+/GxLbwjTcGh+r7EQXFAj6Ah wlQQ55DaD95oj/WkRYW2pCg5+g== X-Google-Smtp-Source: ACHHUZ4RWdwlfmE4HxDH85NtG4N+3LRB9BQsLJLeEYH8wtwl67F/1B1j3/l4x4dNuo9wx0QB51ijpQ== X-Received: by 2002:a5d:4ad0:0:b0:313:f98a:1fd3 with SMTP id y16-20020a5d4ad0000000b00313f98a1fd3mr2072465wrs.27.1687862443390; Tue, 27 Jun 2023 03:40:43 -0700 (PDT) Received: from hackbox.lan ([62.231.110.100]) by smtp.gmail.com with ESMTPSA id a10-20020adfdd0a000000b0030af15d7e41sm10203750wrm.4.2023.06.27.03.40.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 27 Jun 2023 03:40:42 -0700 (PDT) From: Abel Vesa To: "Rafael J . Wysocki" , Kevin Hilman , Ulf Hansson , avel Machek , Len Brown , Greg Kroah-Hartman , Bjorn Andersson , Andy Gross , Konrad Dybcio , Mike Turquette , Stephen Boyd , Taniya Das Cc: linux-pm@vger.kernel.org, Linux Kernel Mailing List , linux-arm-msm@vger.kernel.org Subject: [RFC PATCH 1/2] PM: domains: Allow devices attached to genpd to be managed by HW Date: Tue, 27 Jun 2023 13:40:32 +0300 Message-Id: <20230627104033.3345659-1-abel.vesa@linaro.org> X-Mailer: git-send-email 2.34.1 MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org From: Ulf Hansson Some power-domains may be capable of relying on the HW to control the power for a device that's hooked up to it. Typically, for these kinds of configurations the device doesn't really need to be attached to a PM domain (genpd), from Linux point of view. However, in some cases the behaviour of the power-domain and its device can be changed in runtime. To allow a consumer driver to change the behaviour of the PM domain for its device, let's provide a new function, dev_pm_genpd_set_hwmode(). Moreover, let's add a corresponding optional genpd callback, ->set_hwmode_dev(), which the genpd provider should implement if it can support switching between HW controlled mode and SW controlled mode. Signed-off-by: Ulf Hansson --- drivers/base/power/domain.c | 66 +++++++++++++++++++++++++++++++++++++ include/linux/pm_domain.h | 15 +++++++++ 2 files changed, 81 insertions(+) diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c index 5cb2023581d4..23286853d1d0 100644 --- a/drivers/base/power/domain.c +++ b/drivers/base/power/domain.c @@ -541,6 +541,72 @@ void dev_pm_genpd_synced_poweroff(struct device *dev) } EXPORT_SYMBOL_GPL(dev_pm_genpd_synced_poweroff); +/** + * dev_pm_genpd_set_hwmode - Set the HW mode for the device and its PM domain. + * + * @dev: Device for which the HW-mode should be changed. + * @enable: Value to set or unset the HW-mode. + * + * Some PM domains can rely on HW signals to control the power for a device. To + * allow a consumer driver to switch the behaviour for its device in runtime, + * which may be beneficial from a latency or energy point of view, this function + * may be called. + * + * It is assumed that the users guarantee that the genpd wouldn't be detached + * while this routine is getting called. + * + * Returns 0 on success and negative error values on failures. + */ +int dev_pm_genpd_set_hwmode(struct device *dev, bool enable) +{ + struct generic_pm_domain *genpd; + int ret = 0; + + genpd = dev_to_genpd_safe(dev); + if (!genpd) + return -ENODEV; + + if (!genpd->set_hwmode_dev) + return -EOPNOTSUPP; + + genpd_lock(genpd); + + if (dev_gpd_data(dev)->hw_mode == enable) + goto out; + + ret = genpd->set_hwmode_dev(genpd, dev, enable); + if (!ret) + dev_gpd_data(dev)->hw_mode = enable; + +out: + genpd_unlock(genpd); + return ret; +} +EXPORT_SYMBOL_GPL(dev_pm_genpd_set_hwmode); + +/** + * dev_pm_genpd_get_hwmode - Get the HW mode setting for the device. + * + * @dev: Device for which the current HW-mode setting should be fetched. + * + * This helper function allows consumer drivers to fetch the current HW mode + * setting of its the device. + * + * It is assumed that the users guarantee that the genpd wouldn't be detached + * while this routine is getting called. + */ +bool dev_pm_genpd_get_hwmode(struct device *dev) +{ + struct generic_pm_domain *genpd; + + genpd = dev_to_genpd_safe(dev); + if (!genpd) + return false; + + return dev_gpd_data(dev)->hw_mode; +} +EXPORT_SYMBOL_GPL(dev_pm_genpd_get_hwmode); + static int _genpd_power_on(struct generic_pm_domain *genpd, bool timed) { unsigned int state_idx = genpd->state_idx; diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h index f776fb93eaa0..8f60c36851d5 100644 --- a/include/linux/pm_domain.h +++ b/include/linux/pm_domain.h @@ -146,6 +146,8 @@ struct generic_pm_domain { int (*set_performance_state)(struct generic_pm_domain *genpd, unsigned int state); struct gpd_dev_ops dev_ops; + int (*set_hwmode_dev)(struct generic_pm_domain *domain, + struct device *dev, bool enable); int (*attach_dev)(struct generic_pm_domain *domain, struct device *dev); void (*detach_dev)(struct generic_pm_domain *domain, @@ -208,6 +210,7 @@ struct generic_pm_domain_data { unsigned int performance_state; unsigned int default_pstate; unsigned int rpm_pstate; + bool hw_mode; void *data; }; @@ -237,6 +240,8 @@ int dev_pm_genpd_remove_notifier(struct device *dev); void dev_pm_genpd_set_next_wakeup(struct device *dev, ktime_t next); ktime_t dev_pm_genpd_get_next_hrtimer(struct device *dev); void dev_pm_genpd_synced_poweroff(struct device *dev); +int dev_pm_genpd_set_hwmode(struct device *dev, bool enable); +bool dev_pm_genpd_get_hwmode(struct device *dev); extern struct dev_power_governor simple_qos_governor; extern struct dev_power_governor pm_domain_always_on_gov; @@ -305,6 +310,16 @@ static inline ktime_t dev_pm_genpd_get_next_hrtimer(struct device *dev) static inline void dev_pm_genpd_synced_poweroff(struct device *dev) { } +static inline int dev_pm_genpd_set_hwmode(struct device *dev, bool enable) +{ + return -EOPNOTSUPP; +} + +static inline bool dev_pm_genpd_get_hwmode(struct device *dev) +{ + return false; +} + #define simple_qos_governor (*(struct dev_power_governor *)(NULL)) #define pm_domain_always_on_gov (*(struct dev_power_governor *)(NULL)) #endif From patchwork Tue Jun 27 10:40:33 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Abel Vesa X-Patchwork-Id: 13294337 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id EFD06C001B3 for ; Tue, 27 Jun 2023 10:40:49 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231288AbjF0Kks (ORCPT ); Tue, 27 Jun 2023 06:40:48 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50644 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231148AbjF0Kkr (ORCPT ); Tue, 27 Jun 2023 06:40:47 -0400 Received: from mail-wr1-x435.google.com (mail-wr1-x435.google.com [IPv6:2a00:1450:4864:20::435]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6A3CE10C9 for ; Tue, 27 Jun 2023 03:40:46 -0700 (PDT) Received: by mail-wr1-x435.google.com with SMTP id ffacd0b85a97d-313f3a6db22so1955019f8f.3 for ; Tue, 27 Jun 2023 03:40:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1687862445; x=1690454445; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=/UOP/HXwOfjROV0iDHrU1g1p6LD4GcCF3K/FghLtNOU=; b=y5+DnJgJYphY781NuJroMLh1mIZh3+eUMQjDpKMhsyWLF+SMHN4tPapiVgi3uiVbX4 1cUL4yRaDVQDHkrmMUBVplhWuXMbXP+0ZQG73WO5b4lmq+d3M+fh3InkHRBGLtpEpC8E K3l0vVj/mKmznriOrTPlcfUYBiQSVN1hKLJc5Qzp7aiPPw6rW1zXRUGgWGCjQiKhuHCK ofV5FjoVrXUkRnofsmwXXInwtxy0KKDN6i/7llXeIAcygky0QAttWLhABjAOl19KApyT XeJ1rK/ArsbtnW+kqXlmSsiGXZnrYx7x70hdgWNTL5YYA1e6dkSg0Ja4Vrj8oFHezqwU jPMQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1687862445; x=1690454445; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=/UOP/HXwOfjROV0iDHrU1g1p6LD4GcCF3K/FghLtNOU=; b=Z+jmhhqIlNjsBR2GUt87NmxYIdC1KR1cbJfY2xPyVFenf7+PT594Fsw1qNih/yMGNu aUQf0Jot5k6b7DkLCuFFh3vS/HcRq9AzdGGUtDtbIS62cHpMhYT3UL2/tQCOAYtla9rB UWzW4s1iFmvnxskxbXeMllMm5HE68jq6Jlaqe7fxa/cdhvrwDKPFNbm7wLPk8fJ00m9Z CxziXfYBOJctsnbDPWBBP+mzQBOpgQLRT2mpfI2rwVCh5W+ht7K6dRwfdLjQpqYjRRpB EzcLFMpx2XwmipWv2u4TFGbHlENSSctZf+umms0mvenJJ8k9VfTI4kBEn/0NjgcvAGpL x5LA== X-Gm-Message-State: AC+VfDze3/+zBLZMB0tYwKauwBgRlnPMEYAjG5JJ7S3ZcKh4mPB+918P MkSbHpqFQoEiub8IeWmZEjzZVw== X-Google-Smtp-Source: ACHHUZ4qAygidQOG1GKKu2XwuyqAylSRU5Ym/1VTMrpY2Q7ErH4bT3tOZXV/sh5hy6eTJ3BMmLgx+g== X-Received: by 2002:adf:fa83:0:b0:30d:44a1:99a with SMTP id h3-20020adffa83000000b0030d44a1099amr24120038wrr.54.1687862444873; Tue, 27 Jun 2023 03:40:44 -0700 (PDT) Received: from hackbox.lan ([62.231.110.100]) by smtp.gmail.com with ESMTPSA id a10-20020adfdd0a000000b0030af15d7e41sm10203750wrm.4.2023.06.27.03.40.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 27 Jun 2023 03:40:44 -0700 (PDT) From: Abel Vesa To: "Rafael J . Wysocki" , Kevin Hilman , Ulf Hansson , avel Machek , Len Brown , Greg Kroah-Hartman , Bjorn Andersson , Andy Gross , Konrad Dybcio , Mike Turquette , Stephen Boyd , Taniya Das Cc: linux-pm@vger.kernel.org, Linux Kernel Mailing List , linux-arm-msm@vger.kernel.org Subject: [RFC PATCH 2/2] clk: qcom: gdsc: Add support for set_hwmode_dev Date: Tue, 27 Jun 2023 13:40:33 +0300 Message-Id: <20230627104033.3345659-2-abel.vesa@linaro.org> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230627104033.3345659-1-abel.vesa@linaro.org> References: <20230627104033.3345659-1-abel.vesa@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org Implement the GDSC specific genpd set_hwmode_dev callback in order to switch the HW control on or off. For any GDSC that supports HW control set this callback in order to allow its consumers to control it. Signed-off-by: Abel Vesa --- drivers/clk/qcom/gdsc.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/drivers/clk/qcom/gdsc.c b/drivers/clk/qcom/gdsc.c index 5358e28122ab..9a04bf2e4379 100644 --- a/drivers/clk/qcom/gdsc.c +++ b/drivers/clk/qcom/gdsc.c @@ -314,6 +314,26 @@ static int gdsc_enable(struct generic_pm_domain *domain) return 0; } +static int gdsc_set_hwmode_dev(struct generic_pm_domain *domain, + struct device *dev, bool enable) +{ + int ret = gdsc_hwctrl(domain_to_gdsc(domain), enable); + + if (ret) + goto out; + + /* + * Wait for the GDSC to go through a power down and + * up cycle. In case there is a status polling going on + * before the power cycle is completed it might read an + * wrong status value. + */ + udelay(1); + +out: + return ret; +} + static int gdsc_disable(struct generic_pm_domain *domain) { struct gdsc *sc = domain_to_gdsc(domain); @@ -451,6 +471,8 @@ static int gdsc_init(struct gdsc *sc) sc->pd.power_off = gdsc_disable; if (!sc->pd.power_on) sc->pd.power_on = gdsc_enable; + if (sc->flags & HW_CTRL) + sc->pd.set_hwmode_dev = gdsc_set_hwmode_dev; ret = pm_genpd_init(&sc->pd, NULL, !on); if (ret)