A grab-bag of minor stuff for the end of the year. My to-review

queue is not empty, but it it at least in single figures...

The following changes since commit 5bfbd8170ce7acb98a1834ff49ed7340b0837144:

Merge remote-tracking branch 'remotes/vivier2/tags/trivial-branch-for-6.0-pull-request' into staging (2020-12-14 20:32:38 +0000)

https://git.linaro.org/people/pmaydell/qemu-arm.git tags/pull-target-arm-20201215

for you to fetch changes up to 23af268566069183285bebbdf95b1b37cb7c0942:

hw/block/m25p80: Fix Numonyx fast read dummy cycle count (2020-12-15 13:39:30 +0000)

* gdbstub: Correct misparsing of vCont C/S requests

* openrisc: Move pic_cpu code into CPU object proper

* nios2: Move IIC code into CPU object proper

* Improve reporting of ROM overlap errors

* xlnx-versal: Add USB support

* hw/misc/zynq_slcr: Avoid #DIV/0! error

* Numonyx: Fix dummy cycles and check for SPI mode on cmds

Joe Komlodi (4):

hw/block/m25p80: Make Numonyx config field names more accurate

hw/block/m25p80: Fix when VCFG XIP bit is set for Numonyx

hw/block/m25p80: Check SPI mode before running some Numonyx commands

hw/block/m25p80: Fix Numonyx fast read dummy cycle count

Peter Maydell (11):

gdbstub: Correct misparsing of vCont C/S requests

hw/openrisc/openrisc_sim: Use IRQ splitter when connecting IRQ to multiple CPUs

hw/openrisc/openrisc_sim: Abstract out "get IRQ x of CPU y"

target/openrisc: Move pic_cpu code into CPU object proper

target/nios2: Move IIC code into CPU object proper

target/nios2: Move nios2_check_interrupts() into target/nios2

target/nios2: Use deposit32() to update ipending register

hw/core/loader.c: Track last-seen ROM in rom_check_and_register_reset()

hw/core/loader.c: Improve reporting of ROM overlap errors

elf_ops.h: Don't truncate name of the ROM blobs we create

elf_ops.h: Be more verbose with ROM blob names

Philippe Mathieu-Daudé (1):

hw/misc/zynq_slcr: Avoid #DIV/0! error

Sai Pavan Boddu (2):

usb: Add versal-usb2-ctrl-regs module

usb: xlnx-usb-subsystem: Add xilinx usb subsystem

We're about to refactor the OpenRISC pic_cpu code in a way that means

that just grabbing the whole qemu_irq[] array of inbound IRQs for a

CPU won't be possible any more. Abstract out a function for "return

the qemu_irq for IRQ x input of CPU y" so we can more easily replace

the implementation.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>

Reviewed-by: Stafford Horne <shorne@gmail.com>

Message-id: 20201127225127.14770-3-peter.maydell@linaro.org

---

hw/openrisc/openrisc_sim.c | 38 +++++++++++++++++++++-----------------

1 file changed, 21 insertions(+), 17 deletions(-)

diff --git a/hw/openrisc/openrisc_sim.c b/hw/openrisc/openrisc_sim.c

--- a/hw/openrisc/openrisc_sim.c

+++ b/hw/openrisc/openrisc_sim.c

@@ -XXX,XX +XXX,XX @@ static void main_cpu_reset(void *opaque)

cpu_set_pc(cs, boot_info.bootstrap_pc);

}

+static qemu_irq get_cpu_irq(OpenRISCCPU *cpus[], int cpunum, int irq_pin)

+{

+ return cpus[cpunum]->env.irq[irq_pin];

+}

static void openrisc_sim_net_init(hwaddr base, hwaddr descriptors,

- int num_cpus, qemu_irq **cpu_irqs,

+ int num_cpus, OpenRISCCPU *cpus[],

int irq_pin, NICInfo *nd)

@@ -XXX,XX +XXX,XX @@ static void openrisc_sim_net_init(hwaddr base, hwaddr descriptors,

qdev_prop_set_uint32(splitter, "num-lines", num_cpus);

qdev_realize_and_unref(splitter, NULL, &error_fatal);

for (i = 0; i < num_cpus; i++) {

- qdev_connect_gpio_out(splitter, i, cpu_irqs[i][irq_pin]);

+ qdev_connect_gpio_out(splitter, i, get_cpu_irq(cpus, i, irq_pin));

}

sysbus_connect_irq(s, 0, qdev_get_gpio_in(splitter, 0));

} else {

- sysbus_connect_irq(s, 0, cpu_irqs[0][irq_pin]);

+ sysbus_connect_irq(s, 0, get_cpu_irq(cpus, 0, irq_pin));

}

