// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2015 - ARM Ltd
 * Author: Marc Zyngier <[email protected]>
 */

#ifndef __ARM64_KVM_HYP_FAULT_H__
#define __ARM64_KVM_HYP_FAULT_H__

#include <asm/kvm_asm.h>
#include <asm/kvm_emulate.h>
#include <asm/kvm_hyp.h>
#include <asm/kvm_mmu.h>

static inline bool __fault_safe_to_translate(u64 esr)
{
	u64 fsc = esr & ESR_ELx_FSC;

	if (esr_fsc_is_sea_ttw(esr) || esr_fsc_is_secc_ttw(esr))
		return false;

	return !(fsc == ESR_ELx_FSC_EXTABT && (esr & ESR_ELx_FnV));
}

static inline bool __translate_far_to_hpfar(u64 far, u64 *hpfar)
{
	int ret;
	u64 par, tmp;

	/*
	 * Resolve the IPA the hard way using the guest VA.
	 *
	 * Stage-1 translation already validated the memory access
	 * rights. As such, we can use the EL1 translation regime, and
	 * don't have to distinguish between EL0 and EL1 access.
	 *
	 * We do need to save/restore PAR_EL1 though, as we haven't
	 * saved the guest context yet, and we may return early...
	 */
	par = read_sysreg_par();
	ret = system_supports_poe() ? __kvm_at(OP_AT_S1E1A, far) :
	                              __kvm_at(OP_AT_S1E1R, far);
	if (!ret)
		tmp = read_sysreg_par();
	else
		tmp = SYS_PAR_EL1_F; /* back to the guest */
	write_sysreg(par, par_el1);

	if (unlikely(tmp & SYS_PAR_EL1_F))
		return false; /* Translation failed, back to guest */

	/* Convert PAR to HPFAR format */
	*hpfar = PAR_TO_HPFAR(tmp);
	return true;
}

/*
 * Checks for the conditions when HPFAR_EL2 is written, per ARM ARM R_FKLWR.
 */
static inline bool __hpfar_valid(u64 esr)
{
	/*
	 * CPUs affected by ARM erratum #834220 may incorrectly report a
	 * stage-2 translation fault when a stage-1 permission fault occurs.
	 *
	 * Re-walk the page tables to determine if a stage-1 fault actually
	 * occurred.
	 */
	if (cpus_have_final_cap(ARM64_WORKAROUND_834220) &&
	    esr_fsc_is_translation_fault(esr))
		return false;

	if (esr_fsc_is_translation_fault(esr) || esr_fsc_is_access_flag_fault(esr))
		return true;

	if ((esr & ESR_ELx_S1PTW) && esr_fsc_is_permission_fault(esr))
		return true;

	return esr_fsc_is_addr_sz_fault(esr);
}

static inline bool __get_fault_info(u64 esr, struct kvm_vcpu_fault_info *fault)
{
	u64 hpfar;

	fault->far_el2		= read_sysreg_el2(SYS_FAR);
	fault->hpfar_el2	= 0;

	if (__hpfar_valid(esr))
		hpfar = read_sysreg(hpfar_el2);
	else if (unlikely(!__fault_safe_to_translate(esr)))
		return true;
	else if (!__translate_far_to_hpfar(fault->far_el2, &hpfar))
		return false;

	/*
	 * Hijack HPFAR_EL2.NS (RES0 in Non-secure) to indicate a valid
	 * HPFAR value.
	 */
	fault->hpfar_el2 = hpfar | HPFAR_EL2_NS;
	return true;
}

#endif