// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2025 ARM Limited, All Rights Reserved.
 */
#include <linux/bitops.h>
#include <linux/bsearch.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/kvm.h>
#include <linux/kvm_host.h>
#include <kvm/iodev.h>
#include <kvm/arm_arch_timer.h>
#include <kvm/arm_vgic.h>

#include "vgic.h"
#include "vgic-mmio.h"
#include "vgic-v5-tables.h"

#define irs_caps kvm_vgic_global_state.vgic_v5_irs_caps

static struct vgic_dist *vgic_v5_get_vgic(struct kvm_vcpu *vcpu)
{
	return &vcpu->kvm->arch.vgic;
}

static struct vgic_v5_irs *vgic_v5_get_irs(struct kvm_vcpu *vcpu)
{
	return vcpu->kvm->arch.vgic.vgic_v5_irs_data;
}

static unsigned long vgic_v5_mmio_read_irs_misc(struct kvm_vcpu *vcpu,
						gpa_t addr, unsigned int len)
{
	struct vgic_v5_irs *irs = vgic_v5_get_irs(vcpu);
	const size_t offset = addr & (SZ_64K - 1);
	struct kvm_vcpu *target_vcpu;
	u8 vpe_id_bits;
	u64 value = 0;

	switch (offset) {
	case GICV5_IRS_IDR0:
		value = FIELD_PREP(GICV5_IRS_IDR0_INT_DOM, irs->idr0.domain);
		value |= FIELD_PREP(GICV5_IRS_IDR0_PA_RANGE, irs->idr0.pa_range);
		if (irs->idr0.virt)
			value |= GICV5_IRS_IDR0_VIRT;
		if (irs->idr0.setlpi)
			value |= GICV5_IRS_IDR0_SETLPI;
		if (irs->idr0.mec)
			value |= GICV5_IRS_IDR0_MEC;
		if (irs->idr0.mpam)
			value |= GICV5_IRS_IDR0_MPAM;
		if (irs->idr0.swe)
			value |= GICV5_IRS_IDR0_SWE;
		value |= FIELD_PREP(GICV5_IRS_IDR0_IRSID, irs->idr0.irs_id);
		break;
	case GICV5_IRS_IDR1:
		value = FIELD_PREP(GICV5_IRS_IDR1_PE_CNT,
				   atomic_read(&vcpu->kvm->online_vcpus));
		/*
		 * IRS_IDR1 encodes IAFFID_BITS as N - 1.
		 */
		vpe_id_bits = vgic_v5_vmte_vpe_id_bits(vcpu);
		value |= FIELD_PREP(GICV5_IRS_IDR1_IAFFID_BITS, vpe_id_bits - 1);
		value |= FIELD_PREP(GICV5_IRS_IDR1_PRIORITY_BITS, irs->idr1.priority_bits);
		break;
	case GICV5_IRS_IDR2:
		value = FIELD_PREP(GICV5_IRS_IDR2_ISTMD_SZ, irs->idr2.istmd_sz);
		if (irs->idr2.istmd)
			value |= GICV5_IRS_IDR2_ISTMD;
		value |= FIELD_PREP(GICV5_IRS_IDR2_IST_L2SZ, irs->idr2.ist_l2sz);
		if (irs->idr2.ist_levels)
			value |= GICV5_IRS_IDR2_IST_LEVELS;
		value |= FIELD_PREP(GICV5_IRS_IDR2_MIN_LPI_ID_BITS, irs->idr2.min_lpi_id_bits);
		value |= GICV5_IRS_IDR2_LPI;
		value |= FIELD_PREP(GICV5_IRS_IDR2_ID_BITS, irs->idr2.id_bits);
		break;
	case GICV5_IRS_IDR5:
		value = FIELD_PREP(GICV5_IRS_IDR5_SPI_RANGE, irs->idr5.spi_range);
		break;
	case GICV5_IRS_IDR6:
		value = FIELD_PREP(GICV5_IRS_IDR6_SPI_IRS_RANGE, irs->idr6.spi_irs_range);
		break;
	case GICV5_IRS_IDR7:
		value = FIELD_PREP(GICV5_IRS_IDR7_SPI_BASE, irs->idr7.spi_base);
		break;
	case GICV5_IRS_IIDR:
		/* Revision, Variant, ProductID are implementation defined */
		value = FIELD_PREP(GICV5_IRS_IIDR_PRODUCT_ID, PRODUCT_ID_KVM);
		value |= FIELD_PREP(GICV5_IRS_IIDR_VARIANT, 0);
		value |= FIELD_PREP(GICV5_IRS_IIDR_REVISION, 0);
		value |= FIELD_PREP(GICV5_IRS_IIDR_IMPLEMENTER, IMPLEMENTER_ARM);
		break;
	case GICV5_IRS_AIDR:
		value = FIELD_PREP(GICV5_IRS_AIDR_COMPONENT,
				   GICV5_AIDR_COMPONENT_IRS);
		value |= FIELD_PREP(GICV5_IRS_AIDR_ARCHMAJORREV,
				    GICV5_AIDR_ARCH_MAJ_REV_V5);
		value |= FIELD_PREP(GICV5_IRS_AIDR_ARCHMINORREV,
				    GICV5_AIDR_ARCH_MIN_REV_V0);
		break;
	case GICV5_IRS_CR0:
		/*
		 * The IRS is ALWAYS idle as we handle things instantaneously
		 * from a guest's viewpoint.
		 */
		value = GICV5_IRS_CR0_IDLE;
		if (READ_ONCE(vcpu->kvm->arch.vgic.enabled))
			value |= GICV5_IRS_CR0_IRSEN;
		break;
	case GICV5_IRS_CR1:
		if (irs->cr1.vped_wa)
			value |= GICV5_IRS_CR1_VPED_WA;
		if (irs->cr1.vped_ra)
			value |= GICV5_IRS_CR1_VPED_RA;
		if (irs->cr1.vmd_wa)
			value |= GICV5_IRS_CR1_VMD_WA;
		if (irs->cr1.vmd_ra)
			value |= GICV5_IRS_CR1_VMD_RA;
		if (irs->cr1.vpet_ra)
			value |= GICV5_IRS_CR1_VPET_RA;
		if (irs->cr1.vmt_ra)
			value |= GICV5_IRS_CR1_VMT_RA;
		if (irs->cr1.ist_wa)
			value |= GICV5_IRS_CR1_IST_WA;
		if (irs->cr1.ist_ra)
			value |= GICV5_IRS_CR1_IST_RA;
		value |= FIELD_PREP(GICV5_IRS_CR1_IC, irs->cr1.ic);
		value |= FIELD_PREP(GICV5_IRS_CR1_OC, irs->cr1.oc);
		value |= FIELD_PREP(GICV5_IRS_CR1_SH, irs->cr1.sh);
		break;
	case GICV5_IRS_SYNC_STATUSR:
		value = GICV5_IRS_SYNC_STATUSR_IDLE;
		break;
	case GICV5_IRS_PE_SELR:
		value = FIELD_PREP(GICV5_IRS_PE_SELR_IAFFID,
				   READ_ONCE(irs->pe_selr.iaffid));
		break;
	case GICV5_IRS_PE_STATUSR:
		/* We assume that the PE is Online if present. Always IDLE too */
		value = GICV5_IRS_PE_STATUSR_IDLE;

		/* Set ONLINE and V if IAFFID selects a present PE */
		if (kvm_get_vcpu_by_id(vcpu->kvm,
				       READ_ONCE(irs->pe_selr.iaffid))) {
			value |= GICV5_IRS_PE_STATUSR_ONLINE;
			value |= GICV5_IRS_PE_STATUSR_V;
		}
		break;
	case GICV5_IRS_PE_CR0: {
		u32 iaffid = READ_ONCE(irs->pe_selr.iaffid);

		/*
		 * Make sure that we are doing something reasonable first.
		 * Remember, the IAFFID is the same as the VPE_ID
		 */
		target_vcpu = kvm_get_vcpu_by_id(vcpu->kvm, iaffid);
		if (!target_vcpu) {
			kvm_debug("Guest programmed invalid IAFFID (0x%x) into the IRS_PE_SELR\n",
				  iaffid);
			break;
		}

		value = GICV5_IRS_PE_CR0_DPS;
		break;
	}
	default:
		return 0;
	}

	return value;
}

