// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Copyright (c) 2019 Amlogic, Inc. All rights reserved.
 */
#include <linux/stacktrace.h>
#include <linux/export.h>
#include <linux/types.h>
#include <linux/smp.h>
#include <linux/irqflags.h>
#include <linux/sched.h>
#include <linux/moduleparam.h>
#include <linux/debugfs.h>
#include <linux/module.h>
#include <linux/uaccess.h>
#include <linux/sched/clock.h>
#include <linux/sched/debug.h>

/*isr trace*/
#define ns2ms			(1000 * 1000)
#define LONG_ISR		(500 * ns2ms)
#define LONG_SIRQ		(500 * ns2ms)
#define CHK_WINDOW		(1000 * ns2ms)
#define IRQ_MAX			256
#define CCCNT_WARN		1000
/*irq disable trace*/
#define LONG_IRQDIS		(1000 * 1000000)	/*1000 ms*/
#define OUT_WIN			(500 * 1000000)		/*500 ms*/
#define LONG_IDLE		(5000000000)		/*5 sec*/
#define ENTRY			10

/*isr trace*/
static unsigned long long t_base[IRQ_MAX];
static unsigned long long t_isr[IRQ_MAX];
static unsigned long long t_total[IRQ_MAX];
static unsigned int cnt_total[IRQ_MAX];
static void *cpu_action[NR_CPUS];
static int cpu_irq[NR_CPUS] = {0};
static void *cpu_sirq[NR_CPUS] = {NULL};
/*irq disable trace*/
static unsigned long long	t_i_d[NR_CPUS];
static int			irq_flg;
static struct stack_trace	irq_trace[NR_CPUS];
static unsigned long		t_entries[NR_CPUS][ENTRY];
static unsigned long long	t_idle[NR_CPUS] = { 0 };
static unsigned long long	t_d_out;

static unsigned long isr_thr = LONG_ISR;
static unsigned long irq_dis_thr = LONG_IRQDIS;
static unsigned long sirq_thr = LONG_SIRQ;
static int irq_check_en;
static int isr_check_en = 1;
static unsigned long out_thr = OUT_WIN;
core_param(isr_thr, isr_thr, ulong, 0644);
core_param(irq_dis_thr, irq_dis_thr, ulong, 0644);
core_param(sirq_thr, sirq_thr, ulong, 0644);
/* core_param(irq_check_en, irq_check_en, int, 0644);*/
core_param(irq_check_en_d, irq_check_en, int, 0644);
core_param(isr_check_en, isr_check_en, int, 0644);
core_param(out_thr, out_thr, ulong, 0644);

extern struct task_struct *get_current_cpu_task(int cpu);

void notrace isr_in_hook(unsigned int cpu, unsigned long long *tin,
			 unsigned int irq, void *act)
{
	if (irq >= IRQ_MAX || !isr_check_en || oops_in_progress)
		return;
	cpu_irq[cpu] = irq;
	cpu_action[cpu] = act;
	*tin = sched_clock();
	if (*tin >= CHK_WINDOW + t_base[irq]) {
		t_base[irq]	= *tin;
		t_isr[irq]	= 0;
		t_total[irq]	= 0;
		cnt_total[irq]	= 0;
	}
}

void notrace isr_out_hook(unsigned int cpu, unsigned long long tin,
			  unsigned int irq)
{
	unsigned long long tout;
	unsigned long long ratio = 0;
	unsigned long long t_diff;
	unsigned long long t_isr_tmp;
	unsigned long long t_total_tmp;

	if (!isr_check_en || oops_in_progress)
		return;
	if (irq >= IRQ_MAX || cpu_irq[cpu] <= 0)
		return;
	cpu_irq[cpu] = 0;
	tout = sched_clock();
	t_isr[irq] += (tout > tin) ? (tout - tin) : 0;
	t_total[irq] = (tout - t_base[irq]);
	cnt_total[irq]++;

	if (tout > isr_thr + tin) {
		t_diff = tout - tin;
		do_div(t_diff, ns2ms);
		pr_err("ISR_Long___ERR. irq:%d  tout-tin:%llu ms\n",
		       irq, t_diff);
	}

	if (t_total[irq] < CHK_WINDOW)
		return;

	if (t_isr[irq] * 100 >= 35 * t_total[irq]) {
		t_isr_tmp = t_isr[irq];
		do_div(t_isr_tmp, ns2ms);
		t_total_tmp = t_total[irq];
		do_div(t_total_tmp, ns2ms);
		ratio = t_isr_tmp * 100;
		do_div(ratio, t_total_tmp);
		pr_err("IRQRatio___ERR.irq:%d ratio:%llu\n", irq, ratio);
		pr_err("t_isr:%llu  t_total:%llu, cnt:%d\n",
		       t_isr_tmp, t_total_tmp, cnt_total[irq]);
	}
	t_base[irq] = sched_clock();
	t_isr[irq] = 0;
	t_total[irq] = 0;
	cnt_total[irq] = 0;
	cpu_action[cpu] = NULL;
}

