// SPDX-License-Identifier: GPL-2.0
/*
 * Idle functions for s390.
 *
 * Copyright IBM Corp. 2014
 *
 * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
 */

#include <linux/kernel.h>
#include <linux/kernel_stat.h>
#include <linux/sched/stat.h>
#include <linux/notifier.h>
#include <linux/init.h>
#include <linux/cpu.h>
#include <linux/export.h>
#include <trace/events/power.h>
#include <asm/cpu_mf.h>
#include <asm/cputime.h>
#include <asm/idle.h>
#include <asm/nmi.h>
#include <asm/smp.h>

DEFINE_PER_CPU(struct s390_idle_data, s390_idle);

static __always_inline void __account_idle_time_irq(void)
{
	struct s390_idle_data *idle = this_cpu_ptr(&s390_idle);
	unsigned long idle_time;

	idle_time = idle->clock_idle_exit.tod - idle->clock_idle_enter.tod;
	account_idle_time(cputime_to_nsecs(idle_time));
}

static __always_inline void __account_idle_time_setup(void)
{
	struct s390_idle_data *idle = this_cpu_ptr(&s390_idle);

	store_tod_clock_ext(&idle->clock_idle_enter);
	idle->timer_idle_enter = get_cpu_timer();
	idle->clock_idle_exit = idle->clock_idle_enter;
}

#ifdef CONFIG_NO_HZ_COMMON

static u64 arch_cpu_in_idle_time(int cpu)
{
	struct s390_idle_data *idle = &per_cpu(s390_idle, cpu);
	union tod_clock now;
	u64 idle_time;

	if (!idle->in_idle)
		return 0;
	store_tod_clock_ext(&now);
	if (tod_after(idle->clock_idle_exit.tod, idle->clock_idle_enter.tod))
		idle_time = idle->clock_idle_exit.tod - idle->clock_idle_enter.tod;
	else
		idle_time = now.tod - idle->clock_idle_enter.tod;
	return cputime_to_nsecs(idle_time);
}

static u64 arch_cpu_idle_time(int cpu, enum cpu_usage_stat idx, bool compute_delta)
{
	struct kernel_cpustat *kc = &kcpustat_cpu(cpu);
	u64 *cpustat = kc->cpustat;
	unsigned int seq;
	u64 idle_time;

	/*
	 * The open coded seqcount writer in entry.S relies on the
	 * raw counting mechanism without any writer protection.
	 */
	typecheck(typeof(kc->idle_sleeptime_seq), seqcount_t);
	do {
		seq = read_seqcount_begin(&kc->idle_sleeptime_seq);
		idle_time = cpustat[idx];
		if (compute_delta)
			idle_time += arch_cpu_in_idle_time(cpu);
	} while (read_seqcount_retry(&kc->idle_sleeptime_seq, seq));
	return idle_time;
}

u64 arch_kcpustat_field_idle(int cpu)
{
	return arch_cpu_idle_time(cpu, CPUTIME_IDLE, !nr_iowait_cpu(cpu));
}
EXPORT_SYMBOL_GPL(arch_kcpustat_field_idle);

u64 arch_kcpustat_field_iowait(int cpu)
{
	return arch_cpu_idle_time(cpu, CPUTIME_IOWAIT, nr_iowait_cpu(cpu));
}
EXPORT_SYMBOL_GPL(arch_kcpustat_field_iowait);

void account_idle_time_irq(void)
{
	struct s390_idle_data *idle = this_cpu_ptr(&s390_idle);
	struct kernel_cpustat *kc = kcpustat_this_cpu;

	write_seqcount_begin(&kc->idle_sleeptime_seq);
	idle->in_idle = false;
	__account_idle_time_irq();
	write_seqcount_end(&kc->idle_sleeptime_seq);
}

static __always_inline void account_idle_time_setup(void)
{
	struct s390_idle_data *idle = this_cpu_ptr(&s390_idle);
	struct kernel_cpustat *kc = kcpustat_this_cpu;

	raw_write_seqcount_begin(&kc->idle_sleeptime_seq);
	idle->in_idle = true;
	__account_idle_time_setup();
	raw_write_seqcount_end(&kc->idle_sleeptime_seq);
}

#else  /* CONFIG_NO_HZ_COMMON */

void account_idle_time_irq(void)
{
	__account_idle_time_irq();
}

static __always_inline void account_idle_time_setup(void)
{
	__account_idle_time_setup();
}

#endif /* CONFIG_NO_HZ_COMMON */

void noinstr arch_cpu_idle(void)
{
	struct s390_idle_data *idle = this_cpu_ptr(&s390_idle);
	unsigned long psw_mask;

	/* Wait for external, I/O or machine check interrupt. */
	psw_mask = PSW_KERNEL_BITS | PSW_MASK_WAIT |
		   PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
	clear_cpu_flag(CIF_NOHZ_DELAY);
	set_cpu_flag(CIF_ENABLED_WAIT);
	if (smp_cpu_mtid)
		stcctm(MT_DIAG, smp_cpu_mtid, (u64 *)&idle->mt_cycles_enter);
	account_idle_time_setup();
	bpon();
	__load_psw_mask(psw_mask);
}

void arch_cpu_idle_enter(void)
{
}

void arch_cpu_idle_exit(void)
{
}

void __noreturn arch_cpu_idle_dead(void)
{
	cpu_die();
}