static void vgic_v5_mmio_write_irs_misc(struct kvm_vcpu *vcpu, gpa_t addr,
					unsigned int len, unsigned long val)
{
	struct vgic_v5_irs *irs = vgic_v5_get_irs(vcpu);
	struct vgic_dist *vgic = vgic_v5_get_vgic(vcpu);
	const size_t offset = addr & (SZ_64K - 1);

	switch (offset) {
	case GICV5_IRS_CR0:
		scoped_guard(mutex, &vcpu->kvm->arch.config_lock) {
			bool was_enabled = vgic->enabled;

			WRITE_ONCE(vgic->enabled, !!(val & GICV5_IRS_CR0_IRSEN));

			/* Reload other vCPUs on an edge */
			if (was_enabled != !!(val & GICV5_IRS_CR0_IRSEN))
				kvm_make_all_cpus_request(vcpu->kvm,
							  KVM_REQ_RELOAD_GICv5);
		}
		return;
	case GICV5_IRS_CR1:
		irs->cr1.sh = FIELD_GET(GICV5_IRS_CR1_SH, val);
		irs->cr1.oc = FIELD_GET(GICV5_IRS_CR1_OC, val);
		irs->cr1.ic = FIELD_GET(GICV5_IRS_CR1_IC, val);
		irs->cr1.ist_ra = !!(val & GICV5_IRS_CR1_IST_RA);
		irs->cr1.ist_wa = !!(val & GICV5_IRS_CR1_IST_WA);
		irs->cr1.vmt_ra = !!(val & GICV5_IRS_CR1_VMT_RA);
		irs->cr1.vpet_ra = !!(val & GICV5_IRS_CR1_VPET_RA);
		irs->cr1.vmd_ra = !!(val & GICV5_IRS_CR1_VMD_RA);
		irs->cr1.vmd_wa = !!(val & GICV5_IRS_CR1_VMD_WA);
		irs->cr1.vped_ra = !!(val & GICV5_IRS_CR1_VPED_RA);
		irs->cr1.vped_wa = !!(val & GICV5_IRS_CR1_VPED_WA);
		return;
	case GICV5_IRS_PE_SELR:
		WRITE_ONCE(irs->pe_selr.iaffid,
			   FIELD_GET(GICV5_IRS_PE_SELR_IAFFID, val));
		return;
	case GICV5_IRS_PE_CR0:
		/*
		 * We actually have nothing to do here as we don't support
		 * 1-of-N routing. The only thing that the guest can correctly
		 * write here is 0x1. However, there's no way to fault if it
		 * writes something else. This is effectively a WI in our case,
		 * but we keep it here for the purposes of documenting it.
		 */
		return;
	default:
		return;
	}
}

static bool vgic_v5_is_spi_selr_valid(struct vgic_v5_irs *irs, u32 id)
{
	/* Invalid - we don't have any SPIs at all */
	if (irs->idr5.spi_range == 0)
		return false;

	/* Invalid - we don't have any on this IRS */
	if (irs->idr6.spi_irs_range == 0)
		return false;

	/* Invalid - ID is less than min */
	if (id < irs->idr7.spi_base)
		return false;

	/* Invalid - ID is greater than max */
	if (id >= (irs->idr7.spi_base + irs->idr6.spi_irs_range))
		return false;

	return true;
}