void notrace sirq_in_hook(unsigned int cpu, unsigned long long *tin, void *p)
{
	cpu_sirq[cpu] = p;
	*tin = sched_clock();
}

void notrace sirq_out_hook(unsigned int cpu, unsigned long long tin, void *p)
{
	unsigned long long tout = sched_clock();
	unsigned long long t_diff;

	if (cpu_sirq[cpu] && tin && (tout > tin + sirq_thr) &&
	    !oops_in_progress) {
		t_diff = tout - tin;
		do_div(t_diff, ns2ms);
		pr_err("SIRQLong___ERR. sirq:%p  tout-tin:%llu ms\n",
		       p, t_diff);
	}
	cpu_sirq[cpu] = NULL;
}

void notrace irq_trace_start(unsigned long flags)
{
	unsigned int cpu;
	int softirq = 0;

	if (!irq_flg  || !irq_check_en || oops_in_progress)
		return;

	if (arch_irqs_disabled_flags(flags))
		return;

	cpu = get_cpu();
	put_cpu();
	softirq =  task_thread_info(current)->preempt_count & SOFTIRQ_MASK;
	if ((!current->pid && !softirq) || t_i_d[cpu] || cpu_is_offline(cpu) ||
	    (softirq_count() && !cpu_sirq[cpu]))
		return;

	memset(&irq_trace[cpu], 0, sizeof(irq_trace[cpu]));
	memset(&t_entries[cpu][0], 0, sizeof(t_entries[cpu][0]) * ENTRY);
	irq_trace[cpu].entries = &t_entries[cpu][0];
	irq_trace[cpu].max_entries = ENTRY;
	irq_trace[cpu].skip = 2;
	irq_trace[cpu].nr_entries = 0;
	t_i_d[cpu] = sched_clock();

	save_stack_trace(&irq_trace[cpu]);
}
EXPORT_SYMBOL(irq_trace_start);

void notrace irq_trace_stop(unsigned long flag)
{
	unsigned long long t_i_e, t;
	unsigned int cpu;
	int softirq = 0;
	static int out_cnt;

	if (!irq_check_en ||  !irq_flg || oops_in_progress)
		return;

	if (arch_irqs_disabled_flags(flag))
		return;

	cpu = get_cpu();
	put_cpu();
	if (!t_i_d[cpu] ||
	    !arch_irqs_disabled_flags(arch_local_save_flags())) {
		t_i_d[cpu] = 0;
		return;
	}

	t_i_e = sched_clock();
	if (t_i_e <  t_i_d[cpu]) {
		t_i_d[cpu] = 0;
		return;
	}

	t = (t_i_e - t_i_d[cpu]);
	softirq =  task_thread_info(current)->preempt_count & SOFTIRQ_MASK;

	if (!(!current->pid && !softirq) && t > irq_dis_thr && t_i_d[cpu] &&
	    !(softirq_count() && !cpu_sirq[cpu])) {
		out_cnt++;
		if (t_i_e >= t_d_out + out_thr) {
			t_d_out = t_i_e;
			do_div(t, ns2ms);
			do_div(t_i_e, ns2ms);
			do_div(t_i_d[cpu], ns2ms);
			pr_err("\n\nDisIRQ___ERR:%llu ms <%llu %llu> %d:\n",
			       t, t_i_e, t_i_d[cpu], out_cnt);
			print_stack_trace(&irq_trace[cpu], 0);
			dump_stack();
		}
	}
	t_i_d[cpu] = 0;
}
EXPORT_SYMBOL(irq_trace_stop);

int  notrace in_irq_trace(void)
{
	int cpu = get_cpu();

	put_cpu();
	return (irq_check_en  && irq_flg && t_i_d[cpu]);
}

void __attribute__((weak)) lockup_hook(int cpu)
{
}

void  notrace __arch_cpu_idle_enter(void)
{
	int cpu;

	if ((!irq_check_en ||  !irq_flg) && !isr_check_en)
		return;
	cpu = get_cpu();
	put_cpu();
	t_idle[cpu] = local_clock();
}

void  notrace __arch_cpu_idle_exit(void)
{
	int cpu;

	if ((!irq_check_en ||  !irq_flg) && !isr_check_en)
		return;
	cpu = get_cpu();
	put_cpu();
	t_idle[cpu] = 0;
}