sysbus_mmio_map(s, 0, base);

sysbus_mmio_map(s, 1, descriptors);

}

static void openrisc_sim_ompic_init(hwaddr base, int num_cpus,

- qemu_irq **cpu_irqs, int irq_pin)

+ OpenRISCCPU *cpus[], int irq_pin)

SysBusDevice *s;

@@ -XXX,XX +XXX,XX @@ static void openrisc_sim_ompic_init(hwaddr base, int num_cpus,

s = SYS_BUS_DEVICE(dev);

sysbus_realize_and_unref(s, &error_fatal);

for (i = 0; i < num_cpus; i++) {

- sysbus_connect_irq(s, i, cpu_irqs[i][irq_pin]);

+ sysbus_connect_irq(s, i, get_cpu_irq(cpus, i, irq_pin));

}

sysbus_mmio_map(s, 0, base);

}

@@ -XXX,XX +XXX,XX @@ static void openrisc_sim_init(MachineState *machine)

{

ram_addr_t ram_size = machine->ram_size;

const char *kernel_filename = machine->kernel_filename;

- OpenRISCCPU *cpu = NULL;

+ OpenRISCCPU *cpus[2] = {};

MemoryRegion *ram;

- qemu_irq *cpu_irqs[2];

qemu_irq serial_irq;

int n;

unsigned int smp_cpus = machine->smp.cpus;

assert(smp_cpus >= 1 && smp_cpus <= 2);

for (n = 0; n < smp_cpus; n++) {

- cpu = OPENRISC_CPU(cpu_create(machine->cpu_type));

- if (cpu == NULL) {

+ cpus[n] = OPENRISC_CPU(cpu_create(machine->cpu_type));

+ if (cpus[n] == NULL) {

fprintf(stderr, "Unable to find CPU definition!\n");

exit(1);

}

- cpu_openrisc_pic_init(cpu);

- cpu_irqs[n] = (qemu_irq *) cpu->env.irq;

+ cpu_openrisc_pic_init(cpus[n]);

- cpu_openrisc_clock_init(cpu);

+ cpu_openrisc_clock_init(cpus[n]);

- qemu_register_reset(main_cpu_reset, cpu);

+ qemu_register_reset(main_cpu_reset, cpus[n]);

}

ram = g_malloc(sizeof(*ram));

@@ -XXX,XX +XXX,XX @@ static void openrisc_sim_init(MachineState *machine)

if (nd_table[0].used) {

openrisc_sim_net_init(0x92000000, 0x92000400, smp_cpus,

- cpu_irqs, 4, nd_table);

+ cpus, 4, nd_table);

}

if (smp_cpus > 1) {

- openrisc_sim_ompic_init(0x98000000, smp_cpus, cpu_irqs, 1);

+ openrisc_sim_ompic_init(0x98000000, smp_cpus, cpus, 1);

- serial_irq = qemu_irq_split(cpu_irqs[0][2], cpu_irqs[1][2]);

+ serial_irq = qemu_irq_split(get_cpu_irq(cpus, 0, 2),

+ get_cpu_irq(cpus, 1, 2));

} else {

- serial_irq = cpu_irqs[0][2];

+ serial_irq = get_cpu_irq(cpus, 0, 2);

}

serial_mm_init(get_system_memory(), 0x90000000, 0, serial_irq,

The openrisc code uses an old style of interrupt handling, where a

separate standalone set of qemu_irqs invoke a function

openrisc_pic_cpu_handler() which signals the interrupt to the CPU

proper by directly calling cpu_interrupt() and cpu_reset_interrupt().

Because CPU objects now inherit (indirectly) from TYPE_DEVICE, they

can have GPIO input lines themselves, and the neater modern way to

implement this is to simply have the CPU object itself provide the

input IRQ lines.

Reviewed-by: Stafford Horne <shorne@gmail.com>

Message-id: 20201127225127.14770-4-peter.maydell@linaro.org

target/openrisc/cpu.h | 1 -

hw/openrisc/openrisc_sim.c | 3 +-

hw/openrisc/pic_cpu.c | 61 --------------------------------------

target/openrisc/cpu.c | 32 ++++++++++++++++++++

hw/openrisc/meson.build | 2 +-

5 files changed, 34 insertions(+), 65 deletions(-)

delete mode 100644 hw/openrisc/pic_cpu.c

diff --git a/target/openrisc/cpu.h b/target/openrisc/cpu.h

--- a/target/openrisc/cpu.h

+++ b/target/openrisc/cpu.h

@@ -XXX,XX +XXX,XX @@ typedef struct CPUOpenRISCState {

uint32_t picmr; /* Interrupt mask register */

uint32_t picsr; /* Interrupt contrl register*/

#endif

- void *irq[32]; /* Interrupt irq input */

} CPUOpenRISCState;

/**

diff --git a/hw/openrisc/openrisc_sim.c b/hw/openrisc/openrisc_sim.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/openrisc/openrisc_sim.c

+++ b/hw/openrisc/openrisc_sim.c

@@ -XXX,XX +XXX,XX @@ static void main_cpu_reset(void *opaque)

static qemu_irq get_cpu_irq(OpenRISCCPU *cpus[], int cpunum, int irq_pin)

{

- return cpus[cpunum]->env.irq[irq_pin];

+ return qdev_get_gpio_in_named(DEVICE(cpus[cpunum]), "IRQ", irq_pin);

}

static void openrisc_sim_net_init(hwaddr base, hwaddr descriptors,

@@ -XXX,XX +XXX,XX @@ static void openrisc_sim_init(MachineState *machine)

fprintf(stderr, "Unable to find CPU definition!\n");

exit(1);

}

- cpu_openrisc_pic_init(cpus[n]);

cpu_openrisc_clock_init(cpus[n]);

diff --git a/hw/openrisc/pic_cpu.c b/hw/openrisc/pic_cpu.c

deleted file mode 100644

index XXXXXXX..XXXXXXX

--- a/hw/openrisc/pic_cpu.c

+++ /dev/null

-/*

- * OpenRISC Programmable Interrupt Controller support.

- *

- * Copyright (c) 2011-2012 Jia Liu <proljc@gmail.com>

- * Feng Gao <gf91597@gmail.com>

- *

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation; either

- * version 2.1 of the License, or (at your option) any later version.

- *

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

- * Lesser General Public License for more details.

- *

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, see <http://www.gnu.org/licenses/>.

- */

-

-#include "qemu/osdep.h"

-#include "hw/irq.h"

-#include "cpu.h"

-

-/* OpenRISC pic handler */

-static void openrisc_pic_cpu_handler(void *opaque, int irq, int level)

- cpu->env.picsr |= irq_bit;

- } else {

- cpu->env.picsr &= ~irq_bit;

- }

-

- if (cpu->env.picsr & cpu->env.picmr) {

- cpu_interrupt(cs, CPU_INTERRUPT_HARD);

- } else {

- cpu_reset_interrupt(cs, CPU_INTERRUPT_HARD);

- cpu->env.picsr = 0;

-void cpu_openrisc_pic_init(OpenRISCCPU *cpu)

-{

- int i;

- qemu_irq *qi;

- qi = qemu_allocate_irqs(openrisc_pic_cpu_handler, cpu, NR_IRQS);

- for (i = 0; i < NR_IRQS; i++) {

- cpu->env.irq[i] = qi[i];

diff --git a/target/openrisc/cpu.c b/target/openrisc/cpu.c

index XXXXXXX..XXXXXXX 100644

--- a/target/openrisc/cpu.c

+++ b/target/openrisc/cpu.c

@@ -XXX,XX +XXX,XX @@ static void openrisc_cpu_reset(DeviceState *dev)

#endif

}

+#ifndef CONFIG_USER_ONLY

+static void openrisc_cpu_set_irq(void *opaque, int irq, int level)

+{

+ OpenRISCCPU *cpu = (OpenRISCCPU *)opaque;

+ CPUState *cs = CPU(cpu);

+ uint32_t irq_bit;

+

+ if (irq > 31 || irq < 0) {

+ return;

+ }

+

+ irq_bit = 1U << irq;

+

+ if (level) {

+ cpu->env.picsr |= irq_bit;

+ } else {

+ cpu->env.picsr &= ~irq_bit;

+ }

+

+ if (cpu->env.picsr & cpu->env.picmr) {

+ cpu_interrupt(cs, CPU_INTERRUPT_HARD);

+ } else {

+ cpu_reset_interrupt(cs, CPU_INTERRUPT_HARD);

+ cpu->env.picsr = 0;

+ }

+}

+#endif

+

static void openrisc_cpu_realizefn(DeviceState *dev, Error **errp)

{

CPUState *cs = CPU(dev);

@@ -XXX,XX +XXX,XX @@ static void openrisc_cpu_initfn(Object *obj)

OpenRISCCPU *cpu = OPENRISC_CPU(obj);

cpu_set_cpustate_pointers(cpu);

+

+#ifndef CONFIG_USER_ONLY

+ qdev_init_gpio_in_named(DEVICE(cpu), openrisc_cpu_set_irq, "IRQ", NR_IRQS);

+#endif

}

/* CPU models */

diff --git a/hw/openrisc/meson.build b/hw/openrisc/meson.build

index XXXXXXX..XXXXXXX 100644

--- a/hw/openrisc/meson.build

+++ b/hw/openrisc/meson.build

@@ -XXX,XX +XXX,XX @@

openrisc_ss = ss.source_set()

-openrisc_ss.add(files('pic_cpu.c', 'cputimer.c'))

+openrisc_ss.add(files('cputimer.c'))

openrisc_ss.add(when: 'CONFIG_OR1K_SIM', if_true: files('openrisc_sim.c'))

hw_arch += {'openrisc': openrisc_ss}

The Nios2 architecture supports two different interrupt controller

options:

* The IIC (Internal Interrupt Controller) is part of the CPU itself;

it has 32 IRQ input lines and no NMI support. Interrupt status is

queried and controlled via the CPU's ipending and istatus

registers.

* The EIC (External Interrupt Controller) interface allows the CPU

to connect to an external interrupt controller. The interface

allows the interrupt controller to present a packet of information

containing:

- handler address

- interrupt level

- register set

- NMI mode

QEMU does not model an EIC currently. We do model the IIC, but its

implementation is split across code in hw/nios2/cpu_pic.c and

hw/intc/nios2_iic.c. The code in those two files has no state of its

own -- the IIC state is in the Nios2CPU state struct.

Because CPU objects now inherit (indirectly) from TYPE_DEVICE, they

can have GPIO input lines themselves, so we can implement the IIC

directly in the CPU object the same way that real hardware does.

Create named "IRQ" GPIO inputs to the Nios2 CPU object, and make the

only user of the IIC wire up directly to those instead.

Note that the old code had an "NMI" concept which was entirely unused

and also as far as I can see not architecturally correct, since only

the EIC has a concept of an NMI.

This fixes a Coverity-reported trivial memory leak of the IRQ array

allocated in nios2_cpu_pic_init().

Fixes: Coverity CID 1421916

Message-id: 20201129174022.26530-2-peter.maydell@linaro.org

Reviewed-by: Wentong Wu <wentong.wu@intel.com>

Tested-by: Wentong Wu <wentong.wu@intel.com>

target/nios2/cpu.h | 1 -

hw/intc/nios2_iic.c | 95 ---------------------------------------

hw/nios2/10m50_devboard.c | 13 +-----

hw/nios2/cpu_pic.c | 31 -------------

target/nios2/cpu.c | 30 +++++++++++++

MAINTAINERS | 1 -

hw/intc/meson.build | 1 -

7 files changed, 32 insertions(+), 140 deletions(-)

delete mode 100644 hw/intc/nios2_iic.c

diff --git a/target/nios2/cpu.h b/target/nios2/cpu.h

index XXXXXXX..XXXXXXX 100644

--- a/target/nios2/cpu.h

+++ b/target/nios2/cpu.h

@@ -XXX,XX +XXX,XX @@ void nios2_cpu_do_unaligned_access(CPUState *cpu, vaddr addr,

MMUAccessType access_type,

int mmu_idx, uintptr_t retaddr);

-qemu_irq *nios2_cpu_pic_init(Nios2CPU *cpu);

void nios2_check_interrupts(CPUNios2State *env);

void do_nios2_semihosting(CPUNios2State *env);

diff --git a/hw/intc/nios2_iic.c b/hw/intc/nios2_iic.c

deleted file mode 100644

index XXXXXXX..XXXXXXX

--- a/hw/intc/nios2_iic.c

+++ /dev/null

@@ -XXX,XX +XXX,XX @@

-/*

- * QEMU Altera Internal Interrupt Controller.

- *

- * Copyright (c) 2012 Chris Wulff <crwulff@gmail.com>

- *

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation; either

- * version 2.1 of the License, or (at your option) any later version.

- *

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

- * Lesser General Public License for more details.

- *

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, see

- * <http://www.gnu.org/licenses/lgpl-2.1.html>

- */

-

-#include "qemu/osdep.h"

-#include "qemu/module.h"

-#include "qapi/error.h"

-

-#include "hw/irq.h"

-#include "hw/sysbus.h"

-#include "cpu.h"

-#include "qom/object.h"

-

-#define TYPE_ALTERA_IIC "altera,iic"

-OBJECT_DECLARE_SIMPLE_TYPE(AlteraIIC, ALTERA_IIC)

-

-struct AlteraIIC {

- SysBusDevice parent_obj;

- void *cpu;

- qemu_irq parent_irq;

-};

-

-static void update_irq(AlteraIIC *pv)

-{

- CPUNios2State *env = &((Nios2CPU *)(pv->cpu))->env;

-

- qemu_set_irq(pv->parent_irq,

- env->regs[CR_IPENDING] & env->regs[CR_IENABLE]);

-}

-

-static void irq_handler(void *opaque, int irq, int level)

-{

- AlteraIIC *pv = opaque;

- CPUNios2State *env = &((Nios2CPU *)(pv->cpu))->env;

-

- env->regs[CR_IPENDING] &= ~(1 << irq);

- env->regs[CR_IPENDING] |= !!level << irq;

-

- update_irq(pv);

-}

-

-static void altera_iic_init(Object *obj)

-{

- AlteraIIC *pv = ALTERA_IIC(obj);

-

- qdev_init_gpio_in(DEVICE(pv), irq_handler, 32);

- sysbus_init_irq(SYS_BUS_DEVICE(obj), &pv->parent_irq);

-}

-

-static void altera_iic_realize(DeviceState *dev, Error **errp)

-{

- struct AlteraIIC *pv = ALTERA_IIC(dev);

-

- pv->cpu = object_property_get_link(OBJECT(dev), "cpu", &error_abort);

-}

-

-static void altera_iic_class_init(ObjectClass *klass, void *data)

-{

- DeviceClass *dc = DEVICE_CLASS(klass);

-

- /* Reason: needs to be wired up, e.g. by nios2_10m50_ghrd_init() */

- dc->user_creatable = false;

- dc->realize = altera_iic_realize;

-}

-

-static TypeInfo altera_iic_info = {

- .name = TYPE_ALTERA_IIC,

- .parent = TYPE_SYS_BUS_DEVICE,

- .instance_size = sizeof(AlteraIIC),

- .instance_init = altera_iic_init,

- .class_init = altera_iic_class_init,

-};

-

-static void altera_iic_register(void)

-{

- type_register_static(&altera_iic_info);

-}

-

-type_init(altera_iic_register)

diff --git a/hw/nios2/10m50_devboard.c b/hw/nios2/10m50_devboard.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/nios2/10m50_devboard.c

+++ b/hw/nios2/10m50_devboard.c

@@ -XXX,XX +XXX,XX @@ static void nios2_10m50_ghrd_init(MachineState *machine)

ram_addr_t tcm_size = 0x1000; /* 1 kiB, but QEMU limit is 4 kiB */

ram_addr_t ram_base = 0x08000000;

ram_addr_t ram_size = 0x08000000;

- qemu_irq *cpu_irq, irq[32];

+ qemu_irq irq[32];

int i;

/* Physical TCM (tb_ram_1k) with alias at 0xc0000000 */

@@ -XXX,XX +XXX,XX @@ static void nios2_10m50_ghrd_init(MachineState *machine)

/* Create CPU -- FIXME */

cpu = NIOS2_CPU(cpu_create(TYPE_NIOS2_CPU));

-

- /* Register: CPU interrupt controller (PIC) */

- cpu_irq = nios2_cpu_pic_init(cpu);

-

- /* Register: Internal Interrupt Controller (IIC) */

- dev = qdev_new("altera,iic");

- object_property_add_const_link(OBJECT(dev), "cpu", OBJECT(cpu));

- sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal);

- sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, cpu_irq[0]);

for (i = 0; i < 32; i++) {

- irq[i] = qdev_get_gpio_in(dev, i);

+ irq[i] = qdev_get_gpio_in_named(DEVICE(cpu), "IRQ", i);

}

/* Register: Altera 16550 UART */

diff --git a/hw/nios2/cpu_pic.c b/hw/nios2/cpu_pic.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/nios2/cpu_pic.c

+++ b/hw/nios2/cpu_pic.c

@@ -XXX,XX +XXX,XX @@

#include "boot.h"

-static void nios2_pic_cpu_handler(void *opaque, int irq, int level)

-{

- Nios2CPU *cpu = opaque;

- CPUNios2State *env = &cpu->env;

- CPUState *cs = CPU(cpu);

- int type = irq ? CPU_INTERRUPT_NMI : CPU_INTERRUPT_HARD;

-

- if (type == CPU_INTERRUPT_HARD) {

- env->irq_pending = level;

-

- if (level && (env->regs[CR_STATUS] & CR_STATUS_PIE)) {

- env->irq_pending = 0;

- cpu_interrupt(cs, type);

- } else if (!level) {

- env->irq_pending = 0;

- cpu_reset_interrupt(cs, type);

- }

- } else {

- if (level) {

- cpu_interrupt(cs, type);

- cpu_reset_interrupt(cs, type);

- }

- }

-}

-

void nios2_check_interrupts(CPUNios2State *env)

{

if (env->irq_pending &&

@@ -XXX,XX +XXX,XX @@ void nios2_check_interrupts(CPUNios2State *env)

cpu_interrupt(env_cpu(env), CPU_INTERRUPT_HARD);

}

}

-

-qemu_irq *nios2_cpu_pic_init(Nios2CPU *cpu)

-{

- return qemu_allocate_irqs(nios2_pic_cpu_handler, cpu, 2);

-}

diff --git a/target/nios2/cpu.c b/target/nios2/cpu.c

index XXXXXXX..XXXXXXX 100644

--- a/target/nios2/cpu.c

+++ b/target/nios2/cpu.c

@@ -XXX,XX +XXX,XX @@ static void nios2_cpu_reset(DeviceState *dev)

#endif

}

