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

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

Vikram Garhwal (2):

usb: Add DWC3 model

arm: xlnx-versal: Connect usb to virt-versal

VCFG XIP is set (disabled) when the NVCFG XIP bits are all set (disabled).

Signed-off-by: Joe Komlodi <komlodi@xilinx.com>

Reviewed-by: Francisco Iglesias <francisco.iglesias@xilinx.com>

Message-id: 1605568264-26376-3-git-send-email-komlodi@xilinx.com

hw/block/m25p80.c | 2 +-

diff --git a/hw/block/m25p80.c b/hw/block/m25p80.c

--- a/hw/block/m25p80.c

+++ b/hw/block/m25p80.c

@@ -XXX,XX +XXX,XX @@ static void reset_memory(Flash *s)

s->volatile_cfg |= VCFG_DUMMY;

s->volatile_cfg |= VCFG_WRAP_SEQUENTIAL;

if ((s->nonvolatile_cfg & NVCFG_XIP_MODE_MASK)

- != NVCFG_XIP_MODE_DISABLED) {

+ == NVCFG_XIP_MODE_DISABLED) {

s->volatile_cfg |= VCFG_XIP_MODE_DISABLED;

}

s->volatile_cfg |= deposit32(s->volatile_cfg,

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.

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)

{

DeviceState *dev;

@@ -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)

{

DeviceState *dev;

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,

openrisc_sim_net_init() attempts to connect the IRQ line from the

ethernet device to both CPUs in an SMP configuration by simply caling

sysbus_connect_irq() for it twice. This doesn't work, because the

second connection simply overrides the first.

Fix this by creating a TYPE_SPLIT_IRQ to split the IRQ in the SMP

case.

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

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

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

hw/openrisc/Kconfig | 1 +

2 files changed, 12 insertions(+), 2 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 @@

#include "hw/sysbus.h"

#include "sysemu/qtest.h"

#include "sysemu/reset.h"

+#include "hw/core/split-irq.h"

#define KERNEL_LOAD_ADDR 0x100

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

s = SYS_BUS_DEVICE(dev);

sysbus_realize_and_unref(s, &error_fatal);

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

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

+ if (num_cpus > 1) {

+ DeviceState *splitter = qdev_new(TYPE_SPLIT_IRQ);

+ 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]);

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

+ } else {

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

sysbus_mmio_map(s, 0, base);

sysbus_mmio_map(s, 1, descriptors);

diff --git a/hw/openrisc/Kconfig b/hw/openrisc/Kconfig

--- a/hw/openrisc/Kconfig

+++ b/hw/openrisc/Kconfig

@@ -XXX,XX +XXX,XX @@ config OR1K_SIM

select SERIAL

select OPENCORES_ETH

select OMPIC

+ select SPLIT_IRQ

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

operations to set the appropriate bit in the ipending register.

Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>

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];

Instead of making the ROM blob name something like:

phdr #0: /home/petmay01/linaro/qemu-misc-tests/ldmia-fault.axf

make it a little more self-explanatory for people who don't know

ELF format details:

/home/petmay01/linaro/qemu-misc-tests/ldmia-fault.axf ELF program header segment 0

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

include/hw/elf_ops.h | 3 ++-

1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/hw/elf_ops.h b/include/hw/elf_ops.h

--- a/include/hw/elf_ops.h

+++ b/include/hw/elf_ops.h

