// SPDX-License-Identifier: GPL-2.0
/*
 *      Copyright IBM Corp. 1999, 2023
 */

#include <linux/irqflags.h>
#include <linux/spinlock.h>
#include <linux/export.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/smp.h>
#include <linux/cache.h>
#include <asm/abs_lowcore.h>
#include <asm/ctlreg.h>

/*
 * ctl_lock guards access to global control register contents which
 * are kept in the control register save area within absolute lowcore
 * at physical address zero.
 */
static DEFINE_SPINLOCK(system_ctl_lock);

void system_ctlreg_lock(void)
        __acquires(&system_ctl_lock)
{
        spin_lock(&system_ctl_lock);
}

void system_ctlreg_unlock(void)
        __releases(&system_ctl_lock)
{
        spin_unlock(&system_ctl_lock);
}

static bool system_ctlreg_area_init __ro_after_init;

void __init system_ctlreg_init_save_area(struct lowcore *lc)
{
        struct lowcore *abs_lc;

        abs_lc = get_abs_lowcore();
        __local_ctl_store(0, 15, lc->cregs_save_area);
        __local_ctl_store(0, 15, abs_lc->cregs_save_area);
        put_abs_lowcore(abs_lc);
        system_ctlreg_area_init = true;
}

struct ctlreg_parms {
        unsigned long andval;
        unsigned long orval;
        unsigned long val;
        int request;
        int cr;
};

static void ctlreg_callback(void *info)
{
        struct ctlreg_parms *pp = info;
        struct ctlreg regs[16];

        __local_ctl_store(0, 15, regs);
        if (pp->request == CTLREG_LOAD) {
                regs[pp->cr].val = pp->val;
        } else {
                regs[pp->cr].val &= pp->andval;
                regs[pp->cr].val |= pp->orval;
        }
        __local_ctl_load(0, 15, regs);
}

static void system_ctlreg_update(void *info)
{
        unsigned long flags;

        if (system_state == SYSTEM_BOOTING) {
                /*
                 * For very early calls do not call on_each_cpu()
                 * since not everything might be setup.
                 */
                local_irq_save(flags);
                ctlreg_callback(info);
                local_irq_restore(flags);
        } else {
                on_each_cpu(ctlreg_callback, info, 1);
        }
}

void system_ctlreg_modify(unsigned int cr, unsigned long data, int request)
{
        struct ctlreg_parms pp = { .cr = cr, .request = request, };
        struct lowcore *abs_lc;

        switch (request) {
        case CTLREG_SET_BIT:
                pp.orval  = 1UL << data;
                pp.andval = -1UL;
                break;
        case CTLREG_CLEAR_BIT:
                pp.orval  = 0;
                pp.andval = ~(1UL << data);
                break;
        case CTLREG_LOAD:
                pp.val = data;
                break;
        }
        if (system_ctlreg_area_init) {
                system_ctlreg_lock();
                abs_lc = get_abs_lowcore();
                if (request == CTLREG_LOAD) {
                        abs_lc->cregs_save_area[cr].val = pp.val;
                } else {
                        abs_lc->cregs_save_area[cr].val &= pp.andval;
                        abs_lc->cregs_save_area[cr].val |= pp.orval;
                }
                put_abs_lowcore(abs_lc);
                system_ctlreg_update(&pp);
                system_ctlreg_unlock();
        } else {
                system_ctlreg_update(&pp);
        }
}
EXPORT_SYMBOL(system_ctlreg_modify);