// SPDX-License-Identifier: GPL-2.0

#define pr_fmt(fmt) "smccc: KVM: " fmt

#include <linux/arm-smccc.h>
#include <linux/bitmap.h>
#include <linux/cache.h>
#include <linux/kernel.h>
#include <linux/memblock.h>
#include <linux/string.h>

#include <uapi/linux/psci.h>

#include <asm/hypervisor.h>

static DECLARE_BITMAP(__kvm_arm_hyp_services, ARM_SMCCC_KVM_NUM_FUNCS) __ro_after_init = { };

void __init kvm_init_hyp_services(void)
{
        uuid_t kvm_uuid = ARM_SMCCC_VENDOR_HYP_UID_KVM;
        struct arm_smccc_res res;
        u32 val[4];

        if (!arm_smccc_hypervisor_has_uuid(&kvm_uuid))
                return;

        memset(&res, 0, sizeof(res));
        arm_smccc_1_1_invoke(ARM_SMCCC_VENDOR_HYP_KVM_FEATURES_FUNC_ID, &res);

        val[0] = lower_32_bits(res.a0);
        val[1] = lower_32_bits(res.a1);
        val[2] = lower_32_bits(res.a2);
        val[3] = lower_32_bits(res.a3);

        bitmap_from_arr32(__kvm_arm_hyp_services, val, ARM_SMCCC_KVM_NUM_FUNCS);

        pr_info("hypervisor services detected (0x%08lx 0x%08lx 0x%08lx 0x%08lx)\n",
                 res.a3, res.a2, res.a1, res.a0);

        kvm_arch_init_hyp_services();
}

bool kvm_arm_hyp_service_available(u32 func_id)
{
        if (func_id >= ARM_SMCCC_KVM_NUM_FUNCS)
                return false;

        return test_bit(func_id, __kvm_arm_hyp_services);
}
EXPORT_SYMBOL_GPL(kvm_arm_hyp_service_available);

#ifdef CONFIG_ARM64
void  __init kvm_arm_target_impl_cpu_init(void)
{
        int i;
        u32 ver;
        u64 max_cpus;
        struct arm_smccc_res res;
        struct target_impl_cpu *target;

        if (!kvm_arm_hyp_service_available(ARM_SMCCC_KVM_FUNC_DISCOVER_IMPL_VER) ||
            !kvm_arm_hyp_service_available(ARM_SMCCC_KVM_FUNC_DISCOVER_IMPL_CPUS))
                return;

        arm_smccc_1_1_invoke(ARM_SMCCC_VENDOR_HYP_KVM_DISCOVER_IMPL_VER_FUNC_ID,
                             0, &res);
        if (res.a0 != SMCCC_RET_SUCCESS)
                return;

        /* Version info is in lower 32 bits and is in SMMCCC_VERSION format */
        ver = lower_32_bits(res.a1);
        if (PSCI_VERSION_MAJOR(ver) != 1) {
                pr_warn("Unsupported target CPU implementation version v%d.%d\n",
                        PSCI_VERSION_MAJOR(ver), PSCI_VERSION_MINOR(ver));
                return;
        }

        if (!res.a2) {
                pr_warn("No target implementation CPUs specified\n");
                return;
        }

        max_cpus = res.a2;
        target = memblock_alloc(sizeof(*target) * max_cpus,  __alignof__(*target));
        if (!target) {
                pr_warn("Not enough memory for struct target_impl_cpu\n");
                return;
        }

        for (i = 0; i < max_cpus; i++) {
                arm_smccc_1_1_invoke(ARM_SMCCC_VENDOR_HYP_KVM_DISCOVER_IMPL_CPUS_FUNC_ID,
                                     i, 0, 0, &res);
                if (res.a0 != SMCCC_RET_SUCCESS) {
                        pr_warn("Discovering target implementation CPUs failed\n");
                        goto mem_free;
                }
                target[i].midr = res.a1;
                target[i].revidr = res.a2;
                target[i].aidr = res.a3;
        }

        if (!cpu_errata_set_target_impl(max_cpus, target)) {
                pr_warn("Failed to set target implementation CPUs\n");
                goto mem_free;
        }

        pr_info("Number of target implementation CPUs is %lld\n", max_cpus);
        return;

mem_free:
        memblock_free(target, sizeof(*target) * max_cpus);
}
#endif