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 5 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), "Component: %s\n", label); 53 } 54 55 /* 56 * To test system suspend, we need a hands-off mechanism to resume the 57 * system. RTCs wake alarms are a common self-contained mechanism. 58 */ 59 60 static void __init test_wakealarm(struct rtc_device *rtc, suspend_state_t state) 61 { 62 static char err_readtime[] __initdata = 63 KERN_ERR "PM: can't read %s time, err %d\n"; 64 static char err_wakealarm [] __initdata = 65 KERN_ERR "PM: can't set %s wakealarm, err %d\n"; 66 static char err_suspend[] __initdata = 67 KERN_ERR "PM: suspend test failed, error %d\n"; 68 static char info_test[] __initdata = 69 KERN_INFO "PM: test RTC wakeup from '%s' suspend\n"; 70 71 unsigned long now; 72 struct rtc_wkalrm alm; 73 int status; 74 75 /* this may fail if the RTC hasn't been initialized */ 76 status = rtc_read_time(rtc, &alm.time); 77 if (status < 0) { 78 printk(err_readtime, dev_name(&rtc->dev), status); 79 return; 80 } 81 rtc_tm_to_time(&alm.time, &now); 82 83 memset(&alm, 0, sizeof alm); 84 rtc_time_to_tm(now + TEST_SUSPEND_SECONDS, &alm.time); 85 alm.enabled = true; 86 87 status = rtc_set_alarm(rtc, &alm); 88 if (status < 0) { 89 printk(err_wakealarm, dev_name(&rtc->dev), status); 90 return; 91 } 92 93 if (state == PM_SUSPEND_MEM) { 94 printk(info_test, pm_states[state]); 95 status = pm_suspend(state); 96 if (status == -ENODEV) 97 state = PM_SUSPEND_STANDBY; 98 } 99 if (state == PM_SUSPEND_STANDBY) { 100 printk(info_test, pm_states[state]); 101 status = pm_suspend(state); 102 } 103 if (status < 0) 104 printk(err_suspend, status); 105 106 /* Some platforms can't detect that the alarm triggered the 107 * wakeup, or (accordingly) disable it after it afterwards. 108 * It's supposed to give oneshot behavior; cope. 109 */ 110 alm.enabled = false; 111 rtc_set_alarm(rtc, &alm); 112 } 113 114 static int __init has_wakealarm(struct device *dev, void *name_ptr) 115 { 116 struct rtc_device *candidate = to_rtc_device(dev); 117 118 if (!candidate->ops->set_alarm) 119 return 0; 120 if (!device_may_wakeup(candidate->dev.parent)) 121 return 0; 122 123 *(const char **)name_ptr = dev_name(dev); 124 return 1; 125 } 126 127 /* 128 * Kernel options like "test_suspend=mem" force suspend/resume sanity tests 129 * at startup time. They're normally disabled, for faster boot and because 130 * we can't know which states really work on this particular system. 131 */ 132 static suspend_state_t test_state __initdata = PM_SUSPEND_ON; 133 134 static char warn_bad_state[] __initdata = 135 KERN_WARNING "PM: can't test '%s' suspend state\n"; 136 137 static int __init setup_test_suspend(char *value) 138 { 139 unsigned i; 140 141 /* "=mem" ==> "mem" */ 142 value++; 143 for (i = 0; i < PM_SUSPEND_MAX; i++) { 144 if (!pm_states[i]) 145 continue; 146 if (strcmp(pm_states[i], value) != 0) 147 continue; 148 test_state = (__force suspend_state_t) i; 149 return 0; 150 } 151 printk(warn_bad_state, value); 152 return 0; 153 } 154 __setup("test_suspend", setup_test_suspend); 155 156 static int __init test_suspend(void) 157 { 158 static char warn_no_rtc[] __initdata = 159 KERN_WARNING "PM: no wakealarm-capable RTC driver is ready\n"; 160 161 char *pony = NULL; 162 struct rtc_device *rtc = NULL; 163 164 /* PM is initialized by now; is that state testable? */ 165 if (test_state == PM_SUSPEND_ON) 166 goto done; 167 if (!valid_state(test_state)) { 168 printk(warn_bad_state, pm_states[test_state]); 169 goto done; 170 } 171 172 /* RTCs have initialized by now too ... can we use one? */ 173 class_find_device(rtc_class, NULL, &pony, has_wakealarm); 174 if (pony) 175 rtc = rtc_class_open(pony); 176 if (!rtc) { 177 printk(warn_no_rtc); 178 goto done; 179 } 180 181 /* go for it */ 182 test_wakealarm(rtc, test_state); 183 rtc_class_close(rtc); 184 done: 185 return 0; 186 } 187 late_initcall(test_suspend); 188