+#ifndef CONFIG_USER_ONLY

+static void nios2_cpu_set_irq(void *opaque, int irq, int level)

+{

+ Nios2CPU *cpu = opaque;

+ CPUNios2State *env = &cpu->env;

+ CPUState *cs = CPU(cpu);

+

+ env->regs[CR_IPENDING] &= ~(1 << irq);

+ env->regs[CR_IPENDING] |= !!level << irq;

+

+ env->irq_pending = env->regs[CR_IPENDING] & env->regs[CR_IENABLE];

+

+ if (env->irq_pending && (env->regs[CR_STATUS] & CR_STATUS_PIE)) {

+ env->irq_pending = 0;

+ cpu_interrupt(cs, CPU_INTERRUPT_HARD);

+ } else if (!env->irq_pending) {

+ cpu_reset_interrupt(cs, CPU_INTERRUPT_HARD);

+ }

+}

+#endif

+

static void nios2_cpu_initfn(Object *obj)

{

Nios2CPU *cpu = NIOS2_CPU(obj);

@@ -XXX,XX +XXX,XX @@ static void nios2_cpu_initfn(Object *obj)

#if !defined(CONFIG_USER_ONLY)

mmu_init(&cpu->env);

+

+ /*

+ * These interrupt lines model the IIC (internal interrupt

+ * controller). QEMU does not currently support the EIC

+ * (external interrupt controller) -- if we did it would be

+ * a separate device in hw/intc with a custom interface to

+ * the CPU, and boards using it would not wire up these IRQ lines.

+ */

+ qdev_init_gpio_in_named(DEVICE(cpu), nios2_cpu_set_irq, "IRQ", 32);

#endif

}

