/*
   * 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
  ", 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
  ", 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->irq,
  				n->irq_name);

  	else if (wakeup_reason == RESUME_ABNORMAL)

  		pr_info("Resume caused by %s
  ", non_irq_wake_reason);
  	else
  		pr_info("Resume cause unknown
  ");
  
  	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->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
  ",

  		       (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
  ", __func__);
  		goto fail;

  	}

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

  	}

  
  	if (sysfs_create_group(kobj, &attr_group)) {
  		pr_warn("[%s] failed to create a sysfs group
  ", __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);