Merge tag 'pm+acpi-3.10-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull power management and ACPI fixes from Rafael Wysocki: - intel_pstate driver fixes and cleanups from Dirk Brandewie and Wei Yongjun. - cpufreq fixes related to ARM big.LITTLE support and the cpufreq-cpu0 driver from Viresh Kumar. - Assorted cpufreq fixes from Srivatsa S Bhat, Borislav Petkov, Wolfram Sang, Alexander Shiyan, and Nishanth Menon. - Assorted ACPI fixes from Catalin Marinas, Lan Tianyu, Alex Hung, Jan-Simon Möller, and Rafael J Wysocki. - Fix for a kfree() under spinlock in the PM core from Shuah Khan. - PM documentation updates from Borislav Petkov and Zhang Rui. * tag 'pm+acpi-3.10-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (30 commits) cpufreq: Preserve sysfs files across suspend/resume ACPI / scan: Fix memory leak on acpi_scan_init_hotplug() error path PM / hibernate: Correct documentation PM / Documentation: remove inaccurate suspend/hibernate transition lantency statement PM: Documentation update for freeze state cpufreq / intel_pstate: use vzalloc() instead of vmalloc()/memset(0) cpufreq, ondemand: Remove leftover debug line PM: Avoid calling kfree() under spinlock in dev_pm_put_subsys_data() cpufreq / kirkwood: don't check resource with devm_ioremap_resource cpufreq / intel_pstate: remove #ifdef MODULE compile fence cpufreq / intel_pstate: Remove idle mode PID cpufreq / intel_pstate: fix ffmpeg regression cpufreq / intel_pstate: use lowest requested max performance cpufreq / intel_pstate: remove idle time and duration from sample and calculations cpufreq: Fix incorrect dependecies for ARM SA11xx drivers cpufreq: ARM big LITTLE: Fix Kconfig entries cpufreq: cpufreq-cpu0: Free parent node for error cases cpufreq: cpufreq-cpu0: defer probe when regulator is not ready cpufreq: Issue CPUFREQ_GOV_POLICY_EXIT notifier before dropping policy refcount cpufreq: governors: Fix CPUFREQ_GOV_POLICY_{INIT|EXIT} notifiers ...

Linus Torvalds committed 13 years ago

Commit d5fe85a2 parents 8968216 49a9e4326 files · +190 −195Browse files

Unified · Split

26 files

Documentation/power/devices.txt +8 −7
Documentation/power/interface.txt +2 −2
Documentation/power/notifiers.txt +4 −2
Documentation/power/states.txt +17 −13
drivers/acpi/ac.c +33 −0
drivers/acpi/ec.c +1 −3
drivers/acpi/processor_driver.c +4 −4
drivers/acpi/processor_idle.c +19 −10
drivers/acpi/scan.c +2 −1
drivers/acpi/video.c +8 −0
drivers/base/power/common.c +6 −6
drivers/cpufreq/Kconfig +1 −1
drivers/cpufreq/Kconfig.arm +8 −7
drivers/cpufreq/arm_big_little.c +1 −6
drivers/cpufreq/arm_big_little.h +5 −0
drivers/cpufreq/arm_big_little_dt.c +5 −4
drivers/cpufreq/cpufreq-cpu0.c +20 −7
drivers/cpufreq/cpufreq.c +4 −6
drivers/cpufreq/cpufreq_governor.c +7 −4
drivers/cpufreq/cpufreq_governor.h +1 −0
drivers/cpufreq/cpufreq_ondemand.c +0 −1
drivers/cpufreq/cpufreq_stats.c +4 −3
drivers/cpufreq/intel_pstate.c +21 −101
drivers/cpufreq/kirkwood-cpufreq.c +0 −4
include/acpi/acpiosxf.h +1 −1
include/acpi/processor.h +8 −2

Documentation/power/devices.txt+8−7

@@ -268,7 +268,7 @@ situations. · 267 unmodified lines
268	268	System Power Management Phases
269	269	------------------------------
270	270	Suspending or resuming the system is done in several phases. Different phases
271		−are used for standby or memory sleep states ("suspend-to-RAM") and the
	271	+are used for freeze, standby, and memory sleep states ("suspend-to-RAM") and the
272	272	hibernation state ("suspend-to-disk"). Each phase involves executing callbacks
273	273	for every device before the next phase begins. Not all busses or classes
274	274	support all these callbacks and not all drivers use all the callbacks. The
@@ -309,7 +309,8 @@ execute the corresponding method from dev->driver->pm instead if there is one. · 34 unmodified lines
309	309
310	310	Entering System Suspend
311	311	-----------------------
312		−When the system goes into the standby or memory sleep state, the phases are:
	312	+When the system goes into the freeze, standby or memory sleep state,
	313	+the phases are:
313	314
314	315	prepare, suspend, suspend_late, suspend_noirq.
315	316
@@ -368,7 +369,7 @@ the devices that were suspended. · 52 unmodified lines
368	369
369	370	Leaving System Suspend
370	371	----------------------
371		−When resuming from standby or memory sleep, the phases are:
	372	+When resuming from freeze, standby or memory sleep, the phases are:
372	373
373	374	resume_noirq, resume_early, resume, complete.
374	375
@@ -433,8 +434,8 @@ the system log. · 58 unmodified lines
433	434
434	435	Entering Hibernation
435	436	--------------------
436		−Hibernating the system is more complicated than putting it into the standby or
437		−memory sleep state, because it involves creating and saving a system image.
	437	+Hibernating the system is more complicated than putting it into the other
	438	+sleep states, because it involves creating and saving a system image.
438	439	Therefore there are more phases for hibernation, with a different set of
439	440	callbacks. These phases always run after tasks have been frozen and memory has
440	441	been freed.
@@ -485,8 +486,8 @@ image forms an atomic snapshot of the system state. · 44 unmodified lines
485	486
486	487	At this point the system image is saved, and the devices then need to be
487	488	prepared for the upcoming system shutdown. This is much like suspending them
488		−before putting the system into the standby or memory sleep state, and the phases
489		−are similar.
	489	+before putting the system into the freeze, standby or memory sleep state,
	490	+and the phases are similar.
