Linux Audio

Check our new training course

Loading...
v4.6
 
  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/cpuidle.h>
 18#include <linux/syscalls.h>
 19#include <linux/gfp.h>
 20#include <linux/io.h>
 21#include <linux/kernel.h>
 22#include <linux/list.h>
 23#include <linux/mm.h>
 24#include <linux/slab.h>
 25#include <linux/export.h>
 26#include <linux/suspend.h>
 27#include <linux/syscore_ops.h>
 
 28#include <linux/ftrace.h>
 29#include <trace/events/power.h>
 30#include <linux/compiler.h>
 31#include <linux/moduleparam.h>
 32
 33#include "power.h"
 34
 35const char *pm_labels[] = { "mem", "standby", "freeze", NULL };
 
 
 
 
 36const char *pm_states[PM_SUSPEND_MAX];
 
 
 
 
 
 
 
 
 
 
 
 37
 38unsigned int pm_suspend_global_flags;
 39EXPORT_SYMBOL_GPL(pm_suspend_global_flags);
 40
 41static const struct platform_suspend_ops *suspend_ops;
 42static const struct platform_freeze_ops *freeze_ops;
 43static DECLARE_WAIT_QUEUE_HEAD(suspend_freeze_wait_head);
 44
 45enum freeze_state __read_mostly suspend_freeze_state;
 46static DEFINE_SPINLOCK(suspend_freeze_lock);
 
 
 
 
 
 
 
 
 
 
 
 
 47
 48void freeze_set_ops(const struct platform_freeze_ops *ops)
 49{
 50	lock_system_sleep();
 51	freeze_ops = ops;
 52	unlock_system_sleep();
 
 
 53}
 54
 55static void freeze_begin(void)
 56{
 57	suspend_freeze_state = FREEZE_STATE_NONE;
 58}
 59
 60static void freeze_enter(void)
 61{
 62	spin_lock_irq(&suspend_freeze_lock);
 
 
 63	if (pm_wakeup_pending())
 64		goto out;
 65
 66	suspend_freeze_state = FREEZE_STATE_ENTER;
 67	spin_unlock_irq(&suspend_freeze_lock);
 68
 69	get_online_cpus();
 70	cpuidle_resume();
 71
 72	/* Push all the CPUs into the idle loop. */
 73	wake_up_all_idle_cpus();
 74	pr_debug("PM: suspend-to-idle\n");
 75	/* Make the current CPU wait so it can enter the idle loop too. */
 76	wait_event(suspend_freeze_wait_head,
 77		   suspend_freeze_state == FREEZE_STATE_WAKE);
 78	pr_debug("PM: resume from suspend-to-idle\n");
 
 
 
 
 
 79
 80	cpuidle_pause();
 81	put_online_cpus();
 82
 83	spin_lock_irq(&suspend_freeze_lock);
 84
 85 out:
 86	suspend_freeze_state = FREEZE_STATE_NONE;
 87	spin_unlock_irq(&suspend_freeze_lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 88}
 89
 90void freeze_wake(void)
 91{
 92	unsigned long flags;
 93
 94	spin_lock_irqsave(&suspend_freeze_lock, flags);
 95	if (suspend_freeze_state > FREEZE_STATE_NONE) {
 96		suspend_freeze_state = FREEZE_STATE_WAKE;
 97		wake_up(&suspend_freeze_wait_head);
 98	}
 99	spin_unlock_irqrestore(&suspend_freeze_lock, flags);
100}
101EXPORT_SYMBOL_GPL(freeze_wake);
102
103static bool valid_state(suspend_state_t state)
104{
105	/*
106	 * PM_SUSPEND_STANDBY and PM_SUSPEND_MEM states need low level
107	 * support and need to be valid to the low level
108	 * implementation, no valid callback implies that none are valid.
 
109	 */
110	return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
 
111}
112
113/*
114 * If this is set, the "mem" label always corresponds to the deepest sleep state
115 * available, the "standby" label corresponds to the second deepest sleep state
116 * available (if any), and the "freeze" label corresponds to the remaining
117 * available sleep state (if there is one).
118 */
119static bool relative_states;
 
 
 
 
120
121static int __init sleep_states_setup(char *str)
122{
123	relative_states = !strncmp(str, "1", 1);
124	pm_states[PM_SUSPEND_FREEZE] = pm_labels[relative_states ? 0 : 2];
 
 
 
 
 
 
 
 
125	return 1;
126}
127
128__setup("relative_sleep_states=", sleep_states_setup);
129
130/**
131 * suspend_set_ops - Set the global suspend method table.
132 * @ops: Suspend operations to use.
133 */
134void suspend_set_ops(const struct platform_suspend_ops *ops)
135{
136	suspend_state_t i;
137	int j = 0;
138
139	lock_system_sleep();
140
141	suspend_ops = ops;
142	for (i = PM_SUSPEND_MEM; i >= PM_SUSPEND_STANDBY; i--)
143		if (valid_state(i)) {
144			pm_states[i] = pm_labels[j++];
145		} else if (!relative_states) {
146			pm_states[i] = NULL;
147			j++;
148		}
149
150	pm_states[PM_SUSPEND_FREEZE] = pm_labels[j];
 
 
 
 
 
 
 
 
 
 
151
152	unlock_system_sleep();
153}
154EXPORT_SYMBOL_GPL(suspend_set_ops);
155
156/**
157 * suspend_valid_only_mem - Generic memory-only valid callback.
 
158 *
159 * Platform drivers that implement mem suspend only and only need to check for
160 * that in their .valid() callback can use this instead of rolling their own
161 * .valid() callback.
162 */
163int suspend_valid_only_mem(suspend_state_t state)
164{
165	return state == PM_SUSPEND_MEM;
166}
167EXPORT_SYMBOL_GPL(suspend_valid_only_mem);
168
169static bool sleep_state_supported(suspend_state_t state)
170{
171	return state == PM_SUSPEND_FREEZE || (suspend_ops && suspend_ops->enter);
 
172}
173
174static int platform_suspend_prepare(suspend_state_t state)
175{
176	return state != PM_SUSPEND_FREEZE && suspend_ops->prepare ?
177		suspend_ops->prepare() : 0;
178}
179
180static int platform_suspend_prepare_late(suspend_state_t state)
181{
182	return state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->prepare ?
183		freeze_ops->prepare() : 0;
184}
185
186static int platform_suspend_prepare_noirq(suspend_state_t state)
187{
188	return state != PM_SUSPEND_FREEZE && suspend_ops->prepare_late ?
189		suspend_ops->prepare_late() : 0;
 
 
 
190}
191
192static void platform_resume_noirq(suspend_state_t state)
193{
194	if (state != PM_SUSPEND_FREEZE && suspend_ops->wake)
 
 
 
195		suspend_ops->wake();
 
196}
197
198static void platform_resume_early(suspend_state_t state)
199{
200	if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->restore)
201		freeze_ops->restore();
202}
203
204static void platform_resume_finish(suspend_state_t state)
205{
206	if (state != PM_SUSPEND_FREEZE && suspend_ops->finish)
207		suspend_ops->finish();
208}
209
210static int platform_suspend_begin(suspend_state_t state)
211{
212	if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->begin)
213		return freeze_ops->begin();
214	else if (suspend_ops->begin)
215		return suspend_ops->begin(state);
216	else
217		return 0;
218}
219
220static void platform_resume_end(suspend_state_t state)
221{
222	if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->end)
223		freeze_ops->end();
224	else if (suspend_ops->end)
225		suspend_ops->end();
226}
227
228static void platform_recover(suspend_state_t state)
229{
230	if (state != PM_SUSPEND_FREEZE && suspend_ops->recover)
231		suspend_ops->recover();
232}
233
234static bool platform_suspend_again(suspend_state_t state)
235{
236	return state != PM_SUSPEND_FREEZE && suspend_ops->suspend_again ?
237		suspend_ops->suspend_again() : false;
238}
239
240#ifdef CONFIG_PM_DEBUG
241static unsigned int pm_test_delay = 5;
242module_param(pm_test_delay, uint, 0644);
243MODULE_PARM_DESC(pm_test_delay,
244		 "Number of seconds to wait before resuming from suspend test");
245#endif
246
247static int suspend_test(int level)
248{
249#ifdef CONFIG_PM_DEBUG
250	if (pm_test_level == level) {
251		pr_info("suspend debug: Waiting for %d second(s).\n",
252				pm_test_delay);
253		mdelay(pm_test_delay * 1000);
254		return 1;
255	}
256#endif /* !CONFIG_PM_DEBUG */
257	return 0;
258}
259
260/**
261 * suspend_prepare - Prepare for entering system sleep state.
 
262 *
263 * Common code run for every system sleep state that can be entered (except for
264 * hibernation).  Run suspend notifiers, allocate the "suspend" console and
265 * freeze processes.
266 */
267static int suspend_prepare(suspend_state_t state)
268{
269	int error;
270
271	if (!sleep_state_supported(state))
272		return -EPERM;
273
274	pm_prepare_console();
275
276	error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
277	if (error)
278		goto Finish;
279
280	trace_suspend_resume(TPS("freeze_processes"), 0, true);
281	error = suspend_freeze_processes();
282	trace_suspend_resume(TPS("freeze_processes"), 0, false);
283	if (!error)
284		return 0;
285
286	suspend_stats.failed_freeze++;
287	dpm_save_failed_step(SUSPEND_FREEZE);
288 Finish:
289	pm_notifier_call_chain(PM_POST_SUSPEND);
 
290	pm_restore_console();
291	return error;
292}
293
294/* default implementation */
295void __weak arch_suspend_disable_irqs(void)
296{
297	local_irq_disable();
298}
299
300/* default implementation */
301void __weak arch_suspend_enable_irqs(void)
302{
303	local_irq_enable();
304}
305
306/**
307 * suspend_enter - Make the system enter the given sleep state.
308 * @state: System sleep state to enter.
309 * @wakeup: Returns information that the sleep state should not be re-entered.
310 *
311 * This function should be called after devices have been suspended.
312 */
313static int suspend_enter(suspend_state_t state, bool *wakeup)
314{
315	int error;
316
317	error = platform_suspend_prepare(state);
318	if (error)
319		goto Platform_finish;
320
321	error = dpm_suspend_late(PMSG_SUSPEND);
322	if (error) {
323		pr_err("PM: late suspend of devices failed\n");
324		goto Platform_finish;
325	}
326	error = platform_suspend_prepare_late(state);
327	if (error)
328		goto Devices_early_resume;
329
330	error = dpm_suspend_noirq(PMSG_SUSPEND);
331	if (error) {
332		pr_err("PM: noirq suspend of devices failed\n");
333		goto Platform_early_resume;
334	}
335	error = platform_suspend_prepare_noirq(state);
336	if (error)
337		goto Platform_wake;
338
339	if (suspend_test(TEST_PLATFORM))
340		goto Platform_wake;
341
342	/*
343	 * PM_SUSPEND_FREEZE equals
344	 * frozen processes + suspended devices + idle processors.
345	 * Thus we should invoke freeze_enter() soon after
346	 * all the devices are suspended.
347	 */
348	if (state == PM_SUSPEND_FREEZE) {
349		trace_suspend_resume(TPS("machine_suspend"), state, true);
350		freeze_enter();
351		trace_suspend_resume(TPS("machine_suspend"), state, false);
352		goto Platform_wake;
353	}
354
355	error = disable_nonboot_cpus();
356	if (error || suspend_test(TEST_CPUS))
357		goto Enable_cpus;
358
359	arch_suspend_disable_irqs();
360	BUG_ON(!irqs_disabled());
361
 
 
362	error = syscore_suspend();
363	if (!error) {
364		*wakeup = pm_wakeup_pending();
365		if (!(suspend_test(TEST_CORE) || *wakeup)) {
366			trace_suspend_resume(TPS("machine_suspend"),
367				state, true);
368			error = suspend_ops->enter(state);
369			trace_suspend_resume(TPS("machine_suspend"),
370				state, false);
371			events_check_enabled = false;
372		} else if (*wakeup) {
373			error = -EBUSY;
374		}
375		syscore_resume();
376	}
377
 
 
378	arch_suspend_enable_irqs();
379	BUG_ON(irqs_disabled());
380
381 Enable_cpus:
382	enable_nonboot_cpus();
383
384 Platform_wake:
385	platform_resume_noirq(state);
386	dpm_resume_noirq(PMSG_RESUME);
387
388 Platform_early_resume:
389	platform_resume_early(state);
390
391 Devices_early_resume:
392	dpm_resume_early(PMSG_RESUME);
393
394 Platform_finish:
395	platform_resume_finish(state);
396	return error;
397}
398
399/**
400 * suspend_devices_and_enter - Suspend devices and enter system sleep state.
401 * @state: System sleep state to enter.
402 */
403int suspend_devices_and_enter(suspend_state_t state)
404{
405	int error;
406	bool wakeup = false;
407
408	if (!sleep_state_supported(state))
409		return -ENOSYS;
410
 
 
 
 
 
411	error = platform_suspend_begin(state);
412	if (error)
413		goto Close;
414
415	suspend_console();
416	suspend_test_start();
417	error = dpm_suspend_start(PMSG_SUSPEND);
418	if (error) {
419		pr_err("PM: Some devices failed to suspend, or early wake event detected\n");
420		goto Recover_platform;
421	}
422	suspend_test_finish("suspend devices");
423	if (suspend_test(TEST_DEVICES))
424		goto Recover_platform;
425
426	do {
427		error = suspend_enter(state, &wakeup);
428	} while (!error && !wakeup && platform_suspend_again(state));
429
430 Resume_devices:
431	suspend_test_start();
432	dpm_resume_end(PMSG_RESUME);
433	suspend_test_finish("resume devices");
434	trace_suspend_resume(TPS("resume_console"), state, true);
435	resume_console();
436	trace_suspend_resume(TPS("resume_console"), state, false);
437
438 Close:
439	platform_resume_end(state);
 
440	return error;
441
442 Recover_platform:
443	platform_recover(state);
444	goto Resume_devices;
445}
446
447/**
448 * suspend_finish - Clean up before finishing the suspend sequence.
449 *
450 * Call platform code to clean up, restart processes, and free the console that
451 * we've allocated. This routine is not called for hibernation.
452 */
453static void suspend_finish(void)
454{
455	suspend_thaw_processes();
456	pm_notifier_call_chain(PM_POST_SUSPEND);
457	pm_restore_console();
458}
459
460/**
461 * enter_state - Do common work needed to enter system sleep state.
462 * @state: System sleep state to enter.
463 *
464 * Make sure that no one else is trying to put the system into a sleep state.
465 * Fail if that's not the case.  Otherwise, prepare for system suspend, make the
466 * system enter the given sleep state and clean up after wakeup.
467 */
468static int enter_state(suspend_state_t state)
469{
470	int error;
471
472	trace_suspend_resume(TPS("suspend_enter"), state, true);
473	if (state == PM_SUSPEND_FREEZE) {
474#ifdef CONFIG_PM_DEBUG
475		if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {
476			pr_warn("PM: Unsupported test mode for suspend to idle, please choose none/freezer/devices/platform.\n");
477			return -EAGAIN;
478		}
479#endif
480	} else if (!valid_state(state)) {
481		return -EINVAL;
482	}
483	if (!mutex_trylock(&pm_mutex))
484		return -EBUSY;
485
486	if (state == PM_SUSPEND_FREEZE)
487		freeze_begin();
488
489#ifndef CONFIG_SUSPEND_SKIP_SYNC
490	trace_suspend_resume(TPS("sync_filesystems"), 0, true);
491	printk(KERN_INFO "PM: Syncing filesystems ... ");
492	sys_sync();
493	printk("done.\n");
494	trace_suspend_resume(TPS("sync_filesystems"), 0, false);
495#endif
496
497	pr_debug("PM: Preparing system for sleep (%s)\n", pm_states[state]);
498	pm_suspend_clear_flags();
499	error = suspend_prepare(state);
500	if (error)
501		goto Unlock;
502
503	if (suspend_test(TEST_FREEZER))
504		goto Finish;
505
506	trace_suspend_resume(TPS("suspend_enter"), state, false);
507	pr_debug("PM: Suspending system (%s)\n", pm_states[state]);
508	pm_restrict_gfp_mask();
509	error = suspend_devices_and_enter(state);
510	pm_restore_gfp_mask();
511
512 Finish:
513	pr_debug("PM: Finishing wakeup.\n");
 
514	suspend_finish();
515 Unlock:
516	mutex_unlock(&pm_mutex);
517	return error;
518}
519
520/**
521 * pm_suspend - Externally visible function for suspending the system.
522 * @state: System sleep state to enter.
523 *
524 * Check if the value of @state represents one of the supported states,
525 * execute enter_state() and update system suspend statistics.
526 */
527int pm_suspend(suspend_state_t state)
528{
529	int error;
530
531	if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX)
532		return -EINVAL;
533
 