diff --git a/MAINTAINERS b/MAINTAINERS

index XXXXXXX..XXXXXXX 100644

--- a/MAINTAINERS

+++ b/MAINTAINERS

@@ -XXX,XX +XXX,XX @@ M: Marek Vasut <marex@denx.de>

S: Maintained

F: target/nios2/

F: hw/nios2/

-F: hw/intc/nios2_iic.c

F: disas/nios2.c

F: default-configs/nios2-softmmu.mak

diff --git a/hw/intc/meson.build b/hw/intc/meson.build

index XXXXXXX..XXXXXXX 100644

--- a/hw/intc/meson.build

+++ b/hw/intc/meson.build

@@ -XXX,XX +XXX,XX @@ specific_ss.add(when: 'CONFIG_IBEX', if_true: files('ibex_plic.c'))

specific_ss.add(when: 'CONFIG_IOAPIC', if_true: files('ioapic.c'))

specific_ss.add(when: 'CONFIG_LOONGSON_LIOINTC', if_true: files('loongson_liointc.c'))

specific_ss.add(when: 'CONFIG_MIPS_CPS', if_true: files('mips_gic.c'))

-specific_ss.add(when: 'CONFIG_NIOS2', if_true: files('nios2_iic.c'))

specific_ss.add(when: 'CONFIG_OMAP', if_true: files('omap_intc.c'))