static unsigned long vgic_v5_mmio_read_irs_spi(struct kvm_vcpu *vcpu,
					       gpa_t addr, unsigned int len)
{
	struct vgic_v5_irs *irs = vgic_v5_get_irs(vcpu);
	const size_t offset = addr & (SZ_64K - 1);
	struct vgic_irq *irq;
	u64 value = 0;

	switch (offset) {
	case GICV5_IRS_SPI_SELR:
		/* Return whatever was last written */
		value = FIELD_PREP(GICV5_IRS_SPI_SELR_ID, READ_ONCE(irs->spi_selr.id));
		break;
	case GICV5_IRS_SPI_STATUSR:
		/* We assume that we can always claim to be idle */
		value = GICV5_IRS_SPI_STATUSR_IDLE;
		if (vgic_v5_is_spi_selr_valid(irs, READ_ONCE(irs->spi_selr.id)))
			value |= GICV5_IRS_SPI_STATUSR_V;
		break;
	case GICV5_IRS_SPI_DOMAINR:
		value = FIELD_PREP(GICV5_IRS_SPI_DOMAINR_DOMAIN,
				   GICV5_IRS_SPI_DOMAINR_DOMAIN_NON_SECURE);
		break;
	case GICV5_IRS_SPI_CFGR: {
		u32 id = READ_ONCE(irs->spi_selr.id);

		if (!vgic_v5_is_spi_selr_valid(irs, id)) {
			/* Fault with IRS_SPI_SELR; return 0*/
			value = 0;
			break;
		}

		irq = vgic_get_irq(vcpu->kvm, vgic_v5_make_spi(id));
		if (!irq) {
			kvm_debug_ratelimited("Guest trying to access SPI not backed by KVM\n");
			value = 0;
			break;
		}

		scoped_guard(raw_spinlock_irqsave, &irq->irq_lock) {
			if (irq->config == VGIC_CONFIG_LEVEL)
				value = GICV5_IRS_SPI_CFGR_TM;
		}

		vgic_put_irq(vcpu->kvm, irq);

		break;
	}
	default:
		return 0;
	}

	return value;
}

static void vgic_v5_mmio_write_irs_spi(struct kvm_vcpu *vcpu, gpa_t addr,
				       unsigned int len, unsigned long val)
{
	struct vgic_v5_irs *irs = vgic_v5_get_irs(vcpu);
	const size_t offset = addr & (SZ_64K - 1);
	struct vgic_irq *irq;

	switch (offset) {
	case GICV5_IRS_SPI_SELR:
		WRITE_ONCE(irs->spi_selr.id,
			   FIELD_GET(GICV5_IRS_SPI_SELR_ID, val));
		return;
	case GICV5_IRS_SPI_CFGR: {
		u32 id = READ_ONCE(irs->spi_selr.id);

		if (!vgic_v5_is_spi_selr_valid(irs, id))
			return;

		/*
		 * Find KVM's representation of the interrupt - we need to make
		 * sure that KVM's view agrees with the guest's, else interrupt
		 * injection won't work properly for level-triggered interrupts
		 * (we fail to handle the clearing of the pending state if KVM
		 * thinks that the interrupt is edge-triggered, which is the
		 * default.)
		 */
		irq = vgic_get_irq(vcpu->kvm, vgic_v5_make_spi(id));
		if (!irq)
			return;

		scoped_guard(raw_spinlock_irqsave, &irq->irq_lock) {
			if (val & GICV5_IRS_SPI_CFGR_TM)
				irq->config = VGIC_CONFIG_LEVEL;
			else
				irq->config = VGIC_CONFIG_EDGE;
		}

		vgic_put_irq(vcpu->kvm, irq);

		return;
	}
	default:
		return;
	}
}

static bool vgic_v5_ist_cfgr_valid(struct vgic_v5_irs *irs)
{
	unsigned int expected_istsz;

	if (irs->ist_cfgr.lpi_id_bits < irs->idr2.min_lpi_id_bits ||
	    irs->ist_cfgr.lpi_id_bits > irs->idr2.id_bits)
		return false;

	if (!irs->idr2.istmd)
		expected_istsz = GICV5_IRS_IST_CFGR_ISTSZ_4;
	else if (irs->ist_cfgr.lpi_id_bits >= irs->idr2.istmd_sz)
		expected_istsz = GICV5_IRS_IST_CFGR_ISTSZ_16;
	else
		expected_istsz = GICV5_IRS_IST_CFGR_ISTSZ_8;

	if (irs->ist_cfgr.istsz != expected_istsz)
		return false;

	if (irs->ist_cfgr.structure && !irs->idr2.ist_levels)
		return false;

	if (!irs->ist_cfgr.structure)
		return true;

	return irs->ist_cfgr.l2sz == irs->idr2.ist_l2sz;
}

static u64 vgic_v5_read_irs_ist_baser(struct vgic_v5_irs *irs)
{
	u64 value;

	value = FIELD_PREP(GICV5_IRS_IST_BASER_ADDR_MASK,
			   irs->ist_baser.addr >> GICV5_IRS_IST_BASER_ADDR_SHIFT);
	if (irs->ist_baser.valid)
		value |= GICV5_IRS_IST_BASER_VALID;

	return value;
}

static bool vgic_v5_ist_cfgr_matches(const struct vgic_v5_irs *irs,
				     unsigned long val)
{
	u8 lpi_id_bits = FIELD_GET(GICV5_IRS_IST_CFGR_LPI_ID_BITS, val);
	u8 l2sz = FIELD_GET(GICV5_IRS_IST_CFGR_L2SZ, val);
	u8 istsz = FIELD_GET(GICV5_IRS_IST_CFGR_ISTSZ, val);
	bool structure = !!(val & GICV5_IRS_IST_CFGR_STRUCTURE);

	return irs->ist_cfgr.lpi_id_bits == lpi_id_bits &&
	       irs->ist_cfgr.l2sz == l2sz &&
	       irs->ist_cfgr.istsz == istsz &&
	       irs->ist_cfgr.structure == structure;
}