@@ -XXX,XX +XXX,XX @@ static int glue(load_elf, SZ)(const char *name, int fd,

if (mem_size != 0) {

if (load_rom) {

g_autofree char *label =

- g_strdup_printf("phdr #%d: %s", i, name);

+ g_strdup_printf("%s ELF program header segment %d",

+ name, i);

/*

* rom_add_elf_program() takes its own reference to

Currently the load_elf code assembles the ROM blob name into a

local 128 byte fixed-size array. Use g_strdup_printf() instead so

that we don't truncate the pathname if it happens to be long.

(This matters mostly for monitor 'info roms' output and for the

error messages if ROM blobs overlap.)

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

include/hw/elf_ops.h | 4 ++--

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

diff --git a/include/hw/elf_ops.h b/include/hw/elf_ops.h

--- a/include/hw/elf_ops.h

+++ b/include/hw/elf_ops.h

@@ -XXX,XX +XXX,XX @@ static int glue(load_elf, SZ)(const char *name, int fd,

uint64_t addr, low = (uint64_t)-1, high = 0;

GMappedFile *mapped_file = NULL;

uint8_t *data = NULL;

- char label[128];

int ret = ELF_LOAD_FAILED;

if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr))

@@ -XXX,XX +XXX,XX @@ static int glue(load_elf, SZ)(const char *name, int fd,

*/

if (mem_size != 0) {

if (load_rom) {

- snprintf(label, sizeof(label), "phdr #%d: %s", i, name);

+ g_autofree char *label =

+ g_strdup_printf("phdr #%d: %s", i, name);

/*

* rom_add_elf_program() takes its own reference to

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)

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);

+}

+

int rom_check_and_register_reset(void)

{

MemoryRegionSection section;

Rom *rom, *last_rom = NULL;

+ bool found_overlap = false;

QTAILQ_FOREACH(rom, &roms, next) {

if (rom->fw_file) {

@@ -XXX,XX +XXX,XX @@ int rom_check_and_register_reset(void)

}

if (!rom->mr) {

if (roms_overlap(last_rom, rom)) {

- fprintf(stderr, "rom: requested regions overlap "

- "(rom %s. free=0x" TARGET_FMT_plx

- ", addr=0x" TARGET_FMT_plx ")\n",

- rom->name, last_rom->addr + last_rom->romsize,

- rom->addr);

- return -1;

+ if (!found_overlap) {

+ found_overlap = true;

+ rom_print_overlap_error_header();

+ }

+ rom_print_one_overlap_error(last_rom, rom);

+ /* Keep going through the list so we report all overlaps */

}

last_rom = rom;

}

@@ -XXX,XX +XXX,XX @@ int rom_check_and_register_reset(void)

rom->isrom = int128_nz(section.size) && memory_region_is_rom(section.mr);

memory_region_unref(section.mr);

}

+ if (found_overlap) {

+ return -1;

+ }

+

qemu_register_reset(rom_reset, NULL);

roms_loaded = 1;

return 0;

diff --git a/softmmu/vl.c b/softmmu/vl.c

index XXXXXXX..XXXXXXX 100644

--- a/softmmu/vl.c

+++ b/softmmu/vl.c

@@ -XXX,XX +XXX,XX @@ static void qemu_machine_creation_done(void)

qemu_run_machine_init_done_notifiers();

if (rom_check_and_register_reset() != 0) {

- error_report("rom check and register reset failed");

exit(1);

}

In rom_check_and_register_reset() we detect overlaps by looking at

whether the ROM blob we're currently examining is in the same address

space and starts before the previous ROM blob ends. (This works

because the ROM list is kept sorted in order by AddressSpace and then

by address.)

Instead of keeping the AddressSpace and last address of the previous ROM

blob in local variables, just keep a pointer to it.

This will allow us to print more useful information when we do detect

an overlap.

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

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

1 file changed, 15 insertions(+), 8 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 void rom_reset(void *unused)

}

+/* Return true if two consecutive ROMs in the ROM list overlap */

+static bool roms_overlap(Rom *last_rom, Rom *this_rom)

+ if (!last_rom) {

+ return false;

+ return last_rom->as == this_rom->as &&

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

int rom_check_and_register_reset(void)

- hwaddr addr = 0;

MemoryRegionSection section;

- Rom *rom;

- AddressSpace *as = NULL;

+ Rom *rom, *last_rom = NULL;

QTAILQ_FOREACH(rom, &roms, next) {

if (rom->fw_file) {

continue;

}

if (!rom->mr) {

- if ((addr > rom->addr) && (as == rom->as)) {

+ if (roms_overlap(last_rom, rom)) {

fprintf(stderr, "rom: requested regions overlap "

"(rom %s. free=0x" TARGET_FMT_plx

", addr=0x" TARGET_FMT_plx ")\n",

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

+ rom->name, last_rom->addr + last_rom->romsize,

+ rom->addr);

return -1;

}

- addr = rom->addr;

- addr += rom->romsize;

- as = rom->as;

+ last_rom = rom;

}

section = memory_region_find(rom->mr ? rom->mr : get_system_memory(),

rom->addr, 1);

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

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

Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>

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

--- 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);

- } else {

- 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

}

@@ -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'))

From: Joe Komlodi <joe.komlodi@xilinx.com>

Numonyx chips determine the number of cycles to wait based on bits 7:4

in the volatile configuration register.

However, if these bits are 0x0 or 0xF, the number of dummy cycles to

wait is 10 for QIOR and QIOR4 commands or when in QIO mode, and otherwise 8 for

the currently supported fast read commands. [1]

[1]

https://www.micron.com/-/media/client/global/documents/products/data-sheet/nor-flash/serial-nor/mt25q/die-rev-b/mt25q_qlkt_u_02g_cbb_0.pdf?rev=9b167fbf2b3645efba6385949a72e453

Signed-off-by: Joe Komlodi <komlodi@xilinx.com>

Reviewed-by: Francisco Iglesias <francisco.iglesias@xilinx.com>

Message-id: 1605568264-26376-5-git-send-email-komlodi@xilinx.com

hw/block/m25p80.c | 30 +++++++++++++++++++++++++++---

1 file changed, 27 insertions(+), 3 deletions(-)

diff --git a/hw/block/m25p80.c b/hw/block/m25p80.c

--- a/hw/block/m25p80.c

+++ b/hw/block/m25p80.c

@@ -XXX,XX +XXX,XX @@ static uint8_t numonyx_mode(Flash *s)

}

}

