Linux Audio

Check our new training course

Loading...
v5.4
  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * kernel/power/main.c - PM subsystem core functionality.
  4 *
  5 * Copyright (c) 2003 Patrick Mochel
  6 * Copyright (c) 2003 Open Source Development Lab
  7 */
  8
 
  9#include <linux/export.h>
 10#include <linux/kobject.h>
 11#include <linux/string.h>
 12#include <linux/pm-trace.h>
 13#include <linux/workqueue.h>
 14#include <linux/debugfs.h>
 15#include <linux/seq_file.h>
 16#include <linux/suspend.h>
 17#include <linux/syscalls.h>
 18#include <linux/pm_runtime.h>
 19
 20#include "power.h"
 21
 22#ifdef CONFIG_PM_SLEEP
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 23
 24void lock_system_sleep(void)
 25{
 26	current->flags |= PF_FREEZER_SKIP;
 
 27	mutex_lock(&system_transition_mutex);
 
 28}
 29EXPORT_SYMBOL_GPL(lock_system_sleep);
 30
 31void unlock_system_sleep(void)
 32{
 33	/*
 34	 * Don't use freezer_count() because we don't want the call to
 35	 * try_to_freeze() here.
 36	 *
 37	 * Reason:
 38	 * Fundamentally, we just don't need it, because freezing condition
 39	 * doesn't come into effect until we release the
 40	 * system_transition_mutex lock, since the freezer always works with
 41	 * system_transition_mutex held.
 42	 *
 43	 * More importantly, in the case of hibernation,
 44	 * unlock_system_sleep() gets called in snapshot_read() and
 45	 * snapshot_write() when the freezing condition is still in effect.
 46	 * Which means, if we use try_to_freeze() here, it would make them
 47	 * enter the refrigerator, thus causing hibernation to lockup.
 48	 */
 49	current->flags &= ~PF_FREEZER_SKIP;
 50	mutex_unlock(&system_transition_mutex);
 51}
 52EXPORT_SYMBOL_GPL(unlock_system_sleep);
 53
 54void ksys_sync_helper(void)
 55{
 56	ktime_t start;
 57	long elapsed_msecs;
 58
 59	start = ktime_get();
 60	ksys_sync();
 61	elapsed_msecs = ktime_to_ms(ktime_sub(ktime_get(), start));
 62	pr_info("Filesystems sync: %ld.%03ld seconds\n",
 63		elapsed_msecs / MSEC_PER_SEC, elapsed_msecs % MSEC_PER_SEC);
 64}
 65EXPORT_SYMBOL_GPL(ksys_sync_helper);
 66
 67/* Routines for PM-transition notifications */
 68
 69static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
 70
 71int register_pm_notifier(struct notifier_block *nb)
 72{
 73	return blocking_notifier_chain_register(&pm_chain_head, nb);
 74}
 75EXPORT_SYMBOL_GPL(register_pm_notifier);
 76
 77int unregister_pm_notifier(struct notifier_block *nb)
 78{
 79	return blocking_notifier_chain_unregister(&pm_chain_head, nb);
 80}
 81EXPORT_SYMBOL_GPL(unregister_pm_notifier);
 82
 83int __pm_notifier_call_chain(unsigned long val, int nr_to_call, int *nr_calls)
 
 
 
 
 
 
 
 
 
 
 
 
 
 84{
 85	int ret;
 86
 87	ret = __blocking_notifier_call_chain(&pm_chain_head, val, NULL,
 88						nr_to_call, nr_calls);
 89
 90	return notifier_to_errno(ret);
 91}
 
 92int pm_notifier_call_chain(unsigned long val)
 93{
 94	return __pm_notifier_call_chain(val, -1, NULL);
 95}
 96
 97/* If set, devices may be suspended and resumed asynchronously. */
 98int pm_async_enabled = 1;
 99
100static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
101			     char *buf)
102{
103	return sprintf(buf, "%d\n", pm_async_enabled);
104}
105
106static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
107			      const char *buf, size_t n)
108{
109	unsigned long val;
110
111	if (kstrtoul(buf, 10, &val))
112		return -EINVAL;
113
114	if (val > 1)
115		return -EINVAL;
116
117	pm_async_enabled = val;
118	return n;
119}
120
121power_attr(pm_async);
122
123#ifdef CONFIG_SUSPEND
124static ssize_t mem_sleep_show(struct kobject *kobj, struct kobj_attribute *attr,
125			      char *buf)
126{
127	char *s = buf;
128	suspend_state_t i;
129
130	for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
 
 
131		if (mem_sleep_states[i]) {
132			const char *label = mem_sleep_states[i];
133
134			if (mem_sleep_current == i)
135				s += sprintf(s, "[%s] ", label);
136			else
137				s += sprintf(s, "%s ", label);
138		}
 
139
140	/* Convert the last space to a newline if needed. */
141	if (s != buf)
142		*(s-1) = '\n';
143
144	return (s - buf);
145}
146
147static suspend_state_t decode_suspend_state(const char *buf, size_t n)
148{
149	suspend_state_t state;
150	char *p;
151	int len;
152
153	p = memchr(buf, '\n', n);
154	len = p ? p - buf : n;
155
156	for (state = PM_SUSPEND_MIN; state < PM_SUSPEND_MAX; state++) {
157		const char *label = mem_sleep_states[state];
158
159		if (label && len == strlen(label) && !strncmp(buf, label, len))
160			return state;
161	}
162
163	return PM_SUSPEND_ON;
164}
165
166static ssize_t mem_sleep_store(struct kobject *kobj, struct kobj_attribute *attr,
167			       const char *buf, size_t n)
168{
169	suspend_state_t state;
170	int error;
171
172	error = pm_autosleep_lock();
173	if (error)
174		return error;
175
176	if (pm_autosleep_state() > PM_SUSPEND_ON) {
177		error = -EBUSY;
178		goto out;
179	}
180
181	state = decode_suspend_state(buf, n);
182	if (state < PM_SUSPEND_MAX && state > PM_SUSPEND_ON)
183		mem_sleep_current = state;
184	else
185		error = -EINVAL;
186
187 out:
188	pm_autosleep_unlock();
189	return error ? error : n;
190}
191
192power_attr(mem_sleep);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
193#endif /* CONFIG_SUSPEND */
194
195#ifdef CONFIG_PM_SLEEP_DEBUG
196int pm_test_level = TEST_NONE;
197
198static const char * const pm_tests[__TEST_AFTER_LAST] = {
199	[TEST_NONE] = "none",
200	[TEST_CORE] = "core",
201	[TEST_CPUS] = "processors",
202	[TEST_PLATFORM] = "platform",
203	[TEST_DEVICES] = "devices",
204	[TEST_FREEZER] = "freezer",
205};
206
207static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr,
208				char *buf)
209{
210	char *s = buf;
211	int level;
212
213	for (level = TEST_FIRST; level <= TEST_MAX; level++)
214		if (pm_tests[level]) {
215			if (level == pm_test_level)
216				s += sprintf(s, "[%s] ", pm_tests[level]);
217			else
218				s += sprintf(s, "%s ", pm_tests[level]);
219		}
220
221	if (s != buf)
222		/* convert the last space to a newline */
223		*(s-1) = '\n';
224
225	return (s - buf);
226}
227
228static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
229				const char *buf, size_t n)
230{
 
231	const char * const *s;
 
232	int level;
233	char *p;
234	int len;
235	int error = -EINVAL;
236
237	p = memchr(buf, '\n', n);
238	len = p ? p - buf : n;
239
240	lock_system_sleep();
241
242	level = TEST_FIRST;
243	for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
244		if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) {
245			pm_test_level = level;
246			error = 0;
247			break;
248		}
249
250	unlock_system_sleep();
251
252	return error ? error : n;
253}
254
255power_attr(pm_test);
256#endif /* CONFIG_PM_SLEEP_DEBUG */
257
258static char *suspend_step_name(enum suspend_stat_step step)
259{
260	switch (step) {
261	case SUSPEND_FREEZE:
262		return "freeze";
263	case SUSPEND_PREPARE:
264		return "prepare";
265	case SUSPEND_SUSPEND:
266		return "suspend";
267	case SUSPEND_SUSPEND_NOIRQ:
268		return "suspend_noirq";
269	case SUSPEND_RESUME_NOIRQ:
270		return "resume_noirq";
271	case SUSPEND_RESUME:
272		return "resume";
273	default:
274		return "";
275	}
276}
277
278#define suspend_attr(_name)					\
279static ssize_t _name##_show(struct kobject *kobj,		\
280		struct kobj_attribute *attr, char *buf)		\
281{								\
282	return sprintf(buf, "%d\n", suspend_stats._name);	\
283}								\
284static struct kobj_attribute _name = __ATTR_RO(_name)
285
286suspend_attr(success);
287suspend_attr(fail);
288suspend_attr(failed_freeze);
289suspend_attr(failed_prepare);
290suspend_attr(failed_suspend);
291suspend_attr(failed_suspend_late);
292suspend_attr(failed_suspend_noirq);
293suspend_attr(failed_resume);
294suspend_attr(failed_resume_early);
295suspend_attr(failed_resume_noirq);
 
 
 
