From patchwork Tue May 29 10:04:20 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ulf Hansson X-Patchwork-Id: 137142 Delivered-To: patches@linaro.org Received: by 2002:a2e:9706:0:0:0:0:0 with SMTP id r6-v6csp3845547lji; Tue, 29 May 2018 03:04:41 -0700 (PDT) X-Received: by 2002:a2e:3e0c:: with SMTP id l12-v6mr10689250lja.23.1527588281429; Tue, 29 May 2018 03:04:41 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1527588281; cv=none; d=google.com; s=arc-20160816; b=zlFJBHxWQ/NCSFFbmPdgZoSXWZGwjNX47TRHererNXhVx18GOPGCHcigXEp4SqBEM8 gkhUwlEPByZHA1ox+B1fahPkEOmmplIVNBpfdqmvNXx6ioew8Jnm2+dydDjpFTG24sWQ 20W+f4U6ticTknNiNxC0lS64TjzHPxbwKAIlcwkzAINdJF/aO2o0qO1x4k18hrU/sYM3 rsbB4q/k25LgrafIdp4iKaPIrceDeXk4V3Ib8tTCET2IP3TVkwnADpONZOuIiW8pB453 jM/xCShyAeH63KD4d8o1LU9De7qnFFDsAPFRckBXW4/f6c2g3vZI6Km2BWDu/avk4Lhu mSMw== 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=4AKcocpDu8LzFvQQptUzJpFM524E5IXAqb+rjvCBc/c=; b=phVlCZB4xbcC4ugt7Af8N4TGf7GG9A+3CL4rJFKdDnHh7tWPTnWjoeOb0CEBvV3tHX F6Gzb3As3QLz3GCGunw2Tl/4/LiOwrv5Hkw4037H6TZbW/cd1U/bmLmcS5IW7uZS1/bf mNEBbFjNsr5yxguJ3HmhRa6hH2sTtKCla6u+4LZ4/Xd0KtFD5P9h2lRW22SZEcSgjqlf qS+wV5zrhMhNUeWEYnMgbQJv20mpIFJRAJf65/6NKMGO6bfcSDqgog1XZARPHPZpGdgs sq3Rtb8svS2a7cAsRPk0c60zVC44+5kUW1Yl7RG/u6GHSdAFYn7uTbPK7xQZkpzfFPVk vkfQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ZZJD24OS; 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 u10-v6sor2263544ljh.109.2018.05.29.03.04.41 for (Google Transport Security); Tue, 29 May 2018 03:04:41 -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=ZZJD24OS; 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=4AKcocpDu8LzFvQQptUzJpFM524E5IXAqb+rjvCBc/c=; b=ZZJD24OSCW897IXk7gN0gsb538Ig7zxjlS3qOtp99xeQh2i2UskamIfmgRM7lHsKnr nK1yXnN+vDVZjpTWJIu0A4f6F9y/IaZnqPl2mFEhssWHHjOog4mQdHPkC/pTV8dnfq0P hIhci/jpMHG3M4VejT5BBJW/dpRmS1mqPOlzI= 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=4AKcocpDu8LzFvQQptUzJpFM524E5IXAqb+rjvCBc/c=; b=hbbI9Iacy1oBWUiCNaH5Rd1v+p9NMYLTOLFLOVStQNrmUAzRNAm8vHRmiKrcwUMSLh V5ym6DogDDVujkND3FHQZAfGsT8piJ5gswOy9jrvbdXUrH+8wzzzT78N70J80xlNkNeZ iH6Q1HqW1yBb/jpmjLCIIQoAfB+7q8vYEzL6wRKugbNJ0XMPVA72WXbhwUFLCyhYvReQ +4LXhGl29263I1BqzNegqu+eBcpPAUjJW4ZoMFUGoaY/9McvoLVsRmGDux0ypwNJHW8Q CP6W+M5NDLAC27d+XMUHHMz+FhZmUsop1mdlanYzUFR81vlgN2+3Mmm71SwjGvMjVzeg AmzA== X-Gm-Message-State: ALKqPwc71cEN0Nbb9mpfeG5/LQvL8Wh6fDDjnGtZYQeTY2j/lXj+UEv6 kBOaXCvpElW4wpQufTRS1+vrzUrIskO/Bw== X-Google-Smtp-Source: ADUXVKJeObP68e8ut4WHB00kxNq4iihomAaNX61RuLdxYWga3Fsyujl/yYKCgHyZzeWajzklXEstPw== X-Received: by 2002:a2e:8948:: with SMTP id b8-v6mr10916487ljk.31.1527588281021; Tue, 29 May 2018 03:04:41 -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 e21-v6sm2561718lfg.74.2018.05.29.03.04.39 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 29 May 2018 03:04:40 -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 v2 8/9] PM / Domains: Add support for multi PM domains per device to genpd Date: Tue, 29 May 2018 12:04:20 +0200 Message-Id: <20180529100421.31022-9-ulf.hansson@linaro.org> X-Mailer: git-send-email 2.17.0 In-Reply-To: <20180529100421.31022-1-ulf.hansson@linaro.org> References: <20180529100421.31022-1-ulf.hansson@linaro.org> To support devices being partitioned across multiple PM domains, let's begin with extending genpd to cope with these kind of configurations. Therefore, add a new exported function genpd_dev_pm_attach_by_id(), which is similar to the existing genpd_dev_pm_attach(), but with the difference that it allows its callers to provide an index to the PM domain that it wants to attach. Note that, genpd_dev_pm_attach_by_id() shall only be called by the driver core / PM core, similar to how the existing dev_pm_domain_attach() makes use of genpd_dev_pm_attach(). However, this is implemented by following changes on top. Because, only one PM domain can be attached per device, genpd needs to create a virtual device that it can attach/detach instead. More precisely, let the new function genpd_dev_pm_attach_by_id() register a virtual struct device via calling device_register(). Then let it attach this device to the corresponding PM domain, rather than the one that is provided by the caller. The actual attaching is done via re-using the existing genpd OF functions. At successful attachment, genpd_dev_pm_attach_by_id() returns the created virtual device, which allows the caller to operate on it to deal with power management. Following changes on top, provides more details in this regards. To deal with detaching of a PM domain for the multiple PM domains case, let's also extend the existing genpd_dev_pm_detach() function, to cover the cleanup of the created virtual device, via make it call device_unregister() on it. In this way, there is no need to introduce a new function to deal with detach for the multiple PM domain case, but instead the existing one is re-used. Signed-off-by: Ulf Hansson --- Changes in v2: - Fixed comments from Jon. Clarified function descriptions and changelog. --- drivers/base/power/domain.c | 80 +++++++++++++++++++++++++++++++++++++ include/linux/pm_domain.h | 8 ++++ 2 files changed, 88 insertions(+) -- 2.17.0 diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c index 2af99bfcbe3c..2b496d79159d 100644 --- a/drivers/base/power/domain.c +++ b/drivers/base/power/domain.c @@ -2171,6 +2171,15 @@ struct generic_pm_domain *of_genpd_remove_last(struct device_node *np) } EXPORT_SYMBOL_GPL(of_genpd_remove_last); +static void genpd_release_dev(struct device *dev) +{ + kfree(dev); +} + +static struct bus_type genpd_bus_type = { + .name = "genpd", +}; + /** * genpd_dev_pm_detach - Detach a device from its PM domain. * @dev: Device to detach. @@ -2208,6 +2217,10 @@ static void genpd_dev_pm_detach(struct device *dev, bool power_off) /* Check if PM domain can be powered off after removing this device. */ genpd_queue_power_off_work(pd); + + /* Unregister the device if it was created by genpd. */ + if (dev->bus == &genpd_bus_type) + device_unregister(dev); } static void genpd_dev_pm_sync(struct device *dev) @@ -2298,6 +2311,67 @@ int genpd_dev_pm_attach(struct device *dev) } EXPORT_SYMBOL_GPL(genpd_dev_pm_attach); +/** + * genpd_dev_pm_attach_by_id() - Attach a device to one of its PM domain. + * @dev: Device to attach. + * @index: The index of the PM domain. + * + * Parse device's OF node to find a PM domain specifier at the provided @index. + * If such is found, creates a virtual device and attaches it to the retrieved + * pm_domain ops. To deal with detaching of the virtual device, the ->detach() + * callback in the struct dev_pm_domain are assigned to genpd_dev_pm_detach(). + * + * Returns the created virtual device if successfully attached PM domain, NULL + * when the device don't need a PM domain, else an ERR_PTR() in case of + * failures. If a power-domain exists for the device, but cannot be found or + * turned on, then ERR_PTR(-EPROBE_DEFER) is returned to ensure that the device + * is not probed and to re-try again later. + */ +struct device *genpd_dev_pm_attach_by_id(struct device *dev, + unsigned int index) +{ + struct device *genpd_dev; + int num_domains; + int ret; + + if (!dev->of_node) + return NULL; + + /* Deal only with devices using multiple PM domains. */ + num_domains = of_count_phandle_with_args(dev->of_node, "power-domains", + "#power-domain-cells"); + if (num_domains < 2 || index >= num_domains) + return NULL; + + /* Allocate and register device on the genpd bus. */ + genpd_dev = kzalloc(sizeof(*genpd_dev), GFP_KERNEL); + if (!genpd_dev) + return ERR_PTR(-ENOMEM); + + dev_set_name(genpd_dev, "genpd:%u:%s", index, dev_name(dev)); + genpd_dev->bus = &genpd_bus_type; + genpd_dev->release = genpd_release_dev; + + ret = device_register(genpd_dev); + if (ret) { + kfree(genpd_dev); + return ERR_PTR(ret); + } + + /* Try to attach the device to the PM domain at the specified index. */ + ret = __genpd_dev_pm_attach(genpd_dev, dev->of_node, index); + if (ret < 1) { + device_unregister(genpd_dev); + return ret ? ERR_PTR(ret) : NULL; + } + + pm_runtime_set_active(genpd_dev); + pm_runtime_enable(genpd_dev); + + return genpd_dev; +} +EXPORT_SYMBOL_GPL(genpd_dev_pm_attach_by_id); + static const struct of_device_id idle_state_match[] = { { .compatible = "domain-idle-state", }, { } @@ -2457,6 +2531,12 @@ unsigned int of_genpd_opp_to_performance_state(struct device *dev, } EXPORT_SYMBOL_GPL(of_genpd_opp_to_performance_state); +static int __init genpd_bus_init(void) +{ + return bus_register(&genpd_bus_type); +} +core_initcall(genpd_bus_init); + #endif /* CONFIG_PM_GENERIC_DOMAINS_OF */ diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h index 42e0d649e653..82458e8e2e01 100644 --- a/include/linux/pm_domain.h +++ b/include/linux/pm_domain.h @@ -237,6 +237,8 @@ unsigned int of_genpd_opp_to_performance_state(struct device *dev, struct device_node *opp_node); int genpd_dev_pm_attach(struct device *dev); +struct device *genpd_dev_pm_attach_by_id(struct device *dev, + unsigned int index); #else /* !CONFIG_PM_GENERIC_DOMAINS_OF */ static inline int of_genpd_add_provider_simple(struct device_node *np, struct generic_pm_domain *genpd) @@ -282,6 +284,12 @@ static inline int genpd_dev_pm_attach(struct device *dev) return 0; } +static inline struct device *genpd_dev_pm_attach_by_id(struct device *dev, + unsigned int index) +{ + return NULL; +} + static inline struct generic_pm_domain *of_genpd_remove_last(struct device_node *np) {