// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2011. Freescale Inc. All rights reserved.
 *
 * Authors:
 *    Alexander Graf <agraf@suse.de>
 *    Paul Mackerras <paulus@samba.org>
 *
 * Description:
 *
 * Hypercall handling for running PAPR guests in PR KVM on Book 3S
 * processors.
 */

#include <linux/anon_inodes.h>

#include <linux/uaccess.h>
#include <asm/kvm_ppc.h>
#include <asm/kvm_book3s.h>

#define HPTE_SIZE       16              /* bytes per HPT entry */

static unsigned long get_pteg_addr(struct kvm_vcpu *vcpu, long pte_index)
{
        struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);
        unsigned long pteg_addr;

        pte_index <<= 4;
        pte_index &= ((1 << ((vcpu_book3s->sdr1 & 0x1f) + 11)) - 1) << 7 | 0x70;
        pteg_addr = vcpu_book3s->sdr1 & 0xfffffffffffc0000ULL;
        pteg_addr |= pte_index;

        return pteg_addr;
}

static int kvmppc_h_pr_enter(struct kvm_vcpu *vcpu)
{
        long flags = kvmppc_get_gpr(vcpu, 4);
        long pte_index = kvmppc_get_gpr(vcpu, 5);
        __be64 pteg[2 * 8];
        __be64 *hpte;
        unsigned long pteg_addr, i;
        long int ret;

        i = pte_index & 7;
        pte_index &= ~7UL;
        pteg_addr = get_pteg_addr(vcpu, pte_index);

        mutex_lock(&vcpu->kvm->arch.hpt_mutex);
        ret = H_FUNCTION;
        if (copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg)))
                goto done;
        hpte = pteg;

        ret = H_PTEG_FULL;
        if (likely((flags & H_EXACT) == 0)) {
                for (i = 0; ; ++i) {
                        if (i == 8)
                                goto done;
                        if ((be64_to_cpu(*hpte) & HPTE_V_VALID) == 0)
                                break;
                        hpte += 2;
                }
        } else {
                hpte += i * 2;
                if (*hpte & HPTE_V_VALID)
                        goto done;
        }

        hpte[0] = cpu_to_be64(kvmppc_get_gpr(vcpu, 6));
        hpte[1] = cpu_to_be64(kvmppc_get_gpr(vcpu, 7));
        pteg_addr += i * HPTE_SIZE;
        ret = H_FUNCTION;
        if (copy_to_user((void __user *)pteg_addr, hpte, HPTE_SIZE))
                goto done;
        kvmppc_set_gpr(vcpu, 4, pte_index | i);
        ret = H_SUCCESS;

 done:
        mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
        kvmppc_set_gpr(vcpu, 3, ret);

        return EMULATE_DONE;
}

static int kvmppc_h_pr_remove(struct kvm_vcpu *vcpu)
{
        unsigned long flags= kvmppc_get_gpr(vcpu, 4);
        unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
        unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
        unsigned long v = 0, pteg, rb;
        unsigned long pte[2];
        long int ret;

        pteg = get_pteg_addr(vcpu, pte_index);
        mutex_lock(&vcpu->kvm->arch.hpt_mutex);
        ret = H_FUNCTION;
        if (copy_from_user(pte, (void __user *)pteg, sizeof(pte)))
                goto done;
        pte[0] = be64_to_cpu((__force __be64)pte[0]);
        pte[1] = be64_to_cpu((__force __be64)pte[1]);

        ret = H_NOT_FOUND;
        if ((pte[0] & HPTE_V_VALID) == 0 ||
            ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) ||
            ((flags & H_ANDCOND) && (pte[0] & avpn) != 0))
                goto done;

        ret = H_FUNCTION;
        if (copy_to_user((void __user *)pteg, &v, sizeof(v)))
                goto done;

        rb = compute_tlbie_rb(pte[0], pte[1], pte_index);
        vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);

        ret = H_SUCCESS;
        kvmppc_set_gpr(vcpu, 4, pte[0]);
        kvmppc_set_gpr(vcpu, 5, pte[1]);

 done:
        mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
        kvmppc_set_gpr(vcpu, 3, ret);

        return EMULATE_DONE;
}

