1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * kernel/power/suspend_test.c - Suspend to RAM and standby test facility.
4 *
5 * Copyright (c) 2009 Pavel Machek <pavel@ucw.cz>
6 */
7
8#include <linux/init.h>
9#include <linux/rtc.h>
10
11#include "power.h"
12
13/*
14 * We test the system suspend code by setting an RTC wakealarm a short
15 * time in the future, then suspending.  Suspending the devices won't
16 * normally take long ... some systems only need a few milliseconds.
17 *
18 * The time it takes is system-specific though, so when we test this
19 * during system bootup we allow a LOT of time.
20 */
21#define TEST_SUSPEND_SECONDS	10
22
23static unsigned long suspend_test_start_time;
24static u32 test_repeat_count_max = 1;
25static u32 test_repeat_count_current;
26
27void suspend_test_start(void)
28{
29	/* FIXME Use better timebase than "jiffies", ideally a clocksource.
30	 * What we want is a hardware counter that will work correctly even
31	 * during the irqs-are-off stages of the suspend/resume cycle...
32	 */
33	suspend_test_start_time = jiffies;
34}
35
36void suspend_test_finish(const char *label)
37{
38	long nj = jiffies - suspend_test_start_time;
39	unsigned msec;
40
41	msec = jiffies_to_msecs(abs(nj));
42	pr_info("PM: %s took %d.%03d seconds\n", label,
43			msec / 1000, msec % 1000);
44
45	/* Warning on suspend means the RTC alarm period needs to be
46	 * larger -- the system was sooo slooowwww to suspend that the
47	 * alarm (should have) fired before the system went to sleep!
48	 *
49	 * Warning on either suspend or resume also means the system
50	 * has some performance issues.  The stack dump of a WARN_ON
51	 * is more likely to get the right attention than a printk...
52	 */
53	WARN(msec > (TEST_SUSPEND_SECONDS * 1000),
54	     "Component: %s, time: %u\n", label, msec);
55}
56
57/*
58 * To test system suspend, we need a hands-off mechanism to resume the
59 * system.  RTCs wake alarms are a common self-contained mechanism.
60 */
61
62static void __init test_wakealarm(struct rtc_device *rtc, suspend_state_t state)
63{
64	static char err_readtime[] __initdata =
65		KERN_ERR "PM: can't read %s time, err %d\n";
66	static char err_wakealarm [] __initdata =
67		KERN_ERR "PM: can't set %s wakealarm, err %d\n";
68	static char err_suspend[] __initdata =
69		KERN_ERR "PM: suspend test failed, error %d\n";
70	static char info_test[] __initdata =
71		KERN_INFO "PM: test RTC wakeup from '%s' suspend\n";
72
73	time64_t		now;
74	struct rtc_wkalrm	alm;
75	int			status;
76
77	/* this may fail if the RTC hasn't been initialized */
78repeat:
79	status = rtc_read_time(rtc, &alm.time);
80	if (status < 0) {
81		printk(err_readtime, dev_name(&rtc->dev), status);
82		return;
83	}
84	now = rtc_tm_to_time64(&alm.time);
85
86	memset(&alm, 0, sizeof alm);
87	rtc_time64_to_tm(now + TEST_SUSPEND_SECONDS, &alm.time);
88	alm.enabled = true;
89
90	status = rtc_set_alarm(rtc, &alm);
91	if (status < 0) {
92		printk(err_wakealarm, dev_name(&rtc->dev), status);
93		return;
94	}
95
96	if (state == PM_SUSPEND_MEM) {
97		printk(info_test, pm_states[state]);
98		status = pm_suspend(state);
99		if (status == -ENODEV)
100			state = PM_SUSPEND_STANDBY;
101	}
102	if (state == PM_SUSPEND_STANDBY) {
103		printk(info_test, pm_states[state]);
104		status = pm_suspend(state);
105		if (status < 0)
106			state = PM_SUSPEND_TO_IDLE;
107	}
108	if (state == PM_SUSPEND_TO_IDLE) {
109		printk(info_test, pm_states[state]);
110		status = pm_suspend(state);
111	}
112
113	if (status < 0)
114		printk(err_suspend, status);
115
116	test_repeat_count_current++;
117	if (test_repeat_count_current < test_repeat_count_max)
118		goto repeat;
119
120	/* Some platforms can't detect that the alarm triggered the
121	 * wakeup, or (accordingly) disable it after it afterwards.
122	 * It's supposed to give oneshot behavior; cope.
123	 */
124	alm.enabled = false;
125	rtc_set_alarm(rtc, &alm);
126}
127
128static int __init has_wakealarm(struct device *dev, const void *data)
129{
130	struct rtc_device *candidate = to_rtc_device(dev);
131
132	if (!test_bit(RTC_FEATURE_ALARM, candidate->features))
133		return 0;
134	if (!device_may_wakeup(candidate->dev.parent))
135		return 0;
136
137	return 1;
138}
139
140/*
141 * Kernel options like "test_suspend=mem" force suspend/resume sanity tests
142 * at startup time.  They're normally disabled, for faster boot and because
143 * we can't know which states really work on this particular system.
144 */
145static const char *test_state_label __initdata;
146
147static char warn_bad_state[] __initdata =
148	KERN_WARNING "PM: can't test '%s' suspend state\n";
149
150static int __init setup_test_suspend(char *value)
151{
152	int i;
153	char *repeat;
154	char *suspend_type;
155
156	/* example : "=mem[,N]" ==> "mem[,N]" */
157	value++;
158	suspend_type = strsep(&value, ",");
159	if (!suspend_type)
160		return 1;
161
162	repeat = strsep(&value, ",");
163	if (repeat) {
164		if (kstrtou32(repeat, 0, &test_repeat_count_max))
165			return 1;
166	}
167
168	for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
169		if (!strcmp(pm_labels[i], suspend_type)) {
170			test_state_label = pm_labels[i];
171			return 1;
172		}
173
174	printk(warn_bad_state, suspend_type);
175	return 1;
176}
177__setup("test_suspend", setup_test_suspend);
178
179static int __init test_suspend(void)
180{
181	static char		warn_no_rtc[] __initdata =
182		KERN_WARNING "PM: no wakealarm-capable RTC driver is ready\n";
183
184	struct rtc_device	*rtc = NULL;
185	struct device		*dev;
186	suspend_state_t test_state;
187
188	/* PM is initialized by now; is that state testable? */
189	if (!test_state_label)
190		return 0;
191
192	for (test_state = PM_SUSPEND_MIN; test_state < PM_SUSPEND_MAX; test_state++) {
193		const char *state_label = pm_states[test_state];
194
195		if (state_label && !strcmp(test_state_label, state_label))
196			break;
197	}
198	if (test_state == PM_SUSPEND_MAX) {
199		printk(warn_bad_state, test_state_label);
200		return 0;
201	}
202
203	/* RTCs have initialized by now too ... can we use one? */
204	dev = class_find_device(&rtc_class, NULL, NULL, has_wakealarm);
205	if (dev) {
206		rtc = rtc_class_open(dev_name(dev));
207		put_device(dev);
208	}
209	if (!rtc) {
210		printk(warn_no_rtc);
211		return 0;
212	}
213
214	/* go for it */
215	test_wakealarm(rtc, test_state);
216	rtc_class_close(rtc);
217	return 0;
218}
219late_initcall(test_suspend);
220