490	491
491	492	9. The prepare phase is discussed above.
492	493

Documentation/power/interface.txt+2−2

@@ -7,8 +7,8 @@ running. The interface exists in /sys/power/ directory (assuming sysfs · 6 unmodified lines
7	7	is mounted at /sys).
8	8
9	9	/sys/power/state controls system power state. Reading from this file
10		−returns what states are supported, which is hard-coded to 'standby'
11		−(Power-On Suspend), 'mem' (Suspend-to-RAM), and 'disk'
	10	+returns what states are supported, which is hard-coded to 'freeze',
	11	+'standby' (Power-On Suspend), 'mem' (Suspend-to-RAM), and 'disk'
12	12	(Suspend-to-Disk).
13	13
14	14	Writing to this file one of those strings causes the system to

Documentation/power/notifiers.txt+4−2

@@ -15,8 +15,10 @@ A suspend/hibernation notifier may be used for this purpose. · 14 unmodified lines
15	15	The subsystems or drivers having such needs can register suspend notifiers that
16	16	will be called upon the following events by the PM core:
17	17
18		−PM_HIBERNATION_PREPARE The system is going to hibernate or suspend, tasks will
19		− be frozen immediately.
	18	+PM_HIBERNATION_PREPARE The system is going to hibernate, tasks will be frozen
	19	+ immediately. This is different from PM_SUSPEND_PREPARE
	20	+ below because here we do additional work between notifiers
	21	+ and drivers freezing.
20	22
21	23	PM_POST_HIBERNATION The system memory state has been restored from a
22	24	hibernation image or an error occurred during

Documentation/power/states.txt+17−13

@@ -2,12 +2,26 @@ · 1 unmodified line
2	2	System Power Management States
3	3
4	4
5		−The kernel supports three power management states generically, though
6		−each is dependent on platform support code to implement the low-level
7		−details for each state. This file describes each state, what they are
	5	+The kernel supports four power management states generically, though
	6	+one is generic and the other three are dependent on platform support
	7	+code to implement the low-level details for each state.
	8	+This file describes each state, what they are
8	9	commonly called, what ACPI state they map to, and what string to write
9	10	to /sys/power/state to enter that state
10	11
	12	+state: Freeze / Low-Power Idle
	13	+ACPI state: S0
	14	+String: "freeze"
	15	+
	16	+This state is a generic, pure software, light-weight, low-power state.
	17	+It allows more energy to be saved relative to idle by freezing user
	18	+space and putting all I/O devices into low-power states (possibly
	19	+lower-power than available at run time), such that the processors can
	20	+spend more time in their idle states.
	21	+This state can be used for platforms without Standby/Suspend-to-RAM
	22	+support, or it can be used in addition to Suspend-to-RAM (memory sleep)
	23	+to provide reduced resume latency.
	24	+
11	25
12	26	State: Standby / Power-On Suspend
13	27	ACPI State: S1
@@ -22,9 +36,6 @@ We try to put devices in a low-power state equivalent to D1, which · 8 unmodified lines
22	36	also offers low power savings, but low resume latency. Not all devices
23	37	support D1, and those that don't are left on.
24	38
25		−A transition from Standby to the On state should take about 1-2
26		−seconds.
27		−
28	39
29	40	State: Suspend-to-RAM
30	41	ACPI State: S3
@@ -42,9 +53,6 @@ transition back to the On state. · 11 unmodified lines
42	53	For at least ACPI, STR requires some minimal boot-strapping code to
43	54	resume the system from STR. This may be true on other platforms.
44	55
45		−A transition from Suspend-to-RAM to the On state should take about
46		−3-5 seconds.
47		−
48	56
49	57	State: Suspend-to-disk
50	58	ACPI State: S4
@@ -74,7 +82,3 @@ low-power state (like ACPI S4), or it may simply power down. Powering · 23 unmodified lines
74	82	down offers greater savings, and allows this mechanism to work on any
75	83	system. However, entering a real low-power state allows the user to
76	84	trigger wake up events (e.g. pressing a key or opening a laptop lid).
77		−
78		−A transition from Suspend-to-Disk to the On state should take about 30
79		−seconds, though it's typically a bit more with the current
80		−implementation.

drivers/acpi/ac.c+33−0

@@ -28,6 +28,8 @@ · 27 unmodified lines
28	28	#include <linux/slab.h>
29	29	#include <linux/init.h>
30	30	#include <linux/types.h>
	31	+#include <linux/dmi.h>
	32	+#include <linux/delay.h>
31	33	#ifdef CONFIG_ACPI_PROCFS_POWER
32	34	#include <linux/proc_fs.h>
33	35	#include <linux/seq_file.h>
@@ -74,6 +76,8 @@ static int acpi_ac_resume(struct device *dev); · 40 unmodified lines
74	76	#endif
75	77	static SIMPLE_DEV_PM_OPS(acpi_ac_pm, NULL, acpi_ac_resume);
76	78
	79	+static int ac_sleep_before_get_state_ms;
	80	+
