kernel/power/wakeup_reason.c - manifest_repos/kernel - Git at Google

 /*
  * kernel/power/wakeup_reason.c
  *
  * Logs the reasons which caused the kernel to resume from
  * the suspend mode.
  *
  * Copyright (C) 2020 Google, Inc.
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
  * may be copied, distributed, and modified under those terms.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */

 #include <linux/wakeup_reason.h>
 #include <linux/kernel.h>
 #include <linux/irq.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/kobject.h>
 #include <linux/sysfs.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/notifier.h>
 #include <linux/suspend.h>
 #include <linux/slab.h>

 /*
  * struct wakeup_irq_node - stores data and relationships for IRQs logged as
  * either base or nested wakeup reasons during suspend/resume flow.
  * @siblings - for membership on leaf or parent IRQ lists
  * @irq      - the IRQ number
  * @irq_name - the name associated with the IRQ, or a default if none
  */
 struct wakeup_irq_node {
 	struct list_head siblings;
 	int irq;
 	const char *irq_name;
 };

 enum wakeup_reason_flag {
 	RESUME_NONE = 0,
 	RESUME_IRQ,
 	RESUME_ABORT,
 	RESUME_ABNORMAL,
 };

 static DEFINE_SPINLOCK(wakeup_reason_lock);

 static LIST_HEAD(leaf_irqs);   /* kept in ascending IRQ sorted order */
 static LIST_HEAD(parent_irqs); /* unordered */

 static struct kmem_cache *wakeup_irq_nodes_cache;

 static const char *default_irq_name = "(unnamed)";

 static struct kobject *kobj;

 static bool capture_reasons;
 static int wakeup_reason;
 static char non_irq_wake_reason[MAX_SUSPEND_ABORT_LEN];

 static ktime_t last_monotime; /* monotonic time before last suspend */
 static ktime_t curr_monotime; /* monotonic time after last suspend */
 static ktime_t last_stime; /* monotonic boottime offset before last suspend */
 static ktime_t curr_stime; /* monotonic boottime offset after last suspend */

 static void init_node(struct wakeup_irq_node *p, int irq)
 {
 	struct irq_desc *desc;

 	INIT_LIST_HEAD(&p->siblings);

 	p->irq = irq;
 	desc = irq_to_desc(irq);
 	if (desc && desc->action && desc->action->name)
 		p->irq_name = desc->action->name;
 	else
 		p->irq_name = default_irq_name;
 }

 static struct wakeup_irq_node *create_node(int irq)
 {
 	struct wakeup_irq_node *result;

 	result = kmem_cache_alloc(wakeup_irq_nodes_cache, GFP_ATOMIC);
 	if (unlikely(!result))
 		pr_warn("Failed to log wakeup IRQ %d\n", irq);
 	else
 		init_node(result, irq);

 	return result;
 }

 static void delete_list(struct list_head *head)
 {
 	struct wakeup_irq_node *n;

 	while (!list_empty(head)) {
 		n = list_first_entry(head, struct wakeup_irq_node, siblings);
 		list_del(&n->siblings);
 		kmem_cache_free(wakeup_irq_nodes_cache, n);
 	}
 }

 static bool add_sibling_node_sorted(struct list_head *head, int irq)
 {
 	struct wakeup_irq_node *n = NULL;
 	struct list_head *predecessor = head;

 	if (unlikely(WARN_ON(!head)))
 		return NULL;

 	if (!list_empty(head))
 		list_for_each_entry(n, head, siblings) {
 			if (n->irq < irq)
 				predecessor = &n->siblings;
 			else if (n->irq == irq)
 				return true;
 			else
 				break;
 		}

 	n = create_node(irq);
 	if (n) {
 		list_add(&n->siblings, predecessor);
 		return true;
 	}

 	return false;
 }

 static struct wakeup_irq_node *find_node_in_list(struct list_head *head,
 						 int irq)
 {
 	struct wakeup_irq_node *n;

 	if (unlikely(WARN_ON(!head)))
 		return NULL;

 	list_for_each_entry(n, head, siblings)
 		if (n->irq == irq)
 			return n;

 	return NULL;
 }

 void log_irq_wakeup_reason(int irq)
 {
 	unsigned long flags;

 	spin_lock_irqsave(&wakeup_reason_lock, flags);
 	if (wakeup_reason == RESUME_ABNORMAL || wakeup_reason == RESUME_ABORT) {
 		spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 		return;
 	}

 	if (!capture_reasons) {
 		spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 		return;
 	}

 	if (find_node_in_list(&parent_irqs, irq) == NULL)
 		add_sibling_node_sorted(&leaf_irqs, irq);

 	wakeup_reason = RESUME_IRQ;
 	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 }

 void log_threaded_irq_wakeup_reason(int irq, int parent_irq)
 {
 	struct wakeup_irq_node *parent;
 	unsigned long flags;

 	/*
 	 * Intentionally unsynchronized.  Calls that come in after we have
 	 * resumed should have a fast exit path since there's no work to be
 	 * done, any any coherence issue that could cause a wrong value here is
 	 * both highly improbable - given the set/clear timing - and very low
 	 * impact (parent IRQ gets logged instead of the specific child).
 	 */
 	if (!capture_reasons)
 		return;

 	spin_lock_irqsave(&wakeup_reason_lock, flags);

 	if (wakeup_reason == RESUME_ABNORMAL || wakeup_reason == RESUME_ABORT) {
 		spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 		return;
 	}

 	if (!capture_reasons || (find_node_in_list(&leaf_irqs, irq) != NULL)) {
 		spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 		return;
 	}

 	parent = find_node_in_list(&parent_irqs, parent_irq);
 	if (parent != NULL)
 		add_sibling_node_sorted(&leaf_irqs, irq);
 	else {
 		parent = find_node_in_list(&leaf_irqs, parent_irq);
 		if (parent != NULL) {
 			list_del_init(&parent->siblings);
 			list_add_tail(&parent->siblings, &parent_irqs);
 			add_sibling_node_sorted(&leaf_irqs, irq);
 		}
 	}

 	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 }
 EXPORT_SYMBOL_GPL(log_threaded_irq_wakeup_reason);

 static void __log_abort_or_abnormal_wake(bool abort, const char *fmt,
 					 va_list args)
 {
 	unsigned long flags;

 	spin_lock_irqsave(&wakeup_reason_lock, flags);

 	/* Suspend abort or abnormal wake reason has already been logged. */
 	if (wakeup_reason != RESUME_NONE) {
 		spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 		return;
 	}

 	if (abort)
 		wakeup_reason = RESUME_ABORT;
 	else
 		wakeup_reason = RESUME_ABNORMAL;

 	vsnprintf(non_irq_wake_reason, MAX_SUSPEND_ABORT_LEN, fmt, args);

 	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 }

 void log_suspend_abort_reason(const char *fmt, ...)
 {
 	va_list args;

 	va_start(args, fmt);
 	__log_abort_or_abnormal_wake(true, fmt, args);
 	va_end(args);
 }
 EXPORT_SYMBOL_GPL(log_suspend_abort_reason);

 void log_abnormal_wakeup_reason(const char *fmt, ...)
 {
 	va_list args;

 	va_start(args, fmt);
 	__log_abort_or_abnormal_wake(false, fmt, args);
 	va_end(args);
 }
 EXPORT_SYMBOL_GPL(log_abnormal_wakeup_reason);

 void clear_wakeup_reasons(void)
 {
 	unsigned long flags;

 	spin_lock_irqsave(&wakeup_reason_lock, flags);

 	delete_list(&leaf_irqs);
 	delete_list(&parent_irqs);
 	wakeup_reason = RESUME_NONE;
 	capture_reasons = true;

 	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 }

 static void print_wakeup_sources(void)
 {
 	struct wakeup_irq_node *n;
 	unsigned long flags;

 	spin_lock_irqsave(&wakeup_reason_lock, flags);

 	capture_reasons = false;

 	if (wakeup_reason == RESUME_ABORT) {
 		pr_info("Abort: %s\n", non_irq_wake_reason);
 		spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 		return;
 	}

 	if (wakeup_reason == RESUME_IRQ && !list_empty(&leaf_irqs))
 		list_for_each_entry(n, &leaf_irqs, siblings)
 			pr_info("Resume caused by IRQ %d, %s\n", n->irq,
 				n->irq_name);
 	else if (wakeup_reason == RESUME_ABNORMAL)
 		pr_info("Resume caused by %s\n", non_irq_wake_reason);
 	else
 		pr_info("Resume cause unknown\n");

 	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 }

 static ssize_t last_resume_reason_show(struct kobject *kobj,
 				       struct kobj_attribute *attr, char *buf)
 {
 	ssize_t buf_offset = 0;
 	struct wakeup_irq_node *n;
 	unsigned long flags;

 	spin_lock_irqsave(&wakeup_reason_lock, flags);

 	if (wakeup_reason == RESUME_ABORT) {
 		buf_offset = scnprintf(buf, PAGE_SIZE, "Abort: %s",
 				       non_irq_wake_reason);
 		spin_unlock_irqrestore(&wakeup_reason_lock, flags);
 		return buf_offset;
 	}

 	if (wakeup_reason == RESUME_IRQ && !list_empty(&leaf_irqs))
 		list_for_each_entry(n, &leaf_irqs, siblings)
 			buf_offset += scnprintf(buf + buf_offset,
 						PAGE_SIZE - buf_offset,
 						"%d %s\n", n->irq, n->irq_name);
 	else if (wakeup_reason == RESUME_ABNORMAL)
 		buf_offset = scnprintf(buf, PAGE_SIZE, "-1 %s",
 				       non_irq_wake_reason);

 	spin_unlock_irqrestore(&wakeup_reason_lock, flags);

 	return buf_offset;
 }

 static ssize_t last_suspend_time_show(struct kobject *kobj,
 			struct kobj_attribute *attr, char *buf)
 {
 	struct timespec64 sleep_time;
 	struct timespec64 total_time;
 	struct timespec64 suspend_resume_time;

 	/*
 	 * total_time is calculated from monotonic bootoffsets because
 	 * unlike CLOCK_MONOTONIC it include the time spent in suspend state.
 	 */
 	total_time = ktime_to_timespec64(ktime_sub(curr_stime, last_stime));

 	/*
 	 * suspend_resume_time is calculated as monotonic (CLOCK_MONOTONIC)
 	 * time interval before entering suspend and post suspend.
 	 */
 	suspend_resume_time =
 		ktime_to_timespec64(ktime_sub(curr_monotime, last_monotime));

 	/* sleep_time = total_time - suspend_resume_time */
 	sleep_time = timespec64_sub(total_time, suspend_resume_time);

 	/* Export suspend_resume_time and sleep_time in pair here. */
 	return sprintf(buf, "%llu.%09lu %llu.%09lu\n",
 		       (unsigned long long)suspend_resume_time.tv_sec,
 		       suspend_resume_time.tv_nsec,
 		       (unsigned long long)sleep_time.tv_sec,
 		       sleep_time.tv_nsec);
 }

 static struct kobj_attribute resume_reason = __ATTR_RO(last_resume_reason);
 static struct kobj_attribute suspend_time = __ATTR_RO(last_suspend_time);

 static struct attribute *attrs[] = {
 	&resume_reason.attr,
 	&suspend_time.attr,
 	NULL,
 };
 static struct attribute_group attr_group = {
 	.attrs = attrs,
 };

 /* Detects a suspend and clears all the previous wake up reasons*/
 static int wakeup_reason_pm_event(struct notifier_block *notifier,
 		unsigned long pm_event, void *unused)
 {
 	switch (pm_event) {
 	case PM_SUSPEND_PREPARE:
 		/* monotonic time since boot */
 		last_monotime = ktime_get();
 		/* monotonic time since boot including the time spent in suspend */
 		last_stime = ktime_get_boottime();
 		clear_wakeup_reasons();
 		break;
 	case PM_POST_SUSPEND:
 		/* monotonic time since boot */
 		curr_monotime = ktime_get();
 		/* monotonic time since boot including the time spent in suspend */
 		curr_stime = ktime_get_boottime();
 		print_wakeup_sources();
 		break;
 	default:
 		break;
 	}
 	return NOTIFY_DONE;
 }

 static struct notifier_block wakeup_reason_pm_notifier_block = {
 	.notifier_call = wakeup_reason_pm_event,
 };

 static int __init wakeup_reason_init(void)
 {
 	if (register_pm_notifier(&wakeup_reason_pm_notifier_block)) {
 		pr_warn("[%s] failed to register PM notifier\n", __func__);
 		goto fail;
 	}

 	kobj = kobject_create_and_add("wakeup_reasons", kernel_kobj);
 	if (!kobj) {
 		pr_warn("[%s] failed to create a sysfs kobject\n", __func__);
 		goto fail_unregister_pm_notifier;
 	}

 	if (sysfs_create_group(kobj, &attr_group)) {
 		pr_warn("[%s] failed to create a sysfs group\n", __func__);
 		goto fail_kobject_put;
 	}

 	wakeup_irq_nodes_cache =
 		kmem_cache_create("wakeup_irq_node_cache",
 				  sizeof(struct wakeup_irq_node), 0, 0, NULL);
 	if (!wakeup_irq_nodes_cache)
 		goto fail_remove_group;

 	return 0;

 fail_remove_group:
 	sysfs_remove_group(kobj, &attr_group);
 fail_kobject_put:
 	kobject_put(kobj);
 fail_unregister_pm_notifier:
 	unregister_pm_notifier(&wakeup_reason_pm_notifier_block);
 fail:
 	return 1;
 }

 late_initcall(wakeup_reason_init);
	/*
	* kernel/power/wakeup_reason.c
	*
	* Logs the reasons which caused the kernel to resume from
	* the suspend mode.
	*
	* Copyright (C) 2020 Google, Inc.
	* This software is licensed under the terms of the GNU General Public
	* License version 2, as published by the Free Software Foundation, and
	* may be copied, distributed, and modified under those terms.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/

	#include <linux/wakeup_reason.h>
	#include <linux/kernel.h>
	#include <linux/irq.h>
	#include <linux/interrupt.h>
	#include <linux/io.h>
	#include <linux/kobject.h>
	#include <linux/sysfs.h>
	#include <linux/init.h>
	#include <linux/spinlock.h>
	#include <linux/notifier.h>
	#include <linux/suspend.h>
	#include <linux/slab.h>

	/*
	* struct wakeup_irq_node - stores data and relationships for IRQs logged as
	* either base or nested wakeup reasons during suspend/resume flow.
	* @siblings - for membership on leaf or parent IRQ lists
	* @irq - the IRQ number
	* @irq_name - the name associated with the IRQ, or a default if none
	*/
	struct wakeup_irq_node {
	struct list_head siblings;
	int irq;
	const char *irq_name;
	};

	enum wakeup_reason_flag {
	RESUME_NONE = 0,
	RESUME_IRQ,
	RESUME_ABORT,
	RESUME_ABNORMAL,
	};

	static DEFINE_SPINLOCK(wakeup_reason_lock);

	static LIST_HEAD(leaf_irqs); /* kept in ascending IRQ sorted order */
	static LIST_HEAD(parent_irqs); /* unordered */

	static struct kmem_cache *wakeup_irq_nodes_cache;

	static const char *default_irq_name = "(unnamed)";

	static struct kobject *kobj;

	static bool capture_reasons;
	static int wakeup_reason;
	static char non_irq_wake_reason[MAX_SUSPEND_ABORT_LEN];

	static ktime_t last_monotime; /* monotonic time before last suspend */
	static ktime_t curr_monotime; /* monotonic time after last suspend */
	static ktime_t last_stime; /* monotonic boottime offset before last suspend */
	static ktime_t curr_stime; /* monotonic boottime offset after last suspend */

	static void init_node(struct wakeup_irq_node *p, int irq)
	{
	struct irq_desc *desc;

	INIT_LIST_HEAD(&p->siblings);

	p->irq = irq;
	desc = irq_to_desc(irq);
	if (desc && desc->action && desc->action->name)
	p->irq_name = desc->action->name;
	else
	p->irq_name = default_irq_name;
	}

	static struct wakeup_irq_node *create_node(int irq)
	{
	struct wakeup_irq_node *result;

	result = kmem_cache_alloc(wakeup_irq_nodes_cache, GFP_ATOMIC);
	if (unlikely(!result))
	pr_warn("Failed to log wakeup IRQ %d\n", irq);
	else
	init_node(result, irq);

	return result;
	}

	static void delete_list(struct list_head *head)
	{
	struct wakeup_irq_node *n;

	while (!list_empty(head)) {
	n = list_first_entry(head, struct wakeup_irq_node, siblings);
	list_del(&n->siblings);
	kmem_cache_free(wakeup_irq_nodes_cache, n);
	}
	}

	static bool add_sibling_node_sorted(struct list_head *head, int irq)
	{
	struct wakeup_irq_node *n = NULL;
	struct list_head *predecessor = head;

	if (unlikely(WARN_ON(!head)))
	return NULL;

	if (!list_empty(head))
	list_for_each_entry(n, head, siblings) {
	if (n->irq < irq)
	predecessor = &n->siblings;
	else if (n->irq == irq)
	return true;
	else
	break;
	}

	n = create_node(irq);
	if (n) {
	list_add(&n->siblings, predecessor);
	return true;
	}

	return false;
	}

	static struct wakeup_irq_node find_node_in_list(struct list_head head,
	int irq)
	{
	struct wakeup_irq_node *n;

	if (unlikely(WARN_ON(!head)))
	return NULL;

	list_for_each_entry(n, head, siblings)
	if (n->irq == irq)
	return n;

	return NULL;
	}

	void log_irq_wakeup_reason(int irq)
	{
	unsigned long flags;

	spin_lock_irqsave(&wakeup_reason_lock, flags);
	if (wakeup_reason == RESUME_ABNORMAL \|\| wakeup_reason == RESUME_ABORT) {
	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	return;
	}

	if (!capture_reasons) {
	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	return;
	}

	if (find_node_in_list(&parent_irqs, irq) == NULL)
	add_sibling_node_sorted(&leaf_irqs, irq);

	wakeup_reason = RESUME_IRQ;
	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	}

	void log_threaded_irq_wakeup_reason(int irq, int parent_irq)
	{
	struct wakeup_irq_node *parent;
	unsigned long flags;

	/*
	* Intentionally unsynchronized. Calls that come in after we have
	* resumed should have a fast exit path since there's no work to be
	* done, any any coherence issue that could cause a wrong value here is
	* both highly improbable - given the set/clear timing - and very low
	* impact (parent IRQ gets logged instead of the specific child).
	*/
	if (!capture_reasons)
	return;

	spin_lock_irqsave(&wakeup_reason_lock, flags);

	if (wakeup_reason == RESUME_ABNORMAL \|\| wakeup_reason == RESUME_ABORT) {
	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	return;
	}

	if (!capture_reasons \|\| (find_node_in_list(&leaf_irqs, irq) != NULL)) {
	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	return;
	}

	parent = find_node_in_list(&parent_irqs, parent_irq);
	if (parent != NULL)
	add_sibling_node_sorted(&leaf_irqs, irq);
	else {
	parent = find_node_in_list(&leaf_irqs, parent_irq);
	if (parent != NULL) {
	list_del_init(&parent->siblings);
	list_add_tail(&parent->siblings, &parent_irqs);
	add_sibling_node_sorted(&leaf_irqs, irq);
	}
	}

	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	}
	EXPORT_SYMBOL_GPL(log_threaded_irq_wakeup_reason);

	static void __log_abort_or_abnormal_wake(bool abort, const char *fmt,
	va_list args)
	{
	unsigned long flags;

	spin_lock_irqsave(&wakeup_reason_lock, flags);

	/* Suspend abort or abnormal wake reason has already been logged. */
	if (wakeup_reason != RESUME_NONE) {
	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	return;
	}

	if (abort)
	wakeup_reason = RESUME_ABORT;
	else
	wakeup_reason = RESUME_ABNORMAL;

	vsnprintf(non_irq_wake_reason, MAX_SUSPEND_ABORT_LEN, fmt, args);

	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	}

	void log_suspend_abort_reason(const char *fmt, ...)
	{
	va_list args;

	va_start(args, fmt);
	__log_abort_or_abnormal_wake(true, fmt, args);
	va_end(args);
	}
	EXPORT_SYMBOL_GPL(log_suspend_abort_reason);

	void log_abnormal_wakeup_reason(const char *fmt, ...)
	{
	va_list args;

	va_start(args, fmt);
	__log_abort_or_abnormal_wake(false, fmt, args);
	va_end(args);
	}
	EXPORT_SYMBOL_GPL(log_abnormal_wakeup_reason);

	void clear_wakeup_reasons(void)
	{
	unsigned long flags;

	spin_lock_irqsave(&wakeup_reason_lock, flags);

	delete_list(&leaf_irqs);
	delete_list(&parent_irqs);
	wakeup_reason = RESUME_NONE;
	capture_reasons = true;

	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	}

	static void print_wakeup_sources(void)
	{
	struct wakeup_irq_node *n;
	unsigned long flags;

	spin_lock_irqsave(&wakeup_reason_lock, flags);

	capture_reasons = false;

	if (wakeup_reason == RESUME_ABORT) {
	pr_info("Abort: %s\n", non_irq_wake_reason);
	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	return;
	}

	if (wakeup_reason == RESUME_IRQ && !list_empty(&leaf_irqs))
	list_for_each_entry(n, &leaf_irqs, siblings)
	pr_info("Resume caused by IRQ %d, %s\n", n->irq,
	n->irq_name);
	else if (wakeup_reason == RESUME_ABNORMAL)
	pr_info("Resume caused by %s\n", non_irq_wake_reason);
	else
	pr_info("Resume cause unknown\n");

	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	}

	static ssize_t last_resume_reason_show(struct kobject *kobj,
	struct kobj_attribute attr, char buf)
	{
	ssize_t buf_offset = 0;
	struct wakeup_irq_node *n;
	unsigned long flags;

	spin_lock_irqsave(&wakeup_reason_lock, flags);

	if (wakeup_reason == RESUME_ABORT) {
	buf_offset = scnprintf(buf, PAGE_SIZE, "Abort: %s",
	non_irq_wake_reason);
	spin_unlock_irqrestore(&wakeup_reason_lock, flags);
	return buf_offset;
	}

	if (wakeup_reason == RESUME_IRQ && !list_empty(&leaf_irqs))
	list_for_each_entry(n, &leaf_irqs, siblings)
	buf_offset += scnprintf(buf + buf_offset,
	PAGE_SIZE - buf_offset,
	"%d %s\n", n->irq, n->irq_name);
	else if (wakeup_reason == RESUME_ABNORMAL)
	buf_offset = scnprintf(buf, PAGE_SIZE, "-1 %s",
	non_irq_wake_reason);

	spin_unlock_irqrestore(&wakeup_reason_lock, flags);

	return buf_offset;
	}

	static ssize_t last_suspend_time_show(struct kobject *kobj,
	struct kobj_attribute attr, char buf)
	{
	struct timespec64 sleep_time;
	struct timespec64 total_time;
	struct timespec64 suspend_resume_time;

	/*
	* total_time is calculated from monotonic bootoffsets because
	* unlike CLOCK_MONOTONIC it include the time spent in suspend state.
	*/
	total_time = ktime_to_timespec64(ktime_sub(curr_stime, last_stime));

	/*
	* suspend_resume_time is calculated as monotonic (CLOCK_MONOTONIC)
	* time interval before entering suspend and post suspend.
	*/
	suspend_resume_time =
	ktime_to_timespec64(ktime_sub(curr_monotime, last_monotime));

	/* sleep_time = total_time - suspend_resume_time */
	sleep_time = timespec64_sub(total_time, suspend_resume_time);

	/* Export suspend_resume_time and sleep_time in pair here. */
	return sprintf(buf, "%llu.%09lu %llu.%09lu\n",
	(unsigned long long)suspend_resume_time.tv_sec,
	suspend_resume_time.tv_nsec,
	(unsigned long long)sleep_time.tv_sec,
	sleep_time.tv_nsec);
	}

	static struct kobj_attribute resume_reason = __ATTR_RO(last_resume_reason);
	static struct kobj_attribute suspend_time = __ATTR_RO(last_suspend_time);

	static struct attribute *attrs[] = {
	&resume_reason.attr,
	&suspend_time.attr,
	NULL,
	};
	static struct attribute_group attr_group = {
	.attrs = attrs,
	};

	/* Detects a suspend and clears all the previous wake up reasons*/
	static int wakeup_reason_pm_event(struct notifier_block *notifier,
	unsigned long pm_event, void *unused)
	{
	switch (pm_event) {
	case PM_SUSPEND_PREPARE:
	/* monotonic time since boot */
	last_monotime = ktime_get();
	/* monotonic time since boot including the time spent in suspend */
	last_stime = ktime_get_boottime();
	clear_wakeup_reasons();
	break;
	case PM_POST_SUSPEND:
	/* monotonic time since boot */
	curr_monotime = ktime_get();
	/* monotonic time since boot including the time spent in suspend */
	curr_stime = ktime_get_boottime();
	print_wakeup_sources();
	break;
	default:
	break;
	}
	return NOTIFY_DONE;
	}

	static struct notifier_block wakeup_reason_pm_notifier_block = {
	.notifier_call = wakeup_reason_pm_event,
	};

	static int __init wakeup_reason_init(void)
	{
	if (register_pm_notifier(&wakeup_reason_pm_notifier_block)) {
	pr_warn("[%s] failed to register PM notifier\n", __func__);
	goto fail;
	}

	kobj = kobject_create_and_add("wakeup_reasons", kernel_kobj);
	if (!kobj) {
	pr_warn("[%s] failed to create a sysfs kobject\n", __func__);
	goto fail_unregister_pm_notifier;
	}

	if (sysfs_create_group(kobj, &attr_group)) {
	pr_warn("[%s] failed to create a sysfs group\n", __func__);
	goto fail_kobject_put;
	}

	wakeup_irq_nodes_cache =
	kmem_cache_create("wakeup_irq_node_cache",
	sizeof(struct wakeup_irq_node), 0, 0, NULL);
	if (!wakeup_irq_nodes_cache)
	goto fail_remove_group;

	return 0;

	fail_remove_group:
	sysfs_remove_group(kobj, &attr_group);
	fail_kobject_put:
	kobject_put(kobj);
	fail_unregister_pm_notifier:
	unregister_pm_notifier(&wakeup_reason_pm_notifier_block);
	fail:
	return 1;
	}

	late_initcall(wakeup_reason_init);