2 * kernel/power/wakeup_reason.c
4 * Logs the reasons which caused the kernel to resume from
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.
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.
18 #include <linux/wakeup_reason.h>
19 #include <linux/kernel.h>
20 #include <linux/irq.h>
21 #include <linux/interrupt.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>
31 #define MAX_WAKEUP_REASON_IRQS 32
32 static int irq_list[MAX_WAKEUP_REASON_IRQS];
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);
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 */
44 static ssize_t last_resume_reason_show(struct kobject *kobj, struct kobj_attribute *attr,
47 int irq_no, buf_offset = 0;
48 struct irq_desc *desc;
49 spin_lock(&resume_reason_lock);
51 buf_offset = sprintf(buf, "Abort: %s", abort_reason);
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);
59 buf_offset += sprintf(buf + buf_offset, "%d\n",
63 spin_unlock(&resume_reason_lock);
67 static ssize_t last_suspend_time_show(struct kobject *kobj,
68 struct kobj_attribute *attr, char *buf)
70 struct timespec sleep_time;
71 struct timespec total_time;
72 struct timespec suspend_resume_time;
75 * total_time is calculated from monotonic bootoffsets because
76 * unlike CLOCK_MONOTONIC it include the time spent in suspend state.
78 total_time = ktime_to_timespec(ktime_sub(curr_stime, last_stime));
81 * suspend_resume_time is calculated as monotonic (CLOCK_MONOTONIC)
82 * time interval before entering suspend and post suspend.
84 suspend_resume_time = ktime_to_timespec(ktime_sub(curr_monotime, last_monotime));
86 /* sleep_time = total_time - suspend_resume_time */
87 sleep_time = timespec_sub(total_time, suspend_resume_time);
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);
95 static struct kobj_attribute resume_reason = __ATTR_RO(last_resume_reason);
96 static struct kobj_attribute suspend_time = __ATTR_RO(last_suspend_time);
98 static struct attribute *attrs[] = {
103 static struct attribute_group attr_group = {
108 * logs all the wake up reasons to the kernel
109 * stores the irqs to expose them to the userspace via sysfs
111 void log_wakeup_reason(int irq)
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,
119 printk(KERN_INFO "Resume caused by IRQ %d\n", irq);
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);
129 irq_list[irqcount++] = irq;
130 spin_unlock(&resume_reason_lock);
133 int check_wakeup_reason(int irq)
138 spin_lock(&resume_reason_lock);
139 for (irq_no = 0; irq_no < irqcount; irq_no++)
140 if (irq_list[irq_no] == irq) {
144 spin_unlock(&resume_reason_lock);
148 void log_suspend_abort_reason(const char *fmt, ...)
152 spin_lock(&resume_reason_lock);
154 //Suspend abort reason has already been logged.
156 spin_unlock(&resume_reason_lock);
160 suspend_abort = true;
162 vsnprintf(abort_reason, MAX_SUSPEND_ABORT_LEN, fmt, args);
164 spin_unlock(&resume_reason_lock);
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)
172 case PM_SUSPEND_PREPARE:
173 spin_lock(&resume_reason_lock);
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();
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();
194 static struct notifier_block wakeup_reason_pm_notifier_block = {
195 .notifier_call = wakeup_reason_pm_event,
198 /* Initializes the sysfs parameter
199 * registers the pm_event notifier
201 int __init wakeup_reason_init(void)
205 retval = register_pm_notifier(&wakeup_reason_pm_notifier_block);
207 printk(KERN_WARNING "[%s] failed to register PM notifier %d\n",
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",
216 retval = sysfs_create_group(wakeup_reason, &attr_group);
218 kobject_put(wakeup_reason);
219 printk(KERN_WARNING "[%s] failed to create a sysfs group %d\n",
225 late_initcall(wakeup_reason_init);