static unsigned long vgic_v5_mmio_read_irs_ist(struct kvm_vcpu *vcpu,
					       gpa_t addr, unsigned int len)
{
	struct vgic_v5_irs *irs = vgic_v5_get_irs(vcpu);
	const size_t offset = addr & (SZ_64K - 1);
	u64 value = 0;

	switch (offset) {
	case GICV5_IRS_IST_STATUSR:
		return GICV5_IRS_IST_STATUSR_IDLE;
	case GICV5_IRS_IST_CFGR:
		if (irs->ist_cfgr.structure)
			value |= GICV5_IRS_IST_CFGR_STRUCTURE;
		value |= FIELD_PREP(GICV5_IRS_IST_CFGR_ISTSZ, irs->ist_cfgr.istsz);
		value |= FIELD_PREP(GICV5_IRS_IST_CFGR_L2SZ, irs->ist_cfgr.l2sz);
		value |= FIELD_PREP(GICV5_IRS_IST_CFGR_LPI_ID_BITS, irs->ist_cfgr.lpi_id_bits);
		break;
	case GICV5_IRS_IST_BASER:
	case GICV5_IRS_IST_BASER + 4:
		value = vgic_v5_read_irs_ist_baser(irs);
		return extract_bytes(value, offset & 7, len);
	default:
		return 0;
	}

	return value;
}

static bool vgic_v5_ist_baser_matches(const struct vgic_v5_irs *irs,
				      unsigned long val)
{
	u64 addr = FIELD_GET(GICV5_IRS_IST_BASER_ADDR_MASK, val)
		   << GICV5_IRS_IST_BASER_ADDR_SHIFT;
	bool valid = !!(val & GICV5_IRS_IST_BASER_VALID);

	return irs->ist_baser.addr == addr && irs->ist_baser.valid == valid;
}

static void vgic_v5_update_irs_ist_baser(struct vgic_v5_irs *irs,
					 unsigned long val)
{
	irs->ist_baser.valid = !!(val & GICV5_IRS_IST_BASER_VALID);
	irs->ist_baser.addr = FIELD_GET(GICV5_IRS_IST_BASER_ADDR_MASK, val)
		<< GICV5_IRS_IST_BASER_ADDR_SHIFT;
}

static int vgic_v5_write_irs_ist_baser(struct kvm_vcpu *vcpu, unsigned long val)
{
	struct vgic_v5_irs *irs = vgic_v5_get_irs(vcpu);
	enum gicv5_vcpu_cmd cmd = LPI_VIST_MAKE_INVALID;
	bool valid = !!(val & GICV5_IRS_IST_BASER_VALID);
	int rc;

	/* The address cannot be changed while the IST is valid. */
	if (irs->ist_baser.valid && valid)
		return 0;

	/* Valid -> Invalid */
	if (irs->ist_baser.valid && !valid) {
		/* Make the LPI IST invalid and then ... */
		rc = irq_set_vcpu_affinity(vgic_v5_vpe_db(vcpu), &cmd);
		if (rc)
			return rc;

		vgic_v5_update_irs_ist_baser(irs, val);

		/*
		 * ... reflect that in the emulated BASER before freeing the
		 * host IST. If the free fails, the guest-visible valid bit
		 * still matches the hardware state.
		 */
		return vgic_v5_lpi_ist_free(vcpu->kvm);
	} else if (!irs->ist_baser.valid && valid) { /* Invalid -> Valid */
		if (!vgic_v5_ist_cfgr_valid(irs))
			return -EINVAL;

		rc = vgic_v5_lpi_ist_alloc(vcpu->kvm, irs->ist_cfgr.lpi_id_bits);
		if (rc)
			return rc;
	}

	/* Now that we've handled the edges, update the valid bit and addr */
	vgic_v5_update_irs_ist_baser(irs, val);

	return 0;
}

static void vgic_v5_mmio_write_irs_ist(struct kvm_vcpu *vcpu, gpa_t addr,
				       unsigned int len, unsigned long val)
{
	struct vgic_v5_irs *irs = vgic_v5_get_irs(vcpu);
	const size_t offset = addr & (SZ_64K - 1);

	switch (offset) {
	case GICV5_IRS_IST_CFGR:
		scoped_guard(mutex, &vcpu->kvm->arch.config_lock) {
			if (irs->ist_baser.valid)
				return;

			irs->ist_cfgr.lpi_id_bits = FIELD_GET(GICV5_IRS_IST_CFGR_LPI_ID_BITS, val);
			irs->ist_cfgr.l2sz = FIELD_GET(GICV5_IRS_IST_CFGR_L2SZ, val);
			irs->ist_cfgr.istsz = FIELD_GET(GICV5_IRS_IST_CFGR_ISTSZ, val);
			irs->ist_cfgr.structure = !!(val & GICV5_IRS_IST_CFGR_STRUCTURE);
		}
		return;
	case GICV5_IRS_IST_BASER:
	case GICV5_IRS_IST_BASER + 4: {
		scoped_guard(mutex, &vcpu->kvm->arch.config_lock) {
			u64 baser;

			baser = update_64bit_reg(vgic_v5_read_irs_ist_baser(irs),
						 offset & 4, len, val);
			vgic_v5_write_irs_ist_baser(vcpu, baser);
		}
		return;
	}
	default:
		return;
	}
}

static unsigned long vgic_v5_coresight_read(struct kvm_vcpu *vcpu,
					    gpa_t addr, unsigned int len)
{
	const size_t offset = addr & (SZ_64K - 1);

	switch (offset) {
	case GICV5_CORESIGHT_DEVARCH:
		return GICV5_CORESIGHT_DEVARCH_VAL;
	case GICV5_CORESIGHT_PIDR4:
		return GICV5_CORESIGHT_PIDR4_JEP106_CONT;
	case GICV5_CORESIGHT_PIDR5:
		return GICV5_CORESIGHT_PIDR5_RES0;
	case GICV5_CORESIGHT_PIDR6:
		return GICV5_CORESIGHT_PIDR6_RES0;
	case GICV5_CORESIGHT_PIDR7:
		return GICV5_CORESIGHT_PIDR7_RES0;
	case GICV5_CORESIGHT_PIDR0:
		return GICV5_CORESIGHT_PIDR0_PART_0;
	case GICV5_CORESIGHT_PIDR1:
		return GICV5_CORESIGHT_PIDR1_DES_0_PART_1;
	case GICV5_CORESIGHT_PIDR2:
		return GICV5_CORESIGHT_PIDR2_DES_1;
	case GICV5_CORESIGHT_PIDR3:
		return GICV5_CORESIGHT_PIDR3_REVAND_CMOD;
	case GICV5_CORESIGHT_CIDR0:
		return GICV5_CORESIGHT_CIDR0_VAL;
	case GICV5_CORESIGHT_CIDR1:
		return GICV5_CORESIGHT_CIDR1_VAL;
	case GICV5_CORESIGHT_CIDR2:
		return GICV5_CORESIGHT_CIDR2_VAL;
	case GICV5_CORESIGHT_CIDR3:
		return GICV5_CORESIGHT_CIDR3_VAL;
	default:
		return 0;
	}
}

