Commit cd8198a2 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge branch 'pm-domains' 

Merge generlic power domains update for 5.19-rc1:

 - Extend dev_pm_domain_detach() doc (Krzysztof Kozlowski).

 - Move genpd's time-accounting to ktime_get_mono_fast_ns() (Ulf
   Hansson).

 - Improve the way genpd deals with its governors (Ulf Hansson).

* pm-domains:
  PM: domains: Trust domain-idle-states from DT to be correct by genpd
  PM: domains: Measure power-on/off latencies in genpd based on a governor
  PM: domains: Allocate governor data dynamically based on a genpd governor
  PM: domains: Clean up some code in pm_genpd_init() and genpd_remove()
  PM: domains: Fix initialization of genpd's next_wakeup
  PM: domains: Fixup QoS latency measurements for IRQ safe devices in genpd
  PM: domains: Measure suspend/resume latencies in genpd based on governor
  PM: domains: Move the next_wakeup variable into the struct gpd_timing_data
  PM: domains: Allocate gpd_timing_data dynamically based on governor
  PM: domains: Skip another warning in irq_safe_dev_in_sleep_domain()
  PM: domains: Rename irq_safe_dev_in_no_sleep_domain() in genpd
  PM: domains: Don't check PM_QOS_FLAG_NO_POWER_OFF in genpd
  PM: domains: Drop redundant code for genpd always-on governor
  PM: domains: Add GENPD_FLAG_RPM_ALWAYS_ON for the always-on governor
  PM: domains: Move genpd's time-accounting to ktime_get_mono_fast_ns()
  PM: domains: Extend dev_pm_domain_detach() doc
parents d988c913 b2a92f35

drivers/base/power/common.c

+4 −4
Original line number Diff line number Diff line
@@ -172,10 +172,10 @@ EXPORT_SYMBOL_GPL(dev_pm_domain_attach_by_name); 
 * @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

 * 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.

 * This functions will reverse the actions from dev_pm_domain_attach(),

 * dev_pm_domain_attach_by_id() and dev_pm_domain_attach_by_name(), 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.

drivers/base/power/domain.c

