mirror of
https://gitlab.com/qemu-project/qemu
synced 2024-11-05 20:35:44 +00:00
c6f3f334d1
MX PIC comes out of reset with IRQ routing registers set to 0, thus not delivering any external IRQ to any connected CPU by default. Fix the model to match the hardware. Signed-off-by: Max Filippov <jcmvbkbc@gmail.com>
354 lines
10 KiB
C
354 lines
10 KiB
C
/*
|
|
* Copyright (c) 2013 - 2019, Max Filippov, Open Source and Linux Lab.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the Open Source and Linux Lab nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "hw/irq.h"
|
|
#include "hw/xtensa/mx_pic.h"
|
|
#include "qemu/log.h"
|
|
|
|
#define MX_MAX_CPU 32
|
|
#define MX_MAX_IRQ 32
|
|
|
|
#define MIROUT 0x0
|
|
#define MIPICAUSE 0x100
|
|
#define MIPISET 0x140
|
|
#define MIENG 0x180
|
|
#define MIENGSET 0x184
|
|
#define MIASG 0x188
|
|
#define MIASGSET 0x18c
|
|
#define MIPIPART 0x190
|
|
#define SYSCFGID 0x1a0
|
|
#define MPSCORE 0x200
|
|
#define CCON 0x220
|
|
|
|
struct XtensaMxPic {
|
|
unsigned n_cpu;
|
|
unsigned n_irq;
|
|
|
|
uint32_t ext_irq_state;
|
|
uint32_t mieng;
|
|
uint32_t miasg;
|
|
uint32_t mirout[MX_MAX_IRQ];
|
|
uint32_t mipipart;
|
|
uint32_t runstall;
|
|
|
|
qemu_irq *irq_inputs;
|
|
struct XtensaMxPicCpu {
|
|
XtensaMxPic *mx;
|
|
qemu_irq *irq;
|
|
qemu_irq runstall;
|
|
uint32_t mipicause;
|
|
uint32_t mirout_cache;
|
|
uint32_t irq_state_cache;
|
|
uint32_t ccon;
|
|
MemoryRegion reg;
|
|
} cpu[MX_MAX_CPU];
|
|
};
|
|
|
|
static uint64_t xtensa_mx_pic_ext_reg_read(void *opaque, hwaddr offset,
|
|
unsigned size)
|
|
{
|
|
struct XtensaMxPicCpu *mx_cpu = opaque;
|
|
struct XtensaMxPic *mx = mx_cpu->mx;
|
|
|
|
if (offset < MIROUT + MX_MAX_IRQ) {
|
|
return mx->mirout[offset - MIROUT];
|
|
} else if (offset >= MIPICAUSE && offset < MIPICAUSE + MX_MAX_CPU) {
|
|
return mx->cpu[offset - MIPICAUSE].mipicause;
|
|
} else {
|
|
switch (offset) {
|
|
case MIENG:
|
|
return mx->mieng;
|
|
|
|
case MIASG:
|
|
return mx->miasg;
|
|
|
|
case MIPIPART:
|
|
return mx->mipipart;
|
|
|
|
case SYSCFGID:
|
|
return ((mx->n_cpu - 1) << 18) | (mx_cpu - mx->cpu);
|
|
|
|
case MPSCORE:
|
|
return mx->runstall;
|
|
|
|
case CCON:
|
|
return mx_cpu->ccon;
|
|
|
|
default:
|
|
qemu_log_mask(LOG_GUEST_ERROR,
|
|
"unknown RER in MX PIC range: 0x%08x\n",
|
|
(uint32_t)offset);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
static uint32_t xtensa_mx_pic_get_ipi_for_cpu(const XtensaMxPic *mx,
|
|
unsigned cpu)
|
|
{
|
|
uint32_t mipicause = mx->cpu[cpu].mipicause;
|
|
uint32_t mipipart = mx->mipipart;
|
|
|
|
return (((mipicause & 1) << (mipipart & 3)) |
|
|
((mipicause & 0x000e) != 0) << ((mipipart >> 2) & 3) |
|
|
((mipicause & 0x00f0) != 0) << ((mipipart >> 4) & 3) |
|
|
((mipicause & 0xff00) != 0) << ((mipipart >> 6) & 3)) & 0x7;
|
|
}
|
|
|
|
static uint32_t xtensa_mx_pic_get_ext_irq_for_cpu(const XtensaMxPic *mx,
|
|
unsigned cpu)
|
|
{
|
|
return ((((mx->ext_irq_state & mx->mieng) | mx->miasg) &
|
|
mx->cpu[cpu].mirout_cache) << 2) |
|
|
xtensa_mx_pic_get_ipi_for_cpu(mx, cpu);
|
|
}
|
|
|
|
static void xtensa_mx_pic_update_cpu(XtensaMxPic *mx, unsigned cpu)
|
|
{
|
|
uint32_t irq = xtensa_mx_pic_get_ext_irq_for_cpu(mx, cpu);
|
|
uint32_t changed_irq = mx->cpu[cpu].irq_state_cache ^ irq;
|
|
unsigned i;
|
|
|
|
qemu_log_mask(CPU_LOG_INT, "%s: CPU %d, irq: %08x, changed_irq: %08x\n",
|
|
__func__, cpu, irq, changed_irq);
|
|
mx->cpu[cpu].irq_state_cache = irq;
|
|
for (i = 0; changed_irq; ++i) {
|
|
uint32_t mask = 1u << i;
|
|
|
|
if (changed_irq & mask) {
|
|
changed_irq ^= mask;
|
|
qemu_set_irq(mx->cpu[cpu].irq[i], irq & mask);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void xtensa_mx_pic_update_all(XtensaMxPic *mx)
|
|
{
|
|
unsigned cpu;
|
|
|
|
for (cpu = 0; cpu < mx->n_cpu; ++cpu) {
|
|
xtensa_mx_pic_update_cpu(mx, cpu);
|
|
}
|
|
}
|
|
|
|
static void xtensa_mx_pic_ext_reg_write(void *opaque, hwaddr offset,
|
|
uint64_t v, unsigned size)
|
|
{
|
|
struct XtensaMxPicCpu *mx_cpu = opaque;
|
|
struct XtensaMxPic *mx = mx_cpu->mx;
|
|
unsigned cpu;
|
|
|
|
if (offset < MIROUT + mx->n_irq) {
|
|
mx->mirout[offset - MIROUT] = v;
|
|
for (cpu = 0; cpu < mx->n_cpu; ++cpu) {
|
|
uint32_t mask = 1u << (offset - MIROUT);
|
|
|
|
if (!(mx->cpu[cpu].mirout_cache & mask) != !(v & (1u << cpu))) {
|
|
mx->cpu[cpu].mirout_cache ^= mask;
|
|
xtensa_mx_pic_update_cpu(mx, cpu);
|
|
}
|
|
}
|
|
} else if (offset >= MIPICAUSE && offset < MIPICAUSE + mx->n_cpu) {
|
|
cpu = offset - MIPICAUSE;
|
|
mx->cpu[cpu].mipicause &= ~v;
|
|
xtensa_mx_pic_update_cpu(mx, cpu);
|
|
} else if (offset >= MIPISET && offset < MIPISET + 16) {
|
|
for (cpu = 0; cpu < mx->n_cpu; ++cpu) {
|
|
if (v & (1u << cpu)) {
|
|
mx->cpu[cpu].mipicause |= 1u << (offset - MIPISET);
|
|
xtensa_mx_pic_update_cpu(mx, cpu);
|
|
}
|
|
}
|
|
} else {
|
|
uint32_t change = 0;
|
|
uint32_t oldv, newv;
|
|
const char *name = "???";
|
|
|
|
switch (offset) {
|
|
case MIENG:
|
|
change = mx->mieng & v;
|
|
oldv = mx->mieng;
|
|
mx->mieng &= ~v;
|
|
newv = mx->mieng;
|
|
name = "MIENG";
|
|
break;
|
|
|
|
case MIENGSET:
|
|
change = ~mx->mieng & v;
|
|
oldv = mx->mieng;
|
|
mx->mieng |= v;
|
|
newv = mx->mieng;
|
|
name = "MIENG";
|
|
break;
|
|
|
|
case MIASG:
|
|
change = mx->miasg & v;
|
|
oldv = mx->miasg;
|
|
mx->miasg &= ~v;
|
|
newv = mx->miasg;
|
|
name = "MIASG";
|
|
break;
|
|
|
|
case MIASGSET:
|
|
change = ~mx->miasg & v;
|
|
oldv = mx->miasg;
|
|
mx->miasg |= v;
|
|
newv = mx->miasg;
|
|
name = "MIASG";
|
|
break;
|
|
|
|
case MIPIPART:
|
|
change = mx->mipipart ^ v;
|
|
oldv = mx->mipipart;
|
|
mx->mipipart = v;
|
|
newv = mx->mipipart;
|
|
name = "MIPIPART";
|
|
break;
|
|
|
|
case MPSCORE:
|
|
change = mx->runstall ^ v;
|
|
oldv = mx->runstall;
|
|
mx->runstall = v;
|
|
newv = mx->runstall;
|
|
name = "RUNSTALL";
|
|
for (cpu = 0; cpu < mx->n_cpu; ++cpu) {
|
|
if (change & (1u << cpu)) {
|
|
qemu_set_irq(mx->cpu[cpu].runstall, v & (1u << cpu));
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CCON:
|
|
mx_cpu->ccon = v & 0x1;
|
|
break;
|
|
|
|
default:
|
|
qemu_log_mask(LOG_GUEST_ERROR,
|
|
"unknown WER in MX PIC range: 0x%08x = 0x%08x\n",
|
|
(uint32_t)offset, (uint32_t)v);
|
|
break;
|
|
}
|
|
if (change) {
|
|
qemu_log_mask(CPU_LOG_INT,
|
|
"%s: %s changed by CPU %d: %08x -> %08x\n",
|
|
__func__, name, (int)(mx_cpu - mx->cpu),
|
|
oldv, newv);
|
|
xtensa_mx_pic_update_all(mx);
|
|
}
|
|
}
|
|
}
|
|
|
|
static const MemoryRegionOps xtensa_mx_pic_ops = {
|
|
.read = xtensa_mx_pic_ext_reg_read,
|
|
.write = xtensa_mx_pic_ext_reg_write,
|
|
.endianness = DEVICE_NATIVE_ENDIAN,
|
|
.valid = {
|
|
.unaligned = true,
|
|
},
|
|
};
|
|
|
|
MemoryRegion *xtensa_mx_pic_register_cpu(XtensaMxPic *mx,
|
|
qemu_irq *irq,
|
|
qemu_irq runstall)
|
|
{
|
|
struct XtensaMxPicCpu *mx_cpu = mx->cpu + mx->n_cpu;
|
|
|
|
mx_cpu->mx = mx;
|
|
mx_cpu->irq = irq;
|
|
mx_cpu->runstall = runstall;
|
|
|
|
memory_region_init_io(&mx_cpu->reg, NULL, &xtensa_mx_pic_ops, mx_cpu,
|
|
"mx_pic", 0x280);
|
|
|
|
++mx->n_cpu;
|
|
return &mx_cpu->reg;
|
|
}
|
|
|
|
static void xtensa_mx_pic_set_irq(void *opaque, int irq, int active)
|
|
{
|
|
XtensaMxPic *mx = opaque;
|
|
|
|
if (irq < mx->n_irq) {
|
|
uint32_t old_irq_state = mx->ext_irq_state;
|
|
|
|
if (active) {
|
|
mx->ext_irq_state |= 1u << irq;
|
|
} else {
|
|
mx->ext_irq_state &= ~(1u << irq);
|
|
}
|
|
if (old_irq_state != mx->ext_irq_state) {
|
|
qemu_log_mask(CPU_LOG_INT,
|
|
"%s: IRQ %d, active: %d, ext_irq_state: %08x -> %08x\n",
|
|
__func__, irq, active,
|
|
old_irq_state, mx->ext_irq_state);
|
|
xtensa_mx_pic_update_all(mx);
|
|
}
|
|
} else {
|
|
qemu_log_mask(LOG_GUEST_ERROR, "%s: IRQ %d out of range\n",
|
|
__func__, irq);
|
|
}
|
|
}
|
|
|
|
XtensaMxPic *xtensa_mx_pic_init(unsigned n_irq)
|
|
{
|
|
XtensaMxPic *mx = calloc(1, sizeof(XtensaMxPic));
|
|
|
|
mx->n_irq = n_irq + 1;
|
|
mx->irq_inputs = qemu_allocate_irqs(xtensa_mx_pic_set_irq, mx,
|
|
mx->n_irq);
|
|
return mx;
|
|
}
|
|
|
|
void xtensa_mx_pic_reset(void *opaque)
|
|
{
|
|
XtensaMxPic *mx = opaque;
|
|
unsigned i;
|
|
|
|
mx->ext_irq_state = 0;
|
|
mx->mieng = mx->n_irq < 32 ? (1u << mx->n_irq) - 1 : ~0u;
|
|
mx->miasg = 0;
|
|
mx->mipipart = 0;
|
|
for (i = 0; i < mx->n_irq; ++i) {
|
|
mx->mirout[i] = 0;
|
|
}
|
|
for (i = 0; i < mx->n_cpu; ++i) {
|
|
mx->cpu[i].mipicause = 0;
|
|
mx->cpu[i].mirout_cache = i ? 0 : mx->mieng;
|
|
mx->cpu[i].irq_state_cache = 0;
|
|
mx->cpu[i].ccon = 0;
|
|
}
|
|
mx->runstall = (1u << mx->n_cpu) - 2;
|
|
for (i = 0; i < mx->n_cpu; ++i) {
|
|
qemu_set_irq(mx->cpu[i].runstall, i > 0);
|
|
}
|
|
}
|
|
|
|
qemu_irq *xtensa_mx_pic_get_extints(XtensaMxPic *mx)
|
|
{
|
|
return mx->irq_inputs + 1;
|
|
}
|