specific_ss.add(when: 'CONFIG_OMPIC', if_true: files('ompic.c'))

specific_ss.add(when: 'CONFIG_OPENPIC_KVM', if_true: files('openpic_kvm.c'))

The function nios2_check_interrupts)() looks only at CPU-internal

state; it belongs in target/nios2, not hw/nios2. Move it into the

same file as its only caller, so it can just be local to that file.

This removes the only remaining code from cpu_pic.c, so we can delete

that file entirely.

Message-id: 20201129174022.26530-3-peter.maydell@linaro.org

Reviewed-by: Wentong Wu <wentong.wu@intel.com>

Tested-by: Wentong Wu <wentong.wu@intel.com>

target/nios2/cpu.h | 2 --

hw/nios2/cpu_pic.c | 36 ------------------------------------

target/nios2/op_helper.c | 9 +++++++++

hw/nios2/meson.build | 2 +-

4 files changed, 10 insertions(+), 39 deletions(-)

delete mode 100644 hw/nios2/cpu_pic.c

diff --git a/target/nios2/cpu.h b/target/nios2/cpu.h

--- a/target/nios2/cpu.h

+++ b/target/nios2/cpu.h

@@ -XXX,XX +XXX,XX @@ void nios2_cpu_do_unaligned_access(CPUState *cpu, vaddr addr,

MMUAccessType access_type,

int mmu_idx, uintptr_t retaddr);