+170 −108
Original line number Diff line number Diff line
@@ -131,7 +131,7 @@ static const struct genpd_lock_ops genpd_spin_ops = { 
#define genpd_is_cpu_domain(genpd)	(genpd->flags & GENPD_FLAG_CPU_DOMAIN)

#define genpd_is_rpm_always_on(genpd)	(genpd->flags & GENPD_FLAG_RPM_ALWAYS_ON)



static inline bool irq_safe_dev_in_no_sleep_domain(struct device *dev,

static inline bool irq_safe_dev_in_sleep_domain(struct device *dev,

		const struct generic_pm_domain *genpd)

{

	bool ret;
@@ -139,11 +139,14 @@ static inline bool irq_safe_dev_in_no_sleep_domain(struct device *dev, 
	ret = pm_runtime_is_irq_safe(dev) && !genpd_is_irq_safe(genpd);



	/*

	 * Warn once if an IRQ safe device is attached to a no sleep domain, as

	 * to indicate a suboptimal configuration for PM. For an always on

	 * domain this isn't case, thus don't warn.

	 * Warn once if an IRQ safe device is attached to a domain, which

	 * callbacks are allowed to sleep. This indicates a suboptimal

	 * configuration for PM, but it doesn't matter for an always on domain.

	 */

	if (ret && !genpd_is_always_on(genpd))

	if (genpd_is_always_on(genpd) || genpd_is_rpm_always_on(genpd))

		return ret;



	if (ret)

		dev_warn_once(dev, "PM domain %s will not be powered off\n",

				genpd->name);
@@ -225,24 +228,23 @@ static void genpd_debug_remove(struct generic_pm_domain *genpd) 


static void genpd_update_accounting(struct generic_pm_domain *genpd)

{

	ktime_t delta, now;

	u64 delta, now;



	now = ktime_get();

	delta = ktime_sub(now, genpd->accounting_time);

	now = ktime_get_mono_fast_ns();

	if (now <= genpd->accounting_time)

		return;



	delta = now - genpd->accounting_time;



	/*

	 * If genpd->status is active, it means we are just

	 * out of off and so update the idle time and vice

	 * versa.

	 */

	if (genpd->status == GENPD_STATE_ON) {

		int state_idx = genpd->state_idx;



		genpd->states[state_idx].idle_time =

			ktime_add(genpd->states[state_idx].idle_time, delta);

	} else {

		genpd->on_time = ktime_add(genpd->on_time, delta);

	}

	if (genpd->status == GENPD_STATE_ON)

		genpd->states[genpd->state_idx].idle_time += delta;

	else

		genpd->on_time += delta;



	genpd->accounting_time = now;

}
@@ -476,15 +478,16 @@ EXPORT_SYMBOL_GPL(dev_pm_genpd_set_performance_state); 
 */

void dev_pm_genpd_set_next_wakeup(struct device *dev, ktime_t next)

{

	struct generic_pm_domain_data *gpd_data;

	struct generic_pm_domain *genpd;

	struct gpd_timing_data *td;



	genpd = dev_to_genpd_safe(dev);

	if (!genpd)

		return;



	gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);

	gpd_data->next_wakeup = next;

	td = to_gpd_data(dev->power.subsys_data->domain_data)->td;

	if (td)

		td->next_wakeup = next;

}

EXPORT_SYMBOL_GPL(dev_pm_genpd_set_next_wakeup);
@@ -506,6 +509,7 @@ static int _genpd_power_on(struct generic_pm_domain *genpd, bool timed) 
	if (!genpd->power_on)

		goto out;



	timed = timed && genpd->gd && !genpd->states[state_idx].fwnode;

	if (!timed) {

		ret = genpd->power_on(genpd);

		if (ret)
@@ -524,7 +528,7 @@ static int _genpd_power_on(struct generic_pm_domain *genpd, bool timed) 
		goto out;



	genpd->states[state_idx].power_on_latency_ns = elapsed_ns;

	genpd->max_off_time_changed = true;

	genpd->gd->max_off_time_changed = true;

	pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n",

		 genpd->name, "on", elapsed_ns);
@@ -555,6 +559,7 @@ static int _genpd_power_off(struct generic_pm_domain *genpd, bool timed) 
	if (!genpd->power_off)

		goto out;



	timed = timed && genpd->gd && !genpd->states[state_idx].fwnode;

	if (!timed) {

		ret = genpd->power_off(genpd);

		if (ret)
@@ -573,7 +578,7 @@ static int _genpd_power_off(struct generic_pm_domain *genpd, bool timed) 
		goto out;



	genpd->states[state_idx].power_off_latency_ns = elapsed_ns;

	genpd->max_off_time_changed = true;

	genpd->gd->max_off_time_changed = true;

	pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n",

		 genpd->name, "off", elapsed_ns);
@@ -649,18 +654,12 @@ static int genpd_power_off(struct generic_pm_domain *genpd, bool one_dev_on, 
	}



	list_for_each_entry(pdd, &genpd->dev_list, list_node) {

		enum pm_qos_flags_status stat;



		stat = dev_pm_qos_flags(pdd->dev, PM_QOS_FLAG_NO_POWER_OFF);

		if (stat > PM_QOS_FLAGS_NONE)

			return -EBUSY;



		/*

		 * Do not allow PM domain to be powered off, when an IRQ safe

		 * device is part of a non-IRQ safe domain.

		 */

		if (!pm_runtime_suspended(pdd->dev) ||

			irq_safe_dev_in_no_sleep_domain(pdd->dev, genpd))

			irq_safe_dev_in_sleep_domain(pdd->dev, genpd))

			not_suspended++;

	}
@@ -775,25 +774,27 @@ static int genpd_dev_pm_qos_notifier(struct notifier_block *nb, 
	dev = gpd_data->base.dev;



	for (;;) {

		struct generic_pm_domain *genpd;

		struct generic_pm_domain *genpd = ERR_PTR(-ENODATA);

		struct pm_domain_data *pdd;

		struct gpd_timing_data *td;



		spin_lock_irq(&dev->power.lock);



		pdd = dev->power.subsys_data ?

				dev->power.subsys_data->domain_data : NULL;

		if (pdd) {

			to_gpd_data(pdd)->td.constraint_changed = true;

			td = to_gpd_data(pdd)->td;

			if (td) {

				td->constraint_changed = true;

				genpd = dev_to_genpd(dev);

		} else {

			genpd = ERR_PTR(-ENODATA);

			}

		}



		spin_unlock_irq(&dev->power.lock);



		if (!IS_ERR(genpd)) {

			genpd_lock(genpd);

			genpd->max_off_time_changed = true;

			genpd->gd->max_off_time_changed = true;

			genpd_unlock(genpd);

		}
@@ -879,9 +880,9 @@ static int genpd_runtime_suspend(struct device *dev) 
	struct generic_pm_domain *genpd;

	bool (*suspend_ok)(struct device *__dev);

	struct generic_pm_domain_data *gpd_data = dev_gpd_data(dev);

	struct gpd_timing_data *td = &gpd_data->td;

	struct gpd_timing_data *td = gpd_data->td;

	bool runtime_pm = pm_runtime_enabled(dev);

	ktime_t time_start;

	ktime_t time_start = 0;

	s64 elapsed_ns;

	int ret;
@@ -902,8 +903,7 @@ static int genpd_runtime_suspend(struct device *dev) 
		return -EBUSY;



	/* Measure suspend latency. */

	time_start = 0;

	if (runtime_pm)

	if (td && runtime_pm)

		time_start = ktime_get();



	ret = __genpd_runtime_suspend(dev);
@@ -917,13 +917,13 @@ static int genpd_runtime_suspend(struct device *dev) 
	}



	/* Update suspend latency value if the measured time exceeds it. */

	if (runtime_pm) {

	if (td && runtime_pm) {

		elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));

		if (elapsed_ns > td->suspend_latency_ns) {

			td->suspend_latency_ns = elapsed_ns;

			dev_dbg(dev, "suspend latency exceeded, %lld ns\n",

				elapsed_ns);

			genpd->max_off_time_changed = true;

			genpd->gd->max_off_time_changed = true;

			td->constraint_changed = true;

		}

	}
@@ -932,7 +932,7 @@ static int genpd_runtime_suspend(struct device *dev) 
	 * If power.irq_safe is set, this routine may be run with

	 * IRQs disabled, so suspend only if the PM domain also is irq_safe.

	 */

	if (irq_safe_dev_in_no_sleep_domain(dev, genpd))

	if (irq_safe_dev_in_sleep_domain(dev, genpd))

		return 0;



	genpd_lock(genpd);
@@ -955,12 +955,11 @@ static int genpd_runtime_resume(struct device *dev) 
{

	struct generic_pm_domain *genpd;

	struct generic_pm_domain_data *gpd_data = dev_gpd_data(dev);

	struct gpd_timing_data *td = &gpd_data->td;

	bool runtime_pm = pm_runtime_enabled(dev);

	ktime_t time_start;

	struct gpd_timing_data *td = gpd_data->td;

	bool timed = td && pm_runtime_enabled(dev);

	ktime_t time_start = 0;

	s64 elapsed_ns;

	int ret;

	bool timed = true;



	dev_dbg(dev, "%s()\n", __func__);
@@ -972,10 +971,8 @@ static int genpd_runtime_resume(struct device *dev) 
	 * As we don't power off a non IRQ safe domain, which holds

	 * an IRQ safe device, we don't need to restore power to it.

	 */

	if (irq_safe_dev_in_no_sleep_domain(dev, genpd)) {

		timed = false;

	if (irq_safe_dev_in_sleep_domain(dev, genpd))

		goto out;

	}



	genpd_lock(genpd);

	ret = genpd_power_on(genpd, 0);
@@ -988,8 +985,7 @@ static int genpd_runtime_resume(struct device *dev) 


 out:

	/* Measure resume latency. */

	time_start = 0;

	if (timed && runtime_pm)

	if (timed)

		time_start = ktime_get();



	ret = genpd_start_dev(genpd, dev);
@@ -1001,13 +997,13 @@ static int genpd_runtime_resume(struct device *dev) 
		goto err_stop;



	/* Update resume latency value if the measured time exceeds it. */

	if (timed && runtime_pm) {

	if (timed) {

		elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));

		if (elapsed_ns > td->resume_latency_ns) {

			td->resume_latency_ns = elapsed_ns;

			dev_dbg(dev, "resume latency exceeded, %lld ns\n",

				elapsed_ns);

			genpd->max_off_time_changed = true;

			genpd->gd->max_off_time_changed = true;

			td->constraint_changed = true;

		}

	}
@@ -1500,9 +1496,11 @@ EXPORT_SYMBOL_GPL(dev_pm_genpd_resume); 


#endif /* CONFIG_PM_SLEEP */



static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev)

static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev,

							   bool has_governor)

