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 ktime_t last_monotime; /* monotonic time before last suspend */
  40 static ktime_t curr_monotime; /* monotonic time after last suspend */
  41 static ktime_t last_stime; /* monotonic boottime offset before last suspend */
  42 static ktime_t curr_stime; /* monotonic boottime offset 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         /*
  75          * total_time is calculated from monotonic bootoffsets because
  76          * unlike CLOCK_MONOTONIC it include the time spent in suspend state.
  77          */
  78         total_time = ktime_to_timespec(ktime_sub(curr_stime, last_stime));
  79
  80         /*
  81          * suspend_resume_time is calculated as monotonic (CLOCK_MONOTONIC)
  82          * time interval before entering suspend and post suspend.
  83          */
  84         suspend_resume_time = ktime_to_timespec(ktime_sub(curr_monotime, last_monotime));
  85
  86         /* sleep_time = total_time - suspend_resume_time */
  87         sleep_time = timespec_sub(total_time, suspend_resume_time);
  88
  89         /* Export suspend_resume_time and sleep_time in pair here. */
  90         return sprintf(buf, "%lu.%09lu %lu.%09lu\n",
  91                                 suspend_resume_time.tv_sec, suspend_resume_time.tv_nsec,
  92                                 sleep_time.tv_sec, sleep_time.tv_nsec);
  93 }
  94
  95 static struct kobj_attribute resume_reason = __ATTR_RO(last_resume_reason);
  96 static struct kobj_attribute suspend_time = __ATTR_RO(last_suspend_time);
  97
  98 static struct attribute *attrs[] = {
  99         &resume_reason.attr,
 100         &suspend_time.attr,
 101         NULL,
 102 };
 103 static struct attribute_group attr_group = {
 104         .attrs = attrs,
 105 };
 106
 107 /*
 108  * logs all the wake up reasons to the kernel
 109  * stores the irqs to expose them to the userspace via sysfs
 110  */
 111 void log_wakeup_reason(int irq)
 112 {
 113         struct irq_desc *desc;
 114         desc = irq_to_desc(irq);
 115         if (desc && desc->action && desc->action->name)
 116                 printk(KERN_INFO "Resume caused by IRQ %d, %s\n", irq,
 117                                 desc->action->name);
 118         else
 119                 printk(KERN_INFO "Resume caused by IRQ %d\n", irq);
 120
 121         spin_lock(&resume_reason_lock);
 122         if (irqcount == MAX_WAKEUP_REASON_IRQS) {
 123                 spin_unlock(&resume_reason_lock);
 124                 printk(KERN_WARNING "Resume caused by more than %d IRQs\n",
 125                                 MAX_WAKEUP_REASON_IRQS);
 126                 return;
 127         }
 128
 129         irq_list[irqcount++] = irq;
 130         spin_unlock(&resume_reason_lock);
 131 }
 132
 133 int check_wakeup_reason(int irq)
 134 {
 135         int irq_no;
 136         int ret = false;
 137
 138         spin_lock(&resume_reason_lock);
 139         for (irq_no = 0; irq_no < irqcount; irq_no++)
 140                 if (irq_list[irq_no] == irq) {
 141                         ret = true;
 142                         break;
 143         }
 144         spin_unlock(&resume_reason_lock);
 145         return ret;
 146 }
 147
 148 void log_suspend_abort_reason(const char *fmt, ...)
 149 {
 150         va_list args;
 151
 152         spin_lock(&resume_reason_lock);
 153
 154         //Suspend abort reason has already been logged.
 155         if (suspend_abort) {
 156                 spin_unlock(&resume_reason_lock);
 157                 return;
 158         }
 159
 160         suspend_abort = true;
 161         va_start(args, fmt);
 162         vsnprintf(abort_reason, MAX_SUSPEND_ABORT_LEN, fmt, args);
 163         va_end(args);
 164         spin_unlock(&resume_reason_lock);
 165 }
 166
 167 /* Detects a suspend and clears all the previous wake up reasons*/
 168 static int wakeup_reason_pm_event(struct notifier_block *notifier,
 169                 unsigned long pm_event, void *unused)
 170 {
 171         switch (pm_event) {
 172         case PM_SUSPEND_PREPARE:
 173                 spin_lock(&resume_reason_lock);
 174                 irqcount = 0;
 175                 suspend_abort = false;
 176                 spin_unlock(&resume_reason_lock);
 177                 /* monotonic time since boot */
 178                 last_monotime = ktime_get();
 179                 /* monotonic time since boot including the time spent in suspend */
 180                 last_stime = ktime_get_boottime();
 181                 break;
 182         case PM_POST_SUSPEND:
 183                 /* monotonic time since boot */
 184                 curr_monotime = ktime_get();
 185                 /* monotonic time since boot including the time spent in suspend */
 186                 curr_stime = ktime_get_boottime();
 187                 break;
 188         default:
 189                 break;
 190         }
 191         return NOTIFY_DONE;
 192 }
 193
 194 static struct notifier_block wakeup_reason_pm_notifier_block = {
 195         .notifier_call = wakeup_reason_pm_event,
 196 };
 197
 198 /* Initializes the sysfs parameter
 199  * registers the pm_event notifier
 200  */
 201 int __init wakeup_reason_init(void)
 202 {
 203         int retval;
 204
 205         retval = register_pm_notifier(&wakeup_reason_pm_notifier_block);
 206         if (retval)
 207                 printk(KERN_WARNING "[%s] failed to register PM notifier %d\n",
 208                                 __func__, retval);
 209
 210         wakeup_reason = kobject_create_and_add("wakeup_reasons", kernel_kobj);
 211         if (!wakeup_reason) {
 212                 printk(KERN_WARNING "[%s] failed to create a sysfs kobject\n",
 213                                 __func__);
 214                 return 1;
 215         }
 216         retval = sysfs_create_group(wakeup_reason, &attr_group);
 217         if (retval) {
 218                 kobject_put(wakeup_reason);
 219                 printk(KERN_WARNING "[%s] failed to create a sysfs group %d\n",
 220                                 __func__, retval);
 221         }
 222         return 0;
 223 }
 224
 225 late_initcall(wakeup_reason_init);