kernel/power/wakeup_reason.c

   1 /*
   2  * kernel/power/wakeup_reason.c
   3  *
   4  * Logs the reasons which caused the kernel to resume from
   5  * the suspend mode.
   6  *
   7  * Copyright (C) 2014 Google, Inc.
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 #include <linux/wakeup_reason.h>
  19 #include <linux/kernel.h>
  20 #include <linux/irq.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/io.h>
  23 #include <linux/kobject.h>
  24 #include <linux/sysfs.h>
  25 #include <linux/init.h>
  26 #include <linux/spinlock.h>
  27 #include <linux/notifier.h>
  28 #include <linux/suspend.h>
  29
  30
  31 #define MAX_WAKEUP_REASON_IRQS 32
  32 static int irq_list[MAX_WAKEUP_REASON_IRQS];
  33 static int irqcount;
  34 static bool suspend_abort;
  35 static char abort_reason[MAX_SUSPEND_ABORT_LEN];
  36 static struct kobject *wakeup_reason;
  37 static DEFINE_SPINLOCK(resume_reason_lock);
  38
  39 static struct timespec last_xtime; /* wall time before last suspend */
  40 static struct timespec curr_xtime; /* wall time after last suspend */
  41 static struct timespec last_stime; /* total_sleep_time before last suspend */
  42 static struct timespec curr_stime; /* total_sleep_time after last suspend */
  43
  44 static ssize_t last_resume_reason_show(struct kobject *kobj, struct kobj_attribute *attr,
  45                 char *buf)
  46 {
  47         int irq_no, buf_offset = 0;
  48         struct irq_desc *desc;
  49         spin_lock(&resume_reason_lock);
  50         if (suspend_abort) {
  51                 buf_offset = sprintf(buf, "Abort: %s", abort_reason);
  52         } else {
  53                 for (irq_no = 0; irq_no < irqcount; irq_no++) {
  54                         desc = irq_to_desc(irq_list[irq_no]);
  55                         if (desc && desc->action && desc->action->name)
  56                                 buf_offset += sprintf(buf + buf_offset, "%d %s\n",
  57                                                 irq_list[irq_no], desc->action->name);
  58                         else
  59                                 buf_offset += sprintf(buf + buf_offset, "%d\n",
  60                                                 irq_list[irq_no]);
  61                 }
  62         }
  63         spin_unlock(&resume_reason_lock);
  64         return buf_offset;
  65 }
  66
  67 static ssize_t last_suspend_time_show(struct kobject *kobj,
  68                         struct kobj_attribute *attr, char *buf)
  69 {
  70         struct timespec sleep_time;
  71         struct timespec total_time;
  72         struct timespec suspend_resume_time;
  73
  74         sleep_time = timespec_sub(curr_stime, last_stime);
  75         total_time = timespec_sub(curr_xtime, last_xtime);
  76         suspend_resume_time = timespec_sub(total_time, sleep_time);
  77
  78         /*
  79          * suspend_resume_time is calculated from sleep_time. Userspace would
  80          * always need both. Export them in pair here.
  81          */
  82         return sprintf(buf, "%lu.%09lu %lu.%09lu\n",
  83                                 suspend_resume_time.tv_sec, suspend_resume_time.tv_nsec,
  84                                 sleep_time.tv_sec, sleep_time.tv_nsec);
  85 }
  86
  87 static struct kobj_attribute resume_reason = __ATTR_RO(last_resume_reason);
  88 static struct kobj_attribute suspend_time = __ATTR_RO(last_suspend_time);
  89
  90 static struct attribute *attrs[] = {
  91         &resume_reason.attr,
  92         &suspend_time.attr,
  93         NULL,
  94 };
  95 static struct attribute_group attr_group = {
  96         .attrs = attrs,
  97 };
  98
  99 /*
 100  * logs all the wake up reasons to the kernel
 101  * stores the irqs to expose them to the userspace via sysfs
 102  */
 103 void log_wakeup_reason(int irq)
 104 {
 105         struct irq_desc *desc;
 106         desc = irq_to_desc(irq);
 107         if (desc && desc->action && desc->action->name)
 108                 printk(KERN_INFO "Resume caused by IRQ %d, %s\n", irq,
 109                                 desc->action->name);
 110         else
 111                 printk(KERN_INFO "Resume caused by IRQ %d\n", irq);
 112
 113         spin_lock(&resume_reason_lock);
 114         if (irqcount == MAX_WAKEUP_REASON_IRQS) {
 115                 spin_unlock(&resume_reason_lock);
 116                 printk(KERN_WARNING "Resume caused by more than %d IRQs\n",
 117                                 MAX_WAKEUP_REASON_IRQS);
 118                 return;
 119         }
 120
 121         irq_list[irqcount++] = irq;
 122         spin_unlock(&resume_reason_lock);
 123 }
 124
 125 int check_wakeup_reason(int irq)
 126 {
 127         int irq_no;
 128         int ret = false;
 129
 130         spin_lock(&resume_reason_lock);
 131         for (irq_no = 0; irq_no < irqcount; irq_no++)
 132                 if (irq_list[irq_no] == irq) {
 133                         ret = true;
 134                         break;
 135         }
 136         spin_unlock(&resume_reason_lock);
 137         return ret;
 138 }
 139
 140 void log_suspend_abort_reason(const char *fmt, ...)
 141 {
 142         va_list args;
 143
 144         spin_lock(&resume_reason_lock);
 145
 146         //Suspend abort reason has already been logged.
 147         if (suspend_abort) {
 148                 spin_unlock(&resume_reason_lock);
 149                 return;
 150         }
 151
 152         suspend_abort = true;
 153         va_start(args, fmt);
 154         snprintf(abort_reason, MAX_SUSPEND_ABORT_LEN, fmt, args);
 155         va_end(args);
 156         spin_unlock(&resume_reason_lock);
 157 }
 158
 159 /* Detects a suspend and clears all the previous wake up reasons*/
 160 static int wakeup_reason_pm_event(struct notifier_block *notifier,
 161                 unsigned long pm_event, void *unused)
 162 {
 163         struct timespec xtom; /* wall_to_monotonic, ignored */
 164
 165         switch (pm_event) {
 166         case PM_SUSPEND_PREPARE:
 167                 spin_lock(&resume_reason_lock);
 168                 irqcount = 0;
 169                 suspend_abort = false;
 170                 spin_unlock(&resume_reason_lock);
 171
 172                 get_xtime_and_monotonic_and_sleep_offset(&last_xtime, &xtom,
 173                         &last_stime);
 174                 break;
 175         case PM_POST_SUSPEND:
 176                 get_xtime_and_monotonic_and_sleep_offset(&curr_xtime, &xtom,
 177                         &curr_stime);
 178                 break;
 179         default:
 180                 break;
 181         }
 182         return NOTIFY_DONE;
 183 }
 184
 185 static struct notifier_block wakeup_reason_pm_notifier_block = {
 186         .notifier_call = wakeup_reason_pm_event,
 187 };
 188
 189 /* Initializes the sysfs parameter
 190  * registers the pm_event notifier
 191  */
 192 int __init wakeup_reason_init(void)
 193 {
 194         int retval;
 195
 196         retval = register_pm_notifier(&wakeup_reason_pm_notifier_block);
 197         if (retval)
 198                 printk(KERN_WARNING "[%s] failed to register PM notifier %d\n",
 199                                 __func__, retval);
 200
 201         wakeup_reason = kobject_create_and_add("wakeup_reasons", kernel_kobj);
 202         if (!wakeup_reason) {
 203                 printk(KERN_WARNING "[%s] failed to create a sysfs kobject\n",
 204                                 __func__);
 205                 return 1;
 206         }
 207         retval = sysfs_create_group(wakeup_reason, &attr_group);
 208         if (retval) {
 209                 kobject_put(wakeup_reason);
 210                 printk(KERN_WARNING "[%s] failed to create a sysfs group %d\n",
 211                                 __func__, retval);
 212         }
 213         return 0;
 214 }
 215
 216 late_initcall(wakeup_reason_init);