534	error = enter_state(state);
535	if (error) {
536		suspend_stats.fail++;
537		dpm_save_failed_errno(error);
538	} else {
539		suspend_stats.success++;
540	}
541	return error;
542}
543EXPORT_SYMBOL(pm_suspend);
v6.9.4
  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * kernel/power/suspend.c - Suspend to RAM and standby functionality.
  4 *
  5 * Copyright (c) 2003 Patrick Mochel
  6 * Copyright (c) 2003 Open Source Development Lab
  7 * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
 
 
  8 */
  9
 10#define pr_fmt(fmt) "PM: " fmt
 11
 12#include <linux/string.h>
 13#include <linux/delay.h>
 14#include <linux/errno.h>
 15#include <linux/init.h>
 16#include <linux/console.h>
 17#include <linux/cpu.h>
 18#include <linux/cpuidle.h>
 
 19#include <linux/gfp.h>
 20#include <linux/io.h>
 21#include <linux/kernel.h>
 22#include <linux/list.h>
 23#include <linux/mm.h>
 24#include <linux/slab.h>
 25#include <linux/export.h>
 26#include <linux/suspend.h>
 27#include <linux/syscore_ops.h>
 28#include <linux/swait.h>
 29#include <linux/ftrace.h>
 30#include <trace/events/power.h>
 31#include <linux/compiler.h>
 32#include <linux/moduleparam.h>
 33
 34#include "power.h"
 35
 36const char * const pm_labels[] = {
 37	[PM_SUSPEND_TO_IDLE] = "freeze",
 38	[PM_SUSPEND_STANDBY] = "standby",
 39	[PM_SUSPEND_MEM] = "mem",
 40};
 41const char *pm_states[PM_SUSPEND_MAX];
 42static const char * const mem_sleep_labels[] = {
 43	[PM_SUSPEND_TO_IDLE] = "s2idle",
 44	[PM_SUSPEND_STANDBY] = "shallow",
 45	[PM_SUSPEND_MEM] = "deep",
 46};
 47const char *mem_sleep_states[PM_SUSPEND_MAX];
 48
 49suspend_state_t mem_sleep_current = PM_SUSPEND_TO_IDLE;
 50suspend_state_t mem_sleep_default = PM_SUSPEND_MAX;
 51suspend_state_t pm_suspend_target_state;
 52EXPORT_SYMBOL_GPL(pm_suspend_target_state);
 53
 54unsigned int pm_suspend_global_flags;
 55EXPORT_SYMBOL_GPL(pm_suspend_global_flags);
 56
 57static const struct platform_suspend_ops *suspend_ops;
 58static const struct platform_s2idle_ops *s2idle_ops;
 59static DECLARE_SWAIT_QUEUE_HEAD(s2idle_wait_head);
 60
 61enum s2idle_states __read_mostly s2idle_state;
 62static DEFINE_RAW_SPINLOCK(s2idle_lock);
 63
 64/**
 65 * pm_suspend_default_s2idle - Check if suspend-to-idle is the default suspend.
 66 *
 67 * Return 'true' if suspend-to-idle has been selected as the default system
 68 * suspend method.
 69 */
 70bool pm_suspend_default_s2idle(void)
 71{
 72	return mem_sleep_current == PM_SUSPEND_TO_IDLE;
 73}
 74EXPORT_SYMBOL_GPL(pm_suspend_default_s2idle);
 75
 76void s2idle_set_ops(const struct platform_s2idle_ops *ops)
 77{
 78	unsigned int sleep_flags;
 79
 80	sleep_flags = lock_system_sleep();
 81	s2idle_ops = ops;
 82	unlock_system_sleep(sleep_flags);
 83}
 84
 85static void s2idle_begin(void)
 86{
 87	s2idle_state = S2IDLE_STATE_NONE;
 88}
 89
 90static void s2idle_enter(void)
 91{
 92	trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_TO_IDLE, true);
 93
 94	raw_spin_lock_irq(&s2idle_lock);
 95	if (pm_wakeup_pending())
 96		goto out;
 97
 98	s2idle_state = S2IDLE_STATE_ENTER;
 99	raw_spin_unlock_irq(&s2idle_lock);