77	81	static struct acpi_driver acpi_ac_driver = {
78	82	.name = "ac",
79	83	.class = ACPI_AC_CLASS,
@@ -252,6 +256,16 @@ static void acpi_ac_notify(struct acpi_device *device, u32 event) · 172 unmodified lines
252	256	case ACPI_AC_NOTIFY_STATUS:
253	257	case ACPI_NOTIFY_BUS_CHECK:
254	258	case ACPI_NOTIFY_DEVICE_CHECK:
	259	+ /*
	260	+ * A buggy BIOS may notify AC first and then sleep for
	261	+ * a specific time before doing actual operations in the
	262	+ * EC event handler (_Qxx). This will cause the AC state
	263	+ * reported by the ACPI event to be incorrect, so wait for a
	264	+ * specific time for the EC event handler to make progress.
	265	+ */
	266	+ if (ac_sleep_before_get_state_ms > 0)
	267	+ msleep(ac_sleep_before_get_state_ms);
	268	+
255	269	acpi_ac_get_state(ac);
256	270	acpi_bus_generate_proc_event(device, event, (u32) ac->state);
257	271	acpi_bus_generate_netlink_event(device->pnp.device_class,
@@ -264,6 +278,24 @@ static void acpi_ac_notify(struct acpi_device *device, u32 event) · 6 unmodified lines
264	278	return;
265	279	}
266	280
	281	+static int thinkpad_e530_quirk(const struct dmi_system_id *d)
	282	+{
	283	+ ac_sleep_before_get_state_ms = 1000;
	284	+ return 0;
	285	+}
	286	+
	287	+static struct dmi_system_id ac_dmi_table[] = {
	288	+ {
	289	+ .callback = thinkpad_e530_quirk,
	290	+ .ident = "thinkpad e530",
	291	+ .matches = {
	292	+ DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
	293	+ DMI_MATCH(DMI_PRODUCT_NAME, "32597CG"),
	294	+ },
	295	+ },
	296	+ {},
	297	+};
	298	+
267	299	static int acpi_ac_add(struct acpi_device *device)
268	300	{
269	301	int result = 0;
@@ -312,6 +344,7 @@ static int acpi_ac_add(struct acpi_device *device) · 42 unmodified lines
312	344	kfree(ac);
313	345	}
314	346
	347	+ dmi_check_system(ac_dmi_table);
315	348	return result;
316	349	}
317	350

drivers/acpi/ec.c+1−3

@@ -223,7 +223,7 @@ static int ec_check_sci_sync(struct acpi_ec *ec, u8 state) · 222 unmodified lines
223	223	static int ec_poll(struct acpi_ec *ec)
224	224	{
225	225	unsigned long flags;
226		− int repeat = 2; /* number of command restarts */
	226	+ int repeat = 5; /* number of command restarts */
227	227	while (repeat--) {
228	228	unsigned long delay = jiffies +
229	229	msecs_to_jiffies(ec_delay);
@@ -241,8 +241,6 @@ static int ec_poll(struct acpi_ec *ec) · 11 unmodified lines
241	241	}
242	242	advance_transaction(ec, acpi_ec_read_status(ec));
243	243	} while (time_before(jiffies, delay));
244		− if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)
245		− break;
246	244	pr_debug(PREFIX "controller reset, restart transaction\n");
247	245	spin_lock_irqsave(&ec->lock, flags);
248	246	start_transaction(ec);

drivers/acpi/processor_driver.c+4−4

@@ -95,9 +95,6 @@ static const struct acpi_device_id processor_device_ids[] = { · 94 unmodified lines
95	95	};
96	96	MODULE_DEVICE_TABLE(acpi, processor_device_ids);
97	97
98		−static SIMPLE_DEV_PM_OPS(acpi_processor_pm,
99		− acpi_processor_suspend, acpi_processor_resume);
100		−
101	98	static struct acpi_driver acpi_processor_driver = {
102	99	.name = "processor",
103	100	.class = ACPI_PROCESSOR_CLASS,
@@ -107,7 +104,6 @@ static struct acpi_driver acpi_processor_driver = { · 3 unmodified lines
107	104	.remove = acpi_processor_remove,
108	105	.notify = acpi_processor_notify,
109	106	},
110		− .drv.pm = &acpi_processor_pm,
111	107	};
112	108
113	109	#define INSTALL_NOTIFY_HANDLER 1
@@ -934,6 +930,8 @@ static int __init acpi_processor_init(void) · 820 unmodified lines
934	930	if (result < 0)
935	931	return result;
936	932
	933	+ acpi_processor_syscore_init();
	934	+
937	935	acpi_processor_install_hotplug_notify();
938	936
939	937	acpi_thermal_cpufreq_init();
@@ -956,6 +954,8 @@ static void __exit acpi_processor_exit(void) · 16 unmodified lines
956	954
957	955	acpi_processor_uninstall_hotplug_notify();
958	956
	957	+ acpi_processor_syscore_exit();
	958	+
959	959	acpi_bus_unregister_driver(&acpi_processor_driver);
960	960
961	961	return;

drivers/acpi/processor_idle.c+19−10

@@ -34,6 +34,7 @@ · 33 unmodified lines
34	34	#include <linux/sched.h> /* need_resched() */
35	35	#include <linux/clockchips.h>
36	36	#include <linux/cpuidle.h>
	37	+#include <linux/syscore_ops.h>
37	38
38	39	/*
39	40	* Include the apic definitions for x86 to have the APIC timer related defines
@@ -210,33 +211,41 @@ static void lapic_timer_state_broadcast(struct acpi_processor *pr, · 170 unmodified lines
210	211
211	212	#endif
212	213
	214	+#ifdef CONFIG_PM_SLEEP
213	215	static u32 saved_bm_rld;
214	216
215		−static void acpi_idle_bm_rld_save(void)
	217	+int acpi_processor_suspend(void)
216	218	{
217	219	acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
	220	+ return 0;
218	221	}
219		−static void acpi_idle_bm_rld_restore(void)
	222	+
	223	+void acpi_processor_resume(void)
220	224	{
221	225	u32 resumed_bm_rld;
222	226
223	227	acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);
	228	+ if (resumed_bm_rld == saved_bm_rld)
	229	+ return;
224	230
225		− if (resumed_bm_rld != saved_bm_rld)
226		− acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
	231	+ acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
227	232	}
228	233
229		−int acpi_processor_suspend(struct device *dev)
	234	+static struct syscore_ops acpi_processor_syscore_ops = {
	235	+ .suspend = acpi_processor_suspend,
	236	+ .resume = acpi_processor_resume,
	237	+};
	238	+
	239	+void acpi_processor_syscore_init(void)
230	240	{
231		− acpi_idle_bm_rld_save();
232		− return 0;
	241	+ register_syscore_ops(&acpi_processor_syscore_ops);
233	242	}
234	243
235		−int acpi_processor_resume(struct device *dev)
	244	+void acpi_processor_syscore_exit(void)
236	245	{
237		− acpi_idle_bm_rld_restore();
238		− return 0;
	246	+ unregister_syscore_ops(&acpi_processor_syscore_ops);
239	247	}
	248	+#endif /* CONFIG_PM_SLEEP */
