From patchwork Wed Aug 23 14:42:05 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ulf Hansson X-Patchwork-Id: 110851 Delivered-To: patches@linaro.org Received: by 10.37.128.210 with SMTP id c18csp7031479ybm; Wed, 23 Aug 2017 07:42:24 -0700 (PDT) X-Received: by 10.46.86.142 with SMTP id k14mr1504082lje.55.1503499344393; Wed, 23 Aug 2017 07:42:24 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1503499344; cv=none; d=google.com; s=arc-20160816; b=NNJFcjliyaK9K6nEq6ZtrHvJmnqAKga0xAWBbzWDdX+1limGL1UjzqdTLQqyWJU38Q NQKdcyreleE5ipeAwkMLhfpEf3bL+5MA11LrY/SFe6xZ2ZYRrLKKy6ZebkGWjS0OxMaS t20jSNdo38ynEwQsCu/vBYyt9Joivt3nFY7R4NuViVLXNWV9jEJpMCiH9kUpvqXmSSfT 2RoIgx+X1KP7LV7udJ9+oLYCcmrqdnKFSaW0MBOMLNvvUYRCcDNhdTN0XV+OYEKkKL0U ZNO4a8KXSuiPI071lLpHH3j7kSHTLDj+QPpKd+XcBaQ1Z1IEUPD2RgKSBcFOnVE8UgFT dfEQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature:arc-authentication-results; bh=eZED+UuPfl6DljeOBH8UB3GJkUVwVyCCf056rEWlHQY=; b=VYnb4QzJnxQ6ZCs4mwodV/7IHBwBZivmai/IwZmrTaOyS34eRNjEGH7wfUrtxLu55b 0p2myaRaX4JtOfBW1PWkdlgA97/ETIidvpAmAqe0YXJ7OAbto6+NK/XHuJ1aomIcPfmE /uG3DnW33p7v9t118Xr6WjQPKCUm9uiQ9YjasubKHKeDVdtysjnggi4XfXXULk87YD/W NReWQAWW60VEso6R6MvHzr21Kq5mp30+edyMD6U1aTjMvsQaGwS8gQCdLOR2XI9+eQh/ dJueNqxTuh+OjU/cVGc+OlSfOAnc2nuMozpQZT3dZOY/Sm0Cfqaqv7rDv1qZWpC0C4h/ B35A== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=GpEsEDMK; spf=pass (google.com: domain of ulf.hansson@linaro.org designates 2a00:1450:4010:c07::229 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-lf0-x229.google.com (mail-lf0-x229.google.com. [2a00:1450:4010:c07::229]) by mx.google.com with ESMTPS id a15si724950lfe.272.2017.08.23.07.42.24 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 23 Aug 2017 07:42:24 -0700 (PDT) Received-SPF: pass (google.com: domain of ulf.hansson@linaro.org designates 2a00:1450:4010:c07::229 as permitted sender) client-ip=2a00:1450:4010:c07::229; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=GpEsEDMK; spf=pass (google.com: domain of ulf.hansson@linaro.org designates 2a00:1450:4010:c07::229 as permitted sender) smtp.mailfrom=ulf.hansson@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: by mail-lf0-x229.google.com with SMTP id d17so1565328lfe.0 for ; Wed, 23 Aug 2017 07:42:24 -0700 (PDT) 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; bh=eZED+UuPfl6DljeOBH8UB3GJkUVwVyCCf056rEWlHQY=; b=GpEsEDMK5hiAbDOsKVrQZBBK7urLrwbm8ykc3Irq4pH/xLv2p8BRD/dP1pmaW09WFp 7kMT2S7QWu0pwsRyWZiY0Jffy16e3Sy1oQZanQhj4tT0CmazPgWi/wFcSSoHo4/h5EMA uXsuymyEJ2wYbIhxu+bI9vlqtK9H8dmAIvsaw= 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; bh=eZED+UuPfl6DljeOBH8UB3GJkUVwVyCCf056rEWlHQY=; b=gOkJEM8IWREey0KjYQy+FYzD0NlS0EiwkIQubitZwh5ytO0/jaeQlrYe0yWT4InLZ6 Vtvs3v2BPG08DQAxUkACugube2d68+JuD83rW/0ShsBlPT9R3YmprKSDTu0gZ/U/9r2n ph+bQuB6eVMsUwMfOsyZj0cI1HAOmEZECsJCaXDySXu4D423Doh8+koALTA0F3sNjHzN gwEONhgpPt6PzaJlunW+OAB8tpZkMcKqUdX79SJDjsBebwEmr6nWXTL7Mbg1CKynok2J PSIb1jNaV89XlMJgHOxr8s7obhVfQaqBQpnDOTBSUC96w1kxhxJvBkxpSINQgenDIS2R W4CA== X-Gm-Message-State: AHYfb5heNV5tkLozwF9i7AAdfeW1HE+uk7k55NC60Fvb/c4g5W3CVyBR nrJFHUhP9v9mpSW4K5o= X-Received: by 10.46.81.65 with SMTP id b1mr1170724lje.168.1503499343926; Wed, 23 Aug 2017 07:42:23 -0700 (PDT) Return-Path: Received: from localhost.localdomain (h-158-174-22-67.NA.cust.bahnhof.se. [158.174.22.67]) by smtp.gmail.com with ESMTPSA id c89sm287593lfb.78.2017.08.23.07.42.22 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 23 Aug 2017 07:42:22 -0700 (PDT) From: Ulf Hansson To: Wolfram Sang , "Rafael J . Wysocki" , Len Brown , linux-acpi@vger.kernel.org, linux-pm@vger.kernel.org Cc: Kevin Hilman , Jarkko Nikula , Andy Shevchenko , Mika Westerberg , Jisheng Zhang , John Stultz , Guodong Xu , Sumit Semwal , Haojian Zhuang , linux-arm-kernel@lists.infradead.org, linux-i2c@vger.kernel.org, Ulf Hansson Subject: [PATCH v2 5/9] PM / ACPI: Provide option to disable direct_complete for ACPI devices Date: Wed, 23 Aug 2017 16:42:05 +0200 Message-Id: <1503499329-28834-6-git-send-email-ulf.hansson@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1503499329-28834-1-git-send-email-ulf.hansson@linaro.org> References: <1503499329-28834-1-git-send-email-ulf.hansson@linaro.org> In some cases a driver for an ACPI device needs to be able to prevent the ACPI PM domain from using the direct_complete path during system sleep. One typical case is when the driver for the device needs its device to stay runtime enabled, during the __device_suspend phase. This isn't the case when the direct_complete path is being executed by the PM core, as it then disables runtime PM for the device in __device_suspend(). Any following attempts to runtime resume the device after that point, just fails. A workaround to this problem is to let the driver runtime resume its device from its ->prepare() callback, as that would prevent the direct_complete path from being executed. However, that may often be a waste, especially if it turned out that no one really needed the device. For this reason, invent acpi_dev_disable|enable_direct_complete(), to allow drivers to inform the ACPI PM domain to change its default behaviour during system sleep, and thus control whether it may use the direct_complete path or not. Typically a driver should call acpi_dev_disable_direct_comlete() during ->probe() and acpi_dev_enable_direct_complete() in ->remove(). Signed-off-by: Ulf Hansson --- Changes in v2: - Moved the no_direct_complete flag to the struct acpi_device_power. --- drivers/acpi/device_pm.c | 38 +++++++++++++++++++++++++++++++++++++- include/acpi/acpi_bus.h | 1 + include/linux/acpi.h | 4 ++++ 3 files changed, 42 insertions(+), 1 deletion(-) -- 2.7.4 diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c index 5181057..f7bf596 100644 --- a/drivers/acpi/device_pm.c +++ b/drivers/acpi/device_pm.c @@ -933,6 +933,41 @@ EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume); #ifdef CONFIG_PM_SLEEP /** + * acpi_dev_disable_direct_complete - Disable the direct_complete path for ACPI. + * @dev: Device to disable the path for. + * + * Per default the ACPI PM domain tries to use the direct_complete path for its + * devices during system sleep. This function allows a user, typically a driver + * during probe, to disable the direct_complete path from being used by ACPI. + */ +void acpi_dev_disable_direct_complete(struct device *dev) +{ + struct acpi_device *adev = ACPI_COMPANION(dev); + + if (adev) + adev->power.no_direct_complete = true; +} +EXPORT_SYMBOL_GPL(acpi_dev_disable_direct_complete); + +/** + * acpi_dev_enable_direct_complete - Enable the direct_complete path for ACPI. + * @dev: Device to enable the path for. + * + * Enable the direct_complete path to be used during system suspend for the ACPI + * PM domain, which is the default option. Typically a driver that disabled the + * path during ->probe(), must call this function during ->remove() to re-enable + * the direct_complete path to be used by ACPI. + */ +void acpi_dev_enable_direct_complete(struct device *dev) +{ + struct acpi_device *adev = ACPI_COMPANION(dev); + + if (adev) + adev->power.no_direct_complete = false; +} +EXPORT_SYMBOL_GPL(acpi_dev_enable_direct_complete); + +/** * acpi_dev_suspend_late - Put device into a low-power state using ACPI. * @dev: Device to put into a low-power state. * @@ -1023,7 +1058,8 @@ int acpi_subsys_prepare(struct device *dev) if (ret < 0) return ret; - if (!adev || !pm_runtime_suspended(dev)) + if (!adev || adev->power.no_direct_complete || + !pm_runtime_suspended(dev)) return 0; return !acpi_dev_needs_resume(dev, adev); diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h index dedf9d7..bdec5f2 100644 --- a/include/acpi/acpi_bus.h +++ b/include/acpi/acpi_bus.h @@ -285,6 +285,7 @@ struct acpi_device_power_state { struct acpi_device_power { int state; /* Current state */ + bool no_direct_complete; struct acpi_device_power_flags flags; struct acpi_device_power_state states[ACPI_D_STATE_COUNT]; /* Power states (D0-D3Cold) */ }; diff --git a/include/linux/acpi.h b/include/linux/acpi.h index c1a5213..ec33c41 100644 --- a/include/linux/acpi.h +++ b/include/linux/acpi.h @@ -867,6 +867,8 @@ static inline int acpi_dev_pm_attach(struct device *dev, bool power_on) #endif #if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP) +void acpi_dev_disable_direct_complete(struct device *dev); +void acpi_dev_enable_direct_complete(struct device *dev); int acpi_dev_suspend_late(struct device *dev); int acpi_dev_resume_early(struct device *dev); int acpi_subsys_prepare(struct device *dev); @@ -876,6 +878,8 @@ int acpi_subsys_resume_early(struct device *dev); int acpi_subsys_suspend(struct device *dev); int acpi_subsys_freeze(struct device *dev); #else +static inline void acpi_dev_disable_direct_complete(struct device *dev) {} +static inline void acpi_dev_enable_direct_complete(struct device *dev) {} static inline int acpi_dev_suspend_late(struct device *dev) { return 0; } static inline int acpi_dev_resume_early(struct device *dev) { return 0; } static inline int acpi_subsys_prepare(struct device *dev) { return 0; }