/* Request defs for kvmppc_h_pr_bulk_remove() */
#define H_BULK_REMOVE_TYPE             0xc000000000000000ULL
#define   H_BULK_REMOVE_REQUEST        0x4000000000000000ULL
#define   H_BULK_REMOVE_RESPONSE       0x8000000000000000ULL
#define   H_BULK_REMOVE_END            0xc000000000000000ULL
#define H_BULK_REMOVE_CODE             0x3000000000000000ULL
#define   H_BULK_REMOVE_SUCCESS        0x0000000000000000ULL
#define   H_BULK_REMOVE_NOT_FOUND      0x1000000000000000ULL
#define   H_BULK_REMOVE_PARM           0x2000000000000000ULL
#define   H_BULK_REMOVE_HW             0x3000000000000000ULL
#define H_BULK_REMOVE_RC               0x0c00000000000000ULL
#define H_BULK_REMOVE_FLAGS            0x0300000000000000ULL
#define   H_BULK_REMOVE_ABSOLUTE       0x0000000000000000ULL
#define   H_BULK_REMOVE_ANDCOND        0x0100000000000000ULL
#define   H_BULK_REMOVE_AVPN           0x0200000000000000ULL
#define H_BULK_REMOVE_PTEX             0x00ffffffffffffffULL
#define H_BULK_REMOVE_MAX_BATCH        4

static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu)
{
        int i;
        int paramnr = 4;
        int ret = H_SUCCESS;

        mutex_lock(&vcpu->kvm->arch.hpt_mutex);
        for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) {
                unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i));
                unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1);
                unsigned long pteg, rb, flags;
                unsigned long pte[2];
                unsigned long v = 0;

                if ((tsh & H_BULK_REMOVE_TYPE) == H_BULK_REMOVE_END) {
                        break; /* Exit success */
                } else if ((tsh & H_BULK_REMOVE_TYPE) !=
                           H_BULK_REMOVE_REQUEST) {
                        ret = H_PARAMETER;
                        break; /* Exit fail */
                }

                tsh &= H_BULK_REMOVE_PTEX | H_BULK_REMOVE_FLAGS;
                tsh |= H_BULK_REMOVE_RESPONSE;

                if ((tsh & H_BULK_REMOVE_ANDCOND) &&
                    (tsh & H_BULK_REMOVE_AVPN)) {
                        tsh |= H_BULK_REMOVE_PARM;
                        kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
                        ret = H_PARAMETER;
                        break; /* Exit fail */
                }

                pteg = get_pteg_addr(vcpu, tsh & H_BULK_REMOVE_PTEX);
                if (copy_from_user(pte, (void __user *)pteg, sizeof(pte))) {
                        ret = H_FUNCTION;
                        break;
                }
                pte[0] = be64_to_cpu((__force __be64)pte[0]);
                pte[1] = be64_to_cpu((__force __be64)pte[1]);

                /* tsl = AVPN */
                flags = (tsh & H_BULK_REMOVE_FLAGS) >> 26;

                if ((pte[0] & HPTE_V_VALID) == 0 ||
                    ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != tsl) ||
                    ((flags & H_ANDCOND) && (pte[0] & tsl) != 0)) {
                        tsh |= H_BULK_REMOVE_NOT_FOUND;
                } else {
                        /* Splat the pteg in (userland) hpt */
                        if (copy_to_user((void __user *)pteg, &v, sizeof(v))) {
                                ret = H_FUNCTION;
                                break;
                        }

                        rb = compute_tlbie_rb(pte[0], pte[1],
                                              tsh & H_BULK_REMOVE_PTEX);
                        vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
                        tsh |= H_BULK_REMOVE_SUCCESS;
                        tsh |= (pte[1] & (HPTE_R_C | HPTE_R_R)) << 43;
                }
                kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
        }
        mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
        kvmppc_set_gpr(vcpu, 3, ret);

        return EMULATE_DONE;
}