240	249
241	250	#if defined(CONFIG_X86)
242	251	static void tsc_check_state(int state)

drivers/acpi/scan.c+2−1

@@ -1785,7 +1785,7 @@ static void acpi_scan_init_hotplug(acpi_handle handle, int type) · 1784 unmodified lines
1785	1785	acpi_set_pnp_ids(handle, &pnp, type);
1786	1786
1787	1787	if (!pnp.type.hardware_id)
1788		− return;
	1788	+ goto out;
1789	1789
1790	1790	/*
1791	1791	* This relies on the fact that acpi_install_notify_handler() will not
@@ -1800,6 +1800,7 @@ static void acpi_scan_init_hotplug(acpi_handle handle, int type) · 8 unmodified lines
1800	1800	}
1801	1801	}
1802	1802
	1803	+out:
1803	1804	acpi_free_pnp_ids(&pnp);
1804	1805	}
1805	1806

drivers/acpi/video.c+8−0

@@ -456,6 +456,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = { · 455 unmodified lines
456	456	DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion dm4 Notebook PC"),
457	457	},
458	458	},
	459	+ {
	460	+ .callback = video_ignore_initial_backlight,
	461	+ .ident = "HP 1000 Notebook PC",
	462	+ .matches = {
	463	+ DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
	464	+ DMI_MATCH(DMI_PRODUCT_NAME, "HP 1000 Notebook PC"),
	465	+ },
	466	+ },
459	467	{}
460	468	};
461	469

drivers/base/power/common.c+6−6

@@ -61,24 +61,24 @@ EXPORT_SYMBOL_GPL(dev_pm_get_subsys_data); · 60 unmodified lines
61	61	int dev_pm_put_subsys_data(struct device *dev)
62	62	{
63	63	struct pm_subsys_data *psd;
64		− int ret = 0;
	64	+ int ret = 1;
65	65
66	66	spin_lock_irq(&dev->power.lock);
67	67
68	68	psd = dev_to_psd(dev);
69		− if (!psd) {
70		− ret = -EINVAL;
	69	+ if (!psd)
71	70	goto out;
72		− }
73	71
74	72	if (--psd->refcount == 0) {
75	73	dev->power.subsys_data = NULL;
76		− kfree(psd);
77		− ret = 1;
	74	+ } else {
	75	+ psd = NULL;
	76	+ ret = 0;
78	77	}
79	78
80	79	out:
81	80	spin_unlock_irq(&dev->power.lock);
	81	+ kfree(psd);
82	82
83	83	return ret;
84	84	}

drivers/cpufreq/Kconfig+1−1

@@ -47,7 +47,7 @@ config CPU_FREQ_STAT_DETAILS · 46 unmodified lines
47	47
48	48	choice
49	49	prompt "Default CPUFreq governor"
50		− default CPU_FREQ_DEFAULT_GOV_USERSPACE if CPU_FREQ_SA1100 \|\| CPU_FREQ_SA1110
	50	+ default CPU_FREQ_DEFAULT_GOV_USERSPACE if ARM_SA1100_CPUFREQ \|\| ARM_SA1110_CPUFREQ
51	51	default CPU_FREQ_DEFAULT_GOV_PERFORMANCE
52	52	help
53	53	This option sets which CPUFreq governor shall be loaded at

drivers/cpufreq/Kconfig.arm+8−7

@@ -3,16 +3,17 @@ · 2 unmodified lines
3	3	#
4	4
5	5	config ARM_BIG_LITTLE_CPUFREQ
6		− tristate
7		− depends on ARM_CPU_TOPOLOGY
	6	+ tristate "Generic ARM big LITTLE CPUfreq driver"
	7	+ depends on ARM_CPU_TOPOLOGY && PM_OPP && HAVE_CLK
	8	+ help
	9	+ This enables the Generic CPUfreq driver for ARM big.LITTLE platforms.
8	10
9	11	config ARM_DT_BL_CPUFREQ
10		− tristate "Generic ARM big LITTLE CPUfreq driver probed via DT"
11		− select ARM_BIG_LITTLE_CPUFREQ
12		− depends on OF && HAVE_CLK
	12	+ tristate "Generic probing via DT for ARM big LITTLE CPUfreq driver"
	13	+ depends on ARM_BIG_LITTLE_CPUFREQ && OF
13	14	help
14		− This enables the Generic CPUfreq driver for ARM big.LITTLE platform.
15		− This gets frequency tables from DT.
	15	+ This enables probing via DT for Generic CPUfreq driver for ARM
	16	+ big.LITTLE platform. This gets frequency tables from DT.
16	17
17	18	config ARM_EXYNOS_CPUFREQ
18	19	bool "SAMSUNG EXYNOS SoCs"

drivers/cpufreq/arm_big_little.c+1−6

@@ -40,11 +40,6 @@ static struct clk *clk[MAX_CLUSTERS]; · 39 unmodified lines
40	40	static struct cpufreq_frequency_table *freq_table[MAX_CLUSTERS];
41	41	static atomic_t cluster_usage[MAX_CLUSTERS] = {ATOMIC_INIT(0), ATOMIC_INIT(0)};
42	42
43		−static int cpu_to_cluster(int cpu)
44		−{
45		− return topology_physical_package_id(cpu);
46		−}
47		−
48	43	static unsigned int bL_cpufreq_get(unsigned int cpu)
49	44	{
50	45	u32 cur_cluster = cpu_to_cluster(cpu);
@@ -192,7 +187,7 @@ static int bL_cpufreq_init(struct cpufreq_policy *policy) · 141 unmodified lines
192	187
193	188	cpumask_copy(policy->cpus, topology_core_cpumask(policy->cpu));
194	189
195		− dev_info(cpu_dev, "CPU %d initialized\n", policy->cpu);
	190	+ dev_info(cpu_dev, "%s: CPU %d initialized\n", __func__, policy->cpu);
196	191	return 0;
197	192	}
198	193

drivers/cpufreq/arm_big_little.h+5−0

@@ -34,6 +34,11 @@ struct cpufreq_arm_bL_ops { · 33 unmodified lines
34	34	int (init_opp_table)(struct device cpu_dev);
35	35	};
36	36
	37	+static inline int cpu_to_cluster(int cpu)
	38	+{
	39	+ return topology_physical_package_id(cpu);
	40	+}
	41	+
37	42	int bL_cpufreq_register(struct cpufreq_arm_bL_ops *ops);
38	43	void bL_cpufreq_unregister(struct cpufreq_arm_bL_ops *ops);
39	44

drivers/cpufreq/arm_big_little_dt.c+5−4

@@ -66,8 +66,8 @@ static int dt_get_transition_latency(struct device *cpu_dev) · 65 unmodified lines
66	66
67	67	parent = of_find_node_by_path("/cpus");
68	68	if (!parent) {
69		− pr_err("failed to find OF /cpus\n");
70		− return -ENOENT;
	69	+ pr_info("Failed to find OF /cpus. Use CPUFREQ_ETERNAL transition latency\n");
	70	+ return CPUFREQ_ETERNAL;
71	71	}
72	72
73	73	for_each_child_of_node(parent, np) {
@@ -78,10 +78,11 @@ static int dt_get_transition_latency(struct device *cpu_dev) · 4 unmodified lines
78	78	of_node_put(np);
79	79	of_node_put(parent);
80	80
81		− return 0;
	81	+ return transition_latency;
82	82	}
83	83
84		− return -ENODEV;
	84	+ pr_info("clock-latency isn't found, use CPUFREQ_ETERNAL transition latency\n");
	85	+ return CPUFREQ_ETERNAL;
85	86	}
86	87
87	88	static struct cpufreq_arm_bL_ops dt_bL_ops = {

drivers/cpufreq/cpufreq-cpu0.c+20−7

@@ -189,12 +189,29 @@ static int cpu0_cpufreq_probe(struct platform_device *pdev) · 188 unmodified lines
189	189
190	190	if (!np) {
191	191	pr_err("failed to find cpu0 node\n");
192		− return -ENOENT;
	192	+ ret = -ENOENT;
	193	+ goto out_put_parent;
193	194	}
194	195
195	196	cpu_dev = &pdev->dev;
196	197	cpu_dev->of_node = np;
197	198
	199	+ cpu_reg = devm_regulator_get(cpu_dev, "cpu0");
	200	+ if (IS_ERR(cpu_reg)) {
	201	+ /*
	202	+ * If cpu0 regulator supply node is present, but regulator is
	203	+ * not yet registered, we should try defering probe.
	204	+ */
	205	+ if (PTR_ERR(cpu_reg) == -EPROBE_DEFER) {
	206	+ dev_err(cpu_dev, "cpu0 regulator not ready, retry\n");
	207	+ ret = -EPROBE_DEFER;
	208	+ goto out_put_node;
	209	+ }
	210	+ pr_warn("failed to get cpu0 regulator: %ld\n",
	211	+ PTR_ERR(cpu_reg));
	212	+ cpu_reg = NULL;
	213	+ }
	214	+