296
297static ssize_t last_failed_dev_show(struct kobject *kobj,
298		struct kobj_attribute *attr, char *buf)
299{
300	int index;
301	char *last_failed_dev = NULL;
302
303	index = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
304	index %= REC_FAILED_NUM;
305	last_failed_dev = suspend_stats.failed_devs[index];
306
307	return sprintf(buf, "%s\n", last_failed_dev);
308}
309static struct kobj_attribute last_failed_dev = __ATTR_RO(last_failed_dev);
310
311static ssize_t last_failed_errno_show(struct kobject *kobj,
312		struct kobj_attribute *attr, char *buf)
313{
314	int index;
315	int last_failed_errno;
316
317	index = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
318	index %= REC_FAILED_NUM;
319	last_failed_errno = suspend_stats.errno[index];
320
321	return sprintf(buf, "%d\n", last_failed_errno);
322}
323static struct kobj_attribute last_failed_errno = __ATTR_RO(last_failed_errno);
324
325static ssize_t last_failed_step_show(struct kobject *kobj,
326		struct kobj_attribute *attr, char *buf)
327{
328	int index;
329	enum suspend_stat_step step;
330	char *last_failed_step = NULL;
331
332	index = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
333	index %= REC_FAILED_NUM;
334	step = suspend_stats.failed_steps[index];
335	last_failed_step = suspend_step_name(step);
336
337	return sprintf(buf, "%s\n", last_failed_step);
338}
339static struct kobj_attribute last_failed_step = __ATTR_RO(last_failed_step);
340
341static struct attribute *suspend_attrs[] = {
342	&success.attr,
343	&fail.attr,
344	&failed_freeze.attr,
345	&failed_prepare.attr,
346	&failed_suspend.attr,
347	&failed_suspend_late.attr,
348	&failed_suspend_noirq.attr,
349	&failed_resume.attr,
350	&failed_resume_early.attr,
351	&failed_resume_noirq.attr,
352	&last_failed_dev.attr,
353	&last_failed_errno.attr,
354	&last_failed_step.attr,
 
 
 
355	NULL,
356};
357
358static struct attribute_group suspend_attr_group = {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
359	.name = "suspend_stats",
360	.attrs = suspend_attrs,
 
361};
362
363#ifdef CONFIG_DEBUG_FS
364static int suspend_stats_show(struct seq_file *s, void *unused)
365{
366	int i, index, last_dev, last_errno, last_step;
367
368	last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
369	last_dev %= REC_FAILED_NUM;
370	last_errno = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
371	last_errno %= REC_FAILED_NUM;
372	last_step = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
373	last_step %= REC_FAILED_NUM;
374	seq_printf(s, "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n"
375			"%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n",
376			"success", suspend_stats.success,
377			"fail", suspend_stats.fail,
378			"failed_freeze", suspend_stats.failed_freeze,
379			"failed_prepare", suspend_stats.failed_prepare,
380			"failed_suspend", suspend_stats.failed_suspend,
381			"failed_suspend_late",
382				suspend_stats.failed_suspend_late,
383			"failed_suspend_noirq",
384				suspend_stats.failed_suspend_noirq,
385			"failed_resume", suspend_stats.failed_resume,
386			"failed_resume_early",
387				suspend_stats.failed_resume_early,
388			"failed_resume_noirq",
389				suspend_stats.failed_resume_noirq);
390	seq_printf(s,	"failures:\n  last_failed_dev:\t%-s\n",
391			suspend_stats.failed_devs[last_dev]);
392	for (i = 1; i < REC_FAILED_NUM; i++) {
393		index = last_dev + REC_FAILED_NUM - i;
394		index %= REC_FAILED_NUM;
395		seq_printf(s, "\t\t\t%-s\n",
396			suspend_stats.failed_devs[index]);
397	}
398	seq_printf(s,	"  last_failed_errno:\t%-d\n",
399			suspend_stats.errno[last_errno]);
400	for (i = 1; i < REC_FAILED_NUM; i++) {
401		index = last_errno + REC_FAILED_NUM - i;
402		index %= REC_FAILED_NUM;
403		seq_printf(s, "\t\t\t%-d\n",
404			suspend_stats.errno[index]);
405	}
406	seq_printf(s,	"  last_failed_step:\t%-s\n",
407			suspend_step_name(
408				suspend_stats.failed_steps[last_step]));
409	for (i = 1; i < REC_FAILED_NUM; i++) {
410		index = last_step + REC_FAILED_NUM - i;
411		index %= REC_FAILED_NUM;
412		seq_printf(s, "\t\t\t%-s\n",
413			suspend_step_name(
414				suspend_stats.failed_steps[index]));
415	}
416
417	return 0;
418}
419DEFINE_SHOW_ATTRIBUTE(suspend_stats);
420
421static int __init pm_debugfs_init(void)
422{
423	debugfs_create_file("suspend_stats", S_IFREG | S_IRUGO,
424			NULL, NULL, &suspend_stats_fops);
425	return 0;
426}
427
428late_initcall(pm_debugfs_init);
429#endif /* CONFIG_DEBUG_FS */
430
431#endif /* CONFIG_PM_SLEEP */
432
433#ifdef CONFIG_PM_SLEEP_DEBUG
434/*
435 * pm_print_times: print time taken by devices to suspend and resume.
436 *
437 * show() returns whether printing of suspend and resume times is enabled.
438 * store() accepts 0 or 1.  0 disables printing and 1 enables it.
439 */
440bool pm_print_times_enabled;
441
442static ssize_t pm_print_times_show(struct kobject *kobj,
443				   struct kobj_attribute *attr, char *buf)
444{
445	return sprintf(buf, "%d\n", pm_print_times_enabled);
446}
447
448static ssize_t pm_print_times_store(struct kobject *kobj,
449				    struct kobj_attribute *attr,
450				    const char *buf, size_t n)
451{
452	unsigned long val;
453
454	if (kstrtoul(buf, 10, &val))
455		return -EINVAL;
456
457	if (val > 1)
458		return -EINVAL;
459
460	pm_print_times_enabled = !!val;
461	return n;
462}
463
464power_attr(pm_print_times);
465
466static inline void pm_print_times_init(void)
467{
468	pm_print_times_enabled = !!initcall_debug;
469}
470
471static ssize_t pm_wakeup_irq_show(struct kobject *kobj,
472					struct kobj_attribute *attr,
473					char *buf)
474{
475	return pm_wakeup_irq ? sprintf(buf, "%u\n", pm_wakeup_irq) : -ENODATA;
 
 
 
476}
477
478power_attr_ro(pm_wakeup_irq);
479
480bool pm_debug_messages_on __read_mostly;
481
 
 
 
 
 
 
482static ssize_t pm_debug_messages_show(struct kobject *kobj,
483				      struct kobj_attribute *attr, char *buf)
484{
485	return sprintf(buf, "%d\n", pm_debug_messages_on);
486}
487
488static ssize_t pm_debug_messages_store(struct kobject *kobj,
489				       struct kobj_attribute *attr,
490				       const char *buf, size_t n)
491{
492	unsigned long val;
493
494	if (kstrtoul(buf, 10, &val))
495		return -EINVAL;
496
497	if (val > 1)
498		return -EINVAL;
499
500	pm_debug_messages_on = !!val;
501	return n;
502}
503
504power_attr(pm_debug_messages);
505
506/**
507 * __pm_pr_dbg - Print a suspend debug message to the kernel log.
508 * @defer: Whether or not to use printk_deferred() to print the message.
509 * @fmt: Message format.
510 *
511 * The message will be emitted if enabled through the pm_debug_messages
512 * sysfs attribute.
513 */
514void __pm_pr_dbg(bool defer, const char *fmt, ...)
515{
516	struct va_format vaf;
517	va_list args;
518
519	if (!pm_debug_messages_on)
520		return;
521
522	va_start(args, fmt);
523
524	vaf.fmt = fmt;
525	vaf.va = &args;
526
527	if (defer)
528		printk_deferred(KERN_DEBUG "PM: %pV", &vaf);
529	else
530		printk(KERN_DEBUG "PM: %pV", &vaf);
531
532	va_end(args);
533}
 