{

	struct generic_pm_domain_data *gpd_data;

	struct gpd_timing_data *td;

	int ret;



	ret = dev_pm_get_subsys_data(dev);
@@ -1516,26 +1514,38 @@ static struct generic_pm_domain_data *genpd_alloc_dev_data(struct device *dev) 
	}



	gpd_data->base.dev = dev;

	gpd_data->td.constraint_changed = true;

	gpd_data->td.effective_constraint_ns = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS;

	gpd_data->nb.notifier_call = genpd_dev_pm_qos_notifier;

	gpd_data->next_wakeup = KTIME_MAX;



	spin_lock_irq(&dev->power.lock);



	if (dev->power.subsys_data->domain_data) {

		ret = -EINVAL;

	/* Allocate data used by a governor. */

	if (has_governor) {

		td = kzalloc(sizeof(*td), GFP_KERNEL);

		if (!td) {

			ret = -ENOMEM;

			goto err_free;

		}



		td->constraint_changed = true;

		td->effective_constraint_ns = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS;

		td->next_wakeup = KTIME_MAX;

		gpd_data->td = td;

	}



	spin_lock_irq(&dev->power.lock);



	if (dev->power.subsys_data->domain_data)

		ret = -EINVAL;

	else

		dev->power.subsys_data->domain_data = &gpd_data->base;



	spin_unlock_irq(&dev->power.lock);



	if (ret)

		goto err_free;



	return gpd_data;



 err_free:

	spin_unlock_irq(&dev->power.lock);

	kfree(gpd_data->td);

	kfree(gpd_data);

 err_put:

	dev_pm_put_subsys_data(dev);
@@ -1551,6 +1561,7 @@ static void genpd_free_dev_data(struct device *dev, 


	spin_unlock_irq(&dev->power.lock);



	kfree(gpd_data->td);

	kfree(gpd_data);

	dev_pm_put_subsys_data(dev);

}
@@ -1607,6 +1618,7 @@ static int genpd_get_cpu(struct generic_pm_domain *genpd, struct device *dev) 
static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,

			    struct device *base_dev)

