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