static unsigned long vgic_v5_mmio_uaccess_read_irs_status(struct kvm_vcpu *vcpu,
							  gpa_t addr,
							  unsigned int len)
{
	const size_t offset = addr & (SZ_64K - 1);

	switch (offset) {
	case GICV5_IRS_SYNC_STATUSR:
		return GICV5_IRS_SYNC_STATUSR_IDLE;
	case GICV5_IRS_SPI_STATUSR:
		return GICV5_IRS_SPI_STATUSR_IDLE;
	case GICV5_IRS_PE_STATUSR:
		return GICV5_IRS_PE_STATUSR_IDLE;
	case GICV5_IRS_IST_STATUSR:
		return GICV5_IRS_IST_STATUSR_IDLE;
	default:
		return 0;
	}
}

static int vgic_v5_mmio_uaccess_write_irs(struct kvm_vcpu *vcpu, gpa_t addr,
					  unsigned int len, unsigned long val)
{
	struct vgic_dist *vgic = &vcpu->kvm->arch.vgic;
	struct vgic_v5_irs *irs_data = vgic->vgic_v5_irs_data;
	size_t offset = addr & (SZ_64K - 1);
	int ret;

	/*
	 * The following registers are ONLY settable via uaccesses. The guest
	 * cannot write them!
	 */

	switch (offset) {
	case GICV5_IRS_IDR0:
		if (FIELD_GET(GICV5_IRS_IDR0_INT_DOM, val) !=
		    GICV5_IRS_IDR0_INT_DOM_NON_SECURE)
			return -EINVAL;

		if ((val & GICV5_IRS_IDR0_VIRT) ||
		    (val & GICV5_IRS_IDR0_ONE_N) ||
		    (val & GICV5_IRS_IDR0_VIRT_ONE_N) ||
		    (val & GICV5_IRS_IDR0_SETLPI) ||
		    (val & GICV5_IRS_IDR0_MEC) ||
		    (val & GICV5_IRS_IDR0_MPAM) ||
		    (val & GICV5_IRS_IDR0_SWE))
			return -EINVAL;

		irs_data->idr0.domain = FIELD_GET(GICV5_IRS_IDR0_INT_DOM, val);
		irs_data->idr0.pa_range = FIELD_GET(GICV5_IRS_IDR0_PA_RANGE, val);
		irs_data->idr0.virt = !!(val & GICV5_IRS_IDR0_VIRT);
		irs_data->idr0.setlpi = !!(val & GICV5_IRS_IDR0_SETLPI);
		irs_data->idr0.mec = !!(val & GICV5_IRS_IDR0_MEC);
		irs_data->idr0.mpam = !!(val & GICV5_IRS_IDR0_MPAM);
		irs_data->idr0.swe = !!(val & GICV5_IRS_IDR0_SWE);
		irs_data->idr0.irs_id = FIELD_GET(GICV5_IRS_IDR0_IRSID, val);
		break;
	case GICV5_IRS_IDR1: {
		unsigned int iaffid_bits, priority_bits;
		u8 vpe_id_bits;

		/* Ignore writes to PE_CNT as this is populated from num vcpus */
		iaffid_bits = FIELD_GET(GICV5_IRS_IDR1_IAFFID_BITS, val);
		priority_bits = FIELD_GET(GICV5_IRS_IDR1_PRIORITY_BITS, val);

		/* IAFFID_BITS is derived from the VMTE and encoded as N - 1. */
		vpe_id_bits = vgic_v5_vmte_vpe_id_bits(vcpu);
		if (iaffid_bits != vpe_id_bits - 1)
			return -EINVAL;

		if (priority_bits > gicv5_global_data.irs_pri_bits - 1)
			return -EINVAL;

		irs_data->idr1.priority_bits = priority_bits;
		break;
	}
	case GICV5_IRS_IDR2:
		/* We always support LPIs */
		if (!(val & GICV5_IRS_IDR2_LPI))
			return -EINVAL;

		/* We only support LPIs with linear, non-metadata guest ISTs */
		if (val & GICV5_IRS_IDR2_IST_LEVELS)
			return -EINVAL;

		if ((val & GICV5_IRS_IDR2_ISTMD) ||
		    FIELD_GET(GICV5_IRS_IDR2_ISTMD_SZ, val))
			return -EINVAL;

		/* We can't present more bits than we have support for in HW */
		if (FIELD_GET(GICV5_IRS_IDR2_ID_BITS, val) >
		    vgic_v5_irs_ist_id_bits(&irs_caps))
			return -EINVAL;

		/* Min LPI ID bits must be greater than or equal to the HW */
		if (FIELD_GET(GICV5_IRS_IDR2_MIN_LPI_ID_BITS, val) <
		    vgic_v5_irs_min_lpi_id_bits(&irs_caps))
			return -EINVAL;

		if (FIELD_GET(GICV5_IRS_IDR2_MIN_LPI_ID_BITS, val) >
		    FIELD_GET(GICV5_IRS_IDR2_ID_BITS, val))
			return -EINVAL;

		irs_data->idr2.istmd_sz = FIELD_GET(GICV5_IRS_IDR2_ISTMD_SZ, val);
		irs_data->idr2.istmd = !!(val & GICV5_IRS_IDR2_ISTMD);
		irs_data->idr2.ist_l2sz = FIELD_GET(GICV5_IRS_IDR2_IST_L2SZ, val);
		irs_data->idr2.ist_levels = !!(val & GICV5_IRS_IDR2_IST_LEVELS);
		irs_data->idr2.min_lpi_id_bits = FIELD_GET(GICV5_IRS_IDR2_MIN_LPI_ID_BITS, val);
		irs_data->idr2.id_bits = FIELD_GET(GICV5_IRS_IDR2_ID_BITS, val);
		break;
	case GICV5_IRS_IDR5:
		if (FIELD_GET(GICV5_IRS_IDR5_SPI_RANGE, val) != irs_data->idr5.spi_range)
			return -EINVAL;
		break;
	case GICV5_IRS_IDR6:
		if (FIELD_GET(GICV5_IRS_IDR6_SPI_IRS_RANGE, val) != irs_data->idr6.spi_irs_range)
			return -EINVAL;
		break;
	case GICV5_IRS_IDR7:
		if (FIELD_GET(GICV5_IRS_IDR7_SPI_BASE, val) != irs_data->idr7.spi_base)
			return -EINVAL;
		break;
	case GICV5_IRS_IST_BASER:
		ret = vgic_v5_lpi_ist_exists(vcpu->kvm);
		if (ret < 0)
			return ret;

		if (ret && !vgic_v5_ist_baser_matches(irs_data, val))
			return -EINVAL;

		if (!irs_data->ist_baser.valid &&
		    (val & GICV5_IRS_IST_BASER_VALID))
			irs_data->lpi_ist_restore_pending = true;

		vgic_v5_update_irs_ist_baser(irs_data, val);
		break;
	case GICV5_IRS_IST_CFGR:
		ret = vgic_v5_lpi_ist_exists(vcpu->kvm);
		if (ret < 0)
			return ret;

		if (ret && !vgic_v5_ist_cfgr_matches(irs_data, val))
			return -EINVAL;

		irs_data->ist_cfgr.lpi_id_bits = FIELD_GET(GICV5_IRS_IST_CFGR_LPI_ID_BITS, val);
		irs_data->ist_cfgr.l2sz = FIELD_GET(GICV5_IRS_IST_CFGR_L2SZ, val);
		irs_data->ist_cfgr.istsz = FIELD_GET(GICV5_IRS_IST_CFGR_ISTSZ, val);
		irs_data->ist_cfgr.structure = !!(val & GICV5_IRS_IST_CFGR_STRUCTURE);
		break;
	case GICV5_IRS_CR0:
		vgic->enabled = !!(val & GICV5_IRS_CR0_IRSEN);
		break;
	case GICV5_IRS_SPI_CFGR:
		break;
	case GICV5_IRS_IIDR:
		fallthrough;
	case GICV5_IRS_AIDR:
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static const struct vgic_register_region vgic_v5_irs_registers[] = {
	/*
	 * This is the IRS_CONFIG_FRAME.
	 */
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_IDR0, vgic_v5_mmio_read_irs_misc,
					  vgic_mmio_write_wi, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_IDR1, vgic_v5_mmio_read_irs_misc,
					  vgic_mmio_write_wi, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_IDR2, vgic_v5_mmio_read_irs_misc,
					  vgic_mmio_write_wi, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_IDR3, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_IDR4, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_IDR5, vgic_v5_mmio_read_irs_misc,
					  vgic_mmio_write_wi, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_IDR6, vgic_v5_mmio_read_irs_misc,
					  vgic_mmio_write_wi, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_IDR7, vgic_v5_mmio_read_irs_misc,
					  vgic_mmio_write_wi, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_IIDR, vgic_v5_mmio_read_irs_misc,
					  vgic_mmio_write_wi, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_AIDR, vgic_v5_mmio_read_irs_misc,
					  vgic_mmio_write_wi, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_CR0,
					  vgic_v5_mmio_read_irs_misc,
					  vgic_v5_mmio_write_irs_misc, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_CR1, vgic_v5_mmio_read_irs_misc,
				  vgic_v5_mmio_write_irs_misc, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_SYNCR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_SYNC_STATUSR,
					  vgic_v5_mmio_read_irs_misc,
					  vgic_mmio_write_wi,
					  vgic_v5_mmio_uaccess_read_irs_status,
					  vgic_mmio_uaccess_write_wi, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_SPI_VMR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_SPI_SELR, vgic_v5_mmio_read_irs_spi,
				  vgic_v5_mmio_write_irs_spi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_SPI_DOMAINR, vgic_v5_mmio_read_irs_spi,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_SPI_RESAMPLER, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_SPI_CFGR,
					  vgic_v5_mmio_read_irs_spi,
					  vgic_v5_mmio_write_irs_spi, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_SPI_STATUSR,
					  vgic_v5_mmio_read_irs_spi,
					  vgic_mmio_write_wi,
					  vgic_v5_mmio_uaccess_read_irs_status,
					  vgic_mmio_uaccess_write_wi, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_PE_SELR,
				  vgic_v5_mmio_read_irs_misc,
				  vgic_v5_mmio_write_irs_misc, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_PE_STATUSR,
					  vgic_v5_mmio_read_irs_misc,
					  vgic_mmio_write_wi,
					  vgic_v5_mmio_uaccess_read_irs_status,
					  vgic_mmio_uaccess_write_wi, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_PE_CR0, vgic_v5_mmio_read_irs_misc,
				  vgic_v5_mmio_write_irs_misc, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_IST_BASER,
					  vgic_v5_mmio_read_irs_ist,
					  vgic_v5_mmio_write_irs_ist, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 8,
					  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_IST_CFGR,
					  vgic_v5_mmio_read_irs_ist,
					  vgic_v5_mmio_write_irs_ist, NULL,
					  vgic_v5_mmio_uaccess_write_irs, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH_UACCESS(GICV5_IRS_IST_STATUSR,
					  vgic_v5_mmio_read_irs_ist,
					  vgic_mmio_write_wi,
					  vgic_v5_mmio_uaccess_read_irs_status,
					  vgic_mmio_uaccess_write_wi, 4,
					  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_MAP_L2_ISTR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),

	/*
	 * The following registers are only for running VMs. They are not yet
	 * supported as we don't currently support nested, so expose them as
	 * read-as-zero/write-ignored.
	 */
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VMT_BASER, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VMT_CFGR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VMT_STATUSR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VPE_SELR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VPE_DBR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VPE_HPPIR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VPE_CR0, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VPE_STATUSR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VM_DBR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VM_SELR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VM_STATUSR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VMAP_L2_VMTR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VMAP_VMR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VMAP_VISTR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VMAP_L2_VISTR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_VMAP_VPER, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_SAVE_VMR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_SAVE_VM_STATUSR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),

	/* MEC, MPAM, SWERR - all unimplemented */

	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_MEC_IDR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_MEC_MECID_R, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_MPAM_IDR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_MPAM_PARTID_R, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 4, VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_SWERR_STATUSR, vgic_mmio_read_raz,
				  vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_SWERR_SYNDROMER0,
				  vgic_mmio_read_raz, vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_IRS_SWERR_SYNDROMER1,
				  vgic_mmio_read_raz, vgic_mmio_write_wi, 8,
				  VGIC_ACCESS_64bit | VGIC_ACCESS_32bit),

	/* CoreSight identification registers */
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_DEVARCH,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_PIDR4,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_PIDR5,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_PIDR6,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_PIDR7,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_PIDR0,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_PIDR1,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_PIDR2,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_PIDR3,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_CIDR0,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_CIDR1,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_CIDR2,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
	REGISTER_DESC_WITH_LENGTH(GICV5_CORESIGHT_CIDR3,
				  vgic_v5_coresight_read, vgic_mmio_write_wi, 4,
				  VGIC_ACCESS_32bit),
};