{

	struct genpd_governor_data *gd = genpd->gd;

	struct generic_pm_domain_data *gpd_data;

	int ret;
@@ -1615,7 +1627,7 @@ static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev, 
	if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))

		return -EINVAL;



	gpd_data = genpd_alloc_dev_data(dev);

	gpd_data = genpd_alloc_dev_data(dev, gd);

	if (IS_ERR(gpd_data))

		return PTR_ERR(gpd_data);
@@ -1631,7 +1643,8 @@ static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev, 
	dev_pm_domain_set(dev, &genpd->domain);



	genpd->device_count++;

	genpd->max_off_time_changed = true;

	if (gd)

		gd->max_off_time_changed = true;



	list_add_tail(&gpd_data->base.list_node, &genpd->dev_list);
@@ -1685,7 +1698,8 @@ static int genpd_remove_device(struct generic_pm_domain *genpd, 
	}



	genpd->device_count--;

	genpd->max_off_time_changed = true;

	if (genpd->gd)

		genpd->gd->max_off_time_changed = true;



	genpd_clear_cpumask(genpd, gpd_data->cpu);

	dev_pm_domain_set(dev, NULL);
@@ -1958,6 +1972,53 @@ static int genpd_set_default_power_state(struct generic_pm_domain *genpd) 
	return 0;

}



static int genpd_alloc_data(struct generic_pm_domain *genpd)

{

	struct genpd_governor_data *gd = NULL;

	int ret;



	if (genpd_is_cpu_domain(genpd) &&

	    !zalloc_cpumask_var(&genpd->cpus, GFP_KERNEL))

		return -ENOMEM;



	if (genpd->gov) {

		gd = kzalloc(sizeof(*gd), GFP_KERNEL);

		if (!gd) {

			ret = -ENOMEM;

			goto free;

		}



		gd->max_off_time_ns = -1;

		gd->max_off_time_changed = true;

		gd->next_wakeup = KTIME_MAX;

	}



	/* Use only one "off" state if there were no states declared */

	if (genpd->state_count == 0) {

		ret = genpd_set_default_power_state(genpd);

		if (ret)

			goto free;

	}



	genpd->gd = gd;

	return 0;



free:

	if (genpd_is_cpu_domain(genpd))

		free_cpumask_var(genpd->cpus);

	kfree(gd);

	return ret;

}



static void genpd_free_data(struct generic_pm_domain *genpd)

{

	if (genpd_is_cpu_domain(genpd))

		free_cpumask_var(genpd->cpus);

	if (genpd->free_states)

		genpd->free_states(genpd->states, genpd->state_count);

	kfree(genpd->gd);

}



static void genpd_lock_init(struct generic_pm_domain *genpd)