100
101	cpus_read_lock();
 
102
103	/* Push all the CPUs into the idle loop. */
104	wake_up_all_idle_cpus();
 
105	/* Make the current CPU wait so it can enter the idle loop too. */
106	swait_event_exclusive(s2idle_wait_head,
107		    s2idle_state == S2IDLE_STATE_WAKE);
108
109	/*
110	 * Kick all CPUs to ensure that they resume their timers and restore
111	 * consistent system state.
112	 */
113	wake_up_all_idle_cpus();
114
115	cpus_read_unlock();
 
116
117	raw_spin_lock_irq(&s2idle_lock);
118
119 out:
120	s2idle_state = S2IDLE_STATE_NONE;
121	raw_spin_unlock_irq(&s2idle_lock);
122
123	trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_TO_IDLE, false);
124}
125
126static void s2idle_loop(void)
127{
128	pm_pr_dbg("suspend-to-idle\n");
129
130	/*
131	 * Suspend-to-idle equals:
132	 * frozen processes + suspended devices + idle processors.
133	 * Thus s2idle_enter() should be called right after all devices have
134	 * been suspended.
135	 *
136	 * Wakeups during the noirq suspend of devices may be spurious, so try
137	 * to avoid them upfront.
138	 */
139	for (;;) {
140		if (s2idle_ops && s2idle_ops->wake) {
141			if (s2idle_ops->wake())
142				break;
143		} else if (pm_wakeup_pending()) {
144			break;
145		}
146
147		if (s2idle_ops && s2idle_ops->check)
148			s2idle_ops->check();
149
150		s2idle_enter();
151	}
152
153	pm_pr_dbg("resume from suspend-to-idle\n");
154}
155
156void s2idle_wake(void)
157{
158	unsigned long flags;
159
160	raw_spin_lock_irqsave(&s2idle_lock, flags);
161	if (s2idle_state > S2IDLE_STATE_NONE) {
162		s2idle_state = S2IDLE_STATE_WAKE;
163		swake_up_one(&s2idle_wait_head);
164	}
165	raw_spin_unlock_irqrestore(&s2idle_lock, flags);
166}
167EXPORT_SYMBOL_GPL(s2idle_wake);
168
169static bool valid_state(suspend_state_t state)
170{
171	/*
172	 * The PM_SUSPEND_STANDBY and PM_SUSPEND_MEM states require low-level
173	 * support and need to be valid to the low-level implementation.
174	 *
175	 * No ->valid() or ->enter() callback implies that none are valid.
176	 */
177	return suspend_ops && suspend_ops->valid && suspend_ops->valid(state) &&
178		suspend_ops->enter;
179}
180
181void __init pm_states_init(void)
182{
183	/* "mem" and "freeze" are always present in /sys/power/state. */
184	pm_states[PM_SUSPEND_MEM] = pm_labels[PM_SUSPEND_MEM];
185	pm_states[PM_SUSPEND_TO_IDLE] = pm_labels[PM_SUSPEND_TO_IDLE];
186	/*
187	 * Suspend-to-idle should be supported even without any suspend_ops,
188	 * initialize mem_sleep_states[] accordingly here.
189	 */
190	mem_sleep_states[PM_SUSPEND_TO_IDLE] = mem_sleep_labels[PM_SUSPEND_TO_IDLE];
191}
192
193static int __init mem_sleep_default_setup(char *str)
194{
195	suspend_state_t state;
196
197	for (state = PM_SUSPEND_TO_IDLE; state <= PM_SUSPEND_MEM; state++)
198		if (mem_sleep_labels[state] &&
199		    !strcmp(str, mem_sleep_labels[state])) {
200			mem_sleep_default = state;
201			mem_sleep_current = state;
202			break;
203		}
204
205	return 1;
206}
207__setup("mem_sleep_default=", mem_sleep_default_setup);
 
