kernel/power/suspend_test.c

   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, const void *data)
 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         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         struct rtc_device       *rtc = NULL;
 162         struct device           *dev;
 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         dev = class_find_device(rtc_class, NULL, NULL, has_wakealarm);
 174         if (dev)
 175                 rtc = rtc_class_open(dev_name(dev));
 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);