static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu)
{
        unsigned long flags = kvmppc_get_gpr(vcpu, 4);
        unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
        unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
        unsigned long rb, pteg, r, v;
        unsigned long pte[2];
        long int ret;

        pteg = get_pteg_addr(vcpu, pte_index);
        mutex_lock(&vcpu->kvm->arch.hpt_mutex);
        ret = H_FUNCTION;
        if (copy_from_user(pte, (void __user *)pteg, sizeof(pte)))
                goto done;
        pte[0] = be64_to_cpu((__force __be64)pte[0]);
        pte[1] = be64_to_cpu((__force __be64)pte[1]);

        ret = H_NOT_FOUND;
        if ((pte[0] & HPTE_V_VALID) == 0 ||
            ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn))
                goto done;

        v = pte[0];
        r = pte[1];
        r &= ~(HPTE_R_PP0 | HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_HI |
               HPTE_R_KEY_LO);
        r |= (flags << 55) & HPTE_R_PP0;
        r |= (flags << 48) & HPTE_R_KEY_HI;
        r |= flags & (HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_LO);

        pte[1] = r;

        rb = compute_tlbie_rb(v, r, pte_index);
        vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
        pte[0] = (__force u64)cpu_to_be64(pte[0]);
        pte[1] = (__force u64)cpu_to_be64(pte[1]);
        ret = H_FUNCTION;
        if (copy_to_user((void __user *)pteg, pte, sizeof(pte)))
                goto done;
        ret = H_SUCCESS;

 done:
        mutex_unlock(&vcpu->kvm->arch.hpt_mutex);
        kvmppc_set_gpr(vcpu, 3, ret);

        return EMULATE_DONE;
}

static int kvmppc_h_pr_logical_ci_load(struct kvm_vcpu *vcpu)
{
        long rc;

        rc = kvmppc_h_logical_ci_load(vcpu);
        if (rc == H_TOO_HARD)
                return EMULATE_FAIL;
        kvmppc_set_gpr(vcpu, 3, rc);
        return EMULATE_DONE;
}

static int kvmppc_h_pr_logical_ci_store(struct kvm_vcpu *vcpu)
{
        long rc;

        rc = kvmppc_h_logical_ci_store(vcpu);
        if (rc == H_TOO_HARD)
                return EMULATE_FAIL;
        kvmppc_set_gpr(vcpu, 3, rc);
        return EMULATE_DONE;
}

static int kvmppc_h_pr_set_mode(struct kvm_vcpu *vcpu)
{
        unsigned long mflags = kvmppc_get_gpr(vcpu, 4);
        unsigned long resource = kvmppc_get_gpr(vcpu, 5);

        if (resource == H_SET_MODE_RESOURCE_ADDR_TRANS_MODE) {
                /* KVM PR does not provide AIL!=0 to guests */
                if (mflags == 0)
                        kvmppc_set_gpr(vcpu, 3, H_SUCCESS);
                else
                        kvmppc_set_gpr(vcpu, 3, H_UNSUPPORTED_FLAG_START - 63);
                return EMULATE_DONE;
        }
        return EMULATE_FAIL;
}

#ifdef CONFIG_SPAPR_TCE_IOMMU
static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
{
        unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
        unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
        unsigned long tce = kvmppc_get_gpr(vcpu, 6);
        long rc;

        rc = kvmppc_h_put_tce(vcpu, liobn, ioba, tce);
        if (rc == H_TOO_HARD)
                return EMULATE_FAIL;
        kvmppc_set_gpr(vcpu, 3, rc);
        return EMULATE_DONE;
}

static int kvmppc_h_pr_put_tce_indirect(struct kvm_vcpu *vcpu)
{
        unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
        unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
        unsigned long tce = kvmppc_get_gpr(vcpu, 6);
        unsigned long npages = kvmppc_get_gpr(vcpu, 7);
        long rc;

        rc = kvmppc_h_put_tce_indirect(vcpu, liobn, ioba,
                        tce, npages);
        if (rc == H_TOO_HARD)
                return EMULATE_FAIL;
        kvmppc_set_gpr(vcpu, 3, rc);
        return EMULATE_DONE;
}

static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu)
{
        unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
        unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
        unsigned long tce_value = kvmppc_get_gpr(vcpu, 6);
        unsigned long npages = kvmppc_get_gpr(vcpu, 7);
        long rc;

        rc = kvmppc_h_stuff_tce(vcpu, liobn, ioba, tce_value, npages);
        if (rc == H_TOO_HARD)
                return EMULATE_FAIL;
        kvmppc_set_gpr(vcpu, 3, rc);
        return EMULATE_DONE;
}

#else /* CONFIG_SPAPR_TCE_IOMMU */
static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
{
        return EMULATE_FAIL;
}

static int kvmppc_h_pr_put_tce_indirect(struct kvm_vcpu *vcpu)
{
        return EMULATE_FAIL;
}

static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu)
{
        return EMULATE_FAIL;
}
#endif /* CONFIG_SPAPR_TCE_IOMMU */

static int kvmppc_h_pr_xics_hcall(struct kvm_vcpu *vcpu, u32 cmd)
{
        long rc = kvmppc_xics_hcall(vcpu, cmd);
        kvmppc_set_gpr(vcpu, 3, rc);
        return EMULATE_DONE;
}