-void nios2_check_interrupts(CPUNios2State *env);

-

void do_nios2_semihosting(CPUNios2State *env);

#define CPU_RESOLVING_TYPE TYPE_NIOS2_CPU

diff --git a/hw/nios2/cpu_pic.c b/hw/nios2/cpu_pic.c

deleted file mode 100644

index XXXXXXX..XXXXXXX

--- a/hw/nios2/cpu_pic.c

+++ /dev/null

@@ -XXX,XX +XXX,XX @@

-/*

- * Altera Nios2 CPU PIC

- *

- * Copyright (c) 2016 Marek Vasut <marek.vasut@gmail.com>

- *

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation; either

- * version 2.1 of the License, or (at your option) any later version.

- *

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

- * Lesser General Public License for more details.

- *

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, see

- * <http://www.gnu.org/licenses/lgpl-2.1.html>

- */

-

-#include "qemu/osdep.h"

-#include "cpu.h"

-#include "hw/irq.h"

-

-#include "qemu/config-file.h"

-

-#include "boot.h"

-

-void nios2_check_interrupts(CPUNios2State *env)

-{

- if (env->irq_pending &&

- (env->regs[CR_STATUS] & CR_STATUS_PIE)) {

- env->irq_pending = 0;

- cpu_interrupt(env_cpu(env), CPU_INTERRUPT_HARD);

- }

-}

