Skip to contentSkip to conversation

cpufreq: suspend governors during s2r/hibernation

PATCH Superseded Viresh Kumar 5 participants 19 messages Nov 22, 2013 – Nov 27, 2013

Subsystems (5)

v2 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Viresh Kumar

author maintainer
#0 lore raw

v2 cover cpufreq: suspend governors during s2r/hibernation

This patchset adds cpufreq callbacks to dpm_{suspend|resume}_noirq() for handling suspend/resume of cpufreq governors. This is required for early suspend and late resume of governors.

There are multiple problems that are fixed by this patch:
- Nishanth Menon (TI) found an interesting problem on his platform, OMAP. His board wasn't working well with suspend/resume as calls for removing non-boot CPUs was turning out into a call to drivers ->target() which then tries to play with regulators. But regulators and their I2C bus were already suspended and this resulted in a failure. This is why we need a PM notifier here.
- Lan Tianyu (Intel) & Jinhyuk Choi (Broadcom) found another issue where tunables configuration for clusters/sockets with non-boot CPUs was getting lost after suspend/resume, as we were notifying governors with CPUFREQ_GOV_POLICY_EXIT on removal of the last cpu for that policy and so deallocating memory for tunables.

This was earlier sent here:
https://lkml.org/lkml/2013/11/15/107

V1->V2:
- Used direct callbacks from dpm_{suspend|resume}_noirq() for suspending/resuming govenors instead of doing that with help of PM notifiers.
- Patch 2/2: Switching to the desirable frequency before suspending the governors.

Viresh Kumar (2):
cpufreq: suspend governors on system suspend/hibernate
cpufreq: Change freq before suspending governors

 drivers/base/power/main.c |  3 ++
 drivers/cpufreq/cpufreq.c | 79 +++++++++++++++++++++++++++++++++++++++++++++++
 include/linux/cpufreq.h   |  5 +++
 3 files changed, 87 insertions(+)
Signature · 1 line
1.7.12.rc2.18.g61b472e
author maintainer
#1 lore raw

PATCH v2 1/2 cpufreq: suspend governors on system suspend/hibernate

This patch adds cpufreq callbacks to dpm_{suspend|resume}_noirq() for handling suspend/resume of cpufreq governors. This is required for early suspend and late resume of governors.

There are multiple problems that are fixed by this patch:
- Nishanth Menon (TI) found an interesting problem on his platform, OMAP. His board wasn't working well with suspend/resume as calls for removing non-boot CPUs was turning out into a call to drivers ->target() which then tries to play with regulators. But regulators and their I2C bus were already suspended and this resulted in a failure. This is why we need a PM notifier here.
- Lan Tianyu (Intel) & Jinhyuk Choi (Broadcom) found another issue where tunables configuration for clusters/sockets with non-boot CPUs was getting lost after suspend/resume, as we were notifying governors with CPUFREQ_GOV_POLICY_EXIT on removal of the last cpu for that policy and so deallocating memory for tunables.

---
 drivers/base/power/main.c |  3 +++
 drivers/cpufreq/cpufreq.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++
 include/linux/cpufreq.h   |  3 +++
 3 files changed, 68 insertions(+)
drivers/base/power/main.c +3 -0
index c12e9b9..0fbe792 100644
@@ -29,6 +29,7 @@
 #include <linux/async.h>
 #include <linux/suspend.h>
 #include <trace/events/power.h>
+#include <linux/cpufreq.h>
 #include <linux/cpuidle.h>
 #include <linux/timer.h>
 
@@ -540,6 +541,7 @@ static void dpm_resume_noirq(pm_message_t state)
 	dpm_show_time(starttime, state, "noirq");
 	resume_device_irqs();
 	cpuidle_resume();
