2 * kernel/power/suspend_test.c - Suspend to RAM and standby test facility.
4 * Copyright (c) 2009 Pavel Machek <pavel@ucw.cz>
6 * This file is released under the GPLv2.
9 #include <linux/init.h>
10 #include <linux/rtc.h>
15 * We test the system suspend code by setting an RTC wakealarm a short
16 * time in the future, then suspending. Suspending the devices won't
17 * normally take long ... some systems only need a few milliseconds.
19 * The time it takes is system-specific though, so when we test this
20 * during system bootup we allow a LOT of time.
22 #define TEST_SUSPEND_SECONDS 10
24 static unsigned long suspend_test_start_time
;
26 void suspend_test_start(void)
28 suspend_test_start_time
= jiffies
;
31 void suspend_test_finish(const char *label
)
33 long nj
= jiffies
- suspend_test_start_time
;
36 msec
= jiffies_to_msecs(abs(nj
));
37 pr_info("PM: %s took %d.%03d seconds\n", label
,
38 msec
/ 1000, msec
% 1000);
40 /* Warning on suspend means the RTC alarm period needs to be
41 * larger -- the system was sooo slooowwww to suspend that the
42 * alarm (should have) fired before the system went to sleep!
44 * Warning on either suspend or resume also means the system
45 * has some performance issues. The stack dump of a WARN_ON
46 * is more likely to get the right attention than a printk...
48 WARN(msec
> (TEST_SUSPEND_SECONDS
* 1000),
49 "Component: %s, time: %u\n", label
, msec
);
53 * To test system suspend, we need a hands-off mechanism to resume the
54 * system. RTCs wake alarms are a common self-contained mechanism.
57 static void __init
test_wakealarm(struct rtc_device
*rtc
, suspend_state_t state
)
59 static char err_readtime
[] __initdata
=
60 KERN_ERR
"PM: can't read %s time, err %d\n";
61 static char err_wakealarm
[] __initdata
=
62 KERN_ERR
"PM: can't set %s wakealarm, err %d\n";
63 static char err_suspend
[] __initdata
=
64 KERN_ERR
"PM: suspend test failed, error %d\n";
65 static char info_test
[] __initdata
=
66 KERN_INFO
"PM: test RTC wakeup from '%s' suspend\n";
69 struct rtc_wkalrm alm
;
72 /* this may fail if the RTC hasn't been initialized */
73 status
= rtc_read_time(rtc
, &alm
.time
);
75 printk(err_readtime
, dev_name(&rtc
->dev
), status
);
78 rtc_tm_to_time(&alm
.time
, &now
);
80 memset(&alm
, 0, sizeof alm
);
81 rtc_time_to_tm(now
+ TEST_SUSPEND_SECONDS
, &alm
.time
);
84 status
= rtc_set_alarm(rtc
, &alm
);
86 printk(err_wakealarm
, dev_name(&rtc
->dev
), status
);
90 if (state
== PM_SUSPEND_MEM
) {
91 printk(info_test
, pm_states
[state
]);
92 status
= pm_suspend(state
);
93 if (status
== -ENODEV
)
94 state
= PM_SUSPEND_STANDBY
;
96 if (state
== PM_SUSPEND_STANDBY
) {
97 printk(info_test
, pm_states
[state
]);
98 status
= pm_suspend(state
);
101 printk(err_suspend
, status
);
103 /* Some platforms can't detect that the alarm triggered the
104 * wakeup, or (accordingly) disable it after it afterwards.
105 * It's supposed to give oneshot behavior; cope.
108 rtc_set_alarm(rtc
, &alm
);
111 static int __init
has_wakealarm(struct device
*dev
, void *name_ptr
)
113 struct rtc_device
*candidate
= to_rtc_device(dev
);
115 if (!candidate
->ops
->set_alarm
)
117 if (!device_may_wakeup(candidate
->dev
.parent
))
120 *(const char **)name_ptr
= dev_name(dev
);
125 * Kernel options like "test_suspend=mem" force suspend/resume sanity tests
126 * at startup time. They're normally disabled, for faster boot and because
127 * we can't know which states really work on this particular system.
129 static suspend_state_t test_state __initdata
= PM_SUSPEND_ON
;
131 static char warn_bad_state
[] __initdata
=
132 KERN_WARNING
"PM: can't test '%s' suspend state\n";
134 static int __init
setup_test_suspend(char *value
)
138 /* "=mem" ==> "mem" */
140 for (i
= 0; i
< PM_SUSPEND_MAX
; i
++) {
143 if (strcmp(pm_states
[i
], value
) != 0)
145 test_state
= (__force suspend_state_t
) i
;
148 printk(warn_bad_state
, value
);
151 __setup("test_suspend", setup_test_suspend
);
153 static int __init
test_suspend(void)
155 static char warn_no_rtc
[] __initdata
=
156 KERN_WARNING
"PM: no wakealarm-capable RTC driver is ready\n";
159 struct rtc_device
*rtc
= NULL
;
161 /* PM is initialized by now; is that state testable? */
162 if (test_state
== PM_SUSPEND_ON
)
164 if (!valid_state(test_state
)) {
165 printk(warn_bad_state
, pm_states
[test_state
]);
169 /* RTCs have initialized by now too ... can we use one? */
170 class_find_device(rtc_class
, NULL
, &pony
, has_wakealarm
);
172 rtc
= rtc_class_open(pony
);
179 test_wakealarm(rtc
, test_state
);
180 rtc_class_close(rtc
);
184 late_initcall(test_suspend
);