unsigned int vgic_v5_init_irs_iodev(struct vgic_io_device *dev)
{
	dev->regions = vgic_v5_irs_registers;
	dev->nr_regions = ARRAY_SIZE(vgic_v5_irs_registers);

	kvm_iodevice_init(&dev->dev, &kvm_io_gic_ops);

	/* We represent both of the IRS frames back to back, so this is 128K */
	return KVM_VGIC_V5_IRS_SIZE;
}

int vgic_v5_register_irs_iodev(struct kvm *kvm, gpa_t irs_base_address)
{
	struct vgic_io_device *io_device = &kvm->arch.vgic.vgic_v5_irs_data->iodev;
	unsigned int len;

	/*
	 * Design choice: Force MMIO region to be 64k aligned. Simplifies
	 * pulling out registers.
	 */
	if (!IS_ALIGNED(irs_base_address, SZ_64K))
		return -EINVAL;

	len = vgic_v5_init_irs_iodev(io_device);

	io_device->base_addr = irs_base_address;
	io_device->iodev_type = IODEV_GICV5_IRS;
	io_device->redist_vcpu = NULL;

	return kvm_io_bus_register_dev(kvm, KVM_MMIO_BUS, irs_base_address, len,
				       &io_device->dev);
}

/**
 * kvm_vgic_v5_irs_init: initialize the IRS data structures
 * @kvm: kvm struct pointer
 * @nr_spis: number of spis, frozen by caller
 */