208
209/**
210 * suspend_set_ops - Set the global suspend method table.
211 * @ops: Suspend operations to use.
212 */
213void suspend_set_ops(const struct platform_suspend_ops *ops)
214{
215	unsigned int sleep_flags;
 
216
217	sleep_flags = lock_system_sleep();
218
219	suspend_ops = ops;
 
 
 
 
 
 
 
220
221	if (valid_state(PM_SUSPEND_STANDBY)) {
222		mem_sleep_states[PM_SUSPEND_STANDBY] = mem_sleep_labels[PM_SUSPEND_STANDBY];
223		pm_states[PM_SUSPEND_STANDBY] = pm_labels[PM_SUSPEND_STANDBY];
224		if (mem_sleep_default == PM_SUSPEND_STANDBY)
225			mem_sleep_current = PM_SUSPEND_STANDBY;
226	}
227	if (valid_state(PM_SUSPEND_MEM)) {
228		mem_sleep_states[PM_SUSPEND_MEM] = mem_sleep_labels[PM_SUSPEND_MEM];
229		if (mem_sleep_default >= PM_SUSPEND_MEM)
230			mem_sleep_current = PM_SUSPEND_MEM;
231	}
232
233	unlock_system_sleep(sleep_flags);
234}
235EXPORT_SYMBOL_GPL(suspend_set_ops);
236
237/**
238 * suspend_valid_only_mem - Generic memory-only valid callback.
239 * @state: Target system sleep state.
240 *
241 * Platform drivers that implement mem suspend only and only need to check for
242 * that in their .valid() callback can use this instead of rolling their own
243 * .valid() callback.
244 */
245int suspend_valid_only_mem(suspend_state_t state)
246{
247	return state == PM_SUSPEND_MEM;
248}
249EXPORT_SYMBOL_GPL(suspend_valid_only_mem);
250
251static bool sleep_state_supported(suspend_state_t state)
252{
253	return state == PM_SUSPEND_TO_IDLE ||
254	       (valid_state(state) && !cxl_mem_active());
255}
256
257static int platform_suspend_prepare(suspend_state_t state)
258{
259	return state != PM_SUSPEND_TO_IDLE && suspend_ops->prepare ?
260		suspend_ops->prepare() : 0;
261}
262
263static int platform_suspend_prepare_late(suspend_state_t state)
264{
265	return state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->prepare ?
266		s2idle_ops->prepare() : 0;
267}
268
269static int platform_suspend_prepare_noirq(suspend_state_t state)
270{
271	if (state == PM_SUSPEND_TO_IDLE)
272		return s2idle_ops && s2idle_ops->prepare_late ?
273			s2idle_ops->prepare_late() : 0;
274
275	return suspend_ops->prepare_late ? suspend_ops->prepare_late() : 0;
276}
277
278static void platform_resume_noirq(suspend_state_t state)
279{
280	if (state == PM_SUSPEND_TO_IDLE) {
281		if (s2idle_ops && s2idle_ops->restore_early)
282			s2idle_ops->restore_early();
283	} else if (suspend_ops->wake) {
284		suspend_ops->wake();
285	}
286}
287
288static void platform_resume_early(suspend_state_t state)
289{
290	if (state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->restore)
291		s2idle_ops->restore();
292}
293
294static void platform_resume_finish(suspend_state_t state)
295{
296	if (state != PM_SUSPEND_TO_IDLE && suspend_ops->finish)
297		suspend_ops->finish();
298}
299
300static int platform_suspend_begin(suspend_state_t state)
301{
302	if (state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->begin)
303		return s2idle_ops->begin();
304	else if (suspend_ops && suspend_ops->begin)
305		return suspend_ops->begin(state);
306	else
307		return 0;
308}
309
310static void platform_resume_end(suspend_state_t state)
311{
312	if (state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->end)
313		s2idle_ops->end();
314	else if (suspend_ops && suspend_ops->end)
315		suspend_ops->end();
316}
317
318static void platform_recover(suspend_state_t state)
319{
320	if (state != PM_SUSPEND_TO_IDLE && suspend_ops->recover)
321		suspend_ops->recover();
322}
323
324static bool platform_suspend_again(suspend_state_t state)
325{
326	return state != PM_SUSPEND_TO_IDLE && suspend_ops->suspend_again ?
327		suspend_ops->suspend_again() : false;
328}
329
330#ifdef CONFIG_PM_DEBUG
331static unsigned int pm_test_delay = 5;
332module_param(pm_test_delay, uint, 0644);
333MODULE_PARM_DESC(pm_test_delay,
334		 "Number of seconds to wait before resuming from suspend test");
335#endif
336
337static int suspend_test(int level)
338{
339#ifdef CONFIG_PM_DEBUG
340	if (pm_test_level == level) {
341		pr_info("suspend debug: Waiting for %d second(s).\n",
342				pm_test_delay);
343		mdelay(pm_test_delay * 1000);
344		return 1;
345	}
346#endif /* !CONFIG_PM_DEBUG */
347	return 0;
348}
349
350/**
351 * suspend_prepare - Prepare for entering system sleep state.
352 * @state: Target system sleep state.
353 *
354 * Common code run for every system sleep state that can be entered (except for
355 * hibernation).  Run suspend notifiers, allocate the "suspend" console and
356 * freeze processes.
357 */
358static int suspend_prepare(suspend_state_t state)
359{
360	int error;
361
362	if (!sleep_state_supported(state))
363		return -EPERM;
364
365	pm_prepare_console();
366
367	error = pm_notifier_call_chain_robust(PM_SUSPEND_PREPARE, PM_POST_SUSPEND);
368	if (error)
369		goto Restore;
370
371	trace_suspend_resume(TPS("freeze_processes"), 0, true);
372	error = suspend_freeze_processes();
373	trace_suspend_resume(TPS("freeze_processes"), 0, false);
374	if (!error)
375		return 0;
376
 
377	dpm_save_failed_step(SUSPEND_FREEZE);
 
378	pm_notifier_call_chain(PM_POST_SUSPEND);
379 Restore:
380	pm_restore_console();
381	return error;
382}
383
384/* default implementation */
385void __weak arch_suspend_disable_irqs(void)
386{
387	local_irq_disable();
388}
389
390/* default implementation */
391void __weak arch_suspend_enable_irqs(void)
392{
393	local_irq_enable();
394}
395
396/**
397 * suspend_enter - Make the system enter the given sleep state.
398 * @state: System sleep state to enter.
399 * @wakeup: Returns information that the sleep state should not be re-entered.
400 *
401 * This function should be called after devices have been suspended.
402 */
403static int suspend_enter(suspend_state_t state, bool *wakeup)
404{
405	int error;
406
407	error = platform_suspend_prepare(state);
408	if (error)
409		goto Platform_finish;
410
411	error = dpm_suspend_late(PMSG_SUSPEND);
412	if (error) {
413		pr_err("late suspend of devices failed\n");
414		goto Platform_finish;
415	}
416	error = platform_suspend_prepare_late(state);
417	if (error)
418		goto Devices_early_resume;
419
420	error = dpm_suspend_noirq(PMSG_SUSPEND);
421	if (error) {
422		pr_err("noirq suspend of devices failed\n");
423		goto Platform_early_resume;
424	}
425	error = platform_suspend_prepare_noirq(state);
426	if (error)
427		goto Platform_wake;
428
429	if (suspend_test(TEST_PLATFORM))
430		goto Platform_wake;
431
432	if (state == PM_SUSPEND_TO_IDLE) {
433		s2idle_loop();
 
 
 
 
 
 
 
 
434		goto Platform_wake;
435	}
436
437	error = pm_sleep_disable_secondary_cpus();
438	if (error || suspend_test(TEST_CPUS))
439		goto Enable_cpus;
440
441	arch_suspend_disable_irqs();
442	BUG_ON(!irqs_disabled());
443
444	system_state = SYSTEM_SUSPEND;
445
446	error = syscore_suspend();
447	if (!error) {
448		*wakeup = pm_wakeup_pending();
449		if (!(suspend_test(TEST_CORE) || *wakeup)) {
450			trace_suspend_resume(TPS("machine_suspend"),
451				state, true);
452			error = suspend_ops->enter(state);
453			trace_suspend_resume(TPS("machine_suspend"),
454				state, false);
 
455		} else if (*wakeup) {
456			error = -EBUSY;
457		}
458		syscore_resume();
459	}
460
461	system_state = SYSTEM_RUNNING;
462
463	arch_suspend_enable_irqs();
464	BUG_ON(irqs_disabled());
465
466 Enable_cpus:
467	pm_sleep_enable_secondary_cpus();
468
469 Platform_wake:
470	platform_resume_noirq(state);
471	dpm_resume_noirq(PMSG_RESUME);
472
473 Platform_early_resume:
474	platform_resume_early(state);
475
476 Devices_early_resume:
477	dpm_resume_early(PMSG_RESUME);
478
479 Platform_finish:
480	platform_resume_finish(state);
481	return error;
482}
483
484/**
485 * suspend_devices_and_enter - Suspend devices and enter system sleep state.
486 * @state: System sleep state to enter.
487 */
488int suspend_devices_and_enter(suspend_state_t state)
489{
490	int error;
491	bool wakeup = false;
492
493	if (!sleep_state_supported(state))
494		return -ENOSYS;
495
496	pm_suspend_target_state = state;
497
498	if (state == PM_SUSPEND_TO_IDLE)
499		pm_set_suspend_no_platform();
500
501	error = platform_suspend_begin(state);
502	if (error)
503		goto Close;
504
505	suspend_console();
506	suspend_test_start();
507	error = dpm_suspend_start(PMSG_SUSPEND);
508	if (error) {
509		pr_err("Some devices failed to suspend, or early wake event detected\n");
510		goto Recover_platform;
511	}
512	suspend_test_finish("suspend devices");
513	if (suspend_test(TEST_DEVICES))
514		goto Recover_platform;
515
516	do {
517		error = suspend_enter(state, &wakeup);
518	} while (!error && !wakeup && platform_suspend_again(state));
519
520 Resume_devices:
521	suspend_test_start();
522	dpm_resume_end(PMSG_RESUME);
523	suspend_test_finish("resume devices");
524	trace_suspend_resume(TPS("resume_console"), state, true);
525	resume_console();
526	trace_suspend_resume(TPS("resume_console"), state, false);
527
528 Close:
529	platform_resume_end(state);
530	pm_suspend_target_state = PM_SUSPEND_ON;
531	return error;
532
533 Recover_platform:
534	platform_recover(state);
535	goto Resume_devices;
536}
537
538/**
539 * suspend_finish - Clean up before finishing the suspend sequence.
540 *
541 * Call platform code to clean up, restart processes, and free the console that
542 * we've allocated. This routine is not called for hibernation.
543 */
544static void suspend_finish(void)
545{
546	suspend_thaw_processes();
547	pm_notifier_call_chain(PM_POST_SUSPEND);
548	pm_restore_console();
549}
550
551/**
552 * enter_state - Do common work needed to enter system sleep state.
553 * @state: System sleep state to enter.
554 *
555 * Make sure that no one else is trying to put the system into a sleep state.
556 * Fail if that's not the case.  Otherwise, prepare for system suspend, make the
557 * system enter the given sleep state and clean up after wakeup.
558 */
559static int enter_state(suspend_state_t state)
560{
561	int error;
562
563	trace_suspend_resume(TPS("suspend_enter"), state, true);
564	if (state == PM_SUSPEND_TO_IDLE) {
565#ifdef CONFIG_PM_DEBUG
566		if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {
567			pr_warn("Unsupported test mode for suspend to idle, please choose none/freezer/devices/platform.\n");
568			return -EAGAIN;
569		}
570#endif
571	} else if (!valid_state(state)) {
572		return -EINVAL;
573	}
574	if (!mutex_trylock(&system_transition_mutex))
575		return -EBUSY;
576
577	if (state == PM_SUSPEND_TO_IDLE)
578		s2idle_begin();
579
580	if (sync_on_suspend_enabled) {
581		trace_suspend_resume(TPS("sync_filesystems"), 0, true);
582		ksys_sync_helper();
583		trace_suspend_resume(TPS("sync_filesystems"), 0, false);
584	}
 
 
585
586	pm_pr_dbg("Preparing system for sleep (%s)\n", mem_sleep_labels[state]);
587	pm_suspend_clear_flags();
588	error = suspend_prepare(state);
589	if (error)
590		goto Unlock;
591
592	if (suspend_test(TEST_FREEZER))
593		goto Finish;
594
595	trace_suspend_resume(TPS("suspend_enter"), state, false);
596	pm_pr_dbg("Suspending system (%s)\n", mem_sleep_labels[state]);
597	pm_restrict_gfp_mask();
598	error = suspend_devices_and_enter(state);
599	pm_restore_gfp_mask();
600
601 Finish:
602	events_check_enabled = false;
603	pm_pr_dbg("Finishing wakeup.\n");
604	suspend_finish();
605 Unlock:
606	mutex_unlock(&system_transition_mutex);
607	return error;
608}
609
610/**
611 * pm_suspend - Externally visible function for suspending the system.
612 * @state: System sleep state to enter.
613 *
614 * Check if the value of @state represents one of the supported states,
615 * execute enter_state() and update system suspend statistics.
616 */
617int pm_suspend(suspend_state_t state)
618{
619	int error;
620
621	if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX)
622		return -EINVAL;
623
624	pr_info("suspend entry (%s)\n", mem_sleep_labels[state]);
625	error = enter_state(state);
626	dpm_save_errno(error);
627	pr_info("suspend exit\n");
 
 
 
 
628	return error;
629}
630EXPORT_SYMBOL(pm_suspend);