1/*
  2 * kernel/power/suspend.c - Suspend to RAM and standby functionality.
  3 *
  4 * Copyright (c) 2003 Patrick Mochel
  5 * Copyright (c) 2003 Open Source Development Lab
  6 * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
  7 *
  8 * This file is released under the GPLv2.
  9 */
 10
 11#include <linux/string.h>
 12#include <linux/delay.h>
 13#include <linux/errno.h>
 14#include <linux/init.h>
 15#include <linux/console.h>
 16#include <linux/cpu.h>
 17#include <linux/syscalls.h>
 18#include <linux/gfp.h>
 19#include <linux/io.h>
 20#include <linux/kernel.h>
 21#include <linux/list.h>
 22#include <linux/mm.h>
 23#include <linux/slab.h>
 
 24#include <linux/suspend.h>
 25#include <linux/syscore_ops.h>
 
 26#include <trace/events/power.h>
 27
 28#include "power.h"
 29
 30const char *const pm_states[PM_SUSPEND_MAX] = {
 31	[PM_SUSPEND_STANDBY]	= "standby",
 32	[PM_SUSPEND_MEM]	= "mem",
 33};
 34
 35static const struct platform_suspend_ops *suspend_ops;
 36
 37/**
 38 *	suspend_set_ops - Set the global suspend method table.
 39 *	@ops:	Pointer to ops structure.
 40 */
 41void suspend_set_ops(const struct platform_suspend_ops *ops)
 42{
 43	mutex_lock(&pm_mutex);
 44	suspend_ops = ops;
 45	mutex_unlock(&pm_mutex);
 46}
 47EXPORT_SYMBOL_GPL(suspend_set_ops);
 48
 49bool valid_state(suspend_state_t state)
 50{
 51	/*
 52	 * All states need lowlevel support and need to be valid to the lowlevel
 53	 * implementation, no valid callback implies that none are valid.
 54	 */
 55	return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
 56}
 57
 58/**
 59 * suspend_valid_only_mem - generic memory-only valid callback
 60 *
 61 * Platform drivers that implement mem suspend only and only need
 62 * to check for that in their .valid callback can use this instead
 63 * of rolling their own .valid callback.
 64 */
 65int suspend_valid_only_mem(suspend_state_t state)
 66{
 67	return state == PM_SUSPEND_MEM;
 68}
 69EXPORT_SYMBOL_GPL(suspend_valid_only_mem);
 70
 71static int suspend_test(int level)
 72{
 73#ifdef CONFIG_PM_DEBUG
 74	if (pm_test_level == level) {
 75		printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n");
 76		mdelay(5000);
 77		return 1;
 78	}
 79#endif /* !CONFIG_PM_DEBUG */
 80	return 0;
 81}
 82
 83/**
 84 *	suspend_prepare - Do prep work before entering low-power state.
 85 *
 86 *	This is common code that is called for each state that we're entering.
 87 *	Run suspend notifiers, allocate a console and stop all processes.
 
 88 */
 89static int suspend_prepare(void)
 90{
 91	int error;
 92
 93	if (!suspend_ops || !suspend_ops->enter)
 94		return -EPERM;
 95
 96	pm_prepare_console();
 97
 98	error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
 99	if (error)
100		goto Finish;
101
102	error = usermodehelper_disable();
103	if (error)
104		goto Finish;
105
106	error = suspend_freeze_processes();
107	if (!error)
108		return 0;
109
110	suspend_thaw_processes();
111	usermodehelper_enable();
112 Finish:
113	pm_notifier_call_chain(PM_POST_SUSPEND);
114	pm_restore_console();
115	return error;
116}
117
118/* default implementation */
119void __attribute__ ((weak)) arch_suspend_disable_irqs(void)
120{
121	local_irq_disable();
122}
123
124/* default implementation */
125void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
126{
127	local_irq_enable();
128}
129
130/**
131 * suspend_enter - enter the desired system sleep state.
132 * @state: State to enter
133 * @wakeup: Returns information that suspend should not be entered again.
134 *
135 * This function should be called after devices have been suspended.
136 */
137static int suspend_enter(suspend_state_t state, bool *wakeup)
138{
139	int error;
140
141	if (suspend_ops->prepare) {
142		error = suspend_ops->prepare();
143		if (error)
144			goto Platform_finish;
145	}
146
147	error = dpm_suspend_noirq(PMSG_SUSPEND);
148	if (error) {
149		printk(KERN_ERR "PM: Some devices failed to power down\n");
150		goto Platform_finish;
151	}
152
153	if (suspend_ops->prepare_late) {
154		error = suspend_ops->prepare_late();
155		if (error)
156			goto Platform_wake;
157	}
158
159	if (suspend_test(TEST_PLATFORM))
160		goto Platform_wake;
161
162	error = disable_nonboot_cpus();
163	if (error || suspend_test(TEST_CPUS))
164		goto Enable_cpus;
165
166	arch_suspend_disable_irqs();
167	BUG_ON(!irqs_disabled());
168
169	error = syscore_suspend();
170	if (!error) {
171		*wakeup = pm_wakeup_pending();
172		if (!(suspend_test(TEST_CORE) || *wakeup)) {
173			error = suspend_ops->enter(state);
174			events_check_enabled = false;
175		}
176		syscore_resume();
177	}
178
179	arch_suspend_enable_irqs();
180	BUG_ON(irqs_disabled());
181
182 Enable_cpus:
183	enable_nonboot_cpus();
184
185 Platform_wake:
186	if (suspend_ops->wake)
187		suspend_ops->wake();
188
189	dpm_resume_noirq(PMSG_RESUME);
190
191 Platform_finish:
192	if (suspend_ops->finish)
193		suspend_ops->finish();
194
195	return error;
196}
197
198/**
199 *	suspend_devices_and_enter - suspend devices and enter the desired system
200 *				    sleep state.
201 *	@state:		  state to enter
202 */
203int suspend_devices_and_enter(suspend_state_t state)
204{
205	int error;
206	bool wakeup = false;
207
208	if (!suspend_ops)
209		return -ENOSYS;
210
211	trace_machine_suspend(state);
212	if (suspend_ops->begin) {
213		error = suspend_ops->begin(state);
214		if (error)
215			goto Close;
216	}
217	suspend_console();
 
218	suspend_test_start();
219	error = dpm_suspend_start(PMSG_SUSPEND);
220	if (error) {
221		printk(KERN_ERR "PM: Some devices failed to suspend\n");
222		goto Recover_platform;
223	}
224	suspend_test_finish("suspend devices");
225	if (suspend_test(TEST_DEVICES))
226		goto Recover_platform;
227
228	do {
229		error = suspend_enter(state, &wakeup);
230	} while (!error && !wakeup
231		&& suspend_ops->suspend_again && suspend_ops->suspend_again());
232
233 Resume_devices:
234	suspend_test_start();
235	dpm_resume_end(PMSG_RESUME);
236	suspend_test_finish("resume devices");
 
237	resume_console();
238 Close:
239	if (suspend_ops->end)
240		suspend_ops->end();
241	trace_machine_suspend(PWR_EVENT_EXIT);
242	return error;
243
244 Recover_platform:
245	if (suspend_ops->recover)
246		suspend_ops->recover();
247	goto Resume_devices;
248}
249
250/**
251 *	suspend_finish - Do final work before exiting suspend sequence.
252 *
253 *	Call platform code to clean up, restart processes, and free the
254 *	console that we've allocated. This is not called for suspend-to-disk.
255 */
256static void suspend_finish(void)
257{
258	suspend_thaw_processes();
259	usermodehelper_enable();
260	pm_notifier_call_chain(PM_POST_SUSPEND);
261	pm_restore_console();
262}
263
264/**
265 *	enter_state - Do common work of entering low-power state.
266 *	@state:		pm_state structure for state we're entering.
267 *
268 *	Make sure we're the only ones trying to enter a sleep state. Fail
269 *	if someone has beat us to it, since we don't want anything weird to
270 *	happen when we wake up.
271 *	Then, do the setup for suspend, enter the state, and cleaup (after
272 *	we've woken up).
273 */
274int enter_state(suspend_state_t state)
275{
276	int error;
277
278	if (!valid_state(state))
279		return -ENODEV;
280
281	if (!mutex_trylock(&pm_mutex))
282		return -EBUSY;
283
284	printk(KERN_INFO "PM: Syncing filesystems ... ");
285	sys_sync();
286	printk("done.\n");
287
288	pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
289	error = suspend_prepare();
290	if (error)
291		goto Unlock;
292
293	if (suspend_test(TEST_FREEZER))
294		goto Finish;
295
296	pr_debug("PM: Entering %s sleep\n", pm_states[state]);
297	pm_restrict_gfp_mask();
298	error = suspend_devices_and_enter(state);
299	pm_restore_gfp_mask();
300
301 Finish:
302	pr_debug("PM: Finishing wakeup.\n");
303	suspend_finish();
304 Unlock:
305	mutex_unlock(&pm_mutex);
306	return error;
307}
308
309/**
310 *	pm_suspend - Externally visible function for suspending system.
311 *	@state:		Enumerated value of state to enter.
312 *
313 *	Determine whether or not value is within range, get state
314 *	structure, and enter (above).
315 */
316int pm_suspend(suspend_state_t state)
317{
318	if (state > PM_SUSPEND_ON && state <= PM_SUSPEND_MAX)
319		return enter_state(state);
320	return -EINVAL;
 
 
 
 
 
 
 
 
 
 
321}
322EXPORT_SYMBOL(pm_suspend);

  1/*
  2 * kernel/power/suspend.c - Suspend to RAM and standby functionality.
  3 *
  4 * Copyright (c) 2003 Patrick Mochel
  5 * Copyright (c) 2003 Open Source Development Lab
  6 * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
  7 *
  8 * This file is released under the GPLv2.
  9 */
 10
 11#include <linux/string.h>
 12#include <linux/delay.h>
 13#include <linux/errno.h>
 14#include <linux/init.h>
 15#include <linux/console.h>
 16#include <linux/cpu.h>
 17#include <linux/syscalls.h>
 18#include <linux/gfp.h>
 19#include <linux/io.h>
 20#include <linux/kernel.h>
 21#include <linux/list.h>
 22#include <linux/mm.h>
 23#include <linux/slab.h>
 24#include <linux/export.h>
 25#include <linux/suspend.h>
 26#include <linux/syscore_ops.h>
 27#include <linux/ftrace.h>
 28#include <trace/events/power.h>
 29
 30#include "power.h"
 31
 32const char *const pm_states[PM_SUSPEND_MAX] = {
 33	[PM_SUSPEND_STANDBY]	= "standby",
 34	[PM_SUSPEND_MEM]	= "mem",
 35};
 36
 37static const struct platform_suspend_ops *suspend_ops;
 38
 39/**
 40 * suspend_set_ops - Set the global suspend method table.
 41 * @ops: Suspend operations to use.
 42 */
 43void suspend_set_ops(const struct platform_suspend_ops *ops)
 44{
 45	lock_system_sleep();
 46	suspend_ops = ops;
 47	unlock_system_sleep();
 48}
 49EXPORT_SYMBOL_GPL(suspend_set_ops);
 50
 51bool valid_state(suspend_state_t state)
 52{
 53	/*
 54	 * All states need lowlevel support and need to be valid to the lowlevel
 55	 * implementation, no valid callback implies that none are valid.
 56	 */
 57	return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
 58}
 59
 60/**
 61 * suspend_valid_only_mem - Generic memory-only valid callback.
 62 *
 63 * Platform drivers that implement mem suspend only and only need to check for
 64 * that in their .valid() callback can use this instead of rolling their own
 65 * .valid() callback.
 66 */
 67int suspend_valid_only_mem(suspend_state_t state)
 68{
 69	return state == PM_SUSPEND_MEM;
 70}
 71EXPORT_SYMBOL_GPL(suspend_valid_only_mem);
 72
 73static int suspend_test(int level)
 74{
 75#ifdef CONFIG_PM_DEBUG
 76	if (pm_test_level == level) {
 77		printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n");
 78		mdelay(5000);
 79		return 1;
 80	}
 81#endif /* !CONFIG_PM_DEBUG */
 82	return 0;
 83}
 84
 85/**
 86 * suspend_prepare - Prepare for entering system sleep state.
 87 *
 88 * Common code run for every system sleep state that can be entered (except for
 89 * hibernation).  Run suspend notifiers, allocate the "suspend" console and
 90 * freeze processes.
 91 */
 92static int suspend_prepare(void)
 93{
 94	int error;
 95
 96	if (!suspend_ops || !suspend_ops->enter)
 97		return -EPERM;
 98
 99	pm_prepare_console();
100
101	error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
102	if (error)
103		goto Finish;
104
 
 
 
 
105	error = suspend_freeze_processes();
106	if (!error)
107		return 0;
108
109	suspend_stats.failed_freeze++;
110	dpm_save_failed_step(SUSPEND_FREEZE);
111 Finish:
112	pm_notifier_call_chain(PM_POST_SUSPEND);
113	pm_restore_console();
114	return error;
115}
116
117/* default implementation */
118void __attribute__ ((weak)) arch_suspend_disable_irqs(void)
119{
120	local_irq_disable();
121}
122
123/* default implementation */
124void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
125{
126	local_irq_enable();
127}
128
129/**
130 * suspend_enter - Make the system enter the given sleep state.
131 * @state: System sleep state to enter.
132 * @wakeup: Returns information that the sleep state should not be re-entered.
133 *
134 * This function should be called after devices have been suspended.
135 */
136static int suspend_enter(suspend_state_t state, bool *wakeup)
137{
138	int error;
139
140	if (suspend_ops->prepare) {
141		error = suspend_ops->prepare();
142		if (error)
143			goto Platform_finish;
144	}
145
146	error = dpm_suspend_end(PMSG_SUSPEND);
147	if (error) {
148		printk(KERN_ERR "PM: Some devices failed to power down\n");
149		goto Platform_finish;
150	}
151
152	if (suspend_ops->prepare_late) {
153		error = suspend_ops->prepare_late();
154		if (error)
155			goto Platform_wake;
156	}
157
158	if (suspend_test(TEST_PLATFORM))
159		goto Platform_wake;
160
161	error = disable_nonboot_cpus();
162	if (error || suspend_test(TEST_CPUS))
163		goto Enable_cpus;
164
165	arch_suspend_disable_irqs();
166	BUG_ON(!irqs_disabled());
167
168	error = syscore_suspend();
169	if (!error) {
170		*wakeup = pm_wakeup_pending();
171		if (!(suspend_test(TEST_CORE) || *wakeup)) {
172			error = suspend_ops->enter(state);
173			events_check_enabled = false;
174		}
175		syscore_resume();
176	}
177
178	arch_suspend_enable_irqs();
179	BUG_ON(irqs_disabled());
180
181 Enable_cpus:
182	enable_nonboot_cpus();
183
184 Platform_wake:
185	if (suspend_ops->wake)
186		suspend_ops->wake();
187
188	dpm_resume_start(PMSG_RESUME);
189
190 Platform_finish:
191	if (suspend_ops->finish)
192		suspend_ops->finish();
193
194	return error;
195}
196
197/**
198 * suspend_devices_and_enter - Suspend devices and enter system sleep state.
199 * @state: System sleep state to enter.
 
200 */
201int suspend_devices_and_enter(suspend_state_t state)
202{
203	int error;
204	bool wakeup = false;
205
206	if (!suspend_ops)
207		return -ENOSYS;
208
209	trace_machine_suspend(state);
210	if (suspend_ops->begin) {
211		error = suspend_ops->begin(state);
212		if (error)
213			goto Close;
214	}
215	suspend_console();
216	ftrace_stop();
217	suspend_test_start();
218	error = dpm_suspend_start(PMSG_SUSPEND);
219	if (error) {
220		printk(KERN_ERR "PM: Some devices failed to suspend\n");
221		goto Recover_platform;
222	}
223	suspend_test_finish("suspend devices");
224	if (suspend_test(TEST_DEVICES))
225		goto Recover_platform;
226
227	do {
228		error = suspend_enter(state, &wakeup);
229	} while (!error && !wakeup
230		&& suspend_ops->suspend_again && suspend_ops->suspend_again());
231
232 Resume_devices:
233	suspend_test_start();
234	dpm_resume_end(PMSG_RESUME);
235	suspend_test_finish("resume devices");
236	ftrace_start();
237	resume_console();
238 Close:
239	if (suspend_ops->end)
240		suspend_ops->end();
241	trace_machine_suspend(PWR_EVENT_EXIT);
242	return error;
243
244 Recover_platform:
245	if (suspend_ops->recover)
246		suspend_ops->recover();
247	goto Resume_devices;
248}
249
250/**
251 * suspend_finish - Clean up before finishing the suspend sequence.
252 *
253 * Call platform code to clean up, restart processes, and free the console that
254 * we've allocated. This routine is not called for hibernation.
255 */
256static void suspend_finish(void)
257{
258	suspend_thaw_processes();
 
259	pm_notifier_call_chain(PM_POST_SUSPEND);
260	pm_restore_console();
261}
262
263/**
264 * enter_state - Do common work needed to enter system sleep state.
265 * @state: System sleep state to enter.
266 *
267 * Make sure that no one else is trying to put the system into a sleep state.
268 * Fail if that's not the case.  Otherwise, prepare for system suspend, make the
269 * system enter the given sleep state and clean up after wakeup.
 
 
270 */
271static int enter_state(suspend_state_t state)
272{
273	int error;
274
275	if (!valid_state(state))
276		return -ENODEV;
277
278	if (!mutex_trylock(&pm_mutex))
279		return -EBUSY;
280
281	printk(KERN_INFO "PM: Syncing filesystems ... ");
282	sys_sync();
283	printk("done.\n");
284
285	pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
286	error = suspend_prepare();
287	if (error)
288		goto Unlock;
289
290	if (suspend_test(TEST_FREEZER))
291		goto Finish;
292
293	pr_debug("PM: Entering %s sleep\n", pm_states[state]);
294	pm_restrict_gfp_mask();
295	error = suspend_devices_and_enter(state);
296	pm_restore_gfp_mask();
297
298 Finish:
299	pr_debug("PM: Finishing wakeup.\n");
300	suspend_finish();
301 Unlock:
302	mutex_unlock(&pm_mutex);
303	return error;
304}
305
306/**
307 * pm_suspend - Externally visible function for suspending the system.
308 * @state: System sleep state to enter.
309 *
310 * Check if the value of @state represents one of the supported states,
311 * execute enter_state() and update system suspend statistics.
312 */
313int pm_suspend(suspend_state_t state)
314{
315	int error;
316
317	if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX)
318		return -EINVAL;
319
320	error = enter_state(state);
321	if (error) {
322		suspend_stats.fail++;
323		dpm_save_failed_errno(error);
324	} else {
325		suspend_stats.success++;
326	}
327	return error;
328}
329EXPORT_SYMBOL(pm_suspend);