ARK-OS/arkos/kernel/drivers/firmware/smccc/kvm_guest.c

// 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