198	215	cpu_clk = devm_clk_get(cpu_dev, NULL);
199	216	if (IS_ERR(cpu_clk)) {
200	217	ret = PTR_ERR(cpu_clk);
@@ -202,12 +219,6 @@ static int cpu0_cpufreq_probe(struct platform_device *pdev) · 1 unmodified line
202	219	goto out_put_node;
203	220	}
204	221
205		− cpu_reg = devm_regulator_get(cpu_dev, "cpu0");
206		− if (IS_ERR(cpu_reg)) {
207		− pr_warn("failed to get cpu0 regulator\n");
208		− cpu_reg = NULL;
209		− }
210		−
211	222	ret = of_init_opp_table(cpu_dev);
212	223	if (ret) {
213	224	pr_err("failed to init OPP table: %d\n", ret);
@@ -264,6 +275,8 @@ out_free_table: · 50 unmodified lines
264	275	opp_free_cpufreq_table(cpu_dev, &freq_table);
265	276	out_put_node:
266	277	of_node_put(np);
	278	+out_put_parent:
	279	+ of_node_put(parent);
267	280	return ret;
268	281	}
269	282

drivers/cpufreq/cpufreq.c+4−6

@@ -1075,14 +1075,14 @@ static int __cpufreq_remove_dev(struct device dev, struct subsys_interface sif · 1074 unmodified lines
1075	1075	__func__, cpu_dev->id, cpu);
1076	1076	}
1077	1077
	1078	+ if ((cpus == 1) && (cpufreq_driver->target))
	1079	+ __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
	1080	+