int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd)
{
        int rc, idx;

        if (cmd <= MAX_HCALL_OPCODE &&
            !test_bit(cmd/4, vcpu->kvm->arch.enabled_hcalls))
                return EMULATE_FAIL;

        switch (cmd) {
        case H_ENTER:
                return kvmppc_h_pr_enter(vcpu);
        case H_REMOVE:
                return kvmppc_h_pr_remove(vcpu);
        case H_PROTECT:
                return kvmppc_h_pr_protect(vcpu);
        case H_BULK_REMOVE:
                return kvmppc_h_pr_bulk_remove(vcpu);
        case H_PUT_TCE:
                return kvmppc_h_pr_put_tce(vcpu);
        case H_PUT_TCE_INDIRECT:
                return kvmppc_h_pr_put_tce_indirect(vcpu);
        case H_STUFF_TCE:
                return kvmppc_h_pr_stuff_tce(vcpu);
        case H_CEDE:
                kvmppc_set_msr_fast(vcpu, kvmppc_get_msr(vcpu) | MSR_EE);
                kvm_vcpu_halt(vcpu);
                vcpu->stat.generic.halt_wakeup++;
                return EMULATE_DONE;
        case H_LOGICAL_CI_LOAD:
                return kvmppc_h_pr_logical_ci_load(vcpu);
        case H_LOGICAL_CI_STORE:
                return kvmppc_h_pr_logical_ci_store(vcpu);
        case H_SET_MODE:
                return kvmppc_h_pr_set_mode(vcpu);
        case H_XIRR:
        case H_CPPR:
        case H_EOI:
        case H_IPI:
        case H_IPOLL:
        case H_XIRR_X:
                if (kvmppc_xics_enabled(vcpu))
                        return kvmppc_h_pr_xics_hcall(vcpu, cmd);
                break;
        case H_RTAS:
                if (list_empty(&vcpu->kvm->arch.rtas_tokens))
                        break;
                idx = srcu_read_lock(&vcpu->kvm->srcu);
                rc = kvmppc_rtas_hcall(vcpu);
                srcu_read_unlock(&vcpu->kvm->srcu, idx);
                if (rc)
                        break;
                kvmppc_set_gpr(vcpu, 3, 0);
                return EMULATE_DONE;
        }

        return EMULATE_FAIL;
}

int kvmppc_hcall_impl_pr(unsigned long cmd)
{
        switch (cmd) {
        case H_ENTER:
        case H_REMOVE:
        case H_PROTECT:
        case H_BULK_REMOVE:
#ifdef CONFIG_SPAPR_TCE_IOMMU
        case H_GET_TCE:
        case H_PUT_TCE:
        case H_PUT_TCE_INDIRECT:
        case H_STUFF_TCE:
#endif
        case H_CEDE:
        case H_LOGICAL_CI_LOAD:
        case H_LOGICAL_CI_STORE:
        case H_SET_MODE:
#ifdef CONFIG_KVM_XICS
        case H_XIRR:
        case H_CPPR:
        case H_EOI:
        case H_IPI:
        case H_IPOLL:
        case H_XIRR_X:
#endif
                return 1;
        }
        return 0;
}

/*
 * List of hcall numbers to enable by default.
 * For compatibility with old userspace, we enable by default
 * all hcalls that were implemented before the hcall-enabling
 * facility was added.  Note this list should not include H_RTAS.
 */
static unsigned int default_hcall_list[] = {
        H_ENTER,
        H_REMOVE,
        H_PROTECT,
        H_BULK_REMOVE,
#ifdef CONFIG_SPAPR_TCE_IOMMU
        H_GET_TCE,
        H_PUT_TCE,
#endif
        H_CEDE,
        H_SET_MODE,
#ifdef CONFIG_KVM_XICS
        H_XIRR,
        H_CPPR,
        H_EOI,
        H_IPI,
        H_IPOLL,
        H_XIRR_X,
#endif
        0
};

void kvmppc_pr_init_default_hcalls(struct kvm *kvm)
{
        int i;
        unsigned int hcall;

        for (i = 0; default_hcall_list[i]; ++i) {
                hcall = default_hcall_list[i];
                WARN_ON(!kvmppc_hcall_impl_pr(hcall));
                __set_bit(hcall / 4, kvm->arch.enabled_hcalls);
        }
}