mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-31 16:38:12 +00:00
8e936e9871
The reads to APLIC in_clrip[x] registers returns rectified input values
of the interrupt sources.
A rectified input value of an interrupt source is defined by the section
"4.5.2 Source configurations (sourcecfg[1]–sourcecfg[1023])" of the
RISC-V AIA specification as:
rectified input value = (incoming wire value) XOR (source is inverted)
Update the riscv_aplic_input() implementation to match the above.
Cc: stable@vger.kernel.org
Fixes: 74967aa208
("RISC-V: KVM: Add in-kernel emulation of AIA APLIC")
Signed-off-by: Anup Patel <apatel@ventanamicro.com>
Signed-off-by: Anup Patel <anup@brainfault.org>
Link: https://lore.kernel.org/r/20240321085041.1955293-3-apatel@ventanamicro.com
644 lines
16 KiB
C
644 lines
16 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2021 Western Digital Corporation or its affiliates.
|
|
* Copyright (C) 2022 Ventana Micro Systems Inc.
|
|
*
|
|
* Authors:
|
|
* Anup Patel <apatel@ventanamicro.com>
|
|
*/
|
|
|
|
#include <linux/kvm_host.h>
|
|
#include <linux/math.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/swab.h>
|
|
#include <kvm/iodev.h>
|
|
#include <asm/kvm_aia_aplic.h>
|
|
|
|
struct aplic_irq {
|
|
raw_spinlock_t lock;
|
|
u32 sourcecfg;
|
|
u32 state;
|
|
#define APLIC_IRQ_STATE_PENDING BIT(0)
|
|
#define APLIC_IRQ_STATE_ENABLED BIT(1)
|
|
#define APLIC_IRQ_STATE_ENPEND (APLIC_IRQ_STATE_PENDING | \
|
|
APLIC_IRQ_STATE_ENABLED)
|
|
#define APLIC_IRQ_STATE_INPUT BIT(8)
|
|
u32 target;
|
|
};
|
|
|
|
struct aplic {
|
|
struct kvm_io_device iodev;
|
|
|
|
u32 domaincfg;
|
|
u32 genmsi;
|
|
|
|
u32 nr_irqs;
|
|
u32 nr_words;
|
|
struct aplic_irq *irqs;
|
|
};
|
|
|
|
static u32 aplic_read_sourcecfg(struct aplic *aplic, u32 irq)
|
|
{
|
|
u32 ret;
|
|
unsigned long flags;
|
|
struct aplic_irq *irqd;
|
|
|
|
if (!irq || aplic->nr_irqs <= irq)
|
|
return 0;
|
|
irqd = &aplic->irqs[irq];
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
ret = irqd->sourcecfg;
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void aplic_write_sourcecfg(struct aplic *aplic, u32 irq, u32 val)
|
|
{
|
|
unsigned long flags;
|
|
struct aplic_irq *irqd;
|
|
|
|
if (!irq || aplic->nr_irqs <= irq)
|
|
return;
|
|
irqd = &aplic->irqs[irq];
|
|
|
|
if (val & APLIC_SOURCECFG_D)
|
|
val = 0;
|
|
else
|
|
val &= APLIC_SOURCECFG_SM_MASK;
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
irqd->sourcecfg = val;
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
}
|
|
|
|
static u32 aplic_read_target(struct aplic *aplic, u32 irq)
|
|
{
|
|
u32 ret;
|
|
unsigned long flags;
|
|
struct aplic_irq *irqd;
|
|
|
|
if (!irq || aplic->nr_irqs <= irq)
|
|
return 0;
|
|
irqd = &aplic->irqs[irq];
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
ret = irqd->target;
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void aplic_write_target(struct aplic *aplic, u32 irq, u32 val)
|
|
{
|
|
unsigned long flags;
|
|
struct aplic_irq *irqd;
|
|
|
|
if (!irq || aplic->nr_irqs <= irq)
|
|
return;
|
|
irqd = &aplic->irqs[irq];
|
|
|
|
val &= APLIC_TARGET_EIID_MASK |
|
|
(APLIC_TARGET_HART_IDX_MASK << APLIC_TARGET_HART_IDX_SHIFT) |
|
|
(APLIC_TARGET_GUEST_IDX_MASK << APLIC_TARGET_GUEST_IDX_SHIFT);
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
irqd->target = val;
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
}
|
|
|
|
static bool aplic_read_pending(struct aplic *aplic, u32 irq)
|
|
{
|
|
bool ret;
|
|
unsigned long flags;
|
|
struct aplic_irq *irqd;
|
|
|
|
if (!irq || aplic->nr_irqs <= irq)
|
|
return false;
|
|
irqd = &aplic->irqs[irq];
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
ret = (irqd->state & APLIC_IRQ_STATE_PENDING) ? true : false;
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void aplic_write_pending(struct aplic *aplic, u32 irq, bool pending)
|
|
{
|
|
unsigned long flags, sm;
|
|
struct aplic_irq *irqd;
|
|
|
|
if (!irq || aplic->nr_irqs <= irq)
|
|
return;
|
|
irqd = &aplic->irqs[irq];
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
|
|
sm = irqd->sourcecfg & APLIC_SOURCECFG_SM_MASK;
|
|
if (sm == APLIC_SOURCECFG_SM_INACTIVE)
|
|
goto skip_write_pending;
|
|
|
|
if (sm == APLIC_SOURCECFG_SM_LEVEL_HIGH ||
|
|
sm == APLIC_SOURCECFG_SM_LEVEL_LOW) {
|
|
if (!pending)
|
|
goto skip_write_pending;
|
|
if ((irqd->state & APLIC_IRQ_STATE_INPUT) &&
|
|
sm == APLIC_SOURCECFG_SM_LEVEL_LOW)
|
|
goto skip_write_pending;
|
|
if (!(irqd->state & APLIC_IRQ_STATE_INPUT) &&
|
|
sm == APLIC_SOURCECFG_SM_LEVEL_HIGH)
|
|
goto skip_write_pending;
|
|
}
|
|
|
|
if (pending)
|
|
irqd->state |= APLIC_IRQ_STATE_PENDING;
|
|
else
|
|
irqd->state &= ~APLIC_IRQ_STATE_PENDING;
|
|
|
|
skip_write_pending:
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
}
|
|
|
|
static bool aplic_read_enabled(struct aplic *aplic, u32 irq)
|
|
{
|
|
bool ret;
|
|
unsigned long flags;
|
|
struct aplic_irq *irqd;
|
|
|
|
if (!irq || aplic->nr_irqs <= irq)
|
|
return false;
|
|
irqd = &aplic->irqs[irq];
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
ret = (irqd->state & APLIC_IRQ_STATE_ENABLED) ? true : false;
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void aplic_write_enabled(struct aplic *aplic, u32 irq, bool enabled)
|
|
{
|
|
unsigned long flags;
|
|
struct aplic_irq *irqd;
|
|
|
|
if (!irq || aplic->nr_irqs <= irq)
|
|
return;
|
|
irqd = &aplic->irqs[irq];
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
if (enabled)
|
|
irqd->state |= APLIC_IRQ_STATE_ENABLED;
|
|
else
|
|
irqd->state &= ~APLIC_IRQ_STATE_ENABLED;
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
}
|
|
|
|
static bool aplic_read_input(struct aplic *aplic, u32 irq)
|
|
{
|
|
u32 sourcecfg, sm, raw_input, irq_inverted;
|
|
struct aplic_irq *irqd;
|
|
unsigned long flags;
|
|
bool ret = false;
|
|
|
|
if (!irq || aplic->nr_irqs <= irq)
|
|
return false;
|
|
irqd = &aplic->irqs[irq];
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
|
|
sourcecfg = irqd->sourcecfg;
|
|
if (sourcecfg & APLIC_SOURCECFG_D)
|
|
goto skip;
|
|
|
|
sm = sourcecfg & APLIC_SOURCECFG_SM_MASK;
|
|
if (sm == APLIC_SOURCECFG_SM_INACTIVE)
|
|
goto skip;
|
|
|
|
raw_input = (irqd->state & APLIC_IRQ_STATE_INPUT) ? 1 : 0;
|
|
irq_inverted = (sm == APLIC_SOURCECFG_SM_LEVEL_LOW ||
|
|
sm == APLIC_SOURCECFG_SM_EDGE_FALL) ? 1 : 0;
|
|
ret = !!(raw_input ^ irq_inverted);
|
|
|
|
skip:
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void aplic_inject_msi(struct kvm *kvm, u32 irq, u32 target)
|
|
{
|
|
u32 hart_idx, guest_idx, eiid;
|
|
|
|
hart_idx = target >> APLIC_TARGET_HART_IDX_SHIFT;
|
|
hart_idx &= APLIC_TARGET_HART_IDX_MASK;
|
|
guest_idx = target >> APLIC_TARGET_GUEST_IDX_SHIFT;
|
|
guest_idx &= APLIC_TARGET_GUEST_IDX_MASK;
|
|
eiid = target & APLIC_TARGET_EIID_MASK;
|
|
kvm_riscv_aia_inject_msi_by_id(kvm, hart_idx, guest_idx, eiid);
|
|
}
|
|
|
|
static void aplic_update_irq_range(struct kvm *kvm, u32 first, u32 last)
|
|
{
|
|
bool inject;
|
|
u32 irq, target;
|
|
unsigned long flags;
|
|
struct aplic_irq *irqd;
|
|
struct aplic *aplic = kvm->arch.aia.aplic_state;
|
|
|
|
if (!(aplic->domaincfg & APLIC_DOMAINCFG_IE))
|
|
return;
|
|
|
|
for (irq = first; irq <= last; irq++) {
|
|
if (!irq || aplic->nr_irqs <= irq)
|
|
continue;
|
|
irqd = &aplic->irqs[irq];
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
|
|
inject = false;
|
|
target = irqd->target;
|
|
if ((irqd->state & APLIC_IRQ_STATE_ENPEND) ==
|
|
APLIC_IRQ_STATE_ENPEND) {
|
|
irqd->state &= ~APLIC_IRQ_STATE_PENDING;
|
|
inject = true;
|
|
}
|
|
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
|
|
if (inject)
|
|
aplic_inject_msi(kvm, irq, target);
|
|
}
|
|
}
|
|
|
|
int kvm_riscv_aia_aplic_inject(struct kvm *kvm, u32 source, bool level)
|
|
{
|
|
u32 target;
|
|
bool inject = false, ie;
|
|
unsigned long flags;
|
|
struct aplic_irq *irqd;
|
|
struct aplic *aplic = kvm->arch.aia.aplic_state;
|
|
|
|
if (!aplic || !source || (aplic->nr_irqs <= source))
|
|
return -ENODEV;
|
|
irqd = &aplic->irqs[source];
|
|
ie = (aplic->domaincfg & APLIC_DOMAINCFG_IE) ? true : false;
|
|
|
|
raw_spin_lock_irqsave(&irqd->lock, flags);
|
|
|
|
if (irqd->sourcecfg & APLIC_SOURCECFG_D)
|
|
goto skip_unlock;
|
|
|
|
switch (irqd->sourcecfg & APLIC_SOURCECFG_SM_MASK) {
|
|
case APLIC_SOURCECFG_SM_EDGE_RISE:
|
|
if (level && !(irqd->state & APLIC_IRQ_STATE_INPUT) &&
|
|
!(irqd->state & APLIC_IRQ_STATE_PENDING))
|
|
irqd->state |= APLIC_IRQ_STATE_PENDING;
|
|
break;
|
|
case APLIC_SOURCECFG_SM_EDGE_FALL:
|
|
if (!level && (irqd->state & APLIC_IRQ_STATE_INPUT) &&
|
|
!(irqd->state & APLIC_IRQ_STATE_PENDING))
|
|
irqd->state |= APLIC_IRQ_STATE_PENDING;
|
|
break;
|
|
case APLIC_SOURCECFG_SM_LEVEL_HIGH:
|
|
if (level && !(irqd->state & APLIC_IRQ_STATE_PENDING))
|
|
irqd->state |= APLIC_IRQ_STATE_PENDING;
|
|
break;
|
|
case APLIC_SOURCECFG_SM_LEVEL_LOW:
|
|
if (!level && !(irqd->state & APLIC_IRQ_STATE_PENDING))
|
|
irqd->state |= APLIC_IRQ_STATE_PENDING;
|
|
break;
|
|
}
|
|
|
|
if (level)
|
|
irqd->state |= APLIC_IRQ_STATE_INPUT;
|
|
else
|
|
irqd->state &= ~APLIC_IRQ_STATE_INPUT;
|
|
|
|
target = irqd->target;
|
|
if (ie && ((irqd->state & APLIC_IRQ_STATE_ENPEND) ==
|
|
APLIC_IRQ_STATE_ENPEND)) {
|
|
irqd->state &= ~APLIC_IRQ_STATE_PENDING;
|
|
inject = true;
|
|
}
|
|
|
|
skip_unlock:
|
|
raw_spin_unlock_irqrestore(&irqd->lock, flags);
|
|
|
|
if (inject)
|
|
aplic_inject_msi(kvm, source, target);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static u32 aplic_read_input_word(struct aplic *aplic, u32 word)
|
|
{
|
|
u32 i, ret = 0;
|
|
|
|
for (i = 0; i < 32; i++)
|
|
ret |= aplic_read_input(aplic, word * 32 + i) ? BIT(i) : 0;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static u32 aplic_read_pending_word(struct aplic *aplic, u32 word)
|
|
{
|
|
u32 i, ret = 0;
|
|
|
|
for (i = 0; i < 32; i++)
|
|
ret |= aplic_read_pending(aplic, word * 32 + i) ? BIT(i) : 0;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void aplic_write_pending_word(struct aplic *aplic, u32 word,
|
|
u32 val, bool pending)
|
|
{
|
|
u32 i;
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
if (val & BIT(i))
|
|
aplic_write_pending(aplic, word * 32 + i, pending);
|
|
}
|
|
}
|
|
|
|
static u32 aplic_read_enabled_word(struct aplic *aplic, u32 word)
|
|
{
|
|
u32 i, ret = 0;
|
|
|
|
for (i = 0; i < 32; i++)
|
|
ret |= aplic_read_enabled(aplic, word * 32 + i) ? BIT(i) : 0;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void aplic_write_enabled_word(struct aplic *aplic, u32 word,
|
|
u32 val, bool enabled)
|
|
{
|
|
u32 i;
|
|
|
|
for (i = 0; i < 32; i++) {
|
|
if (val & BIT(i))
|
|
aplic_write_enabled(aplic, word * 32 + i, enabled);
|
|
}
|
|
}
|
|
|
|
static int aplic_mmio_read_offset(struct kvm *kvm, gpa_t off, u32 *val32)
|
|
{
|
|
u32 i;
|
|
struct aplic *aplic = kvm->arch.aia.aplic_state;
|
|
|
|
if ((off & 0x3) != 0)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (off == APLIC_DOMAINCFG) {
|
|
*val32 = APLIC_DOMAINCFG_RDONLY |
|
|
aplic->domaincfg | APLIC_DOMAINCFG_DM;
|
|
} else if ((off >= APLIC_SOURCECFG_BASE) &&
|
|
(off < (APLIC_SOURCECFG_BASE + (aplic->nr_irqs - 1) * 4))) {
|
|
i = ((off - APLIC_SOURCECFG_BASE) >> 2) + 1;
|
|
*val32 = aplic_read_sourcecfg(aplic, i);
|
|
} else if ((off >= APLIC_SETIP_BASE) &&
|
|
(off < (APLIC_SETIP_BASE + aplic->nr_words * 4))) {
|
|
i = (off - APLIC_SETIP_BASE) >> 2;
|
|
*val32 = aplic_read_pending_word(aplic, i);
|
|
} else if (off == APLIC_SETIPNUM) {
|
|
*val32 = 0;
|
|
} else if ((off >= APLIC_CLRIP_BASE) &&
|
|
(off < (APLIC_CLRIP_BASE + aplic->nr_words * 4))) {
|
|
i = (off - APLIC_CLRIP_BASE) >> 2;
|
|
*val32 = aplic_read_input_word(aplic, i);
|
|
} else if (off == APLIC_CLRIPNUM) {
|
|
*val32 = 0;
|
|
} else if ((off >= APLIC_SETIE_BASE) &&
|
|
(off < (APLIC_SETIE_BASE + aplic->nr_words * 4))) {
|
|
i = (off - APLIC_SETIE_BASE) >> 2;
|
|
*val32 = aplic_read_enabled_word(aplic, i);
|
|
} else if (off == APLIC_SETIENUM) {
|
|
*val32 = 0;
|
|
} else if ((off >= APLIC_CLRIE_BASE) &&
|
|
(off < (APLIC_CLRIE_BASE + aplic->nr_words * 4))) {
|
|
*val32 = 0;
|
|
} else if (off == APLIC_CLRIENUM) {
|
|
*val32 = 0;
|
|
} else if (off == APLIC_SETIPNUM_LE) {
|
|
*val32 = 0;
|
|
} else if (off == APLIC_SETIPNUM_BE) {
|
|
*val32 = 0;
|
|
} else if (off == APLIC_GENMSI) {
|
|
*val32 = aplic->genmsi;
|
|
} else if ((off >= APLIC_TARGET_BASE) &&
|
|
(off < (APLIC_TARGET_BASE + (aplic->nr_irqs - 1) * 4))) {
|
|
i = ((off - APLIC_TARGET_BASE) >> 2) + 1;
|
|
*val32 = aplic_read_target(aplic, i);
|
|
} else
|
|
return -ENODEV;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int aplic_mmio_read(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
|
|
gpa_t addr, int len, void *val)
|
|
{
|
|
if (len != 4)
|
|
return -EOPNOTSUPP;
|
|
|
|
return aplic_mmio_read_offset(vcpu->kvm,
|
|
addr - vcpu->kvm->arch.aia.aplic_addr,
|
|
val);
|
|
}
|
|
|
|
static int aplic_mmio_write_offset(struct kvm *kvm, gpa_t off, u32 val32)
|
|
{
|
|
u32 i;
|
|
struct aplic *aplic = kvm->arch.aia.aplic_state;
|
|
|
|
if ((off & 0x3) != 0)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (off == APLIC_DOMAINCFG) {
|
|
/* Only IE bit writeable */
|
|
aplic->domaincfg = val32 & APLIC_DOMAINCFG_IE;
|
|
} else if ((off >= APLIC_SOURCECFG_BASE) &&
|
|
(off < (APLIC_SOURCECFG_BASE + (aplic->nr_irqs - 1) * 4))) {
|
|
i = ((off - APLIC_SOURCECFG_BASE) >> 2) + 1;
|
|
aplic_write_sourcecfg(aplic, i, val32);
|
|
} else if ((off >= APLIC_SETIP_BASE) &&
|
|
(off < (APLIC_SETIP_BASE + aplic->nr_words * 4))) {
|
|
i = (off - APLIC_SETIP_BASE) >> 2;
|
|
aplic_write_pending_word(aplic, i, val32, true);
|
|
} else if (off == APLIC_SETIPNUM) {
|
|
aplic_write_pending(aplic, val32, true);
|
|
} else if ((off >= APLIC_CLRIP_BASE) &&
|
|
(off < (APLIC_CLRIP_BASE + aplic->nr_words * 4))) {
|
|
i = (off - APLIC_CLRIP_BASE) >> 2;
|
|
aplic_write_pending_word(aplic, i, val32, false);
|
|
} else if (off == APLIC_CLRIPNUM) {
|
|
aplic_write_pending(aplic, val32, false);
|
|
} else if ((off >= APLIC_SETIE_BASE) &&
|
|
(off < (APLIC_SETIE_BASE + aplic->nr_words * 4))) {
|
|
i = (off - APLIC_SETIE_BASE) >> 2;
|
|
aplic_write_enabled_word(aplic, i, val32, true);
|
|
} else if (off == APLIC_SETIENUM) {
|
|
aplic_write_enabled(aplic, val32, true);
|
|
} else if ((off >= APLIC_CLRIE_BASE) &&
|
|
(off < (APLIC_CLRIE_BASE + aplic->nr_words * 4))) {
|
|
i = (off - APLIC_CLRIE_BASE) >> 2;
|
|
aplic_write_enabled_word(aplic, i, val32, false);
|
|
} else if (off == APLIC_CLRIENUM) {
|
|
aplic_write_enabled(aplic, val32, false);
|
|
} else if (off == APLIC_SETIPNUM_LE) {
|
|
aplic_write_pending(aplic, val32, true);
|
|
} else if (off == APLIC_SETIPNUM_BE) {
|
|
aplic_write_pending(aplic, __swab32(val32), true);
|
|
} else if (off == APLIC_GENMSI) {
|
|
aplic->genmsi = val32 & ~(APLIC_TARGET_GUEST_IDX_MASK <<
|
|
APLIC_TARGET_GUEST_IDX_SHIFT);
|
|
kvm_riscv_aia_inject_msi_by_id(kvm,
|
|
val32 >> APLIC_TARGET_HART_IDX_SHIFT, 0,
|
|
val32 & APLIC_TARGET_EIID_MASK);
|
|
} else if ((off >= APLIC_TARGET_BASE) &&
|
|
(off < (APLIC_TARGET_BASE + (aplic->nr_irqs - 1) * 4))) {
|
|
i = ((off - APLIC_TARGET_BASE) >> 2) + 1;
|
|
aplic_write_target(aplic, i, val32);
|
|
} else
|
|
return -ENODEV;
|
|
|
|
aplic_update_irq_range(kvm, 1, aplic->nr_irqs - 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int aplic_mmio_write(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
|
|
gpa_t addr, int len, const void *val)
|
|
{
|
|
if (len != 4)
|
|
return -EOPNOTSUPP;
|
|
|
|
return aplic_mmio_write_offset(vcpu->kvm,
|
|
addr - vcpu->kvm->arch.aia.aplic_addr,
|
|
*((const u32 *)val));
|
|
}
|
|
|
|
static struct kvm_io_device_ops aplic_iodoev_ops = {
|
|
.read = aplic_mmio_read,
|
|
.write = aplic_mmio_write,
|
|
};
|
|
|
|
int kvm_riscv_aia_aplic_set_attr(struct kvm *kvm, unsigned long type, u32 v)
|
|
{
|
|
int rc;
|
|
|
|
if (!kvm->arch.aia.aplic_state)
|
|
return -ENODEV;
|
|
|
|
rc = aplic_mmio_write_offset(kvm, type, v);
|
|
if (rc)
|
|
return rc;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int kvm_riscv_aia_aplic_get_attr(struct kvm *kvm, unsigned long type, u32 *v)
|
|
{
|
|
int rc;
|
|
|
|
if (!kvm->arch.aia.aplic_state)
|
|
return -ENODEV;
|
|
|
|
rc = aplic_mmio_read_offset(kvm, type, v);
|
|
if (rc)
|
|
return rc;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int kvm_riscv_aia_aplic_has_attr(struct kvm *kvm, unsigned long type)
|
|
{
|
|
int rc;
|
|
u32 val;
|
|
|
|
if (!kvm->arch.aia.aplic_state)
|
|
return -ENODEV;
|
|
|
|
rc = aplic_mmio_read_offset(kvm, type, &val);
|
|
if (rc)
|
|
return rc;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int kvm_riscv_aia_aplic_init(struct kvm *kvm)
|
|
{
|
|
int i, ret = 0;
|
|
struct aplic *aplic;
|
|
|
|
/* Do nothing if we have zero sources */
|
|
if (!kvm->arch.aia.nr_sources)
|
|
return 0;
|
|
|
|
/* Allocate APLIC global state */
|
|
aplic = kzalloc(sizeof(*aplic), GFP_KERNEL);
|
|
if (!aplic)
|
|
return -ENOMEM;
|
|
kvm->arch.aia.aplic_state = aplic;
|
|
|
|
/* Setup APLIC IRQs */
|
|
aplic->nr_irqs = kvm->arch.aia.nr_sources + 1;
|
|
aplic->nr_words = DIV_ROUND_UP(aplic->nr_irqs, 32);
|
|
aplic->irqs = kcalloc(aplic->nr_irqs,
|
|
sizeof(*aplic->irqs), GFP_KERNEL);
|
|
if (!aplic->irqs) {
|
|
ret = -ENOMEM;
|
|
goto fail_free_aplic;
|
|
}
|
|
for (i = 0; i < aplic->nr_irqs; i++)
|
|
raw_spin_lock_init(&aplic->irqs[i].lock);
|
|
|
|
/* Setup IO device */
|
|
kvm_iodevice_init(&aplic->iodev, &aplic_iodoev_ops);
|
|
mutex_lock(&kvm->slots_lock);
|
|
ret = kvm_io_bus_register_dev(kvm, KVM_MMIO_BUS,
|
|
kvm->arch.aia.aplic_addr,
|
|
KVM_DEV_RISCV_APLIC_SIZE,
|
|
&aplic->iodev);
|
|
mutex_unlock(&kvm->slots_lock);
|
|
if (ret)
|
|
goto fail_free_aplic_irqs;
|
|
|
|
/* Setup default IRQ routing */
|
|
ret = kvm_riscv_setup_default_irq_routing(kvm, aplic->nr_irqs);
|
|
if (ret)
|
|
goto fail_unreg_iodev;
|
|
|
|
return 0;
|
|
|
|
fail_unreg_iodev:
|
|
mutex_lock(&kvm->slots_lock);
|
|
kvm_io_bus_unregister_dev(kvm, KVM_MMIO_BUS, &aplic->iodev);
|
|
mutex_unlock(&kvm->slots_lock);
|
|
fail_free_aplic_irqs:
|
|
kfree(aplic->irqs);
|
|
fail_free_aplic:
|
|
kvm->arch.aia.aplic_state = NULL;
|
|
kfree(aplic);
|
|
return ret;
|
|
}
|
|
|
|
void kvm_riscv_aia_aplic_cleanup(struct kvm *kvm)
|
|
{
|
|
struct aplic *aplic = kvm->arch.aia.aplic_state;
|
|
|
|
if (!aplic)
|
|
return;
|
|
|
|
mutex_lock(&kvm->slots_lock);
|
|
kvm_io_bus_unregister_dev(kvm, KVM_MMIO_BUS, &aplic->iodev);
|
|
mutex_unlock(&kvm->slots_lock);
|
|
|
|
kfree(aplic->irqs);
|
|
|
|
kvm->arch.aia.aplic_state = NULL;
|
|
kfree(aplic);
|
|
}
|