void pr_lockup_info(int c)
{
	int cpu;
	int virq = irq_check_en;
	int visr = isr_check_en;
	unsigned long long t_idle_diff;
	unsigned long long t_idle_tmp;
	unsigned long long t_i_diff;
	unsigned long long t_i_tmp;

	irq_flg = 0;
	irq_check_en = 0;
	isr_check_en = 0;
	console_loglevel = 7;
	pr_err("\n\n\nHARDLOCKUP____ERR.CPU[%d] <irqen:%d isren%d>START\n",
	       c, virq, visr);
	for_each_online_cpu(cpu) {
		unsigned long long t_cur = sched_clock();
		struct task_struct *p = get_current_cpu_task(cpu);
		int preempt = task_thread_info(p)->preempt_count;

		pr_err("\ndump_cpu[%d] irq:%3d preempt:%x  %s\n",
		       cpu, cpu_irq[cpu], preempt,	 p->comm);
		if (preempt & HARDIRQ_MASK)
			pr_err("IRQ %ps, %x\n", cpu_action[cpu],
			       (unsigned int)(preempt & HARDIRQ_MASK));
		if (preempt & SOFTIRQ_MASK)
			pr_err("SotIRQ %ps, %x\n", cpu_sirq[cpu],
			       (unsigned int)(preempt & SOFTIRQ_MASK));

		if (t_i_d[cpu]) {
			t_i_diff = t_cur - t_i_d[cpu];
			do_div(t_i_diff, ns2ms);
			t_i_tmp = t_i_d[cpu];
			do_div(t_i_tmp, ns2ms);
			pr_err("IRQ____ERR[%d]. <%llu %llu>.\n",
			       cpu, t_i_tmp, t_i_diff);
			print_stack_trace(&irq_trace[cpu], 0);
		}
		if (t_idle[cpu] && (t_idle[cpu] > LONG_IDLE + t_cur)) {
			t_idle_diff = t_cur - t_idle[cpu];
			do_div(t_idle_diff, ns2ms);
			do_div(t_cur, ns2ms);
			t_idle_tmp = t_idle[cpu];
			do_div(t_idle_tmp, ns2ms);
			pr_err("CPU[%d] IdleLong____ERR:%llu ms <%llu %llu>\n",
			       cpu, t_idle_diff, t_cur, t_idle_tmp);
		}
		dump_cpu_task(cpu);
		lockup_hook(cpu);
	}
	pr_err("\nHARDLOCKUP____ERR.END\n\n");
}

static struct dentry *debug_lockup;
#define debug_fs(x)							\
static ssize_t x##_write(struct file *file, const char __user *userbuf,	\
				   size_t count, loff_t *ppos)		\
{									\
	char buf[20];							\
	unsigned long val;						\
	int ret;							\
	count = min_t(size_t, count, (sizeof(buf) - 1));		\
	if (copy_from_user(buf, userbuf, count))			\
		return -EFAULT;						\
	buf[count] = 0;							\
	ret = kstrtoul(buf, 0, &val);					\
	if (ret)							\
		return -1;						\
	x = (typeof(x))val;						\
	pr_info("%s:%ld\n", __func__, (unsigned long)x);		\
	return count;							\
}									\
static ssize_t x##_read(struct file *file, char __user *userbuf,	\
				 size_t count, loff_t *ppos)		\
{									\
	char buf[20];							\
	unsigned long val;						\
	ssize_t len;							\
	val = (unsigned long)x;						\
	len = snprintf(buf, sizeof(buf), "%ld\n", val);			\
	pr_info("%s:%ld\n", __func__, val);				\
	return simple_read_from_buffer(userbuf, count, ppos, buf, len);	\
}									\
static const struct file_operations x##_debug_ops = {			\
	.open		= simple_open,					\
	.read		= x##_read,					\
	.write		= x##_write,					\
}

debug_fs(isr_thr);
debug_fs(irq_dis_thr);
debug_fs(sirq_thr);
debug_fs(irq_check_en);
debug_fs(isr_check_en);
debug_fs(out_thr);

static int __init debug_lockup_init(void)
{
	debug_lockup = debugfs_create_dir("lockup", NULL);
	if (IS_ERR_OR_NULL(debug_lockup)) {
		pr_warn("failed to create debug_lockup\n");
		debug_lockup = NULL;
		return -1;
	}
	debugfs_create_file("isr_thr", S_IFREG | 0664,
			    debug_lockup, NULL, &isr_thr_debug_ops);
	debugfs_create_file("irq_dis_thr", S_IFREG | 0664,
			    debug_lockup, NULL, &irq_dis_thr_debug_ops);
	debugfs_create_file("sirq_thr", S_IFREG | 0664,
			    debug_lockup, NULL, &sirq_thr_debug_ops);
	debugfs_create_file("out_thr", S_IFREG | 0664,
			    debug_lockup, NULL, &out_thr_debug_ops);
	debugfs_create_file("isr_check_en", S_IFREG | 0664,
			    debug_lockup, NULL, &isr_check_en_debug_ops);
	debugfs_create_file("irq_check_en", S_IFREG | 0664,
			    debug_lockup, NULL, &irq_check_en_debug_ops);
	pr_err("init_lockup:%lx\n", arch_local_save_flags());
	irq_flg = 1;
	return 0;
}
late_initcall(debug_lockup_init);

MODULE_DESCRIPTION("Amlogic debug lockup module");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jianxiong Pan <jianxiong.pan@amlogic.com>");