int kvm_vgic_v5_irs_init(struct kvm *kvm, unsigned int nr_spis)
{
	struct vgic_dist *dist = &kvm->arch.vgic;
	struct vgic_v5_irs *irs = dist->vgic_v5_irs_data;
	struct kvm_vcpu *vcpu0 = kvm_get_vcpu(kvm, 0);
	size_t nr_spi_bits;
	u64 mmfr0;
	int ret, i;

	/*
	 * We (KVM) allocate an Interrupt State Table (IST) for SPIs. The
	 * hardware mandates that lower 6 bits of the address are 0. Each ISTE
	 * is 4 bytes in size (or larger if metadata storage is required), so 16
	 * entries would be enough for alignment. We require userspace to
	 * provide at least 32 SPIs, so we always meet alignment requirements.
	 */
	if (nr_spis) {
		dist->spis = kzalloc_objs(struct vgic_irq, nr_spis,
					  GFP_KERNEL_ACCOUNT);
		if (!dist->spis)
			return -ENOMEM;

		/*
		 * In the following code we do not take the irq struct lock since
		 * no other action on irq structs can happen while the VGIC is
		 * not initialized yet.
		 */
		for (i = 0; i < nr_spis; i++) {
			struct vgic_irq *irq = &dist->spis[i];

			irq->intid = vgic_v5_make_spi(i);
			INIT_LIST_HEAD(&irq->ap_list);
			raw_spin_lock_init(&irq->irq_lock);
			irq->vcpu = NULL;
			irq->target_vcpu = vcpu0;
			refcount_set(&irq->refcount, 0);
			/*
			 * The guest controls the enable state, and again it is
			 * directly handled by the hardware. From our point of
			 * view it is always enabled.
			 */
			irq->enabled = 1;
			vgic_v5_set_spi_ops(irq);
		}

		nr_spi_bits = fls(roundup_pow_of_two(nr_spis)) - 1;

		ret = vgic_v5_spi_ist_alloc(kvm, nr_spi_bits);
		if (ret) {
			kfree(dist->spis);
			dist->spis = NULL;
			return ret;
		}
	}

	/* Set sane initial state for the IRS MMIO registers */

	irs->idr0.domain = GICV5_IRS_IDR0_INT_DOM_NON_SECURE;

	mmfr0 = read_sanitised_ftr_reg(SYS_ID_AA64MMFR0_EL1);
	irs->idr0.pa_range = cpuid_feature_extract_unsigned_field(mmfr0,
								  ID_AA64MMFR0_EL1_PARANGE_SHIFT);

	irs->idr0.virt = 0;
	irs->idr0.setlpi = 0;
	irs->idr0.mec = 0;
	irs->idr0.mpam = 0;
	irs->idr0.swe = 0;
	irs->idr0.irs_id = 0;

	irs->idr1.priority_bits = gicv5_global_data.irs_pri_bits - 1;

	/*
	 * Support 16-bits of ID space for the IRS. This should be sufficient
	 * for most applications, and the CPUIF is guaranteed to have at least
	 * 16-bits of ID space support (we actually present 16-bits there, even
	 * if the hardware supports more). Warn if the hardware doesn't support
	 * 16 bits, and use the smaller value. YMMV!
	 *
	 * As for the minimum number of ID bits, we match the hardware's
	 * capability.
	 */
	if (vgic_v5_irs_ist_id_bits(&irs_caps) < 16)
		pr_warn_ratelimited("Host IRS supports fewer than 16 ID bits for ISTs (%u)\n",
				    vgic_v5_irs_ist_id_bits(&irs_caps));

	irs->idr2.id_bits = min(16, vgic_v5_irs_ist_id_bits(&irs_caps));
	irs->idr2.min_lpi_id_bits = vgic_v5_irs_min_lpi_id_bits(&irs_caps);

	/* Only allow the guest to create Linear ISTs - simplifies Save/Restore */
	irs->idr2.ist_levels = 0;
	irs->idr2.ist_l2sz = GICV5_IRS_IST_CFGR_L2SZ_4K;
	irs->idr2.istmd = 0;
	irs->idr2.istmd_sz = 0;

	/* We have a single IRS, only. All SPIs reside here! */
	irs->idr5.spi_range = nr_spis;
	irs->idr6.spi_irs_range = nr_spis;
	irs->idr7.spi_base = 0;

	irs->cr1.sh = 0;
	irs->cr1.oc = 0;
	irs->cr1.ic = 0;
	irs->cr1.ist_ra = 0;
	irs->cr1.ist_wa = 0;
	irs->cr1.vmt_ra = 0;
	irs->cr1.vpet_ra = 0;
	irs->cr1.vmd_ra = 0;
	irs->cr1.vmd_wa = 0;
	irs->cr1.vped_ra = 0;
	irs->cr1.vped_wa = 0;

	irs->spi_selr.id = -1;

	irs->pe_selr.iaffid = -1;

	irs->ist_cfgr.lpi_id_bits = 0;
	irs->ist_cfgr.l2sz = 0;
	irs->ist_cfgr.istsz = 0;
	irs->ist_cfgr.structure = 0;

	irs->ist_baser.valid = 0;
	irs->ist_baser.addr = 0;
	irs->lpi_ist_restore_pending = false;

	return 0;
}