1078	1081	pr_debug("%s: removing link, cpu: %d\n", __func__, cpu);
1079	1082	cpufreq_cpu_put(data);
1080	1083
1081	1084	/* If cpu is last user of policy, free policy */
1082	1085	if (cpus == 1) {
1083		− if (cpufreq_driver->target)
1084		− __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
1085		−
1086	1086	lock_policy_rwsem_read(cpu);
1087	1087	kobj = &data->kobj;
1088	1088	cmp = &data->kobj_unregister;
@@ -1832,15 +1832,13 @@ static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb, · 743 unmodified lines
1832	1832	if (dev) {
1833	1833	switch (action) {
1834	1834	case CPU_ONLINE:
1835		− case CPU_ONLINE_FROZEN:
1836	1835	cpufreq_add_dev(dev, NULL);
1837	1836	break;
1838	1837	case CPU_DOWN_PREPARE:
1839		− case CPU_DOWN_PREPARE_FROZEN:
	1838	+ case CPU_UP_CANCELED_FROZEN:
1840	1839	__cpufreq_remove_dev(dev, NULL);
1841	1840	break;
1842	1841	case CPU_DOWN_FAILED:
1843		− case CPU_DOWN_FAILED_FROZEN:
1844	1842	cpufreq_add_dev(dev, NULL);
1845	1843	break;
1846	1844	}

drivers/cpufreq/cpufreq_governor.c+7−4

@@ -255,6 +255,7 @@ int cpufreq_governor_dbs(struct cpufreq_policy *policy, · 254 unmodified lines
255	255	if (have_governor_per_policy()) {
256	256	WARN_ON(dbs_data);
257	257	} else if (dbs_data) {
	258	+ dbs_data->usage_count++;
258	259	policy->governor_data = dbs_data;
259	260	return 0;
260	261	}
@@ -266,6 +267,7 @@ int cpufreq_governor_dbs(struct cpufreq_policy *policy, · 5 unmodified lines
266	267	}
267	268
268	269	dbs_data->cdata = cdata;
	270	+ dbs_data->usage_count = 1;
269	271	rc = cdata->init(dbs_data);
270	272	if (rc) {
271	273	pr_err("%s: POLICY_INIT: init() failed\n", __func__);
@@ -294,7 +296,8 @@ int cpufreq_governor_dbs(struct cpufreq_policy *policy, · 22 unmodified lines
294	296	set_sampling_rate(dbs_data, max(dbs_data->min_sampling_rate,
295	297	latency * LATENCY_MULTIPLIER));
296	298
297		− if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
	299	+ if ((cdata->governor == GOV_CONSERVATIVE) &&
	300	+ (!policy->governor->initialized)) {
298	301	struct cs_ops *cs_ops = dbs_data->cdata->gov_ops;
299	302
300	303	cpufreq_register_notifier(cs_ops->notifier_block,
@@ -306,12 +309,12 @@ int cpufreq_governor_dbs(struct cpufreq_policy *policy, · 5 unmodified lines
306	309
307	310	return 0;
308	311	case CPUFREQ_GOV_POLICY_EXIT:
309		− if ((policy->governor->initialized == 1) \|\|
310		− have_governor_per_policy()) {
	312	+ if (!--dbs_data->usage_count) {
311	313	sysfs_remove_group(get_governor_parent_kobj(policy),
312	314	get_sysfs_attr(dbs_data));
313	315
314		− if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
	316	+ if ((dbs_data->cdata->governor == GOV_CONSERVATIVE) &&
	317	+ (policy->governor->initialized == 1)) {
315	318	struct cs_ops *cs_ops = dbs_data->cdata->gov_ops;
316	319
317	320	cpufreq_unregister_notifier(cs_ops->notifier_block,

drivers/cpufreq/cpufreq_governor.h+1−0

@@ -211,6 +211,7 @@ struct common_dbs_data { · 210 unmodified lines
211	211	struct dbs_data {
212	212	struct common_dbs_data *cdata;
213	213	unsigned int min_sampling_rate;
	214	+ int usage_count;
214	215	void *tuners;
215	216
216	217	/* dbs_mutex protects dbs_enable in governor start/stop */

drivers/cpufreq/cpufreq_ondemand.c+0−1

@@ -547,7 +547,6 @@ static int od_init(struct dbs_data *dbs_data) · 546 unmodified lines
547	547	tuners->io_is_busy = should_io_be_busy();
548	548
549	549	dbs_data->tuners = tuners;
550		− pr_info("%s: tuners %p\n", __func__, tuners);
551	550	mutex_init(&dbs_data->mutex);
552	551	return 0;
553	552	}

drivers/cpufreq/cpufreq_stats.c+4−3

@@ -349,15 +349,16 @@ static int __cpuinit cpufreq_stat_cpu_callback(struct notifier_block *nfb, · 348 unmodified lines
349	349
350	350	switch (action) {
351	351	case CPU_ONLINE:
352		− case CPU_ONLINE_FROZEN:
353	352	cpufreq_update_policy(cpu);
354	353	break;
355	354	case CPU_DOWN_PREPARE:
356		− case CPU_DOWN_PREPARE_FROZEN:
357	355	cpufreq_stats_free_sysfs(cpu);
358	356	break;
359	357	case CPU_DEAD:
360		− case CPU_DEAD_FROZEN:
	358	+ cpufreq_stats_free_table(cpu);
	359	+ break;
	360	+ case CPU_UP_CANCELED_FROZEN:
	361	+ cpufreq_stats_free_sysfs(cpu);
361	362	cpufreq_stats_free_table(cpu);
362	363	break;
363	364	}

drivers/cpufreq/intel_pstate.c+21−101

@@ -48,12 +48,7 @@ static inline int32_t div_fp(int32_t x, int32_t y) · 47 unmodified lines
48	48	}
49	49
50	50	struct sample {
51		− ktime_t start_time;
52		− ktime_t end_time;
53	51	int core_pct_busy;
54		− int pstate_pct_busy;
55		− u64 duration_us;
56		− u64 idletime_us;
57	52	u64 aperf;
58	53	u64 mperf;
59	54	int freq;
@@ -86,13 +81,9 @@ struct cpudata { · 26 unmodified lines
86	81	struct pstate_adjust_policy *pstate_policy;
87	82	struct pstate_data pstate;
88	83	struct _pid pid;
89		− struct _pid idle_pid;
90	84
91	85	int min_pstate_count;
92		− int idle_mode;
93	86
94		− ktime_t prev_sample;
95		− u64 prev_idle_time_us;
96	87	u64 prev_aperf;
97	88	u64 prev_mperf;
98	89	int sample_ptr;
@@ -124,6 +115,8 @@ struct perf_limits { · 25 unmodified lines
124	115	int min_perf_pct;
125	116	int32_t max_perf;
126	117	int32_t min_perf;
	118	+ int max_policy_pct;
	119	+ int max_sysfs_pct;
127	120	};
128	121
129	122	static struct perf_limits limits = {
@@ -132,6 +125,8 @@ static struct perf_limits limits = { · 2 unmodified lines
132	125	.max_perf = int_tofp(1),
133	126	.min_perf_pct = 0,
134	127	.min_perf = 0,
	128	+ .max_policy_pct = 100,
	129	+ .max_sysfs_pct = 100,
135	130	};
136	131
137	132	static inline void pid_reset(struct _pid *pid, int setpoint, int busy,
@@ -202,19 +197,6 @@ static inline void intel_pstate_busy_pid_reset(struct cpudata *cpu) · 64 unmodified lines
202	197	0);
203	198	}
204	199
205		−static inline void intel_pstate_idle_pid_reset(struct cpudata *cpu)
206		−{
207		− pid_p_gain_set(&cpu->idle_pid, cpu->pstate_policy->p_gain_pct);
208		− pid_d_gain_set(&cpu->idle_pid, cpu->pstate_policy->d_gain_pct);
209		− pid_i_gain_set(&cpu->idle_pid, cpu->pstate_policy->i_gain_pct);
210		−
211		− pid_reset(&cpu->idle_pid,
212		− 75,
213		− 50,
214		− cpu->pstate_policy->deadband,
215		− 0);
216		−}
217		−
218	200	static inline void intel_pstate_reset_all_pid(void)
219	201	{
220	202	unsigned int cpu;
@@ -302,7 +284,8 @@ static ssize_t store_max_perf_pct(struct kobject a, struct attribute b, · 81 unmodified lines
302	284	if (ret != 1)
303	285	return -EINVAL;
304	286
305		− limits.max_perf_pct = clamp_t(int, input, 0 , 100);
	287	+ limits.max_sysfs_pct = clamp_t(int, input, 0 , 100);
	288	+ limits.max_perf_pct = min(limits.max_policy_pct, limits.max_sysfs_pct);
306	289	limits.max_perf = div_fp(int_tofp(limits.max_perf_pct), int_tofp(100));
307	290	return count;
308	291	}
@@ -408,9 +391,8 @@ static void intel_pstate_set_pstate(struct cpudata *cpu, int pstate) · 99 unmodified lines
408	391	if (pstate == cpu->pstate.current_pstate)
409	392	return;
410	393
411		−#ifndef MODULE
412	394	trace_cpu_frequency(pstate * 100000, cpu->cpu);
413		−#endif
	395	+
414	396	cpu->pstate.current_pstate = pstate;
415	397	wrmsrl(MSR_IA32_PERF_CTL, pstate << 8);
416	398
@@ -450,48 +432,26 @@ static inline void intel_pstate_calc_busy(struct cpudata *cpu, · 33 unmodified lines
450	432	struct sample *sample)
451	433	{
452	434	u64 core_pct;
453		− sample->pstate_pct_busy = 100 - div64_u64(
454		− sample->idletime_us * 100,
455		− sample->duration_us);
456	435	core_pct = div64_u64(sample->aperf * 100, sample->mperf);
457	436	sample->freq = cpu->pstate.max_pstate * core_pct * 1000;
458	437
459		− sample->core_pct_busy = div_s64((sample->pstate_pct_busy * core_pct),
460		− 100);
	438	+ sample->core_pct_busy = core_pct;
461	439	}
462	440
463	441	static inline void intel_pstate_sample(struct cpudata *cpu)
464	442	{
465		− ktime_t now;
466		− u64 idle_time_us;
467	443	u64 aperf, mperf;
468	444
469		− now = ktime_get();
470		− idle_time_us = get_cpu_idle_time_us(cpu->cpu, NULL);
471		−
472	445	rdmsrl(MSR_IA32_APERF, aperf);
473	446	rdmsrl(MSR_IA32_MPERF, mperf);
474		− /* for the first sample, don't actually record a sample, just
475		− * set the baseline */
476		− if (cpu->prev_idle_time_us > 0) {
477		− cpu->sample_ptr = (cpu->sample_ptr + 1) % SAMPLE_COUNT;
478		− cpu->samples[cpu->sample_ptr].start_time = cpu->prev_sample;
479		− cpu->samples[cpu->sample_ptr].end_time = now;
480		− cpu->samples[cpu->sample_ptr].duration_us =
481		− ktime_us_delta(now, cpu->prev_sample);
482		− cpu->samples[cpu->sample_ptr].idletime_us =
483		− idle_time_us - cpu->prev_idle_time_us;
484		−
485		− cpu->samples[cpu->sample_ptr].aperf = aperf;
486		− cpu->samples[cpu->sample_ptr].mperf = mperf;
487		− cpu->samples[cpu->sample_ptr].aperf -= cpu->prev_aperf;
488		− cpu->samples[cpu->sample_ptr].mperf -= cpu->prev_mperf;
489		−
490		− intel_pstate_calc_busy(cpu, &cpu->samples[cpu->sample_ptr]);
491		− }
	447	+ cpu->sample_ptr = (cpu->sample_ptr + 1) % SAMPLE_COUNT;
	448	+ cpu->samples[cpu->sample_ptr].aperf = aperf;
	449	+ cpu->samples[cpu->sample_ptr].mperf = mperf;
	450	+ cpu->samples[cpu->sample_ptr].aperf -= cpu->prev_aperf;
	451	+ cpu->samples[cpu->sample_ptr].mperf -= cpu->prev_mperf;
	452	+
	453	+ intel_pstate_calc_busy(cpu, &cpu->samples[cpu->sample_ptr]);
492	454
493		− cpu->prev_sample = now;
494		− cpu->prev_idle_time_us = idle_time_us;
495	455	cpu->prev_aperf = aperf;
496	456	cpu->prev_mperf = mperf;
497	457	}
@@ -505,16 +465,6 @@ static inline void intel_pstate_set_sample_time(struct cpudata *cpu) · 7 unmodified lines
505	465	mod_timer_pinned(&cpu->timer, jiffies + delay);
506	466	}
507	467
508		−static inline void intel_pstate_idle_mode(struct cpudata *cpu)
509		−{
510		− cpu->idle_mode = 1;
511		−}
512		−
513		−static inline void intel_pstate_normal_mode(struct cpudata *cpu)
514		−{
515		− cpu->idle_mode = 0;
516		−}
517		−
518	468	static inline int intel_pstate_get_scaled_busy(struct cpudata *cpu)
519	469	{
520	470	int32_t busy_scaled;
@@ -547,50 +497,21 @@ static inline void intel_pstate_adjust_busy_pstate(struct cpudata *cpu) · 26 unmodified lines
547	497	intel_pstate_pstate_decrease(cpu, steps);
548	498	}
549	499
550		−static inline void intel_pstate_adjust_idle_pstate(struct cpudata *cpu)
551		−{
552		− int busy_scaled;
553		− struct _pid *pid;
554		− int ctl = 0;
555		− int steps;
556		−
557		− pid = &cpu->idle_pid;
558		−
559		− busy_scaled = intel_pstate_get_scaled_busy(cpu);
560		−
561		− ctl = pid_calc(pid, 100 - busy_scaled);
562		−
563		− steps = abs(ctl);
564		− if (ctl < 0)
565		− intel_pstate_pstate_decrease(cpu, steps);
566		− else
567		− intel_pstate_pstate_increase(cpu, steps);
568		−
569		− if (cpu->pstate.current_pstate == cpu->pstate.min_pstate)
570		− intel_pstate_normal_mode(cpu);
571		−}
572		−
573	500	static void intel_pstate_timer_func(unsigned long __data)
574	501	{
575	502	struct cpudata cpu = (struct cpudata ) __data;
576	503
577	504	intel_pstate_sample(cpu);
	505	+ intel_pstate_adjust_busy_pstate(cpu);
578	506
579		− if (!cpu->idle_mode)
580		− intel_pstate_adjust_busy_pstate(cpu);
581		− else
582		− intel_pstate_adjust_idle_pstate(cpu);
583		−
584		−#if defined(XPERF_FIX)
585	507	if (cpu->pstate.current_pstate == cpu->pstate.min_pstate) {
586	508	cpu->min_pstate_count++;
587	509	if (!(cpu->min_pstate_count % 5)) {
588	510	intel_pstate_set_pstate(cpu, cpu->pstate.max_pstate);
589		− intel_pstate_idle_mode(cpu);
590	511	}
591	512	} else
592	513	cpu->min_pstate_count = 0;
593		−#endif
	514	+
594	515	intel_pstate_set_sample_time(cpu);
595	516	}
596	517
@@ -631,7 +552,6 @@ static int intel_pstate_init_cpu(unsigned int cpunum) · 34 unmodified lines
631	552	(unsigned long)cpu;
632	553	cpu->timer.expires = jiffies + HZ/100;
633	554	intel_pstate_busy_pid_reset(cpu);
634		− intel_pstate_idle_pid_reset(cpu);
635	555	intel_pstate_sample(cpu);
636	556	intel_pstate_set_pstate(cpu, cpu->pstate.max_pstate);
637	557
@@ -675,8 +595,9 @@ static int intel_pstate_set_policy(struct cpufreq_policy *policy) · 37 unmodified lines
675	595	limits.min_perf_pct = clamp_t(int, limits.min_perf_pct, 0 , 100);
676	596	limits.min_perf = div_fp(int_tofp(limits.min_perf_pct), int_tofp(100));
677	597
678		− limits.max_perf_pct = policy->max * 100 / policy->cpuinfo.max_freq;
679		− limits.max_perf_pct = clamp_t(int, limits.max_perf_pct, 0 , 100);
	598	+ limits.max_policy_pct = policy->max * 100 / policy->cpuinfo.max_freq;
	599	+ limits.max_policy_pct = clamp_t(int, limits.max_policy_pct, 0 , 100);
	600	+ limits.max_perf_pct = min(limits.max_policy_pct, limits.max_sysfs_pct);
680	601	limits.max_perf = div_fp(int_tofp(limits.max_perf_pct), int_tofp(100));
681	602
682	603	return 0;
@@ -788,10 +709,9 @@ static int __init intel_pstate_init(void) · 105 unmodified lines
788	709
789	710	pr_info("Intel P-state driver initializing.\n");
790	711
791		− all_cpu_data = vmalloc(sizeof(void ) num_possible_cpus());
	712	+ all_cpu_data = vzalloc(sizeof(void ) num_possible_cpus());
792	713	if (!all_cpu_data)
793	714	return -ENOMEM;
794		− memset(all_cpu_data, 0, sizeof(void ) num_possible_cpus());
795	715
796	716	rc = cpufreq_register_driver(&intel_pstate_driver);
797	717	if (rc)

drivers/cpufreq/kirkwood-cpufreq.c+0−4

@@ -171,10 +171,6 @@ static int kirkwood_cpufreq_probe(struct platform_device *pdev) · 170 unmodified lines
171	171	priv.dev = &pdev->dev;
172	172
173	173	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
174		− if (!res) {
175		− dev_err(&pdev->dev, "Cannot get memory resource\n");
176		− return -ENODEV;
177		− }
178	174	priv.base = devm_ioremap_resource(&pdev->dev, res);
179	175	if (IS_ERR(priv.base))
180	176	return PTR_ERR(priv.base);

include/acpi/acpiosxf.h+1−1

@@ -77,7 +77,7 @@ struct acpi_signal_fatal_info { · 76 unmodified lines
77	77	/*
78	78	* OSL Initialization and shutdown primitives
79	79	*/
80		−acpi_status __initdata acpi_os_initialize(void);
	80	+acpi_status __init acpi_os_initialize(void);
81	81
82	82	acpi_status acpi_os_terminate(void);
83	83

include/acpi/processor.h+8−2

@@ -329,10 +329,16 @@ int acpi_processor_power_init(struct acpi_processor *pr); · 328 unmodified lines
329	329	int acpi_processor_power_exit(struct acpi_processor *pr);
330	330	int acpi_processor_cst_has_changed(struct acpi_processor *pr);
331	331	int acpi_processor_hotplug(struct acpi_processor *pr);
332		−int acpi_processor_suspend(struct device *dev);
333		−int acpi_processor_resume(struct device *dev);
334	332	extern struct cpuidle_driver acpi_idle_driver;
335	333
	334	+#ifdef CONFIG_PM_SLEEP
	335	+void acpi_processor_syscore_init(void);
	336	+void acpi_processor_syscore_exit(void);
	337	+#else
	338	+static inline void acpi_processor_syscore_init(void) {}
	339	+static inline void acpi_processor_syscore_exit(void) {}
	340	+#endif
	341	+
336	342	/* in processor_thermal.c */
337	343	int acpi_processor_get_limit_info(struct acpi_processor *pr);
338	344	extern const struct thermal_cooling_device_ops processor_cooling_ops;

Merge tag 'pm+acpi-3.10-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code