// SPDX-License-Identifier: GPL-2.0
/*
 * Support for warning track interruption
 *
 * Copyright IBM Corp. 2023
 */

#include <linux/cpu.h>
#include <linux/debugfs.h>
#include <linux/kallsyms.h>
#include <linux/smpboot.h>
#include <linux/irq.h>
#include <uapi/linux/sched/types.h>
#include <asm/debug.h>
#include <asm/diag.h>
#include <asm/sclp.h>

#define WTI_DBF_LEN 64

struct wti_debug {
	unsigned long	missed;
	unsigned long	addr;
	pid_t		pid;
};

struct wti_state {
	/* debug data for s390dbf */
	struct wti_debug	dbg;
	/*
	 * Represents the real-time thread responsible to
	 * acknowledge the warning-track interrupt and trigger
	 * preliminary and postliminary precautions.
	 */
	struct task_struct	*thread;
	/*
	 * If pending is true, the real-time thread must be scheduled.
	 * If not, a wake up of that thread will remain a noop.
	 */
	bool			pending;
};

static DEFINE_PER_CPU(struct wti_state, wti_state);

static debug_info_t *wti_dbg;

/*
 * During a warning-track grace period, interrupts are disabled
 * to prevent delays of the warning-track acknowledgment.
 *
 * Once the CPU is physically dispatched again, interrupts are
 * re-enabled.
 */

static void wti_irq_disable(void)
{
	unsigned long flags;
	struct ctlreg cr6;

	local_irq_save(flags);
	local_ctl_store(6, &cr6);
	/* disable all I/O interrupts */
	cr6.val &= ~0xff000000UL;
	local_ctl_load(6, &cr6);
	local_irq_restore(flags);
}

static void wti_irq_enable(void)
{
	unsigned long flags;
	struct ctlreg cr6;

	local_irq_save(flags);
	local_ctl_store(6, &cr6);
	/* enable all I/O interrupts */
	cr6.val |= 0xff000000UL;
	local_ctl_load(6, &cr6);
	local_irq_restore(flags);
}

static void store_debug_data(struct wti_state *st)
{
	struct pt_regs *regs = get_irq_regs();

	st->dbg.pid = current->pid;
	st->dbg.addr = 0;
	if (!user_mode(regs))
		st->dbg.addr = regs->psw.addr;
}

static void wti_interrupt(struct ext_code ext_code,
			  unsigned int param32, unsigned long param64)
{
	struct wti_state *st = this_cpu_ptr(&wti_state);

	inc_irq_stat(IRQEXT_WTI);
	wti_irq_disable();
	store_debug_data(st);
	st->pending = true;
	wake_up_process(st->thread);
}

static int wti_pending(unsigned int cpu)
{
	struct wti_state *st = per_cpu_ptr(&wti_state, cpu);

	return st->pending;
}

static void wti_dbf_grace_period(struct wti_state *st)
{
	struct wti_debug *wdi = &st->dbg;
	char buf[WTI_DBF_LEN];

	if (wdi->addr)
		snprintf(buf, sizeof(buf), "%d %pS", wdi->pid, (void *)wdi->addr);
	else
		snprintf(buf, sizeof(buf), "%d <user>", wdi->pid);
	debug_text_event(wti_dbg, 2, buf);
	wdi->missed++;
}

static int wti_show(struct seq_file *seq, void *v)
{
	struct wti_state *st;
	int cpu;

	cpus_read_lock();
	seq_puts(seq, "       ");
	for_each_online_cpu(cpu)
		seq_printf(seq, "CPU%-8d", cpu);
	seq_putc(seq, '\n');
	for_each_online_cpu(cpu) {
		st = per_cpu_ptr(&wti_state, cpu);
		seq_printf(seq, " %10lu", st->dbg.missed);
	}
	seq_putc(seq, '\n');
	cpus_read_unlock();
	return 0;
}
DEFINE_SHOW_ATTRIBUTE(wti);

static void wti_thread_fn(unsigned int cpu)
{
	struct wti_state *st = per_cpu_ptr(&wti_state, cpu);

	st->pending = false;
	/*
	 * Yield CPU voluntarily to the hypervisor. Control
	 * resumes when hypervisor decides to dispatch CPU
	 * to this LPAR again.
	 */
	if (diag49c(DIAG49C_SUBC_ACK))
		wti_dbf_grace_period(st);
	wti_irq_enable();
}

static struct smp_hotplug_thread wti_threads = {
	.store			= &wti_state.thread,
	.thread_should_run	= wti_pending,
	.thread_fn		= wti_thread_fn,
	.thread_comm		= "cpuwti/%u",
	.selfparking		= false,
};

static int __init wti_init(void)
{
	struct sched_param wti_sched_param = { .sched_priority = MAX_RT_PRIO - 1 };
	struct dentry *wti_dir;
	struct wti_state *st;
	int cpu, rc;

	rc = -EOPNOTSUPP;
	if (!sclp.has_wti)
		goto out;
	rc = smpboot_register_percpu_thread(&wti_threads);
	if (WARN_ON(rc))
		goto out;
	for_each_online_cpu(cpu) {
		st = per_cpu_ptr(&wti_state, cpu);
		sched_setscheduler(st->thread, SCHED_FIFO, &wti_sched_param);
	}
	rc = register_external_irq(EXT_IRQ_WARNING_TRACK, wti_interrupt);
	if (rc) {
		pr_warn("Couldn't request external interrupt 0x1007\n");
		goto out_thread;
	}
	irq_subclass_register(IRQ_SUBCLASS_WARNING_TRACK);
	rc = diag49c(DIAG49C_SUBC_REG);
	if (rc) {
		pr_warn("Failed to register warning track interrupt through DIAG 49C\n");
		rc = -EOPNOTSUPP;
		goto out_subclass;
	}
	wti_dir = debugfs_create_dir("wti", arch_debugfs_dir);
	debugfs_create_file("stat", 0400, wti_dir, NULL, &wti_fops);
	wti_dbg = debug_register("wti", 1, 1, WTI_DBF_LEN);
	if (!wti_dbg) {
		rc = -ENOMEM;
		goto out_debug_register;
	}
	rc = debug_register_view(wti_dbg, &debug_hex_ascii_view);
	if (rc)
		goto out_debug_register;
	goto out;
out_debug_register:
	debug_unregister(wti_dbg);
out_subclass:
	irq_subclass_unregister(IRQ_SUBCLASS_WARNING_TRACK);
	unregister_external_irq(EXT_IRQ_WARNING_TRACK, wti_interrupt);
out_thread:
	smpboot_unregister_percpu_thread(&wti_threads);
out:
	return rc;
}
late_initcall(wti_init);