+static uint8_t numonyx_extract_cfg_num_dummies(Flash *s)

+{

+ uint8_t num_dummies;

+ uint8_t mode;

+ assert(get_man(s) == MAN_NUMONYX);

+ mode = numonyx_mode(s);

+ num_dummies = extract32(s->volatile_cfg, 4, 4);

+

+ if (num_dummies == 0x0 || num_dummies == 0xf) {

+ switch (s->cmd_in_progress) {

+ case QIOR:

+ case QIOR4:

+ num_dummies = 10;

+ break;

+ default:

+ num_dummies = (mode == MODE_QIO) ? 10 : 8;

+ break;

+ }

+ }

+

+ return num_dummies;

+}

+

static void decode_fast_read_cmd(Flash *s)

{

s->needed_bytes = get_addr_length(s);

@@ -XXX,XX +XXX,XX @@ static void decode_fast_read_cmd(Flash *s)

s->needed_bytes += 8;

break;

case MAN_NUMONYX:

- s->needed_bytes += extract32(s->volatile_cfg, 4, 4);

+ s->needed_bytes += numonyx_extract_cfg_num_dummies(s);

break;

case MAN_MACRONIX:

if (extract32(s->volatile_cfg, 6, 2) == 1) {

@@ -XXX,XX +XXX,XX @@ static void decode_dio_read_cmd(Flash *s)

);

break;

case MAN_NUMONYX:

- s->needed_bytes += extract32(s->volatile_cfg, 4, 4);

+ s->needed_bytes += numonyx_extract_cfg_num_dummies(s);

break;

case MAN_MACRONIX:

switch (extract32(s->volatile_cfg, 6, 2)) {

@@ -XXX,XX +XXX,XX @@ static void decode_qio_read_cmd(Flash *s)

);

break;

case MAN_NUMONYX:

- s->needed_bytes += extract32(s->volatile_cfg, 4, 4);

+ s->needed_bytes += numonyx_extract_cfg_num_dummies(s);

break;

case MAN_MACRONIX:

switch (extract32(s->volatile_cfg, 6, 2)) {