From patchwork Wed May 17 07:02:42 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Viresh Kumar X-Patchwork-Id: 99905 Delivered-To: patch@linaro.org Received: by 10.140.96.100 with SMTP id j91csp100017qge; Wed, 17 May 2017 00:03:18 -0700 (PDT) X-Received: by 10.99.114.72 with SMTP id c8mr2142039pgn.81.1495004598247; Wed, 17 May 2017 00:03:18 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1495004598; cv=none; d=google.com; s=arc-20160816; b=Ie4i1xbEPDvD+QwrLIdfO9LPVZY9HwDzNsMhDOXx/UWx/S9tfH27QPeV9Pd6sdDooa hBmQcLkO/QlX2ZE4+v1sYOyzqVXjdtt+VCKUiuN4eVMgh+oXXc9bKCdFb/NoIf2joLvI xfUY5LIsXnFwEwTDGhYWpUgowyq0fEz+ygRuHsCOxVE7ZcqkPL0xYgCm6hz80aLvRphc lbsBdXyN9fXATDxp9ODlJ+Fdziyyp6E8eNVqfrIQn+PaSqFJ7PI/VgfUKvddui3psagC wvmzulDBnWQ97HLmkn3faA5CiDJyi0ndgbUbR/5seZcmiQ5sy2zuBBcAAYu6M2zdVvE4 O0ng== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:references :in-reply-to:message-id:date:subject:cc:to:from:dkim-signature :arc-authentication-results; bh=pvQFI599kS8XmedffgHGfPxgrZfgT5sK3HgfrO05dXg=; b=ATSZLE9ECC0uOu0YtG0o8Wk4Ub8SEmt5MVzUcFK27ZQ2XS7+iTwPGatwHDI34mhTPP BClb18g1HSKcq8dvm6/DR4TjqnoecJ9Gwm2mmHjxe5p8QVLA1urfhhQFBlAwciJ90yas 884RMHeawrGnXRUj+gmIJAzh70p1BBpsdktx2d0LCAEBtJW04gqJzcSeqzJsPkMQje5Z ZIPUSOv1qbWzGEo/Y/kyBQBXo6+sw/7ig9r3SBdghlQBUrLTZvKm/1WCIzQ4CiqABbaZ x4RJgnJPSS0fFt4a1Le1g8t/DX4mXuqs3owWxujI7w1ojFfRup6mFxo7hPeQkIi8s4my Ar8g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id y8si1257708pfd.317.2017.05.17.00.03.17; Wed, 17 May 2017 00:03:18 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753808AbdEQHCz (ORCPT + 25 others); Wed, 17 May 2017 03:02:55 -0400 Received: from mail-pg0-f45.google.com ([74.125.83.45]:33528 "EHLO mail-pg0-f45.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753786AbdEQHCw (ORCPT ); Wed, 17 May 2017 03:02:52 -0400 Received: by mail-pg0-f45.google.com with SMTP id u187so2663441pgb.0 for ; Wed, 17 May 2017 00:02:51 -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 :in-reply-to:references; bh=pvQFI599kS8XmedffgHGfPxgrZfgT5sK3HgfrO05dXg=; b=AIswF6eQ4AgLaPLYh9M53iQnyQKbE7PdeCQnWImwwLvo+MiUzhCibHlANEQiYzP1QJ QZ79GlNRNCpL8y2wpdxtAJHonPOLfp3zw5xv3kjL7HIhSjZm0qf0Ez2cbgxpFQZk1AnQ Qbf+qfE+yRKreu/N2lqXf5ktOazoZpng9fM28= 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:in-reply-to:references; bh=pvQFI599kS8XmedffgHGfPxgrZfgT5sK3HgfrO05dXg=; b=i0v9OtOvDlasXqHv9rhm8dUj7h82oS2gs7zZA1a8xoWvRUQQOBdqQfgLmliw3imOqp iMtYdQbO9/QsQN9oKu+yYAmbQFYKmdgCY8sFD38cGG2MYgZm6nEMQxcw/j57kUVPzgs1 ygVhSZRCll9hmxxXpigKKqtpM4Kx9TukfyVfKonyp+aIWOXo7/n6uzeRX06IZqr/NpLU MmrsbVQPlXHUe5IF0OExuO0QG5E8ZdJvvHS8ng2TWwAZ4k2esTjZEKb1clGfTdEcBwA1 OU0BHKQkFpN8BiVr3Hbq44zYTRzTeeugOmeGLLIWz2Di6GKukOxZuhyJpAezYFnBf63N VjTQ== X-Gm-Message-State: AODbwcAFPvVyfqnrs/NzoNKiDtnsC5TGu7/WZVgZ6L2+7nGQ76+sZY6H CW22Hhh9iIILV9Jr X-Received: by 10.99.2.3 with SMTP id 3mr2127054pgc.17.1495004570977; Wed, 17 May 2017 00:02:50 -0700 (PDT) Received: from localhost ([122.172.129.253]) by smtp.gmail.com with ESMTPSA id b1sm1893185pfc.27.2017.05.17.00.02.49 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 17 May 2017 00:02:50 -0700 (PDT) From: Viresh Kumar To: Rafael Wysocki , ulf.hansson@linaro.org, Kevin Hilman , Pavel Machek , Len Brown Cc: linaro-kernel@lists.linaro.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, Vincent Guittot , Stephen Boyd , Nishanth Menon , robh+dt@kernel.org, lina.iyer@linaro.org, rnayak@codeaurora.org, sudeep.holla@arm.com, Viresh Kumar Subject: [PATCH V7 1/2] PM / Domains: Add support to select performance-state of domains Date: Wed, 17 May 2017 12:32:42 +0530 Message-Id: <4cc55fce0fd4199941f1d7b785e677255ff792d5.1495003720.git.viresh.kumar@linaro.org> X-Mailer: git-send-email 2.13.0.303.g4ebf3021692d In-Reply-To: References: In-Reply-To: References: Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Some platforms have the capability to configure the performance state of their Power Domains. The performance levels are identified by positive integer values, a lower value represents lower performance state. This patch adds a new genpd API: pm_genpd_update_performance_state(). The caller passes the affected device and the frequency representing its next DVFS state. The power domains get two new callbacks: - get_performance_state(): This is called by the genpd core to retrieve the performance state (integer value) corresponding to a target frequency for the device. This state is used by the genpd core to find the highest requested state by all the devices powered by a domain. - set_performance_state(): The highest state retrieved from above interface is then passed to this callback to finally program the performance state of the power domain. The power domains can avoid supplying these callbacks, if they don't support setting performance-states. A power domain may have only get_performance_state() callback, if it doesn't have the capability of changing the performance state itself but someone in its parent hierarchy has. A power domain may have only set_performance_state(), it doesn't have any direct devices below it and only subdomains. And so the get_performance_state() will never get called. The more common case would be to have both the callbacks set. Another API, pm_genpd_has_performance_state(), is also added to let other parts of the kernel check if the power domain of a device supports performance-states or not. Note that the same performance level as returned by the parent domain of a device is used for every other domain in parent hierarchy. Signed-off-by: Viresh Kumar --- drivers/base/power/domain.c | 172 ++++++++++++++++++++++++++++++++++++++++++++ include/linux/pm_domain.h | 19 +++++ 2 files changed, 191 insertions(+) -- 2.13.0.303.g4ebf3021692d diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c index 71c95ad808d5..56b666eb1a71 100644 --- a/drivers/base/power/domain.c +++ b/drivers/base/power/domain.c @@ -466,6 +466,166 @@ static int genpd_dev_pm_qos_notifier(struct notifier_block *nb, return NOTIFY_DONE; } +/* + * Returns true if anyone in genpd's parent hierarchy has + * set_performance_state() set. + */ +static bool genpd_has_set_performance_state(struct generic_pm_domain *genpd) +{ + struct gpd_link *link; + + if (genpd->set_performance_state) + return true; + + list_for_each_entry(link, &genpd->slave_links, slave_node) { + if (genpd_has_set_performance_state(link->master)) + return true; + } + + return false; +} + +/** + * pm_genpd_has_performance_state - Checks if power domain does performance + * state management. + * + * @dev: Device whose power domain is getting inquired. + */ +bool pm_genpd_has_performance_state(struct device *dev) +{ + struct generic_pm_domain *genpd = dev_to_genpd(dev); + + /* The parent domain must have set get_performance_state() */ + if (!IS_ERR(genpd) && genpd->get_performance_state) + return true; + + return false; +} +EXPORT_SYMBOL_GPL(pm_genpd_has_performance_state); + +static int genpd_update_performance_state(struct generic_pm_domain *genpd, + int depth) +{ + struct generic_pm_domain_data *pd_data; + struct generic_pm_domain *subdomain; + struct pm_domain_data *pdd; + unsigned int state = 0, prev; + struct gpd_link *link; + int ret; + + /* Traverse all devices within the domain */ + list_for_each_entry(pdd, &genpd->dev_list, list_node) { + pd_data = to_gpd_data(pdd); + + if (pd_data->performance_state > state) + state = pd_data->performance_state; + } + + /* Traverse all subdomains within the domain */ + list_for_each_entry(link, &genpd->master_links, master_node) { + subdomain = link->slave; + + if (subdomain->performance_state > state) + state = subdomain->performance_state; + } + + if (genpd->performance_state == state) + return 0; + + /* + * Not all domains support updating performance state. Move on to their + * parent domains in that case. + */ + if (genpd->set_performance_state) { + ret = genpd->set_performance_state(genpd, state); + if (!ret) + genpd->performance_state = state; + + return ret; + } + + prev = genpd->performance_state; + genpd->performance_state = state; + + list_for_each_entry(link, &genpd->slave_links, slave_node) { + struct generic_pm_domain *master = link->master; + + genpd_lock_nested(master, depth + 1); + ret = genpd_update_performance_state(master, depth + 1); + genpd_unlock(master); + + if (!ret) + continue; + + /* + * Preserve earlier state for all the power domains which have + * been updated. + */ + genpd->performance_state = prev; + + list_for_each_entry(link, &genpd->slave_links, slave_node) { + struct generic_pm_domain *nmaster = link->master; + + if (nmaster == master) + break; + + genpd_lock_nested(nmaster, depth + 1); + genpd_update_performance_state(master, depth + 1); + genpd_unlock(master); + } + + return ret; + } + + return 0; +} + +/** + * pm_genpd_update_performance_state - Update performance state of parent power + * domain for the target frequency for the device. + * + * @dev: Device for which the performance-state needs to be adjusted. + * @rate: Device's next frequency. + */ +int pm_genpd_update_performance_state(struct device *dev, unsigned long rate) +{ + struct generic_pm_domain *genpd = ERR_PTR(-ENODATA); + struct generic_pm_domain_data *gpd_data; + int ret, prev; + + spin_lock_irq(&dev->power.lock); + if (dev->power.subsys_data && dev->power.subsys_data->domain_data) { + gpd_data = to_gpd_data(dev->power.subsys_data->domain_data); + genpd = dev_to_genpd(dev); + } + spin_unlock_irq(&dev->power.lock); + + if (IS_ERR(genpd)) + return -ENODEV; + + if (!genpd->get_performance_state) { + dev_err(dev, "Performance states aren't supported by power domain\n"); + return -EINVAL; + } + + genpd_lock(genpd); + ret = genpd->get_performance_state(dev, rate); + if (ret < 0) + goto unlock; + + prev = gpd_data->performance_state; + gpd_data->performance_state = ret; + ret = genpd_update_performance_state(genpd, 0); + if (ret) + gpd_data->performance_state = prev; + +unlock: + genpd_unlock(genpd); + + return ret; +} +EXPORT_SYMBOL_GPL(pm_genpd_update_performance_state); + /** * genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0. * @work: Work structure used for scheduling the execution of this function. @@ -1156,6 +1316,7 @@ static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev, gpd_data->td.constraint_changed = true; gpd_data->td.effective_constraint_ns = -1; gpd_data->nb.notifier_call = genpd_dev_pm_qos_notifier; + gpd_data->performance_state = 0; spin_lock_irq(&dev->power.lock); @@ -1502,6 +1663,17 @@ int pm_genpd_init(struct generic_pm_domain *genpd, genpd->dev_ops.start = pm_clk_resume; } + /* + * If this genpd supports getting performance state, then someone in its + * hierarchy must support setting it too. + */ + if (genpd->get_performance_state && + !genpd_has_set_performance_state(genpd)) { + pr_err("%s: genpd doesn't support updating performance state\n", + genpd->name); + return -ENODEV; + } + /* Always-on domains must be powered on at initialization. */ if (genpd_is_always_on(genpd) && !genpd_status_on(genpd)) return -EINVAL; diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h index b7803a251044..74502664ea33 100644 --- a/include/linux/pm_domain.h +++ b/include/linux/pm_domain.h @@ -63,8 +63,12 @@ struct generic_pm_domain { unsigned int device_count; /* Number of devices */ unsigned int suspended_count; /* System suspend device counter */ unsigned int prepared_count; /* Suspend counter of prepared devices */ + unsigned int performance_state; /* Max requested performance state */ int (*power_off)(struct generic_pm_domain *domain); int (*power_on)(struct generic_pm_domain *domain); + int (*get_performance_state)(struct device *dev, unsigned long rate); + int (*set_performance_state)(struct generic_pm_domain *domain, + unsigned int state); struct gpd_dev_ops dev_ops; s64 max_off_time_ns; /* Maximum allowed "suspended" time. */ bool max_off_time_changed; @@ -118,6 +122,7 @@ struct generic_pm_domain_data { struct pm_domain_data base; struct gpd_timing_data td; struct notifier_block nb; + unsigned int performance_state; void *data; }; @@ -148,6 +153,9 @@ extern int pm_genpd_remove(struct generic_pm_domain *genpd); extern struct dev_power_governor simple_qos_governor; extern struct dev_power_governor pm_domain_always_on_gov; +extern bool pm_genpd_has_performance_state(struct device *dev); +extern int pm_genpd_update_performance_state(struct device *dev, + unsigned long rate); #else static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev) @@ -185,6 +193,17 @@ static inline int pm_genpd_remove(struct generic_pm_domain *genpd) return -ENOTSUPP; } +static inline bool pm_genpd_has_performance_state(struct device *dev) +{ + return false; +} + +static inline int pm_genpd_update_performance_state(struct device *dev, + unsigned long rate) +{ + return -ENOTSUPP; +} + #define simple_qos_governor (*(struct dev_power_governor *)(NULL)) #define pm_domain_always_on_gov (*(struct dev_power_governor *)(NULL)) #endif