From patchwork Thu May 31 10:59:59 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ulf Hansson X-Patchwork-Id: 137361 Delivered-To: patches@linaro.org Received: by 2002:a2e:9706:0:0:0:0:0 with SMTP id r6-v6csp6441396lji; Thu, 31 May 2018 04:00:14 -0700 (PDT) X-Received: by 2002:a2e:9ac4:: with SMTP id p4-v6mr1119772ljj.60.1527764414637; Thu, 31 May 2018 04:00:14 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1527764414; cv=none; d=google.com; s=arc-20160816; b=ja51FGHrB0ZuAKBKG5x+yuzzXaOjLA5RwcesnySU1DljU/3mKAL0MRv9h3Uw4VZ5qb VeOR4yx7z7UIv0spQrUku19l7gl7EFZX3DCFai1H6fVMcx1/BoPgJJ+OnC5ZhqjDJbsy iuk5dztEpqYDK/eZ6CzRqZnSsTatSAUF/dxlop3FKZjHUBptonRW1W+RdRc1fWMdUsDT pQlNFlMHMTdMDhxE8ZhbTmDrWN8/JZylIcZC3MsNp69gFFJFawhpkSAr+iCc97RJXCtH rbImKv3jYeF+73x36ItFzbawkZXPbhiQS6rv02HHKy0kX4ZYEwvJdTZWtTGTbEzRJ0YN o9gA== 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=cWUDGKzaf3nKb2Zo8t5+5svs98XA+o/lGIHL4mv1YHE=; b=hEchBT3eJgOEa2X5t9EQkItgYApebwOn02sOjhkuNOWlcEi7K1s+2tbPd8MR9F7Zva u1/KKaN/seibaTUL/rlx15beLsvIL3SiaJ6YHu96bCEman3lf70Tbn5BSQzGiIr6VUmJ c/NybPAHq3RcYUrvbmfQKmyIqDzEBOBGuDhTAv0UWwKxJKdWQhU4a7VOxopdPyKFotrU ve3g5PeK8N26EnSjvJJOdBWgZx5noEYnHfs3xa3yJOyC4M5zpmH1HZvOFr/XmYVGhHc/ JcreWhqS/99jd2m0xegI7ktk6RPoN0FgJPc+oEDV5hxTczJ3Bkg3u0TTsdwwKgKXbrIK dKyw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=LGSJB2u3; 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 k19-v6sor6680589lfj.80.2018.05.31.04.00.14 for (Google Transport Security); Thu, 31 May 2018 04:00:14 -0700 (PDT) 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=LGSJB2u3; 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; bh=cWUDGKzaf3nKb2Zo8t5+5svs98XA+o/lGIHL4mv1YHE=; b=LGSJB2u3Ty6A07G4YdCMukVUH6MT8eEXJSbM5G73Ckip4UaXDeIdXxAJBEOJtmamcS +tctrSqKQHlJnsWB96z8jjBJW0FDps1J3oXu/FTJ1OzmdZLaPXJ4BW3owGwjS473rxjc 74TcYkvqs64lHUlg37Zr6USpwh8Lv/DKq5Okk= 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=cWUDGKzaf3nKb2Zo8t5+5svs98XA+o/lGIHL4mv1YHE=; b=dEX2IpH+R+Y0ZOTlckkLtzsOmgN9nMxHVvVnJ3ZOj3sSXw8nv7+RBU9jRgWoZfQkNr AB1HW717yMBxozDCPTFpd9mqnN2PQfAmLdH7+NyNQUyOl2a4cu0RN6T5NJHmtxR2u3EO Rll6AQ+JVlEpXxZlwvs6WbGuQJ1W+rXRLYT55sVKFT9lUbGeUNqYIfBlhkAlknJ4xR9M XW6hd1kN/ceLhUeRZ72J4DN7C6QgxBhfGoPZomofR7k9PoNafVC2bYDj+8piRlBLw1dK zu4gtFCHD9eGEIjV3WFhXlAMtYwT1YP0I7JZJYwRnbR+wRGLZpb8oN06cgkEV567gkYV V/9Q== X-Gm-Message-State: ALKqPwevDbaalsR+leon59jzuIVCBB/Fl3zB4JaVFgkcJkiip1fUYMAJ q3D9kOrRY5iF3wPUDQvWUgh3uHFN X-Google-Smtp-Source: ADUXVKIGQzNkabL2KsPiRHcdiTzt3kpedg7uT3BwPSDerc7DgjDhN8gpDYkbcw0Q1znCd1NCb0Rpmw== X-Received: by 2002:a19:e117:: with SMTP id y23-v6mr4062062lfg.9.1527764414336; Thu, 31 May 2018 04:00:14 -0700 (PDT) Return-Path: Received: from localhost.localdomain (h-158-174-22-210.NA.cust.bahnhof.se. [158.174.22.210]) by smtp.gmail.com with ESMTPSA id b20-v6sm7454383ljf.51.2018.05.31.04.00.12 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 31 May 2018 04:00:13 -0700 (PDT) From: Ulf Hansson To: "Rafael J . Wysocki" , linux-pm@vger.kernel.org Cc: Ulf Hansson , Greg Kroah-Hartman , Jon Hunter , Geert Uytterhoeven , Todor Tomov , Rajendra Nayak , Viresh Kumar , Vincent Guittot , Kevin Hilman , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-tegra@vger.kernel.org Subject: [PATCH v3 5/5] PM / Domains: Add dev_pm_domain_attach_by_id() to manage multi PM domains Date: Thu, 31 May 2018 12:59:59 +0200 Message-Id: <20180531105959.14843-6-ulf.hansson@linaro.org> X-Mailer: git-send-email 2.17.0 In-Reply-To: <20180531105959.14843-1-ulf.hansson@linaro.org> References: <20180531105959.14843-1-ulf.hansson@linaro.org> The existing dev_pm_domain_attach() function, allows a single PM domain to be attached per device. To be able to support devices that are partitioned across multiple PM domains, let's introduce a new interface, dev_pm_domain_attach_by_id(). The dev_pm_domain_attach_by_id() returns a new allocated struct device with the corresponding attached PM domain. This enables for example a driver to operate on the new device from a power management point of view. The driver may then also benefit from using the received device, to set up so called device-links towards its original device. Depending on the situation, these links may then be dynamically changed. The new interface is typically called by drivers during their probe phase, in case they manages devices which uses multiple PM domains. If that is the case, the driver also becomes responsible of managing the detaching of the PM domains, which typically should be done at the remove phase. Detaching is done by calling the existing dev_pm_domain_detach() function and for each of the received devices from dev_pm_domain_attach_by_id(). Note, currently its only genpd that supports multiple PM domains per device, but dev_pm_domain_attach_by_id() can easily by extended to cover other PM domain types, if/when needed. Signed-off-by: Ulf Hansson Acked-by: Jon Hunter Tested-by: Jon Hunter Reviewed-by: Viresh Kumar --- drivers/base/power/common.c | 43 ++++++++++++++++++++++++++++++++++--- include/linux/pm_domain.h | 7 ++++++ 2 files changed, 47 insertions(+), 3 deletions(-) -- 2.17.0 diff --git a/drivers/base/power/common.c b/drivers/base/power/common.c index 7ae62b6355b8..df41b4780b3b 100644 --- a/drivers/base/power/common.c +++ b/drivers/base/power/common.c @@ -116,14 +116,51 @@ int dev_pm_domain_attach(struct device *dev, bool power_on) } EXPORT_SYMBOL_GPL(dev_pm_domain_attach); +/** + * dev_pm_domain_attach_by_id - Associate a device with one of its PM domains. + * @dev: The device used to lookup the PM domain. + * @index: The index of the PM domain. + * + * As @dev may only be attached to a single PM domain, the backend PM domain + * provider creates a virtual device to attach instead. If attachment succeeds, + * the ->detach() callback in the struct dev_pm_domain are assigned by the + * corresponding backend attach function, as to deal with detaching of the + * created virtual device. + * + * This function should typically be invoked by a driver during the probe phase, + * in case its device requires power management through multiple PM domains. The + * driver may benefit from using the received device, to configure device-links + * towards its original device. Depending on the use-case and if needed, the + * links may be dynamically changed by the driver, which allows it to control + * the power to the PM domains independently from each other. + * + * Callers must ensure proper synchronization of this function with power + * management callbacks. + * + * Returns the virtual created device when successfully attached to its PM + * domain, NULL in case @dev don't need a PM domain, else an ERR_PTR(). + * Note that, to detach the returned virtual device, the driver shall call + * dev_pm_domain_detach() on it, typically during the remove phase. + */ +struct device *dev_pm_domain_attach_by_id(struct device *dev, + unsigned int index) +{ + if (dev->pm_domain) + return ERR_PTR(-EEXIST); + + return genpd_dev_pm_attach_by_id(dev, index); +} +EXPORT_SYMBOL_GPL(dev_pm_domain_attach_by_id); + /** * dev_pm_domain_detach - Detach a device from its PM domain. * @dev: Device to detach. * @power_off: Used to indicate whether we should power off the device. * - * This functions will reverse the actions from dev_pm_domain_attach() and thus - * try to detach the @dev from its PM domain. Typically it should be invoked - * from subsystem level code during the remove phase. + * This functions will reverse the actions from dev_pm_domain_attach() and + * dev_pm_domain_attach_by_id(), thus it detaches @dev from its PM domain. + * Typically it should be invoked during the remove phase, either from + * subsystem level code or from drivers. * * Callers must ensure proper synchronization of this function with power * management callbacks. diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h index 82458e8e2e01..9206a4fef9ac 100644 --- a/include/linux/pm_domain.h +++ b/include/linux/pm_domain.h @@ -299,6 +299,8 @@ struct generic_pm_domain *of_genpd_remove_last(struct device_node *np) #ifdef CONFIG_PM int dev_pm_domain_attach(struct device *dev, bool power_on); +struct device *dev_pm_domain_attach_by_id(struct device *dev, + unsigned int index); void dev_pm_domain_detach(struct device *dev, bool power_off); void dev_pm_domain_set(struct device *dev, struct dev_pm_domain *pd); #else @@ -306,6 +308,11 @@ static inline int dev_pm_domain_attach(struct device *dev, bool power_on) { return 0; } +static inline struct device *dev_pm_domain_attach_by_id(struct device *dev, + unsigned int index) +{ + return NULL; +} static inline void dev_pm_domain_detach(struct device *dev, bool power_off) {} static inline void dev_pm_domain_set(struct device *dev, struct dev_pm_domain *pd) {}