{

	if (genpd->flags & GENPD_FLAG_IRQ_SAFE) {
@@ -1995,11 +2056,9 @@ int pm_genpd_init(struct generic_pm_domain *genpd, 
	atomic_set(&genpd->sd_count, 0);

	genpd->status = is_off ? GENPD_STATE_OFF : GENPD_STATE_ON;

	genpd->device_count = 0;

	genpd->max_off_time_ns = -1;

	genpd->max_off_time_changed = true;

	genpd->provider = NULL;

	genpd->has_provider = false;

	genpd->accounting_time = ktime_get();

	genpd->accounting_time = ktime_get_mono_fast_ns();

	genpd->domain.ops.runtime_suspend = genpd_runtime_suspend;

	genpd->domain.ops.runtime_resume = genpd_runtime_resume;

	genpd->domain.ops.prepare = genpd_prepare;
@@ -2017,26 +2076,22 @@ int pm_genpd_init(struct generic_pm_domain *genpd, 
		genpd->dev_ops.start = pm_clk_resume;

	}



	/* The always-on governor works better with the corresponding flag. */

	if (gov == &pm_domain_always_on_gov)

		genpd->flags |= GENPD_FLAG_RPM_ALWAYS_ON;



	/* Always-on domains must be powered on at initialization. */

	if ((genpd_is_always_on(genpd) || genpd_is_rpm_always_on(genpd)) &&

			!genpd_status_on(genpd))

		return -EINVAL;



	if (genpd_is_cpu_domain(genpd) &&

	    !zalloc_cpumask_var(&genpd->cpus, GFP_KERNEL))

		return -ENOMEM;

	/* Multiple states but no governor doesn't make sense. */

	if (!gov && genpd->state_count > 1)

		pr_warn("%s: no governor for states\n", genpd->name);



	/* Use only one "off" state if there were no states declared */

	if (genpd->state_count == 0) {

		ret = genpd_set_default_power_state(genpd);

		if (ret) {

			if (genpd_is_cpu_domain(genpd))

				free_cpumask_var(genpd->cpus);

	ret = genpd_alloc_data(genpd);

	if (ret)

		return ret;

		}

	} else if (!gov && genpd->state_count > 1) {

		pr_warn("%s: no governor for states\n", genpd->name);

	}



	device_initialize(&genpd->dev);

	dev_set_name(&genpd->dev, "%s", genpd->name);
@@ -2081,10 +2136,7 @@ static int genpd_remove(struct generic_pm_domain *genpd) 
	genpd_unlock(genpd);

	genpd_debug_remove(genpd);

	cancel_work_sync(&genpd->power_off_work);

	if (genpd_is_cpu_domain(genpd))

		free_cpumask_var(genpd->cpus);

	if (genpd->free_states)

		genpd->free_states(genpd->states, genpd->state_count);

	genpd_free_data(genpd);



	pr_debug("%s: removed %s\n", __func__, genpd->name);
@@ -3163,6 +3215,7 @@ static int sub_domains_show(struct seq_file *s, void *data) 
static int idle_states_show(struct seq_file *s, void *data)

{

	struct generic_pm_domain *genpd = s->private;

	u64 now, delta, idle_time = 0;

	unsigned int i;

	int ret = 0;
@@ -3173,16 +3226,18 @@ static int idle_states_show(struct seq_file *s, void *data) 
	seq_puts(s, "State          Time Spent(ms) Usage          Rejected\n");



	for (i = 0; i < genpd->state_count; i++) {

		ktime_t delta = 0;

		s64 msecs;

		idle_time += genpd->states[i].idle_time;



		if ((genpd->status == GENPD_STATE_OFF) &&

				(genpd->state_idx == i))

			delta = ktime_sub(ktime_get(), genpd->accounting_time);

		if (genpd->status == GENPD_STATE_OFF && genpd->state_idx == i) {

			now = ktime_get_mono_fast_ns();

			if (now > genpd->accounting_time) {

				delta = now - genpd->accounting_time;

				idle_time += delta;

			}

		}



		msecs = ktime_to_ms(

			ktime_add(genpd->states[i].idle_time, delta));

		seq_printf(s, "S%-13i %-14lld %-14llu %llu\n", i, msecs,

		do_div(idle_time, NSEC_PER_MSEC);

		seq_printf(s, "S%-13i %-14llu %-14llu %llu\n", i, idle_time,

			   genpd->states[i].usage, genpd->states[i].rejected);

	}
@@ -3193,18 +3248,22 @@ static int idle_states_show(struct seq_file *s, void *data) 
static int active_time_show(struct seq_file *s, void *data)

{

	struct generic_pm_domain *genpd = s->private;

	ktime_t delta = 0;

	u64 now, on_time, delta = 0;

	int ret = 0;



	ret = genpd_lock_interruptible(genpd);

	if (ret)

		return -ERESTARTSYS;



	if (genpd->status == GENPD_STATE_ON)

		delta = ktime_sub(ktime_get(), genpd->accounting_time);

	if (genpd->status == GENPD_STATE_ON) {

		now = ktime_get_mono_fast_ns();

		if (now > genpd->accounting_time)

			delta = now - genpd->accounting_time;

	}



	seq_printf(s, "%lld ms\n", ktime_to_ms(

				ktime_add(genpd->on_time, delta)));

	on_time = genpd->on_time + delta;

	do_div(on_time, NSEC_PER_MSEC);

	seq_printf(s, "%llu ms\n", on_time);



	genpd_unlock(genpd);

	return ret;
@@ -3213,7 +3272,7 @@ static int active_time_show(struct seq_file *s, void *data) 
static int total_idle_time_show(struct seq_file *s, void *data)

{

	struct generic_pm_domain *genpd = s->private;

	ktime_t delta = 0, total = 0;

	u64 now, delta, total = 0;

	unsigned int i;

	int ret = 0;
@@ -3222,16 +3281,19 @@ static int total_idle_time_show(struct seq_file *s, void *data) 
		return -ERESTARTSYS;



	for (i = 0; i < genpd->state_count; i++) {

		total += genpd->states[i].idle_time;



		if ((genpd->status == GENPD_STATE_OFF) &&

				(genpd->state_idx == i))

			delta = ktime_sub(ktime_get(), genpd->accounting_time);



		total = ktime_add(total, genpd->states[i].idle_time);

		if (genpd->status == GENPD_STATE_OFF && genpd->state_idx == i) {

			now = ktime_get_mono_fast_ns();

			if (now > genpd->accounting_time) {

				delta = now - genpd->accounting_time;

				total += delta;

			}

		}

	}

	total = ktime_add(total, delta);



	seq_printf(s, "%lld ms\n", ktime_to_ms(total));

	do_div(total, NSEC_PER_MSEC);

	seq_printf(s, "%llu ms\n", total);



	genpd_unlock(genpd);

	return ret;

drivers/base/power/domain_governor.c

+35 −30
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ static int dev_update_qos_constraint(struct device *dev, void *data) 
	s64 constraint_ns;



	if (dev->power.subsys_data && dev->power.subsys_data->domain_data) {

		struct gpd_timing_data *td = dev_gpd_data(dev)->td;



		/*

		 * Only take suspend-time QoS constraints of devices into

		 * account, because constraints updated after the device has
@@ -25,7 +27,8 @@ static int dev_update_qos_constraint(struct device *dev, void *data) 
		 * anyway.  In order for them to take effect, the device has to

		 * be resumed and suspended again.

		 */

		constraint_ns = dev_gpd_data(dev)->td.effective_constraint_ns;

		constraint_ns = td ? td->effective_constraint_ns :

				PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS;

	} else {

		/*

		 * The child is not in a domain and there's no info on its
@@ -49,7 +52,7 @@ static int dev_update_qos_constraint(struct device *dev, void *data) 
 */

static bool default_suspend_ok(struct device *dev)

{

	struct gpd_timing_data *td = &dev_gpd_data(dev)->td;

	struct gpd_timing_data *td = dev_gpd_data(dev)->td;

	unsigned long flags;

	s64 constraint_ns;
@@ -136,26 +139,28 @@ static void update_domain_next_wakeup(struct generic_pm_domain *genpd, ktime_t n 
	 * is able to enter its optimal idle state.

	 */

	list_for_each_entry(pdd, &genpd->dev_list, list_node) {

		next_wakeup = to_gpd_data(pdd)->next_wakeup;

		next_wakeup = to_gpd_data(pdd)->td->next_wakeup;

		if (next_wakeup != KTIME_MAX && !ktime_before(next_wakeup, now))

			if (ktime_before(next_wakeup, domain_wakeup))

				domain_wakeup = next_wakeup;

	}



	list_for_each_entry(link, &genpd->parent_links, parent_node) {

		next_wakeup = link->child->next_wakeup;

		struct genpd_governor_data *cgd = link->child->gd;



		next_wakeup = cgd ? cgd->next_wakeup : KTIME_MAX;

		if (next_wakeup != KTIME_MAX && !ktime_before(next_wakeup, now))

			if (ktime_before(next_wakeup, domain_wakeup))

				domain_wakeup = next_wakeup;

	}



	genpd->next_wakeup = domain_wakeup;

	genpd->gd->next_wakeup = domain_wakeup;

}



static bool next_wakeup_allows_state(struct generic_pm_domain *genpd,

				     unsigned int state, ktime_t now)

{

	ktime_t domain_wakeup = genpd->next_wakeup;

	ktime_t domain_wakeup = genpd->gd->next_wakeup;

	s64 idle_time_ns, min_sleep_ns;



	min_sleep_ns = genpd->states[state].power_off_latency_ns +
@@ -185,8 +190,9 @@ static bool __default_power_down_ok(struct dev_pm_domain *pd, 
	 * All subdomains have been powered off already at this point.

	 */

	list_for_each_entry(link, &genpd->parent_links, parent_node) {

		struct generic_pm_domain *sd = link->child;

		s64 sd_max_off_ns = sd->max_off_time_ns;

		struct genpd_governor_data *cgd = link->child->gd;



		s64 sd_max_off_ns = cgd ? cgd->max_off_time_ns : -1;



		if (sd_max_off_ns < 0)

			continue;
@@ -215,7 +221,7 @@ static bool __default_power_down_ok(struct dev_pm_domain *pd, 
		 * domain to turn off and on (that's how much time it will

		 * have to wait worst case).

		 */

		td = &to_gpd_data(pdd)->td;

		td = to_gpd_data(pdd)->td;

		constraint_ns = td->effective_constraint_ns;

		/*

		 * Zero means "no suspend at all" and this runs only when all
@@ -244,7 +250,7 @@ static bool __default_power_down_ok(struct dev_pm_domain *pd, 
	 * time and the time needed to turn the domain on is the maximum

	 * theoretical time this domain can spend in the "off" state.

	 */

	genpd->max_off_time_ns = min_off_time_ns -

	genpd->gd->max_off_time_ns = min_off_time_ns -

		genpd->states[state].power_on_latency_ns;

	return true;

}
@@ -259,6 +265,7 @@ static bool __default_power_down_ok(struct dev_pm_domain *pd, 
static bool _default_power_down_ok(struct dev_pm_domain *pd, ktime_t now)

{

	struct generic_pm_domain *genpd = pd_to_genpd(pd);

	struct genpd_governor_data *gd = genpd->gd;

	int state_idx = genpd->state_count - 1;

	struct gpd_link *link;
@@ -269,11 +276,11 @@ static bool _default_power_down_ok(struct dev_pm_domain *pd, ktime_t now) 
	 * cannot be met.

	 */

	update_domain_next_wakeup(genpd, now);

	if ((genpd->flags & GENPD_FLAG_MIN_RESIDENCY) && (genpd->next_wakeup != KTIME_MAX)) {

	if ((genpd->flags & GENPD_FLAG_MIN_RESIDENCY) && (gd->next_wakeup != KTIME_MAX)) {

		/* Let's find out the deepest domain idle state, the devices prefer */

		while (state_idx >= 0) {

			if (next_wakeup_allows_state(genpd, state_idx, now)) {

				genpd->max_off_time_changed = true;

				gd->max_off_time_changed = true;

				break;

			}

			state_idx--;
@@ -281,14 +288,14 @@ static bool _default_power_down_ok(struct dev_pm_domain *pd, ktime_t now) 


		if (state_idx < 0) {

			state_idx = 0;

			genpd->cached_power_down_ok = false;

			gd->cached_power_down_ok = false;

			goto done;

		}

	}



	if (!genpd->max_off_time_changed) {

		genpd->state_idx = genpd->cached_power_down_state_idx;

		return genpd->cached_power_down_ok;

	if (!gd->max_off_time_changed) {

		genpd->state_idx = gd->cached_power_down_state_idx;

		return gd->cached_power_down_ok;

	}



	/*
@@ -297,12 +304,16 @@ static bool _default_power_down_ok(struct dev_pm_domain *pd, ktime_t now) 
	 * going to be called for any parent until this instance

	 * returns.

	 */

	list_for_each_entry(link, &genpd->child_links, child_node)

		link->parent->max_off_time_changed = true;

	list_for_each_entry(link, &genpd->child_links, child_node) {

		struct genpd_governor_data *pgd = link->parent->gd;



		if (pgd)

			pgd->max_off_time_changed = true;

	}



	genpd->max_off_time_ns = -1;

	genpd->max_off_time_changed = false;

	genpd->cached_power_down_ok = true;

	gd->max_off_time_ns = -1;

	gd->max_off_time_changed = false;

	gd->cached_power_down_ok = true;



	/*

	 * Find a state to power down to, starting from the state
@@ -310,7 +321,7 @@ static bool _default_power_down_ok(struct dev_pm_domain *pd, ktime_t now) 
	 */

	while (!__default_power_down_ok(pd, state_idx)) {

		if (state_idx == 0) {

			genpd->cached_power_down_ok = false;

			gd->cached_power_down_ok = false;

			break;

		}

		state_idx--;
@@ -318,8 +329,8 @@ static bool _default_power_down_ok(struct dev_pm_domain *pd, ktime_t now) 


done:

	genpd->state_idx = state_idx;

	genpd->cached_power_down_state_idx = genpd->state_idx;

	return genpd->cached_power_down_ok;

	gd->cached_power_down_state_idx = genpd->state_idx;

	return gd->cached_power_down_ok;

}



static bool default_power_down_ok(struct dev_pm_domain *pd)
@@ -327,11 +338,6 @@ static bool default_power_down_ok(struct dev_pm_domain *pd) 
	return _default_power_down_ok(pd, ktime_get());

}



static bool always_on_power_down_ok(struct dev_pm_domain *domain)

{

	return false;

}



#ifdef CONFIG_CPU_IDLE

static bool cpu_power_down_ok(struct dev_pm_domain *pd)

{
@@ -401,6 +407,5 @@ struct dev_power_governor simple_qos_governor = { 
 * pm_genpd_gov_always_on - A governor implementing an always-on policy

 */

struct dev_power_governor pm_domain_always_on_gov = {

	.power_down_ok = always_on_power_down_ok,

	.suspend_ok = default_suspend_ok,

};

include/linux/pm_domain.h

+14 −10
Original line number Diff line number Diff line
@@ -91,6 +91,14 @@ struct gpd_dev_ops { 
	int (*stop)(struct device *dev);

};



struct genpd_governor_data {

	s64 max_off_time_ns;

	bool max_off_time_changed;

	ktime_t next_wakeup;

	bool cached_power_down_ok;

	bool cached_power_down_state_idx;

};



struct genpd_power_state {

	s64 power_off_latency_ns;

	s64 power_on_latency_ns;
@@ -98,7 +106,7 @@ struct genpd_power_state { 
	u64 usage;

	u64 rejected;

	struct fwnode_handle *fwnode;

	ktime_t idle_time;

	u64 idle_time;

	void *data;

};
@@ -114,6 +122,7 @@ struct generic_pm_domain { 
	struct list_head child_links;	/* Links with PM domain as a child */

	struct list_head dev_list;	/* List of devices */

	struct dev_power_governor *gov;

	struct genpd_governor_data *gd;	/* Data used by a genpd governor. */

	struct work_struct power_off_work;

	struct fwnode_handle *provider;	/* Identity of the domain provider */

	bool has_provider;
@@ -134,11 +143,6 @@ struct generic_pm_domain { 
	int (*set_performance_state)(struct generic_pm_domain *genpd,

				     unsigned int state);

	struct gpd_dev_ops dev_ops;

	s64 max_off_time_ns;	/* Maximum allowed "suspended" time. */

	ktime_t next_wakeup;	/* Maintained by the domain governor */

	bool max_off_time_changed;

	bool cached_power_down_ok;

	bool cached_power_down_state_idx;

	int (*attach_dev)(struct generic_pm_domain *domain,

			  struct device *dev);

	void (*detach_dev)(struct generic_pm_domain *domain,
@@ -149,8 +153,8 @@ struct generic_pm_domain { 
			    unsigned int state_count);

	unsigned int state_count; /* number of states */

	unsigned int state_idx; /* state that genpd will go to when off */

	ktime_t on_time;

	ktime_t accounting_time;

	u64 on_time;

	u64 accounting_time;

	const struct genpd_lock_ops *lock_ops;

	union {

		struct mutex mlock;
@@ -182,6 +186,7 @@ struct gpd_timing_data { 
	s64 suspend_latency_ns;

	s64 resume_latency_ns;

	s64 effective_constraint_ns;

	ktime_t	next_wakeup;

	bool constraint_changed;

	bool cached_suspend_ok;

};
@@ -193,14 +198,13 @@ struct pm_domain_data { 


struct generic_pm_domain_data {

	struct pm_domain_data base;

	struct gpd_timing_data td;

	struct gpd_timing_data *td;

	struct notifier_block nb;

	struct notifier_block *power_nb;

	int cpu;

	unsigned int performance_state;

	unsigned int default_pstate;

	unsigned int rpm_pstate;

	ktime_t	next_wakeup;

	void *data;

};