534
535#else /* !CONFIG_PM_SLEEP_DEBUG */
536static inline void pm_print_times_init(void) {}
537#endif /* CONFIG_PM_SLEEP_DEBUG */
538
539struct kobject *power_kobj;
540
541/**
542 * state - control system sleep states.
543 *
544 * show() returns available sleep state labels, which may be "mem", "standby",
545 * "freeze" and "disk" (hibernation).
546 * See Documentation/admin-guide/pm/sleep-states.rst for a description of
547 * what they mean.
548 *
549 * store() accepts one of those strings, translates it into the proper
550 * enumerated value, and initiates a suspend transition.
551 */
552static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
553			  char *buf)
554{
555	char *s = buf;
556#ifdef CONFIG_SUSPEND
557	suspend_state_t i;
558
559	for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
560		if (pm_states[i])
561			s += sprintf(s,"%s ", pm_states[i]);
562
563#endif
564	if (hibernation_available())
565		s += sprintf(s, "disk ");
566	if (s != buf)
567		/* convert the last space to a newline */
568		*(s-1) = '\n';
569	return (s - buf);
570}
571
572static suspend_state_t decode_state(const char *buf, size_t n)
573{
574#ifdef CONFIG_SUSPEND
575	suspend_state_t state;
576#endif
577	char *p;
578	int len;
579
580	p = memchr(buf, '\n', n);
581	len = p ? p - buf : n;
582
583	/* Check hibernation first. */
584	if (len == 4 && str_has_prefix(buf, "disk"))
585		return PM_SUSPEND_MAX;
586
587#ifdef CONFIG_SUSPEND
588	for (state = PM_SUSPEND_MIN; state < PM_SUSPEND_MAX; state++) {
589		const char *label = pm_states[state];
590
591		if (label && len == strlen(label) && !strncmp(buf, label, len))
592			return state;
593	}
594#endif
595
596	return PM_SUSPEND_ON;
597}
598
599static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
600			   const char *buf, size_t n)
601{
602	suspend_state_t state;
603	int error;
604
605	error = pm_autosleep_lock();
606	if (error)
607		return error;
608
609	if (pm_autosleep_state() > PM_SUSPEND_ON) {
610		error = -EBUSY;
611		goto out;
612	}
613
614	state = decode_state(buf, n);
615	if (state < PM_SUSPEND_MAX) {
616		if (state == PM_SUSPEND_MEM)
617			state = mem_sleep_current;
618
619		error = pm_suspend(state);
620	} else if (state == PM_SUSPEND_MAX) {
621		error = hibernate();
622	} else {
623		error = -EINVAL;
624	}
625
626 out:
627	pm_autosleep_unlock();
628	return error ? error : n;
629}
630
631power_attr(state);
632
633#ifdef CONFIG_PM_SLEEP
634/*
635 * The 'wakeup_count' attribute, along with the functions defined in
636 * drivers/base/power/wakeup.c, provides a means by which wakeup events can be
637 * handled in a non-racy way.
638 *
639 * If a wakeup event occurs when the system is in a sleep state, it simply is
640 * woken up.  In turn, if an event that would wake the system up from a sleep
641 * state occurs when it is undergoing a transition to that sleep state, the
642 * transition should be aborted.  Moreover, if such an event occurs when the
643 * system is in the working state, an attempt to start a transition to the
644 * given sleep state should fail during certain period after the detection of
645 * the event.  Using the 'state' attribute alone is not sufficient to satisfy
646 * these requirements, because a wakeup event may occur exactly when 'state'
647 * is being written to and may be delivered to user space right before it is
648 * frozen, so the event will remain only partially processed until the system is
649 * woken up by another event.  In particular, it won't cause the transition to
650 * a sleep state to be aborted.
651 *
652 * This difficulty may be overcome if user space uses 'wakeup_count' before
653 * writing to 'state'.  It first should read from 'wakeup_count' and store
654 * the read value.  Then, after carrying out its own preparations for the system
655 * transition to a sleep state, it should write the stored value to
656 * 'wakeup_count'.  If that fails, at least one wakeup event has occurred since
657 * 'wakeup_count' was read and 'state' should not be written to.  Otherwise, it
658 * is allowed to write to 'state', but the transition will be aborted if there
659 * are any wakeup events detected after 'wakeup_count' was written to.
660 */
661
662static ssize_t wakeup_count_show(struct kobject *kobj,
663				struct kobj_attribute *attr,
664				char *buf)
665{
666	unsigned int val;
667
668	return pm_get_wakeup_count(&val, true) ?
669		sprintf(buf, "%u\n", val) : -EINTR;
670}
671
672static ssize_t wakeup_count_store(struct kobject *kobj,
673				struct kobj_attribute *attr,
674				const char *buf, size_t n)
675{
676	unsigned int val;
677	int error;
678
679	error = pm_autosleep_lock();
680	if (error)
681		return error;
682
683	if (pm_autosleep_state() > PM_SUSPEND_ON) {
684		error = -EBUSY;
685		goto out;
686	}
687
688	error = -EINVAL;
689	if (sscanf(buf, "%u", &val) == 1) {
690		if (pm_save_wakeup_count(val))
691			error = n;
692		else
693			pm_print_active_wakeup_sources();
694	}
695
696 out:
697	pm_autosleep_unlock();
698	return error;
699}
700
701power_attr(wakeup_count);
702
703#ifdef CONFIG_PM_AUTOSLEEP
704static ssize_t autosleep_show(struct kobject *kobj,
705			      struct kobj_attribute *attr,
706			      char *buf)
707{
708	suspend_state_t state = pm_autosleep_state();
709
710	if (state == PM_SUSPEND_ON)
711		return sprintf(buf, "off\n");
712
713#ifdef CONFIG_SUSPEND
714	if (state < PM_SUSPEND_MAX)
715		return sprintf(buf, "%s\n", pm_states[state] ?
716					pm_states[state] : "error");
717#endif
718#ifdef CONFIG_HIBERNATION
719	return sprintf(buf, "disk\n");
720#else
721	return sprintf(buf, "error");
722#endif
723}
724
725static ssize_t autosleep_store(struct kobject *kobj,
726			       struct kobj_attribute *attr,
727			       const char *buf, size_t n)
728{
729	suspend_state_t state = decode_state(buf, n);
730	int error;
731
732	if (state == PM_SUSPEND_ON
733	    && strcmp(buf, "off") && strcmp(buf, "off\n"))
734		return -EINVAL;
735
736	if (state == PM_SUSPEND_MEM)
737		state = mem_sleep_current;
738
739	error = pm_autosleep_set_state(state);
740	return error ? error : n;
741}
742
743power_attr(autosleep);
744#endif /* CONFIG_PM_AUTOSLEEP */
745
746#ifdef CONFIG_PM_WAKELOCKS
747static ssize_t wake_lock_show(struct kobject *kobj,
748			      struct kobj_attribute *attr,
749			      char *buf)
750{
751	return pm_show_wakelocks(buf, true);
752}
753
754static ssize_t wake_lock_store(struct kobject *kobj,
755			       struct kobj_attribute *attr,
756			       const char *buf, size_t n)
757{
758	int error = pm_wake_lock(buf);
759	return error ? error : n;
760}
761
762power_attr(wake_lock);
763
764static ssize_t wake_unlock_show(struct kobject *kobj,
765				struct kobj_attribute *attr,
766				char *buf)
767{
768	return pm_show_wakelocks(buf, false);
769}
770
771static ssize_t wake_unlock_store(struct kobject *kobj,
772				 struct kobj_attribute *attr,
773				 const char *buf, size_t n)
774{
775	int error = pm_wake_unlock(buf);
776	return error ? error : n;
777}
778
779power_attr(wake_unlock);
780
781#endif /* CONFIG_PM_WAKELOCKS */
782#endif /* CONFIG_PM_SLEEP */
783
784#ifdef CONFIG_PM_TRACE
785int pm_trace_enabled;
786
787static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
788			     char *buf)
789{
790	return sprintf(buf, "%d\n", pm_trace_enabled);
791}
792
793static ssize_t
794pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
795	       const char *buf, size_t n)
796{
797	int val;
798
799	if (sscanf(buf, "%d", &val) == 1) {
800		pm_trace_enabled = !!val;
801		if (pm_trace_enabled) {
802			pr_warn("PM: Enabling pm_trace changes system date and time during resume.\n"
803				"PM: Correct system time has to be restored manually after resume.\n");
804		}
805		return n;
806	}
807	return -EINVAL;
808}
809
810power_attr(pm_trace);
811
812static ssize_t pm_trace_dev_match_show(struct kobject *kobj,
813				       struct kobj_attribute *attr,
814				       char *buf)
815{
816	return show_trace_dev_match(buf, PAGE_SIZE);
817}
818
819power_attr_ro(pm_trace_dev_match);
820
821#endif /* CONFIG_PM_TRACE */
822
823#ifdef CONFIG_FREEZER
824static ssize_t pm_freeze_timeout_show(struct kobject *kobj,
825				      struct kobj_attribute *attr, char *buf)
826{
827	return sprintf(buf, "%u\n", freeze_timeout_msecs);
828}
829
830static ssize_t pm_freeze_timeout_store(struct kobject *kobj,
831				       struct kobj_attribute *attr,
832				       const char *buf, size_t n)
833{
834	unsigned long val;
835
836	if (kstrtoul(buf, 10, &val))
837		return -EINVAL;
838
839	freeze_timeout_msecs = val;
840	return n;
841}
842
843power_attr(pm_freeze_timeout);
844
845#endif	/* CONFIG_FREEZER*/
846
847static struct attribute * g[] = {
848	&state_attr.attr,
849#ifdef CONFIG_PM_TRACE
850	&pm_trace_attr.attr,
851	&pm_trace_dev_match_attr.attr,
852#endif
853#ifdef CONFIG_PM_SLEEP
854	&pm_async_attr.attr,
855	&wakeup_count_attr.attr,
856#ifdef CONFIG_SUSPEND
857	&mem_sleep_attr.attr,
 
858#endif
859#ifdef CONFIG_PM_AUTOSLEEP
860	&autosleep_attr.attr,
861#endif
862#ifdef CONFIG_PM_WAKELOCKS
863	&wake_lock_attr.attr,
864	&wake_unlock_attr.attr,
865#endif
866#ifdef CONFIG_PM_SLEEP_DEBUG
867	&pm_test_attr.attr,
868	&pm_print_times_attr.attr,
869	&pm_wakeup_irq_attr.attr,
870	&pm_debug_messages_attr.attr,
871#endif
872#endif
873#ifdef CONFIG_FREEZER
874	&pm_freeze_timeout_attr.attr,
875#endif
876	NULL,
877};
878
879static const struct attribute_group attr_group = {
880	.attrs = g,
881};
882
883static const struct attribute_group *attr_groups[] = {
884	&attr_group,
885#ifdef CONFIG_PM_SLEEP
886	&suspend_attr_group,
887#endif
888	NULL,
889};
890
891struct workqueue_struct *pm_wq;
892EXPORT_SYMBOL_GPL(pm_wq);
893
894static int __init pm_start_workqueue(void)
895{
896	pm_wq = alloc_workqueue("pm", WQ_FREEZABLE, 0);
897
898	return pm_wq ? 0 : -ENOMEM;
899}
900
901static int __init pm_init(void)
902{
903	int error = pm_start_workqueue();
904	if (error)
905		return error;
906	hibernate_image_size_init();
907	hibernate_reserved_size_init();
908	pm_states_init();
909	power_kobj = kobject_create_and_add("power", NULL);
910	if (!power_kobj)
911		return -ENOMEM;
912	error = sysfs_create_groups(power_kobj, attr_groups);
913	if (error)
914		return error;
915	pm_print_times_init();
916	return pm_autosleep_init();
917}
918
919core_initcall(pm_init);
v6.8
  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * kernel/power/main.c - PM subsystem core functionality.
  4 *
  5 * Copyright (c) 2003 Patrick Mochel
  6 * Copyright (c) 2003 Open Source Development Lab
  7 */
  8
  9#include <linux/acpi.h>
 10#include <linux/export.h>
 11#include <linux/kobject.h>
 12#include <linux/string.h>
 13#include <linux/pm-trace.h>
 14#include <linux/workqueue.h>
 15#include <linux/debugfs.h>
 16#include <linux/seq_file.h>
 17#include <linux/suspend.h>
 18#include <linux/syscalls.h>
 19#include <linux/pm_runtime.h>
 20
 21#include "power.h"
 22
 23#ifdef CONFIG_PM_SLEEP
 24/*
 25 * The following functions are used by the suspend/hibernate code to temporarily
 26 * change gfp_allowed_mask in order to avoid using I/O during memory allocations
 27 * while devices are suspended.  To avoid races with the suspend/hibernate code,
 28 * they should always be called with system_transition_mutex held
 29 * (gfp_allowed_mask also should only be modified with system_transition_mutex
 30 * held, unless the suspend/hibernate code is guaranteed not to run in parallel
 31 * with that modification).
 32 */
 33static gfp_t saved_gfp_mask;
 34
 35void pm_restore_gfp_mask(void)
 36{
 37	WARN_ON(!mutex_is_locked(&system_transition_mutex));
 38	if (saved_gfp_mask) {
 39		gfp_allowed_mask = saved_gfp_mask;
 40		saved_gfp_mask = 0;
 41	}
 42}
 43
 44void pm_restrict_gfp_mask(void)
 45{
 46	WARN_ON(!mutex_is_locked(&system_transition_mutex));
 47	WARN_ON(saved_gfp_mask);
 48	saved_gfp_mask = gfp_allowed_mask;
 49	gfp_allowed_mask &= ~(__GFP_IO | __GFP_FS);
 50}
 51
 52unsigned int lock_system_sleep(void)
 53{
 54	unsigned int flags = current->flags;
 55	current->flags |= PF_NOFREEZE;
 56	mutex_lock(&system_transition_mutex);
 57	return flags;
 58}
 59EXPORT_SYMBOL_GPL(lock_system_sleep);
 60
 61void unlock_system_sleep(unsigned int flags)
 62{
 63	if (!(flags & PF_NOFREEZE))
 64		current->flags &= ~PF_NOFREEZE;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 65	mutex_unlock(&system_transition_mutex);
 66}
 67EXPORT_SYMBOL_GPL(unlock_system_sleep);
 68
 69void ksys_sync_helper(void)
 70{
 71	ktime_t start;
 72	long elapsed_msecs;
 73
 74	start = ktime_get();
 75	ksys_sync();
 76	elapsed_msecs = ktime_to_ms(ktime_sub(ktime_get(), start));
 77	pr_info("Filesystems sync: %ld.%03ld seconds\n",
 78		elapsed_msecs / MSEC_PER_SEC, elapsed_msecs % MSEC_PER_SEC);
 79}
 80EXPORT_SYMBOL_GPL(ksys_sync_helper);
 81
 82/* Routines for PM-transition notifications */
 83
 84static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
 85
 86int register_pm_notifier(struct notifier_block *nb)
 87{
 88	return blocking_notifier_chain_register(&pm_chain_head, nb);
 89}
 90EXPORT_SYMBOL_GPL(register_pm_notifier);
 91
 92int unregister_pm_notifier(struct notifier_block *nb)
 93{
 94	return blocking_notifier_chain_unregister(&pm_chain_head, nb);
 95}
 96EXPORT_SYMBOL_GPL(unregister_pm_notifier);
 97
 98void pm_report_hw_sleep_time(u64 t)
 99{
100	suspend_stats.last_hw_sleep = t;
101	suspend_stats.total_hw_sleep += t;
102}
103EXPORT_SYMBOL_GPL(pm_report_hw_sleep_time);
104
105void pm_report_max_hw_sleep(u64 t)
106{
107	suspend_stats.max_hw_sleep = t;
108}
109EXPORT_SYMBOL_GPL(pm_report_max_hw_sleep);
110
111int pm_notifier_call_chain_robust(unsigned long val_up, unsigned long val_down)
112{
113	int ret;
114
115	ret = blocking_notifier_call_chain_robust(&pm_chain_head, val_up, val_down, NULL);
 
116
117	return notifier_to_errno(ret);
118}
119
120int pm_notifier_call_chain(unsigned long val)
121{
122	return blocking_notifier_call_chain(&pm_chain_head, val, NULL);
123}
124
125/* If set, devices may be suspended and resumed asynchronously. */
126int pm_async_enabled = 1;
127
128static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
129			     char *buf)
130{
131	return sprintf(buf, "%d\n", pm_async_enabled);
132}
133
134static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
135			      const char *buf, size_t n)
136{
137	unsigned long val;
138
139	if (kstrtoul(buf, 10, &val))
140		return -EINVAL;
141
142	if (val > 1)
143		return -EINVAL;
144
145	pm_async_enabled = val;
146	return n;
147}
148
149power_attr(pm_async);
150
151#ifdef CONFIG_SUSPEND
152static ssize_t mem_sleep_show(struct kobject *kobj, struct kobj_attribute *attr,
153			      char *buf)
154{
155	char *s = buf;
156	suspend_state_t i;
157
158	for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++) {
159		if (i >= PM_SUSPEND_MEM && cxl_mem_active())
160			continue;
161		if (mem_sleep_states[i]) {
162			const char *label = mem_sleep_states[i];
163
164			if (mem_sleep_current == i)
165				s += sprintf(s, "[%s] ", label);
166			else
167				s += sprintf(s, "%s ", label);
168		}
169	}
170
171	/* Convert the last space to a newline if needed. */
172	if (s != buf)
173		*(s-1) = '\n';
174
175	return (s - buf);
176}
177
178static suspend_state_t decode_suspend_state(const char *buf, size_t n)
179{
180	suspend_state_t state;
181	char *p;
182	int len;
183
184	p = memchr(buf, '\n', n);
185	len = p ? p - buf : n;
186
187	for (state = PM_SUSPEND_MIN; state < PM_SUSPEND_MAX; state++) {
188		const char *label = mem_sleep_states[state];
189
190		if (label && len == strlen(label) && !strncmp(buf, label, len))
191			return state;
192	}
193
194	return PM_SUSPEND_ON;
195}
196
197static ssize_t mem_sleep_store(struct kobject *kobj, struct kobj_attribute *attr,
198			       const char *buf, size_t n)
199{
200	suspend_state_t state;
201	int error;
202
203	error = pm_autosleep_lock();
204	if (error)
205		return error;
206
207	if (pm_autosleep_state() > PM_SUSPEND_ON) {
208		error = -EBUSY;
209		goto out;
210	}
211
212	state = decode_suspend_state(buf, n);
213	if (state < PM_SUSPEND_MAX && state > PM_SUSPEND_ON)
214		mem_sleep_current = state;
215	else
216		error = -EINVAL;
217
218 out:
219	pm_autosleep_unlock();
220	return error ? error : n;
221}
222
223power_attr(mem_sleep);
224
225/*
226 * sync_on_suspend: invoke ksys_sync_helper() before suspend.
227 *
228 * show() returns whether ksys_sync_helper() is invoked before suspend.
229 * store() accepts 0 or 1.  0 disables ksys_sync_helper() and 1 enables it.
230 */
231bool sync_on_suspend_enabled = !IS_ENABLED(CONFIG_SUSPEND_SKIP_SYNC);
232
233static ssize_t sync_on_suspend_show(struct kobject *kobj,
234				   struct kobj_attribute *attr, char *buf)
235{
236	return sprintf(buf, "%d\n", sync_on_suspend_enabled);
237}
238
239static ssize_t sync_on_suspend_store(struct kobject *kobj,
240				    struct kobj_attribute *attr,
241				    const char *buf, size_t n)
242{
243	unsigned long val;
244
245	if (kstrtoul(buf, 10, &val))
246		return -EINVAL;
247
248	if (val > 1)
249		return -EINVAL;
250
251	sync_on_suspend_enabled = !!val;
252	return n;
253}
254
255power_attr(sync_on_suspend);
256#endif /* CONFIG_SUSPEND */
257
258#ifdef CONFIG_PM_SLEEP_DEBUG
259int pm_test_level = TEST_NONE;
260
261static const char * const pm_tests[__TEST_AFTER_LAST] = {
262	[TEST_NONE] = "none",
263	[TEST_CORE] = "core",
264	[TEST_CPUS] = "processors",
265	[TEST_PLATFORM] = "platform",
266	[TEST_DEVICES] = "devices",
267	[TEST_FREEZER] = "freezer",
268};
269
270static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr,
271				char *buf)
272{
273	char *s = buf;
274	int level;
275
276	for (level = TEST_FIRST; level <= TEST_MAX; level++)
277		if (pm_tests[level]) {
278			if (level == pm_test_level)
279				s += sprintf(s, "[%s] ", pm_tests[level]);
280			else
281				s += sprintf(s, "%s ", pm_tests[level]);
282		}
283
284	if (s != buf)
285		/* convert the last space to a newline */
286		*(s-1) = '\n';
287
288	return (s - buf);
289}
290
291static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
292				const char *buf, size_t n)
293{
294	unsigned int sleep_flags;
295	const char * const *s;
296	int error = -EINVAL;
297	int level;
298	char *p;
299	int len;
 
300
301	p = memchr(buf, '\n', n);
302	len = p ? p - buf : n;
303
304	sleep_flags = lock_system_sleep();
305
306	level = TEST_FIRST;
307	for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
308		if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) {
309			pm_test_level = level;
310			error = 0;
311			break;
312		}
313
314	unlock_system_sleep(sleep_flags);
315
316	return error ? error : n;
317}
318
319power_attr(pm_test);
320#endif /* CONFIG_PM_SLEEP_DEBUG */
321
322static char *suspend_step_name(enum suspend_stat_step step)
323{
324	switch (step) {
325	case SUSPEND_FREEZE:
326		return "freeze";
327	case SUSPEND_PREPARE:
328		return "prepare";
329	case SUSPEND_SUSPEND:
330		return "suspend";
331	case SUSPEND_SUSPEND_NOIRQ:
332		return "suspend_noirq";
333	case SUSPEND_RESUME_NOIRQ:
334		return "resume_noirq";
335	case SUSPEND_RESUME:
336		return "resume";
337	default:
338		return "";
339	}
340}
341
342#define suspend_attr(_name, format_str)				\
343static ssize_t _name##_show(struct kobject *kobj,		\
344		struct kobj_attribute *attr, char *buf)		\
345{								\
346	return sprintf(buf, format_str, suspend_stats._name);	\
347}								\
348static struct kobj_attribute _name = __ATTR_RO(_name)
349
350suspend_attr(success, "%d\n");
351suspend_attr(fail, "%d\n");
352suspend_attr(failed_freeze, "%d\n");
353suspend_attr(failed_prepare, "%d\n");
354suspend_attr(failed_suspend, "%d\n");
355suspend_attr(failed_suspend_late, "%d\n");
356suspend_attr(failed_suspend_noirq, "%d\n");
357suspend_attr(failed_resume, "%d\n");
358suspend_attr(failed_resume_early, "%d\n");
359suspend_attr(failed_resume_noirq, "%d\n");
360suspend_attr(last_hw_sleep, "%llu\n");
361suspend_attr(total_hw_sleep, "%llu\n");
362suspend_attr(max_hw_sleep, "%llu\n");
363
364static ssize_t last_failed_dev_show(struct kobject *kobj,
365		struct kobj_attribute *attr, char *buf)
366{
367	int index;
368	char *last_failed_dev = NULL;
369
370	index = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
371	index %= REC_FAILED_NUM;
372	last_failed_dev = suspend_stats.failed_devs[index];
373
374	return sprintf(buf, "%s\n", last_failed_dev);
375}
376static struct kobj_attribute last_failed_dev = __ATTR_RO(last_failed_dev);
377
378static ssize_t last_failed_errno_show(struct kobject *kobj,
379		struct kobj_attribute *attr, char *buf)
380{
381	int index;
382	int last_failed_errno;
383
384	index = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
385	index %= REC_FAILED_NUM;
386	last_failed_errno = suspend_stats.errno[index];
387
388	return sprintf(buf, "%d\n", last_failed_errno);
389}
390static struct kobj_attribute last_failed_errno = __ATTR_RO(last_failed_errno);
391
392static ssize_t last_failed_step_show(struct kobject *kobj,
393		struct kobj_attribute *attr, char *buf)
394{
395	int index;
396	enum suspend_stat_step step;
397	char *last_failed_step = NULL;
398
399	index = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
400	index %= REC_FAILED_NUM;
401	step = suspend_stats.failed_steps[index];
402	last_failed_step = suspend_step_name(step);
403
404	return sprintf(buf, "%s\n", last_failed_step);
405}
406static struct kobj_attribute last_failed_step = __ATTR_RO(last_failed_step);
407
408static struct attribute *suspend_attrs[] = {
409	&success.attr,
410	&fail.attr,
411	&failed_freeze.attr,
412	&failed_prepare.attr,
413	&failed_suspend.attr,
414	&failed_suspend_late.attr,
415	&failed_suspend_noirq.attr,
416	&failed_resume.attr,
417	&failed_resume_early.attr,
418	&failed_resume_noirq.attr,
419	&last_failed_dev.attr,
420	&last_failed_errno.attr,
421	&last_failed_step.attr,
422	&last_hw_sleep.attr,
423	&total_hw_sleep.attr,
424	&max_hw_sleep.attr,
425	NULL,
426};
427
428static umode_t suspend_attr_is_visible(struct kobject *kobj, struct attribute *attr, int idx)
429{
430	if (attr != &last_hw_sleep.attr &&
431	    attr != &total_hw_sleep.attr &&
432	    attr != &max_hw_sleep.attr)
433		return 0444;
434
435#ifdef CONFIG_ACPI
436	if (acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0)
437		return 0444;
438#endif
439	return 0;
440}
441
442static const struct attribute_group suspend_attr_group = {
443	.name = "suspend_stats",
444	.attrs = suspend_attrs,
445	.is_visible = suspend_attr_is_visible,
446};
447
448#ifdef CONFIG_DEBUG_FS
449static int suspend_stats_show(struct seq_file *s, void *unused)
450{
451	int i, index, last_dev, last_errno, last_step;
452
453	last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
454	last_dev %= REC_FAILED_NUM;
455	last_errno = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
456	last_errno %= REC_FAILED_NUM;
457	last_step = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
458	last_step %= REC_FAILED_NUM;
459	seq_printf(s, "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n"
460			"%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n",
461			"success", suspend_stats.success,
462			"fail", suspend_stats.fail,
463			"failed_freeze", suspend_stats.failed_freeze,
464			"failed_prepare", suspend_stats.failed_prepare,
465			"failed_suspend", suspend_stats.failed_suspend,
466			"failed_suspend_late",
467				suspend_stats.failed_suspend_late,
468			"failed_suspend_noirq",
469				suspend_stats.failed_suspend_noirq,
470			"failed_resume", suspend_stats.failed_resume,
471			"failed_resume_early",
472				suspend_stats.failed_resume_early,
473			"failed_resume_noirq",
474				suspend_stats.failed_resume_noirq);
475	seq_printf(s,	"failures:\n  last_failed_dev:\t%-s\n",
476			suspend_stats.failed_devs[last_dev]);
477	for (i = 1; i < REC_FAILED_NUM; i++) {
478		index = last_dev + REC_FAILED_NUM - i;
479		index %= REC_FAILED_NUM;
480		seq_printf(s, "\t\t\t%-s\n",
481			suspend_stats.failed_devs[index]);
482	}
483	seq_printf(s,	"  last_failed_errno:\t%-d\n",
484			suspend_stats.errno[last_errno]);
485	for (i = 1; i < REC_FAILED_NUM; i++) {
486		index = last_errno + REC_FAILED_NUM - i;
487		index %= REC_FAILED_NUM;
488		seq_printf(s, "\t\t\t%-d\n",
489			suspend_stats.errno[index]);
490	}
491	seq_printf(s,	"  last_failed_step:\t%-s\n",
492			suspend_step_name(
493				suspend_stats.failed_steps[last_step]));
494	for (i = 1; i < REC_FAILED_NUM; i++) {
495		index = last_step + REC_FAILED_NUM - i;
496		index %= REC_FAILED_NUM;
497		seq_printf(s, "\t\t\t%-s\n",
498			suspend_step_name(
499				suspend_stats.failed_steps[index]));
500	}
501
502	return 0;
503}
504DEFINE_SHOW_ATTRIBUTE(suspend_stats);
505
506static int __init pm_debugfs_init(void)
507{
508	debugfs_create_file("suspend_stats", S_IFREG | S_IRUGO,
509			NULL, NULL, &suspend_stats_fops);
510	return 0;
511}
512
513late_initcall(pm_debugfs_init);
514#endif /* CONFIG_DEBUG_FS */
515
516#endif /* CONFIG_PM_SLEEP */
517
518#ifdef CONFIG_PM_SLEEP_DEBUG
519/*
520 * pm_print_times: print time taken by devices to suspend and resume.
521 *
522 * show() returns whether printing of suspend and resume times is enabled.
523 * store() accepts 0 or 1.  0 disables printing and 1 enables it.
524 */
525bool pm_print_times_enabled;
526
527static ssize_t pm_print_times_show(struct kobject *kobj,
528				   struct kobj_attribute *attr, char *buf)
529{
530	return sprintf(buf, "%d\n", pm_print_times_enabled);
531}
532
533static ssize_t pm_print_times_store(struct kobject *kobj,
534				    struct kobj_attribute *attr,
535				    const char *buf, size_t n)
536{
537	unsigned long val;
538
539	if (kstrtoul(buf, 10, &val))
540		return -EINVAL;
541
542	if (val > 1)
543		return -EINVAL;
544
545	pm_print_times_enabled = !!val;
546	return n;
547}
548
549power_attr(pm_print_times);
550
551static inline void pm_print_times_init(void)
552{
553	pm_print_times_enabled = !!initcall_debug;
554}
555
556static ssize_t pm_wakeup_irq_show(struct kobject *kobj,
557					struct kobj_attribute *attr,
558					char *buf)
559{
560	if (!pm_wakeup_irq())
561		return -ENODATA;
562
563	return sprintf(buf, "%u\n", pm_wakeup_irq());
564}
565
566power_attr_ro(pm_wakeup_irq);
567
568bool pm_debug_messages_on __read_mostly;
569
570bool pm_debug_messages_should_print(void)
571{
572	return pm_debug_messages_on && pm_suspend_target_state != PM_SUSPEND_ON;
573}
574EXPORT_SYMBOL_GPL(pm_debug_messages_should_print);
575
576static ssize_t pm_debug_messages_show(struct kobject *kobj,
577				      struct kobj_attribute *attr, char *buf)
578{
579	return sprintf(buf, "%d\n", pm_debug_messages_on);
580}
581
582static ssize_t pm_debug_messages_store(struct kobject *kobj,
583				       struct kobj_attribute *attr,
584				       const char *buf, size_t n)
585{
586	unsigned long val;
587
588	if (kstrtoul(buf, 10, &val))
589		return -EINVAL;
590
591	if (val > 1)
592		return -EINVAL;
593
594	pm_debug_messages_on = !!val;
595	return n;
596}
597
598power_attr(pm_debug_messages);
599
600static int __init pm_debug_messages_setup(char *str)
 
 
 
 
 
 
 
 
601{
602	pm_debug_messages_on = true;
603	return 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
604}
605__setup("pm_debug_messages", pm_debug_messages_setup);
606
607#else /* !CONFIG_PM_SLEEP_DEBUG */
608static inline void pm_print_times_init(void) {}
609#endif /* CONFIG_PM_SLEEP_DEBUG */
610
611struct kobject *power_kobj;
612
613/*
614 * state - control system sleep states.
615 *
616 * show() returns available sleep state labels, which may be "mem", "standby",
617 * "freeze" and "disk" (hibernation).
618 * See Documentation/admin-guide/pm/sleep-states.rst for a description of
619 * what they mean.
620 *
621 * store() accepts one of those strings, translates it into the proper
622 * enumerated value, and initiates a suspend transition.
623 */
624static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
625			  char *buf)
626{
627	char *s = buf;
628#ifdef CONFIG_SUSPEND
629	suspend_state_t i;
630
631	for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
632		if (pm_states[i])
633			s += sprintf(s,"%s ", pm_states[i]);
634
635#endif
636	if (hibernation_available())
637		s += sprintf(s, "disk ");
638	if (s != buf)
639		/* convert the last space to a newline */
640		*(s-1) = '\n';
641	return (s - buf);
642}
643
644static suspend_state_t decode_state(const char *buf, size_t n)
645{
646#ifdef CONFIG_SUSPEND
647	suspend_state_t state;
648#endif
649	char *p;
650	int len;
651
652	p = memchr(buf, '\n', n);
653	len = p ? p - buf : n;
654
655	/* Check hibernation first. */
656	if (len == 4 && str_has_prefix(buf, "disk"))
657		return PM_SUSPEND_MAX;
658
659#ifdef CONFIG_SUSPEND
660	for (state = PM_SUSPEND_MIN; state < PM_SUSPEND_MAX; state++) {
661		const char *label = pm_states[state];
662
663		if (label && len == strlen(label) && !strncmp(buf, label, len))
664			return state;
665	}
666#endif
667
668	return PM_SUSPEND_ON;
669}
670
671static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
672			   const char *buf, size_t n)
673{
674	suspend_state_t state;
675	int error;
676
677	error = pm_autosleep_lock();
678	if (error)
679		return error;
680
681	if (pm_autosleep_state() > PM_SUSPEND_ON) {
682		error = -EBUSY;
683		goto out;
684	}
685
686	state = decode_state(buf, n);
687	if (state < PM_SUSPEND_MAX) {
688		if (state == PM_SUSPEND_MEM)
689			state = mem_sleep_current;
690
691		error = pm_suspend(state);
692	} else if (state == PM_SUSPEND_MAX) {
693		error = hibernate();
694	} else {
695		error = -EINVAL;
696	}
697
698 out:
699	pm_autosleep_unlock();
700	return error ? error : n;
701}
702
703power_attr(state);
704
705#ifdef CONFIG_PM_SLEEP
706/*
707 * The 'wakeup_count' attribute, along with the functions defined in
708 * drivers/base/power/wakeup.c, provides a means by which wakeup events can be
709 * handled in a non-racy way.
710 *
711 * If a wakeup event occurs when the system is in a sleep state, it simply is
712 * woken up.  In turn, if an event that would wake the system up from a sleep
713 * state occurs when it is undergoing a transition to that sleep state, the
714 * transition should be aborted.  Moreover, if such an event occurs when the
715 * system is in the working state, an attempt to start a transition to the
716 * given sleep state should fail during certain period after the detection of
717 * the event.  Using the 'state' attribute alone is not sufficient to satisfy
718 * these requirements, because a wakeup event may occur exactly when 'state'
719 * is being written to and may be delivered to user space right before it is
720 * frozen, so the event will remain only partially processed until the system is
721 * woken up by another event.  In particular, it won't cause the transition to
722 * a sleep state to be aborted.
723 *
724 * This difficulty may be overcome if user space uses 'wakeup_count' before
725 * writing to 'state'.  It first should read from 'wakeup_count' and store
726 * the read value.  Then, after carrying out its own preparations for the system
727 * transition to a sleep state, it should write the stored value to
728 * 'wakeup_count'.  If that fails, at least one wakeup event has occurred since
729 * 'wakeup_count' was read and 'state' should not be written to.  Otherwise, it
730 * is allowed to write to 'state', but the transition will be aborted if there
731 * are any wakeup events detected after 'wakeup_count' was written to.
732 */
733
734static ssize_t wakeup_count_show(struct kobject *kobj,
735				struct kobj_attribute *attr,
736				char *buf)
737{
738	unsigned int val;
739
740	return pm_get_wakeup_count(&val, true) ?
741		sprintf(buf, "%u\n", val) : -EINTR;
742}
743
744static ssize_t wakeup_count_store(struct kobject *kobj,
745				struct kobj_attribute *attr,
746				const char *buf, size_t n)
747{
748	unsigned int val;
749	int error;
750
751	error = pm_autosleep_lock();
752	if (error)
753		return error;
754
755	if (pm_autosleep_state() > PM_SUSPEND_ON) {
756		error = -EBUSY;
757		goto out;
758	}
759
760	error = -EINVAL;
761	if (sscanf(buf, "%u", &val) == 1) {
762		if (pm_save_wakeup_count(val))
763			error = n;
764		else
765			pm_print_active_wakeup_sources();
766	}
767
768 out:
769	pm_autosleep_unlock();
770	return error;
771}
772
773power_attr(wakeup_count);
774
775#ifdef CONFIG_PM_AUTOSLEEP
776static ssize_t autosleep_show(struct kobject *kobj,
777			      struct kobj_attribute *attr,
778			      char *buf)
779{
780	suspend_state_t state = pm_autosleep_state();
781
782	if (state == PM_SUSPEND_ON)
783		return sprintf(buf, "off\n");
784
785#ifdef CONFIG_SUSPEND
786	if (state < PM_SUSPEND_MAX)
787		return sprintf(buf, "%s\n", pm_states[state] ?
788					pm_states[state] : "error");
789#endif
790#ifdef CONFIG_HIBERNATION
791	return sprintf(buf, "disk\n");
792#else
793	return sprintf(buf, "error");
794#endif
795}
796
797static ssize_t autosleep_store(struct kobject *kobj,
798			       struct kobj_attribute *attr,
799			       const char *buf, size_t n)
800{
801	suspend_state_t state = decode_state(buf, n);
802	int error;
803
804	if (state == PM_SUSPEND_ON
805	    && strcmp(buf, "off") && strcmp(buf, "off\n"))
806		return -EINVAL;
807
808	if (state == PM_SUSPEND_MEM)
809		state = mem_sleep_current;
810
811	error = pm_autosleep_set_state(state);
812	return error ? error : n;
813}
814
815power_attr(autosleep);
816#endif /* CONFIG_PM_AUTOSLEEP */
817
818#ifdef CONFIG_PM_WAKELOCKS
819static ssize_t wake_lock_show(struct kobject *kobj,
820			      struct kobj_attribute *attr,
821			      char *buf)
822{
823	return pm_show_wakelocks(buf, true);
824}
825
826static ssize_t wake_lock_store(struct kobject *kobj,
827			       struct kobj_attribute *attr,
828			       const char *buf, size_t n)
829{
830	int error = pm_wake_lock(buf);
831	return error ? error : n;
832}
833
834power_attr(wake_lock);
835
836static ssize_t wake_unlock_show(struct kobject *kobj,
837				struct kobj_attribute *attr,
838				char *buf)
839{
840	return pm_show_wakelocks(buf, false);
841}
842
843static ssize_t wake_unlock_store(struct kobject *kobj,
844				 struct kobj_attribute *attr,
845				 const char *buf, size_t n)
846{
847	int error = pm_wake_unlock(buf);
848	return error ? error : n;
849}
850
851power_attr(wake_unlock);
852
853#endif /* CONFIG_PM_WAKELOCKS */
854#endif /* CONFIG_PM_SLEEP */
855
856#ifdef CONFIG_PM_TRACE
857int pm_trace_enabled;
858
859static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
860			     char *buf)
861{
862	return sprintf(buf, "%d\n", pm_trace_enabled);
863}
864
865static ssize_t
866pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
867	       const char *buf, size_t n)
868{
869	int val;
870
871	if (sscanf(buf, "%d", &val) == 1) {
872		pm_trace_enabled = !!val;
873		if (pm_trace_enabled) {
874			pr_warn("PM: Enabling pm_trace changes system date and time during resume.\n"
875				"PM: Correct system time has to be restored manually after resume.\n");
876		}
877		return n;
878	}
879	return -EINVAL;
880}
881
882power_attr(pm_trace);
883
884static ssize_t pm_trace_dev_match_show(struct kobject *kobj,
885				       struct kobj_attribute *attr,
886				       char *buf)
887{
888	return show_trace_dev_match(buf, PAGE_SIZE);
889}
890
891power_attr_ro(pm_trace_dev_match);
892
893#endif /* CONFIG_PM_TRACE */
894
895#ifdef CONFIG_FREEZER
896static ssize_t pm_freeze_timeout_show(struct kobject *kobj,
897				      struct kobj_attribute *attr, char *buf)
898{
899	return sprintf(buf, "%u\n", freeze_timeout_msecs);
900}
901
902static ssize_t pm_freeze_timeout_store(struct kobject *kobj,
903				       struct kobj_attribute *attr,
904				       const char *buf, size_t n)
905{
906	unsigned long val;
907
908	if (kstrtoul(buf, 10, &val))
909		return -EINVAL;
910
911	freeze_timeout_msecs = val;
912	return n;
913}
914
915power_attr(pm_freeze_timeout);
916
917#endif	/* CONFIG_FREEZER*/
918
919static struct attribute * g[] = {
920	&state_attr.attr,
921#ifdef CONFIG_PM_TRACE
922	&pm_trace_attr.attr,
923	&pm_trace_dev_match_attr.attr,
924#endif
925#ifdef CONFIG_PM_SLEEP
926	&pm_async_attr.attr,
927	&wakeup_count_attr.attr,
928#ifdef CONFIG_SUSPEND
929	&mem_sleep_attr.attr,
930	&sync_on_suspend_attr.attr,
931#endif
932#ifdef CONFIG_PM_AUTOSLEEP
933	&autosleep_attr.attr,
934#endif
935#ifdef CONFIG_PM_WAKELOCKS
936	&wake_lock_attr.attr,
937	&wake_unlock_attr.attr,
938#endif
939#ifdef CONFIG_PM_SLEEP_DEBUG
940	&pm_test_attr.attr,
941	&pm_print_times_attr.attr,
942	&pm_wakeup_irq_attr.attr,
943	&pm_debug_messages_attr.attr,
944#endif
945#endif
946#ifdef CONFIG_FREEZER
947	&pm_freeze_timeout_attr.attr,
948#endif
949	NULL,
950};
951
952static const struct attribute_group attr_group = {
953	.attrs = g,
954};
955
956static const struct attribute_group *attr_groups[] = {
957	&attr_group,
958#ifdef CONFIG_PM_SLEEP
959	&suspend_attr_group,
960#endif
961	NULL,
962};
963
964struct workqueue_struct *pm_wq;
965EXPORT_SYMBOL_GPL(pm_wq);
966
967static int __init pm_start_workqueue(void)
968{
969	pm_wq = alloc_workqueue("pm", WQ_FREEZABLE, 0);
970
971	return pm_wq ? 0 : -ENOMEM;
972}
973
974static int __init pm_init(void)
975{
976	int error = pm_start_workqueue();
977	if (error)
978		return error;
979	hibernate_image_size_init();
980	hibernate_reserved_size_init();
981	pm_states_init();
982	power_kobj = kobject_create_and_add("power", NULL);
983	if (!power_kobj)
984		return -ENOMEM;
985	error = sysfs_create_groups(power_kobj, attr_groups);
986	if (error)
987		return error;
988	pm_print_times_init();
989	return pm_autosleep_init();
990}
991
992core_initcall(pm_init);