diff --git a/arch/loongarch/include/asm/kvm_extioi.h b/arch/loongarch/include/asm/kvm_eiointc.h similarity index 38% rename from arch/loongarch/include/asm/kvm_extioi.h rename to arch/loongarch/include/asm/kvm_eiointc.h index 96fbf061cd125969a6723e69dd597f5c1ecfd99e..780c19acc35a47c78d93274e07da2200fcdec552 100644 --- a/arch/loongarch/include/asm/kvm_extioi.h +++ b/arch/loongarch/include/asm/kvm_eiointc.h @@ -3,36 +3,36 @@ * Copyright (C) 2024 Loongson Technology Corporation Limited */ -#ifndef LOONGARCH_EXTIOI_H -#define LOONGARCH_EXTIOI_H +#ifndef LOONGARCH_EIOINTC_H +#define LOONGARCH_EIOINTC_H #include -#define EXTIOI_IRQS 256 -#define EXTIOI_ROUTE_MAX_VCPUS 256 -#define EXTIOI_IRQS_U8_NUMS (EXTIOI_IRQS / 8) -#define EXTIOI_IRQS_U32_NUMS (EXTIOI_IRQS_U8_NUMS / 4) -#define EXTIOI_IRQS_U64_NUMS (EXTIOI_IRQS_U32_NUMS / 2) +#define EIOINTC_IRQS 256 +#define EIOINTC_ROUTE_MAX_VCPUS 256 +#define EIOINTC_IRQS_U8_NUMS (EIOINTC_IRQS / 8) +#define EIOINTC_IRQS_U32_NUMS (EIOINTC_IRQS_U8_NUMS / 4) +#define EIOINTC_IRQS_U64_NUMS (EIOINTC_IRQS_U32_NUMS / 2) /* map to ipnum per 32 irqs */ -#define EXTIOI_IRQS_NODETYPE_COUNT 16 - -#define EXTIOI_BASE 0x1400 -#define EXTIOI_SIZE 0x900 - -#define EXTIOI_NODETYPE_START 0xa0 -#define EXTIOI_NODETYPE_END 0xbf -#define EXTIOI_IPMAP_START 0xc0 -#define EXTIOI_IPMAP_END 0xc7 -#define EXTIOI_ENABLE_START 0x200 -#define EXTIOI_ENABLE_END 0x21f -#define EXTIOI_BOUNCE_START 0x280 -#define EXTIOI_BOUNCE_END 0x29f -#define EXTIOI_ISR_START 0x300 -#define EXTIOI_ISR_END 0x31f -#define EXTIOI_COREISR_START 0x400 -#define EXTIOI_COREISR_END 0x41f -#define EXTIOI_COREMAP_START 0x800 -#define EXTIOI_COREMAP_END 0x8ff +#define EIOINTC_IRQS_NODETYPE_COUNT 16 + +#define EIOINTC_BASE 0x1400 +#define EIOINTC_SIZE 0x900 + +#define EIOINTC_NODETYPE_START 0xa0 +#define EIOINTC_NODETYPE_END 0xbf +#define EIOINTC_IPMAP_START 0xc0 +#define EIOINTC_IPMAP_END 0xc7 +#define EIOINTC_ENABLE_START 0x200 +#define EIOINTC_ENABLE_END 0x21f +#define EIOINTC_BOUNCE_START 0x280 +#define EIOINTC_BOUNCE_END 0x29f +#define EIOINTC_ISR_START 0x300 +#define EIOINTC_ISR_END 0x31f +#define EIOINTC_COREISR_START 0x400 +#define EIOINTC_COREISR_END 0x41f +#define EIOINTC_COREMAP_START 0x800 +#define EIOINTC_COREMAP_END 0x8ff #define EIOINTC_VIRT_BASE (0x40000000) #define EIOINTC_VIRT_SIZE (0x1000) @@ -53,9 +53,9 @@ #define LS3A_INTC_IP 8 -#define EXTIOI_SW_COREMAP_FLAG (1 << 0) +#define EIOINTC_SW_COREMAP_FLAG (1 << 0) -struct loongarch_extioi { +struct loongarch_eiointc { spinlock_t lock; struct kvm *kvm; struct kvm_io_device device; @@ -66,53 +66,53 @@ struct loongarch_extioi { /* hardware state */ union nodetype { - u64 reg_u64[EXTIOI_IRQS_NODETYPE_COUNT / 4]; - u32 reg_u32[EXTIOI_IRQS_NODETYPE_COUNT / 2]; - uint16_t reg_u16[EXTIOI_IRQS_NODETYPE_COUNT]; - u8 reg_u8[EXTIOI_IRQS_NODETYPE_COUNT * 2]; + u64 reg_u64[EIOINTC_IRQS_NODETYPE_COUNT / 4]; + u32 reg_u32[EIOINTC_IRQS_NODETYPE_COUNT / 2]; + uint16_t reg_u16[EIOINTC_IRQS_NODETYPE_COUNT]; + u8 reg_u8[EIOINTC_IRQS_NODETYPE_COUNT * 2]; } nodetype; /* one bit shows the state of one irq */ union bounce { - u64 reg_u64[EXTIOI_IRQS_U64_NUMS]; - u32 reg_u32[EXTIOI_IRQS_U32_NUMS]; - u8 reg_u8[EXTIOI_IRQS_U8_NUMS]; + u64 reg_u64[EIOINTC_IRQS_U64_NUMS]; + u32 reg_u32[EIOINTC_IRQS_U32_NUMS]; + u8 reg_u8[EIOINTC_IRQS_U8_NUMS]; } bounce; union isr { - u64 reg_u64[EXTIOI_IRQS_U64_NUMS]; - u32 reg_u32[EXTIOI_IRQS_U32_NUMS]; - u8 reg_u8[EXTIOI_IRQS_U8_NUMS]; + u64 reg_u64[EIOINTC_IRQS_U64_NUMS]; + u32 reg_u32[EIOINTC_IRQS_U32_NUMS]; + u8 reg_u8[EIOINTC_IRQS_U8_NUMS]; } isr; union coreisr { - u64 reg_u64[EXTIOI_ROUTE_MAX_VCPUS][EXTIOI_IRQS_U64_NUMS]; - u32 reg_u32[EXTIOI_ROUTE_MAX_VCPUS][EXTIOI_IRQS_U32_NUMS]; - u8 reg_u8[EXTIOI_ROUTE_MAX_VCPUS][EXTIOI_IRQS_U8_NUMS]; + u64 reg_u64[EIOINTC_ROUTE_MAX_VCPUS][EIOINTC_IRQS_U64_NUMS]; + u32 reg_u32[EIOINTC_ROUTE_MAX_VCPUS][EIOINTC_IRQS_U32_NUMS]; + u8 reg_u8[EIOINTC_ROUTE_MAX_VCPUS][EIOINTC_IRQS_U8_NUMS]; } coreisr; union enable { - u64 reg_u64[EXTIOI_IRQS_U64_NUMS]; - u32 reg_u32[EXTIOI_IRQS_U32_NUMS]; - u8 reg_u8[EXTIOI_IRQS_U8_NUMS]; + u64 reg_u64[EIOINTC_IRQS_U64_NUMS]; + u32 reg_u32[EIOINTC_IRQS_U32_NUMS]; + u8 reg_u8[EIOINTC_IRQS_U8_NUMS]; } enable; /* use one byte to config ipmap for 32 irqs at once */ union ipmap { u64 reg_u64; - u32 reg_u32[EXTIOI_IRQS_U32_NUMS / 4]; - u8 reg_u8[EXTIOI_IRQS_U8_NUMS / 4]; + u32 reg_u32[EIOINTC_IRQS_U32_NUMS / 4]; + u8 reg_u8[EIOINTC_IRQS_U8_NUMS / 4]; } ipmap; /* use one byte to config coremap for one irq */ union coremap { - u64 reg_u64[EXTIOI_IRQS / 8]; - u32 reg_u32[EXTIOI_IRQS / 4]; - u8 reg_u8[EXTIOI_IRQS]; + u64 reg_u64[EIOINTC_IRQS / 8]; + u32 reg_u32[EIOINTC_IRQS / 4]; + u8 reg_u8[EIOINTC_IRQS]; } coremap; - DECLARE_BITMAP(sw_coreisr[EXTIOI_ROUTE_MAX_VCPUS][LS3A_INTC_IP], EXTIOI_IRQS); - uint8_t sw_coremap[EXTIOI_IRQS]; + DECLARE_BITMAP(sw_coreisr[EIOINTC_ROUTE_MAX_VCPUS][LS3A_INTC_IP], EIOINTC_IRQS); + uint8_t sw_coremap[EIOINTC_IRQS]; }; -void extioi_set_irq(struct loongarch_extioi *s, int irq, int level); -int kvm_loongarch_register_extioi_device(void); -int kvm_loongarch_reset_extioi(struct kvm *kvm); -#endif /* LOONGARCH_EXTIOI_H */ +void eiointc_set_irq(struct loongarch_eiointc *s, int irq, int level); +int kvm_loongarch_register_eiointc_device(void); +int kvm_loongarch_reset_eiointc(struct kvm *kvm); +#endif /* LOONGARCH_EIOINTC_H */ diff --git a/arch/loongarch/include/asm/kvm_host.h b/arch/loongarch/include/asm/kvm_host.h index 4da029a93c68a7b8a9cda78216c641a85f583093..fabe0fe765bc85b9edffee31bf3a71de5933e235 100644 --- a/arch/loongarch/include/asm/kvm_host.h +++ b/arch/loongarch/include/asm/kvm_host.h @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include /* Loongarch KVM register ids */ @@ -54,8 +54,8 @@ struct kvm_vm_stat { u64 hugepages; u64 ipi_read_exits; u64 ipi_write_exits; - u64 extioi_read_exits; - u64 extioi_write_exits; + u64 eiointc_read_exits; + u64 eiointc_write_exits; u64 pch_pic_read_exits; u64 pch_pic_write_exits; }; @@ -98,7 +98,7 @@ struct kvm_world_switch { * * For LOONGARCH_CSR_CPUID register, max CPUID size if 512 * For IPI hardware, max destination CPUID size 1024 - * For extioi interrupt controller, max destination CPUID size is 256 + * For eiointc interrupt controller, max destination CPUID size is 256 * For msgint interrupt controller, max supported CPUID size is 65536 * * Currently max CPUID is defined as 256 for KVM hypervisor, in future @@ -132,7 +132,7 @@ struct kvm_arch { s64 time_offset; struct kvm_context __percpu *vmcs; struct loongarch_ipi *ipi; - struct loongarch_extioi *extioi; + struct loongarch_eiointc *eiointc; struct loongarch_pch_pic *pch_pic; }; diff --git a/arch/loongarch/include/asm/kvm_pch_pic.h b/arch/loongarch/include/asm/kvm_pch_pic.h index f880698e2ed2cb1feded3d8f86ace46da544e0ae..48d84ab091c7b912bb61c6df0144b4bf384e1f16 100644 --- a/arch/loongarch/include/asm/kvm_pch_pic.h +++ b/arch/loongarch/include/asm/kvm_pch_pic.h @@ -51,8 +51,8 @@ struct loongarch_pch_pic { uint64_t irr; /* interrupt request register */ uint64_t isr; /* interrupt service register */ uint64_t polarity; /* 0: high level trigger, 1: low level trigger */ - uint8_t route_entry[64]; /* default value 0, route to int0: extioi */ - uint8_t htmsi_vector[64]; /* irq route table for routing to extioi */ + uint8_t route_entry[64]; /* default value 0, route to int0: eiointc */ + uint8_t htmsi_vector[64]; /* irq route table for routing to eiointc */ }; void pch_pic_set_irq(struct loongarch_pch_pic *s, int irq, int level); diff --git a/arch/loongarch/kvm/Makefile b/arch/loongarch/kvm/Makefile index f363e4b6fcf35ae6e615a40555ec6e744fa84687..40ee9ed365fa00cb665bd9b73538082547bcd3c9 100644 --- a/arch/loongarch/kvm/Makefile +++ b/arch/loongarch/kvm/Makefile @@ -19,7 +19,7 @@ kvm-y += tlb.o kvm-y += vcpu.o kvm-y += vm.o kvm-y += intc/ipi.o -kvm-y += intc/extioi.o +kvm-y += intc/eiointc.o kvm-y += intc/pch_pic.o kvm-y += irqfd.o diff --git a/arch/loongarch/kvm/intc/extioi.c b/arch/loongarch/kvm/intc/eiointc.c similarity index 57% rename from arch/loongarch/kvm/intc/extioi.c rename to arch/loongarch/kvm/intc/eiointc.c index 8b3ba649fb68fa18f69ac892730bc4d419c70fae..5e467bf8391a34ab0674d597fa1e40e8f58d28a8 100644 --- a/arch/loongarch/kvm/intc/extioi.c +++ b/arch/loongarch/kvm/intc/eiointc.c @@ -3,14 +3,14 @@ * Copyright (C) 2024 Loongson Technology Corporation Limited */ -#include +#include #include #include #define loongarch_ext_irq_lock(s, flags) spin_lock_irqsave(&s->lock, flags) #define loongarch_ext_irq_unlock(s, flags) spin_unlock_irqrestore(&s->lock, flags) -static void extioi_update_irq(struct loongarch_extioi *s, int irq, int level) +static void eiointc_update_irq(struct loongarch_eiointc *s, int irq, int level) { unsigned long found; u8 ipnum, cpu, irq_index; @@ -18,7 +18,7 @@ static void extioi_update_irq(struct loongarch_extioi *s, int irq, int level) struct kvm_interrupt vcpu_irq; struct kvm_vcpu *vcpu; - if (irq >= EXTIOI_IRQS) + if (irq >= EIOINTC_IRQS) return; ipnum = s->ipmap.reg_u8[irq / 32]; @@ -44,15 +44,15 @@ static void extioi_update_irq(struct loongarch_extioi *s, int irq, int level) if (((s->enable.reg_u32[irq_index]) & irq_mask) == 0) return; s->coreisr.reg_u32[cpu][irq_index] |= irq_mask; - found = find_first_bit(s->sw_coreisr[cpu][ipnum], EXTIOI_IRQS); + found = find_first_bit(s->sw_coreisr[cpu][ipnum], EIOINTC_IRQS); set_bit(irq, s->sw_coreisr[cpu][ipnum]); } else { s->coreisr.reg_u32[cpu][irq_index] &= ~irq_mask; clear_bit(irq, s->sw_coreisr[cpu][ipnum]); - found = find_first_bit(s->sw_coreisr[cpu][ipnum], EXTIOI_IRQS); + found = find_first_bit(s->sw_coreisr[cpu][ipnum], EIOINTC_IRQS); } - if (found < EXTIOI_IRQS) + if (found < EIOINTC_IRQS) /* other irq is handling, need not update parent irq level */ return; @@ -60,13 +60,13 @@ static void extioi_update_irq(struct loongarch_extioi *s, int irq, int level) kvm_vcpu_ioctl_interrupt(vcpu, &vcpu_irq); } -static void extioi_set_sw_coreisr(struct loongarch_extioi *s) +static void eiointc_set_sw_coreisr(struct loongarch_eiointc *s) { u32 irq_mask, irq; u8 ipnum, cpu, irq_index; struct kvm_vcpu *vcpu; - for (irq = 0; irq < EXTIOI_IRQS; irq++) { + for (irq = 0; irq < EIOINTC_IRQS; irq++) { ipnum = s->ipmap.reg_u8[irq / 32]; if (!(s->status & BIT(EIOINTC_ENABLE_INT_ENCODE))) { ipnum = count_trailing_zeros(ipnum); @@ -95,7 +95,7 @@ static void extioi_set_sw_coreisr(struct loongarch_extioi *s) } } -void extioi_set_irq(struct loongarch_extioi *s, int irq, int level) +void eiointc_set_irq(struct loongarch_eiointc *s, int irq, int level) { unsigned long *isr = (unsigned long *)s->isr.reg_u8; unsigned long flags; @@ -104,11 +104,11 @@ void extioi_set_irq(struct loongarch_extioi *s, int irq, int level) if (!level) return; loongarch_ext_irq_lock(s, flags); - extioi_update_irq(s, irq, level); + eiointc_update_irq(s, irq, level); loongarch_ext_irq_unlock(s, flags); } -static inline void extioi_enable_irq(struct loongarch_extioi *s, +static inline void eiointc_enable_irq(struct loongarch_eiointc *s, int index, u8 mask, int level) { u8 val; @@ -121,13 +121,13 @@ static inline void extioi_enable_irq(struct loongarch_extioi *s, * enable bit change from 0 to 1, * need to update irq by pending bits */ - extioi_update_irq(s, irq - 1 + index * 8, level); + eiointc_update_irq(s, irq - 1 + index * 8, level); val &= ~(1 << (irq - 1)); irq = ffs(val); } } -static inline void extioi_update_sw_coremap(struct loongarch_extioi *s, +static inline void eiointc_update_sw_coremap(struct loongarch_eiointc *s, int irq, void *pvalue, u32 len, bool notify) { u8 i, cpu; @@ -146,7 +146,7 @@ static inline void extioi_update_sw_coremap(struct loongarch_extioi *s, vcpu = kvm_get_vcpu(s->kvm, cpu); if ((!vcpu) || (vcpu->vcpu_id != cpu)) { cpu = 0; - kvm_info("Warning %s: The wrong extioi coremap data was delivered!!\n", + kvm_info("Warning %s: The wrong eiointc coremap data was delivered!!\n", __func__); } @@ -155,17 +155,17 @@ static inline void extioi_update_sw_coremap(struct loongarch_extioi *s, if (notify && test_bit(irq + i, (unsigned long *)s->isr.reg_u8)) { /* lower irq at old cpu and raise irq at new cpu */ - extioi_update_irq(s, irq + i, 0); + eiointc_update_irq(s, irq + i, 0); s->sw_coremap[irq + i] = cpu; - extioi_update_irq(s, irq + i, 1); + eiointc_update_irq(s, irq + i, 1); } else { s->sw_coremap[irq + i] = cpu; } } } -static int loongarch_extioi_writeb(struct kvm_vcpu *vcpu, - struct loongarch_extioi *s, +static int loongarch_eiointc_writeb(struct kvm_vcpu *vcpu, + struct loongarch_eiointc *s, gpa_t addr, int len, const void *val) { int index, irq, ret = 0; @@ -173,23 +173,23 @@ static int loongarch_extioi_writeb(struct kvm_vcpu *vcpu, gpa_t offset; data = *(u8 *)val; - offset = addr - EXTIOI_BASE; + offset = addr - EIOINTC_BASE; switch (offset) { - case EXTIOI_NODETYPE_START ... EXTIOI_NODETYPE_END: - index = (offset - EXTIOI_NODETYPE_START); + case EIOINTC_NODETYPE_START ... EIOINTC_NODETYPE_END: + index = (offset - EIOINTC_NODETYPE_START); s->nodetype.reg_u8[index] = data; break; - case EXTIOI_IPMAP_START ... EXTIOI_IPMAP_END: + case EIOINTC_IPMAP_START ... EIOINTC_IPMAP_END: /* * ipmap cannot be set at runtime, can be set only at the beginning * of intr driver, need not update upper irq level */ - index = (offset - EXTIOI_IPMAP_START); + index = (offset - EIOINTC_IPMAP_START); s->ipmap.reg_u8[index] = data; break; - case EXTIOI_ENABLE_START ... EXTIOI_ENABLE_END: - index = (offset - EXTIOI_ENABLE_START); + case EIOINTC_ENABLE_START ... EIOINTC_ENABLE_END: + index = (offset - EIOINTC_ENABLE_START); old_data = s->enable.reg_u8[index]; s->enable.reg_u8[index] = data; /* @@ -197,22 +197,22 @@ static int loongarch_extioi_writeb(struct kvm_vcpu *vcpu, * update irq when isr is set. */ data = s->enable.reg_u8[index] & ~old_data & s->isr.reg_u8[index]; - extioi_enable_irq(s, index, data, 1); + eiointc_enable_irq(s, index, data, 1); /* * 0: disable irq. * update irq when isr is set. */ data = ~s->enable.reg_u8[index] & old_data & s->isr.reg_u8[index]; - extioi_enable_irq(s, index, data, 0); + eiointc_enable_irq(s, index, data, 0); break; - case EXTIOI_BOUNCE_START ... EXTIOI_BOUNCE_END: + case EIOINTC_BOUNCE_START ... EIOINTC_BOUNCE_END: /* do not emulate hw bounced irq routing */ - index = offset - EXTIOI_BOUNCE_START; + index = offset - EIOINTC_BOUNCE_START; s->bounce.reg_u8[index] = data; break; - case EXTIOI_COREISR_START ... EXTIOI_COREISR_END: + case EIOINTC_COREISR_START ... EIOINTC_COREISR_END: /* length of accessing core isr is 8 bytes */ - index = (offset - EXTIOI_COREISR_START); + index = (offset - EIOINTC_COREISR_START); /* using attrs to get current cpu index */ cpu = vcpu->vcpu_id; coreisr = data; @@ -222,16 +222,16 @@ static int loongarch_extioi_writeb(struct kvm_vcpu *vcpu, coreisr &= old_coreisr; irq = ffs(coreisr); while (irq != 0) { - extioi_update_irq(s, irq - 1 + index * 8, 0); + eiointc_update_irq(s, irq - 1 + index * 8, 0); coreisr &= ~(1 << (irq - 1)); irq = ffs(coreisr); } break; - case EXTIOI_COREMAP_START ... EXTIOI_COREMAP_END: - irq = offset - EXTIOI_COREMAP_START; + case EIOINTC_COREMAP_START ... EIOINTC_COREMAP_END: + irq = offset - EIOINTC_COREMAP_START; index = irq; s->coremap.reg_u8[index] = data; - extioi_update_sw_coremap(s, irq, (void *)&data, sizeof(data), true); + eiointc_update_sw_coremap(s, irq, (void *)&data, sizeof(data), true); break; default: ret = -EINVAL; @@ -240,8 +240,8 @@ static int loongarch_extioi_writeb(struct kvm_vcpu *vcpu, return ret; } -static int loongarch_extioi_writew(struct kvm_vcpu *vcpu, - struct loongarch_extioi *s, +static int loongarch_eiointc_writew(struct kvm_vcpu *vcpu, + struct loongarch_eiointc *s, gpa_t addr, int len, const void *val) { int ret = 0; @@ -250,23 +250,23 @@ static int loongarch_extioi_writew(struct kvm_vcpu *vcpu, gpa_t offset; data = *(u32 *)val; - offset = addr - EXTIOI_BASE; + offset = addr - EIOINTC_BASE; switch (offset) { - case EXTIOI_NODETYPE_START ... EXTIOI_NODETYPE_END: - index = (offset - EXTIOI_NODETYPE_START) >> 2; + case EIOINTC_NODETYPE_START ... EIOINTC_NODETYPE_END: + index = (offset - EIOINTC_NODETYPE_START) >> 2; s->nodetype.reg_u32[index] = data; break; - case EXTIOI_IPMAP_START ... EXTIOI_IPMAP_END: + case EIOINTC_IPMAP_START ... EIOINTC_IPMAP_END: /* * ipmap cannot be set at runtime, can be set only at the beginning * of intr driver, need not update upper irq level */ - index = (offset - EXTIOI_IPMAP_START) >> 2; + index = (offset - EIOINTC_IPMAP_START) >> 2; s->ipmap.reg_u32[index] = data; break; - case EXTIOI_ENABLE_START ... EXTIOI_ENABLE_END: - index = (offset - EXTIOI_ENABLE_START) >> 2; + case EIOINTC_ENABLE_START ... EIOINTC_ENABLE_END: + index = (offset - EIOINTC_ENABLE_START) >> 2; old_data = s->enable.reg_u32[index]; s->enable.reg_u32[index] = data; /* @@ -277,7 +277,7 @@ static int loongarch_extioi_writew(struct kvm_vcpu *vcpu, for (i = 0; i < sizeof(data); i++) { u8 mask = (data >> (i * 8)) & 0xff; - extioi_enable_irq(s, index * 4 + i, mask, 1); + eiointc_enable_irq(s, index * 4 + i, mask, 1); } /* * 0: disable irq. @@ -287,17 +287,17 @@ static int loongarch_extioi_writew(struct kvm_vcpu *vcpu, for (i = 0; i < sizeof(data); i++) { u8 mask = (data >> (i * 8)) & 0xff; - extioi_enable_irq(s, index * 4 + i, mask, 0); + eiointc_enable_irq(s, index * 4 + i, mask, 0); } break; - case EXTIOI_BOUNCE_START ... EXTIOI_BOUNCE_END: + case EIOINTC_BOUNCE_START ... EIOINTC_BOUNCE_END: /* do not emulate hw bounced irq routing */ - index = (offset - EXTIOI_BOUNCE_START) >> 2; + index = (offset - EIOINTC_BOUNCE_START) >> 2; s->bounce.reg_u32[index] = data; break; - case EXTIOI_COREISR_START ... EXTIOI_COREISR_END: + case EIOINTC_COREISR_START ... EIOINTC_COREISR_END: /* length of accessing core isr is 8 bytes */ - index = (offset - EXTIOI_COREISR_START) >> 2; + index = (offset - EIOINTC_COREISR_START) >> 2; /* using attrs to get current cpu index */ cpu = vcpu->vcpu_id; coreisr = data; @@ -307,16 +307,16 @@ static int loongarch_extioi_writew(struct kvm_vcpu *vcpu, coreisr &= old_coreisr; irq = ffs(coreisr); while (irq != 0) { - extioi_update_irq(s, irq - 1 + index * 32, 0); + eiointc_update_irq(s, irq - 1 + index * 32, 0); coreisr &= ~(1 << (irq - 1)); irq = ffs(coreisr); } break; - case EXTIOI_COREMAP_START ... EXTIOI_COREMAP_END: - irq = offset - EXTIOI_COREMAP_START; + case EIOINTC_COREMAP_START ... EIOINTC_COREMAP_END: + irq = offset - EIOINTC_COREMAP_START; index = irq >> 2; s->coremap.reg_u32[index] = data; - extioi_update_sw_coremap(s, irq, (void *)&data, sizeof(data), true); + eiointc_update_sw_coremap(s, irq, (void *)&data, sizeof(data), true); break; default: ret = -EINVAL; @@ -325,8 +325,8 @@ static int loongarch_extioi_writew(struct kvm_vcpu *vcpu, return ret; } -static int loongarch_extioi_writel(struct kvm_vcpu *vcpu, - struct loongarch_extioi *s, +static int loongarch_eiointc_writel(struct kvm_vcpu *vcpu, + struct loongarch_eiointc *s, gpa_t addr, int len, const void *val) { int ret = 0; @@ -335,22 +335,22 @@ static int loongarch_extioi_writel(struct kvm_vcpu *vcpu, gpa_t offset; data = *(u64 *)val; - offset = addr - EXTIOI_BASE; + offset = addr - EIOINTC_BASE; switch (offset) { - case EXTIOI_NODETYPE_START ... EXTIOI_NODETYPE_END: - index = (offset - EXTIOI_NODETYPE_START) >> 3; + case EIOINTC_NODETYPE_START ... EIOINTC_NODETYPE_END: + index = (offset - EIOINTC_NODETYPE_START) >> 3; s->nodetype.reg_u64[index] = data; break; - case EXTIOI_IPMAP_START ... EXTIOI_IPMAP_END: + case EIOINTC_IPMAP_START ... EIOINTC_IPMAP_END: /* * ipmap cannot be set at runtime, can be set only at the beginning * of intr driver, need not update upper irq level */ s->ipmap.reg_u64 = data; break; - case EXTIOI_ENABLE_START ... EXTIOI_ENABLE_END: - index = (offset - EXTIOI_ENABLE_START) >> 3; + case EIOINTC_ENABLE_START ... EIOINTC_ENABLE_END: + index = (offset - EIOINTC_ENABLE_START) >> 3; old_data = s->enable.reg_u64[index]; s->enable.reg_u64[index] = data; /* @@ -361,7 +361,7 @@ static int loongarch_extioi_writel(struct kvm_vcpu *vcpu, for (i = 0; i < sizeof(data); i++) { u8 mask = (data >> (i * 8)) & 0xff; - extioi_enable_irq(s, index * 8 + i, mask, 1); + eiointc_enable_irq(s, index * 8 + i, mask, 1); } /* * 0: disable irq. @@ -371,17 +371,17 @@ static int loongarch_extioi_writel(struct kvm_vcpu *vcpu, for (i = 0; i < sizeof(data); i++) { u8 mask = (data >> (i * 8)) & 0xff; - extioi_enable_irq(s, index * 8 + i, mask, 0); + eiointc_enable_irq(s, index * 8 + i, mask, 0); } break; - case EXTIOI_BOUNCE_START ... EXTIOI_BOUNCE_END: + case EIOINTC_BOUNCE_START ... EIOINTC_BOUNCE_END: /* do not emulate hw bounced irq routing */ - index = (offset - EXTIOI_BOUNCE_START) >> 3; + index = (offset - EIOINTC_BOUNCE_START) >> 3; s->bounce.reg_u64[index] = data; break; - case EXTIOI_COREISR_START ... EXTIOI_COREISR_END: + case EIOINTC_COREISR_START ... EIOINTC_COREISR_END: /* length of accessing core isr is 8 bytes */ - index = (offset - EXTIOI_COREISR_START) >> 3; + index = (offset - EIOINTC_COREISR_START) >> 3; /* using attrs to get current cpu index */ cpu = vcpu->vcpu_id; coreisr = data; @@ -393,16 +393,16 @@ static int loongarch_extioi_writel(struct kvm_vcpu *vcpu, bits = sizeof(u64) * 8; irq = find_first_bit((void *)&coreisr, bits); while (irq < bits) { - extioi_update_irq(s, irq + index * bits, 0); + eiointc_update_irq(s, irq + index * bits, 0); bitmap_clear((void *)&coreisr, irq, 1); irq = find_first_bit((void *)&coreisr, bits); } break; - case EXTIOI_COREMAP_START ... EXTIOI_COREMAP_END: - irq = offset - EXTIOI_COREMAP_START; + case EIOINTC_COREMAP_START ... EIOINTC_COREMAP_END: + irq = offset - EIOINTC_COREMAP_START; index = irq >> 3; s->coremap.reg_u64[index] = data; - extioi_update_sw_coremap(s, irq, (void *)&data, sizeof(data), true); + eiointc_update_sw_coremap(s, irq, (void *)&data, sizeof(data), true); break; default: ret = -EINVAL; @@ -411,32 +411,32 @@ static int loongarch_extioi_writel(struct kvm_vcpu *vcpu, return ret; } -static int kvm_loongarch_extioi_write(struct kvm_vcpu *vcpu, +static int kvm_loongarch_eiointc_write(struct kvm_vcpu *vcpu, struct kvm_io_device *dev, gpa_t addr, int len, const void *val) { int ret; - struct loongarch_extioi *extioi = vcpu->kvm->arch.extioi; + struct loongarch_eiointc *eiointc = vcpu->kvm->arch.eiointc; unsigned long flags; - if (!extioi) { - kvm_err("%s: extioi irqchip not valid!\n", __func__); + if (!eiointc) { + kvm_err("%s: eiointc irqchip not valid!\n", __func__); return -EINVAL; } ret = 0; - vcpu->kvm->stat.extioi_write_exits++; - loongarch_ext_irq_lock(extioi, flags); + vcpu->kvm->stat.eiointc_write_exits++; + loongarch_ext_irq_lock(eiointc, flags); switch (len) { case 1: - ret = loongarch_extioi_writeb(vcpu, extioi, addr, len, val); + ret = loongarch_eiointc_writeb(vcpu, eiointc, addr, len, val); break; case 4: - ret = loongarch_extioi_writew(vcpu, extioi, addr, len, val); + ret = loongarch_eiointc_writew(vcpu, eiointc, addr, len, val); break; case 8: - ret = loongarch_extioi_writel(vcpu, extioi, addr, len, val); + ret = loongarch_eiointc_writel(vcpu, eiointc, addr, len, val); break; default: ret = -EINVAL; @@ -444,13 +444,13 @@ static int kvm_loongarch_extioi_write(struct kvm_vcpu *vcpu, __func__, addr, len); } - loongarch_ext_irq_unlock(extioi, flags); + loongarch_ext_irq_unlock(eiointc, flags); return ret; } -static int loongarch_extioi_readb(struct kvm_vcpu *vcpu, struct loongarch_extioi *s, +static int loongarch_eiointc_readb(struct kvm_vcpu *vcpu, struct loongarch_eiointc *s, gpa_t addr, int len, void *val) { int ret = 0; @@ -458,31 +458,31 @@ static int loongarch_extioi_readb(struct kvm_vcpu *vcpu, struct loongarch_extioi u8 data, index; data = 0; - offset = addr - EXTIOI_BASE; + offset = addr - EIOINTC_BASE; switch (offset) { - case EXTIOI_NODETYPE_START ... EXTIOI_NODETYPE_END: - index = offset - EXTIOI_NODETYPE_START; + case EIOINTC_NODETYPE_START ... EIOINTC_NODETYPE_END: + index = offset - EIOINTC_NODETYPE_START; data = s->nodetype.reg_u8[index]; break; - case EXTIOI_IPMAP_START ... EXTIOI_IPMAP_END: - index = offset - EXTIOI_IPMAP_START; + case EIOINTC_IPMAP_START ... EIOINTC_IPMAP_END: + index = offset - EIOINTC_IPMAP_START; data = s->ipmap.reg_u8[index]; break; - case EXTIOI_ENABLE_START ... EXTIOI_ENABLE_END: - index = offset - EXTIOI_ENABLE_START; + case EIOINTC_ENABLE_START ... EIOINTC_ENABLE_END: + index = offset - EIOINTC_ENABLE_START; data = s->enable.reg_u8[index]; break; - case EXTIOI_BOUNCE_START ... EXTIOI_BOUNCE_END: - index = offset - EXTIOI_BOUNCE_START; + case EIOINTC_BOUNCE_START ... EIOINTC_BOUNCE_END: + index = offset - EIOINTC_BOUNCE_START; data = s->bounce.reg_u8[index]; break; - case EXTIOI_COREISR_START ... EXTIOI_COREISR_END: + case EIOINTC_COREISR_START ... EIOINTC_COREISR_END: /* length of accessing core isr is 8 bytes */ - index = offset - EXTIOI_COREISR_START; + index = offset - EIOINTC_COREISR_START; data = s->coreisr.reg_u8[vcpu->vcpu_id][index]; break; - case EXTIOI_COREMAP_START ... EXTIOI_COREMAP_END: - index = offset - EXTIOI_COREMAP_START; + case EIOINTC_COREMAP_START ... EIOINTC_COREMAP_END: + index = offset - EIOINTC_COREMAP_START; data = s->coremap.reg_u8[index]; break; default: @@ -495,7 +495,7 @@ static int loongarch_extioi_readb(struct kvm_vcpu *vcpu, struct loongarch_extioi return ret; } -static int loongarch_extioi_readw(struct kvm_vcpu *vcpu, struct loongarch_extioi *s, +static int loongarch_eiointc_readw(struct kvm_vcpu *vcpu, struct loongarch_eiointc *s, gpa_t addr, int len, void *val) { int ret = 0; @@ -503,31 +503,31 @@ static int loongarch_extioi_readw(struct kvm_vcpu *vcpu, struct loongarch_extioi gpa_t offset; u64 data = 0; - offset = addr - EXTIOI_BASE; + offset = addr - EIOINTC_BASE; switch (offset) { - case EXTIOI_NODETYPE_START ... EXTIOI_NODETYPE_END: - index = (offset - EXTIOI_NODETYPE_START) >> 2; + case EIOINTC_NODETYPE_START ... EIOINTC_NODETYPE_END: + index = (offset - EIOINTC_NODETYPE_START) >> 2; data = s->nodetype.reg_u32[index]; break; - case EXTIOI_IPMAP_START ... EXTIOI_IPMAP_END: - index = (offset - EXTIOI_IPMAP_START) >> 2; + case EIOINTC_IPMAP_START ... EIOINTC_IPMAP_END: + index = (offset - EIOINTC_IPMAP_START) >> 2; data = s->ipmap.reg_u32[index]; break; - case EXTIOI_ENABLE_START ... EXTIOI_ENABLE_END: - index = (offset - EXTIOI_ENABLE_START) >> 2; + case EIOINTC_ENABLE_START ... EIOINTC_ENABLE_END: + index = (offset - EIOINTC_ENABLE_START) >> 2; data = s->enable.reg_u32[index]; break; - case EXTIOI_BOUNCE_START ... EXTIOI_BOUNCE_END: - index = (offset - EXTIOI_BOUNCE_START) >> 2; + case EIOINTC_BOUNCE_START ... EIOINTC_BOUNCE_END: + index = (offset - EIOINTC_BOUNCE_START) >> 2; data = s->bounce.reg_u32[index]; break; - case EXTIOI_COREISR_START ... EXTIOI_COREISR_END: + case EIOINTC_COREISR_START ... EIOINTC_COREISR_END: /* length of accessing core isr is 8 bytes */ - index = (offset - EXTIOI_COREISR_START) >> 2; + index = (offset - EIOINTC_COREISR_START) >> 2; data = s->coreisr.reg_u32[vcpu->vcpu_id][index]; break; - case EXTIOI_COREMAP_START ... EXTIOI_COREMAP_END: - index = (offset - EXTIOI_COREMAP_START) >> 2; + case EIOINTC_COREMAP_START ... EIOINTC_COREMAP_END: + index = (offset - EIOINTC_COREMAP_START) >> 2; data = s->coremap.reg_u32[index]; break; default: @@ -540,7 +540,7 @@ static int loongarch_extioi_readw(struct kvm_vcpu *vcpu, struct loongarch_extioi return ret; } -static int loongarch_extioi_readl(struct kvm_vcpu *vcpu, struct loongarch_extioi *s, +static int loongarch_eiointc_readl(struct kvm_vcpu *vcpu, struct loongarch_eiointc *s, gpa_t addr, int len, void *val) { int ret = 0; @@ -548,31 +548,31 @@ static int loongarch_extioi_readl(struct kvm_vcpu *vcpu, struct loongarch_extioi gpa_t offset; u64 data = 0; - offset = addr - EXTIOI_BASE; + offset = addr - EIOINTC_BASE; switch (offset) { - case EXTIOI_NODETYPE_START ... EXTIOI_NODETYPE_END: - index = (offset - EXTIOI_NODETYPE_START) >> 3; + case EIOINTC_NODETYPE_START ... EIOINTC_NODETYPE_END: + index = (offset - EIOINTC_NODETYPE_START) >> 3; data = s->nodetype.reg_u64[index]; break; - case EXTIOI_IPMAP_START ... EXTIOI_IPMAP_END: - index = (offset - EXTIOI_IPMAP_START) >> 3; + case EIOINTC_IPMAP_START ... EIOINTC_IPMAP_END: + index = (offset - EIOINTC_IPMAP_START) >> 3; data = s->ipmap.reg_u64; break; - case EXTIOI_ENABLE_START ... EXTIOI_ENABLE_END: - index = (offset - EXTIOI_ENABLE_START) >> 3; + case EIOINTC_ENABLE_START ... EIOINTC_ENABLE_END: + index = (offset - EIOINTC_ENABLE_START) >> 3; data = s->enable.reg_u64[index]; break; - case EXTIOI_BOUNCE_START ... EXTIOI_BOUNCE_END: - index = (offset - EXTIOI_BOUNCE_START) >> 3; + case EIOINTC_BOUNCE_START ... EIOINTC_BOUNCE_END: + index = (offset - EIOINTC_BOUNCE_START) >> 3; data = s->bounce.reg_u64[index]; break; - case EXTIOI_COREISR_START ... EXTIOI_COREISR_END: + case EIOINTC_COREISR_START ... EIOINTC_COREISR_END: /* length of accessing core isr is 8 bytes */ - index = (offset - EXTIOI_COREISR_START) >> 3; + index = (offset - EIOINTC_COREISR_START) >> 3; data = s->coreisr.reg_u64[vcpu->vcpu_id][index]; break; - case EXTIOI_COREMAP_START ... EXTIOI_COREMAP_END: - index = (offset - EXTIOI_COREMAP_START) >> 3; + case EIOINTC_COREMAP_START ... EIOINTC_COREMAP_END: + index = (offset - EIOINTC_COREMAP_START) >> 3; data = s->coremap.reg_u64[index]; break; default: @@ -585,32 +585,32 @@ static int loongarch_extioi_readl(struct kvm_vcpu *vcpu, struct loongarch_extioi return ret; } -static int kvm_loongarch_extioi_read(struct kvm_vcpu *vcpu, +static int kvm_loongarch_eiointc_read(struct kvm_vcpu *vcpu, struct kvm_io_device *dev, gpa_t addr, int len, void *val) { int ret; - struct loongarch_extioi *extioi = vcpu->kvm->arch.extioi; + struct loongarch_eiointc *eiointc = vcpu->kvm->arch.eiointc; unsigned long flags; - if (!extioi) { - kvm_err("%s: extioi irqchip not valid!\n", __func__); + if (!eiointc) { + kvm_err("%s: eiointc irqchip not valid!\n", __func__); return -EINVAL; } ret = 0; - vcpu->kvm->stat.extioi_read_exits++; - loongarch_ext_irq_lock(extioi, flags); + vcpu->kvm->stat.eiointc_read_exits++; + loongarch_ext_irq_lock(eiointc, flags); switch (len) { case 1: - ret = loongarch_extioi_readb(vcpu, extioi, addr, len, val); + ret = loongarch_eiointc_readb(vcpu, eiointc, addr, len, val); break; case 4: - ret = loongarch_extioi_readw(vcpu, extioi, addr, len, val); + ret = loongarch_eiointc_readw(vcpu, eiointc, addr, len, val); break; case 8: - ret = loongarch_extioi_readl(vcpu, extioi, addr, len, val); + ret = loongarch_eiointc_readl(vcpu, eiointc, addr, len, val); break; default: ret = -EINVAL; @@ -618,100 +618,100 @@ static int kvm_loongarch_extioi_read(struct kvm_vcpu *vcpu, __func__, addr, len); } - loongarch_ext_irq_unlock(extioi, flags); + loongarch_ext_irq_unlock(eiointc, flags); return ret; } -static const struct kvm_io_device_ops kvm_loongarch_extioi_ops = { - .read = kvm_loongarch_extioi_read, - .write = kvm_loongarch_extioi_write, +static const struct kvm_io_device_ops kvm_loongarch_eiointc_ops = { + .read = kvm_loongarch_eiointc_read, + .write = kvm_loongarch_eiointc_write, }; -static int kvm_loongarch_extioi_regs_access(struct kvm_device *dev, +static int kvm_loongarch_eiointc_regs_access(struct kvm_device *dev, struct kvm_device_attr *attr, bool is_write) { int len, cpu, offset, addr; void __user *data; void *p = NULL; - struct loongarch_extioi *s; + struct loongarch_eiointc *s; unsigned long flags; len = 4; - s = dev->kvm->arch.extioi; + s = dev->kvm->arch.eiointc; addr = attr->attr; cpu = addr >> 16; addr &= 0xffff; data = (void __user *)attr->addr; loongarch_ext_irq_lock(s, flags); switch (addr) { - case EXTIOI_NODETYPE_START: + case EIOINTC_NODETYPE_START: p = s->nodetype.reg_u8; len = sizeof(s->nodetype); break; - case (EXTIOI_NODETYPE_START + 4) ... EXTIOI_NODETYPE_END: - offset = (addr - EXTIOI_NODETYPE_START) / 4; + case (EIOINTC_NODETYPE_START + 4) ... EIOINTC_NODETYPE_END: + offset = (addr - EIOINTC_NODETYPE_START) / 4; p = &s->nodetype.reg_u32[offset]; break; - case EXTIOI_IPMAP_START: + case EIOINTC_IPMAP_START: p = s->ipmap.reg_u8; len = sizeof(s->ipmap); break; - case (EXTIOI_IPMAP_START + 4) ... EXTIOI_IPMAP_END: - offset = (addr - EXTIOI_IPMAP_START) / 4; + case (EIOINTC_IPMAP_START + 4) ... EIOINTC_IPMAP_END: + offset = (addr - EIOINTC_IPMAP_START) / 4; p = &s->ipmap.reg_u32[offset]; break; - case EXTIOI_ENABLE_START: + case EIOINTC_ENABLE_START: p = s->enable.reg_u8; len = sizeof(s->enable); break; - case (EXTIOI_ENABLE_START + 4) ... EXTIOI_ENABLE_END: - offset = (addr - EXTIOI_ENABLE_START) / 4; + case (EIOINTC_ENABLE_START + 4) ... EIOINTC_ENABLE_END: + offset = (addr - EIOINTC_ENABLE_START) / 4; p = &s->enable.reg_u32[offset]; break; - case EXTIOI_BOUNCE_START: + case EIOINTC_BOUNCE_START: p = s->bounce.reg_u8; len = sizeof(s->bounce); break; - case (EXTIOI_BOUNCE_START + 4) ... EXTIOI_BOUNCE_END: - offset = (addr - EXTIOI_BOUNCE_START) / 4; + case (EIOINTC_BOUNCE_START + 4) ... EIOINTC_BOUNCE_END: + offset = (addr - EIOINTC_BOUNCE_START) / 4; p = &s->bounce.reg_u32[offset]; break; - case EXTIOI_ISR_START: + case EIOINTC_ISR_START: p = s->isr.reg_u8; len = sizeof(s->isr); break; - case (EXTIOI_ISR_START + 4) ... EXTIOI_ISR_END: - offset = (addr - EXTIOI_ISR_START) / 4; + case (EIOINTC_ISR_START + 4) ... EIOINTC_ISR_END: + offset = (addr - EIOINTC_ISR_START) / 4; p = &s->isr.reg_u32[offset]; break; - case EXTIOI_COREISR_START: + case EIOINTC_COREISR_START: p = s->coreisr.reg_u8; len = sizeof(s->coreisr); break; - case (EXTIOI_COREISR_START + 4) ... EXTIOI_COREISR_END: + case (EIOINTC_COREISR_START + 4) ... EIOINTC_COREISR_END: if (cpu >= s->num_cpu) return -EINVAL; - offset = (addr - EXTIOI_COREISR_START) / 4; + offset = (addr - EIOINTC_COREISR_START) / 4; p = &s->coreisr.reg_u32[cpu][offset]; break; - case EXTIOI_COREMAP_START: + case EIOINTC_COREMAP_START: p = s->coremap.reg_u8; len = sizeof(s->coremap); break; - case (EXTIOI_COREMAP_START + 4) ... EXTIOI_COREMAP_END: - offset = (addr - EXTIOI_COREMAP_START) / 4; + case (EIOINTC_COREMAP_START + 4) ... EIOINTC_COREMAP_END: + offset = (addr - EIOINTC_COREMAP_START) / 4; p = &s->coremap.reg_u32[offset]; break; - case EXTIOI_SW_COREMAP_FLAG: + case EIOINTC_SW_COREMAP_FLAG: p = s->sw_coremap; len = sizeof(s->sw_coremap); break; default: loongarch_ext_irq_unlock(s, flags); - kvm_err("%s: unknown extioi register, addr = %d\n", __func__, addr); + kvm_err("%s: unknown eiointc register, addr = %d\n", __func__, addr); return -EINVAL; } @@ -725,16 +725,16 @@ static int kvm_loongarch_extioi_regs_access(struct kvm_device *dev, return -EFAULT; } - if ((addr == EXTIOI_COREISR_START) && is_write) { + if ((addr == EIOINTC_COREISR_START) && is_write) { loongarch_ext_irq_lock(s, flags); - extioi_set_sw_coreisr(s); + eiointc_set_sw_coreisr(s); loongarch_ext_irq_unlock(s, flags); } return 0; } -static int kvm_extioi_ctrl_access(struct kvm_device *dev, +static int kvm_eiointc_ctrl_access(struct kvm_device *dev, struct kvm_device_attr *attr) { int ret = 0; @@ -742,7 +742,7 @@ static int kvm_extioi_ctrl_access(struct kvm_device *dev, unsigned long type = (unsigned long)attr->attr; u32 i, start_irq; void __user *data; - struct loongarch_extioi *s = dev->kvm->arch.extioi; + struct loongarch_eiointc *s = dev->kvm->arch.eiointc; data = (void __user *)attr->addr; spin_lock_irqsave(&s->lock, flags); @@ -758,10 +758,10 @@ static int kvm_extioi_ctrl_access(struct kvm_device *dev, s->status |= BIT(EIOINTC_ENABLE); break; case KVM_DEV_LOONGARCH_EXTIOI_CTRL_LOAD_FINISHED: - extioi_set_sw_coreisr(s); - for (i = 0; i < (EXTIOI_IRQS / 4); i++) { + eiointc_set_sw_coreisr(s); + for (i = 0; i < (EIOINTC_IRQS / 4); i++) { start_irq = i * 4; - extioi_update_sw_coremap(s, start_irq, + eiointc_update_sw_coremap(s, start_irq, (void *)&s->coremap.reg_u32[i], sizeof(u32), false); } break; @@ -774,7 +774,7 @@ static int kvm_extioi_ctrl_access(struct kvm_device *dev, return ret; } -static int kvm_extioi_sw_status_access(struct kvm_device *dev, +static int kvm_eiointc_sw_status_access(struct kvm_device *dev, struct kvm_device_attr *attr, bool is_write) { @@ -782,9 +782,9 @@ static int kvm_extioi_sw_status_access(struct kvm_device *dev, unsigned long flags; void *p = NULL; void __user *data; - struct loongarch_extioi *s; + struct loongarch_eiointc *s; - s = dev->kvm->arch.extioi; + s = dev->kvm->arch.eiointc; addr = attr->attr; addr &= 0xffff; @@ -800,7 +800,7 @@ static int kvm_extioi_sw_status_access(struct kvm_device *dev, p = &s->status; break; default: - kvm_err("%s: unknown extioi register, addr = %d\n", __func__, addr); + kvm_err("%s: unknown eiointc register, addr = %d\n", __func__, addr); return -EINVAL; } spin_lock_irqsave(&s->lock, flags); @@ -816,113 +816,113 @@ static int kvm_extioi_sw_status_access(struct kvm_device *dev, return ret; } -static int kvm_loongarch_extioi_get_attr(struct kvm_device *dev, +static int kvm_loongarch_eiointc_get_attr(struct kvm_device *dev, struct kvm_device_attr *attr) { switch (attr->group) { case KVM_DEV_LOONGARCH_EXTIOI_GRP_REGS: - return kvm_loongarch_extioi_regs_access(dev, attr, false); + return kvm_loongarch_eiointc_regs_access(dev, attr, false); case KVM_DEV_LOONGARCH_EXTIOI_GRP_SW_STATUS: - return kvm_extioi_sw_status_access(dev, attr, false); + return kvm_eiointc_sw_status_access(dev, attr, false); default: return -EINVAL; } } -static int kvm_loongarch_extioi_set_attr(struct kvm_device *dev, +static int kvm_loongarch_eiointc_set_attr(struct kvm_device *dev, struct kvm_device_attr *attr) { switch (attr->group) { case KVM_DEV_LOONGARCH_EXTIOI_GRP_CTRL: - return kvm_extioi_ctrl_access(dev, attr); + return kvm_eiointc_ctrl_access(dev, attr); case KVM_DEV_LOONGARCH_EXTIOI_GRP_REGS: - return kvm_loongarch_extioi_regs_access(dev, attr, true); + return kvm_loongarch_eiointc_regs_access(dev, attr, true); case KVM_DEV_LOONGARCH_EXTIOI_GRP_SW_STATUS: - return kvm_extioi_sw_status_access(dev, attr, true); + return kvm_eiointc_sw_status_access(dev, attr, true); } return -EINVAL; } -static int kvm_extioi_virt_read(struct kvm_vcpu *vcpu, +static int kvm_eiointc_virt_read(struct kvm_vcpu *vcpu, struct kvm_io_device *dev, gpa_t addr, int len, void *val) { unsigned long flags; u32 *data = val; - struct loongarch_extioi *extioi = vcpu->kvm->arch.extioi; + struct loongarch_eiointc *eiointc = vcpu->kvm->arch.eiointc; - if (!extioi) { - kvm_err("%s: extioi irqchip not valid!\n", __func__); + if (!eiointc) { + kvm_err("%s: eiointc irqchip not valid!\n", __func__); return -EINVAL; } addr -= EIOINTC_VIRT_BASE; - spin_lock_irqsave(&extioi->lock, flags); + spin_lock_irqsave(&eiointc->lock, flags); switch (addr) { case EIOINTC_VIRT_FEATURES: - *data = extioi->features; + *data = eiointc->features; break; case EIOINTC_VIRT_CONFIG: - *data = extioi->status; + *data = eiointc->status; break; default: break; } - spin_unlock_irqrestore(&extioi->lock, flags); + spin_unlock_irqrestore(&eiointc->lock, flags); return 0; } -static int kvm_extioi_virt_write(struct kvm_vcpu *vcpu, +static int kvm_eiointc_virt_write(struct kvm_vcpu *vcpu, struct kvm_io_device *dev, gpa_t addr, int len, const void *val) { int ret = 0; unsigned long flags; u32 value = *(u32 *)val; - struct loongarch_extioi *extioi = vcpu->kvm->arch.extioi; + struct loongarch_eiointc *eiointc = vcpu->kvm->arch.eiointc; - if (!extioi) { - kvm_err("%s: extioi irqchip not valid!\n", __func__); + if (!eiointc) { + kvm_err("%s: eiointc irqchip not valid!\n", __func__); return -EINVAL; } addr -= EIOINTC_VIRT_BASE; - spin_lock_irqsave(&extioi->lock, flags); + spin_lock_irqsave(&eiointc->lock, flags); switch (addr) { case EIOINTC_VIRT_FEATURES: ret = -EPERM; break; case EIOINTC_VIRT_CONFIG: /* - * extioi features can only be set at disabled status + * eiointc features can only be set at disabled status */ - if ((extioi->status & BIT(EIOINTC_ENABLE)) && value) { + if ((eiointc->status & BIT(EIOINTC_ENABLE)) && value) { ret = -EPERM; break; } - extioi->status = value & extioi->features; + eiointc->status = value & eiointc->features; break; default: ret = -EINVAL; break; } - spin_unlock_irqrestore(&extioi->lock, flags); + spin_unlock_irqrestore(&eiointc->lock, flags); return ret; } -static const struct kvm_io_device_ops kvm_extioi_virt_ops = { - .read = kvm_extioi_virt_read, - .write = kvm_extioi_virt_write, +static const struct kvm_io_device_ops kvm_eiointc_virt_ops = { + .read = kvm_eiointc_virt_read, + .write = kvm_eiointc_virt_write, }; -static void kvm_loongarch_extioi_destroy(struct kvm_device *dev) +static void kvm_loongarch_eiointc_destroy(struct kvm_device *dev) { struct kvm *kvm; - struct loongarch_extioi *extioi; + struct loongarch_eiointc *eiointc; struct kvm_io_device *device; if (!dev) @@ -932,28 +932,28 @@ static void kvm_loongarch_extioi_destroy(struct kvm_device *dev) if (!kvm) return; - extioi = kvm->arch.extioi; - if (!extioi) + eiointc = kvm->arch.eiointc; + if (!eiointc) return; - device = &extioi->device; + device = &eiointc->device; kvm_io_bus_unregister_dev(kvm, KVM_IOCSR_BUS, device); - kvm_io_bus_unregister_dev(kvm, KVM_IOCSR_BUS, &extioi->device_vext); - kfree(extioi); + kvm_io_bus_unregister_dev(kvm, KVM_IOCSR_BUS, &eiointc->device_vext); + kfree(eiointc); } -static int kvm_loongarch_extioi_create(struct kvm_device *dev, u32 type) +static int kvm_loongarch_eiointc_create(struct kvm_device *dev, u32 type) { int ret; - struct loongarch_extioi *s; + struct loongarch_eiointc *s; struct kvm_io_device *device, *device1; struct kvm *kvm = dev->kvm; - /* extioi has been created */ - if (kvm->arch.extioi) + /* eiointc has been created */ + if (kvm->arch.eiointc) return -EINVAL; - s = kzalloc(sizeof(struct loongarch_extioi), GFP_KERNEL); + s = kzalloc(sizeof(struct loongarch_eiointc), GFP_KERNEL); if (!s) return -ENOMEM; spin_lock_init(&s->lock); @@ -963,9 +963,9 @@ static int kvm_loongarch_extioi_create(struct kvm_device *dev, u32 type) * Initialize IOCSR device */ device = &s->device; - kvm_iodevice_init(device, &kvm_loongarch_extioi_ops); + kvm_iodevice_init(device, &kvm_loongarch_eiointc_ops); mutex_lock(&kvm->slots_lock); - ret = kvm_io_bus_register_dev(kvm, KVM_IOCSR_BUS, EXTIOI_BASE, EXTIOI_SIZE, device); + ret = kvm_io_bus_register_dev(kvm, KVM_IOCSR_BUS, EIOINTC_BASE, EIOINTC_SIZE, device); mutex_unlock(&kvm->slots_lock); if (ret < 0) { kfree(s); @@ -973,7 +973,7 @@ static int kvm_loongarch_extioi_create(struct kvm_device *dev, u32 type) } device1 = &s->device_vext; - kvm_iodevice_init(device1, &kvm_extioi_virt_ops); + kvm_iodevice_init(device1, &kvm_eiointc_virt_ops); ret = kvm_io_bus_register_dev(kvm, KVM_IOCSR_BUS, EIOINTC_VIRT_BASE, EIOINTC_VIRT_SIZE, device1); if (ret < 0) { @@ -981,43 +981,43 @@ static int kvm_loongarch_extioi_create(struct kvm_device *dev, u32 type) kfree(s); return ret; } - kvm->arch.extioi = s; + kvm->arch.eiointc = s; - kvm_info("create extioi device successfully\n"); + kvm_info("create eiointc device successfully\n"); return 0; } -static struct kvm_device_ops kvm_loongarch_extioi_dev_ops = { - .name = "kvm-loongarch-extioi", - .create = kvm_loongarch_extioi_create, - .destroy = kvm_loongarch_extioi_destroy, - .set_attr = kvm_loongarch_extioi_set_attr, - .get_attr = kvm_loongarch_extioi_get_attr, +static struct kvm_device_ops kvm_loongarch_eiointc_dev_ops = { + .name = "kvm-loongarch-eiointc", + .create = kvm_loongarch_eiointc_create, + .destroy = kvm_loongarch_eiointc_destroy, + .set_attr = kvm_loongarch_eiointc_set_attr, + .get_attr = kvm_loongarch_eiointc_get_attr, }; -int kvm_loongarch_register_extioi_device(void) +int kvm_loongarch_register_eiointc_device(void) { - return kvm_register_device_ops(&kvm_loongarch_extioi_dev_ops, + return kvm_register_device_ops(&kvm_loongarch_eiointc_dev_ops, KVM_DEV_TYPE_LOONGARCH_EIOINTC); } -int kvm_loongarch_reset_extioi(struct kvm *kvm) +int kvm_loongarch_reset_eiointc(struct kvm *kvm) { - struct loongarch_extioi *extioi = kvm->arch.extioi; + struct loongarch_eiointc *eiointc = kvm->arch.eiointc; unsigned long flags; unsigned long offset, size; u8 *pstart; - if (!extioi) + if (!eiointc) return -EINVAL; - pstart = (char *)&extioi->nodetype; - offset = (char *)&extioi->nodetype - (char *)extioi; - size = sizeof(struct loongarch_extioi) - offset; + pstart = (char *)&eiointc->nodetype; + offset = (char *)&eiointc->nodetype - (char *)eiointc; + size = sizeof(struct loongarch_eiointc) - offset; - loongarch_ext_irq_lock(extioi, flags); + loongarch_ext_irq_lock(eiointc, flags); memset(pstart, 0, size); - loongarch_ext_irq_unlock(extioi, flags); + loongarch_ext_irq_unlock(eiointc, flags); return 0; } diff --git a/arch/loongarch/kvm/intc/pch_pic.c b/arch/loongarch/kvm/intc/pch_pic.c index 2edaac8080570da3dc7a3e0146d1804545037dec..1b071799638af6f4441e4d86cf83380bfe4312d8 100644 --- a/arch/loongarch/kvm/intc/pch_pic.c +++ b/arch/loongarch/kvm/intc/pch_pic.c @@ -3,31 +3,31 @@ * Copyright (C) 2024 Loongson Technology Corporation Limited */ -#include +#include #include #include #include -/* update the isr according to irq level and route irq to extioi */ +/* update the isr according to irq level and route irq to eiointc */ static void pch_pic_update_irq(struct loongarch_pch_pic *s, int irq, int level) { u64 mask = (1 << irq); /* - * set isr and route irq to extioi and + * set isr and route irq to eiointc and * the route table is in htmsi_vector[] */ if (level) { if (mask & s->irr & ~s->mask) { s->isr |= mask; irq = s->htmsi_vector[irq]; - extioi_set_irq(s->kvm->arch.extioi, irq, level); + eiointc_set_irq(s->kvm->arch.eiointc, irq, level); } } else { if (mask & s->isr & ~s->irr) { s->isr &= ~mask; irq = s->htmsi_vector[irq]; - extioi_set_irq(s->kvm->arch.extioi, irq, level); + eiointc_set_irq(s->kvm->arch.eiointc, irq, level); } } } @@ -35,7 +35,7 @@ static void pch_pic_update_irq(struct loongarch_pch_pic *s, int irq, int level) /* msi irq handler */ void pch_msi_set_irq(struct kvm *kvm, int irq, int level) { - extioi_set_irq(kvm->arch.extioi, irq, level); + eiointc_set_irq(kvm->arch.eiointc, irq, level); } /* called when a irq is triggered in pch pic */ @@ -183,11 +183,11 @@ static int loongarch_pch_pic_write(struct loongarch_pch_pic *s, gpa_t addr, break; case PCH_PIC_ROUTE_ENTRY_START ... PCH_PIC_ROUTE_ENTRY_END: offset -= PCH_PIC_ROUTE_ENTRY_START; - /* only route to int0: extioi */ + /* only route to int0: eiointc */ s->route_entry[offset] = 1; break; case PCH_PIC_HTMSI_VEC_START ... PCH_PIC_HTMSI_VEC_END: - /* route table to extioi */ + /* route table to eiointc */ offset -= PCH_PIC_HTMSI_VEC_START; s->htmsi_vector[offset] = (u8)data; break; @@ -272,7 +272,7 @@ static int loongarch_pch_pic_read(struct loongarch_pch_pic *s, gpa_t addr, int l *(u32 *)val = 0; break; case PCH_PIC_ROUTE_ENTRY_START ... PCH_PIC_ROUTE_ENTRY_END: - /* only route to int0: extioi */ + /* only route to int0: eiointc */ *(u8 *)val = 1; break; case PCH_PIC_HTMSI_VEC_START ... PCH_PIC_HTMSI_VEC_END: diff --git a/arch/loongarch/kvm/main.c b/arch/loongarch/kvm/main.c index ef2bad612c00309a59937a1b59e63cb9d802ca81..a482a9e70b65dfb4f0a54dc8c4d8354e21e92925 100644 --- a/arch/loongarch/kvm/main.c +++ b/arch/loongarch/kvm/main.c @@ -9,7 +9,7 @@ #include #include #include -#include +#include #include #include "trace.h" @@ -396,8 +396,8 @@ static int kvm_loongarch_env_init(void) if (ret) return ret; - /* Register loongarch extioi interrupt controller interface. */ - ret = kvm_loongarch_register_extioi_device(); + /* Register loongarch eiointc interrupt controller interface. */ + ret = kvm_loongarch_register_eiointc_device(); if (ret) return ret; diff --git a/arch/loongarch/kvm/vcpu.c b/arch/loongarch/kvm/vcpu.c index 532138bd049fa257540b8f4c9356ceaf0cf9098d..24f15eb5d4d3d75a0c8b2dc57cd34be1ca8189d4 100644 --- a/arch/loongarch/kvm/vcpu.c +++ b/arch/loongarch/kvm/vcpu.c @@ -871,7 +871,7 @@ static int kvm_set_one_reg(struct kvm_vcpu *vcpu, case KVM_REG_LOONGARCH_VCPU_RESET: vcpu->arch.st.guest_addr = 0; if (vcpu->vcpu_id == 0) { - kvm_loongarch_reset_extioi(vcpu->kvm); + kvm_loongarch_reset_eiointc(vcpu->kvm); kvm_loongarch_reset_pch(vcpu->kvm); } diff --git a/arch/loongarch/kvm/vm.c b/arch/loongarch/kvm/vm.c index c5e62281242c6575b93302146836068ca62ff202..e22c74bc62774fd10e02dc63c508929819b4bffd 100644 --- a/arch/loongarch/kvm/vm.c +++ b/arch/loongarch/kvm/vm.c @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include const struct _kvm_stats_desc kvm_vm_stats_desc[] = { @@ -199,5 +199,5 @@ int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *data, bool kvm_arch_irqchip_in_kernel(struct kvm *kvm) { - return (bool)((!!kvm->arch.extioi) && (!!kvm->arch.pch_pic)); + return (bool)((!!kvm->arch.eiointc) && (!!kvm->arch.pch_pic)); }