int vgic_v5_irs_lpi_ist_id_bits(struct kvm *kvm, unsigned int *id_bits)
{
	struct vgic_v5_irs *irs = kvm->arch.vgic.vgic_v5_irs_data;

	if (!irs)
		return -ENXIO;

	if (!irs->ist_baser.valid)
		return 0;

	if (!vgic_v5_ist_cfgr_valid(irs))
		return -EINVAL;

	*id_bits = irs->ist_cfgr.lpi_id_bits;

	return 1;
}

int vgic_v5_has_attr_regs(struct kvm_device *dev, struct kvm_device_attr *attr)
{
	const struct vgic_register_region *region;
	struct vgic_reg_attr reg_attr;
	struct kvm_vcpu *vcpu;
	gpa_t offset;
	int ret, align;

	ret = vgic_v5_parse_attr(dev, attr, &reg_attr);
	if (ret)
		return ret;

	vcpu = reg_attr.vcpu;

	if (attr->group == KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS)
		return vgic_v5_has_cpu_sysregs_attr(vcpu, attr);

	offset = attr->attr;

	region = vgic_find_mmio_region(vgic_v5_irs_registers,
				       ARRAY_SIZE(vgic_v5_irs_registers),
				       offset);
	if (!region)
		return -ENXIO;

	align = region->access_flags & VGIC_ACCESS_64bit ? 0x7 : 0x3;
	if (offset & align)
		return -EINVAL;

	return 0;
}

/*
 * Access the IRS MMIO Regs. Relevant locks have been taken by the calling code.
 */
int vgic_v5_irs_attr_regs_access(struct kvm_device *dev,
				 struct kvm_device_attr *attr,
				 u64 *reg, bool is_write)
{
	const struct vgic_register_region *region;
	gpa_t addr, offset;
	unsigned int len;
	int align, ret = 0;

	offset = attr->attr;

	if (IS_VGIC_ADDR_UNDEF(dev->kvm->arch.vgic.vgic_v5_irs_data->vgic_v5_irs_base))
		return -ENXIO;

	region = vgic_find_mmio_region(vgic_v5_irs_registers,
				       ARRAY_SIZE(vgic_v5_irs_registers),
				       offset);
	if (!region)
		return -ENXIO;

	/*
	 * Although the spec supports upper/lower 32-bit accesses to
	 * 64-bit IRS registers, the userspace ABI requires 64-bit
	 * accesses to all 64-bit wide registers. We therefore only
	 * support 32-bit accesses to 32-bit-wide registers.
	 */
	align = region->access_flags & VGIC_ACCESS_64bit ? 0x7 : 0x3;
	len = region->access_flags & VGIC_ACCESS_64bit ? 8 : 4;

	if (offset & align)
		return -EINVAL;

	addr = dev->kvm->arch.vgic.vgic_v5_irs_data->vgic_v5_irs_base + offset;

	if (is_write) {
		if (region->uaccess_write)
			ret = region->uaccess_write(kvm_get_vcpu(dev->kvm, 0),
						    addr, len, *reg);
		else
			region->write(kvm_get_vcpu(dev->kvm, 0), addr, len, *reg);
	} else {
		if (region->uaccess_read)
			*reg = region->uaccess_read(kvm_get_vcpu(dev->kvm, 0),
						    addr, len);
		else
			*reg = region->read(kvm_get_vcpu(dev->kvm, 0), addr, len);
	}

	return ret;
}