diff --git a/target/nios2/op_helper.c b/target/nios2/op_helper.c

--- a/target/nios2/op_helper.c

+++ b/target/nios2/op_helper.c

@@ -XXX,XX +XXX,XX @@ void helper_mmu_write(CPUNios2State *env, uint32_t rn, uint32_t v)

mmu_write(env, rn, v);

}

+static void nios2_check_interrupts(CPUNios2State *env)

+ if (env->irq_pending &&

+ (env->regs[CR_STATUS] & CR_STATUS_PIE)) {

+ env->irq_pending = 0;

+ cpu_interrupt(env_cpu(env), CPU_INTERRUPT_HARD);

void helper_check_interrupts(CPUNios2State *env)

qemu_mutex_lock_iothread();

diff --git a/hw/nios2/meson.build b/hw/nios2/meson.build

index XXXXXXX..XXXXXXX 100644

--- a/hw/nios2/meson.build

+++ b/hw/nios2/meson.build

@@ -XXX,XX +XXX,XX @@

nios2_ss = ss.source_set()

-nios2_ss.add(files('boot.c', 'cpu_pic.c'))

+nios2_ss.add(files('boot.c'))

nios2_ss.add(when: 'CONFIG_NIOS2_10M50', if_true: files('10m50_devboard.c'))

nios2_ss.add(when: 'CONFIG_NIOS2_GENERIC_NOMMU', if_true: files('generic_nommu.c'))

In nios2_cpu_set_irq(), use deposit32() rather than raw shift-and-mask

operations to set the appropriate bit in the ipending register.

Message-id: 20201129174022.26530-4-peter.maydell@linaro.org

target/nios2/cpu.c | 3 +--

1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/target/nios2/cpu.c b/target/nios2/cpu.c

--- a/target/nios2/cpu.c

+++ b/target/nios2/cpu.c

@@ -XXX,XX +XXX,XX @@ static void nios2_cpu_set_irq(void *opaque, int irq, int level)

CPUNios2State *env = &cpu->env;

CPUState *cs = CPU(cpu);

- env->regs[CR_IPENDING] &= ~(1 << irq);

- env->regs[CR_IPENDING] |= !!level << irq;

+ env->regs[CR_IPENDING] = deposit32(env->regs[CR_IPENDING], irq, 1, !!level);

env->irq_pending = env->regs[CR_IPENDING] & env->regs[CR_IENABLE];

In rom_check_and_register_reset() we report to the user if there is

a "ROM region overlap". This has a couple of problems:

* the reported information is not very easy to intepret

* the function just prints the overlap to stderr (and relies on

its single callsite in vl.c to do an error_report() and exit)

* only the first overlap encountered is diagnosed

Make this function use error_report() and error_printf() and

report a more user-friendly report with all the overlaps

diagnosed.

Sample old output:

rom: requested regions overlap (rom dtb. free=0x0000000000008000, addr=0x0000000000000000)

qemu-system-aarch64: rom check and register reset failed

Sample new output:

qemu-system-aarch64: Some ROM regions are overlapping

These ROM regions might have been loaded by direct user request or by default.

They could be BIOS/firmware images, a guest kernel, initrd or some other file loaded into guest memory.

Check whether you intended to load all this guest code, and whether it has been built to load to the correct addresses.

The following two regions overlap (in the cpu-memory-0 address space):

phdr #0: /home/petmay01/linaro/qemu-misc-tests/ldmia-fault.axf (addresses 0x0000000000000000 - 0x0000000000008000)

dtb (addresses 0x0000000000000000 - 0x0000000000100000)

The following two regions overlap (in the cpu-memory-0 address space):

phdr #1: /home/petmay01/linaro/qemu-misc-tests/bad-psci-call.axf (addresses 0x0000000040000000 - 0x0000000040000010)

phdr #0: /home/petmay01/linaro/qemu-misc-tests/bp-test.elf (addresses 0x0000000040000000 - 0x0000000040000020)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

Message-id: 20201129203923.10622-3-peter.maydell@linaro.org

hw/core/loader.c | 48 ++++++++++++++++++++++++++++++++++++++++++------

softmmu/vl.c | 1 -

2 files changed, 42 insertions(+), 7 deletions(-)

diff --git a/hw/core/loader.c b/hw/core/loader.c

--- a/hw/core/loader.c

+++ b/hw/core/loader.c

@@ -XXX,XX +XXX,XX @@ static bool roms_overlap(Rom *last_rom, Rom *this_rom)

last_rom->addr + last_rom->romsize > this_rom->addr;

}

+static const char *rom_as_name(Rom *rom)

+ const char *name = rom->as ? rom->as->name : NULL;

+ return name ?: "anonymous";

+static void rom_print_overlap_error_header(void)

+{

+ error_report("Some ROM regions are overlapping");

+ error_printf(

+ "These ROM regions might have been loaded by "

+ "direct user request or by default.\n"

+ "They could be BIOS/firmware images, a guest kernel, "

+ "initrd or some other file loaded into guest memory.\n"

+ "Check whether you intended to load all this guest code, and "

+ "whether it has been built to load to the correct addresses.\n");

+}

+

+static void rom_print_one_overlap_error(Rom *last_rom, Rom *rom)

+{

+ error_printf(

+ "\nThe following two regions overlap (in the %s address space):\n",

+ rom_as_name(rom));

+ error_printf(

+ " %s (addresses 0x" TARGET_FMT_plx " - 0x" TARGET_FMT_plx ")\n",

+ last_rom->name, last_rom->addr, last_rom->addr + last_rom->romsize);

+ error_printf(

+ " %s (addresses 0x" TARGET_FMT_plx " - 0x" TARGET_FMT_plx ")\n",

+ rom->name, rom->addr, rom->addr + rom->romsize);

+}