1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * drivers/base/power/domain_governor.c - Governors for device PM domains.
  4 *
  5 * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
  6 */
  7#include <linux/kernel.h>
  8#include <linux/pm_domain.h>
  9#include <linux/pm_qos.h>
 10#include <linux/hrtimer.h>
 11#include <linux/cpuidle.h>
 12#include <linux/cpumask.h>
 13#include <linux/ktime.h>
 14
 15static int dev_update_qos_constraint(struct device *dev, void *data)
 16{
 17	s64 *constraint_ns_p = data;
 18	s64 constraint_ns;
 19
 20	if (dev->power.subsys_data && dev->power.subsys_data->domain_data) {
 21		/*
 22		 * Only take suspend-time QoS constraints of devices into
 23		 * account, because constraints updated after the device has
 24		 * been suspended are not guaranteed to be taken into account
 25		 * anyway.  In order for them to take effect, the device has to
 26		 * be resumed and suspended again.
 27		 */
 28		constraint_ns = dev_gpd_data(dev)->td.effective_constraint_ns;
 29	} else {
 30		/*
 31		 * The child is not in a domain and there's no info on its
 32		 * suspend/resume latencies, so assume them to be negligible and
 33		 * take its current PM QoS constraint (that's the only thing
 34		 * known at this point anyway).
 35		 */
 36		constraint_ns = dev_pm_qos_read_value(dev, DEV_PM_QOS_RESUME_LATENCY);
 37		constraint_ns *= NSEC_PER_USEC;
 38	}
 39
 40	if (constraint_ns < *constraint_ns_p)
 41		*constraint_ns_p = constraint_ns;
 42
 43	return 0;
 44}
 45
 46/**
 47 * default_suspend_ok - Default PM domain governor routine to suspend devices.
 48 * @dev: Device to check.
 49 */
 50static bool default_suspend_ok(struct device *dev)
 51{
 52	struct gpd_timing_data *td = &dev_gpd_data(dev)->td;
 53	unsigned long flags;
 54	s64 constraint_ns;
 55
 56	dev_dbg(dev, "%s()\n", __func__);
 57
 58	spin_lock_irqsave(&dev->power.lock, flags);
 59
 60	if (!td->constraint_changed) {
 61		bool ret = td->cached_suspend_ok;
 62
 63		spin_unlock_irqrestore(&dev->power.lock, flags);
 64		return ret;
 65	}
 66	td->constraint_changed = false;
 67	td->cached_suspend_ok = false;
 68	td->effective_constraint_ns = 0;
 69	constraint_ns = __dev_pm_qos_resume_latency(dev);
 70
 71	spin_unlock_irqrestore(&dev->power.lock, flags);
 72
 73	if (constraint_ns == 0)
 74		return false;
 75
 76	constraint_ns *= NSEC_PER_USEC;
 77	/*
 78	 * We can walk the children without any additional locking, because
 79	 * they all have been suspended at this point and their
 80	 * effective_constraint_ns fields won't be modified in parallel with us.
 81	 */
 82	if (!dev->power.ignore_children)
 83		device_for_each_child(dev, &constraint_ns,
 84				      dev_update_qos_constraint);
 85
 86	if (constraint_ns == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS) {
 87		/* "No restriction", so the device is allowed to suspend. */
 88		td->effective_constraint_ns = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS;
 89		td->cached_suspend_ok = true;
 90	} else if (constraint_ns == 0) {
 91		/*
 92		 * This triggers if one of the children that don't belong to a
 93		 * domain has a zero PM QoS constraint and it's better not to
 94		 * suspend then.  effective_constraint_ns is zero already and
 95		 * cached_suspend_ok is false, so bail out.
 96		 */
 97		return false;
 98	} else {
 99		constraint_ns -= td->suspend_latency_ns +
100				td->resume_latency_ns;
101		/*
102		 * effective_constraint_ns is zero already and cached_suspend_ok
103		 * is false, so if the computed value is not positive, return
104		 * right away.
105		 */
106		if (constraint_ns <= 0)
107			return false;
108
109		td->effective_constraint_ns = constraint_ns;
110		td->cached_suspend_ok = true;
111	}
112
113	/*
114	 * The children have been suspended already, so we don't need to take
115	 * their suspend latencies into account here.
116	 */
117	return td->cached_suspend_ok;
118}
119
120static bool __default_power_down_ok(struct dev_pm_domain *pd,
121				     unsigned int state)
122{
123	struct generic_pm_domain *genpd = pd_to_genpd(pd);
124	struct gpd_link *link;
125	struct pm_domain_data *pdd;
126	s64 min_off_time_ns;
127	s64 off_on_time_ns;
128
129	off_on_time_ns = genpd->states[state].power_off_latency_ns +
130		genpd->states[state].power_on_latency_ns;
131
132	min_off_time_ns = -1;
133	/*
134	 * Check if subdomains can be off for enough time.
135	 *
136	 * All subdomains have been powered off already at this point.
137	 */
138	list_for_each_entry(link, &genpd->parent_links, parent_node) {
139		struct generic_pm_domain *sd = link->child;
140		s64 sd_max_off_ns = sd->max_off_time_ns;
141
142		if (sd_max_off_ns < 0)
143			continue;
144
145		/*
146		 * Check if the subdomain is allowed to be off long enough for
147		 * the current domain to turn off and on (that's how much time
148		 * it will have to wait worst case).
149		 */
150		if (sd_max_off_ns <= off_on_time_ns)
151			return false;
152
153		if (min_off_time_ns > sd_max_off_ns || min_off_time_ns < 0)
154			min_off_time_ns = sd_max_off_ns;
155	}
156
157	/*
158	 * Check if the devices in the domain can be off enough time.
159	 */
160	list_for_each_entry(pdd, &genpd->dev_list, list_node) {
161		struct gpd_timing_data *td;
162		s64 constraint_ns;
163
164		/*
165		 * Check if the device is allowed to be off long enough for the
166		 * domain to turn off and on (that's how much time it will
167		 * have to wait worst case).
168		 */
169		td = &to_gpd_data(pdd)->td;
170		constraint_ns = td->effective_constraint_ns;
171		/*
172		 * Zero means "no suspend at all" and this runs only when all
173		 * devices in the domain are suspended, so it must be positive.
174		 */
175		if (constraint_ns == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS)
176			continue;
177
178		if (constraint_ns <= off_on_time_ns)
179			return false;
180
181		if (min_off_time_ns > constraint_ns || min_off_time_ns < 0)
182			min_off_time_ns = constraint_ns;
183	}
184
185	/*
186	 * If the computed minimum device off time is negative, there are no
187	 * latency constraints, so the domain can spend arbitrary time in the
188	 * "off" state.
189	 */
190	if (min_off_time_ns < 0)
191		return true;
192
193	/*
194	 * The difference between the computed minimum subdomain or device off
195	 * time and the time needed to turn the domain on is the maximum
196	 * theoretical time this domain can spend in the "off" state.
197	 */
198	genpd->max_off_time_ns = min_off_time_ns -
199		genpd->states[state].power_on_latency_ns;
200	return true;
201}
202
203/**
204 * default_power_down_ok - Default generic PM domain power off governor routine.
205 * @pd: PM domain to check.
206 *
207 * This routine must be executed under the PM domain's lock.
208 */
209static bool default_power_down_ok(struct dev_pm_domain *pd)
210{
211	struct generic_pm_domain *genpd = pd_to_genpd(pd);
212	struct gpd_link *link;
213
214	if (!genpd->max_off_time_changed) {
215		genpd->state_idx = genpd->cached_power_down_state_idx;
216		return genpd->cached_power_down_ok;
217	}
218
219	/*
220	 * We have to invalidate the cached results for the parents, so
221	 * use the observation that default_power_down_ok() is not
222	 * going to be called for any parent until this instance
223	 * returns.
224	 */
225	list_for_each_entry(link, &genpd->child_links, child_node)
226		link->parent->max_off_time_changed = true;
227
228	genpd->max_off_time_ns = -1;
229	genpd->max_off_time_changed = false;
230	genpd->cached_power_down_ok = true;
231	genpd->state_idx = genpd->state_count - 1;
232
233	/* Find a state to power down to, starting from the deepest. */
234	while (!__default_power_down_ok(pd, genpd->state_idx)) {
235		if (genpd->state_idx == 0) {
236			genpd->cached_power_down_ok = false;
237			break;
238		}
239		genpd->state_idx--;
240	}
241
242	genpd->cached_power_down_state_idx = genpd->state_idx;
243	return genpd->cached_power_down_ok;
244}
245
246static bool always_on_power_down_ok(struct dev_pm_domain *domain)
247{
248	return false;
249}
250
251#ifdef CONFIG_CPU_IDLE
252static bool cpu_power_down_ok(struct dev_pm_domain *pd)
253{
254	struct generic_pm_domain *genpd = pd_to_genpd(pd);
255	struct cpuidle_device *dev;
256	ktime_t domain_wakeup, next_hrtimer;
257	s64 idle_duration_ns;
258	int cpu, i;
259
260	/* Validate dev PM QoS constraints. */
261	if (!default_power_down_ok(pd))
262		return false;
263
264	if (!(genpd->flags & GENPD_FLAG_CPU_DOMAIN))
265		return true;
266
267	/*
268	 * Find the next wakeup for any of the online CPUs within the PM domain
269	 * and its subdomains. Note, we only need the genpd->cpus, as it already
270	 * contains a mask of all CPUs from subdomains.
271	 */
272	domain_wakeup = ktime_set(KTIME_SEC_MAX, 0);
273	for_each_cpu_and(cpu, genpd->cpus, cpu_online_mask) {
274		dev = per_cpu(cpuidle_devices, cpu);
275		if (dev) {
276			next_hrtimer = READ_ONCE(dev->next_hrtimer);
277			if (ktime_before(next_hrtimer, domain_wakeup))
278				domain_wakeup = next_hrtimer;
279		}
280	}
281
282	/* The minimum idle duration is from now - until the next wakeup. */
283	idle_duration_ns = ktime_to_ns(ktime_sub(domain_wakeup, ktime_get()));
284	if (idle_duration_ns <= 0)
285		return false;
286
287	/*
288	 * Find the deepest idle state that has its residency value satisfied
289	 * and by also taking into account the power off latency for the state.
290	 * Start at the state picked by the dev PM QoS constraint validation.
291	 */
292	i = genpd->state_idx;
293	do {
294		if (idle_duration_ns >= (genpd->states[i].residency_ns +
295		    genpd->states[i].power_off_latency_ns)) {
296			genpd->state_idx = i;
297			return true;
298		}
299	} while (--i >= 0);
300
301	return false;
302}
303
304struct dev_power_governor pm_domain_cpu_gov = {
305	.suspend_ok = default_suspend_ok,
306	.power_down_ok = cpu_power_down_ok,
307};
308#endif
309
310struct dev_power_governor simple_qos_governor = {
311	.suspend_ok = default_suspend_ok,
312	.power_down_ok = default_power_down_ok,
313};
314
315/**
316 * pm_genpd_gov_always_on - A governor implementing an always-on policy
317 */
318struct dev_power_governor pm_domain_always_on_gov = {
319	.power_down_ok = always_on_power_down_ok,
320	.suspend_ok = default_suspend_ok,
321};