linux/arch/loongarch/kvm/intc/dmsintc.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2025 Loongson Technology Corporation Limited
 */

#include <linux/kvm_host.h>
#include <asm/kvm_csr.h>
#include <asm/kvm_dmsintc.h>
#include <asm/kvm_vcpu.h>

void dmsintc_inject_irq(struct kvm_vcpu *vcpu)
{
	unsigned int i;
	unsigned long vector[4], old;
	struct dmsintc_state *ds = &vcpu->arch.dmsintc_state;

	if (!ds)
		return;

	for (i = 0; i < 4; i++) {
		old = atomic64_read(&(ds->vector_map[i]));
		if (old)
			vector[i] = atomic64_xchg(&(ds->vector_map[i]), 0);
	}

	if (vector[0]) {
		old = kvm_read_hw_gcsr(LOONGARCH_CSR_ISR0);
		kvm_write_hw_gcsr(LOONGARCH_CSR_ISR0, vector[0] | old);
	}

	if (vector[1]) {
		old = kvm_read_hw_gcsr(LOONGARCH_CSR_ISR1);
		kvm_write_hw_gcsr(LOONGARCH_CSR_ISR1, vector[1] | old);
	}

	if (vector[2]) {
		old = kvm_read_hw_gcsr(LOONGARCH_CSR_ISR2);
		kvm_write_hw_gcsr(LOONGARCH_CSR_ISR2, vector[2] | old);
	}

	if (vector[3]) {
		old = kvm_read_hw_gcsr(LOONGARCH_CSR_ISR3);
		kvm_write_hw_gcsr(LOONGARCH_CSR_ISR3, vector[3] | old);
	}
}

int dmsintc_deliver_msi_to_vcpu(struct kvm *kvm,
				struct kvm_vcpu *vcpu, u32 vector, int level)
{
	struct kvm_interrupt vcpu_irq;
	struct dmsintc_state *ds = &vcpu->arch.dmsintc_state;

	if (!level)
		return 0;
	if (!vcpu || vector >= 256)
		return -EINVAL;
	if (!ds)
		return -ENODEV;

	vcpu_irq.irq = INT_AVEC;
	set_bit(vector, (unsigned long *)&ds->vector_map);
	kvm_vcpu_ioctl_interrupt(vcpu, &vcpu_irq);
	kvm_vcpu_kick(vcpu);

	return 0;
}

int dmsintc_set_irq(struct kvm *kvm, u64 addr, int data, int level)
{
	unsigned int irq, cpu;
	struct kvm_vcpu *vcpu;

	irq = (addr >> AVEC_IRQ_SHIFT) & AVEC_IRQ_MASK;
	cpu = (addr >> AVEC_CPU_SHIFT) & kvm->arch.dmsintc->cpu_mask;
	if (cpu >= KVM_MAX_VCPUS)
		return -EINVAL;
	vcpu = kvm_get_vcpu_by_cpuid(kvm, cpu);
	if (!vcpu)
		return -EINVAL;

	return dmsintc_deliver_msi_to_vcpu(kvm, vcpu, irq, level);
}

static int kvm_dmsintc_ctrl_access(struct kvm_device *dev,
				   struct kvm_device_attr *attr, bool is_write)
{
	int addr = attr->attr;
	unsigned long cpu_bit, val;
	void __user *data = (void __user *)attr->addr;
	struct loongarch_dmsintc *s = dev->kvm->arch.dmsintc;

	switch (addr) {
	case KVM_DEV_LOONGARCH_DMSINTC_MSG_ADDR_BASE:
		if (is_write) {
			if (copy_from_user(&val, data, sizeof(s->msg_addr_base)))
				return -EFAULT;
			if (s->msg_addr_base)
				return -EFAULT; /* Duplicate setting are not allowed. */
			if ((val & (BIT(AVEC_CPU_SHIFT) - 1)) != 0)
				return -EINVAL;
			s->msg_addr_base = val;
			cpu_bit = find_first_bit((unsigned long *)&(s->msg_addr_base), 64) - AVEC_CPU_SHIFT;
			cpu_bit = min(cpu_bit, AVEC_CPU_BIT);
			s->cpu_mask = GENMASK(cpu_bit - 1, 0) & AVEC_CPU_MASK;
		}
		break;
	case KVM_DEV_LOONGARCH_DMSINTC_MSG_ADDR_SIZE:
		if (is_write) {
			if (copy_from_user(&val, data, sizeof(s->msg_addr_size)))
				return -EFAULT;
			if (s->msg_addr_size)
				return -EFAULT; /*Duplicate setting are not allowed. */
			s->msg_addr_size = val;
		}
		break;
	default:
		kvm_err("%s: unknown dmsintc register, addr = %d\n", __func__, addr);
		return -ENXIO;
	}

	return 0;
}

static int kvm_dmsintc_set_attr(struct kvm_device *dev,
				struct kvm_device_attr *attr)
{
	switch (attr->group) {
	case KVM_DEV_LOONGARCH_DMSINTC_GRP_CTRL:
		return kvm_dmsintc_ctrl_access(dev, attr, true);
	default:
		kvm_err("%s: unknown group (%d)\n", __func__, attr->group);
		return -EINVAL;
	}
}

static int kvm_dmsintc_create(struct kvm_device *dev, u32 type)
{
	struct kvm *kvm;
	struct loongarch_dmsintc *s;

	if (!dev) {
		kvm_err("%s: kvm_device ptr is invalid!\n", __func__);
		return -EINVAL;
	}

	kvm = dev->kvm;
	if (kvm->arch.dmsintc) {
		kvm_err("%s: LoongArch DMSINTC has already been created!\n", __func__);
		return -EINVAL;
	}

	s = kzalloc(sizeof(struct loongarch_dmsintc), GFP_KERNEL);
	if (!s)
		return -ENOMEM;

	s->kvm = kvm;
	kvm->arch.dmsintc = s;

	return 0;
}

static void kvm_dmsintc_destroy(struct kvm_device *dev)
{

	if (!dev || !dev->kvm || !dev->kvm->arch.dmsintc)
		return;

	kfree(dev->kvm->arch.dmsintc);
	kfree(dev);
}

static struct kvm_device_ops kvm_dmsintc_dev_ops = {
	.name = "kvm-loongarch-dmsintc",
	.create = kvm_dmsintc_create,
	.destroy = kvm_dmsintc_destroy,
	.set_attr = kvm_dmsintc_set_attr,
};

int kvm_loongarch_register_dmsintc_device(void)
{
	return kvm_register_device_ops(&kvm_dmsintc_dev_ops, KVM_DEV_TYPE_LOONGARCH_DMSINTC);
}