+	cpufreq_resume();
 }
 
 /**
@@ -955,6 +957,7 @@ static int dpm_suspend_noirq(pm_message_t state)
 	ktime_t starttime = ktime_get();
 	int error = 0;
 
+	cpufreq_suspend();
 	cpuidle_pause();
 	suspend_device_irqs();
 	mutex_lock(&dpm_list_mtx);
drivers/cpufreq/cpufreq.c +62 -0

92 lines not on this page · raw message

include/linux/cpufreq.h +3 -0
index dc196bb..6d93f91 100644
@@ -255,6 +255,9 @@ struct cpufreq_driver {
 int cpufreq_register_driver(struct cpufreq_driver *driver_data);
 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
 
+void cpufreq_suspend(void);
+void cpufreq_resume(void);
+
 const char *cpufreq_get_current_driver(void);
 
 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
Signature · 1 line
1.7.12.rc2.18.g61b472e
#2 lore raw

Re: [PATCH V2 1/2] cpufreq: suspend governors on system suspend/hibernate

Quoted 94 lines · Viresh Kumar

This patch adds cpufreq callbacks to dpm_{suspend|resume}_noirq() for handling suspend/resume of cpufreq governors. This is required for early suspend and late resume of governors.

There are multiple problems that are fixed by this patch:
- Nishanth Menon (TI) found an interesting problem on his platform, OMAP. His board wasn't working well with suspend/resume as calls for removing non-boot CPUs was turning out into a call to drivers ->target() which then tries to play with regulators. But regulators and their I2C bus were already suspended and this resulted in a failure. This is why we need a PM notifier here.
- Lan Tianyu (Intel) & Jinhyuk Choi (Broadcom) found another issue where tunables configuration for clusters/sockets with non-boot CPUs was getting lost after suspend/resume, as we were notifying governors with CPUFREQ_GOV_POLICY_EXIT on removal of the last cpu for that policy and so deallocating memory for tunables.

---
 drivers/base/power/main.c |  3 +++
 drivers/cpufreq/cpufreq.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++
 include/linux/cpufreq.h   |  3 +++
 3 files changed, 68 insertions(+)
drivers/base/power/main.c +3 -0
index c12e9b9..0fbe792 100644
@@ -29,6 +29,7 @@
 #include <linux/async.h>
 #include <linux/suspend.h>
 #include <trace/events/power.h>
+#include <linux/cpufreq.h>
 #include <linux/cpuidle.h>
 #include <linux/timer.h>
 
@@ -540,6 +541,7 @@ static void dpm_resume_noirq(pm_message_t state)
 	dpm_show_time(starttime, state, "noirq");
 	resume_device_irqs();
 	cpuidle_resume();
+	cpufreq_resume();
 }
 
 /**
@@ -955,6 +957,7 @@ static int dpm_suspend_noirq(pm_message_t state)
 	ktime_t starttime = ktime_get();
 	int error = 0;
 
+	cpufreq_suspend();
 	cpuidle_pause();
 	suspend_device_irqs();
 	mutex_lock(&dpm_list_mtx);
drivers/cpufreq/cpufreq.c +18 -0
index 02d534d..540bd87 100644
@@ -26,6 +26,7 @@
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
+#include <linux/suspend.h>
 #include <linux/syscore_ops.h>
 #include <linux/tick.h>
 #include <trace/events/power.h>
@@ -47,6 +48,9 @@ static LIST_HEAD(cpufreq_policy_list);
 static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], cpufreq_cpu_governor);
 #endif
 
+/* Flag to suspend/resume CPUFreq governors */
+static bool cpufreq_suspended;
+
 static inline bool has_target(void)
 {
 	return cpufreq_driver->target_index || cpufreq_driver->target;
@@ -1462,6 +1466,54 @@ static struct subsys_interface cpufreq_interface = {
 	.remove_dev	= cpufreq_remove_dev,
 };
 
+/*
+ * Callbacks for suspending/resuming governors as some platforms can't change
+ * frequency after this point in suspend cycle. Because some of the devices
+ * (like: i2c, regulators, etc) they use for changing frequency are suspended
+ * quickly after this point.
+ */
+void cpufreq_suspend(void)
+{
+	struct cpufreq_policy *policy;
+	unsigned long flags;
+
+	if (!has_target())
+		return;
+

drivers/cpufreq/cpufreq.c static struct subsys_interface cpufreq_interface = { · line 1492

Quoted 10 lines
drivers/cpufreq/cpufreq.c +10 -0
+	pr_debug("%s: Suspending Governors\n", __func__);
+
+	list_for_each_entry(policy, &cpufreq_policy_list, policy_list)
+		if (__cpufreq_governor(policy, CPUFREQ_GOV_STOP))
+			pr_err("%s: Failed to stop governor for policy: %p\n",
+					__func__, policy);
+
+	write_lock_irqsave(&cpufreq_driver_lock, flags);
+	cpufreq_suspended = true;
+	write_unlock_irqrestore(&cpufreq_driver_lock, flags);

The locking here is pointless. It doesn't prevent any race conditions from happening.

Quoted 5 lines
drivers/cpufreq/cpufreq.c +5 -0
+}
+
+void cpufreq_resume(void)
+{
+	struct cpufreq_policy *policy;

drivers/cpufreq/cpufreq.c static struct subsys_interface cpufreq_interface = { · line 1507

Quoted 10 lines
drivers/cpufreq/cpufreq.c +10 -0
+	unsigned long flags;
+
+	if (!has_target())
+		return;
+
+	pr_debug("%s: Resuming Governors\n", __func__);
+
+	write_lock_irqsave(&cpufreq_driver_lock, flags);
+	cpufreq_suspended = false;
+	write_unlock_irqrestore(&cpufreq_driver_lock, flags);

Same here.

Quoted 22 lines
drivers/cpufreq/cpufreq.c +11 -0
+
+	list_for_each_entry(policy, &cpufreq_policy_list, policy_list)
+		if (__cpufreq_governor(policy, CPUFREQ_GOV_START) ||
+				__cpufreq_governor(policy,
+					CPUFREQ_GOV_LIMITS))
+			pr_err("%s: Failed to start governor for policy: %p\n",
+					__func__, policy);
+}
+
 /**
  * cpufreq_bp_suspend - Prepare the boot CPU for system suspend.
  *
@@ -1752,6 +1804,8 @@ EXPORT_SYMBOL_GPL(cpufreq_driver_target);
 static int __cpufreq_governor(struct cpufreq_policy *policy,
 					unsigned int event)
 {
+	unsigned long flags;
+	bool is_suspended;
 	int ret;
 
 	/* Only must be defined when default governor is known to have latency

drivers/cpufreq/cpufreq.c static int __cpufreq_governor(struct cpufreq_policy *policy, · line 1824

Quoted 7 lines
drivers/cpufreq/cpufreq.c +4 -0
@@ -1764,6 +1818,14 @@ static int __cpufreq_governor(struct cpufreq_policy *policy,
 	struct cpufreq_governor *gov = NULL;
 #endif
 
+	/* Don't start any governor operations if we are entering suspend */
+	read_lock_irqsave(&cpufreq_driver_lock, flags);
+	is_suspended = cpufreq_suspended;
+	read_unlock_irqrestore(&cpufreq_driver_lock, flags);

And same here.

drivers/cpufreq/cpufreq.c static int __cpufreq_governor(struct cpufreq_policy *policy, · line 1826

Quoted 2 lines
drivers/cpufreq/cpufreq.c +2 -0
+
+	if (is_suspended)

And you can check cpufreq_suspended directly here.

Quoted 10 lines
drivers/cpufreq/cpufreq.c +2 -0
+		return 0;
+
 	if (policy->governor->max_transition_latency &&
 	    policy->cpuinfo.transition_latency >
 	    policy->governor->max_transition_latency) {
include/linux/cpufreq.h +0 -0
index dc196bb..6d93f91 100644

include/linux/cpufreq.h struct cpufreq_driver { · line 263

Quoted 9 lines
include/linux/cpufreq.h +3 -0
@@ -255,6 +255,9 @@ struct cpufreq_driver {
 int cpufreq_register_driver(struct cpufreq_driver *driver_data);
 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
 
+void cpufreq_suspend(void);
+void cpufreq_resume(void);
+
 const char *cpufreq_get_current_driver(void);
 
 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,

Thanks!

Signature · 2 lines
I speak only for myself.
Rafael J. Wysocki, Intel Open Source Technology Center.
author maintainer
#3 lore raw

Re: [PATCH V2 1/2] cpufreq: suspend governors on system suspend/hibernate

Quoted 2 lines · Rafael J. Wysocki

The locking here is pointless. It doesn't prevent any race conditions from happening.

All comments accepted..

#4 lore raw

Re: [PATCH V2 1/2] cpufreq: suspend governors on system suspend/hibernate

In reply to Viresh Kumar
Quoted 20 lines · Viresh Kumar

This patch adds cpufreq callbacks to dpm_{suspend|resume}_noirq() for handling suspend/resume of cpufreq governors. This is required for early suspend and late resume of governors.

There are multiple problems that are fixed by this patch:
- Nishanth Menon (TI) found an interesting problem on his platform, OMAP. His board wasn't working well with suspend/resume as calls for removing non-boot CPUs was turning out into a call to drivers ->target() which then tries to play with regulators. But regulators and their I2C bus were already suspended and this resulted in a failure. This is why we need a PM notifier here.
- Lan Tianyu (Intel) & Jinhyuk Choi (Broadcom) found another issue where tunables configuration for clusters/sockets with non-boot CPUs was getting lost after suspend/resume, as we were notifying governors with CPUFREQ_GOV_POLICY_EXIT on removal of the last cpu for that policy and so deallocating memory for tunables.

Quoted 5 lines
---
 drivers/base/power/main.c |  3 +++
 drivers/cpufreq/cpufreq.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++
 include/linux/cpufreq.h   |  3 +++
 3 files changed, 68 insertions(+)

yes, this seems to work for me as well.
http://pastebin.mozilla.org/3670909 - no cpufreq attempts to transition were triggered.

Signature · 2 lines
Regards,
Nishanth Menon
author maintainer
#5 lore raw

Re: [PATCH V2 1/2] cpufreq: suspend governors on system suspend/hibernate

Quoted 3 lines · Nishanth Menon

yes, this seems to work for me as well.
http://pastebin.mozilla.org/3670909 - no cpufreq attempts to transition were triggered.

Ahh.. Thanks for confirming..
But we still can't work with noirq handlers as there are platforms which want to change frequency before going into suspend and so we need to do this from dpm_suspend() :)

Thanks for trying.

--
viresh

#6 lore raw

Re: [PATCH V2 1/2] cpufreq: suspend governors on system suspend/hibernate

In reply to Viresh Kumar

Hi!

Quoted 26 lines

This patch adds cpufreq callbacks to dpm_{suspend|resume}_noirq() for handling suspend/resume of cpufreq governors. This is required for early suspend and late resume of governors.

There are multiple problems that are fixed by this patch:
- Nishanth Menon (TI) found an interesting problem on his platform, OMAP. His board wasn't working well with suspend/resume as calls for removing non-boot CPUs was turning out into a call to drivers ->target() which then tries to play with regulators. But regulators and their I2C bus were already suspended and this resulted in a failure. This is why we need a PM notifier here.
- Lan Tianyu (Intel) & Jinhyuk Choi (Broadcom) found another issue where tunables configuration for clusters/sockets with non-boot CPUs was getting lost after suspend/resume, as we were notifying governors with CPUFREQ_GOV_POLICY_EXIT on removal of the last cpu for that policy and so deallocating memory for tunables.

drivers/cpufreq/cpufreq.c +10 -0
+/*
+ * Callbacks for suspending/resuming governors as some platforms can't change
+ * frequency after this point in suspend cycle. Because some of the devices
+ * (like: i2c, regulators, etc) they use for changing frequency are suspended
+ * quickly after this point.
+ */
+void cpufreq_suspend(void)
+{
+	struct cpufreq_policy *policy;
+	unsigned long flags;

drivers/cpufreq/cpufreq.c static struct subsys_interface cpufreq_interface = { · line 1488

Quoted 10 lines
drivers/cpufreq/cpufreq.c +10 -0
+
+	if (!has_target())
+		return;
+
+	pr_debug("%s: Suspending Governors\n", __func__);
+
+	list_for_each_entry(policy, &cpufreq_policy_list, policy_list)
+		if (__cpufreq_governor(policy, CPUFREQ_GOV_STOP))
+			pr_err("%s: Failed to stop governor for policy: %p\n",
+					__func__, policy);

So... we freeze frequencies in whatever state they are, yes?

Should we go to some specific frequency?

For example, early athlon64 notebooks were unable to run on battery power on max frequency... these days there are various "Turbo" modes, but IIRC staying at high frequency there is only safe as long as CPU stays cool enough...
Pavel

Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
#7 lore raw

Re: [PATCH V2 1/2] cpufreq: suspend governors on system suspend/hibernate

Quoted 32 lines · Pavel Machek

Hi!

Quoted 30 lines

This patch adds cpufreq callbacks to dpm_{suspend|resume}_noirq() for handling suspend/resume of cpufreq governors. This is required for early suspend and late resume of governors.

There are multiple problems that are fixed by this patch:
- Nishanth Menon (TI) found an interesting problem on his platform, OMAP. His board wasn't working well with suspend/resume as calls for removing non-boot CPUs was turning out into a call to drivers ->target() which then tries to play with regulators. But regulators and their I2C bus were already suspended and this resulted in a failure. This is why we need a PM notifier here.
- Lan Tianyu (Intel) & Jinhyuk Choi (Broadcom) found another issue where tunables configuration for clusters/sockets with non-boot CPUs was getting lost after suspend/resume, as we were notifying governors with CPUFREQ_GOV_POLICY_EXIT on removal of the last cpu for that policy and so deallocating memory for tunables.

drivers/cpufreq/cpufreq.c +14 -0
+/*
+ * Callbacks for suspending/resuming governors as some platforms can't change
+ * frequency after this point in suspend cycle. Because some of the devices
+ * (like: i2c, regulators, etc) they use for changing frequency are suspended
+ * quickly after this point.
+ */
+void cpufreq_suspend(void)
+{
+	struct cpufreq_policy *policy;
+	unsigned long flags;
+
+	if (!has_target())
+		return;
+
Quoted 8 lines

drivers/cpufreq/cpufreq.c static struct subsys_interface cpufreq_interface = { · line 1488

Quoted 6 lines
drivers/cpufreq/cpufreq.c +6 -0
+	pr_debug("%s: Suspending Governors\n", __func__);
+
+	list_for_each_entry(policy, &cpufreq_policy_list, policy_list)
+		if (__cpufreq_governor(policy, CPUFREQ_GOV_STOP))
+			pr_err("%s: Failed to stop governor for policy: %p\n",
+					__func__, policy);

So... we freeze frequencies in whatever state they are, yes?

Yes. The idea was to do that after suspending devices in which case it wouldn't matter so much. But Viresh always has to complicate things.

Quoted 1 line

Should we go to some specific frequency?

If that is done where it is done, yes, we should.

Thanks,
Rafael

author maintainer
#8 lore raw

Re: [PATCH V2 1/2] cpufreq: suspend governors on system suspend/hibernate

Quoted 2 lines · Rafael J. Wysocki
Quoted 1 line · Pavel Machek

So... we freeze frequencies in whatever state they are, yes?

Better go through the V3 of this patchset:

https://lkml.org/lkml/2013/11/25/838

We are giving drivers and opportunity to set core to whatever frequency they want before suspending.

Quoted 2 lines

Yes. The idea was to do that after suspending devices in which case it wouldn't matter so much. But Viresh always has to complicate things.

:)

Its complicated by the kind of designs we have for our hardware. We tried the noirq callbacks and it worked atleast for Nishanth, who reported the problem initially. But the problem started when drivers wanted to change their frequencies before suspending and that can't happen in noirq place..

I had another idea but then left it thinking that it might be even more complicated :)

What about both dpm_suspend_noirq and dpm_suspend callbacks. Drivers will change freq in dpm_suspend_noirq and dpm_suspend will stop governors?

But the question is can governors try another frequency at that time? i.e. override whatever is configured by drivers?

Quoted 3 lines
Quoted 1 line

Should we go to some specific frequency?

If that is done where it is done, yes, we should.

You meant dpm_suspend() here, right?

#9 lore raw

Re: [PATCH V2 1/2] cpufreq: suspend governors on system suspend/hibernate

Quoted 14 lines · Viresh Kumar
Quoted 2 lines · Rafael J. Wysocki
Quoted 1 line · Pavel Machek

So... we freeze frequencies in whatever state they are, yes?

Better go through the V3 of this patchset:

https://lkml.org/lkml/2013/11/25/838

We are giving drivers and opportunity to set core to whatever frequency they want before suspending.

Quoted 2 lines

Yes. The idea was to do that after suspending devices in which case it wouldn't matter so much. But Viresh always has to complicate things.

Quoted 6 lines

:)

Its complicated by the kind of designs we have for our hardware. We tried the noirq callbacks and it worked atleast for Nishanth, who reported the problem initially. But the problem started when drivers wanted to change their frequencies before suspending and that can't happen in noirq place..

This way you end up with a fix that may introduce other issues. Which is kind of fine before a merge window, but not so much after one. So at this point it's better to fix things that may be fixed without introducing those other issues *first* and then go for a more intrusive change that will cover more cases.

Quoted 6 lines

I had another idea but then left it thinking that it might be even more complicated :)

What about both dpm_suspend_noirq and dpm_suspend callbacks. Drivers will change freq in dpm_suspend_noirq and dpm_suspend will stop governors?

Quoted 8 lines

But the question is can governors try another frequency at that time? i.e. override whatever is configured by drivers?

Quoted 3 lines
Quoted 1 line

Should we go to some specific frequency?

If that is done where it is done, yes, we should.

You meant dpm_suspend() here, right?

Yes.

Thanks!

Signature · 2 lines
I speak only for myself.
Rafael J. Wysocki, Intel Open Source Technology Center.
author maintainer
#10 lore raw

PATCH v2 2/2 cpufreq: Change freq before suspending governors

In reply to Viresh Kumar

Some platforms might want to change frequency before suspending governors. Like:
- Some platform which want to set freq to max to speed up suspend/hibernation process.
- Some platform (like: Tegra or exynos), set this to min or bootloader's frequency.

This patch adds an option for those, so that they can specify this at call to ->init(), so that cpufreq core can take care of this before suspending system.

If this variable is not updated by ->init() then its value would be zero and so core wouldn't do anything.

---
 drivers/cpufreq/cpufreq.c | 17 +++++++++++++++++
 include/linux/cpufreq.h   |  2 ++
 2 files changed, 19 insertions(+)
drivers/cpufreq/cpufreq.c +17 -0
index 540bd87..e609102 100644
@@ -1476,6 +1476,7 @@ void cpufreq_suspend(void)
 {
 	struct cpufreq_policy *policy;
 	unsigned long flags;
+	int ret;
 
 	if (!has_target())
 		return;
@@ -1487,6 +1488,22 @@ void cpufreq_suspend(void)
 			pr_err("%s: Failed to stop governor for policy: %p\n",
 					__func__, policy);
 
+	/*
+	 * In case platform wants some specific frequency to be configured
+	 * during suspend
+	 */
+	if (policy->suspend_freq) {
+		pr_debug("%s: Suspending Governors: Setting suspend-freq: %u\n",
+				__func__, policy->suspend_freq);
+
+		ret = __cpufreq_driver_target(policy, policy->suspend_freq,
+				CPUFREQ_RELATION_H);
+		/* We can still suspend even if this failed */
+		if (ret)
+			pr_err("%s: Unable to set suspend-freq: %u. Err: %d\n",
+					__func__, policy->suspend_freq, ret);
+	}
+
 	write_lock_irqsave(&cpufreq_driver_lock, flags);
 	cpufreq_suspended = true;
 	write_unlock_irqrestore(&cpufreq_driver_lock, flags);
include/linux/cpufreq.h +2 -0
index 6d93f91..867fdd4 100644
@@ -72,6 +72,8 @@ struct cpufreq_policy {
 	unsigned int		max;    /* in kHz */
 	unsigned int		cur;    /* in kHz, only needed if cpufreq
 					 * governors are used */
+	unsigned int		suspend_freq; /* freq to set during suspend */
+
 	unsigned int		policy; /* see above */
 	struct cpufreq_governor	*governor; /* see below */
 	void			*governor_data;
Signature · 1 line
1.7.12.rc2.18.g61b472e
#11 lore raw

Re: [PATCH V2 2/2] cpufreq: Change freq before suspending governors

Quoted 6 lines · Viresh Kumar

Some platforms might want to change frequency before suspending governors. Like:
- Some platform which want to set freq to max to speed up suspend/hibernation process.
- Some platform (like: Tegra or exynos), set this to min or bootloader's frequency.

Quoted 7 lines

This patch adds an option for those, so that they can specify this at call to ->init(), so that cpufreq core can take care of this before suspending system.

If this variable is not updated by ->init() then its value would be zero and so core wouldn't do anything.

I don't think this is generally necessary, because the suspend/resume routines added by patch [1/2] will be executed very late during suspend or very early during resume and it shouldn't really matter what performance levels the CPUs are at then.

The only exception *may* be hibernation, because the amount of time needed to create the image will depend on the current performance level of the boot CPU, but that should be an explicitly special case in my opinion.

Thanks!

Signature · 2 lines
I speak only for myself.
Rafael J. Wysocki, Intel Open Source Technology Center.
author maintainer
#12 lore raw

Re: [PATCH V2 2/2] cpufreq: Change freq before suspending governors

Quoted 13 lines · Rafael J. Wysocki
Quoted 12 lines · Viresh Kumar

Some platforms might want to change frequency before suspending governors. Like:
- Some platform which want to set freq to max to speed up suspend/hibernation process.
- Some platform (like: Tegra or exynos), set this to min or bootloader's frequency.

This patch adds an option for those, so that they can specify this at call to ->init(), so that cpufreq core can take care of this before suspending system.

If this variable is not updated by ->init() then its value would be zero and so core wouldn't do anything.

Quoted 6 lines
Quoted 1 line

I don't think this is generally necessary, because the suspend/resume routines added by patch [1/2] will be executed very late during suspend or very early during resume and it shouldn't really matter what performance levels the CPUs are at then.

There are few things here:
- I feel that the current place from where we have suspended stuff is not gonna fly. We are doing that in noirq and probably devices which might be required during frequency transitions might already be down.. So we *may* need to move that in dpm_suspend()..
- Secondly I want to understand why Tegra/Exynos has such code which I mentioned above..

@Stephen, Kukjin and other samsung folks: Please provide some input here, before your systems break in mainline :)

Quoted 3 lines

The only exception *may* be hibernation, because the amount of time needed to create the image will depend on the current performance level of the boot CPU, but that should be an explicitly special case in my opinion.

Hmm.. That looks sensible if there is nothing special required for Tegra/Exynos.

#13 lore raw

Re: [PATCH V2 2/2] cpufreq: Change freq before suspending governors

Quoted 21 lines · Viresh Kumar
Quoted 13 lines · Rafael J. Wysocki
Quoted 12 lines · Viresh Kumar

Some platforms might want to change frequency before suspending governors. Like:
- Some platform which want to set freq to max to speed up suspend/hibernation process.
- Some platform (like: Tegra or exynos), set this to min or bootloader's frequency.

This patch adds an option for those, so that they can specify this at call to ->init(), so that cpufreq core can take care of this before suspending system.

If this variable is not updated by ->init() then its value would be zero and so core wouldn't do anything.

Quoted 6 lines
Quoted 1 line

I don't think this is generally necessary, because the suspend/resume routines added by patch [1/2] will be executed very late during suspend or very early during resume and it shouldn't really matter what performance levels the CPUs are at then.

Quoted 5 lines

There are few things here:
- I feel that the current place from where we have suspended stuff is not gonna fly. We are doing that in noirq and probably devices which might be required during frequency transitions might already be down.. So we *may* need to move that in dpm_suspend()..

That would be a much more intrusive change. Definitely not 3.13 material at this point.

Thanks!

Signature · 2 lines
I speak only for myself.
Rafael J. Wysocki, Intel Open Source Technology Center.
author maintainer
#14 lore raw

Re: [PATCH V2 2/2] cpufreq: Change freq before suspending governors

Quoted 2 lines · Rafael J. Wysocki

That would be a much more intrusive change. Definitely not 3.13 material at this point.

Agreed..

#15 lore raw

Re: [PATCH V2 2/2] cpufreq: Change freq before suspending governors

In reply to Viresh Kumar
Quoted 29 lines · Viresh Kumar
Quoted 13 lines · Rafael J. Wysocki
Quoted 12 lines · Viresh Kumar

Some platforms might want to change frequency before suspending governors. Like:
- Some platform which want to set freq to max to speed up suspend/hibernation process.
- Some platform (like: Tegra or exynos), set this to min or bootloader's frequency.

This patch adds an option for those, so that they can specify this at call to ->init(), so that cpufreq core can take care of this before suspending system.

If this variable is not updated by ->init() then its value would be zero and so core wouldn't do anything.

Quoted 6 lines
Quoted 1 line

I don't think this is generally necessary, because the suspend/resume routines added by patch [1/2] will be executed very late during suspend or very early during resume and it shouldn't really matter what performance levels the CPUs are at then.

There are few things here:
- I feel that the current place from where we have suspended stuff is not gonna fly. We are doing that in noirq and probably devices which might be required during frequency transitions might already be down.. So we *may* need to move that in dpm_suspend()..
- Secondly I want to understand why Tegra/Exynos has such code which I mentioned above..

Quoted 2 lines

@Stephen, Kukjin and other samsung folks: Please provide some input here, before your systems break in mainline :)

I believe we set the clock to a low value because fast clocks consume more power. Tegra architecturally supports a number of different suspend levels. Only some of those actually power off or gate the clock source itself.

#16 lore raw

Re: [PATCH V2 2/2] cpufreq: Change freq before suspending governors

Quoted 30 lines · Stephen Warren
Quoted 29 lines · Viresh Kumar
Quoted 13 lines · Rafael J. Wysocki
Quoted 12 lines · Viresh Kumar

Some platforms might want to change frequency before suspending governors. Like:
- Some platform which want to set freq to max to speed up suspend/hibernation process.
- Some platform (like: Tegra or exynos), set this to min or bootloader's frequency.

This patch adds an option for those, so that they can specify this at call to ->init(), so that cpufreq core can take care of this before suspending system.

If this variable is not updated by ->init() then its value would be zero and so core wouldn't do anything.

Quoted 6 lines
Quoted 1 line

I don't think this is generally necessary, because the suspend/resume routines added by patch [1/2] will be executed very late during suspend or very early during resume and it shouldn't really matter what performance levels the CPUs are at then.

There are few things here:
- I feel that the current place from where we have suspended stuff is not gonna fly. We are doing that in noirq and probably devices which might be required during frequency transitions might already be down.. So we *may* need to move that in dpm_suspend()..
- Secondly I want to understand why Tegra/Exynos has such code which I mentioned above..

Quoted 7 lines
Quoted 2 lines

@Stephen, Kukjin and other samsung folks: Please provide some input here, before your systems break in mainline :)

I believe we set the clock to a low value because fast clocks consume more power. Tegra architecturally supports a number of different suspend levels. Only some of those actually power off or gate the clock source itself.

Hmm.

Viresh, maybe make it possible for the cpufreq driver to provide suspend/resume callbacks to be executed by cpufreq_suspend() and cpufreq_resume() introduced by [1/2]? Then Tegra could set the frequencies to what it wants from there before the governors are stopped.

Thanks!

Signature · 2 lines
I speak only for myself.
Rafael J. Wysocki, Intel Open Source Technology Center.
author maintainer
#17 lore raw

Re: [PATCH V2 2/2] cpufreq: Change freq before suspending governors

Quoted 4 lines · Rafael J. Wysocki

Viresh, maybe make it possible for the cpufreq driver to provide suspend/resume callbacks to be executed by cpufreq_suspend() and cpufreq_resume() introduced by [1/2]? Then Tegra could set the frequencies to what it wants from there before the governors are stopped.

Giving cpufreq-drivers a chance to do whatever they want looks to be correct. So, maybe prepare() or suspend_prepare() for them can be implemented.

Though I would still go for a generic function in core, which can be just reused by samsung and tegra to set cores to specific frequencies.

--
viresh

author maintainer
#18 lore raw

Re: [PATCH V2 2/2] cpufreq: Change freq before suspending governors

Quoted 3 lines · Viresh Kumar

Giving cpufreq-drivers a chance to do whatever they want looks to be correct. So, maybe prepare() or suspend_prepare() for them can be implemented.

I have used the existing infrastructure here, i.e. suspend/resume callbacks for drivers.. As we don't need two suspend calls now..