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 ssize_t last_resume_reason_show(struct kobject *kobj, struct kobj_attribute *attr,
42 int irq_no, buf_offset = 0;
43 struct irq_desc *desc;
44 spin_lock(&resume_reason_lock);
46 buf_offset = sprintf(buf, "Abort: %s", abort_reason);
48 for (irq_no = 0; irq_no < irqcount; irq_no++) {
49 desc = irq_to_desc(irq_list[irq_no]);
50 if (desc && desc->action && desc->action->name)
51 buf_offset += sprintf(buf + buf_offset, "%d %s\n",
52 irq_list[irq_no], desc->action->name);
54 buf_offset += sprintf(buf + buf_offset, "%d\n",
58 spin_unlock(&resume_reason_lock);
62 static struct kobj_attribute resume_reason = __ATTR_RO(last_resume_reason);
64 static struct attribute *attrs[] = {
68 static struct attribute_group attr_group = {
73 * logs all the wake up reasons to the kernel
74 * stores the irqs to expose them to the userspace via sysfs
76 void log_wakeup_reason(int irq)
78 struct irq_desc *desc;
79 desc = irq_to_desc(irq);
80 if (desc && desc->action && desc->action->name)
81 printk(KERN_INFO "Resume caused by IRQ %d, %s\n", irq,
84 printk(KERN_INFO "Resume caused by IRQ %d\n", irq);
86 spin_lock(&resume_reason_lock);
87 if (irqcount == MAX_WAKEUP_REASON_IRQS) {
88 spin_unlock(&resume_reason_lock);
89 printk(KERN_WARNING "Resume caused by more than %d IRQs\n",
90 MAX_WAKEUP_REASON_IRQS);
94 irq_list[irqcount++] = irq;
95 spin_unlock(&resume_reason_lock);
98 int check_wakeup_reason(int irq)
103 spin_lock(&resume_reason_lock);
104 for (irq_no = 0; irq_no < irqcount; irq_no++)
105 if (irq_list[irq_no] == irq) {
109 spin_unlock(&resume_reason_lock);
113 void log_suspend_abort_reason(const char *fmt, ...)
117 spin_lock(&resume_reason_lock);
119 //Suspend abort reason has already been logged.
121 spin_unlock(&resume_reason_lock);
125 suspend_abort = true;
127 snprintf(abort_reason, MAX_SUSPEND_ABORT_LEN, fmt, args);
129 spin_unlock(&resume_reason_lock);
132 /* Detects a suspend and clears all the previous wake up reasons*/
133 static int wakeup_reason_pm_event(struct notifier_block *notifier,
134 unsigned long pm_event, void *unused)
137 case PM_SUSPEND_PREPARE:
138 spin_lock(&resume_reason_lock);
140 suspend_abort = false;
141 spin_unlock(&resume_reason_lock);
149 static struct notifier_block wakeup_reason_pm_notifier_block = {
150 .notifier_call = wakeup_reason_pm_event,
153 /* Initializes the sysfs parameter
154 * registers the pm_event notifier
156 int __init wakeup_reason_init(void)
160 retval = register_pm_notifier(&wakeup_reason_pm_notifier_block);
162 printk(KERN_WARNING "[%s] failed to register PM notifier %d\n",
165 wakeup_reason = kobject_create_and_add("wakeup_reasons", kernel_kobj);
166 if (!wakeup_reason) {
167 printk(KERN_WARNING "[%s] failed to create a sysfs kobject\n",
171 retval = sysfs_create_group(wakeup_reason, &attr_group);
173 kobject_put(wakeup_reason);
174 printk(KERN_WARNING "[%s] failed to create a sysfs group %d\n",
180 late_initcall(wakeup_reason_init);