Series comparison

-[Qemu-devel] [PULL 00/21] target-arm queue
+[Qemu-devel] [PULL v3 00/10] target-arm queue
-Arm queue -- mostly the first slice of my Musca patches.
+This is a respin of my pull request from earlier this week:
  * versal board compile failure fixed
  * a few new patches:
   - MAINTAINERS file fix
   - use ARRAY_SIZE macro in xilinx_zynq
   - avoid an array overrun in strongarm GPIO irq handling
   - fix an assert running KVM on an aarch64-only host
-thanks
+The following changes since commit 69e2d03843412b9c076515b3aa9a71db161b6a1a:
 -- PMM
-The following changes since commit fc3dbb90f2eb069801bfb4cfe9cbc83cf9c5f4a9:
+  Merge remote-tracking branch 'remotes/riscv/tags/riscv-for-master-3.1-sf1' into staging (2018-11-02 13:16:13 +0000)
   Merge remote-tracking branch 'remotes/jnsnow/tags/bitmaps-pull-request' into staging (2019-02-21 13:09:33 +0000)
 are available in the Git repository at:
-  https://git.linaro.org/people/pmaydell/qemu-arm.git tags/pull-target-arm-20190221
+  https://git.linaro.org/people/pmaydell/qemu-arm.git tags/pull-target-arm-20181102
-for you to fetch changes up to 3733f80308d2a7f23f5e39b039e0547aba6c07f1:
+for you to fetch changes up to 6f16da53ffe4567c0353f85055df04860eb4e6fc:
-  hw/arm/armsse: Make 0x5... alias region work for per-CPU devices (2019-02-21 18:17:48 +0000)
+  hw/arm: versal: Add a virtual Xilinx Versal board (2018-11-02 14:11:31 +0000)
 ----------------------------------------------------------------
 target-arm queue:
- * Model the Arm "Musca" development boards: "musca-a" and "musca-b1"
+ * microbit: Add the UART to our nRF51 SoC model
- * Implement the ARMv8.3-JSConv extension
+ * Add a virtual Xilinx Versal board "xlnx-versal-virt"
- * v8M MPU should use background region as default, not always
+ * hw/arm/virt: Set VIRT_COMPAT_3_0 compat
- * Stop unintentional sign extension in pmu_init
+ * MAINTAINERS: Remove bouncing email in ARM ACPI
  * strongarm: mask off high[31:28] bits from dir and state registers
  * target/arm: Conditionalize some asserts on aarch32 support
  * hw/arm/xilinx_zynq: Use the ARRAY_SIZE macro
 ----------------------------------------------------------------
-Aaron Lindsay OS (1):
+Edgar E. Iglesias (2):
-      target/arm: Stop unintentional sign extension in pmu_init
+      hw/arm: versal: Add a model of Xilinx Versal SoC
       hw/arm: versal: Add a virtual Xilinx Versal board
-Peter Maydell (16):
+Eric Auger (1):
-      hw/arm/armsse: Fix memory leak in error-exit path
+      hw/arm/virt: Set VIRT_COMPAT_3_0 compat
       target/arm: v8M MPU should use background region as default, not always
       hw/misc/tz-ppc: Support having unused ports in the middle of the range
       hw/timer/pl031: Allow use as an embedded-struct device
       hw/timer/pl031: Convert to using trace events
       hw/char/pl011: Allow use as an embedded-struct device
       hw/char/pl011: Support all interrupt lines
       hw/char/pl011: Use '0x' prefix when logging hex numbers
       hw/arm/armsse: Document SRAM_ADDR_WIDTH property in header comment
       hw/arm/armsse: Allow boards to specify init-svtor
       hw/arm/musca.c: Implement models of the Musca-A and -B1 boards
       hw/arm/musca: Add PPCs
       hw/arm/musca: Add MPCs
       hw/arm/musca: Wire up PL031 RTC
       hw/arm/musca: Wire up PL011 UARTs
       hw/arm/armsse: Make 0x5... alias region work for per-CPU devices
-Richard Henderson (4):
+Julia Suvorova (3):
-      target/arm: Restructure disas_fp_int_conv
+      hw/char: Implement nRF51 SoC UART
-      target/arm: Split out vfp_helper.c
+      hw/arm/nrf51_soc: Connect UART to nRF51 SoC
-      target/arm: Rearrange Floating-point data-processing (2 regs)
+      tests/boot-serial-test: Add microbit board testcase
       target/arm: Implement ARMv8.3-JSConv
- hw/arm/Makefile.objs            |    1 +
+Philippe Mathieu-Daudé (2):
- target/arm/Makefile.objs        |    2 +-
+      MAINTAINERS: Remove bouncing email in ARM ACPI
- include/hw/arm/armsse.h         |    7 +-
+      hw/arm/xilinx_zynq: Use the ARRAY_SIZE macro
  include/hw/char/pl011.h         |   34 ++
  include/hw/misc/tz-ppc.h        |    8 +-
  include/hw/timer/pl031.h        |   44 ++
  target/arm/cpu.h                |   10 +
  target/arm/helper.h             |    3 +
  hw/arm/armsse.c                 |   44 +-
  hw/arm/musca.c                  |  669 ++++++++++++++++++++++
  hw/char/pl011.c                 |   81 +--
  hw/misc/tz-ppc.c                |   32 ++
  hw/timer/pl031.c                |   80 ++-
  target/arm/cpu.c                |    1 +
  target/arm/cpu64.c              |    2 +
  target/arm/helper.c             | 1072 +----------------------------------
  target/arm/translate-a64.c      |  120 ++--
  target/arm/translate.c          |  237 ++++----
  target/arm/vfp_helper.c         | 1176 +++++++++++++++++++++++++++++++++++++++
  MAINTAINERS                     |    7 +
  default-configs/arm-softmmu.mak |    1 +
  hw/timer/trace-events           |    6 +
 files changed, 2307 insertions(+), 1330 deletions(-)
  create mode 100644 include/hw/timer/pl031.h
  create mode 100644 hw/arm/musca.c
  create mode 100644 target/arm/vfp_helper.c
+Prasad J Pandit (1):
+      strongarm: mask off high[31:28] bits from dir and state registers
+Richard Henderson (1):
+      target/arm: Conditionalize some asserts on aarch32 support
+ hw/arm/Makefile.objs                |   1 +
+ hw/char/Makefile.objs               |   1 +
+ include/hw/arm/nrf51_soc.h          |   3 +
+ include/hw/arm/xlnx-versal.h        | 122 +++++++++
+ include/hw/char/nrf51_uart.h        |  78 ++++++
+ target/arm/cpu.h                    |   5 +
+ hw/arm/microbit.c                   |   2 +
+ hw/arm/nrf51_soc.c                  |  20 ++
+ hw/arm/strongarm.c                  |   4 +-
+ hw/arm/virt.c                       |   4 +
+ hw/arm/xilinx_zynq.c                |   2 +-
+ hw/arm/xlnx-versal-virt.c           | 494 ++++++++++++++++++++++++++++++++++++
+ hw/arm/xlnx-versal.c                | 323 +++++++++++++++++++++++
+ hw/char/nrf51_uart.c                | 330 ++++++++++++++++++++++++
+ target/arm/cpu.c                    |  15 +-
+ tests/boot-serial-test.c            |  19 ++
+ MAINTAINERS                         |   1 -
+ default-configs/aarch64-softmmu.mak |   1 +
+ hw/char/trace-events                |   4 +
+files changed, 1423 insertions(+), 6 deletions(-)
+ create mode 100644 include/hw/arm/xlnx-versal.h
+ create mode 100644 include/hw/char/nrf51_uart.h
+ create mode 100644 hw/arm/xlnx-versal-virt.c
+ create mode 100644 hw/arm/xlnx-versal.c
+ create mode 100644 hw/char/nrf51_uart.c

-[Qemu-devel] [PULL 01/21] hw/arm/armsse: Fix memory leak in error-exit path
+Deleted patch
-Coverity points out (CID 1398632, CID 1398650) that we
-leak a couple of allocated strings in the error-exit
-code path for setting up the MHUs in the ARMSSE.
-Fix this bug by moving the allocate-and-free of each
-string to be closer to the use, so we do the free before
-doing the error-exit check.
-Fixes: f8574705f62b38a ("hw/arm/armsse: Add unimplemented-device stubs for MHUs")
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Message-id: 20190215113707.24553-1-peter.maydell@linaro.org
----
- hw/arm/armsse.c | 10 ++++++----
-file changed, 6 insertions(+), 4 deletions(-)
-diff --git a/hw/arm/armsse.c b/hw/arm/armsse.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/arm/armsse.c
-+++ b/hw/arm/armsse.c
-@@ -XXX,XX +XXX,XX @@ static void armsse_realize(DeviceState *dev, Error **errp)
-     if (info->has_mhus) {
-         for (i = 0; i < ARRAY_SIZE(s->mhu); i++) {
--            char *name = g_strdup_printf("MHU%d", i);
--            char *port = g_strdup_printf("port[%d]", i + 3);
-+            char *name;
-+            char *port;
-+            name = g_strdup_printf("MHU%d", i);
-             qdev_prop_set_string(DEVICE(&s->mhu[i]), "name", name);
-             qdev_prop_set_uint64(DEVICE(&s->mhu[i]), "size", 0x1000);
-             object_property_set_bool(OBJECT(&s->mhu[i]), true,
-                                      "realized", &err);
-+            g_free(name);
-             if (err) {
-                 error_propagate(errp, err);
-                 return;
-             }
-+            port = g_strdup_printf("port[%d]", i + 3);
-             mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->mhu[i]), 0);
-             object_property_set_link(OBJECT(&s->apb_ppc0), OBJECT(mr),
-                                      port, &err);
-+            g_free(port);
-             if (err) {
-                 error_propagate(errp, err);
-                 return;
-             }
--            g_free(name);
--            g_free(port);
-         }
-     }
---
-.20.1

-[Qemu-devel] [PULL 02/21] target/arm: v8M MPU should use background region as default, not always
+Deleted patch
-The "background region" for a v8M MPU is a default which will be used
-(if enabled, and if the access is privileged) if the access does
-not match any specific MPU region. We were incorrectly using it
-always (by putting the condition at the wrong nesting level). This
-meant that we would always return the default background permissions
-rather than the correct permissions for a specific region, and also
-that we would not return the right information in response to a
-TT instruction.
-Move the check for the background region to the same place in the
-logic as the equivalent v8M MPUCheck() pseudocode puts it.
-This in turn means we must adjust the condition we use to detect
-matches in multiple regions to avoid false-positives.
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
-Message-id: 20190214113408.10214-1-peter.maydell@linaro.org
----
- target/arm/helper.c | 8 +++++---
-file changed, 5 insertions(+), 3 deletions(-)
-diff --git a/target/arm/helper.c b/target/arm/helper.c
-index XXXXXXX..XXXXXXX 100644
---- a/target/arm/helper.c
-+++ b/target/arm/helper.c
-@@ -XXX,XX +XXX,XX @@ static bool pmsav8_mpu_lookup(CPUARMState *env, uint32_t address,
-         hit = true;
-     } else if (m_is_ppb_region(env, address)) {
-         hit = true;
--    } else if (pmsav7_use_background_region(cpu, mmu_idx, is_user)) {
--        hit = true;
-     } else {
-+        if (pmsav7_use_background_region(cpu, mmu_idx, is_user)) {
-+            hit = true;
-+        }
-+
-         for (n = (int)cpu->pmsav7_dregion - 1; n >= 0; n--) {
-             /* region search */
-             /* Note that the base address is bits [31:5] from the register
-@@ -XXX,XX +XXX,XX @@ static bool pmsav8_mpu_lookup(CPUARMState *env, uint32_t address,
-                 *is_subpage = true;
-             }
--            if (hit) {
-+            if (matchregion != -1) {
-                 /* Multiple regions match -- always a failure (unlike
-                  * PMSAv7 where highest-numbered-region wins)
-                  */
---
-.20.1

-[Qemu-devel] [PULL 17/21] hw/arm/musca: Add PPCs
+[Qemu-devel] [PULL 01/10] hw/arm/virt: Set VIRT_COMPAT_3_0 compat
-Many of the devices on the Musca board live behind TrustZone
+From: Eric Auger <eric.auger@redhat.com>
 Peripheral Protection Controllers (PPCs); add models of the
 PPCs, using a similar scheme to the MPS2 board models.
 This commit wires up the PPCs with "unimplemented device"
 stubs behind them in the correct places in the address map.
+We are missing the VIRT_COMPAT_3_0 definition and setting.
+Let's add them.
+Signed-off-by: Eric Auger <eric.auger@redhat.com>
+Reviewed-by: Andrew Jones <drjones@redhat.com>
+Message-id: 20181024085602.16611-1-eric.auger@redhat.com
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
 ---
- hw/arm/musca.c | 289 +++++++++++++++++++++++++++++++++++++++++++++++++
+ hw/arm/virt.c | 4 ++++
-file changed, 289 insertions(+)
+file changed, 4 insertions(+)
-diff --git a/hw/arm/musca.c b/hw/arm/musca.c
+diff --git a/hw/arm/virt.c b/hw/arm/virt.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/arm/musca.c
+--- a/hw/arm/virt.c
-+++ b/hw/arm/musca.c
++++ b/hw/arm/virt.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static void virt_machine_3_1_options(MachineClass *mc)
- #include "hw/arm/armsse.h"
+ }
- #include "hw/boards.h"
+ DEFINE_VIRT_MACHINE_AS_LATEST(3, 1)
- #include "hw/core/split-irq.h"
-+#include "hw/misc/tz-ppc.h"
++#define VIRT_COMPAT_3_0 \
-+#include "hw/misc/unimp.h"
++    HW_COMPAT_3_0
  #define MUSCA_NUMIRQ_MAX 96
 +#define MUSCA_PPC_MAX 3
  typedef enum MuscaType {
      MUSCA_A,
@@ -XXX,XX +XXX,XX @@ typedef struct {
      ARMSSE sse;
      SplitIRQ cpu_irq_splitter[MUSCA_NUMIRQ_MAX];
 +    SplitIRQ sec_resp_splitter;
 +    TZPPC ppc[MUSCA_PPC_MAX];
 +    MemoryRegion container;
 +    UnimplementedDeviceState eflash[2];
 +    UnimplementedDeviceState qspi;
 +    UnimplementedDeviceState mpc[5];
 +    UnimplementedDeviceState mhu[2];
 +    UnimplementedDeviceState pwm[3];
 +    UnimplementedDeviceState i2s;
 +    UnimplementedDeviceState uart[2];
 +    UnimplementedDeviceState i2c[2];
 +    UnimplementedDeviceState spi;
 +    UnimplementedDeviceState scc;
 +    UnimplementedDeviceState timer;
 +    UnimplementedDeviceState rtc;
 +    UnimplementedDeviceState pvt;
 +    UnimplementedDeviceState sdio;
 +    UnimplementedDeviceState gpio;
  } MuscaMachineState;
  #define TYPE_MUSCA_MACHINE "musca"
@@ -XXX,XX +XXX,XX @@ typedef struct {
   */
  #define SYSCLK_FRQ 40000000
 +/*
 + * Most of the devices in the Musca board sit behind Peripheral Protection
 + * Controllers. These data structures define the layout of which devices
 + * sit behind which PPCs.
 + * The devfn for each port is a function which creates, configures
 + * and initializes the device, returning the MemoryRegion which
 + * needs to be plugged into the downstream end of the PPC port.
 + */
 +typedef MemoryRegion *MakeDevFn(MuscaMachineState *mms, void *opaque,
 +                                const char *name, hwaddr size);
 +
-+typedef struct PPCPortInfo {
+ static void virt_3_0_instance_init(Object *obj)
 +    const char *name;
 +    MakeDevFn *devfn;
 +    void *opaque;
 +    hwaddr addr;
 +    hwaddr size;
 +} PPCPortInfo;
 +
 +typedef struct PPCInfo {
 +    const char *name;
 +    PPCPortInfo ports[TZ_NUM_PORTS];
 +} PPCInfo;
 +
 +static MemoryRegion *make_unimp_dev(MuscaMachineState *mms,
 +                                    void *opaque, const char *name, hwaddr size)
 +{
 +    /*
 +     * Initialize, configure and realize a TYPE_UNIMPLEMENTED_DEVICE,
 +     * and return a pointer to its MemoryRegion.
 +     */
 +    UnimplementedDeviceState *uds = opaque;
 +
 +    sysbus_init_child_obj(OBJECT(mms), name, uds,
 +                          sizeof(UnimplementedDeviceState),
 +                          TYPE_UNIMPLEMENTED_DEVICE);
 +    qdev_prop_set_string(DEVICE(uds), "name", name);
 +    qdev_prop_set_uint64(DEVICE(uds), "size", size);
 +    object_property_set_bool(OBJECT(uds), true, "realized", &error_fatal);
 +    return sysbus_mmio_get_region(SYS_BUS_DEVICE(uds), 0);
 +}
 +
 +static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
 +                                       const char *name, hwaddr size)
 +{
 +    /*
 +     * Create the container MemoryRegion for all the devices that live
 +     * behind the Musca-A PPC's single port. These devices don't have a PPC
 +     * port each, but we use the PPCPortInfo struct as a convenient way
 +     * to describe them. Note that addresses here are relative to the base
 +     * address of the PPC port region: 0x40100000, and devices appear both
 +     * at the 0x4... NS region and the 0x5... S region.
 +     */
 +    int i;
 +    MemoryRegion *container = &mms->container;
 +
 +    const PPCPortInfo devices[] = {
 +        { "uart0", make_unimp_dev, &mms->uart[0], 0x1000, 0x1000 },
 +        { "uart1", make_unimp_dev, &mms->uart[1], 0x2000, 0x1000 },
 +        { "spi", make_unimp_dev, &mms->spi, 0x3000, 0x1000 },
 +        { "i2c0", make_unimp_dev, &mms->i2c[0], 0x4000, 0x1000 },
 +        { "i2c1", make_unimp_dev, &mms->i2c[1], 0x5000, 0x1000 },
 +        { "i2s", make_unimp_dev, &mms->i2s, 0x6000, 0x1000 },
 +        { "pwm0", make_unimp_dev, &mms->pwm[0], 0x7000, 0x1000 },
 +        { "rtc", make_unimp_dev, &mms->rtc, 0x8000, 0x1000 },
 +        { "qspi", make_unimp_dev, &mms->qspi, 0xa000, 0x1000 },
 +        { "timer", make_unimp_dev, &mms->timer, 0xb000, 0x1000 },
 +        { "scc", make_unimp_dev, &mms->scc, 0xc000, 0x1000 },
 +        { "pwm1", make_unimp_dev, &mms->pwm[1], 0xe000, 0x1000 },
 +        { "pwm2", make_unimp_dev, &mms->pwm[2], 0xf000, 0x1000 },
 +        { "gpio", make_unimp_dev, &mms->gpio, 0x10000, 0x1000 },
 +        { "mpc0", make_unimp_dev, &mms->mpc[0], 0x12000, 0x1000 },
 +        { "mpc1", make_unimp_dev, &mms->mpc[1], 0x13000, 0x1000 },
 +    };
 +
 +    memory_region_init(container, OBJECT(mms), "musca-device-container", size);
 +
 +    for (i = 0; i < ARRAY_SIZE(devices); i++) {
 +        const PPCPortInfo *pinfo = &devices[i];
 +        MemoryRegion *mr;
 +
 +        mr = pinfo->devfn(mms, pinfo->opaque, pinfo->name, pinfo->size);
 +        memory_region_add_subregion(container, pinfo->addr, mr);
 +    }
 +
 +    return &mms->container;
 +}
 +
  static void musca_init(MachineState *machine)
  {
-     MuscaMachineState *mms = MUSCA_MACHINE(machine);
+     virt_3_1_instance_init(obj);
-@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
+@@ -XXX,XX +XXX,XX @@ static void virt_3_0_instance_init(Object *obj)
-     MachineClass *mc = MACHINE_GET_CLASS(machine);
+ static void virt_machine_3_0_options(MachineClass *mc)
-     MemoryRegion *system_memory = get_system_memory();
+ {
-     DeviceState *ssedev;
+     virt_machine_3_1_options(mc);
-+    DeviceState *dev_splitter;
++    SET_MACHINE_COMPAT(mc, VIRT_COMPAT_3_0);
 +    const PPCInfo *ppcs;
 +    int num_ppcs;
      int i;
      assert(mmc->num_irqs <= MUSCA_NUMIRQ_MAX);
@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
                                                       "EXP_CPU1_IRQ", i));
      }
 +    /*
 +     * The sec_resp_cfg output from the SSE-200 must be split into multiple
 +     * lines, one for each of the PPCs we create here.
 +     */
 +    object_initialize(&mms->sec_resp_splitter, sizeof(mms->sec_resp_splitter),
 +                      TYPE_SPLIT_IRQ);
 +    object_property_add_child(OBJECT(machine), "sec-resp-splitter",
 +                              OBJECT(&mms->sec_resp_splitter), &error_fatal);
 +    object_property_set_int(OBJECT(&mms->sec_resp_splitter),
 +                            ARRAY_SIZE(mms->ppc), "num-lines", &error_fatal);
 +    object_property_set_bool(OBJECT(&mms->sec_resp_splitter), true,
 +                             "realized", &error_fatal);
 +    dev_splitter = DEVICE(&mms->sec_resp_splitter);
 +    qdev_connect_gpio_out_named(ssedev, "sec_resp_cfg", 0,
 +                                qdev_get_gpio_in(dev_splitter, 0));
 +
 +    /*
 +     * Most of the devices in the board are behind Peripheral Protection
 +     * Controllers. The required order for initializing things is:
 +     *  + initialize the PPC
 +     *  + initialize, configure and realize downstream devices
 +     *  + connect downstream device MemoryRegions to the PPC
 +     *  + realize the PPC
 +     *  + map the PPC's MemoryRegions to the places in the address map
 +     *    where the downstream devices should appear
 +     *  + wire up the PPC's control lines to the SSE object
 +     *
 +     * The PPC mapping differs for the -A and -B1 variants; the -A version
 +     * is much simpler, using only a single port of a single PPC and putting
 +     * all the devices behind that.
 +     */
 +    const PPCInfo a_ppcs[] = { {
 +            .name = "ahb_ppcexp0",
 +            .ports = {
 +                { "musca-devices", make_musca_a_devs, 0, 0x40100000, 0x100000 },
 +            },
 +        },
 +    };
 +
 +    /*
 +     * Devices listed with an 0x4.. address appear in both the NS 0x4.. region
 +     * and the 0x5.. S region. Devices listed with an 0x5.. address appear
 +     * only in the S region.
 +     */
 +    const PPCInfo b1_ppcs[] = { {
 +            .name = "apb_ppcexp0",
 +            .ports = {
 +                { "eflash0", make_unimp_dev, &mms->eflash[0],
 +                  0x52400000, 0x1000 },
 +                { "eflash1", make_unimp_dev, &mms->eflash[1],
 +                  0x52500000, 0x1000 },
 +                { "qspi", make_unimp_dev, &mms->qspi, 0x42800000, 0x100000 },
 +                { "mpc0", make_unimp_dev, &mms->mpc[0], 0x52000000, 0x1000 },
 +                { "mpc1", make_unimp_dev, &mms->mpc[1], 0x52100000, 0x1000 },
 +                { "mpc2", make_unimp_dev, &mms->mpc[2], 0x52200000, 0x1000 },
 +                { "mpc3", make_unimp_dev, &mms->mpc[3], 0x52300000, 0x1000 },
 +                { "mhu0", make_unimp_dev, &mms->mhu[0], 0x42600000, 0x100000 },
 +                { "mhu1", make_unimp_dev, &mms->mhu[1], 0x42700000, 0x100000 },
 +                { }, /* port 9: unused */
 +                { }, /* port 10: unused */
 +                { }, /* port 11: unused */
 +                { }, /* port 12: unused */
 +                { }, /* port 13: unused */
 +                { "mpc4", make_unimp_dev, &mms->mpc[4], 0x52e00000, 0x1000 },
 +            },
 +        }, {
 +            .name = "apb_ppcexp1",
 +            .ports = {
 +                { "pwm0", make_unimp_dev, &mms->pwm[0], 0x40101000, 0x1000 },
 +                { "pwm1", make_unimp_dev, &mms->pwm[1], 0x40102000, 0x1000 },
 +                { "pwm2", make_unimp_dev, &mms->pwm[2], 0x40103000, 0x1000 },
 +                { "i2s", make_unimp_dev, &mms->i2s, 0x40104000, 0x1000 },
 +                { "uart0", make_unimp_dev, &mms->uart[0], 0x40105000, 0x1000 },
 +                { "uart1", make_unimp_dev, &mms->uart[1], 0x40106000, 0x1000 },
 +                { "i2c0", make_unimp_dev, &mms->i2c[0], 0x40108000, 0x1000 },
 +                { "i2c1", make_unimp_dev, &mms->i2c[1], 0x40109000, 0x1000 },
 +                { "spi", make_unimp_dev, &mms->spi, 0x4010a000, 0x1000 },
 +                { "scc", make_unimp_dev, &mms->scc, 0x5010b000, 0x1000 },
 +                { "timer", make_unimp_dev, &mms->timer, 0x4010c000, 0x1000 },
 +                { "rtc", make_unimp_dev, &mms->rtc, 0x4010d000, 0x1000 },
 +                { "pvt", make_unimp_dev, &mms->pvt, 0x4010e000, 0x1000 },
 +                { "sdio", make_unimp_dev, &mms->sdio, 0x4010f000, 0x1000 },
 +            },
 +        }, {
 +            .name = "ahb_ppcexp0",
 +            .ports = {
 +                { }, /* port 0: unused */
 +                { "gpio", make_unimp_dev, &mms->gpio, 0x41000000, 0x1000 },
 +            },
 +        },
 +    };
 +
 +    switch (mmc->type) {
 +    case MUSCA_A:
 +        ppcs = a_ppcs;
 +        num_ppcs = ARRAY_SIZE(a_ppcs);
 +        break;
 +    case MUSCA_B1:
 +        ppcs = b1_ppcs;
 +        num_ppcs = ARRAY_SIZE(b1_ppcs);
 +        break;
 +    default:
 +        g_assert_not_reached();
 +    }
 +    assert(num_ppcs <= MUSCA_PPC_MAX);
 +
 +    for (i = 0; i < num_ppcs; i++) {
 +        const PPCInfo *ppcinfo = &ppcs[i];
 +        TZPPC *ppc = &mms->ppc[i];
 +        DeviceState *ppcdev;
 +        int port;
 +        char *gpioname;
 +
 +        sysbus_init_child_obj(OBJECT(machine), ppcinfo->name, ppc,
 +                              sizeof(TZPPC), TYPE_TZ_PPC);
 +        ppcdev = DEVICE(ppc);
 +
 +        for (port = 0; port < TZ_NUM_PORTS; port++) {
 +            const PPCPortInfo *pinfo = &ppcinfo->ports[port];
 +            MemoryRegion *mr;
 +            char *portname;
 +
 +            if (!pinfo->devfn) {
 +                continue;
 +            }
 +
 +            mr = pinfo->devfn(mms, pinfo->opaque, pinfo->name, pinfo->size);
 +            portname = g_strdup_printf("port[%d]", port);
 +            object_property_set_link(OBJECT(ppc), OBJECT(mr),
 +                                     portname, &error_fatal);
 +            g_free(portname);
 +        }
 +
 +        object_property_set_bool(OBJECT(ppc), true, "realized", &error_fatal);
 +
 +        for (port = 0; port < TZ_NUM_PORTS; port++) {
 +            const PPCPortInfo *pinfo = &ppcinfo->ports[port];
 +
 +            if (!pinfo->devfn) {
 +                continue;
 +            }
 +            sysbus_mmio_map(SYS_BUS_DEVICE(ppc), port, pinfo->addr);
 +
 +            gpioname = g_strdup_printf("%s_nonsec", ppcinfo->name);
 +            qdev_connect_gpio_out_named(ssedev, gpioname, port,
 +                                        qdev_get_gpio_in_named(ppcdev,
 +                                                               "cfg_nonsec",
 +                                                               port));
 +            g_free(gpioname);
 +            gpioname = g_strdup_printf("%s_ap", ppcinfo->name);
 +            qdev_connect_gpio_out_named(ssedev, gpioname, port,
 +                                        qdev_get_gpio_in_named(ppcdev,
 +                                                               "cfg_ap", port));
 +            g_free(gpioname);
 +        }
 +
 +        gpioname = g_strdup_printf("%s_irq_enable", ppcinfo->name);
 +        qdev_connect_gpio_out_named(ssedev, gpioname, 0,
 +                                    qdev_get_gpio_in_named(ppcdev,
 +                                                           "irq_enable", 0));
 +        g_free(gpioname);
 +        gpioname = g_strdup_printf("%s_irq_clear", ppcinfo->name);
 +        qdev_connect_gpio_out_named(ssedev, gpioname, 0,
 +                                    qdev_get_gpio_in_named(ppcdev,
 +                                                           "irq_clear", 0));
 +        g_free(gpioname);
 +        gpioname = g_strdup_printf("%s_irq_status", ppcinfo->name);
 +        qdev_connect_gpio_out_named(ppcdev, "irq", 0,
 +                                    qdev_get_gpio_in_named(ssedev,
 +                                                           gpioname, 0));
 +        g_free(gpioname);
 +
 +        qdev_connect_gpio_out(dev_splitter, i,
 +                              qdev_get_gpio_in_named(ppcdev,
 +                                                     "cfg_sec_resp", 0));
 +    }
 +
      armv7m_load_kernel(ARM_CPU(first_cpu), machine->kernel_filename, 0x2000000);
  }
+ DEFINE_VIRT_MACHINE(3, 0)
 --
-.20.1
+.19.1

-[Qemu-devel] [PULL 18/21] hw/arm/musca: Add MPCs
+[Qemu-devel] [PULL 02/10] hw/char: Implement nRF51 SoC UART
-The Musca board puts its SRAM and flash behind TrustZone
+From: Julia Suvorova <jusual@mail.ru>
 Memory Protection Controllers (MPCs). Each MPC sits between
 the CPU and the RAM/flash, and also has a set of memory mapped
 control registers. Wire up the MPCs, and the memory behind them.
 For the moment we implement the flash as simple ROM, which
 cannot be reprogrammed by the guest.
+Not implemented: CTS/NCTS, PSEL*.
+Signed-off-by: Julia Suvorova <jusual@mail.ru>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
 ---
- hw/arm/musca.c | 155 ++++++++++++++++++++++++++++++++++++++++++++++---
+ hw/char/Makefile.objs        |   1 +
-file changed, 147 insertions(+), 8 deletions(-)
+ include/hw/char/nrf51_uart.h |  78 +++++++++
  hw/char/nrf51_uart.c         | 330 +++++++++++++++++++++++++++++++++++
  hw/char/trace-events         |   4 +
 files changed, 413 insertions(+)
  create mode 100644 include/hw/char/nrf51_uart.h
  create mode 100644 hw/char/nrf51_uart.c
-diff --git a/hw/arm/musca.c b/hw/arm/musca.c
+diff --git a/hw/char/Makefile.objs b/hw/char/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
---- a/hw/arm/musca.c
+--- a/hw/char/Makefile.objs
-+++ b/hw/arm/musca.c
++++ b/hw/char/Makefile.objs
 @@ -XXX,XX +XXX,XX @@
- #include "hw/arm/armsse.h"
+ common-obj-$(CONFIG_IPACK) += ipoctal232.o
- #include "hw/boards.h"
+ common-obj-$(CONFIG_ESCC) += escc.o
- #include "hw/core/split-irq.h"
++common-obj-$(CONFIG_NRF51_SOC) += nrf51_uart.o
-+#include "hw/misc/tz-mpc.h"
+ common-obj-$(CONFIG_PARALLEL) += parallel.o
- #include "hw/misc/tz-ppc.h"
+ common-obj-$(CONFIG_PARALLEL) += parallel-isa.o
- #include "hw/misc/unimp.h"
+ common-obj-$(CONFIG_PL011) += pl011.o
+diff --git a/include/hw/char/nrf51_uart.h b/include/hw/char/nrf51_uart.h
- #define MUSCA_NUMIRQ_MAX 96
+new file mode 100644
- #define MUSCA_PPC_MAX 3
+index XXXXXXX..XXXXXXX
-+#define MUSCA_MPC_MAX 5
+--- /dev/null
-+
++++ b/include/hw/char/nrf51_uart.h
-+typedef struct MPCInfo MPCInfo;
+@@ -XXX,XX +XXX,XX @@
++/*
- typedef enum MuscaType {
++ * nRF51 SoC UART emulation
-     MUSCA_A,
++ *
-@@ -XXX,XX +XXX,XX @@ typedef struct {
++ * Copyright (c) 2018 Julia Suvorova <jusual@mail.ru>
-     uint32_t init_svtor;
++ *
-     int sram_addr_width;
++ * This program is free software; you can redistribute it and/or modify
-     int num_irqs;
++ * it under the terms of the GNU General Public License version 2 or
-+    const MPCInfo *mpc_info;
++ * (at your option) any later version.
-+    int num_mpcs;
++ */
- } MuscaMachineClass;
++
++#ifndef NRF51_UART_H
- typedef struct {
++#define NRF51_UART_H
-     MachineState parent;
++
++#include "hw/sysbus.h"
-     ARMSSE sse;
++#include "chardev/char-fe.h"
-+    /* RAM and flash */
++#include "hw/registerfields.h"
-+    MemoryRegion ram[MUSCA_MPC_MAX];
++
-     SplitIRQ cpu_irq_splitter[MUSCA_NUMIRQ_MAX];
++#define UART_FIFO_LENGTH 6
-     SplitIRQ sec_resp_splitter;
++#define UART_BASE 0x40002000
-     TZPPC ppc[MUSCA_PPC_MAX];
++#define UART_SIZE 0x1000
-     MemoryRegion container;
++
-     UnimplementedDeviceState eflash[2];
++#define TYPE_NRF51_UART "nrf51_soc.uart"
-     UnimplementedDeviceState qspi;
++#define NRF51_UART(obj) OBJECT_CHECK(NRF51UARTState, (obj), TYPE_NRF51_UART)
--    UnimplementedDeviceState mpc[5];
++
-+    TZMPC mpc[MUSCA_MPC_MAX];
++REG32(UART_STARTRX, 0x000)
-     UnimplementedDeviceState mhu[2];
++REG32(UART_STOPRX, 0x004)
-     UnimplementedDeviceState pwm[3];
++REG32(UART_STARTTX, 0x008)
-     UnimplementedDeviceState i2s;
++REG32(UART_STOPTX, 0x00C)
-@@ -XXX,XX +XXX,XX @@ typedef struct {
++REG32(UART_SUSPEND, 0x01C)
-     UnimplementedDeviceState pvt;
++
-     UnimplementedDeviceState sdio;
++REG32(UART_CTS, 0x100)
-     UnimplementedDeviceState gpio;
++REG32(UART_NCTS, 0x104)
-+    UnimplementedDeviceState cryptoisland;
++REG32(UART_RXDRDY, 0x108)
- } MuscaMachineState;
++REG32(UART_TXDRDY, 0x11C)
++REG32(UART_ERROR, 0x124)
- #define TYPE_MUSCA_MACHINE "musca"
++REG32(UART_RXTO, 0x144)
-@@ -XXX,XX +XXX,XX @@ static MemoryRegion *make_unimp_dev(MuscaMachineState *mms,
++
-     return sysbus_mmio_get_region(SYS_BUS_DEVICE(uds), 0);
++REG32(UART_INTEN, 0x300)
- }
++    FIELD(UART_INTEN, CTS, 0, 1)
++    FIELD(UART_INTEN, NCTS, 1, 1)
-+typedef enum MPCInfoType {
++    FIELD(UART_INTEN, RXDRDY, 2, 1)
-+    MPC_RAM,
++    FIELD(UART_INTEN, TXDRDY, 7, 1)
-+    MPC_ROM,
++    FIELD(UART_INTEN, ERROR, 9, 1)
-+    MPC_CRYPTOISLAND,
++    FIELD(UART_INTEN, RXTO, 17, 1)
-+} MPCInfoType;
++REG32(UART_INTENSET, 0x304)
-+
++REG32(UART_INTENCLR, 0x308)
-+struct MPCInfo {
++REG32(UART_ERRORSRC, 0x480)
-+    const char *name;
++REG32(UART_ENABLE, 0x500)
-+    hwaddr addr;
++REG32(UART_PSELRTS, 0x508)
-+    hwaddr size;
++REG32(UART_PSELTXD, 0x50C)
-+    MPCInfoType type;
++REG32(UART_PSELCTS, 0x510)
 +REG32(UART_PSELRXD, 0x514)
 +REG32(UART_RXD, 0x518)
 +REG32(UART_TXD, 0x51C)
 +REG32(UART_BAUDRATE, 0x524)
 +REG32(UART_CONFIG, 0x56C)
 +
 +typedef struct NRF51UARTState {
 +    SysBusDevice parent_obj;
 +
 +    MemoryRegion iomem;
 +    CharBackend chr;
 +    qemu_irq irq;
 +    guint watch_tag;
 +
 +    uint8_t rx_fifo[UART_FIFO_LENGTH];
 +    unsigned int rx_fifo_pos;
 +    unsigned int rx_fifo_len;
 +
 +    uint32_t reg[0x56C];
 +
 +    bool rx_started;
 +    bool tx_started;
 +    bool pending_tx_byte;
 +    bool enabled;
 +} NRF51UARTState;
 +
 +#endif
 diff --git a/hw/char/nrf51_uart.c b/hw/char/nrf51_uart.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/hw/char/nrf51_uart.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * nRF51 SoC UART emulation
 + *
 + * See nRF51 Series Reference Manual, "29 Universal Asynchronous
 + * Receiver/Transmitter" for hardware specifications:
 + * http://infocenter.nordicsemi.com/pdf/nRF51_RM_v3.0.pdf
 + *
 + * Copyright (c) 2018 Julia Suvorova <jusual@mail.ru>
 + *
 + * This program is free software; you can redistribute it and/or modify
 + * it under the terms of the GNU General Public License version 2 or
 + * (at your option) any later version.
 + */
 +
 +#include "qemu/osdep.h"
 +#include "qemu/log.h"
 +#include "hw/char/nrf51_uart.h"
 +#include "trace.h"
 +
 +static void nrf51_uart_update_irq(NRF51UARTState *s)
 +{
 +    bool irq = false;
 +
 +    irq |= (s->reg[R_UART_RXDRDY] &&
 +            (s->reg[R_UART_INTEN] & R_UART_INTEN_RXDRDY_MASK));
 +    irq |= (s->reg[R_UART_TXDRDY] &&
 +            (s->reg[R_UART_INTEN] & R_UART_INTEN_TXDRDY_MASK));
 +    irq |= (s->reg[R_UART_ERROR]  &&
 +            (s->reg[R_UART_INTEN] & R_UART_INTEN_ERROR_MASK));
 +    irq |= (s->reg[R_UART_RXTO]   &&
 +            (s->reg[R_UART_INTEN] & R_UART_INTEN_RXTO_MASK));
 +
 +    qemu_set_irq(s->irq, irq);
 +}
 +
 +static uint64_t uart_read(void *opaque, hwaddr addr, unsigned int size)
 +{
 +    NRF51UARTState *s = NRF51_UART(opaque);
 +    uint64_t r;
 +
 +    if (!s->enabled) {
 +        return 0;
 +    }
 +
 +    switch (addr) {
 +    case A_UART_RXD:
 +        r = s->rx_fifo[s->rx_fifo_pos];
 +        if (s->rx_started && s->rx_fifo_len) {
 +            s->rx_fifo_pos = (s->rx_fifo_pos + 1) % UART_FIFO_LENGTH;
 +            s->rx_fifo_len--;
 +            if (s->rx_fifo_len) {
 +                s->reg[R_UART_RXDRDY] = 1;
 +                nrf51_uart_update_irq(s);
 +            }
 +            qemu_chr_fe_accept_input(&s->chr);
 +        }
 +        break;
 +    case A_UART_INTENSET:
 +    case A_UART_INTENCLR:
 +    case A_UART_INTEN:
 +        r = s->reg[R_UART_INTEN];
 +        break;
 +    default:
 +        r = s->reg[addr / 4];
 +        break;
 +    }
 +
 +    trace_nrf51_uart_read(addr, r, size);
 +
 +    return r;
 +}
 +
 +static gboolean uart_transmit(GIOChannel *chan, GIOCondition cond, void *opaque)
 +{
 +    NRF51UARTState *s = NRF51_UART(opaque);
 +    int r;
 +    uint8_t c = s->reg[R_UART_TXD];
 +
 +    s->watch_tag = 0;
 +
 +    r = qemu_chr_fe_write(&s->chr, &c, 1);
 +    if (r <= 0) {
 +        s->watch_tag = qemu_chr_fe_add_watch(&s->chr, G_IO_OUT | G_IO_HUP,
 +                                             uart_transmit, s);
 +        if (!s->watch_tag) {
 +            /* The hardware has no transmit error reporting,
 +             * so silently drop the byte
 +             */
 +            goto buffer_drained;
 +        }
 +        return FALSE;
 +    }
 +
 +buffer_drained:
 +    s->reg[R_UART_TXDRDY] = 1;
 +    s->pending_tx_byte = false;
 +    return FALSE;
 +}
 +
 +static void uart_cancel_transmit(NRF51UARTState *s)
 +{
 +    if (s->watch_tag) {
 +        g_source_remove(s->watch_tag);
 +        s->watch_tag = 0;
 +    }
 +}
 +
 +static void uart_write(void *opaque, hwaddr addr,
 +                       uint64_t value, unsigned int size)
 +{
 +    NRF51UARTState *s = NRF51_UART(opaque);
 +
 +    trace_nrf51_uart_write(addr, value, size);
 +
 +    if (!s->enabled && (addr != A_UART_ENABLE)) {
 +        return;
 +    }
 +
 +    switch (addr) {
 +    case A_UART_TXD:
 +        if (!s->pending_tx_byte && s->tx_started) {
 +            s->reg[R_UART_TXD] = value;
 +            s->pending_tx_byte = true;
 +            uart_transmit(NULL, G_IO_OUT, s);
 +        }
 +        break;
 +    case A_UART_INTEN:
 +        s->reg[R_UART_INTEN] = value;
 +        break;
 +    case A_UART_INTENSET:
 +        s->reg[R_UART_INTEN] |= value;
 +        break;
 +    case A_UART_INTENCLR:
 +        s->reg[R_UART_INTEN] &= ~value;
 +        break;
 +    case A_UART_TXDRDY ... A_UART_RXTO:
 +        s->reg[addr / 4] = value;
 +        break;
 +    case A_UART_ERRORSRC:
 +        s->reg[addr / 4] &= ~value;
 +        break;
 +    case A_UART_RXD:
 +        break;
 +    case A_UART_RXDRDY:
 +        if (value == 0) {
 +            s->reg[R_UART_RXDRDY] = 0;
 +        }
 +        break;
 +    case A_UART_STARTTX:
 +        if (value == 1) {
 +            s->tx_started = true;
 +        }
 +        break;
 +    case A_UART_STARTRX:
 +        if (value == 1) {
 +            s->rx_started = true;
 +        }
 +        break;
 +    case A_UART_ENABLE:
 +        if (value) {
 +            if (value == 4) {
 +                s->enabled = true;
 +            }
 +            break;
 +        }
 +        s->enabled = false;
 +        value = 1;
 +        /* fall through */
 +    case A_UART_SUSPEND:
 +    case A_UART_STOPTX:
 +        if (value == 1) {
 +            s->tx_started = false;
 +        }
 +        /* fall through */
 +    case A_UART_STOPRX:
 +        if (addr != A_UART_STOPTX && value == 1) {
 +            s->rx_started = false;
 +            s->reg[R_UART_RXTO] = 1;
 +        }
 +        break;
 +    default:
 +        s->reg[addr / 4] = value;
 +        break;
 +    }
 +    nrf51_uart_update_irq(s);
 +}
 +
 +static const MemoryRegionOps uart_ops = {
 +    .read =  uart_read,
 +    .write = uart_write,
 +    .endianness = DEVICE_LITTLE_ENDIAN,
 +};
 +
-+/* Order of the MPCs here must match the order of the bits in SECMPCINTSTATUS */
++static void nrf51_uart_reset(DeviceState *dev)
-+static const MPCInfo a_mpc_info[] = { {
++{
-+        .name = "qspi",
++    NRF51UARTState *s = NRF51_UART(dev);
-+        .type = MPC_ROM,
++
-+        .addr = 0x00200000,
++    s->pending_tx_byte = 0;
-+        .size = 0x00800000,
++
-+    }, {
++    uart_cancel_transmit(s);
-+        .name = "sram",
++
-+        .type = MPC_RAM,
++    memset(s->reg, 0, sizeof(s->reg));
-+        .addr = 0x00000000,
++
-+        .size = 0x00200000,
++    s->reg[R_UART_PSELRTS] = 0xFFFFFFFF;
 +    s->reg[R_UART_PSELTXD] = 0xFFFFFFFF;
 +    s->reg[R_UART_PSELCTS] = 0xFFFFFFFF;
 +    s->reg[R_UART_PSELRXD] = 0xFFFFFFFF;
 +    s->reg[R_UART_BAUDRATE] = 0x4000000;
 +
 +    s->rx_fifo_len = 0;
 +    s->rx_fifo_pos = 0;
 +    s->rx_started = false;
 +    s->tx_started = false;
 +    s->enabled = false;
 +}
 +
 +static void uart_receive(void *opaque, const uint8_t *buf, int size)
 +{
 +
 +    NRF51UARTState *s = NRF51_UART(opaque);
 +    int i;
 +
 +    if (size == 0 || s->rx_fifo_len >= UART_FIFO_LENGTH) {
 +        return;
 +    }
 +
 +    for (i = 0; i < size; i++) {
 +        uint32_t pos = (s->rx_fifo_pos + s->rx_fifo_len) % UART_FIFO_LENGTH;
 +        s->rx_fifo[pos] = buf[i];
 +        s->rx_fifo_len++;
 +    }
 +
 +    s->reg[R_UART_RXDRDY] = 1;
 +    nrf51_uart_update_irq(s);
 +}
 +
 +static int uart_can_receive(void *opaque)
 +{
 +    NRF51UARTState *s = NRF51_UART(opaque);
 +
 +    return s->rx_started ? (UART_FIFO_LENGTH - s->rx_fifo_len) : 0;
 +}
 +
 +static void uart_event(void *opaque, int event)
 +{
 +    NRF51UARTState *s = NRF51_UART(opaque);
 +
 +    if (event == CHR_EVENT_BREAK) {
 +        s->reg[R_UART_ERRORSRC] |= 3;
 +        s->reg[R_UART_ERROR] = 1;
 +        nrf51_uart_update_irq(s);
 +    }
 +}
 +
 +static void nrf51_uart_realize(DeviceState *dev, Error **errp)
 +{
 +    NRF51UARTState *s = NRF51_UART(dev);
 +
 +    qemu_chr_fe_set_handlers(&s->chr, uart_can_receive, uart_receive,
 +                             uart_event, NULL, s, NULL, true);
 +}
 +
 +static void nrf51_uart_init(Object *obj)
 +{
 +    NRF51UARTState *s = NRF51_UART(obj);
 +    SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
 +
 +    memory_region_init_io(&s->iomem, obj, &uart_ops, s,
 +                          "nrf51_soc.uart", UART_SIZE);
 +    sysbus_init_mmio(sbd, &s->iomem);
 +    sysbus_init_irq(sbd, &s->irq);
 +}
 +
 +static int nrf51_uart_post_load(void *opaque, int version_id)
 +{
 +    NRF51UARTState *s = NRF51_UART(opaque);
 +
 +    if (s->pending_tx_byte) {
 +        s->watch_tag = qemu_chr_fe_add_watch(&s->chr, G_IO_OUT | G_IO_HUP,
 +                                             uart_transmit, s);
 +    }
 +
 +    return 0;
 +}
 +
 +static const VMStateDescription nrf51_uart_vmstate = {
 +    .name = "nrf51_soc.uart",
 +    .post_load = nrf51_uart_post_load,
 +    .fields = (VMStateField[]) {
 +        VMSTATE_UINT32_ARRAY(reg, NRF51UARTState, 0x56C),
 +        VMSTATE_UINT8_ARRAY(rx_fifo, NRF51UARTState, UART_FIFO_LENGTH),
 +        VMSTATE_UINT32(rx_fifo_pos, NRF51UARTState),
 +        VMSTATE_UINT32(rx_fifo_len, NRF51UARTState),
 +        VMSTATE_BOOL(rx_started, NRF51UARTState),
 +        VMSTATE_BOOL(tx_started, NRF51UARTState),
 +        VMSTATE_BOOL(pending_tx_byte, NRF51UARTState),
 +        VMSTATE_BOOL(enabled, NRF51UARTState),
 +        VMSTATE_END_OF_LIST()
 +    }
 +};
 +
-+static const MPCInfo b1_mpc_info[] = { {
++static Property nrf51_uart_properties[] = {
-+        .name = "qspi",
++    DEFINE_PROP_CHR("chardev", NRF51UARTState, chr),
-+        .type = MPC_ROM,
++    DEFINE_PROP_END_OF_LIST(),
 +        .addr = 0x00000000,
 +        .size = 0x02000000,
 +    }, {
 +        .name = "sram",
 +        .type = MPC_RAM,
 +        .addr = 0x0a400000,
 +        .size = 0x00080000,
 +    }, {
 +        .name = "eflash0",
 +        .type = MPC_ROM,
 +        .addr = 0x0a000000,
 +        .size = 0x00200000,
 +    }, {
 +        .name = "eflash1",
 +        .type = MPC_ROM,
 +        .addr = 0x0a200000,
 +        .size = 0x00200000,
 +    }, {
 +        .name = "cryptoisland",
 +        .type = MPC_CRYPTOISLAND,
 +        .addr = 0x0a000000,
 +        .size = 0x00200000,
 +    }
 +};
 +
-+static MemoryRegion *make_mpc(MuscaMachineState *mms, void *opaque,
++static void nrf51_uart_class_init(ObjectClass *klass, void *data)
-+                              const char *name, hwaddr size)
++{
-+{
++    DeviceClass *dc = DEVICE_CLASS(klass);
-+    /*
++
-+     * Create an MPC and the RAM or flash behind it.
++    dc->reset = nrf51_uart_reset;
-+     * MPC 0: eFlash 0
++    dc->realize = nrf51_uart_realize;
-+     * MPC 1: eFlash 1
++    dc->props = nrf51_uart_properties;
-+     * MPC 2: SRAM
++    dc->vmsd = &nrf51_uart_vmstate;
-+     * MPC 3: QSPI flash
++}
-+     * MPC 4: CryptoIsland
++
-+     * For now we implement the flash regions as ROM (ie not programmable)
++static const TypeInfo nrf51_uart_info = {
-+     * (with their control interface memory regions being unimplemented
++    .name = TYPE_NRF51_UART,
-+     * stubs behind the PPCs).
++    .parent = TYPE_SYS_BUS_DEVICE,
-+     * The whole CryptoIsland region behind its MPC is an unimplemented stub.
++    .instance_size = sizeof(NRF51UARTState),
-+     */
++    .instance_init = nrf51_uart_init,
-+    MuscaMachineClass *mmc = MUSCA_MACHINE_GET_CLASS(mms);
++    .class_init = nrf51_uart_class_init
-+    TZMPC *mpc = opaque;
++};
-+    int i = mpc - &mms->mpc[0];
++
-+    MemoryRegion *downstream;
++static void nrf51_uart_register_types(void)
-+    MemoryRegion *upstream;
++{
-+    UnimplementedDeviceState *uds;
++    type_register_static(&nrf51_uart_info);
-+    char *mpcname;
++}
-+    const MPCInfo *mpcinfo = mmc->mpc_info;
++
-+
++type_init(nrf51_uart_register_types)
-+    mpcname = g_strdup_printf("%s-mpc", mpcinfo[i].name);
+diff --git a/hw/char/trace-events b/hw/char/trace-events
-+
+index XXXXXXX..XXXXXXX 100644
-+    switch (mpcinfo[i].type) {
+--- a/hw/char/trace-events
-+    case MPC_ROM:
++++ b/hw/char/trace-events
-+        downstream = &mms->ram[i];
+@@ -XXX,XX +XXX,XX @@ cmsdk_apb_uart_receive(uint8_t c) "CMSDK APB UART: got character 0x%x from backe
-+        memory_region_init_rom(downstream, NULL, mpcinfo[i].name,
+ cmsdk_apb_uart_tx_pending(void) "CMSDK APB UART: character send to backend pending"
-+                               mpcinfo[i].size, &error_fatal);
+ cmsdk_apb_uart_tx(uint8_t c) "CMSDK APB UART: character 0x%x sent to backend"
-+        break;
+ cmsdk_apb_uart_set_params(int speed) "CMSDK APB UART: params set to %d 8N1"
-+    case MPC_RAM:
++
-+        downstream = &mms->ram[i];
++# hw/char/nrf51_uart.c
-+        memory_region_init_ram(downstream, NULL, mpcinfo[i].name,
++nrf51_uart_read(uint64_t addr, uint64_t r, unsigned int size) "addr 0x%" PRIx64 " value 0x%" PRIx64 " size %u"
-+                               mpcinfo[i].size, &error_fatal);
++nrf51_uart_write(uint64_t addr, uint64_t value, unsigned int size) "addr 0x%" PRIx64 " value 0x%" PRIx64 " size %u"
 +        break;
 +    case MPC_CRYPTOISLAND:
 +        /* We don't implement the CryptoIsland yet */
 +        uds = &mms->cryptoisland;
 +        sysbus_init_child_obj(OBJECT(mms), name, uds,
 +                              sizeof(UnimplementedDeviceState),
 +                              TYPE_UNIMPLEMENTED_DEVICE);
 +        qdev_prop_set_string(DEVICE(uds), "name", mpcinfo[i].name);
 +        qdev_prop_set_uint64(DEVICE(uds), "size", mpcinfo[i].size);
 +        object_property_set_bool(OBJECT(uds), true, "realized", &error_fatal);
 +        downstream = sysbus_mmio_get_region(SYS_BUS_DEVICE(uds), 0);
 +        break;
 +    default:
 +        g_assert_not_reached();
 +    }
 +
 +    sysbus_init_child_obj(OBJECT(mms), mpcname, mpc, sizeof(mms->mpc[0]),
 +                          TYPE_TZ_MPC);
 +    object_property_set_link(OBJECT(mpc), OBJECT(downstream),
 +                             "downstream", &error_fatal);
 +    object_property_set_bool(OBJECT(mpc), true, "realized", &error_fatal);
 +    /* Map the upstream end of the MPC into system memory */
 +    upstream = sysbus_mmio_get_region(SYS_BUS_DEVICE(mpc), 1);
 +    memory_region_add_subregion(get_system_memory(), mpcinfo[i].addr, upstream);
 +    /* and connect its interrupt to the SSE-200 */
 +    qdev_connect_gpio_out_named(DEVICE(mpc), "irq", 0,
 +                                qdev_get_gpio_in_named(DEVICE(&mms->sse),
 +                                                       "mpcexp_status", i));
 +
 +    g_free(mpcname);
 +    /* Return the register interface MR for our caller to map behind the PPC */
 +    return sysbus_mmio_get_region(SYS_BUS_DEVICE(mpc), 0);
 +}
 +
  static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
                                         const char *name, hwaddr size)
  {
@@ -XXX,XX +XXX,XX @@ static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
          { "pwm1", make_unimp_dev, &mms->pwm[1], 0xe000, 0x1000 },
          { "pwm2", make_unimp_dev, &mms->pwm[2], 0xf000, 0x1000 },
          { "gpio", make_unimp_dev, &mms->gpio, 0x10000, 0x1000 },
 -        { "mpc0", make_unimp_dev, &mms->mpc[0], 0x12000, 0x1000 },
 -        { "mpc1", make_unimp_dev, &mms->mpc[1], 0x13000, 0x1000 },
 +        { "mpc0", make_mpc, &mms->mpc[0], 0x12000, 0x1000 },
 +        { "mpc1", make_mpc, &mms->mpc[1], 0x13000, 0x1000 },
      };
      memory_region_init(container, OBJECT(mms), "musca-device-container", size);
@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
      int i;
      assert(mmc->num_irqs <= MUSCA_NUMIRQ_MAX);
 +    assert(mmc->num_mpcs <= MUSCA_MPC_MAX);
      if (strcmp(machine->cpu_type, mc->default_cpu_type) != 0) {
          error_report("This board can only be used with CPU %s",
@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
                  { "eflash1", make_unimp_dev, &mms->eflash[1],
 x52500000, 0x1000 },
                  { "qspi", make_unimp_dev, &mms->qspi, 0x42800000, 0x100000 },
 -                { "mpc0", make_unimp_dev, &mms->mpc[0], 0x52000000, 0x1000 },
 -                { "mpc1", make_unimp_dev, &mms->mpc[1], 0x52100000, 0x1000 },
 -                { "mpc2", make_unimp_dev, &mms->mpc[2], 0x52200000, 0x1000 },
 -                { "mpc3", make_unimp_dev, &mms->mpc[3], 0x52300000, 0x1000 },
 +                { "mpc0", make_mpc, &mms->mpc[0], 0x52000000, 0x1000 },
 +                { "mpc1", make_mpc, &mms->mpc[1], 0x52100000, 0x1000 },
 +                { "mpc2", make_mpc, &mms->mpc[2], 0x52200000, 0x1000 },
 +                { "mpc3", make_mpc, &mms->mpc[3], 0x52300000, 0x1000 },
                  { "mhu0", make_unimp_dev, &mms->mhu[0], 0x42600000, 0x100000 },
                  { "mhu1", make_unimp_dev, &mms->mhu[1], 0x42700000, 0x100000 },
                  { }, /* port 9: unused */
@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
                  { }, /* port 11: unused */
                  { }, /* port 12: unused */
                  { }, /* port 13: unused */
 -                { "mpc4", make_unimp_dev, &mms->mpc[4], 0x52e00000, 0x1000 },
 +                { "mpc4", make_mpc, &mms->mpc[4], 0x52e00000, 0x1000 },
              },
          }, {
              .name = "apb_ppcexp1",
@@ -XXX,XX +XXX,XX @@ static void musca_a_class_init(ObjectClass *oc, void *data)
      mmc->init_svtor = 0x10200000;
      mmc->sram_addr_width = 15;
      mmc->num_irqs = 64;
 +    mmc->mpc_info = a_mpc_info;
 +    mmc->num_mpcs = ARRAY_SIZE(a_mpc_info);
  }
  static void musca_b1_class_init(ObjectClass *oc, void *data)
@@ -XXX,XX +XXX,XX @@ static void musca_b1_class_init(ObjectClass *oc, void *data)
      mmc->init_svtor = 0x10000000;
      mmc->sram_addr_width = 17;
      mmc->num_irqs = 96;
 +    mmc->mpc_info = b1_mpc_info;
 +    mmc->num_mpcs = ARRAY_SIZE(b1_mpc_info);
  }
  static const TypeInfo musca_info = {
 --
-.20.1
+.19.1

-[Qemu-devel] [PULL 04/21] target/arm: Restructure disas_fp_int_conv
+[Qemu-devel] [PULL 03/10] hw/arm/nrf51_soc: Connect UART to nRF51 SoC
-From: Richard Henderson <richard.henderson@linaro.org>
+From: Julia Suvorova <jusual@mail.ru>
-For opcodes 0-5, move some if conditions into the structure
+Wire up nRF51 UART in the corresponding SoC.
 of a switch statement.  For opcodes 6 & 7, decode everything
 at once with a second switch.
-Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
+Signed-off-by: Julia Suvorova <jusual@mail.ru>
-Message-id: 20190215192302.27855-2-richard.henderson@linaro.org
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
 Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
 ---
- target/arm/translate-a64.c | 94 ++++++++++++++++++++------------------
+ include/hw/arm/nrf51_soc.h |  3 +++
-file changed, 49 insertions(+), 45 deletions(-)
+ hw/arm/microbit.c          |  2 ++
  hw/arm/nrf51_soc.c         | 20 ++++++++++++++++++++
 files changed, 25 insertions(+)
-diff --git a/target/arm/translate-a64.c b/target/arm/translate-a64.c
+diff --git a/include/hw/arm/nrf51_soc.h b/include/hw/arm/nrf51_soc.h
 index XXXXXXX..XXXXXXX 100644
---- a/target/arm/translate-a64.c
+--- a/include/hw/arm/nrf51_soc.h
-+++ b/target/arm/translate-a64.c
++++ b/include/hw/arm/nrf51_soc.h
-@@ -XXX,XX +XXX,XX @@ static void disas_fp_int_conv(DisasContext *s, uint32_t insn)
+@@ -XXX,XX +XXX,XX @@
-     int type = extract32(insn, 22, 2);
-     bool sbit = extract32(insn, 29, 1);
+ #include "hw/sysbus.h"
-     bool sf = extract32(insn, 31, 1);
+ #include "hw/arm/armv7m.h"
-+    bool itof = false;
++#include "hw/char/nrf51_uart.h"
-     if (sbit) {
+ #define TYPE_NRF51_SOC "nrf51-soc"
--        unallocated_encoding(s);
+ #define NRF51_SOC(obj) \
--        return;
+@@ -XXX,XX +XXX,XX @@ typedef struct NRF51State {
-+        goto do_unallocated;
+     /*< public >*/
      ARMv7MState cpu;
 +    NRF51UARTState uart;
 +
      MemoryRegion iomem;
      MemoryRegion sram;
      MemoryRegion flash;
 diff --git a/hw/arm/microbit.c b/hw/arm/microbit.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/arm/microbit.c
 +++ b/hw/arm/microbit.c
@@ -XXX,XX +XXX,XX @@
  #include "qapi/error.h"
  #include "hw/boards.h"
  #include "hw/arm/arm.h"
 +#include "sysemu/sysemu.h"
  #include "exec/address-spaces.h"
  #include "hw/arm/nrf51_soc.h"
@@ -XXX,XX +XXX,XX @@ static void microbit_init(MachineState *machine)
      sysbus_init_child_obj(OBJECT(machine), "nrf51", soc, sizeof(s->nrf51),
                            TYPE_NRF51_SOC);
 +    qdev_prop_set_chr(DEVICE(&s->nrf51), "serial0", serial_hd(0));
      object_property_set_link(soc, OBJECT(system_memory), "memory",
                               &error_fatal);
      object_property_set_bool(soc, true, "realized", &error_fatal);
 diff --git a/hw/arm/nrf51_soc.c b/hw/arm/nrf51_soc.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/arm/nrf51_soc.c
 +++ b/hw/arm/nrf51_soc.c
@@ -XXX,XX +XXX,XX @@
  #define NRF51822_FLASH_SIZE     (256 * 1024)
  #define NRF51822_SRAM_SIZE      (16 * 1024)
 +#define BASE_TO_IRQ(base) ((base >> 12) & 0x1F)
 +
  static void nrf51_soc_realize(DeviceState *dev_soc, Error **errp)
  {
      NRF51State *s = NRF51_SOC(dev_soc);
 +    MemoryRegion *mr;
      Error *err = NULL;
      if (!s->board_memory) {
@@ -XXX,XX +XXX,XX @@ static void nrf51_soc_realize(DeviceState *dev_soc, Error **errp)
      }
+     memory_region_add_subregion(&s->container, SRAM_BASE, &s->sram);
--    if (opcode > 5) {
--        /* FMOV */
++    /* UART */
--        bool itof = opcode & 1;
++    object_property_set_bool(OBJECT(&s->uart), true, "realized", &err);
--
++    if (err) {
--        if (rmode >= 2) {
++        error_propagate(errp, err);
--            unallocated_encoding(s);
++        return;
--            return;
++    }
--        }
++    mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->uart), 0);
--
++    memory_region_add_subregion_overlap(&s->container, UART_BASE, mr, 0);
--        switch (sf << 3 | type << 1 | rmode) {
++    sysbus_connect_irq(SYS_BUS_DEVICE(&s->uart), 0,
--        case 0x0: /* 32 bit */
++                       qdev_get_gpio_in(DEVICE(&s->cpu),
--        case 0xa: /* 64 bit */
++                       BASE_TO_IRQ(UART_BASE)));
 -        case 0xd: /* 64 bit to top half of quad */
 -            break;
 -        case 0x6: /* 16-bit float, 32-bit int */
 -        case 0xe: /* 16-bit float, 64-bit int */
 -            if (dc_isar_feature(aa64_fp16, s)) {
 -                break;
 -            }
 -            /* fallthru */
 -        default:
 -            /* all other sf/type/rmode combinations are invalid */
 -            unallocated_encoding(s);
 -            return;
 -        }
 -
 -        if (!fp_access_check(s)) {
 -            return;
 -        }
 -        handle_fmov(s, rd, rn, type, itof);
 -    } else {
 -        /* actual FP conversions */
 -        bool itof = extract32(opcode, 1, 1);
 -
 -        if (rmode != 0 && opcode > 1) {
 -            unallocated_encoding(s);
 -            return;
 +    switch (opcode) {
 +    case 2: /* SCVTF */
 +    case 3: /* UCVTF */
 +        itof = true;
 +        /* fallthru */
 +    case 4: /* FCVTAS */
 +    case 5: /* FCVTAU */
 +        if (rmode != 0) {
 +            goto do_unallocated;
          }
 +        /* fallthru */
 +    case 0: /* FCVT[NPMZ]S */
 +    case 1: /* FCVT[NPMZ]U */
          switch (type) {
          case 0: /* float32 */
          case 1: /* float64 */
              break;
          case 3: /* float16 */
 -            if (dc_isar_feature(aa64_fp16, s)) {
 -                break;
 +            if (!dc_isar_feature(aa64_fp16, s)) {
 +                goto do_unallocated;
              }
 -            /* fallthru */
 +            break;
          default:
 -            unallocated_encoding(s);
 -            return;
 +            goto do_unallocated;
          }
 -
          if (!fp_access_check(s)) {
              return;
          }
          handle_fpfpcvt(s, rd, rn, opcode, itof, rmode, 64, sf, type);
 +        break;
 +
-+    default:
+     create_unimplemented_device("nrf51_soc.io", IOMEM_BASE, IOMEM_SIZE);
-+        switch (sf << 7 | type << 5 | rmode << 3 | opcode) {
+     create_unimplemented_device("nrf51_soc.ficr", FICR_BASE, FICR_SIZE);
-+        case 0b01100110: /* FMOV half <-> 32-bit int */
+     create_unimplemented_device("nrf51_soc.private",
-+        case 0b01100111:
+@@ -XXX,XX +XXX,XX @@ static void nrf51_soc_init(Object *obj)
-+        case 0b11100110: /* FMOV half <-> 64-bit int */
+     qdev_prop_set_string(DEVICE(&s->cpu), "cpu-type",
-+        case 0b11100111:
+                          ARM_CPU_TYPE_NAME("cortex-m0"));
-+            if (!dc_isar_feature(aa64_fp16, s)) {
+     qdev_prop_set_uint32(DEVICE(&s->cpu), "num-irq", 32);
 +                goto do_unallocated;
 +            }
 +            /* fallthru */
 +        case 0b00000110: /* FMOV 32-bit */
 +        case 0b00000111:
 +        case 0b10100110: /* FMOV 64-bit */
 +        case 0b10100111:
 +        case 0b11001110: /* FMOV top half of 128-bit */
 +        case 0b11001111:
 +            if (!fp_access_check(s)) {
 +                return;
 +            }
 +            itof = opcode & 1;
 +            handle_fmov(s, rd, rn, type, itof);
 +            break;
 +
-+        default:
++    sysbus_init_child_obj(obj, "uart", &s->uart, sizeof(s->uart),
-+        do_unallocated:
++                           TYPE_NRF51_UART);
-+            unallocated_encoding(s);
++    object_property_add_alias(obj, "serial0", OBJECT(&s->uart), "chardev",
-+            return;
++                              &error_abort);
 +        }
 +        break;
      }
  }
+ static Property nrf51_soc_properties[] = {
 --
-.20.1
+.19.1

-[Qemu-devel] [PULL 08/21] hw/misc/tz-ppc: Support having unused ports in the middle of the range
+[Qemu-devel] [PULL 04/10] tests/boot-serial-test: Add microbit board testcase
-The Peripheral Protection Controller's handling of unused ports
+From: Julia Suvorova <jusual@mail.ru>
 is that if there is nothing connected to the port's downstream
 then it does not create the sysbus MMIO region for the upstream
 end of the port. This results in odd behaviour when there is
 an unused port in the middle of the range: since sysbus MMIO
 regions are implicitly consecutively allocated, any used ports
 above the unused ones end up with sysbus MMIO region numbers
 that don't match the port number.
-Avoid this numbering mismatch by creating dummy MMIO regions
+New mini-kernel test for nRF51 SoC UART.
 for the unused ports. This doesn't change anything for our
 existing boards, which don't have any gaps in the middle of
 the port ranges they use; but it will be needed for the Musca
 board.
+Signed-off-by: Julia Suvorova <jusual@mail.ru>
+Acked-by: Thomas Huth <thuth@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
 ---
- include/hw/misc/tz-ppc.h |  8 +++++++-
+ tests/boot-serial-test.c | 19 +++++++++++++++++++
- hw/misc/tz-ppc.c         | 32 ++++++++++++++++++++++++++++++++
+file changed, 19 insertions(+)
 files changed, 39 insertions(+), 1 deletion(-)
-diff --git a/include/hw/misc/tz-ppc.h b/include/hw/misc/tz-ppc.h
+diff --git a/tests/boot-serial-test.c b/tests/boot-serial-test.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/hw/misc/tz-ppc.h
+--- a/tests/boot-serial-test.c
-+++ b/include/hw/misc/tz-ppc.h
++++ b/tests/boot-serial-test.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static const uint8_t kernel_aarch64[] = {
-  *
+xfd, 0xff, 0xff, 0x17,                 /* b       -12 (loop) */
   * QEMU interface:
   * + sysbus MMIO regions 0..15: MemoryRegions defining the upstream end
 - *   of each of the 16 ports of the PPC
 + *   of each of the 16 ports of the PPC. When a port is unused (i.e. no
 + *   downstream MemoryRegion is connected to it) at the end of the 0..15
 + *   range then no sysbus MMIO region is created for its upstream. When an
 + *   unused port lies in the middle of the range with other used ports at
 + *   higher port numbers, a dummy MMIO region is created to ensure that
 + *   port N's upstream is always sysbus MMIO region N. Dummy regions should
 + *   not be mapped, and will assert if any access is made to them.
   * + Property "port[0..15]": MemoryRegion defining the downstream device(s)
   *   for each of the 16 ports of the PPC
   * + Named GPIO inputs "cfg_nonsec[0..15]": set to 1 if the port should be
 diff --git a/hw/misc/tz-ppc.c b/hw/misc/tz-ppc.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/misc/tz-ppc.c
 +++ b/hw/misc/tz-ppc.c
@@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps tz_ppc_ops = {
      .endianness = DEVICE_LITTLE_ENDIAN,
  };
-+static bool tz_ppc_dummy_accepts(void *opaque, hwaddr addr,
++static const uint8_t kernel_nrf51[] = {
-+                                 unsigned size, bool is_write,
++    0x00, 0x00, 0x00, 0x00,                 /* Stack top address */
-+                                 MemTxAttrs attrs)
++    0x09, 0x00, 0x00, 0x00,                 /* Reset handler address */
-+{
++    0x04, 0x4a,                             /* ldr  r2, [pc, #16] Get ENABLE */
-+    /*
++    0x04, 0x21,                             /* movs r1, #4 */
-+     * Board code should never map the upstream end of an unused port,
++    0x11, 0x60,                             /* str  r1, [r2] */
-+     * so we should never try to make a memory access to it.
++    0x04, 0x4a,                             /* ldr  r2, [pc, #16] Get STARTTX */
-+     */
++    0x01, 0x21,                             /* movs r1, #1 */
-+    g_assert_not_reached();
++    0x11, 0x60,                             /* str  r1, [r2] */
-+}
++    0x03, 0x4a,                             /* ldr  r2, [pc, #12] Get TXD */
-+
++    0x54, 0x21,                             /* movs r1, 'T' */
-+static const MemoryRegionOps tz_ppc_dummy_ops = {
++    0x11, 0x60,                             /* str  r1, [r2] */
-+    .valid.accepts = tz_ppc_dummy_accepts,
++    0xfe, 0xe7,                             /* b    . */
 +    0x00, 0x25, 0x00, 0x40,                 /* 0x40002500 = UART ENABLE */
 +    0x08, 0x20, 0x00, 0x40,                 /* 0x40002008 = UART STARTTX */
 +    0x1c, 0x25, 0x00, 0x40                  /* 0x4000251c = UART TXD */
 +};
 +
- static void tz_ppc_reset(DeviceState *dev)
+ typedef struct testdef {
- {
+     const char *arch;       /* Target architecture */
-     TZPPC *s = TZ_PPC(dev);
+     const char *machine;    /* Name of the machine */
-@@ -XXX,XX +XXX,XX @@ static void tz_ppc_realize(DeviceState *dev, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static testdef_t tests[] = {
-     SysBusDevice *sbd = SYS_BUS_DEVICE(dev);
+     { "hppa", "hppa", "", "SeaBIOS wants SYSTEM HALT" },
-     TZPPC *s = TZ_PPC(dev);
+     { "aarch64", "virt", "-cpu cortex-a57", "TT", sizeof(kernel_aarch64),
-     int i;
+       kernel_aarch64 },
-+    int max_port = 0;
++    { "arm", "microbit", "", "T", sizeof(kernel_nrf51), kernel_nrf51 },
-     /* We can't create the upstream end of the port until realize,
+     { NULL }
-      * as we don't know the size of the MR used as the downstream until then.
+ };
       */
      for (i = 0; i < TZ_NUM_PORTS; i++) {
 +        if (s->port[i].downstream) {
 +            max_port = i;
 +        }
 +    }
 +
 +    for (i = 0; i <= max_port; i++) {
          TZPPCPort *port = &s->port[i];
          char *name;
          uint64_t size;
          if (!port->downstream) {
 +            /*
 +             * Create dummy sysbus MMIO region so the sysbus region
 +             * numbering doesn't get out of sync with the port numbers.
 +             * The size is entirely arbitrary.
 +             */
 +            name = g_strdup_printf("tz-ppc-dummy-port[%d]", i);
 +            memory_region_init_io(&port->upstream, obj, &tz_ppc_dummy_ops,
 +                                  port, name, 0x10000);
 +            sysbus_init_mmio(sbd, &port->upstream);
 +            g_free(name);
              continue;
          }
 --
-.20.1
+.19.1

-[Qemu-devel] [PULL 09/21] hw/timer/pl031: Allow use as an embedded-struct device
+[Qemu-devel] [PULL 05/10] MAINTAINERS: Remove bouncing email in ARM ACPI
-Create a new include file for the pl031's device struct,
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
 type macros, etc, so that it can be instantiated using
 the "embedded struct" coding style.
+Shannon Zhao's email at Huawei is bouncing: remove it.
+    X-Failed-Recipients: zhaoshenglong@huawei.com
+    ** Address not found **
+    Your message wasn't delivered to zhaoshenglong@huawei.com because the address couldn't be found, or is unable to receive mail.
+Note that the section still contains his personal email (see e59f13d76bb).
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Acked-by: Shannon Zhao <shannon.zhaosl@gmail.com>
+Message-id: 20181029195931.8747-1-philmd@redhat.com
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
 ---
- include/hw/timer/pl031.h | 44 ++++++++++++++++++++++++++++++++++++++++
+ MAINTAINERS | 1 -
- hw/timer/pl031.c         | 25 +----------------------
+file changed, 1 deletion(-)
  MAINTAINERS              |  1 +
 files changed, 46 insertions(+), 24 deletions(-)
  create mode 100644 include/hw/timer/pl031.h
-diff --git a/include/hw/timer/pl031.h b/include/hw/timer/pl031.h
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/include/hw/timer/pl031.h
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * ARM AMBA PrimeCell PL031 RTC
-+ *
-+ * Copyright (c) 2007 CodeSourcery
-+ *
-+ * This file is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License version 2 as
-+ * published by the Free Software Foundation.
-+ *
-+ * Contributions after 2012-01-13 are licensed under the terms of the
-+ * GNU GPL, version 2 or (at your option) any later version.
-+ */
-+
-+#ifndef HW_TIMER_PL031
-+#define HW_TIMER_PL031
-+
-+#include "hw/sysbus.h"
-+
-+#define TYPE_PL031 "pl031"
-+#define PL031(obj) OBJECT_CHECK(PL031State, (obj), TYPE_PL031)
-+
-+typedef struct PL031State {
-+    SysBusDevice parent_obj;
-+
-+    MemoryRegion iomem;
-+    QEMUTimer *timer;
-+    qemu_irq irq;
-+
-+    /*
-+     * Needed to preserve the tick_count across migration, even if the
-+     * absolute value of the rtc_clock is different on the source and
-+     * destination.
-+     */
-+    uint32_t tick_offset_vmstate;
-+    uint32_t tick_offset;
-+
-+    uint32_t mr;
-+    uint32_t lr;
-+    uint32_t cr;
-+    uint32_t im;
-+    uint32_t is;
-+} PL031State;
-+
-+#endif
-diff --git a/hw/timer/pl031.c b/hw/timer/pl031.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/timer/pl031.c
-+++ b/hw/timer/pl031.c
-@@ -XXX,XX +XXX,XX @@
-  */
- #include "qemu/osdep.h"
-+#include "hw/timer/pl031.h"
- #include "hw/sysbus.h"
- #include "qemu/timer.h"
- #include "sysemu/sysemu.h"
-@@ -XXX,XX +XXX,XX @@ do { printf("pl031: " fmt , ## __VA_ARGS__); } while (0)
- #define RTC_MIS     0x18    /* Masked interrupt status register */
- #define RTC_ICR     0x1c    /* Interrupt clear register */
--#define TYPE_PL031 "pl031"
--#define PL031(obj) OBJECT_CHECK(PL031State, (obj), TYPE_PL031)
--
--typedef struct PL031State {
--    SysBusDevice parent_obj;
--
--    MemoryRegion iomem;
--    QEMUTimer *timer;
--    qemu_irq irq;
--
--    /* Needed to preserve the tick_count across migration, even if the
--     * absolute value of the rtc_clock is different on the source and
--     * destination.
--     */
--    uint32_t tick_offset_vmstate;
--    uint32_t tick_offset;
--
--    uint32_t mr;
--    uint32_t lr;
--    uint32_t cr;
--    uint32_t im;
--    uint32_t is;
--} PL031State;
--
- static const unsigned char pl031_id[] = {
-x31, 0x10, 0x14, 0x00,         /* Device ID        */
-x0d, 0xf0, 0x05, 0xb1          /* Cell ID      */
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ F: hw/sd/pl181.c
+@@ -XXX,XX +XXX,XX @@ F: hw/*/xlnx*.c
- F: hw/ssi/pl022.c
+ F: include/hw/*/xlnx*.h
- F: include/hw/ssi/pl022.h
- F: hw/timer/pl031.c
+ ARM ACPI Subsystem
-+F: include/hw/timer/pl031.h
+-M: Shannon Zhao <zhaoshenglong@huawei.com>
- F: include/hw/arm/primecell.h
+ M: Shannon Zhao <shannon.zhaosl@gmail.com>
- F: hw/timer/cmsdk-apb-timer.c
+ L: qemu-arm@nongnu.org
- F: include/hw/timer/cmsdk-apb-timer.h
+ S: Maintained
 --
-.20.1
+.19.1

-[Qemu-devel] [PULL 13/21] hw/char/pl011: Use '0x' prefix when logging hex numbers
+[Qemu-devel] [PULL 06/10] strongarm: mask off high[31:28] bits from dir and state registers
-The pl011 logs when the guest makes a bad access. It prints
+From: Prasad J Pandit <pjp@fedoraproject.org>
 the address offset in hex but confusingly omits the '0x'
 prefix; add it.
+The high[31:28] bits of 'direction' and 'state' registers of
+SA-1100/SA-1110 device are reserved. Setting them may lead to
+OOB 's->handler[]' array access issue. Mask off [31:28] bits to
+avoid it.
+Reported-by: Moguofang <moguofang@huawei.com>
+Signed-off-by: Prasad J Pandit <pjp@fedoraproject.org>
+Message-id: 20181030114635.31232-1-ppandit@redhat.com
+Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
 ---
- hw/char/pl011.c | 4 ++--
+ hw/arm/strongarm.c | 4 ++--
 file changed, 2 insertions(+), 2 deletions(-)
-diff --git a/hw/char/pl011.c b/hw/char/pl011.c
+diff --git a/hw/arm/strongarm.c b/hw/arm/strongarm.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/char/pl011.c
+--- a/hw/arm/strongarm.c
-+++ b/hw/char/pl011.c
++++ b/hw/arm/strongarm.c
-@@ -XXX,XX +XXX,XX @@ static uint64_t pl011_read(void *opaque, hwaddr offset,
+@@ -XXX,XX +XXX,XX @@ static void strongarm_gpio_write(void *opaque, hwaddr offset,
      switch (offset) {
      case GPDR:        /* GPIO Pin-Direction registers */
 -        s->dir = value;
 +        s->dir = value & 0x0fffffff;
          strongarm_gpio_handler_update(s);
          break;
-     default:
-         qemu_log_mask(LOG_GUEST_ERROR,
+     case GPSR:        /* GPIO Pin-Output Set registers */
--                      "pl011_read: Bad offset %x\n", (int)offset);
+-        s->olevel |= value;
-+                      "pl011_read: Bad offset 0x%x\n", (int)offset);
++        s->olevel |= value & 0x0fffffff;
-         r = 0;
+         strongarm_gpio_handler_update(s);
          break;
-     }
-@@ -XXX,XX +XXX,XX @@ static void pl011_write(void *opaque, hwaddr offset,
-         break;
-     default:
-         qemu_log_mask(LOG_GUEST_ERROR,
--                      "pl011_write: Bad offset %x\n", (int)offset);
-+                      "pl011_write: Bad offset 0x%x\n", (int)offset);
-     }
- }
 --
-.20.1
+.19.1

-[Qemu-devel] [PULL 03/21] target/arm: Stop unintentional sign extension in pmu_init
+[Qemu-devel] [PULL 07/10] hw/arm/xilinx_zynq: Use the ARRAY_SIZE macro
-From: Aaron Lindsay OS <aaron@os.amperecomputing.com>
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-This was introduced by
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-    commit bf8d09694ccc07487cd73d7562081fdaec3370c8
+Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
-    target/arm: Don't clear supported PMU events when initializing PMCEID1
+Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
 and identified by Coverity (CID 1398645).
 Signed-off-by: Aaron Lindsay <aaron@os.amperecomputing.com>
 Reported-by: Peter Maydell <peter.maydell@linaro.org>
 Message-id: 20190219144621.450-1-aaron@os.amperecomputing.com
 Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
 ---
- target/arm/helper.c | 2 +-
+ hw/arm/xilinx_zynq.c | 2 +-
 file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/target/arm/helper.c b/target/arm/helper.c
+diff --git a/hw/arm/xilinx_zynq.c b/hw/arm/xilinx_zynq.c
 index XXXXXXX..XXXXXXX 100644
---- a/target/arm/helper.c
+--- a/hw/arm/xilinx_zynq.c
-+++ b/target/arm/helper.c
++++ b/hw/arm/xilinx_zynq.c
-@@ -XXX,XX +XXX,XX @@ void pmu_init(ARMCPU *cpu)
+@@ -XXX,XX +XXX,XX @@ static void zynq_init(MachineState *machine)
+     busdev = SYS_BUS_DEVICE(dev);
-         if (cnt->supported(&cpu->env)) {
+     sysbus_mmio_map(busdev, 0, 0xF8003000);
-             supported_event_map[cnt->number] = i;
+     sysbus_connect_irq(busdev, 0, pic[45-IRQ_OFFSET]); /* abort irq line */
--            uint64_t event_mask = 1 << (cnt->number & 0x1f);
+-    for (n = 0; n < 8; ++n) { /* event irqs */
-+            uint64_t event_mask = 1ULL << (cnt->number & 0x1f);
++    for (n = 0; n < ARRAY_SIZE(dma_irqs); ++n) { /* event irqs */
-             if (cnt->number & 0x20) {
+         sysbus_connect_irq(busdev, n + 1, pic[dma_irqs[n] - IRQ_OFFSET]);
-                 cpu->pmceid1 |= event_mask;
+     }
-             } else {
 --
-.20.1
+.19.1

-[Qemu-devel] [PULL 07/21] target/arm: Implement ARMv8.3-JSConv
+[Qemu-devel] [PULL 08/10] target/arm: Conditionalize some asserts on aarch32 support
 From: Richard Henderson <richard.henderson@linaro.org>
+When populating id registers from kvm, on a host that doesn't support
+aarch32 mode at all, neither arm_div nor jazelle will be supported either.
 Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
-Message-id: 20190215192302.27855-5-richard.henderson@linaro.org
+Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
 Tested-by: Alex Bennée <alex.bennee@linaro.org>
 Message-id: 20181102102025.3546-1-richard.henderson@linaro.org
 Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
-[PMM: fixed a couple of comment typos]
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
 ---
- target/arm/cpu.h           | 10 +++++
+ target/arm/cpu.h |  5 +++++
- target/arm/helper.h        |  3 ++
+ target/arm/cpu.c | 15 +++++++++++++--
- target/arm/cpu.c           |  1 +
+files changed, 18 insertions(+), 2 deletions(-)
  target/arm/cpu64.c         |  2 +
  target/arm/translate-a64.c | 26 +++++++++++
  target/arm/translate.c     | 10 +++++
  target/arm/vfp_helper.c    | 88 ++++++++++++++++++++++++++++++++++++++
 files changed, 140 insertions(+)
 diff --git a/target/arm/cpu.h b/target/arm/cpu.h
 index XXXXXXX..XXXXXXX 100644
 --- a/target/arm/cpu.h
 +++ b/target/arm/cpu.h
-@@ -XXX,XX +XXX,XX @@ static inline bool isar_feature_aa32_vcma(const ARMISARegisters *id)
+@@ -XXX,XX +XXX,XX @@ static inline bool isar_feature_aa64_fp16(const ARMISARegisters *id)
-     return FIELD_EX32(id->id_isar5, ID_ISAR5, VCMA) != 0;
+     return FIELD_EX64(id->id_aa64pfr0, ID_AA64PFR0, FP) == 1;
  }
-+static inline bool isar_feature_aa32_jscvt(const ARMISARegisters *id)
++static inline bool isar_feature_aa64_aa32(const ARMISARegisters *id)
 +{
-+    return FIELD_EX32(id->id_isar6, ID_ISAR6, JSCVT) != 0;
++    return FIELD_EX64(id->id_aa64pfr0, ID_AA64PFR0, EL0) >= 2;
 +}
 +
- static inline bool isar_feature_aa32_dp(const ARMISARegisters *id)
+ static inline bool isar_feature_aa64_sve(const ARMISARegisters *id)
  {
-     return FIELD_EX32(id->id_isar6, ID_ISAR6, DP) != 0;
+     return FIELD_EX64(id->id_aa64pfr0, ID_AA64PFR0, SVE) != 0;
@@ -XXX,XX +XXX,XX @@ static inline bool isar_feature_aa64_dp(const ARMISARegisters *id)
      return FIELD_EX64(id->id_aa64isar0, ID_AA64ISAR0, DP) != 0;
  }
 +static inline bool isar_feature_aa64_jscvt(const ARMISARegisters *id)
 +{
 +    return FIELD_EX64(id->id_aa64isar1, ID_AA64ISAR1, JSCVT) != 0;
 +}
 +
  static inline bool isar_feature_aa64_fcma(const ARMISARegisters *id)
  {
      return FIELD_EX64(id->id_aa64isar1, ID_AA64ISAR1, FCMA) != 0;
 diff --git a/target/arm/helper.h b/target/arm/helper.h
 index XXXXXXX..XXXXXXX 100644
 --- a/target/arm/helper.h
 +++ b/target/arm/helper.h
@@ -XXX,XX +XXX,XX @@ DEF_HELPER_FLAGS_2(rintd_exact, TCG_CALL_NO_RWG, f64, f64, ptr)
  DEF_HELPER_FLAGS_2(rints, TCG_CALL_NO_RWG, f32, f32, ptr)
  DEF_HELPER_FLAGS_2(rintd, TCG_CALL_NO_RWG, f64, f64, ptr)
 +DEF_HELPER_FLAGS_2(vjcvt, TCG_CALL_NO_RWG, i32, f64, env)
 +DEF_HELPER_FLAGS_2(fjcvtzs, TCG_CALL_NO_RWG, i64, f64, ptr)
 +
  /* neon_helper.c */
  DEF_HELPER_FLAGS_3(neon_qadd_u8, TCG_CALL_NO_RWG, i32, env, i32, i32)
  DEF_HELPER_FLAGS_3(neon_qadd_s8, TCG_CALL_NO_RWG, i32, env, i32, i32)
 diff --git a/target/arm/cpu.c b/target/arm/cpu.c
 index XXXXXXX..XXXXXXX 100644
 --- a/target/arm/cpu.c
 +++ b/target/arm/cpu.c
-@@ -XXX,XX +XXX,XX @@ static void arm_max_initfn(Object *obj)
+@@ -XXX,XX +XXX,XX @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp)
-             cpu->isar.id_isar5 = t;
+     CPUARMState *env = &cpu->env;
+     int pagebits;
-             t = cpu->isar.id_isar6;
+     Error *local_err = NULL;
-+            t = FIELD_DP32(t, ID_ISAR6, JSCVT, 1);
++    bool no_aa32 = false;
-             t = FIELD_DP32(t, ID_ISAR6, DP, 1);
-             cpu->isar.id_isar6 = t;
+     /* If we needed to query the host kernel for the CPU features
+      * then it's possible that might have failed in the initfn, but
-diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c
+@@ -XXX,XX +XXX,XX @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp)
-index XXXXXXX..XXXXXXX 100644
+             set_feature(env, ARM_FEATURE_V7VE);
---- a/target/arm/cpu64.c
+         }
 +++ b/target/arm/cpu64.c
@@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj)
          cpu->isar.id_aa64isar0 = t;
          t = cpu->isar.id_aa64isar1;
 +        t = FIELD_DP64(t, ID_AA64ISAR1, JSCVT, 1);
          t = FIELD_DP64(t, ID_AA64ISAR1, FCMA, 1);
          t = FIELD_DP64(t, ID_AA64ISAR1, APA, 1); /* PAuth, architected only */
          t = FIELD_DP64(t, ID_AA64ISAR1, API, 0);
@@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj)
          cpu->isar.id_isar5 = u;
          u = cpu->isar.id_isar6;
 +        u = FIELD_DP32(u, ID_ISAR6, JSCVT, 1);
          u = FIELD_DP32(u, ID_ISAR6, DP, 1);
          cpu->isar.id_isar6 = u;
 diff --git a/target/arm/translate-a64.c b/target/arm/translate-a64.c
 index XXXXXXX..XXXXXXX 100644
 --- a/target/arm/translate-a64.c
 +++ b/target/arm/translate-a64.c
@@ -XXX,XX +XXX,XX @@ static void handle_fmov(DisasContext *s, int rd, int rn, int type, bool itof)
      }
- }
-+static void handle_fjcvtzs(DisasContext *s, int rd, int rn)
-+{
-+    TCGv_i64 t = read_fp_dreg(s, rn);
-+    TCGv_ptr fpstatus = get_fpstatus_ptr(false);
 +
-+    gen_helper_fjcvtzs(t, t, fpstatus);
++    /*
-+
++     * There exist AArch64 cpus without AArch32 support.  When KVM
-+    tcg_temp_free_ptr(fpstatus);
++     * queries ID_ISAR0_EL1 on such a host, the value is UNKNOWN.
-+
++     * Similarly, we cannot check ID_AA64PFR0 without AArch64 support.
-+    tcg_gen_ext32u_i64(cpu_reg(s, rd), t);
++     */
-+    tcg_gen_extrh_i64_i32(cpu_ZF, t);
++    if (arm_feature(&cpu->env, ARM_FEATURE_AARCH64)) {
-+    tcg_gen_movi_i32(cpu_CF, 0);
++        no_aa32 = !cpu_isar_feature(aa64_aa32, cpu);
 +    tcg_gen_movi_i32(cpu_NF, 0);
 +    tcg_gen_movi_i32(cpu_VF, 0);
 +
 +    tcg_temp_free_i64(t);
 +}
 +
  /* Floating point <-> integer conversions
   *   31   30  29 28       24 23  22  21 20   19 18 16 15         10 9  5 4  0
   * +----+---+---+-----------+------+---+-------+-----+-------------+----+----+
@@ -XXX,XX +XXX,XX @@ static void disas_fp_int_conv(DisasContext *s, uint32_t insn)
              handle_fmov(s, rd, rn, type, itof);
              break;
 +        case 0b00111110: /* FJCVTZS */
 +            if (!dc_isar_feature(aa64_jscvt, s)) {
 +                goto do_unallocated;
 +            } else if (fp_access_check(s)) {
 +                handle_fjcvtzs(s, rd, rn);
 +            }
 +            break;
 +
          default:
          do_unallocated:
              unallocated_encoding(s);
 diff --git a/target/arm/translate.c b/target/arm/translate.c
 index XXXXXXX..XXXXXXX 100644
 --- a/target/arm/translate.c
 +++ b/target/arm/translate.c
@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
                      rm_is_dp = false;
                      break;
 +                case 0x13: /* vjcvt */
 +                    if (!dp || !dc_isar_feature(aa32_jscvt, s)) {
 +                        return 1;
 +                    }
 +                    rd_is_dp = false;
 +                    break;
 +
                  default:
                      return 1;
                  }
@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
                      case 17: /* fsito */
                          gen_vfp_sito(dp, 0);
                          break;
 +                    case 19: /* vjcvt */
 +                        gen_helper_vjcvt(cpu_F0s, cpu_F0d, cpu_env);
 +                        break;
                      case 20: /* fshto */
                          gen_vfp_shto(dp, 16 - rm, 0);
                          break;
 diff --git a/target/arm/vfp_helper.c b/target/arm/vfp_helper.c
 index XXXXXXX..XXXXXXX 100644
 --- a/target/arm/vfp_helper.c
 +++ b/target/arm/vfp_helper.c
@@ -XXX,XX +XXX,XX @@ int arm_rmode_to_sf(int rmode)
      }
      return rmode;
  }
 +
 +/*
 + * Implement float64 to int32_t conversion without saturation;
 + * the result is supplied modulo 2^32.
 + */
 +uint64_t HELPER(fjcvtzs)(float64 value, void *vstatus)
 +{
 +    float_status *status = vstatus;
 +    uint32_t exp, sign;
 +    uint64_t frac;
 +    uint32_t inexact = 1; /* !Z */
 +
 +    sign = extract64(value, 63, 1);
 +    exp = extract64(value, 52, 11);
 +    frac = extract64(value, 0, 52);
 +
 +    if (exp == 0) {
 +        /* While not inexact for IEEE FP, -0.0 is inexact for JavaScript.  */
 +        inexact = sign;
 +        if (frac != 0) {
 +            if (status->flush_inputs_to_zero) {
 +                float_raise(float_flag_input_denormal, status);
 +            } else {
 +                float_raise(float_flag_inexact, status);
 +                inexact = 1;
 +            }
 +        }
 +        frac = 0;
 +    } else if (exp == 0x7ff) {
 +        /* This operation raises Invalid for both NaN and overflow (Inf).  */
 +        float_raise(float_flag_invalid, status);
 +        frac = 0;
 +    } else {
 +        int true_exp = exp - 1023;
 +        int shift = true_exp - 52;
 +
 +        /* Restore implicit bit.  */
 +        frac |= 1ull << 52;
 +
 +        /* Shift the fraction into place.  */
 +        if (shift >= 0) {
 +            /* The number is so large we must shift the fraction left.  */
 +            if (shift >= 64) {
 +                /* The fraction is shifted out entirely.  */
 +                frac = 0;
 +            } else {
 +                frac <<= shift;
 +            }
 +        } else if (shift > -64) {
 +            /* Normal case -- shift right and notice if bits shift out.  */
 +            inexact = (frac << (64 + shift)) != 0;
 +            frac >>= -shift;
 +        } else {
 +            /* The fraction is shifted out entirely.  */
 +            frac = 0;
 +        }
 +
 +        /* Notice overflow or inexact exceptions.  */
 +        if (true_exp > 31 || frac > (sign ? 0x80000000ull : 0x7fffffff)) {
 +            /* Overflow, for which this operation raises invalid.  */
 +            float_raise(float_flag_invalid, status);
 +            inexact = 1;
 +        } else if (inexact) {
 +            float_raise(float_flag_inexact, status);
 +        }
 +
 +        /* Honor the sign.  */
 +        if (sign) {
 +            frac = -frac;
 +        }
 +    }
 +
-+    /* Pack the result and the env->ZF representation of Z together.  */
+     if (arm_feature(env, ARM_FEATURE_V7VE)) {
-+    return deposit64(frac, 32, 32, inexact);
+         /* v7 Virtualization Extensions. In real hardware this implies
-+}
+          * EL2 and also the presence of the Security Extensions.
-+
+@@ -XXX,XX +XXX,XX @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp)
-+uint32_t HELPER(vjcvt)(float64 value, CPUARMState *env)
+          * Presence of EL2 itself is ARM_FEATURE_EL2, and of the
-+{
+          * Security Extensions is ARM_FEATURE_EL3.
-+    uint64_t pair = HELPER(fjcvtzs)(value, &env->vfp.fp_status);
+          */
-+    uint32_t result = pair;
+-        assert(cpu_isar_feature(arm_div, cpu));
-+    uint32_t z = (pair >> 32) == 0;
++        assert(no_aa32 || cpu_isar_feature(arm_div, cpu));
-+
+         set_feature(env, ARM_FEATURE_LPAE);
-+    /* Store Z, clear NCV, in FPSCR.NZCV.  */
+         set_feature(env, ARM_FEATURE_V7);
-+    env->vfp.xregs[ARM_VFP_FPSCR]
+     }
-+        = (env->vfp.xregs[ARM_VFP_FPSCR] & ~CPSR_NZCV) | (z * CPSR_Z);
+@@ -XXX,XX +XXX,XX @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp)
-+
+     if (arm_feature(env, ARM_FEATURE_V6)) {
-+    return result;
+         set_feature(env, ARM_FEATURE_V5);
-+}
+         if (!arm_feature(env, ARM_FEATURE_M)) {
 -            assert(cpu_isar_feature(jazelle, cpu));
 +            assert(no_aa32 || cpu_isar_feature(jazelle, cpu));
              set_feature(env, ARM_FEATURE_AUXCR);
          }
      }
 --
-.20.1
+.19.1

-[Qemu-devel] [PULL 05/21] target/arm: Split out vfp_helper.c
+[Qemu-devel] [PULL 09/10] hw/arm: versal: Add a model of Xilinx Versal SoC
-From: Richard Henderson <richard.henderson@linaro.org>
+From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com>
-Move all of the fp helpers out of helper.c into a new file.
+Add a model of Xilinx Versal SoC.
 This is code movement only.  Since helper.c has no copyright
 header, take the one from cpu.h for the new file.
-Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
+Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com>
-Message-id: 20190215192302.27855-3-richard.henderson@linaro.org
+Message-id: 20181102131913.1535-2-edgar.iglesias@xilinx.com
 Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
 ---
- target/arm/Makefile.objs |    2 +-
+ hw/arm/Makefile.objs                |   1 +
- target/arm/helper.c      | 1062 -------------------------------------
+ include/hw/arm/xlnx-versal.h        | 122 +++++++++++
- target/arm/vfp_helper.c  | 1088 ++++++++++++++++++++++++++++++++++++++
+ hw/arm/xlnx-versal.c                | 323 ++++++++++++++++++++++++++++
-files changed, 1089 insertions(+), 1063 deletions(-)
+ default-configs/aarch64-softmmu.mak |   1 +
- create mode 100644 target/arm/vfp_helper.c
+files changed, 447 insertions(+)
  create mode 100644 include/hw/arm/xlnx-versal.h
  create mode 100644 hw/arm/xlnx-versal.c
-diff --git a/target/arm/Makefile.objs b/target/arm/Makefile.objs
+diff --git a/hw/arm/Makefile.objs b/hw/arm/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
---- a/target/arm/Makefile.objs
+--- a/hw/arm/Makefile.objs
-+++ b/target/arm/Makefile.objs
++++ b/hw/arm/Makefile.objs
-@@ -XXX,XX +XXX,XX @@ obj-$(call land,$(CONFIG_KVM),$(call lnot,$(TARGET_AARCH64))) += kvm32.o
+@@ -XXX,XX +XXX,XX @@ obj-$(CONFIG_ALLWINNER_A10) += allwinner-a10.o cubieboard.o
- obj-$(call land,$(CONFIG_KVM),$(TARGET_AARCH64)) += kvm64.o
+ obj-$(CONFIG_RASPI) += bcm2835_peripherals.o bcm2836.o raspi.o
- obj-$(call lnot,$(CONFIG_KVM)) += kvm-stub.o
+ obj-$(CONFIG_STM32F205_SOC) += stm32f205_soc.o
- obj-y += translate.o op_helper.o helper.o cpu.o
+ obj-$(CONFIG_XLNX_ZYNQMP_ARM) += xlnx-zynqmp.o xlnx-zcu102.o
--obj-y += neon_helper.o iwmmxt_helper.o vec_helper.o
++obj-$(CONFIG_XLNX_VERSAL) += xlnx-versal.o
-+obj-y += neon_helper.o iwmmxt_helper.o vec_helper.o vfp_helper.o
+ obj-$(CONFIG_FSL_IMX25) += fsl-imx25.o imx25_pdk.o
- obj-y += gdbstub.o
+ obj-$(CONFIG_FSL_IMX31) += fsl-imx31.o kzm.o
- obj-$(TARGET_AARCH64) += cpu64.o translate-a64.o helper-a64.o gdbstub64.o
+ obj-$(CONFIG_FSL_IMX6) += fsl-imx6.o sabrelite.o
- obj-$(TARGET_AARCH64) += pauth_helper.o
+diff --git a/include/hw/arm/xlnx-versal.h b/include/hw/arm/xlnx-versal.h
 diff --git a/target/arm/helper.c b/target/arm/helper.c
 index XXXXXXX..XXXXXXX 100644
 --- a/target/arm/helper.c
 +++ b/target/arm/helper.c
@@ -XXX,XX +XXX,XX @@ uint32_t HELPER(sel_flags)(uint32_t flags, uint32_t a, uint32_t b)
      return (a & mask) | (b & ~mask);
  }
 -/* VFP support.  We follow the convention used for VFP instructions:
 -   Single precision routines have a "s" suffix, double precision a
 -   "d" suffix.  */
 -
 -/* Convert host exception flags to vfp form.  */
 -static inline int vfp_exceptbits_from_host(int host_bits)
 -{
 -    int target_bits = 0;
 -
 -    if (host_bits & float_flag_invalid)
 -        target_bits |= 1;
 -    if (host_bits & float_flag_divbyzero)
 -        target_bits |= 2;
 -    if (host_bits & float_flag_overflow)
 -        target_bits |= 4;
 -    if (host_bits & (float_flag_underflow | float_flag_output_denormal))
 -        target_bits |= 8;
 -    if (host_bits & float_flag_inexact)
 -        target_bits |= 0x10;
 -    if (host_bits & float_flag_input_denormal)
 -        target_bits |= 0x80;
 -    return target_bits;
 -}
 -
 -uint32_t HELPER(vfp_get_fpscr)(CPUARMState *env)
 -{
 -    uint32_t i, fpscr;
 -
 -    fpscr = env->vfp.xregs[ARM_VFP_FPSCR]
 -            | (env->vfp.vec_len << 16)
 -            | (env->vfp.vec_stride << 20);
 -
 -    i = get_float_exception_flags(&env->vfp.fp_status);
 -    i |= get_float_exception_flags(&env->vfp.standard_fp_status);
 -    /* FZ16 does not generate an input denormal exception.  */
 -    i |= (get_float_exception_flags(&env->vfp.fp_status_f16)
 -          & ~float_flag_input_denormal);
 -    fpscr |= vfp_exceptbits_from_host(i);
 -
 -    i = env->vfp.qc[0] | env->vfp.qc[1] | env->vfp.qc[2] | env->vfp.qc[3];
 -    fpscr |= i ? FPCR_QC : 0;
 -
 -    return fpscr;
 -}
 -
 -uint32_t vfp_get_fpscr(CPUARMState *env)
 -{
 -    return HELPER(vfp_get_fpscr)(env);
 -}
 -
 -/* Convert vfp exception flags to target form.  */
 -static inline int vfp_exceptbits_to_host(int target_bits)
 -{
 -    int host_bits = 0;
 -
 -    if (target_bits & 1)
 -        host_bits |= float_flag_invalid;
 -    if (target_bits & 2)
 -        host_bits |= float_flag_divbyzero;
 -    if (target_bits & 4)
 -        host_bits |= float_flag_overflow;
 -    if (target_bits & 8)
 -        host_bits |= float_flag_underflow;
 -    if (target_bits & 0x10)
 -        host_bits |= float_flag_inexact;
 -    if (target_bits & 0x80)
 -        host_bits |= float_flag_input_denormal;
 -    return host_bits;
 -}
 -
 -void HELPER(vfp_set_fpscr)(CPUARMState *env, uint32_t val)
 -{
 -    int i;
 -    uint32_t changed = env->vfp.xregs[ARM_VFP_FPSCR];
 -
 -    /* When ARMv8.2-FP16 is not supported, FZ16 is RES0.  */
 -    if (!cpu_isar_feature(aa64_fp16, arm_env_get_cpu(env))) {
 -        val &= ~FPCR_FZ16;
 -    }
 -
 -    /*
 -     * We don't implement trapped exception handling, so the
 -     * trap enable bits, IDE|IXE|UFE|OFE|DZE|IOE are all RAZ/WI (not RES0!)
 -     *
 -     * If we exclude the exception flags, IOC|DZC|OFC|UFC|IXC|IDC
 -     * (which are stored in fp_status), and the other RES0 bits
 -     * in between, then we clear all of the low 16 bits.
 -     */
 -    env->vfp.xregs[ARM_VFP_FPSCR] = val & 0xf7c80000;
 -    env->vfp.vec_len = (val >> 16) & 7;
 -    env->vfp.vec_stride = (val >> 20) & 3;
 -
 -    /*
 -     * The bit we set within fpscr_q is arbitrary; the register as a
 -     * whole being zero/non-zero is what counts.
 -     */
 -    env->vfp.qc[0] = val & FPCR_QC;
 -    env->vfp.qc[1] = 0;
 -    env->vfp.qc[2] = 0;
 -    env->vfp.qc[3] = 0;
 -
 -    changed ^= val;
 -    if (changed & (3 << 22)) {
 -        i = (val >> 22) & 3;
 -        switch (i) {
 -        case FPROUNDING_TIEEVEN:
 -            i = float_round_nearest_even;
 -            break;
 -        case FPROUNDING_POSINF:
 -            i = float_round_up;
 -            break;
 -        case FPROUNDING_NEGINF:
 -            i = float_round_down;
 -            break;
 -        case FPROUNDING_ZERO:
 -            i = float_round_to_zero;
 -            break;
 -        }
 -        set_float_rounding_mode(i, &env->vfp.fp_status);
 -        set_float_rounding_mode(i, &env->vfp.fp_status_f16);
 -    }
 -    if (changed & FPCR_FZ16) {
 -        bool ftz_enabled = val & FPCR_FZ16;
 -        set_flush_to_zero(ftz_enabled, &env->vfp.fp_status_f16);
 -        set_flush_inputs_to_zero(ftz_enabled, &env->vfp.fp_status_f16);
 -    }
 -    if (changed & FPCR_FZ) {
 -        bool ftz_enabled = val & FPCR_FZ;
 -        set_flush_to_zero(ftz_enabled, &env->vfp.fp_status);
 -        set_flush_inputs_to_zero(ftz_enabled, &env->vfp.fp_status);
 -    }
 -    if (changed & FPCR_DN) {
 -        bool dnan_enabled = val & FPCR_DN;
 -        set_default_nan_mode(dnan_enabled, &env->vfp.fp_status);
 -        set_default_nan_mode(dnan_enabled, &env->vfp.fp_status_f16);
 -    }
 -
 -    /* The exception flags are ORed together when we read fpscr so we
 -     * only need to preserve the current state in one of our
 -     * float_status values.
 -     */
 -    i = vfp_exceptbits_to_host(val);
 -    set_float_exception_flags(i, &env->vfp.fp_status);
 -    set_float_exception_flags(0, &env->vfp.fp_status_f16);
 -    set_float_exception_flags(0, &env->vfp.standard_fp_status);
 -}
 -
 -void vfp_set_fpscr(CPUARMState *env, uint32_t val)
 -{
 -    HELPER(vfp_set_fpscr)(env, val);
 -}
 -
 -#define VFP_HELPER(name, p) HELPER(glue(glue(vfp_,name),p))
 -
 -#define VFP_BINOP(name) \
 -float32 VFP_HELPER(name, s)(float32 a, float32 b, void *fpstp) \
 -{ \
 -    float_status *fpst = fpstp; \
 -    return float32_ ## name(a, b, fpst); \
 -} \
 -float64 VFP_HELPER(name, d)(float64 a, float64 b, void *fpstp) \
 -{ \
 -    float_status *fpst = fpstp; \
 -    return float64_ ## name(a, b, fpst); \
 -}
 -VFP_BINOP(add)
 -VFP_BINOP(sub)
 -VFP_BINOP(mul)
 -VFP_BINOP(div)
 -VFP_BINOP(min)
 -VFP_BINOP(max)
 -VFP_BINOP(minnum)
 -VFP_BINOP(maxnum)
 -#undef VFP_BINOP
 -
 -float32 VFP_HELPER(neg, s)(float32 a)
 -{
 -    return float32_chs(a);
 -}
 -
 -float64 VFP_HELPER(neg, d)(float64 a)
 -{
 -    return float64_chs(a);
 -}
 -
 -float32 VFP_HELPER(abs, s)(float32 a)
 -{
 -    return float32_abs(a);
 -}
 -
 -float64 VFP_HELPER(abs, d)(float64 a)
 -{
 -    return float64_abs(a);
 -}
 -
 -float32 VFP_HELPER(sqrt, s)(float32 a, CPUARMState *env)
 -{
 -    return float32_sqrt(a, &env->vfp.fp_status);
 -}
 -
 -float64 VFP_HELPER(sqrt, d)(float64 a, CPUARMState *env)
 -{
 -    return float64_sqrt(a, &env->vfp.fp_status);
 -}
 -
 -static void softfloat_to_vfp_compare(CPUARMState *env, int cmp)
 -{
 -    uint32_t flags;
 -    switch (cmp) {
 -    case float_relation_equal:
 -        flags = 0x6;
 -        break;
 -    case float_relation_less:
 -        flags = 0x8;
 -        break;
 -    case float_relation_greater:
 -        flags = 0x2;
 -        break;
 -    case float_relation_unordered:
 -        flags = 0x3;
 -        break;
 -    default:
 -        g_assert_not_reached();
 -    }
 -    env->vfp.xregs[ARM_VFP_FPSCR] =
 -        deposit32(env->vfp.xregs[ARM_VFP_FPSCR], 28, 4, flags);
 -}
 -
 -/* XXX: check quiet/signaling case */
 -#define DO_VFP_cmp(p, type) \
 -void VFP_HELPER(cmp, p)(type a, type b, CPUARMState *env)  \
 -{ \
 -    softfloat_to_vfp_compare(env, \
 -        type ## _compare_quiet(a, b, &env->vfp.fp_status)); \
 -} \
 -void VFP_HELPER(cmpe, p)(type a, type b, CPUARMState *env) \
 -{ \
 -    softfloat_to_vfp_compare(env, \
 -        type ## _compare(a, b, &env->vfp.fp_status)); \
 -}
 -DO_VFP_cmp(s, float32)
 -DO_VFP_cmp(d, float64)
 -#undef DO_VFP_cmp
 -
 -/* Integer to float and float to integer conversions */
 -
 -#define CONV_ITOF(name, ftype, fsz, sign)                           \
 -ftype HELPER(name)(uint32_t x, void *fpstp)                         \
 -{                                                                   \
 -    float_status *fpst = fpstp;                                     \
 -    return sign##int32_to_##float##fsz((sign##int32_t)x, fpst);     \
 -}
 -
 -#define CONV_FTOI(name, ftype, fsz, sign, round)                \
 -sign##int32_t HELPER(name)(ftype x, void *fpstp)                \
 -{                                                               \
 -    float_status *fpst = fpstp;                                 \
 -    if (float##fsz##_is_any_nan(x)) {                           \
 -        float_raise(float_flag_invalid, fpst);                  \
 -        return 0;                                               \
 -    }                                                           \
 -    return float##fsz##_to_##sign##int32##round(x, fpst);       \
 -}
 -
 -#define FLOAT_CONVS(name, p, ftype, fsz, sign)            \
 -    CONV_ITOF(vfp_##name##to##p, ftype, fsz, sign)        \
 -    CONV_FTOI(vfp_to##name##p, ftype, fsz, sign, )        \
 -    CONV_FTOI(vfp_to##name##z##p, ftype, fsz, sign, _round_to_zero)
 -
 -FLOAT_CONVS(si, h, uint32_t, 16, )
 -FLOAT_CONVS(si, s, float32, 32, )
 -FLOAT_CONVS(si, d, float64, 64, )
 -FLOAT_CONVS(ui, h, uint32_t, 16, u)
 -FLOAT_CONVS(ui, s, float32, 32, u)
 -FLOAT_CONVS(ui, d, float64, 64, u)
 -
 -#undef CONV_ITOF
 -#undef CONV_FTOI
 -#undef FLOAT_CONVS
 -
 -/* floating point conversion */
 -float64 VFP_HELPER(fcvtd, s)(float32 x, CPUARMState *env)
 -{
 -    return float32_to_float64(x, &env->vfp.fp_status);
 -}
 -
 -float32 VFP_HELPER(fcvts, d)(float64 x, CPUARMState *env)
 -{
 -    return float64_to_float32(x, &env->vfp.fp_status);
 -}
 -
 -/* VFP3 fixed point conversion.  */
 -#define VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype) \
 -float##fsz HELPER(vfp_##name##to##p)(uint##isz##_t  x, uint32_t shift, \
 -                                     void *fpstp) \
 -{ return itype##_to_##float##fsz##_scalbn(x, -shift, fpstp); }
 -
 -#define VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype, ROUND, suff)   \
 -uint##isz##_t HELPER(vfp_to##name##p##suff)(float##fsz x, uint32_t shift, \
 -                                            void *fpst)                   \
 -{                                                                         \
 -    if (unlikely(float##fsz##_is_any_nan(x))) {                           \
 -        float_raise(float_flag_invalid, fpst);                            \
 -        return 0;                                                         \
 -    }                                                                     \
 -    return float##fsz##_to_##itype##_scalbn(x, ROUND, shift, fpst);       \
 -}
 -
 -#define VFP_CONV_FIX(name, p, fsz, isz, itype)                   \
 -VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype)                     \
 -VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
 -                         float_round_to_zero, _round_to_zero)    \
 -VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
 -                         get_float_rounding_mode(fpst), )
 -
 -#define VFP_CONV_FIX_A64(name, p, fsz, isz, itype)               \
 -VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype)                     \
 -VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
 -                         get_float_rounding_mode(fpst), )
 -
 -VFP_CONV_FIX(sh, d, 64, 64, int16)
 -VFP_CONV_FIX(sl, d, 64, 64, int32)
 -VFP_CONV_FIX_A64(sq, d, 64, 64, int64)
 -VFP_CONV_FIX(uh, d, 64, 64, uint16)
 -VFP_CONV_FIX(ul, d, 64, 64, uint32)
 -VFP_CONV_FIX_A64(uq, d, 64, 64, uint64)
 -VFP_CONV_FIX(sh, s, 32, 32, int16)
 -VFP_CONV_FIX(sl, s, 32, 32, int32)
 -VFP_CONV_FIX_A64(sq, s, 32, 64, int64)
 -VFP_CONV_FIX(uh, s, 32, 32, uint16)
 -VFP_CONV_FIX(ul, s, 32, 32, uint32)
 -VFP_CONV_FIX_A64(uq, s, 32, 64, uint64)
 -
 -#undef VFP_CONV_FIX
 -#undef VFP_CONV_FIX_FLOAT
 -#undef VFP_CONV_FLOAT_FIX_ROUND
 -#undef VFP_CONV_FIX_A64
 -
 -uint32_t HELPER(vfp_sltoh)(uint32_t x, uint32_t shift, void *fpst)
 -{
 -    return int32_to_float16_scalbn(x, -shift, fpst);
 -}
 -
 -uint32_t HELPER(vfp_ultoh)(uint32_t x, uint32_t shift, void *fpst)
 -{
 -    return uint32_to_float16_scalbn(x, -shift, fpst);
 -}
 -
 -uint32_t HELPER(vfp_sqtoh)(uint64_t x, uint32_t shift, void *fpst)
 -{
 -    return int64_to_float16_scalbn(x, -shift, fpst);
 -}
 -
 -uint32_t HELPER(vfp_uqtoh)(uint64_t x, uint32_t shift, void *fpst)
 -{
 -    return uint64_to_float16_scalbn(x, -shift, fpst);
 -}
 -
 -uint32_t HELPER(vfp_toshh)(uint32_t x, uint32_t shift, void *fpst)
 -{
 -    if (unlikely(float16_is_any_nan(x))) {
 -        float_raise(float_flag_invalid, fpst);
 -        return 0;
 -    }
 -    return float16_to_int16_scalbn(x, get_float_rounding_mode(fpst),
 -                                   shift, fpst);
 -}
 -
 -uint32_t HELPER(vfp_touhh)(uint32_t x, uint32_t shift, void *fpst)
 -{
 -    if (unlikely(float16_is_any_nan(x))) {
 -        float_raise(float_flag_invalid, fpst);
 -        return 0;
 -    }
 -    return float16_to_uint16_scalbn(x, get_float_rounding_mode(fpst),
 -                                    shift, fpst);
 -}
 -
 -uint32_t HELPER(vfp_toslh)(uint32_t x, uint32_t shift, void *fpst)
 -{
 -    if (unlikely(float16_is_any_nan(x))) {
 -        float_raise(float_flag_invalid, fpst);
 -        return 0;
 -    }
 -    return float16_to_int32_scalbn(x, get_float_rounding_mode(fpst),
 -                                   shift, fpst);
 -}
 -
 -uint32_t HELPER(vfp_toulh)(uint32_t x, uint32_t shift, void *fpst)
 -{
 -    if (unlikely(float16_is_any_nan(x))) {
 -        float_raise(float_flag_invalid, fpst);
 -        return 0;
 -    }
 -    return float16_to_uint32_scalbn(x, get_float_rounding_mode(fpst),
 -                                    shift, fpst);
 -}
 -
 -uint64_t HELPER(vfp_tosqh)(uint32_t x, uint32_t shift, void *fpst)
 -{
 -    if (unlikely(float16_is_any_nan(x))) {
 -        float_raise(float_flag_invalid, fpst);
 -        return 0;
 -    }
 -    return float16_to_int64_scalbn(x, get_float_rounding_mode(fpst),
 -                                   shift, fpst);
 -}
 -
 -uint64_t HELPER(vfp_touqh)(uint32_t x, uint32_t shift, void *fpst)
 -{
 -    if (unlikely(float16_is_any_nan(x))) {
 -        float_raise(float_flag_invalid, fpst);
 -        return 0;
 -    }
 -    return float16_to_uint64_scalbn(x, get_float_rounding_mode(fpst),
 -                                    shift, fpst);
 -}
 -
 -/* Set the current fp rounding mode and return the old one.
 - * The argument is a softfloat float_round_ value.
 - */
 -uint32_t HELPER(set_rmode)(uint32_t rmode, void *fpstp)
 -{
 -    float_status *fp_status = fpstp;
 -
 -    uint32_t prev_rmode = get_float_rounding_mode(fp_status);
 -    set_float_rounding_mode(rmode, fp_status);
 -
 -    return prev_rmode;
 -}
 -
 -/* Set the current fp rounding mode in the standard fp status and return
 - * the old one. This is for NEON instructions that need to change the
 - * rounding mode but wish to use the standard FPSCR values for everything
 - * else. Always set the rounding mode back to the correct value after
 - * modifying it.
 - * The argument is a softfloat float_round_ value.
 - */
 -uint32_t HELPER(set_neon_rmode)(uint32_t rmode, CPUARMState *env)
 -{
 -    float_status *fp_status = &env->vfp.standard_fp_status;
 -
 -    uint32_t prev_rmode = get_float_rounding_mode(fp_status);
 -    set_float_rounding_mode(rmode, fp_status);
 -
 -    return prev_rmode;
 -}
 -
 -/* Half precision conversions.  */
 -float32 HELPER(vfp_fcvt_f16_to_f32)(uint32_t a, void *fpstp, uint32_t ahp_mode)
 -{
 -    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
 -     * it would affect flushing input denormals.
 -     */
 -    float_status *fpst = fpstp;
 -    flag save = get_flush_inputs_to_zero(fpst);
 -    set_flush_inputs_to_zero(false, fpst);
 -    float32 r = float16_to_float32(a, !ahp_mode, fpst);
 -    set_flush_inputs_to_zero(save, fpst);
 -    return r;
 -}
 -
 -uint32_t HELPER(vfp_fcvt_f32_to_f16)(float32 a, void *fpstp, uint32_t ahp_mode)
 -{
 -    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
 -     * it would affect flushing output denormals.
 -     */
 -    float_status *fpst = fpstp;
 -    flag save = get_flush_to_zero(fpst);
 -    set_flush_to_zero(false, fpst);
 -    float16 r = float32_to_float16(a, !ahp_mode, fpst);
 -    set_flush_to_zero(save, fpst);
 -    return r;
 -}
 -
 -float64 HELPER(vfp_fcvt_f16_to_f64)(uint32_t a, void *fpstp, uint32_t ahp_mode)
 -{
 -    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
 -     * it would affect flushing input denormals.
 -     */
 -    float_status *fpst = fpstp;
 -    flag save = get_flush_inputs_to_zero(fpst);
 -    set_flush_inputs_to_zero(false, fpst);
 -    float64 r = float16_to_float64(a, !ahp_mode, fpst);
 -    set_flush_inputs_to_zero(save, fpst);
 -    return r;
 -}
 -
 -uint32_t HELPER(vfp_fcvt_f64_to_f16)(float64 a, void *fpstp, uint32_t ahp_mode)
 -{
 -    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
 -     * it would affect flushing output denormals.
 -     */
 -    float_status *fpst = fpstp;
 -    flag save = get_flush_to_zero(fpst);
 -    set_flush_to_zero(false, fpst);
 -    float16 r = float64_to_float16(a, !ahp_mode, fpst);
 -    set_flush_to_zero(save, fpst);
 -    return r;
 -}
 -
 -#define float32_two make_float32(0x40000000)
 -#define float32_three make_float32(0x40400000)
 -#define float32_one_point_five make_float32(0x3fc00000)
 -
 -float32 HELPER(recps_f32)(float32 a, float32 b, CPUARMState *env)
 -{
 -    float_status *s = &env->vfp.standard_fp_status;
 -    if ((float32_is_infinity(a) && float32_is_zero_or_denormal(b)) ||
 -        (float32_is_infinity(b) && float32_is_zero_or_denormal(a))) {
 -        if (!(float32_is_zero(a) || float32_is_zero(b))) {
 -            float_raise(float_flag_input_denormal, s);
 -        }
 -        return float32_two;
 -    }
 -    return float32_sub(float32_two, float32_mul(a, b, s), s);
 -}
 -
 -float32 HELPER(rsqrts_f32)(float32 a, float32 b, CPUARMState *env)
 -{
 -    float_status *s = &env->vfp.standard_fp_status;
 -    float32 product;
 -    if ((float32_is_infinity(a) && float32_is_zero_or_denormal(b)) ||
 -        (float32_is_infinity(b) && float32_is_zero_or_denormal(a))) {
 -        if (!(float32_is_zero(a) || float32_is_zero(b))) {
 -            float_raise(float_flag_input_denormal, s);
 -        }
 -        return float32_one_point_five;
 -    }
 -    product = float32_mul(a, b, s);
 -    return float32_div(float32_sub(float32_three, product, s), float32_two, s);
 -}
 -
 -/* NEON helpers.  */
 -
 -/* Constants 256 and 512 are used in some helpers; we avoid relying on
 - * int->float conversions at run-time.  */
 -#define float64_256 make_float64(0x4070000000000000LL)
 -#define float64_512 make_float64(0x4080000000000000LL)
 -#define float16_maxnorm make_float16(0x7bff)
 -#define float32_maxnorm make_float32(0x7f7fffff)
 -#define float64_maxnorm make_float64(0x7fefffffffffffffLL)
 -
 -/* Reciprocal functions
 - *
 - * The algorithm that must be used to calculate the estimate
 - * is specified by the ARM ARM, see FPRecipEstimate()/RecipEstimate
 - */
 -
 -/* See RecipEstimate()
 - *
 - * input is a 9 bit fixed point number
 - * input range 256 .. 511 for a number from 0.5 <= x < 1.0.
 - * result range 256 .. 511 for a number from 1.0 to 511/256.
 - */
 -
 -static int recip_estimate(int input)
 -{
 -    int a, b, r;
 -    assert(256 <= input && input < 512);
 -    a = (input * 2) + 1;
 -    b = (1 << 19) / a;
 -    r = (b + 1) >> 1;
 -    assert(256 <= r && r < 512);
 -    return r;
 -}
 -
 -/*
 - * Common wrapper to call recip_estimate
 - *
 - * The parameters are exponent and 64 bit fraction (without implicit
 - * bit) where the binary point is nominally at bit 52. Returns a
 - * float64 which can then be rounded to the appropriate size by the
 - * callee.
 - */
 -
 -static uint64_t call_recip_estimate(int *exp, int exp_off, uint64_t frac)
 -{
 -    uint32_t scaled, estimate;
 -    uint64_t result_frac;
 -    int result_exp;
 -
 -    /* Handle sub-normals */
 -    if (*exp == 0) {
 -        if (extract64(frac, 51, 1) == 0) {
 -            *exp = -1;
 -            frac <<= 2;
 -        } else {
 -            frac <<= 1;
 -        }
 -    }
 -
 -    /* scaled = UInt('1':fraction<51:44>) */
 -    scaled = deposit32(1 << 8, 0, 8, extract64(frac, 44, 8));
 -    estimate = recip_estimate(scaled);
 -
 -    result_exp = exp_off - *exp;
 -    result_frac = deposit64(0, 44, 8, estimate);
 -    if (result_exp == 0) {
 -        result_frac = deposit64(result_frac >> 1, 51, 1, 1);
 -    } else if (result_exp == -1) {
 -        result_frac = deposit64(result_frac >> 2, 50, 2, 1);
 -        result_exp = 0;
 -    }
 -
 -    *exp = result_exp;
 -
 -    return result_frac;
 -}
 -
 -static bool round_to_inf(float_status *fpst, bool sign_bit)
 -{
 -    switch (fpst->float_rounding_mode) {
 -    case float_round_nearest_even: /* Round to Nearest */
 -        return true;
 -    case float_round_up: /* Round to +Inf */
 -        return !sign_bit;
 -    case float_round_down: /* Round to -Inf */
 -        return sign_bit;
 -    case float_round_to_zero: /* Round to Zero */
 -        return false;
 -    }
 -
 -    g_assert_not_reached();
 -}
 -
 -uint32_t HELPER(recpe_f16)(uint32_t input, void *fpstp)
 -{
 -    float_status *fpst = fpstp;
 -    float16 f16 = float16_squash_input_denormal(input, fpst);
 -    uint32_t f16_val = float16_val(f16);
 -    uint32_t f16_sign = float16_is_neg(f16);
 -    int f16_exp = extract32(f16_val, 10, 5);
 -    uint32_t f16_frac = extract32(f16_val, 0, 10);
 -    uint64_t f64_frac;
 -
 -    if (float16_is_any_nan(f16)) {
 -        float16 nan = f16;
 -        if (float16_is_signaling_nan(f16, fpst)) {
 -            float_raise(float_flag_invalid, fpst);
 -            nan = float16_silence_nan(f16, fpst);
 -        }
 -        if (fpst->default_nan_mode) {
 -            nan =  float16_default_nan(fpst);
 -        }
 -        return nan;
 -    } else if (float16_is_infinity(f16)) {
 -        return float16_set_sign(float16_zero, float16_is_neg(f16));
 -    } else if (float16_is_zero(f16)) {
 -        float_raise(float_flag_divbyzero, fpst);
 -        return float16_set_sign(float16_infinity, float16_is_neg(f16));
 -    } else if (float16_abs(f16) < (1 << 8)) {
 -        /* Abs(value) < 2.0^-16 */
 -        float_raise(float_flag_overflow | float_flag_inexact, fpst);
 -        if (round_to_inf(fpst, f16_sign)) {
 -            return float16_set_sign(float16_infinity, f16_sign);
 -        } else {
 -            return float16_set_sign(float16_maxnorm, f16_sign);
 -        }
 -    } else if (f16_exp >= 29 && fpst->flush_to_zero) {
 -        float_raise(float_flag_underflow, fpst);
 -        return float16_set_sign(float16_zero, float16_is_neg(f16));
 -    }
 -
 -    f64_frac = call_recip_estimate(&f16_exp, 29,
 -                                   ((uint64_t) f16_frac) << (52 - 10));
 -
 -    /* result = sign : result_exp<4:0> : fraction<51:42> */
 -    f16_val = deposit32(0, 15, 1, f16_sign);
 -    f16_val = deposit32(f16_val, 10, 5, f16_exp);
 -    f16_val = deposit32(f16_val, 0, 10, extract64(f64_frac, 52 - 10, 10));
 -    return make_float16(f16_val);
 -}
 -
 -float32 HELPER(recpe_f32)(float32 input, void *fpstp)
 -{
 -    float_status *fpst = fpstp;
 -    float32 f32 = float32_squash_input_denormal(input, fpst);
 -    uint32_t f32_val = float32_val(f32);
 -    bool f32_sign = float32_is_neg(f32);
 -    int f32_exp = extract32(f32_val, 23, 8);
 -    uint32_t f32_frac = extract32(f32_val, 0, 23);
 -    uint64_t f64_frac;
 -
 -    if (float32_is_any_nan(f32)) {
 -        float32 nan = f32;
 -        if (float32_is_signaling_nan(f32, fpst)) {
 -            float_raise(float_flag_invalid, fpst);
 -            nan = float32_silence_nan(f32, fpst);
 -        }
 -        if (fpst->default_nan_mode) {
 -            nan =  float32_default_nan(fpst);
 -        }
 -        return nan;
 -    } else if (float32_is_infinity(f32)) {
 -        return float32_set_sign(float32_zero, float32_is_neg(f32));
 -    } else if (float32_is_zero(f32)) {
 -        float_raise(float_flag_divbyzero, fpst);
 -        return float32_set_sign(float32_infinity, float32_is_neg(f32));
 -    } else if (float32_abs(f32) < (1ULL << 21)) {
 -        /* Abs(value) < 2.0^-128 */
 -        float_raise(float_flag_overflow | float_flag_inexact, fpst);
 -        if (round_to_inf(fpst, f32_sign)) {
 -            return float32_set_sign(float32_infinity, f32_sign);
 -        } else {
 -            return float32_set_sign(float32_maxnorm, f32_sign);
 -        }
 -    } else if (f32_exp >= 253 && fpst->flush_to_zero) {
 -        float_raise(float_flag_underflow, fpst);
 -        return float32_set_sign(float32_zero, float32_is_neg(f32));
 -    }
 -
 -    f64_frac = call_recip_estimate(&f32_exp, 253,
 -                                   ((uint64_t) f32_frac) << (52 - 23));
 -
 -    /* result = sign : result_exp<7:0> : fraction<51:29> */
 -    f32_val = deposit32(0, 31, 1, f32_sign);
 -    f32_val = deposit32(f32_val, 23, 8, f32_exp);
 -    f32_val = deposit32(f32_val, 0, 23, extract64(f64_frac, 52 - 23, 23));
 -    return make_float32(f32_val);
 -}
 -
 -float64 HELPER(recpe_f64)(float64 input, void *fpstp)
 -{
 -    float_status *fpst = fpstp;
 -    float64 f64 = float64_squash_input_denormal(input, fpst);
 -    uint64_t f64_val = float64_val(f64);
 -    bool f64_sign = float64_is_neg(f64);
 -    int f64_exp = extract64(f64_val, 52, 11);
 -    uint64_t f64_frac = extract64(f64_val, 0, 52);
 -
 -    /* Deal with any special cases */
 -    if (float64_is_any_nan(f64)) {
 -        float64 nan = f64;
 -        if (float64_is_signaling_nan(f64, fpst)) {
 -            float_raise(float_flag_invalid, fpst);
 -            nan = float64_silence_nan(f64, fpst);
 -        }
 -        if (fpst->default_nan_mode) {
 -            nan =  float64_default_nan(fpst);
 -        }
 -        return nan;
 -    } else if (float64_is_infinity(f64)) {
 -        return float64_set_sign(float64_zero, float64_is_neg(f64));
 -    } else if (float64_is_zero(f64)) {
 -        float_raise(float_flag_divbyzero, fpst);
 -        return float64_set_sign(float64_infinity, float64_is_neg(f64));
 -    } else if ((f64_val & ~(1ULL << 63)) < (1ULL << 50)) {
 -        /* Abs(value) < 2.0^-1024 */
 -        float_raise(float_flag_overflow | float_flag_inexact, fpst);
 -        if (round_to_inf(fpst, f64_sign)) {
 -            return float64_set_sign(float64_infinity, f64_sign);
 -        } else {
 -            return float64_set_sign(float64_maxnorm, f64_sign);
 -        }
 -    } else if (f64_exp >= 2045 && fpst->flush_to_zero) {
 -        float_raise(float_flag_underflow, fpst);
 -        return float64_set_sign(float64_zero, float64_is_neg(f64));
 -    }
 -
 -    f64_frac = call_recip_estimate(&f64_exp, 2045, f64_frac);
 -
 -    /* result = sign : result_exp<10:0> : fraction<51:0>; */
 -    f64_val = deposit64(0, 63, 1, f64_sign);
 -    f64_val = deposit64(f64_val, 52, 11, f64_exp);
 -    f64_val = deposit64(f64_val, 0, 52, f64_frac);
 -    return make_float64(f64_val);
 -}
 -
 -/* The algorithm that must be used to calculate the estimate
 - * is specified by the ARM ARM.
 - */
 -
 -static int do_recip_sqrt_estimate(int a)
 -{
 -    int b, estimate;
 -
 -    assert(128 <= a && a < 512);
 -    if (a < 256) {
 -        a = a * 2 + 1;
 -    } else {
 -        a = (a >> 1) << 1;
 -        a = (a + 1) * 2;
 -    }
 -    b = 512;
 -    while (a * (b + 1) * (b + 1) < (1 << 28)) {
 -        b += 1;
 -    }
 -    estimate = (b + 1) / 2;
 -    assert(256 <= estimate && estimate < 512);
 -
 -    return estimate;
 -}
 -
 -
 -static uint64_t recip_sqrt_estimate(int *exp , int exp_off, uint64_t frac)
 -{
 -    int estimate;
 -    uint32_t scaled;
 -
 -    if (*exp == 0) {
 -        while (extract64(frac, 51, 1) == 0) {
 -            frac = frac << 1;
 -            *exp -= 1;
 -        }
 -        frac = extract64(frac, 0, 51) << 1;
 -    }
 -
 -    if (*exp & 1) {
 -        /* scaled = UInt('01':fraction<51:45>) */
 -        scaled = deposit32(1 << 7, 0, 7, extract64(frac, 45, 7));
 -    } else {
 -        /* scaled = UInt('1':fraction<51:44>) */
 -        scaled = deposit32(1 << 8, 0, 8, extract64(frac, 44, 8));
 -    }
 -    estimate = do_recip_sqrt_estimate(scaled);
 -
 -    *exp = (exp_off - *exp) / 2;
 -    return extract64(estimate, 0, 8) << 44;
 -}
 -
 -uint32_t HELPER(rsqrte_f16)(uint32_t input, void *fpstp)
 -{
 -    float_status *s = fpstp;
 -    float16 f16 = float16_squash_input_denormal(input, s);
 -    uint16_t val = float16_val(f16);
 -    bool f16_sign = float16_is_neg(f16);
 -    int f16_exp = extract32(val, 10, 5);
 -    uint16_t f16_frac = extract32(val, 0, 10);
 -    uint64_t f64_frac;
 -
 -    if (float16_is_any_nan(f16)) {
 -        float16 nan = f16;
 -        if (float16_is_signaling_nan(f16, s)) {
 -            float_raise(float_flag_invalid, s);
 -            nan = float16_silence_nan(f16, s);
 -        }
 -        if (s->default_nan_mode) {
 -            nan =  float16_default_nan(s);
 -        }
 -        return nan;
 -    } else if (float16_is_zero(f16)) {
 -        float_raise(float_flag_divbyzero, s);
 -        return float16_set_sign(float16_infinity, f16_sign);
 -    } else if (f16_sign) {
 -        float_raise(float_flag_invalid, s);
 -        return float16_default_nan(s);
 -    } else if (float16_is_infinity(f16)) {
 -        return float16_zero;
 -    }
 -
 -    /* Scale and normalize to a double-precision value between 0.25 and 1.0,
 -     * preserving the parity of the exponent.  */
 -
 -    f64_frac = ((uint64_t) f16_frac) << (52 - 10);
 -
 -    f64_frac = recip_sqrt_estimate(&f16_exp, 44, f64_frac);
 -
 -    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(2) */
 -    val = deposit32(0, 15, 1, f16_sign);
 -    val = deposit32(val, 10, 5, f16_exp);
 -    val = deposit32(val, 2, 8, extract64(f64_frac, 52 - 8, 8));
 -    return make_float16(val);
 -}
 -
 -float32 HELPER(rsqrte_f32)(float32 input, void *fpstp)
 -{
 -    float_status *s = fpstp;
 -    float32 f32 = float32_squash_input_denormal(input, s);
 -    uint32_t val = float32_val(f32);
 -    uint32_t f32_sign = float32_is_neg(f32);
 -    int f32_exp = extract32(val, 23, 8);
 -    uint32_t f32_frac = extract32(val, 0, 23);
 -    uint64_t f64_frac;
 -
 -    if (float32_is_any_nan(f32)) {
 -        float32 nan = f32;
 -        if (float32_is_signaling_nan(f32, s)) {
 -            float_raise(float_flag_invalid, s);
 -            nan = float32_silence_nan(f32, s);
 -        }
 -        if (s->default_nan_mode) {
 -            nan =  float32_default_nan(s);
 -        }
 -        return nan;
 -    } else if (float32_is_zero(f32)) {
 -        float_raise(float_flag_divbyzero, s);
 -        return float32_set_sign(float32_infinity, float32_is_neg(f32));
 -    } else if (float32_is_neg(f32)) {
 -        float_raise(float_flag_invalid, s);
 -        return float32_default_nan(s);
 -    } else if (float32_is_infinity(f32)) {
 -        return float32_zero;
 -    }
 -
 -    /* Scale and normalize to a double-precision value between 0.25 and 1.0,
 -     * preserving the parity of the exponent.  */
 -
 -    f64_frac = ((uint64_t) f32_frac) << 29;
 -
 -    f64_frac = recip_sqrt_estimate(&f32_exp, 380, f64_frac);
 -
 -    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(15) */
 -    val = deposit32(0, 31, 1, f32_sign);
 -    val = deposit32(val, 23, 8, f32_exp);
 -    val = deposit32(val, 15, 8, extract64(f64_frac, 52 - 8, 8));
 -    return make_float32(val);
 -}
 -
 -float64 HELPER(rsqrte_f64)(float64 input, void *fpstp)
 -{
 -    float_status *s = fpstp;
 -    float64 f64 = float64_squash_input_denormal(input, s);
 -    uint64_t val = float64_val(f64);
 -    bool f64_sign = float64_is_neg(f64);
 -    int f64_exp = extract64(val, 52, 11);
 -    uint64_t f64_frac = extract64(val, 0, 52);
 -
 -    if (float64_is_any_nan(f64)) {
 -        float64 nan = f64;
 -        if (float64_is_signaling_nan(f64, s)) {
 -            float_raise(float_flag_invalid, s);
 -            nan = float64_silence_nan(f64, s);
 -        }
 -        if (s->default_nan_mode) {
 -            nan =  float64_default_nan(s);
 -        }
 -        return nan;
 -    } else if (float64_is_zero(f64)) {
 -        float_raise(float_flag_divbyzero, s);
 -        return float64_set_sign(float64_infinity, float64_is_neg(f64));
 -    } else if (float64_is_neg(f64)) {
 -        float_raise(float_flag_invalid, s);
 -        return float64_default_nan(s);
 -    } else if (float64_is_infinity(f64)) {
 -        return float64_zero;
 -    }
 -
 -    f64_frac = recip_sqrt_estimate(&f64_exp, 3068, f64_frac);
 -
 -    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(44) */
 -    val = deposit64(0, 61, 1, f64_sign);
 -    val = deposit64(val, 52, 11, f64_exp);
 -    val = deposit64(val, 44, 8, extract64(f64_frac, 52 - 8, 8));
 -    return make_float64(val);
 -}
 -
 -uint32_t HELPER(recpe_u32)(uint32_t a, void *fpstp)
 -{
 -    /* float_status *s = fpstp; */
 -    int input, estimate;
 -
 -    if ((a & 0x80000000) == 0) {
 -        return 0xffffffff;
 -    }
 -
 -    input = extract32(a, 23, 9);
 -    estimate = recip_estimate(input);
 -
 -    return deposit32(0, (32 - 9), 9, estimate);
 -}
 -
 -uint32_t HELPER(rsqrte_u32)(uint32_t a, void *fpstp)
 -{
 -    int estimate;
 -
 -    if ((a & 0xc0000000) == 0) {
 -        return 0xffffffff;
 -    }
 -
 -    estimate = do_recip_sqrt_estimate(extract32(a, 23, 9));
 -
 -    return deposit32(0, 23, 9, estimate);
 -}
 -
 -/* VFPv4 fused multiply-accumulate */
 -float32 VFP_HELPER(muladd, s)(float32 a, float32 b, float32 c, void *fpstp)
 -{
 -    float_status *fpst = fpstp;
 -    return float32_muladd(a, b, c, 0, fpst);
 -}
 -
 -float64 VFP_HELPER(muladd, d)(float64 a, float64 b, float64 c, void *fpstp)
 -{
 -    float_status *fpst = fpstp;
 -    return float64_muladd(a, b, c, 0, fpst);
 -}
 -
 -/* ARMv8 round to integral */
 -float32 HELPER(rints_exact)(float32 x, void *fp_status)
 -{
 -    return float32_round_to_int(x, fp_status);
 -}
 -
 -float64 HELPER(rintd_exact)(float64 x, void *fp_status)
 -{
 -    return float64_round_to_int(x, fp_status);
 -}
 -
 -float32 HELPER(rints)(float32 x, void *fp_status)
 -{
 -    int old_flags = get_float_exception_flags(fp_status), new_flags;
 -    float32 ret;
 -
 -    ret = float32_round_to_int(x, fp_status);
 -
 -    /* Suppress any inexact exceptions the conversion produced */
 -    if (!(old_flags & float_flag_inexact)) {
 -        new_flags = get_float_exception_flags(fp_status);
 -        set_float_exception_flags(new_flags & ~float_flag_inexact, fp_status);
 -    }
 -
 -    return ret;
 -}
 -
 -float64 HELPER(rintd)(float64 x, void *fp_status)
 -{
 -    int old_flags = get_float_exception_flags(fp_status), new_flags;
 -    float64 ret;
 -
 -    ret = float64_round_to_int(x, fp_status);
 -
 -    new_flags = get_float_exception_flags(fp_status);
 -
 -    /* Suppress any inexact exceptions the conversion produced */
 -    if (!(old_flags & float_flag_inexact)) {
 -        new_flags = get_float_exception_flags(fp_status);
 -        set_float_exception_flags(new_flags & ~float_flag_inexact, fp_status);
 -    }
 -
 -    return ret;
 -}
 -
 -/* Convert ARM rounding mode to softfloat */
 -int arm_rmode_to_sf(int rmode)
 -{
 -    switch (rmode) {
 -    case FPROUNDING_TIEAWAY:
 -        rmode = float_round_ties_away;
 -        break;
 -    case FPROUNDING_ODD:
 -        /* FIXME: add support for TIEAWAY and ODD */
 -        qemu_log_mask(LOG_UNIMP, "arm: unimplemented rounding mode: %d\n",
 -                      rmode);
 -        /* fall through for now */
 -    case FPROUNDING_TIEEVEN:
 -    default:
 -        rmode = float_round_nearest_even;
 -        break;
 -    case FPROUNDING_POSINF:
 -        rmode = float_round_up;
 -        break;
 -    case FPROUNDING_NEGINF:
 -        rmode = float_round_down;
 -        break;
 -    case FPROUNDING_ZERO:
 -        rmode = float_round_to_zero;
 -        break;
 -    }
 -    return rmode;
 -}
 -
  /* CRC helpers.
   * The upper bytes of val (above the number specified by 'bytes') must have
   * been zeroed out by the caller.
 diff --git a/target/arm/vfp_helper.c b/target/arm/vfp_helper.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/target/arm/vfp_helper.c
++++ b/include/hw/arm/xlnx-versal.h
 @@ -XXX,XX +XXX,XX @@
 +/*
-+ * ARM VFP floating-point operations
++ * Model of the Xilinx Versal
 + *
-+ *  Copyright (c) 2003 Fabrice Bellard
++ * Copyright (c) 2018 Xilinx Inc.
 + * Written by Edgar E. Iglesias
 + *
-+ * This library is free software; you can redistribute it and/or
++ * This program is free software; you can redistribute it and/or modify
-+ * modify it under the terms of the GNU Lesser General Public
++ * it under the terms of the GNU General Public License version 2 or
-+ * License as published by the Free Software Foundation; either
++ * (at your option) any later version.
-+ * version 2.1 of the License, or (at your option) any later version.
++ */
 +
 +#ifndef XLNX_VERSAL_H
 +#define XLNX_VERSAL_H
 +
 +#include "hw/sysbus.h"
 +#include "hw/arm/arm.h"
 +#include "hw/intc/arm_gicv3.h"
 +
 +#define TYPE_XLNX_VERSAL "xlnx-versal"
 +#define XLNX_VERSAL(obj) OBJECT_CHECK(Versal, (obj), TYPE_XLNX_VERSAL)
 +
 +#define XLNX_VERSAL_NR_ACPUS   2
 +#define XLNX_VERSAL_NR_UARTS   2
 +#define XLNX_VERSAL_NR_GEMS    2
 +#define XLNX_VERSAL_NR_IRQS    256
 +
 +typedef struct Versal {
 +    /*< private >*/
 +    SysBusDevice parent_obj;
 +
 +    /*< public >*/
 +    struct {
 +        struct {
 +            MemoryRegion mr;
 +            ARMCPU *cpu[XLNX_VERSAL_NR_ACPUS];
 +            GICv3State gic;
 +        } apu;
 +    } fpd;
 +
 +    MemoryRegion mr_ps;
 +
 +    struct {
 +        /* 4 ranges to access DDR.  */
 +        MemoryRegion mr_ddr_ranges[4];
 +    } noc;
 +
 +    struct {
 +        MemoryRegion mr_ocm;
 +
 +        struct {
 +            SysBusDevice *uart[XLNX_VERSAL_NR_UARTS];
 +            SysBusDevice *gem[XLNX_VERSAL_NR_GEMS];
 +        } iou;
 +    } lpd;
 +
 +    struct {
 +        MemoryRegion *mr_ddr;
 +        uint32_t psci_conduit;
 +    } cfg;
 +} Versal;
 +
 +/* Memory-map and IRQ definitions. Copied a subset from
 + * auto-generated files.  */
 +
 +#define VERSAL_GIC_MAINT_IRQ        9
 +#define VERSAL_TIMER_VIRT_IRQ       11
 +#define VERSAL_TIMER_S_EL1_IRQ      13
 +#define VERSAL_TIMER_NS_EL1_IRQ     14
 +#define VERSAL_TIMER_NS_EL2_IRQ     10
 +
 +#define VERSAL_UART0_IRQ_0         18
 +#define VERSAL_UART1_IRQ_0         19
 +#define VERSAL_GEM0_IRQ_0          56
 +#define VERSAL_GEM0_WAKE_IRQ_0     57
 +#define VERSAL_GEM1_IRQ_0          58
 +#define VERSAL_GEM1_WAKE_IRQ_0     59
 +
 +/* Architecturally eserved IRQs suitable for virtualization.  */
 +#define VERSAL_RSVD_HIGH_IRQ_FIRST 160
 +#define VERSAL_RSVD_HIGH_IRQ_LAST  255
 +
 +#define MM_TOP_RSVD                 0xa0000000U
 +#define MM_TOP_RSVD_SIZE            0x4000000
 +#define MM_GIC_APU_DIST_MAIN        0xf9000000U
 +#define MM_GIC_APU_DIST_MAIN_SIZE   0x10000
 +#define MM_GIC_APU_REDIST_0         0xf9080000U
 +#define MM_GIC_APU_REDIST_0_SIZE    0x80000
 +
 +#define MM_UART0                    0xff000000U
 +#define MM_UART0_SIZE               0x10000
 +#define MM_UART1                    0xff010000U
 +#define MM_UART1_SIZE               0x10000
 +
 +#define MM_GEM0                     0xff0c0000U
 +#define MM_GEM0_SIZE                0x10000
 +#define MM_GEM1                     0xff0d0000U
 +#define MM_GEM1_SIZE                0x10000
 +
 +#define MM_OCM                      0xfffc0000U
 +#define MM_OCM_SIZE                 0x40000
 +
 +#define MM_TOP_DDR                  0x0
 +#define MM_TOP_DDR_SIZE             0x80000000U
 +#define MM_TOP_DDR_2                0x800000000ULL
 +#define MM_TOP_DDR_2_SIZE           0x800000000ULL
 +#define MM_TOP_DDR_3                0xc000000000ULL
 +#define MM_TOP_DDR_3_SIZE           0x4000000000ULL
 +#define MM_TOP_DDR_4                0x10000000000ULL
 +#define MM_TOP_DDR_4_SIZE           0xb780000000ULL
 +
 +#define MM_PSM_START                0xffc80000U
 +#define MM_PSM_END                  0xffcf0000U
 +
 +#define MM_CRL                      0xff5e0000U
 +#define MM_CRL_SIZE                 0x300000
 +#define MM_IOU_SCNTR                0xff130000U
 +#define MM_IOU_SCNTR_SIZE           0x10000
 +#define MM_IOU_SCNTRS               0xff140000U
 +#define MM_IOU_SCNTRS_SIZE          0x10000
 +#define MM_FPD_CRF                  0xfd1a0000U
 +#define MM_FPD_CRF_SIZE             0x140000
 +#endif
 diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/hw/arm/xlnx-versal.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * Xilinx Versal SoC model.
 + *
-+ * This library is distributed in the hope that it will be useful,
++ * Copyright (c) 2018 Xilinx Inc.
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * Written by Edgar E. Iglesias
 + * 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
++ * This program is free software; you can redistribute it and/or modify
-+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
++ * it under the terms of the GNU General Public License version 2 or
 + * (at your option) any later version.
 + */
 +
 +#include "qemu/osdep.h"
++#include "qapi/error.h"
++#include "qemu-common.h"
 +#include "qemu/log.h"
-+#include "cpu.h"
++#include "hw/sysbus.h"
-+#include "exec/helper-proto.h"
++#include "net/net.h"
-+#include "fpu/softfloat.h"
++#include "sysemu/sysemu.h"
-+#include "internals.h"
++#include "sysemu/kvm.h"
-+
++#include "hw/arm/arm.h"
-+
++#include "kvm_arm.h"
-+/* VFP support.  We follow the convention used for VFP instructions:
++#include "hw/misc/unimp.h"
-+   Single precision routines have a "s" suffix, double precision a
++#include "hw/intc/arm_gicv3_common.h"
-+   "d" suffix.  */
++#include "hw/arm/xlnx-versal.h"
 +
-+/* Convert host exception flags to vfp form.  */
++#define XLNX_VERSAL_ACPU_TYPE ARM_CPU_TYPE_NAME("cortex-a72")
-+static inline int vfp_exceptbits_from_host(int host_bits)
++#define GEM_REVISION        0x40070106
-+{
++
-+    int target_bits = 0;
++static void versal_create_apu_cpus(Versal *s)
 +
 +    if (host_bits & float_flag_invalid)
 +        target_bits |= 1;
 +    if (host_bits & float_flag_divbyzero)
 +        target_bits |= 2;
 +    if (host_bits & float_flag_overflow)
 +        target_bits |= 4;
 +    if (host_bits & (float_flag_underflow | float_flag_output_denormal))
 +        target_bits |= 8;
 +    if (host_bits & float_flag_inexact)
 +        target_bits |= 0x10;
 +    if (host_bits & float_flag_input_denormal)
 +        target_bits |= 0x80;
 +    return target_bits;
 +}
 +
 +uint32_t HELPER(vfp_get_fpscr)(CPUARMState *env)
 +{
 +    uint32_t i, fpscr;
 +
 +    fpscr = env->vfp.xregs[ARM_VFP_FPSCR]
 +            | (env->vfp.vec_len << 16)
 +            | (env->vfp.vec_stride << 20);
 +
 +    i = get_float_exception_flags(&env->vfp.fp_status);
 +    i |= get_float_exception_flags(&env->vfp.standard_fp_status);
 +    /* FZ16 does not generate an input denormal exception.  */
 +    i |= (get_float_exception_flags(&env->vfp.fp_status_f16)
 +          & ~float_flag_input_denormal);
 +    fpscr |= vfp_exceptbits_from_host(i);
 +
 +    i = env->vfp.qc[0] | env->vfp.qc[1] | env->vfp.qc[2] | env->vfp.qc[3];
 +    fpscr |= i ? FPCR_QC : 0;
 +
 +    return fpscr;
 +}
 +
 +uint32_t vfp_get_fpscr(CPUARMState *env)
 +{
 +    return HELPER(vfp_get_fpscr)(env);
 +}
 +
 +/* Convert vfp exception flags to target form.  */
 +static inline int vfp_exceptbits_to_host(int target_bits)
 +{
 +    int host_bits = 0;
 +
 +    if (target_bits & 1)
 +        host_bits |= float_flag_invalid;
 +    if (target_bits & 2)
 +        host_bits |= float_flag_divbyzero;
 +    if (target_bits & 4)
 +        host_bits |= float_flag_overflow;
 +    if (target_bits & 8)
 +        host_bits |= float_flag_underflow;
 +    if (target_bits & 0x10)
 +        host_bits |= float_flag_inexact;
 +    if (target_bits & 0x80)
 +        host_bits |= float_flag_input_denormal;
 +    return host_bits;
 +}
 +
 +void HELPER(vfp_set_fpscr)(CPUARMState *env, uint32_t val)
 +{
 +    int i;
-+    uint32_t changed = env->vfp.xregs[ARM_VFP_FPSCR];
++
-+
++    for (i = 0; i < ARRAY_SIZE(s->fpd.apu.cpu); i++) {
-+    /* When ARMv8.2-FP16 is not supported, FZ16 is RES0.  */
++        Object *obj;
-+    if (!cpu_isar_feature(aa64_fp16, arm_env_get_cpu(env))) {
++        char *name;
-+        val &= ~FPCR_FZ16;
++
-+    }
++        obj = object_new(XLNX_VERSAL_ACPU_TYPE);
-+
++        if (!obj) {
-+    /*
++            /* Secondary CPUs start in PSCI powered-down state */
-+     * We don't implement trapped exception handling, so the
++            error_report("Unable to create apu.cpu[%d] of type %s",
-+     * trap enable bits, IDE|IXE|UFE|OFE|DZE|IOE are all RAZ/WI (not RES0!)
++                         i, XLNX_VERSAL_ACPU_TYPE);
-+     *
++            exit(EXIT_FAILURE);
 +     * If we exclude the exception flags, IOC|DZC|OFC|UFC|IXC|IDC
 +     * (which are stored in fp_status), and the other RES0 bits
 +     * in between, then we clear all of the low 16 bits.
 +     */
 +    env->vfp.xregs[ARM_VFP_FPSCR] = val & 0xf7c80000;
 +    env->vfp.vec_len = (val >> 16) & 7;
 +    env->vfp.vec_stride = (val >> 20) & 3;
 +
 +    /*
 +     * The bit we set within fpscr_q is arbitrary; the register as a
 +     * whole being zero/non-zero is what counts.
 +     */
 +    env->vfp.qc[0] = val & FPCR_QC;
 +    env->vfp.qc[1] = 0;
 +    env->vfp.qc[2] = 0;
 +    env->vfp.qc[3] = 0;
 +
 +    changed ^= val;
 +    if (changed & (3 << 22)) {
 +        i = (val >> 22) & 3;
 +        switch (i) {
 +        case FPROUNDING_TIEEVEN:
 +            i = float_round_nearest_even;
 +            break;
 +        case FPROUNDING_POSINF:
 +            i = float_round_up;
 +            break;
 +        case FPROUNDING_NEGINF:
 +            i = float_round_down;
 +            break;
 +        case FPROUNDING_ZERO:
 +            i = float_round_to_zero;
 +            break;
 +        }
-+        set_float_rounding_mode(i, &env->vfp.fp_status);
++
-+        set_float_rounding_mode(i, &env->vfp.fp_status_f16);
++        name = g_strdup_printf("apu-cpu[%d]", i);
-+    }
++        object_property_add_child(OBJECT(s), name, obj, &error_fatal);
-+    if (changed & FPCR_FZ16) {
++        g_free(name);
-+        bool ftz_enabled = val & FPCR_FZ16;
++
-+        set_flush_to_zero(ftz_enabled, &env->vfp.fp_status_f16);
++        object_property_set_int(obj, s->cfg.psci_conduit,
-+        set_flush_inputs_to_zero(ftz_enabled, &env->vfp.fp_status_f16);
++                                "psci-conduit", &error_abort);
-+    }
++        if (i) {
-+    if (changed & FPCR_FZ) {
++            object_property_set_bool(obj, true,
-+        bool ftz_enabled = val & FPCR_FZ;
++                                     "start-powered-off", &error_abort);
-+        set_flush_to_zero(ftz_enabled, &env->vfp.fp_status);
++        }
-+        set_flush_inputs_to_zero(ftz_enabled, &env->vfp.fp_status);
++
-+    }
++        object_property_set_int(obj, ARRAY_SIZE(s->fpd.apu.cpu),
-+    if (changed & FPCR_DN) {
++                                "core-count", &error_abort);
-+        bool dnan_enabled = val & FPCR_DN;
++        object_property_set_link(obj, OBJECT(&s->fpd.apu.mr), "memory",
-+        set_default_nan_mode(dnan_enabled, &env->vfp.fp_status);
++                                 &error_abort);
-+        set_default_nan_mode(dnan_enabled, &env->vfp.fp_status_f16);
++        object_property_set_bool(obj, true, "realized", &error_fatal);
-+    }
++        s->fpd.apu.cpu[i] = ARM_CPU(obj);
-+
++    }
-+    /* The exception flags are ORed together when we read fpscr so we
++}
-+     * only need to preserve the current state in one of our
++
-+     * float_status values.
++static void versal_create_apu_gic(Versal *s, qemu_irq *pic)
-+     */
++{
-+    i = vfp_exceptbits_to_host(val);
++    static const uint64_t addrs[] = {
-+    set_float_exception_flags(i, &env->vfp.fp_status);
++        MM_GIC_APU_DIST_MAIN,
-+    set_float_exception_flags(0, &env->vfp.fp_status_f16);
++        MM_GIC_APU_REDIST_0
-+    set_float_exception_flags(0, &env->vfp.standard_fp_status);
++    };
-+}
++    SysBusDevice *gicbusdev;
-+
++    DeviceState *gicdev;
-+void vfp_set_fpscr(CPUARMState *env, uint32_t val)
++    int nr_apu_cpus = ARRAY_SIZE(s->fpd.apu.cpu);
-+{
++    int i;
-+    HELPER(vfp_set_fpscr)(env, val);
++
-+}
++    sysbus_init_child_obj(OBJECT(s), "apu-gic",
-+
++                          &s->fpd.apu.gic, sizeof(s->fpd.apu.gic),
-+#define VFP_HELPER(name, p) HELPER(glue(glue(vfp_,name),p))
++                          gicv3_class_name());
-+
++    gicbusdev = SYS_BUS_DEVICE(&s->fpd.apu.gic);
-+#define VFP_BINOP(name) \
++    gicdev = DEVICE(&s->fpd.apu.gic);
-+float32 VFP_HELPER(name, s)(float32 a, float32 b, void *fpstp) \
++    qdev_prop_set_uint32(gicdev, "revision", 3);
-+{ \
++    qdev_prop_set_uint32(gicdev, "num-cpu", 2);
-+    float_status *fpst = fpstp; \
++    qdev_prop_set_uint32(gicdev, "num-irq", XLNX_VERSAL_NR_IRQS + 32);
-+    return float32_ ## name(a, b, fpst); \
++    qdev_prop_set_uint32(gicdev, "len-redist-region-count", 1);
-+} \
++    qdev_prop_set_uint32(gicdev, "redist-region-count[0]", 2);
-+float64 VFP_HELPER(name, d)(float64 a, float64 b, void *fpstp) \
++    qdev_prop_set_bit(gicdev, "has-security-extensions", true);
-+{ \
++
-+    float_status *fpst = fpstp; \
++    object_property_set_bool(OBJECT(&s->fpd.apu.gic), true, "realized",
-+    return float64_ ## name(a, b, fpst); \
++                                    &error_fatal);
-+}
++
-+VFP_BINOP(add)
++    for (i = 0; i < ARRAY_SIZE(addrs); i++) {
-+VFP_BINOP(sub)
++        MemoryRegion *mr;
-+VFP_BINOP(mul)
++
-+VFP_BINOP(div)
++        mr = sysbus_mmio_get_region(gicbusdev, i);
-+VFP_BINOP(min)
++        memory_region_add_subregion(&s->fpd.apu.mr, addrs[i], mr);
-+VFP_BINOP(max)
++    }
-+VFP_BINOP(minnum)
++
-+VFP_BINOP(maxnum)
++    for (i = 0; i < nr_apu_cpus; i++) {
-+#undef VFP_BINOP
++        DeviceState *cpudev = DEVICE(s->fpd.apu.cpu[i]);
-+
++        int ppibase = XLNX_VERSAL_NR_IRQS + i * GIC_INTERNAL + GIC_NR_SGIS;
-+float32 VFP_HELPER(neg, s)(float32 a)
++        qemu_irq maint_irq;
-+{
++        int ti;
-+    return float32_chs(a);
++        /* Mapping from the output timer irq lines from the CPU to the
-+}
++         * GIC PPI inputs.
-+
++         */
-+float64 VFP_HELPER(neg, d)(float64 a)
++        const int timer_irq[] = {
-+{
++            [GTIMER_PHYS] = VERSAL_TIMER_NS_EL1_IRQ,
-+    return float64_chs(a);
++            [GTIMER_VIRT] = VERSAL_TIMER_VIRT_IRQ,
-+}
++            [GTIMER_HYP]  = VERSAL_TIMER_NS_EL2_IRQ,
-+
++            [GTIMER_SEC]  = VERSAL_TIMER_S_EL1_IRQ,
-+float32 VFP_HELPER(abs, s)(float32 a)
++        };
-+{
++
-+    return float32_abs(a);
++        for (ti = 0; ti < ARRAY_SIZE(timer_irq); ti++) {
-+}
++            qdev_connect_gpio_out(cpudev, ti,
-+
++                                  qdev_get_gpio_in(gicdev,
-+float64 VFP_HELPER(abs, d)(float64 a)
++                                                   ppibase + timer_irq[ti]));
-+{
++        }
-+    return float64_abs(a);
++        maint_irq = qdev_get_gpio_in(gicdev,
-+}
++                                        ppibase + VERSAL_GIC_MAINT_IRQ);
-+
++        qdev_connect_gpio_out_named(cpudev, "gicv3-maintenance-interrupt",
-+float32 VFP_HELPER(sqrt, s)(float32 a, CPUARMState *env)
++                                    0, maint_irq);
-+{
++        sysbus_connect_irq(gicbusdev, i, qdev_get_gpio_in(cpudev, ARM_CPU_IRQ));
-+    return float32_sqrt(a, &env->vfp.fp_status);
++        sysbus_connect_irq(gicbusdev, i + nr_apu_cpus,
-+}
++                           qdev_get_gpio_in(cpudev, ARM_CPU_FIQ));
-+
++        sysbus_connect_irq(gicbusdev, i + 2 * nr_apu_cpus,
-+float64 VFP_HELPER(sqrt, d)(float64 a, CPUARMState *env)
++                           qdev_get_gpio_in(cpudev, ARM_CPU_VIRQ));
-+{
++        sysbus_connect_irq(gicbusdev, i + 3 * nr_apu_cpus,
-+    return float64_sqrt(a, &env->vfp.fp_status);
++                           qdev_get_gpio_in(cpudev, ARM_CPU_VFIQ));
-+}
++    }
 +
-+static void softfloat_to_vfp_compare(CPUARMState *env, int cmp)
++    for (i = 0; i < XLNX_VERSAL_NR_IRQS; i++) {
-+{
++        pic[i] = qdev_get_gpio_in(gicdev, i);
-+    uint32_t flags;
++    }
-+    switch (cmp) {
++}
-+    case float_relation_equal:
++
-+        flags = 0x6;
++static void versal_create_uarts(Versal *s, qemu_irq *pic)
-+        break;
++{
-+    case float_relation_less:
++    int i;
-+        flags = 0x8;
++
-+        break;
++    for (i = 0; i < ARRAY_SIZE(s->lpd.iou.uart); i++) {
-+    case float_relation_greater:
++        static const int irqs[] = { VERSAL_UART0_IRQ_0, VERSAL_UART1_IRQ_0};
-+        flags = 0x2;
++        static const uint64_t addrs[] = { MM_UART0, MM_UART1 };
-+        break;
++        char *name = g_strdup_printf("uart%d", i);
-+    case float_relation_unordered:
++        DeviceState *dev;
-+        flags = 0x3;
++        MemoryRegion *mr;
-+        break;
++
-+    default:
++        dev = qdev_create(NULL, "pl011");
-+        g_assert_not_reached();
++        s->lpd.iou.uart[i] = SYS_BUS_DEVICE(dev);
-+    }
++        qdev_prop_set_chr(dev, "chardev", serial_hd(i));
-+    env->vfp.xregs[ARM_VFP_FPSCR] =
++        object_property_add_child(OBJECT(s), name, OBJECT(dev), &error_fatal);
-+        deposit32(env->vfp.xregs[ARM_VFP_FPSCR], 28, 4, flags);
++        qdev_init_nofail(dev);
-+}
++
-+
++        mr = sysbus_mmio_get_region(s->lpd.iou.uart[i], 0);
-+/* XXX: check quiet/signaling case */
++        memory_region_add_subregion(&s->mr_ps, addrs[i], mr);
-+#define DO_VFP_cmp(p, type) \
++
-+void VFP_HELPER(cmp, p)(type a, type b, CPUARMState *env)  \
++        sysbus_connect_irq(s->lpd.iou.uart[i], 0, pic[irqs[i]]);
-+{ \
++        g_free(name);
-+    softfloat_to_vfp_compare(env, \
++    }
-+        type ## _compare_quiet(a, b, &env->vfp.fp_status)); \
++}
-+} \
++
-+void VFP_HELPER(cmpe, p)(type a, type b, CPUARMState *env) \
++static void versal_create_gems(Versal *s, qemu_irq *pic)
-+{ \
++{
-+    softfloat_to_vfp_compare(env, \
++    int i;
-+        type ## _compare(a, b, &env->vfp.fp_status)); \
++
-+}
++    for (i = 0; i < ARRAY_SIZE(s->lpd.iou.gem); i++) {
-+DO_VFP_cmp(s, float32)
++        static const int irqs[] = { VERSAL_GEM0_IRQ_0, VERSAL_GEM1_IRQ_0};
-+DO_VFP_cmp(d, float64)
++        static const uint64_t addrs[] = { MM_GEM0, MM_GEM1 };
-+#undef DO_VFP_cmp
++        char *name = g_strdup_printf("gem%d", i);
-+
++        NICInfo *nd = &nd_table[i];
-+/* Integer to float and float to integer conversions */
++        DeviceState *dev;
-+
++        MemoryRegion *mr;
-+#define CONV_ITOF(name, ftype, fsz, sign)                           \
++
-+ftype HELPER(name)(uint32_t x, void *fpstp)                         \
++        dev = qdev_create(NULL, "cadence_gem");
-+{                                                                   \
++        s->lpd.iou.gem[i] = SYS_BUS_DEVICE(dev);
-+    float_status *fpst = fpstp;                                     \
++        object_property_add_child(OBJECT(s), name, OBJECT(dev), &error_fatal);
-+    return sign##int32_to_##float##fsz((sign##int32_t)x, fpst);     \
++        if (nd->used) {
-+}
++            qemu_check_nic_model(nd, "cadence_gem");
-+
++            qdev_set_nic_properties(dev, nd);
-+#define CONV_FTOI(name, ftype, fsz, sign, round)                \
++        }
-+sign##int32_t HELPER(name)(ftype x, void *fpstp)                \
++        object_property_set_int(OBJECT(s->lpd.iou.gem[i]),
-+{                                                               \
++                                2, "num-priority-queues",
-+    float_status *fpst = fpstp;                                 \
++                                &error_abort);
-+    if (float##fsz##_is_any_nan(x)) {                           \
++        object_property_set_link(OBJECT(s->lpd.iou.gem[i]),
-+        float_raise(float_flag_invalid, fpst);                  \
++                                 OBJECT(&s->mr_ps), "dma",
-+        return 0;                                               \
++                                 &error_abort);
-+    }                                                           \
++        qdev_init_nofail(dev);
-+    return float##fsz##_to_##sign##int32##round(x, fpst);       \
++
-+}
++        mr = sysbus_mmio_get_region(s->lpd.iou.gem[i], 0);
-+
++        memory_region_add_subregion(&s->mr_ps, addrs[i], mr);
-+#define FLOAT_CONVS(name, p, ftype, fsz, sign)            \
++
-+    CONV_ITOF(vfp_##name##to##p, ftype, fsz, sign)        \
++        sysbus_connect_irq(s->lpd.iou.gem[i], 0, pic[irqs[i]]);
-+    CONV_FTOI(vfp_to##name##p, ftype, fsz, sign, )        \
++        g_free(name);
-+    CONV_FTOI(vfp_to##name##z##p, ftype, fsz, sign, _round_to_zero)
++    }
-+
++}
-+FLOAT_CONVS(si, h, uint32_t, 16, )
++
-+FLOAT_CONVS(si, s, float32, 32, )
++/* This takes the board allocated linear DDR memory and creates aliases
-+FLOAT_CONVS(si, d, float64, 64, )
++ * for each split DDR range/aperture on the Versal address map.
 +FLOAT_CONVS(ui, h, uint32_t, 16, u)
 +FLOAT_CONVS(ui, s, float32, 32, u)
 +FLOAT_CONVS(ui, d, float64, 64, u)
 +
 +#undef CONV_ITOF
 +#undef CONV_FTOI
 +#undef FLOAT_CONVS
 +
 +/* floating point conversion */
 +float64 VFP_HELPER(fcvtd, s)(float32 x, CPUARMState *env)
 +{
 +    return float32_to_float64(x, &env->vfp.fp_status);
 +}
 +
 +float32 VFP_HELPER(fcvts, d)(float64 x, CPUARMState *env)
 +{
 +    return float64_to_float32(x, &env->vfp.fp_status);
 +}
 +
 +/* VFP3 fixed point conversion.  */
 +#define VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype) \
 +float##fsz HELPER(vfp_##name##to##p)(uint##isz##_t  x, uint32_t shift, \
 +                                     void *fpstp) \
 +{ return itype##_to_##float##fsz##_scalbn(x, -shift, fpstp); }
 +
 +#define VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype, ROUND, suff)   \
 +uint##isz##_t HELPER(vfp_to##name##p##suff)(float##fsz x, uint32_t shift, \
 +                                            void *fpst)                   \
 +{                                                                         \
 +    if (unlikely(float##fsz##_is_any_nan(x))) {                           \
 +        float_raise(float_flag_invalid, fpst);                            \
 +        return 0;                                                         \
 +    }                                                                     \
 +    return float##fsz##_to_##itype##_scalbn(x, ROUND, shift, fpst);       \
 +}
 +
 +#define VFP_CONV_FIX(name, p, fsz, isz, itype)                   \
 +VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype)                     \
 +VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
 +                         float_round_to_zero, _round_to_zero)    \
 +VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
 +                         get_float_rounding_mode(fpst), )
 +
 +#define VFP_CONV_FIX_A64(name, p, fsz, isz, itype)               \
 +VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype)                     \
 +VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
 +                         get_float_rounding_mode(fpst), )
 +
 +VFP_CONV_FIX(sh, d, 64, 64, int16)
 +VFP_CONV_FIX(sl, d, 64, 64, int32)
 +VFP_CONV_FIX_A64(sq, d, 64, 64, int64)
 +VFP_CONV_FIX(uh, d, 64, 64, uint16)
 +VFP_CONV_FIX(ul, d, 64, 64, uint32)
 +VFP_CONV_FIX_A64(uq, d, 64, 64, uint64)
 +VFP_CONV_FIX(sh, s, 32, 32, int16)
 +VFP_CONV_FIX(sl, s, 32, 32, int32)
 +VFP_CONV_FIX_A64(sq, s, 32, 64, int64)
 +VFP_CONV_FIX(uh, s, 32, 32, uint16)
 +VFP_CONV_FIX(ul, s, 32, 32, uint32)
 +VFP_CONV_FIX_A64(uq, s, 32, 64, uint64)
 +
 +#undef VFP_CONV_FIX
 +#undef VFP_CONV_FIX_FLOAT
 +#undef VFP_CONV_FLOAT_FIX_ROUND
 +#undef VFP_CONV_FIX_A64
 +
 +uint32_t HELPER(vfp_sltoh)(uint32_t x, uint32_t shift, void *fpst)
 +{
 +    return int32_to_float16_scalbn(x, -shift, fpst);
 +}
 +
 +uint32_t HELPER(vfp_ultoh)(uint32_t x, uint32_t shift, void *fpst)
 +{
 +    return uint32_to_float16_scalbn(x, -shift, fpst);
 +}
 +
 +uint32_t HELPER(vfp_sqtoh)(uint64_t x, uint32_t shift, void *fpst)
 +{
 +    return int64_to_float16_scalbn(x, -shift, fpst);
 +}
 +
 +uint32_t HELPER(vfp_uqtoh)(uint64_t x, uint32_t shift, void *fpst)
 +{
 +    return uint64_to_float16_scalbn(x, -shift, fpst);
 +}
 +
 +uint32_t HELPER(vfp_toshh)(uint32_t x, uint32_t shift, void *fpst)
 +{
 +    if (unlikely(float16_is_any_nan(x))) {
 +        float_raise(float_flag_invalid, fpst);
 +        return 0;
 +    }
 +    return float16_to_int16_scalbn(x, get_float_rounding_mode(fpst),
 +                                   shift, fpst);
 +}
 +
 +uint32_t HELPER(vfp_touhh)(uint32_t x, uint32_t shift, void *fpst)
 +{
 +    if (unlikely(float16_is_any_nan(x))) {
 +        float_raise(float_flag_invalid, fpst);
 +        return 0;
 +    }
 +    return float16_to_uint16_scalbn(x, get_float_rounding_mode(fpst),
 +                                    shift, fpst);
 +}
 +
 +uint32_t HELPER(vfp_toslh)(uint32_t x, uint32_t shift, void *fpst)
 +{
 +    if (unlikely(float16_is_any_nan(x))) {
 +        float_raise(float_flag_invalid, fpst);
 +        return 0;
 +    }
 +    return float16_to_int32_scalbn(x, get_float_rounding_mode(fpst),
 +                                   shift, fpst);
 +}
 +
 +uint32_t HELPER(vfp_toulh)(uint32_t x, uint32_t shift, void *fpst)
 +{
 +    if (unlikely(float16_is_any_nan(x))) {
 +        float_raise(float_flag_invalid, fpst);
 +        return 0;
 +    }
 +    return float16_to_uint32_scalbn(x, get_float_rounding_mode(fpst),
 +                                    shift, fpst);
 +}
 +
 +uint64_t HELPER(vfp_tosqh)(uint32_t x, uint32_t shift, void *fpst)
 +{
 +    if (unlikely(float16_is_any_nan(x))) {
 +        float_raise(float_flag_invalid, fpst);
 +        return 0;
 +    }
 +    return float16_to_int64_scalbn(x, get_float_rounding_mode(fpst),
 +                                   shift, fpst);
 +}
 +
 +uint64_t HELPER(vfp_touqh)(uint32_t x, uint32_t shift, void *fpst)
 +{
 +    if (unlikely(float16_is_any_nan(x))) {
 +        float_raise(float_flag_invalid, fpst);
 +        return 0;
 +    }
 +    return float16_to_uint64_scalbn(x, get_float_rounding_mode(fpst),
 +                                    shift, fpst);
 +}
 +
 +/* Set the current fp rounding mode and return the old one.
 + * The argument is a softfloat float_round_ value.
 + */
-+uint32_t HELPER(set_rmode)(uint32_t rmode, void *fpstp)
++static void versal_map_ddr(Versal *s)
 +{
-+    float_status *fp_status = fpstp;
++    uint64_t size = memory_region_size(s->cfg.mr_ddr);
-+
++    /* Describes the various split DDR access regions.  */
-+    uint32_t prev_rmode = get_float_rounding_mode(fp_status);
++    static const struct {
-+    set_float_rounding_mode(rmode, fp_status);
++        uint64_t base;
-+
++        uint64_t size;
-+    return prev_rmode;
++    } addr_ranges[] = {
-+}
++        { MM_TOP_DDR, MM_TOP_DDR_SIZE },
-+
++        { MM_TOP_DDR_2, MM_TOP_DDR_2_SIZE },
-+/* Set the current fp rounding mode in the standard fp status and return
++        { MM_TOP_DDR_3, MM_TOP_DDR_3_SIZE },
-+ * the old one. This is for NEON instructions that need to change the
++        { MM_TOP_DDR_4, MM_TOP_DDR_4_SIZE }
-+ * rounding mode but wish to use the standard FPSCR values for everything
++    };
-+ * else. Always set the rounding mode back to the correct value after
++    uint64_t offset = 0;
-+ * modifying it.
++    int i;
-+ * The argument is a softfloat float_round_ value.
++
-+ */
++    assert(ARRAY_SIZE(addr_ranges) == ARRAY_SIZE(s->noc.mr_ddr_ranges));
-+uint32_t HELPER(set_neon_rmode)(uint32_t rmode, CPUARMState *env)
++    for (i = 0; i < ARRAY_SIZE(addr_ranges) && size; i++) {
-+{
++        char *name;
-+    float_status *fp_status = &env->vfp.standard_fp_status;
++        uint64_t mapsize;
 +
-+    uint32_t prev_rmode = get_float_rounding_mode(fp_status);
++        mapsize = size < addr_ranges[i].size ? size : addr_ranges[i].size;
-+    set_float_rounding_mode(rmode, fp_status);
++        name = g_strdup_printf("noc-ddr-range%d", i);
-+
++        /* Create the MR alias.  */
-+    return prev_rmode;
++        memory_region_init_alias(&s->noc.mr_ddr_ranges[i], OBJECT(s),
-+}
++                                 name, s->cfg.mr_ddr,
-+
++                                 offset, mapsize);
-+/* Half precision conversions.  */
++
-+float32 HELPER(vfp_fcvt_f16_to_f32)(uint32_t a, void *fpstp, uint32_t ahp_mode)
++        /* Map it onto the NoC MR.  */
-+{
++        memory_region_add_subregion(&s->mr_ps, addr_ranges[i].base,
-+    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
++                                    &s->noc.mr_ddr_ranges[i]);
-+     * it would affect flushing input denormals.
++        offset += mapsize;
-+     */
++        size -= mapsize;
-+    float_status *fpst = fpstp;
++        g_free(name);
-+    flag save = get_flush_inputs_to_zero(fpst);
++    }
-+    set_flush_inputs_to_zero(false, fpst);
++}
-+    float32 r = float16_to_float32(a, !ahp_mode, fpst);
++
-+    set_flush_inputs_to_zero(save, fpst);
++static void versal_unimp_area(Versal *s, const char *name,
-+    return r;
++                                MemoryRegion *mr,
-+}
++                                hwaddr base, hwaddr size)
-+
++{
-+uint32_t HELPER(vfp_fcvt_f32_to_f16)(float32 a, void *fpstp, uint32_t ahp_mode)
++    DeviceState *dev = qdev_create(NULL, TYPE_UNIMPLEMENTED_DEVICE);
-+{
++    MemoryRegion *mr_dev;
-+    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
++
-+     * it would affect flushing output denormals.
++    qdev_prop_set_string(dev, "name", name);
-+     */
++    qdev_prop_set_uint64(dev, "size", size);
-+    float_status *fpst = fpstp;
++    object_property_add_child(OBJECT(s), name, OBJECT(dev), &error_fatal);
-+    flag save = get_flush_to_zero(fpst);
++    qdev_init_nofail(dev);
-+    set_flush_to_zero(false, fpst);
++
-+    float16 r = float32_to_float16(a, !ahp_mode, fpst);
++    mr_dev = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0);
-+    set_flush_to_zero(save, fpst);
++    memory_region_add_subregion(mr, base, mr_dev);
-+    return r;
++}
-+}
++
-+
++static void versal_unimp(Versal *s)
-+float64 HELPER(vfp_fcvt_f16_to_f64)(uint32_t a, void *fpstp, uint32_t ahp_mode)
++{
-+{
++    versal_unimp_area(s, "psm", &s->mr_ps,
-+    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
++                        MM_PSM_START, MM_PSM_END - MM_PSM_START);
-+     * it would affect flushing input denormals.
++    versal_unimp_area(s, "crl", &s->mr_ps,
-+     */
++                        MM_CRL, MM_CRL_SIZE);
-+    float_status *fpst = fpstp;
++    versal_unimp_area(s, "crf", &s->mr_ps,
-+    flag save = get_flush_inputs_to_zero(fpst);
++                        MM_FPD_CRF, MM_FPD_CRF_SIZE);
-+    set_flush_inputs_to_zero(false, fpst);
++    versal_unimp_area(s, "iou-scntr", &s->mr_ps,
-+    float64 r = float16_to_float64(a, !ahp_mode, fpst);
++                        MM_IOU_SCNTR, MM_IOU_SCNTR_SIZE);
-+    set_flush_inputs_to_zero(save, fpst);
++    versal_unimp_area(s, "iou-scntr-seucre", &s->mr_ps,
-+    return r;
++                        MM_IOU_SCNTRS, MM_IOU_SCNTRS_SIZE);
 +}
 +
-+uint32_t HELPER(vfp_fcvt_f64_to_f16)(float64 a, void *fpstp, uint32_t ahp_mode)
++static void versal_realize(DeviceState *dev, Error **errp)
 +{
-+    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
++    Versal *s = XLNX_VERSAL(dev);
-+     * it would affect flushing output denormals.
++    qemu_irq pic[XLNX_VERSAL_NR_IRQS];
-+     */
++
-+    float_status *fpst = fpstp;
++    versal_create_apu_cpus(s);
-+    flag save = get_flush_to_zero(fpst);
++    versal_create_apu_gic(s, pic);
-+    set_flush_to_zero(false, fpst);
++    versal_create_uarts(s, pic);
-+    float16 r = float64_to_float16(a, !ahp_mode, fpst);
++    versal_create_gems(s, pic);
-+    set_flush_to_zero(save, fpst);
++    versal_map_ddr(s);
-+    return r;
++    versal_unimp(s);
-+}
++
-+
++    /* Create the On Chip Memory (OCM).  */
-+#define float32_two make_float32(0x40000000)
++    memory_region_init_ram(&s->lpd.mr_ocm, OBJECT(s), "ocm",
-+#define float32_three make_float32(0x40400000)
++                           MM_OCM_SIZE, &error_fatal);
-+#define float32_one_point_five make_float32(0x3fc00000)
++
-+
++    memory_region_add_subregion_overlap(&s->mr_ps, MM_OCM, &s->lpd.mr_ocm, 0);
-+float32 HELPER(recps_f32)(float32 a, float32 b, CPUARMState *env)
++    memory_region_add_subregion_overlap(&s->fpd.apu.mr, 0, &s->mr_ps, 0);
-+{
++}
-+    float_status *s = &env->vfp.standard_fp_status;
++
-+    if ((float32_is_infinity(a) && float32_is_zero_or_denormal(b)) ||
++static void versal_init(Object *obj)
-+        (float32_is_infinity(b) && float32_is_zero_or_denormal(a))) {
++{
-+        if (!(float32_is_zero(a) || float32_is_zero(b))) {
++    Versal *s = XLNX_VERSAL(obj);
-+            float_raise(float_flag_input_denormal, s);
++
-+        }
++    memory_region_init(&s->fpd.apu.mr, obj, "mr-apu", UINT64_MAX);
-+        return float32_two;
++    memory_region_init(&s->mr_ps, obj, "mr-ps-switch", UINT64_MAX);
-+    }
++}
-+    return float32_sub(float32_two, float32_mul(a, b, s), s);
++
-+}
++static Property versal_properties[] = {
-+
++    DEFINE_PROP_LINK("ddr", Versal, cfg.mr_ddr, TYPE_MEMORY_REGION,
-+float32 HELPER(rsqrts_f32)(float32 a, float32 b, CPUARMState *env)
++                     MemoryRegion *),
-+{
++    DEFINE_PROP_UINT32("psci-conduit", Versal, cfg.psci_conduit, 0),
-+    float_status *s = &env->vfp.standard_fp_status;
++    DEFINE_PROP_END_OF_LIST()
-+    float32 product;
++};
-+    if ((float32_is_infinity(a) && float32_is_zero_or_denormal(b)) ||
++
-+        (float32_is_infinity(b) && float32_is_zero_or_denormal(a))) {
++static void versal_class_init(ObjectClass *klass, void *data)
-+        if (!(float32_is_zero(a) || float32_is_zero(b))) {
++{
-+            float_raise(float_flag_input_denormal, s);
++    DeviceClass *dc = DEVICE_CLASS(klass);
-+        }
++
-+        return float32_one_point_five;
++    dc->realize = versal_realize;
-+    }
++    dc->props = versal_properties;
-+    product = float32_mul(a, b, s);
++    /* No VMSD since we haven't got any top-level SoC state to save.  */
-+    return float32_div(float32_sub(float32_three, product, s), float32_two, s);
++}
-+}
++
-+
++static const TypeInfo versal_info = {
-+/* NEON helpers.  */
++    .name = TYPE_XLNX_VERSAL,
-+
++    .parent = TYPE_SYS_BUS_DEVICE,
-+/* Constants 256 and 512 are used in some helpers; we avoid relying on
++    .instance_size = sizeof(Versal),
-+ * int->float conversions at run-time.  */
++    .instance_init = versal_init,
-+#define float64_256 make_float64(0x4070000000000000LL)
++    .class_init = versal_class_init,
-+#define float64_512 make_float64(0x4080000000000000LL)
++};
-+#define float16_maxnorm make_float16(0x7bff)
++
-+#define float32_maxnorm make_float32(0x7f7fffff)
++static void versal_register_types(void)
-+#define float64_maxnorm make_float64(0x7fefffffffffffffLL)
++{
-+
++    type_register_static(&versal_info);
-+/* Reciprocal functions
++}
-+ *
++
-+ * The algorithm that must be used to calculate the estimate
++type_init(versal_register_types);
-+ * is specified by the ARM ARM, see FPRecipEstimate()/RecipEstimate
+diff --git a/default-configs/aarch64-softmmu.mak b/default-configs/aarch64-softmmu.mak
-+ */
+index XXXXXXX..XXXXXXX 100644
-+
+--- a/default-configs/aarch64-softmmu.mak
-+/* See RecipEstimate()
++++ b/default-configs/aarch64-softmmu.mak
-+ *
+@@ -XXX,XX +XXX,XX @@ CONFIG_DDC=y
-+ * input is a 9 bit fixed point number
+ CONFIG_DPCD=y
-+ * input range 256 .. 511 for a number from 0.5 <= x < 1.0.
+ CONFIG_XLNX_ZYNQMP=y
-+ * result range 256 .. 511 for a number from 1.0 to 511/256.
+ CONFIG_XLNX_ZYNQMP_ARM=y
-+ */
++CONFIG_XLNX_VERSAL=y
-+
+ CONFIG_ARM_SMMUV3=y
 +static int recip_estimate(int input)
 +{
 +    int a, b, r;
 +    assert(256 <= input && input < 512);
 +    a = (input * 2) + 1;
 +    b = (1 << 19) / a;
 +    r = (b + 1) >> 1;
 +    assert(256 <= r && r < 512);
 +    return r;
 +}
 +
 +/*
 + * Common wrapper to call recip_estimate
 + *
 + * The parameters are exponent and 64 bit fraction (without implicit
 + * bit) where the binary point is nominally at bit 52. Returns a
 + * float64 which can then be rounded to the appropriate size by the
 + * callee.
 + */
 +
 +static uint64_t call_recip_estimate(int *exp, int exp_off, uint64_t frac)
 +{
 +    uint32_t scaled, estimate;
 +    uint64_t result_frac;
 +    int result_exp;
 +
 +    /* Handle sub-normals */
 +    if (*exp == 0) {
 +        if (extract64(frac, 51, 1) == 0) {
 +            *exp = -1;
 +            frac <<= 2;
 +        } else {
 +            frac <<= 1;
 +        }
 +    }
 +
 +    /* scaled = UInt('1':fraction<51:44>) */
 +    scaled = deposit32(1 << 8, 0, 8, extract64(frac, 44, 8));
 +    estimate = recip_estimate(scaled);
 +
 +    result_exp = exp_off - *exp;
 +    result_frac = deposit64(0, 44, 8, estimate);
 +    if (result_exp == 0) {
 +        result_frac = deposit64(result_frac >> 1, 51, 1, 1);
 +    } else if (result_exp == -1) {
 +        result_frac = deposit64(result_frac >> 2, 50, 2, 1);
 +        result_exp = 0;
 +    }
 +
 +    *exp = result_exp;
 +
 +    return result_frac;
 +}
 +
 +static bool round_to_inf(float_status *fpst, bool sign_bit)
 +{
 +    switch (fpst->float_rounding_mode) {
 +    case float_round_nearest_even: /* Round to Nearest */
 +        return true;
 +    case float_round_up: /* Round to +Inf */
 +        return !sign_bit;
 +    case float_round_down: /* Round to -Inf */
 +        return sign_bit;
 +    case float_round_to_zero: /* Round to Zero */
 +        return false;
 +    }
 +
 +    g_assert_not_reached();
 +}
 +
 +uint32_t HELPER(recpe_f16)(uint32_t input, void *fpstp)
 +{
 +    float_status *fpst = fpstp;
 +    float16 f16 = float16_squash_input_denormal(input, fpst);
 +    uint32_t f16_val = float16_val(f16);
 +    uint32_t f16_sign = float16_is_neg(f16);
 +    int f16_exp = extract32(f16_val, 10, 5);
 +    uint32_t f16_frac = extract32(f16_val, 0, 10);
 +    uint64_t f64_frac;
 +
 +    if (float16_is_any_nan(f16)) {
 +        float16 nan = f16;
 +        if (float16_is_signaling_nan(f16, fpst)) {
 +            float_raise(float_flag_invalid, fpst);
 +            nan = float16_silence_nan(f16, fpst);
 +        }
 +        if (fpst->default_nan_mode) {
 +            nan =  float16_default_nan(fpst);
 +        }
 +        return nan;
 +    } else if (float16_is_infinity(f16)) {
 +        return float16_set_sign(float16_zero, float16_is_neg(f16));
 +    } else if (float16_is_zero(f16)) {
 +        float_raise(float_flag_divbyzero, fpst);
 +        return float16_set_sign(float16_infinity, float16_is_neg(f16));
 +    } else if (float16_abs(f16) < (1 << 8)) {
 +        /* Abs(value) < 2.0^-16 */
 +        float_raise(float_flag_overflow | float_flag_inexact, fpst);
 +        if (round_to_inf(fpst, f16_sign)) {
 +            return float16_set_sign(float16_infinity, f16_sign);
 +        } else {
 +            return float16_set_sign(float16_maxnorm, f16_sign);
 +        }
 +    } else if (f16_exp >= 29 && fpst->flush_to_zero) {
 +        float_raise(float_flag_underflow, fpst);
 +        return float16_set_sign(float16_zero, float16_is_neg(f16));
 +    }
 +
 +    f64_frac = call_recip_estimate(&f16_exp, 29,
 +                                   ((uint64_t) f16_frac) << (52 - 10));
 +
 +    /* result = sign : result_exp<4:0> : fraction<51:42> */
 +    f16_val = deposit32(0, 15, 1, f16_sign);
 +    f16_val = deposit32(f16_val, 10, 5, f16_exp);
 +    f16_val = deposit32(f16_val, 0, 10, extract64(f64_frac, 52 - 10, 10));
 +    return make_float16(f16_val);
 +}
 +
 +float32 HELPER(recpe_f32)(float32 input, void *fpstp)
 +{
 +    float_status *fpst = fpstp;
 +    float32 f32 = float32_squash_input_denormal(input, fpst);
 +    uint32_t f32_val = float32_val(f32);
 +    bool f32_sign = float32_is_neg(f32);
 +    int f32_exp = extract32(f32_val, 23, 8);
 +    uint32_t f32_frac = extract32(f32_val, 0, 23);
 +    uint64_t f64_frac;
 +
 +    if (float32_is_any_nan(f32)) {
 +        float32 nan = f32;
 +        if (float32_is_signaling_nan(f32, fpst)) {
 +            float_raise(float_flag_invalid, fpst);
 +            nan = float32_silence_nan(f32, fpst);
 +        }
 +        if (fpst->default_nan_mode) {
 +            nan =  float32_default_nan(fpst);
 +        }
 +        return nan;
 +    } else if (float32_is_infinity(f32)) {
 +        return float32_set_sign(float32_zero, float32_is_neg(f32));
 +    } else if (float32_is_zero(f32)) {
 +        float_raise(float_flag_divbyzero, fpst);
 +        return float32_set_sign(float32_infinity, float32_is_neg(f32));
 +    } else if (float32_abs(f32) < (1ULL << 21)) {
 +        /* Abs(value) < 2.0^-128 */
 +        float_raise(float_flag_overflow | float_flag_inexact, fpst);
 +        if (round_to_inf(fpst, f32_sign)) {
 +            return float32_set_sign(float32_infinity, f32_sign);
 +        } else {
 +            return float32_set_sign(float32_maxnorm, f32_sign);
 +        }
 +    } else if (f32_exp >= 253 && fpst->flush_to_zero) {
 +        float_raise(float_flag_underflow, fpst);
 +        return float32_set_sign(float32_zero, float32_is_neg(f32));
 +    }
 +
 +    f64_frac = call_recip_estimate(&f32_exp, 253,
 +                                   ((uint64_t) f32_frac) << (52 - 23));
 +
 +    /* result = sign : result_exp<7:0> : fraction<51:29> */
 +    f32_val = deposit32(0, 31, 1, f32_sign);
 +    f32_val = deposit32(f32_val, 23, 8, f32_exp);
 +    f32_val = deposit32(f32_val, 0, 23, extract64(f64_frac, 52 - 23, 23));
 +    return make_float32(f32_val);
 +}
 +
 +float64 HELPER(recpe_f64)(float64 input, void *fpstp)
 +{
 +    float_status *fpst = fpstp;
 +    float64 f64 = float64_squash_input_denormal(input, fpst);
 +    uint64_t f64_val = float64_val(f64);
 +    bool f64_sign = float64_is_neg(f64);
 +    int f64_exp = extract64(f64_val, 52, 11);
 +    uint64_t f64_frac = extract64(f64_val, 0, 52);
 +
 +    /* Deal with any special cases */
 +    if (float64_is_any_nan(f64)) {
 +        float64 nan = f64;
 +        if (float64_is_signaling_nan(f64, fpst)) {
 +            float_raise(float_flag_invalid, fpst);
 +            nan = float64_silence_nan(f64, fpst);
 +        }
 +        if (fpst->default_nan_mode) {
 +            nan =  float64_default_nan(fpst);
 +        }
 +        return nan;
 +    } else if (float64_is_infinity(f64)) {
 +        return float64_set_sign(float64_zero, float64_is_neg(f64));
 +    } else if (float64_is_zero(f64)) {
 +        float_raise(float_flag_divbyzero, fpst);
 +        return float64_set_sign(float64_infinity, float64_is_neg(f64));
 +    } else if ((f64_val & ~(1ULL << 63)) < (1ULL << 50)) {
 +        /* Abs(value) < 2.0^-1024 */
 +        float_raise(float_flag_overflow | float_flag_inexact, fpst);
 +        if (round_to_inf(fpst, f64_sign)) {
 +            return float64_set_sign(float64_infinity, f64_sign);
 +        } else {
 +            return float64_set_sign(float64_maxnorm, f64_sign);
 +        }
 +    } else if (f64_exp >= 2045 && fpst->flush_to_zero) {
 +        float_raise(float_flag_underflow, fpst);
 +        return float64_set_sign(float64_zero, float64_is_neg(f64));
 +    }
 +
 +    f64_frac = call_recip_estimate(&f64_exp, 2045, f64_frac);
 +
 +    /* result = sign : result_exp<10:0> : fraction<51:0>; */
 +    f64_val = deposit64(0, 63, 1, f64_sign);
 +    f64_val = deposit64(f64_val, 52, 11, f64_exp);
 +    f64_val = deposit64(f64_val, 0, 52, f64_frac);
 +    return make_float64(f64_val);
 +}
 +
 +/* The algorithm that must be used to calculate the estimate
 + * is specified by the ARM ARM.
 + */
 +
 +static int do_recip_sqrt_estimate(int a)
 +{
 +    int b, estimate;
 +
 +    assert(128 <= a && a < 512);
 +    if (a < 256) {
 +        a = a * 2 + 1;
 +    } else {
 +        a = (a >> 1) << 1;
 +        a = (a + 1) * 2;
 +    }
 +    b = 512;
 +    while (a * (b + 1) * (b + 1) < (1 << 28)) {
 +        b += 1;
 +    }
 +    estimate = (b + 1) / 2;
 +    assert(256 <= estimate && estimate < 512);
 +
 +    return estimate;
 +}
 +
 +
 +static uint64_t recip_sqrt_estimate(int *exp , int exp_off, uint64_t frac)
 +{
 +    int estimate;
 +    uint32_t scaled;
 +
 +    if (*exp == 0) {
 +        while (extract64(frac, 51, 1) == 0) {
 +            frac = frac << 1;
 +            *exp -= 1;
 +        }
 +        frac = extract64(frac, 0, 51) << 1;
 +    }
 +
 +    if (*exp & 1) {
 +        /* scaled = UInt('01':fraction<51:45>) */
 +        scaled = deposit32(1 << 7, 0, 7, extract64(frac, 45, 7));
 +    } else {
 +        /* scaled = UInt('1':fraction<51:44>) */
 +        scaled = deposit32(1 << 8, 0, 8, extract64(frac, 44, 8));
 +    }
 +    estimate = do_recip_sqrt_estimate(scaled);
 +
 +    *exp = (exp_off - *exp) / 2;
 +    return extract64(estimate, 0, 8) << 44;
 +}
 +
 +uint32_t HELPER(rsqrte_f16)(uint32_t input, void *fpstp)
 +{
 +    float_status *s = fpstp;
 +    float16 f16 = float16_squash_input_denormal(input, s);
 +    uint16_t val = float16_val(f16);
 +    bool f16_sign = float16_is_neg(f16);
 +    int f16_exp = extract32(val, 10, 5);
 +    uint16_t f16_frac = extract32(val, 0, 10);
 +    uint64_t f64_frac;
 +
 +    if (float16_is_any_nan(f16)) {
 +        float16 nan = f16;
 +        if (float16_is_signaling_nan(f16, s)) {
 +            float_raise(float_flag_invalid, s);
 +            nan = float16_silence_nan(f16, s);
 +        }
 +        if (s->default_nan_mode) {
 +            nan =  float16_default_nan(s);
 +        }
 +        return nan;
 +    } else if (float16_is_zero(f16)) {
 +        float_raise(float_flag_divbyzero, s);
 +        return float16_set_sign(float16_infinity, f16_sign);
 +    } else if (f16_sign) {
 +        float_raise(float_flag_invalid, s);
 +        return float16_default_nan(s);
 +    } else if (float16_is_infinity(f16)) {
 +        return float16_zero;
 +    }
 +
 +    /* Scale and normalize to a double-precision value between 0.25 and 1.0,
 +     * preserving the parity of the exponent.  */
 +
 +    f64_frac = ((uint64_t) f16_frac) << (52 - 10);
 +
 +    f64_frac = recip_sqrt_estimate(&f16_exp, 44, f64_frac);
 +
 +    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(2) */
 +    val = deposit32(0, 15, 1, f16_sign);
 +    val = deposit32(val, 10, 5, f16_exp);
 +    val = deposit32(val, 2, 8, extract64(f64_frac, 52 - 8, 8));
 +    return make_float16(val);
 +}
 +
 +float32 HELPER(rsqrte_f32)(float32 input, void *fpstp)
 +{
 +    float_status *s = fpstp;
 +    float32 f32 = float32_squash_input_denormal(input, s);
 +    uint32_t val = float32_val(f32);
 +    uint32_t f32_sign = float32_is_neg(f32);
 +    int f32_exp = extract32(val, 23, 8);
 +    uint32_t f32_frac = extract32(val, 0, 23);
 +    uint64_t f64_frac;
 +
 +    if (float32_is_any_nan(f32)) {
 +        float32 nan = f32;
 +        if (float32_is_signaling_nan(f32, s)) {
 +            float_raise(float_flag_invalid, s);
 +            nan = float32_silence_nan(f32, s);
 +        }
 +        if (s->default_nan_mode) {
 +            nan =  float32_default_nan(s);
 +        }
 +        return nan;
 +    } else if (float32_is_zero(f32)) {
 +        float_raise(float_flag_divbyzero, s);
 +        return float32_set_sign(float32_infinity, float32_is_neg(f32));
 +    } else if (float32_is_neg(f32)) {
 +        float_raise(float_flag_invalid, s);
 +        return float32_default_nan(s);
 +    } else if (float32_is_infinity(f32)) {
 +        return float32_zero;
 +    }
 +
 +    /* Scale and normalize to a double-precision value between 0.25 and 1.0,
 +     * preserving the parity of the exponent.  */
 +
 +    f64_frac = ((uint64_t) f32_frac) << 29;
 +
 +    f64_frac = recip_sqrt_estimate(&f32_exp, 380, f64_frac);
 +
 +    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(15) */
 +    val = deposit32(0, 31, 1, f32_sign);
 +    val = deposit32(val, 23, 8, f32_exp);
 +    val = deposit32(val, 15, 8, extract64(f64_frac, 52 - 8, 8));
 +    return make_float32(val);
 +}
 +
 +float64 HELPER(rsqrte_f64)(float64 input, void *fpstp)
 +{
 +    float_status *s = fpstp;
 +    float64 f64 = float64_squash_input_denormal(input, s);
 +    uint64_t val = float64_val(f64);
 +    bool f64_sign = float64_is_neg(f64);
 +    int f64_exp = extract64(val, 52, 11);
 +    uint64_t f64_frac = extract64(val, 0, 52);
 +
 +    if (float64_is_any_nan(f64)) {
 +        float64 nan = f64;
 +        if (float64_is_signaling_nan(f64, s)) {
 +            float_raise(float_flag_invalid, s);
 +            nan = float64_silence_nan(f64, s);
 +        }
 +        if (s->default_nan_mode) {
 +            nan =  float64_default_nan(s);
 +        }
 +        return nan;
 +    } else if (float64_is_zero(f64)) {
 +        float_raise(float_flag_divbyzero, s);
 +        return float64_set_sign(float64_infinity, float64_is_neg(f64));
 +    } else if (float64_is_neg(f64)) {
 +        float_raise(float_flag_invalid, s);
 +        return float64_default_nan(s);
 +    } else if (float64_is_infinity(f64)) {
 +        return float64_zero;
 +    }
 +
 +    f64_frac = recip_sqrt_estimate(&f64_exp, 3068, f64_frac);
 +
 +    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(44) */
 +    val = deposit64(0, 61, 1, f64_sign);
 +    val = deposit64(val, 52, 11, f64_exp);
 +    val = deposit64(val, 44, 8, extract64(f64_frac, 52 - 8, 8));
 +    return make_float64(val);
 +}
 +
 +uint32_t HELPER(recpe_u32)(uint32_t a, void *fpstp)
 +{
 +    /* float_status *s = fpstp; */
 +    int input, estimate;
 +
 +    if ((a & 0x80000000) == 0) {
 +        return 0xffffffff;
 +    }
 +
 +    input = extract32(a, 23, 9);
 +    estimate = recip_estimate(input);
 +
 +    return deposit32(0, (32 - 9), 9, estimate);
 +}
 +
 +uint32_t HELPER(rsqrte_u32)(uint32_t a, void *fpstp)
 +{
 +    int estimate;
 +
 +    if ((a & 0xc0000000) == 0) {
 +        return 0xffffffff;
 +    }
 +
 +    estimate = do_recip_sqrt_estimate(extract32(a, 23, 9));
 +
 +    return deposit32(0, 23, 9, estimate);
 +}
 +
 +/* VFPv4 fused multiply-accumulate */
 +float32 VFP_HELPER(muladd, s)(float32 a, float32 b, float32 c, void *fpstp)
 +{
 +    float_status *fpst = fpstp;
 +    return float32_muladd(a, b, c, 0, fpst);
 +}
 +
 +float64 VFP_HELPER(muladd, d)(float64 a, float64 b, float64 c, void *fpstp)
 +{
 +    float_status *fpst = fpstp;
 +    return float64_muladd(a, b, c, 0, fpst);
 +}
 +
 +/* ARMv8 round to integral */
 +float32 HELPER(rints_exact)(float32 x, void *fp_status)
 +{
 +    return float32_round_to_int(x, fp_status);
 +}
 +
 +float64 HELPER(rintd_exact)(float64 x, void *fp_status)
 +{
 +    return float64_round_to_int(x, fp_status);
 +}
 +
 +float32 HELPER(rints)(float32 x, void *fp_status)
 +{
 +    int old_flags = get_float_exception_flags(fp_status), new_flags;
 +    float32 ret;
 +
 +    ret = float32_round_to_int(x, fp_status);
 +
 +    /* Suppress any inexact exceptions the conversion produced */
 +    if (!(old_flags & float_flag_inexact)) {
 +        new_flags = get_float_exception_flags(fp_status);
 +        set_float_exception_flags(new_flags & ~float_flag_inexact, fp_status);
 +    }
 +
 +    return ret;
 +}
 +
 +float64 HELPER(rintd)(float64 x, void *fp_status)
 +{
 +    int old_flags = get_float_exception_flags(fp_status), new_flags;
 +    float64 ret;
 +
 +    ret = float64_round_to_int(x, fp_status);
 +
 +    new_flags = get_float_exception_flags(fp_status);
 +
 +    /* Suppress any inexact exceptions the conversion produced */
 +    if (!(old_flags & float_flag_inexact)) {
 +        new_flags = get_float_exception_flags(fp_status);
 +        set_float_exception_flags(new_flags & ~float_flag_inexact, fp_status);
 +    }
 +
 +    return ret;
 +}
 +
 +/* Convert ARM rounding mode to softfloat */
 +int arm_rmode_to_sf(int rmode)
 +{
 +    switch (rmode) {
 +    case FPROUNDING_TIEAWAY:
 +        rmode = float_round_ties_away;
 +        break;
 +    case FPROUNDING_ODD:
 +        /* FIXME: add support for TIEAWAY and ODD */
 +        qemu_log_mask(LOG_UNIMP, "arm: unimplemented rounding mode: %d\n",
 +                      rmode);
 +        /* fall through for now */
 +    case FPROUNDING_TIEEVEN:
 +    default:
 +        rmode = float_round_nearest_even;
 +        break;
 +    case FPROUNDING_POSINF:
 +        rmode = float_round_up;
 +        break;
 +    case FPROUNDING_NEGINF:
 +        rmode = float_round_down;
 +        break;
 +    case FPROUNDING_ZERO:
 +        rmode = float_round_to_zero;
 +        break;
 +    }
 +    return rmode;
 +}
 --
-.20.1
+.19.1

-[Qemu-devel] [PULL 06/21] target/arm: Rearrange Floating-point data-processing (2 regs)
+Deleted patch
-From: Richard Henderson <richard.henderson@linaro.org>
-There are lots of special cases within these insns.  Split the
-major argument decode/loading/saving into no_output (compares),
-rd_is_dp, and rm_is_dp.
-We still need to special case argument load for compare (rd as
-input, rm as zero) and vcvt fixed (rd as input+output), but lots
-of special cases do disappear.
-Now that we have a full switch at the beginning, hoist the ISA
-checks from the code generation.
-Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
-Message-id: 20190215192302.27855-4-richard.henderson@linaro.org
-Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
----
- target/arm/translate.c | 227 ++++++++++++++++++++---------------------
-file changed, 111 insertions(+), 116 deletions(-)
-diff --git a/target/arm/translate.c b/target/arm/translate.c
-index XXXXXXX..XXXXXXX 100644
---- a/target/arm/translate.c
-+++ b/target/arm/translate.c
-@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
-             }
-         } else {
-             /* data processing */
-+            bool rd_is_dp = dp;
-+            bool rm_is_dp = dp;
-+            bool no_output = false;
-+
-             /* The opcode is in bits 23, 21, 20 and 6.  */
-             op = ((insn >> 20) & 8) | ((insn >> 19) & 6) | ((insn >> 6) & 1);
--            if (dp) {
--                if (op == 15) {
--                    /* rn is opcode */
--                    rn = ((insn >> 15) & 0x1e) | ((insn >> 7) & 1);
--                } else {
--                    /* rn is register number */
--                    VFP_DREG_N(rn, insn);
--                }
-+            rn = VFP_SREG_N(insn);
--                if (op == 15 && (rn == 15 || ((rn & 0x1c) == 0x18) ||
--                                 ((rn & 0x1e) == 0x6))) {
--                    /* Integer or single/half precision destination.  */
--                    rd = VFP_SREG_D(insn);
--                } else {
--                    VFP_DREG_D(rd, insn);
--                }
--                if (op == 15 &&
--                    (((rn & 0x1c) == 0x10) || ((rn & 0x14) == 0x14) ||
--                     ((rn & 0x1e) == 0x4))) {
--                    /* VCVT from int or half precision is always from S reg
--                     * regardless of dp bit. VCVT with immediate frac_bits
--                     * has same format as SREG_M.
-+            if (op == 15) {
-+                /* rn is opcode, encoded as per VFP_SREG_N. */
-+                switch (rn) {
-+                case 0x00: /* vmov */
-+                case 0x01: /* vabs */
-+                case 0x02: /* vneg */
-+                case 0x03: /* vsqrt */
-+                    break;
-+
-+                case 0x04: /* vcvtb.f64.f16, vcvtb.f32.f16 */
-+                case 0x05: /* vcvtt.f64.f16, vcvtt.f32.f16 */
-+                    /*
-+                     * VCVTB, VCVTT: only present with the halfprec extension
-+                     * UNPREDICTABLE if bit 8 is set prior to ARMv8
-+                     * (we choose to UNDEF)
-                      */
--                    rm = VFP_SREG_M(insn);
--                } else {
--                    VFP_DREG_M(rm, insn);
-+                    if ((dp && !arm_dc_feature(s, ARM_FEATURE_V8)) ||
-+                        !arm_dc_feature(s, ARM_FEATURE_VFP_FP16)) {
-+                        return 1;
-+                    }
-+                    rm_is_dp = false;
-+                    break;
-+                case 0x06: /* vcvtb.f16.f32, vcvtb.f16.f64 */
-+                case 0x07: /* vcvtt.f16.f32, vcvtt.f16.f64 */
-+                    if ((dp && !arm_dc_feature(s, ARM_FEATURE_V8)) ||
-+                        !arm_dc_feature(s, ARM_FEATURE_VFP_FP16)) {
-+                        return 1;
-+                    }
-+                    rd_is_dp = false;
-+                    break;
-+
-+                case 0x08: case 0x0a: /* vcmp, vcmpz */
-+                case 0x09: case 0x0b: /* vcmpe, vcmpez */
-+                    no_output = true;
-+                    break;
-+
-+                case 0x0c: /* vrintr */
-+                case 0x0d: /* vrintz */
-+                case 0x0e: /* vrintx */
-+                    break;
-+
-+                case 0x0f: /* vcvt double<->single */
-+                    rd_is_dp = !dp;
-+                    break;
-+
-+                case 0x10: /* vcvt.fxx.u32 */
-+                case 0x11: /* vcvt.fxx.s32 */
-+                    rm_is_dp = false;
-+                    break;
-+                case 0x18: /* vcvtr.u32.fxx */
-+                case 0x19: /* vcvtz.u32.fxx */
-+                case 0x1a: /* vcvtr.s32.fxx */
-+                case 0x1b: /* vcvtz.s32.fxx */
-+                    rd_is_dp = false;
-+                    break;
-+
-+                case 0x14: /* vcvt fp <-> fixed */
-+                case 0x15:
-+                case 0x16:
-+                case 0x17:
-+                case 0x1c:
-+                case 0x1d:
-+                case 0x1e:
-+                case 0x1f:
-+                    if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
-+                        return 1;
-+                    }
-+                    /* Immediate frac_bits has same format as SREG_M.  */
-+                    rm_is_dp = false;
-+                    break;
-+
-+                default:
-+                    return 1;
-                 }
-+            } else if (dp) {
-+                /* rn is register number */
-+                VFP_DREG_N(rn, insn);
-+            }
-+
-+            if (rd_is_dp) {
-+                VFP_DREG_D(rd, insn);
-+            } else {
-+                rd = VFP_SREG_D(insn);
-+            }
-+            if (rm_is_dp) {
-+                VFP_DREG_M(rm, insn);
-             } else {
--                rn = VFP_SREG_N(insn);
--                if (op == 15 && rn == 15) {
--                    /* Double precision destination.  */
--                    VFP_DREG_D(rd, insn);
--                } else {
--                    rd = VFP_SREG_D(insn);
--                }
--                /* NB that we implicitly rely on the encoding for the frac_bits
--                 * in VCVT of fixed to float being the same as that of an SREG_M
--                 */
-                 rm = VFP_SREG_M(insn);
-             }
-             veclen = s->vec_len;
--            if (op == 15 && rn > 3)
-+            if (op == 15 && rn > 3) {
-                 veclen = 0;
-+            }
-             /* Shut up compiler warnings.  */
-             delta_m = 0;
-@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
-             /* Load the initial operands.  */
-             if (op == 15) {
-                 switch (rn) {
--                case 16:
--                case 17:
--                    /* Integer source */
--                    gen_mov_F0_vreg(0, rm);
--                    break;
--                case 8:
--                case 9:
--                    /* Compare */
-+                case 0x08: case 0x09: /* Compare */
-                     gen_mov_F0_vreg(dp, rd);
-                     gen_mov_F1_vreg(dp, rm);
-                     break;
--                case 10:
--                case 11:
--                    /* Compare with zero */
-+                case 0x0a: case 0x0b: /* Compare with zero */
-                     gen_mov_F0_vreg(dp, rd);
-                     gen_vfp_F1_ld0(dp);
-                     break;
--                case 20:
--                case 21:
--                case 22:
--                case 23:
--                case 28:
--                case 29:
--                case 30:
--                case 31:
-+                case 0x14: /* vcvt fp <-> fixed */
-+                case 0x15:
-+                case 0x16:
-+                case 0x17:
-+                case 0x1c:
-+                case 0x1d:
-+                case 0x1e:
-+                case 0x1f:
-                     /* Source and destination the same.  */
-                     gen_mov_F0_vreg(dp, rd);
-                     break;
--                case 4:
--                case 5:
--                case 6:
--                case 7:
--                    /* VCVTB, VCVTT: only present with the halfprec extension
--                     * UNPREDICTABLE if bit 8 is set prior to ARMv8
--                     * (we choose to UNDEF)
--                     */
--                    if ((dp && !arm_dc_feature(s, ARM_FEATURE_V8)) ||
--                        !arm_dc_feature(s, ARM_FEATURE_VFP_FP16)) {
--                        return 1;
--                    }
--                    if (!extract32(rn, 1, 1)) {
--                        /* Half precision source.  */
--                        gen_mov_F0_vreg(0, rm);
--                        break;
--                    }
--                    /* Otherwise fall through */
-                 default:
-                     /* One source operand.  */
--                    gen_mov_F0_vreg(dp, rm);
-+                    gen_mov_F0_vreg(rm_is_dp, rm);
-                     break;
-                 }
-             } else {
-@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
-                         break;
-                     }
-                     case 15: /* single<->double conversion */
--                        if (dp)
-+                        if (dp) {
-                             gen_helper_vfp_fcvtsd(cpu_F0s, cpu_F0d, cpu_env);
--                        else
-+                        } else {
-                             gen_helper_vfp_fcvtds(cpu_F0d, cpu_F0s, cpu_env);
-+                        }
-                         break;
-                     case 16: /* fuito */
-                         gen_vfp_uito(dp, 0);
-@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
-                         gen_vfp_sito(dp, 0);
-                         break;
-                     case 20: /* fshto */
--                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
--                            return 1;
--                        }
-                         gen_vfp_shto(dp, 16 - rm, 0);
-                         break;
-                     case 21: /* fslto */
--                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
--                            return 1;
--                        }
-                         gen_vfp_slto(dp, 32 - rm, 0);
-                         break;
-                     case 22: /* fuhto */
--                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
--                            return 1;
--                        }
-                         gen_vfp_uhto(dp, 16 - rm, 0);
-                         break;
-                     case 23: /* fulto */
--                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
--                            return 1;
--                        }
-                         gen_vfp_ulto(dp, 32 - rm, 0);
-                         break;
-                     case 24: /* ftoui */
-@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
-                         gen_vfp_tosiz(dp, 0);
-                         break;
-                     case 28: /* ftosh */
--                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
--                            return 1;
--                        }
-                         gen_vfp_tosh(dp, 16 - rm, 0);
-                         break;
-                     case 29: /* ftosl */
--                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
--                            return 1;
--                        }
-                         gen_vfp_tosl(dp, 32 - rm, 0);
-                         break;
-                     case 30: /* ftouh */
--                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
--                            return 1;
--                        }
-                         gen_vfp_touh(dp, 16 - rm, 0);
-                         break;
-                     case 31: /* ftoul */
--                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
--                            return 1;
--                        }
-                         gen_vfp_toul(dp, 32 - rm, 0);
-                         break;
-                     default: /* undefined */
--                        return 1;
-+                        g_assert_not_reached();
-                     }
-                     break;
-                 default: /* undefined */
-                     return 1;
-                 }
--                /* Write back the result.  */
--                if (op == 15 && (rn >= 8 && rn <= 11)) {
--                    /* Comparison, do nothing.  */
--                } else if (op == 15 && dp && ((rn & 0x1c) == 0x18 ||
--                                              (rn & 0x1e) == 0x6)) {
--                    /* VCVT double to int: always integer result.
--                     * VCVT double to half precision is always a single
--                     * precision result.
--                     */
--                    gen_mov_vreg_F0(0, rd);
--                } else if (op == 15 && rn == 15) {
--                    /* conversion */
--                    gen_mov_vreg_F0(!dp, rd);
--                } else {
--                    gen_mov_vreg_F0(dp, rd);
-+                /* Write back the result, if any.  */
-+                if (!no_output) {
-+                    gen_mov_vreg_F0(rd_is_dp, rd);
-                 }
-                 /* break out of the loop if we have finished  */
--                if (veclen == 0)
-+                if (veclen == 0) {
-                     break;
-+                }
-                 if (op == 15 && delta_m == 0) {
-                     /* single source one-many */
---
-.20.1

-[Qemu-devel] [PULL 10/21] hw/timer/pl031: Convert to using trace events
+Deleted patch
-Convert the debug printing in the PL031 device to use trace events,
-and augment it to cover the interesting parts of device operation.
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
----
- hw/timer/pl031.c      | 55 +++++++++++++++++++++++--------------------
- hw/timer/trace-events |  6 +++++
-files changed, 36 insertions(+), 25 deletions(-)
-diff --git a/hw/timer/pl031.c b/hw/timer/pl031.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/timer/pl031.c
-+++ b/hw/timer/pl031.c
-@@ -XXX,XX +XXX,XX @@
- #include "sysemu/sysemu.h"
- #include "qemu/cutils.h"
- #include "qemu/log.h"
--
--//#define DEBUG_PL031
--
--#ifdef DEBUG_PL031
--#define DPRINTF(fmt, ...) \
--do { printf("pl031: " fmt , ## __VA_ARGS__); } while (0)
--#else
--#define DPRINTF(fmt, ...) do {} while(0)
--#endif
-+#include "trace.h"
- #define RTC_DR      0x00    /* Data read register */
- #define RTC_MR      0x04    /* Match register */
-@@ -XXX,XX +XXX,XX @@ static const unsigned char pl031_id[] = {
- static void pl031_update(PL031State *s)
- {
--    qemu_set_irq(s->irq, s->is & s->im);
-+    uint32_t flags = s->is & s->im;
-+
-+    trace_pl031_irq_state(flags);
-+    qemu_set_irq(s->irq, flags);
- }
- static void pl031_interrupt(void * opaque)
-@@ -XXX,XX +XXX,XX @@ static void pl031_interrupt(void * opaque)
-     PL031State *s = (PL031State *)opaque;
-     s->is = 1;
--    DPRINTF("Alarm raised\n");
-+    trace_pl031_alarm_raised();
-     pl031_update(s);
- }
-@@ -XXX,XX +XXX,XX @@ static void pl031_set_alarm(PL031State *s)
-     /* The timer wraps around.  This subtraction also wraps in the same way,
-        and gives correct results when alarm < now_ticks.  */
-     ticks = s->mr - pl031_get_count(s);
--    DPRINTF("Alarm set in %ud ticks\n", ticks);
-+    trace_pl031_set_alarm(ticks);
-     if (ticks == 0) {
-         timer_del(s->timer);
-         pl031_interrupt(s);
-@@ -XXX,XX +XXX,XX @@ static uint64_t pl031_read(void *opaque, hwaddr offset,
-                            unsigned size)
- {
-     PL031State *s = (PL031State *)opaque;
--
--    if (offset >= 0xfe0  &&  offset < 0x1000)
--        return pl031_id[(offset - 0xfe0) >> 2];
-+    uint64_t r;
-     switch (offset) {
-     case RTC_DR:
--        return pl031_get_count(s);
-+        r = pl031_get_count(s);
-+        break;
-     case RTC_MR:
--        return s->mr;
-+        r = s->mr;
-+        break;
-     case RTC_IMSC:
--        return s->im;
-+        r = s->im;
-+        break;
-     case RTC_RIS:
--        return s->is;
-+        r = s->is;
-+        break;
-     case RTC_LR:
--        return s->lr;
-+        r = s->lr;
-+        break;
-     case RTC_CR:
-         /* RTC is permanently enabled.  */
--        return 1;
-+        r = 1;
-+        break;
-     case RTC_MIS:
--        return s->is & s->im;
-+        r = s->is & s->im;
-+        break;
-+    case 0xfe0 ... 0xfff:
-+        r = pl031_id[(offset - 0xfe0) >> 2];
-+        break;
-     case RTC_ICR:
-         qemu_log_mask(LOG_GUEST_ERROR,
-                       "pl031: read of write-only register at offset 0x%x\n",
-                       (int)offset);
-+        r = 0;
-         break;
-     default:
-         qemu_log_mask(LOG_GUEST_ERROR,
-                       "pl031_read: Bad offset 0x%x\n", (int)offset);
-+        r = 0;
-         break;
-     }
--    return 0;
-+    trace_pl031_read(offset, r);
-+    return r;
- }
- static void pl031_write(void * opaque, hwaddr offset,
-@@ -XXX,XX +XXX,XX @@ static void pl031_write(void * opaque, hwaddr offset,
- {
-     PL031State *s = (PL031State *)opaque;
-+    trace_pl031_write(offset, value);
-     switch (offset) {
-     case RTC_LR:
-@@ -XXX,XX +XXX,XX @@ static void pl031_write(void * opaque, hwaddr offset,
-         break;
-     case RTC_IMSC:
-         s->im = value & 1;
--        DPRINTF("Interrupt mask %d\n", s->im);
-         pl031_update(s);
-         break;
-     case RTC_ICR:
-@@ -XXX,XX +XXX,XX @@ static void pl031_write(void * opaque, hwaddr offset,
-            cleared when bit 0 of the written value is set.  However the
-            arm926e documentation (DDI0287B) states that the interrupt is
-            cleared when any value is written.  */
--        DPRINTF("Interrupt cleared");
-         s->is = 0;
-         pl031_update(s);
-         break;
-diff --git a/hw/timer/trace-events b/hw/timer/trace-events
-index XXXXXXX..XXXXXXX 100644
---- a/hw/timer/trace-events
-+++ b/hw/timer/trace-events
-@@ -XXX,XX +XXX,XX @@ xlnx_zynqmp_rtc_gettime(int year, int month, int day, int hour, int min, int sec
- nrf51_timer_read(uint64_t addr, uint32_t value, unsigned size) "read addr 0x%" PRIx64 " data 0x%" PRIx32 " size %u"
- nrf51_timer_write(uint64_t addr, uint32_t value, unsigned size) "write addr 0x%" PRIx64 " data 0x%" PRIx32 " size %u"
-+# hw/timer/pl031.c
-+pl031_irq_state(int level) "irq state %d"
-+pl031_read(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x"
-+pl031_write(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x"
-+pl031_alarm_raised(void) "alarm raised"
-+pl031_set_alarm(uint32_t ticks) "alarm set for %u ticks"
---
-.20.1

-[Qemu-devel] [PULL 11/21] hw/char/pl011: Allow use as an embedded-struct device
+Deleted patch
-Create a new include file for the pl011's device struct,
-type macros, etc, so that it can be instantiated using
-the "embedded struct" coding style.
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
----
- include/hw/char/pl011.h | 34 ++++++++++++++++++++++++++++++++++
- hw/char/pl011.c         | 31 ++-----------------------------
-files changed, 36 insertions(+), 29 deletions(-)
-diff --git a/include/hw/char/pl011.h b/include/hw/char/pl011.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/hw/char/pl011.h
-+++ b/include/hw/char/pl011.h
-@@ -XXX,XX +XXX,XX @@
- #ifndef HW_PL011_H
- #define HW_PL011_H
-+#include "hw/sysbus.h"
-+#include "chardev/char-fe.h"
-+
-+#define TYPE_PL011 "pl011"
-+#define PL011(obj) OBJECT_CHECK(PL011State, (obj), TYPE_PL011)
-+
-+/* This shares the same struct (and cast macro) as the base pl011 device */
-+#define TYPE_PL011_LUMINARY "pl011_luminary"
-+
-+typedef struct PL011State {
-+    SysBusDevice parent_obj;
-+
-+    MemoryRegion iomem;
-+    uint32_t readbuff;
-+    uint32_t flags;
-+    uint32_t lcr;
-+    uint32_t rsr;
-+    uint32_t cr;
-+    uint32_t dmacr;
-+    uint32_t int_enabled;
-+    uint32_t int_level;
-+    uint32_t read_fifo[16];
-+    uint32_t ilpr;
-+    uint32_t ibrd;
-+    uint32_t fbrd;
-+    uint32_t ifl;
-+    int read_pos;
-+    int read_count;
-+    int read_trigger;
-+    CharBackend chr;
-+    qemu_irq irq;
-+    const unsigned char *id;
-+} PL011State;
-+
- static inline DeviceState *pl011_create(hwaddr addr,
-                                         qemu_irq irq,
-                                         Chardev *chr)
-diff --git a/hw/char/pl011.c b/hw/char/pl011.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/char/pl011.c
-+++ b/hw/char/pl011.c
-@@ -XXX,XX +XXX,XX @@
-  */
- #include "qemu/osdep.h"
-+#include "hw/char/pl011.h"
- #include "hw/sysbus.h"
- #include "chardev/char-fe.h"
- #include "qemu/log.h"
- #include "trace.h"
--#define TYPE_PL011 "pl011"
--#define PL011(obj) OBJECT_CHECK(PL011State, (obj), TYPE_PL011)
--
--typedef struct PL011State {
--    SysBusDevice parent_obj;
--
--    MemoryRegion iomem;
--    uint32_t readbuff;
--    uint32_t flags;
--    uint32_t lcr;
--    uint32_t rsr;
--    uint32_t cr;
--    uint32_t dmacr;
--    uint32_t int_enabled;
--    uint32_t int_level;
--    uint32_t read_fifo[16];
--    uint32_t ilpr;
--    uint32_t ibrd;
--    uint32_t fbrd;
--    uint32_t ifl;
--    int read_pos;
--    int read_count;
--    int read_trigger;
--    CharBackend chr;
--    qemu_irq irq;
--    const unsigned char *id;
--} PL011State;
--
- #define PL011_INT_TX 0x20
- #define PL011_INT_RX 0x10
-@@ -XXX,XX +XXX,XX @@ static void pl011_luminary_init(Object *obj)
- }
- static const TypeInfo pl011_luminary_info = {
--    .name          = "pl011_luminary",
-+    .name          = TYPE_PL011_LUMINARY,
-     .parent        = TYPE_PL011,
-     .instance_init = pl011_luminary_init,
- };
---
-.20.1

-[Qemu-devel] [PULL 12/21] hw/char/pl011: Support all interrupt lines
+Deleted patch
-The PL011 UART has six interrupt lines:
- * RX (receive data)
- * TX (transmit data)
- * RT (receive timeout)
- * MS (modem status)
- * E (errors)
- * combined (logical OR of all the above)
-So far we have only emulated the combined interrupt line;
-add support for the others, so that boards that wire them
-up to different interrupt controller inputs can do so.
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
----
- include/hw/char/pl011.h |  2 +-
- hw/char/pl011.c         | 46 +++++++++++++++++++++++++++++++++++++++--
-files changed, 45 insertions(+), 3 deletions(-)
-diff --git a/include/hw/char/pl011.h b/include/hw/char/pl011.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/hw/char/pl011.h
-+++ b/include/hw/char/pl011.h
-@@ -XXX,XX +XXX,XX @@ typedef struct PL011State {
-     int read_count;
-     int read_trigger;
-     CharBackend chr;
--    qemu_irq irq;
-+    qemu_irq irq[6];
-     const unsigned char *id;
- } PL011State;
-diff --git a/hw/char/pl011.c b/hw/char/pl011.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/char/pl011.c
-+++ b/hw/char/pl011.c
-@@ -XXX,XX +XXX,XX @@
-  * This code is licensed under the GPL.
-  */
-+/*
-+ * QEMU interface:
-+ *  + sysbus MMIO region 0: device registers
-+ *  + sysbus IRQ 0: UARTINTR (combined interrupt line)
-+ *  + sysbus IRQ 1: UARTRXINTR (receive FIFO interrupt line)
-+ *  + sysbus IRQ 2: UARTTXINTR (transmit FIFO interrupt line)
-+ *  + sysbus IRQ 3: UARTRTINTR (receive timeout interrupt line)
-+ *  + sysbus IRQ 4: UARTMSINTR (momem status interrupt line)
-+ *  + sysbus IRQ 5: UARTEINTR (error interrupt line)
-+ */
-+
- #include "qemu/osdep.h"
- #include "hw/char/pl011.h"
- #include "hw/sysbus.h"
-@@ -XXX,XX +XXX,XX @@
- #define PL011_FLAG_TXFF 0x20
- #define PL011_FLAG_RXFE 0x10
-+/* Interrupt status bits in UARTRIS, UARTMIS, UARTIMSC */
-+#define INT_OE (1 << 10)
-+#define INT_BE (1 << 9)
-+#define INT_PE (1 << 8)
-+#define INT_FE (1 << 7)
-+#define INT_RT (1 << 6)
-+#define INT_TX (1 << 5)
-+#define INT_RX (1 << 4)
-+#define INT_DSR (1 << 3)
-+#define INT_DCD (1 << 2)
-+#define INT_CTS (1 << 1)
-+#define INT_RI (1 << 0)
-+#define INT_E (INT_OE | INT_BE | INT_PE | INT_FE)
-+#define INT_MS (INT_RI | INT_DSR | INT_DCD | INT_CTS)
-+
- static const unsigned char pl011_id_arm[8] =
-   { 0x11, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1 };
- static const unsigned char pl011_id_luminary[8] =
-   { 0x11, 0x00, 0x18, 0x01, 0x0d, 0xf0, 0x05, 0xb1 };
-+/* Which bits in the interrupt status matter for each outbound IRQ line ? */
-+static const uint32_t irqmask[] = {
-+    INT_E | INT_MS | INT_RT | INT_TX | INT_RX, /* combined IRQ */
-+    INT_RX,
-+    INT_TX,
-+    INT_RT,
-+    INT_MS,
-+    INT_E,
-+};
-+
- static void pl011_update(PL011State *s)
- {
-     uint32_t flags;
-+    int i;
-     flags = s->int_level & s->int_enabled;
-     trace_pl011_irq_state(flags != 0);
--    qemu_set_irq(s->irq, flags != 0);
-+    for (i = 0; i < ARRAY_SIZE(s->irq); i++) {
-+        qemu_set_irq(s->irq[i], (flags & irqmask[i]) != 0);
-+    }
- }
- static uint64_t pl011_read(void *opaque, hwaddr offset,
-@@ -XXX,XX +XXX,XX @@ static void pl011_init(Object *obj)
- {
-     SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
-     PL011State *s = PL011(obj);
-+    int i;
-     memory_region_init_io(&s->iomem, OBJECT(s), &pl011_ops, s, "pl011", 0x1000);
-     sysbus_init_mmio(sbd, &s->iomem);
--    sysbus_init_irq(sbd, &s->irq);
-+    for (i = 0; i < ARRAY_SIZE(s->irq); i++) {
-+        sysbus_init_irq(sbd, &s->irq[i]);
-+    }
-     s->read_trigger = 1;
-     s->ifl = 0x12;
---
-.20.1

-[Qemu-devel] [PULL 14/21] hw/arm/armsse: Document SRAM_ADDR_WIDTH property in header comment
+Deleted patch
-In commit 4b635cf7a95e501211 we added a QOM property to the ARMSSE
-object, but forgot to add it to the documentation comment in the
-header. Correct the omission.
-Fixes: 4b635cf7a95e501211 ("hw/arm/armsse: Make SRAM bank size configurable")
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
----
- include/hw/arm/armsse.h | 2 ++
-file changed, 2 insertions(+)
-diff --git a/include/hw/arm/armsse.h b/include/hw/arm/armsse.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/hw/arm/armsse.h
-+++ b/include/hw/arm/armsse.h
-@@ -XXX,XX +XXX,XX @@
-  *    being the same for both, to avoid having to have separate Property
-  *    lists for different variants. This restriction can be relaxed later
-  *    if necessary.)
-+ *  + QOM property "SRAM_ADDR_WIDTH" sets the number of bits used for the
-+ *    address of each SRAM bank (and thus the total amount of internal SRAM)
-  *  + Named GPIO inputs "EXP_IRQ" 0..n are the expansion interrupts for CPU 0,
-  *    which are wired to its NVIC lines 32 .. n+32
-  *  + Named GPIO inputs "EXP_CPU1_IRQ" 0..n are the expansion interrupts for
---
-.20.1

-[Qemu-devel] [PULL 15/21] hw/arm/armsse: Allow boards to specify init-svtor
+Deleted patch
-The Musca boards have DAPLink firmware that sets the initial
-secure VTOR value (the location of the vector table) differently
-depending on the boot mode (from flash, from RAM, etc). Export
-the init-svtor as a QOM property of the ARMSSE object so that
-the board can change it.
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
----
- include/hw/arm/armsse.h | 3 +++
- hw/arm/armsse.c         | 8 ++++----
-files changed, 7 insertions(+), 4 deletions(-)
-diff --git a/include/hw/arm/armsse.h b/include/hw/arm/armsse.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/hw/arm/armsse.h
-+++ b/include/hw/arm/armsse.h
-@@ -XXX,XX +XXX,XX @@
-  *    if necessary.)
-  *  + QOM property "SRAM_ADDR_WIDTH" sets the number of bits used for the
-  *    address of each SRAM bank (and thus the total amount of internal SRAM)
-+ *  + QOM property "init-svtor" sets the initial value of the CPU SVTOR register
-+ *    (where it expects to load the PC and SP from the vector table on reset)
-  *  + Named GPIO inputs "EXP_IRQ" 0..n are the expansion interrupts for CPU 0,
-  *    which are wired to its NVIC lines 32 .. n+32
-  *  + Named GPIO inputs "EXP_CPU1_IRQ" 0..n are the expansion interrupts for
-@@ -XXX,XX +XXX,XX @@ typedef struct ARMSSE {
-     uint32_t exp_numirq;
-     uint32_t mainclk_frq;
-     uint32_t sram_addr_width;
-+    uint32_t init_svtor;
- } ARMSSE;
- typedef struct ARMSSEInfo ARMSSEInfo;
-diff --git a/hw/arm/armsse.c b/hw/arm/armsse.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/arm/armsse.c
-+++ b/hw/arm/armsse.c
-@@ -XXX,XX +XXX,XX @@ static void armsse_realize(DeviceState *dev, Error **errp)
-          * the INITSVTOR* registers before powering up the CPUs in any case,
-          * so the hardware's default value doesn't matter. QEMU doesn't emulate
-          * the control processor, so instead we behave in the way that the
--         * firmware does. All boards currently known about have firmware that
--         * sets the INITSVTOR0 and INITSVTOR1 registers to 0x10000000, like the
--         * IoTKit default. We can make this more configurable if necessary.
-+         * firmware does. The initial value is configurable by the board code
-+         * to match whatever its firmware does.
-          */
--        qdev_prop_set_uint32(cpudev, "init-svtor", 0x10000000);
-+        qdev_prop_set_uint32(cpudev, "init-svtor", s->init_svtor);
-         /*
-          * Start all CPUs except CPU0 powered down. In real hardware it is
-          * a configurable property of the SSE-200 which CPUs start powered up
-@@ -XXX,XX +XXX,XX @@ static Property armsse_properties[] = {
-     DEFINE_PROP_UINT32("EXP_NUMIRQ", ARMSSE, exp_numirq, 64),
-     DEFINE_PROP_UINT32("MAINCLK", ARMSSE, mainclk_frq, 0),
-     DEFINE_PROP_UINT32("SRAM_ADDR_WIDTH", ARMSSE, sram_addr_width, 15),
-+    DEFINE_PROP_UINT32("init-svtor", ARMSSE, init_svtor, 0x10000000),
-     DEFINE_PROP_END_OF_LIST()
- };
---
-.20.1

-[Qemu-devel] [PULL 16/21] hw/arm/musca.c: Implement models of the Musca-A and -B1 boards
+[Qemu-devel] [PULL 10/10] hw/arm: versal: Add a virtual Xilinx Versal board
-The Musca-A and Musca-B1 development boards are based on the
+From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com>
 SSE-200 subsystem for embedded. Implement an initial skeleton
 model of these boards, which are similar but not identical.
-This commit creates the board model with the SSE and the IRQ
+Add a virtual Xilinx Versal board.
 splitters to wire IRQs up to its two CPUs. As yet there
 are no devices and no memory: these will be added later.
+This board is based on the Xilinx Versal SoC. The exact
+details of what peripherals are attached to this board
+will remain in control of QEMU. QEMU will generate an
+FDT on the fly for Linux and other software to auto-discover
+peripherals.
+Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com>
+Message-id: 20181102131913.1535-3-edgar.iglesias@xilinx.com
+Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
 Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
 ---
- hw/arm/Makefile.objs            |   1 +
+ hw/arm/Makefile.objs      |   2 +-
- hw/arm/musca.c                  | 197 ++++++++++++++++++++++++++++++++
+ hw/arm/xlnx-versal-virt.c | 494 ++++++++++++++++++++++++++++++++++++++
- MAINTAINERS                     |   6 +
+files changed, 495 insertions(+), 1 deletion(-)
- default-configs/arm-softmmu.mak |   1 +
+ create mode 100644 hw/arm/xlnx-versal-virt.c
 files changed, 205 insertions(+)
  create mode 100644 hw/arm/musca.c
 diff --git a/hw/arm/Makefile.objs b/hw/arm/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/arm/Makefile.objs
 +++ b/hw/arm/Makefile.objs
-@@ -XXX,XX +XXX,XX @@ obj-$(CONFIG_ASPEED_SOC) += aspeed_soc.o aspeed.o
+@@ -XXX,XX +XXX,XX @@ obj-$(CONFIG_ALLWINNER_A10) += allwinner-a10.o cubieboard.o
- obj-$(CONFIG_MPS2) += mps2.o
+ obj-$(CONFIG_RASPI) += bcm2835_peripherals.o bcm2836.o raspi.o
- obj-$(CONFIG_MPS2) += mps2-tz.o
+ obj-$(CONFIG_STM32F205_SOC) += stm32f205_soc.o
- obj-$(CONFIG_MSF2) += msf2-soc.o msf2-som.o
+ obj-$(CONFIG_XLNX_ZYNQMP_ARM) += xlnx-zynqmp.o xlnx-zcu102.o
-+obj-$(CONFIG_MUSCA) += musca.o
+-obj-$(CONFIG_XLNX_VERSAL) += xlnx-versal.o
- obj-$(CONFIG_ARMSSE) += armsse.o
++obj-$(CONFIG_XLNX_VERSAL) += xlnx-versal.o xlnx-versal-virt.o
- obj-$(CONFIG_FSL_IMX7) += fsl-imx7.o mcimx7d-sabre.o
+ obj-$(CONFIG_FSL_IMX25) += fsl-imx25.o imx25_pdk.o
- obj-$(CONFIG_ARM_SMMUV3) += smmu-common.o smmuv3.o
+ obj-$(CONFIG_FSL_IMX31) += fsl-imx31.o kzm.o
-diff --git a/hw/arm/musca.c b/hw/arm/musca.c
+ obj-$(CONFIG_FSL_IMX6) += fsl-imx6.o sabrelite.o
 diff --git a/hw/arm/xlnx-versal-virt.c b/hw/arm/xlnx-versal-virt.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/hw/arm/musca.c
++++ b/hw/arm/xlnx-versal-virt.c
 @@ -XXX,XX +XXX,XX @@
 +/*
-+ * Arm Musca-B1 test chip board emulation
++ * Xilinx Versal Virtual board.
 + *
-+ * Copyright (c) 2019 Linaro Limited
++ * Copyright (c) 2018 Xilinx Inc.
-+ * Written by Peter Maydell
++ * Written by Edgar E. Iglesias
 + *
-+ *  This program is free software; you can redistribute it and/or modify
++ * This program is free software; you can redistribute it and/or modify
-+ *  it under the terms of the GNU General Public License version 2 or
++ * it under the terms of the GNU General Public License version 2 or
-+ *  (at your option) any later version.
++ * (at your option) any later version.
 + */
 +
-+/*
-+ * The Musca boards are a reference implementation of a system using
-+ * the SSE-200 subsystem for embedded:
-+ * https://developer.arm.com/products/system-design/development-boards/iot-test-chips-and-boards/musca-a-test-chip-board
-+ * https://developer.arm.com/products/system-design/development-boards/iot-test-chips-and-boards/musca-b-test-chip-board
-+ * We model the A and B1 variants of this board, as described in the TRMs:
-+ * http://infocenter.arm.com/help/topic/com.arm.doc.101107_0000_00_en/index.html
-+ * http://infocenter.arm.com/help/topic/com.arm.doc.101312_0000_00_en/index.html
-+ */
-+
 +#include "qemu/osdep.h"
++#include "qemu/log.h"
 +#include "qemu/error-report.h"
 +#include "qapi/error.h"
++#include "sysemu/device_tree.h"
 +#include "exec/address-spaces.h"
-+#include "hw/arm/arm.h"
-+#include "hw/arm/armsse.h"
 +#include "hw/boards.h"
-+#include "hw/core/split-irq.h"
++#include "hw/sysbus.h"
-+
++#include "hw/arm/sysbus-fdt.h"
-+#define MUSCA_NUMIRQ_MAX 96
++#include "hw/arm/fdt.h"
-+
++#include "cpu.h"
-+typedef enum MuscaType {
++#include "hw/arm/xlnx-versal.h"
-+    MUSCA_A,
++
-+    MUSCA_B1,
++#define TYPE_XLNX_VERSAL_VIRT_MACHINE MACHINE_TYPE_NAME("xlnx-versal-virt")
-+} MuscaType;
++#define XLNX_VERSAL_VIRT_MACHINE(obj) \
-+
++    OBJECT_CHECK(VersalVirt, (obj), TYPE_XLNX_VERSAL_VIRT_MACHINE)
-+typedef struct {
++
-+    MachineClass parent;
++typedef struct VersalVirt {
-+    MuscaType type;
++    MachineState parent_obj;
-+    uint32_t init_svtor;
++
-+    int sram_addr_width;
++    Versal soc;
-+    int num_irqs;
++    MemoryRegion mr_ddr;
-+} MuscaMachineClass;
++
-+
++    void *fdt;
-+typedef struct {
++    int fdt_size;
-+    MachineState parent;
++    struct {
-+
++        uint32_t gic;
-+    ARMSSE sse;
++        uint32_t ethernet_phy[2];
-+    SplitIRQ cpu_irq_splitter[MUSCA_NUMIRQ_MAX];
++        uint32_t clk_125Mhz;
-+} MuscaMachineState;
++        uint32_t clk_25Mhz;
-+
++    } phandle;
-+#define TYPE_MUSCA_MACHINE "musca"
++    struct arm_boot_info binfo;
-+#define TYPE_MUSCA_A_MACHINE MACHINE_TYPE_NAME("musca-a")
++
-+#define TYPE_MUSCA_B1_MACHINE MACHINE_TYPE_NAME("musca-b1")
++    struct {
-+
++        bool secure;
-+#define MUSCA_MACHINE(obj) \
++    } cfg;
-+    OBJECT_CHECK(MuscaMachineState, obj, TYPE_MUSCA_MACHINE)
++} VersalVirt;
-+#define MUSCA_MACHINE_GET_CLASS(obj) \
++
-+    OBJECT_GET_CLASS(MuscaMachineClass, obj, TYPE_MUSCA_MACHINE)
++static void fdt_create(VersalVirt *s)
-+#define MUSCA_MACHINE_CLASS(klass) \
++{
-+    OBJECT_CLASS_CHECK(MuscaMachineClass, klass, TYPE_MUSCA_MACHINE)
++    MachineClass *mc = MACHINE_GET_CLASS(s);
 +
 +/*
 + * Main SYSCLK frequency in Hz
 + * TODO this should really be different for the two cores, but we
 + * don't model that in our SSE-200 model yet.
 + */
 +#define SYSCLK_FRQ 40000000
 +
 +static void musca_init(MachineState *machine)
 +{
 +    MuscaMachineState *mms = MUSCA_MACHINE(machine);
 +    MuscaMachineClass *mmc = MUSCA_MACHINE_GET_CLASS(mms);
 +    MachineClass *mc = MACHINE_GET_CLASS(machine);
 +    MemoryRegion *system_memory = get_system_memory();
 +    DeviceState *ssedev;
 +    int i;
 +
-+    assert(mmc->num_irqs <= MUSCA_NUMIRQ_MAX);
++    s->fdt = create_device_tree(&s->fdt_size);
-+
++    if (!s->fdt) {
-+    if (strcmp(machine->cpu_type, mc->default_cpu_type) != 0) {
++        error_report("create_device_tree() failed");
 +        error_report("This board can only be used with CPU %s",
 +                     mc->default_cpu_type);
 +        exit(1);
 +    }
 +
-+    sysbus_init_child_obj(OBJECT(machine), "sse-200", &mms->sse,
++    /* Allocate all phandles.  */
-+                          sizeof(mms->sse), TYPE_SSE200);
++    s->phandle.gic = qemu_fdt_alloc_phandle(s->fdt);
-+    ssedev = DEVICE(&mms->sse);
++    for (i = 0; i < ARRAY_SIZE(s->phandle.ethernet_phy); i++) {
-+    object_property_set_link(OBJECT(&mms->sse), OBJECT(system_memory),
++        s->phandle.ethernet_phy[i] = qemu_fdt_alloc_phandle(s->fdt);
-+                             "memory", &error_fatal);
++    }
-+    qdev_prop_set_uint32(ssedev, "EXP_NUMIRQ", mmc->num_irqs);
++    s->phandle.clk_25Mhz = qemu_fdt_alloc_phandle(s->fdt);
-+    qdev_prop_set_uint32(ssedev, "init-svtor", mmc->init_svtor);
++    s->phandle.clk_125Mhz = qemu_fdt_alloc_phandle(s->fdt);
-+    qdev_prop_set_uint32(ssedev, "SRAM_ADDR_WIDTH", mmc->sram_addr_width);
++
-+    qdev_prop_set_uint32(ssedev, "MAINCLK", SYSCLK_FRQ);
++    /* Create /chosen node for load_dtb.  */
-+    object_property_set_bool(OBJECT(&mms->sse), true, "realized",
++    qemu_fdt_add_subnode(s->fdt, "/chosen");
-+                             &error_fatal);
++
 +    /* Header */
 +    qemu_fdt_setprop_cell(s->fdt, "/", "interrupt-parent", s->phandle.gic);
 +    qemu_fdt_setprop_cell(s->fdt, "/", "#size-cells", 0x2);
 +    qemu_fdt_setprop_cell(s->fdt, "/", "#address-cells", 0x2);
 +    qemu_fdt_setprop_string(s->fdt, "/", "model", mc->desc);
 +    qemu_fdt_setprop_string(s->fdt, "/", "compatible", "xlnx-versal-virt");
 +}
 +
 +static void fdt_add_clk_node(VersalVirt *s, const char *name,
 +                             unsigned int freq_hz, uint32_t phandle)
 +{
 +    qemu_fdt_add_subnode(s->fdt, name);
 +    qemu_fdt_setprop_cell(s->fdt, name, "phandle", phandle);
 +    qemu_fdt_setprop_cell(s->fdt, name, "clock-frequency", freq_hz);
 +    qemu_fdt_setprop_cell(s->fdt, name, "#clock-cells", 0x0);
 +    qemu_fdt_setprop_string(s->fdt, name, "compatible", "fixed-clock");
 +    qemu_fdt_setprop(s->fdt, name, "u-boot,dm-pre-reloc", NULL, 0);
 +}
 +
 +static void fdt_add_cpu_nodes(VersalVirt *s, uint32_t psci_conduit)
 +{
 +    int i;
 +
 +    qemu_fdt_add_subnode(s->fdt, "/cpus");
 +    qemu_fdt_setprop_cell(s->fdt, "/cpus", "#size-cells", 0x0);
 +    qemu_fdt_setprop_cell(s->fdt, "/cpus", "#address-cells", 1);
 +
 +    for (i = XLNX_VERSAL_NR_ACPUS - 1; i >= 0; i--) {
 +        char *name = g_strdup_printf("/cpus/cpu@%d", i);
 +        ARMCPU *armcpu = ARM_CPU(qemu_get_cpu(i));
 +
 +        qemu_fdt_add_subnode(s->fdt, name);
 +        qemu_fdt_setprop_cell(s->fdt, name, "reg", armcpu->mp_affinity);
 +        if (psci_conduit != QEMU_PSCI_CONDUIT_DISABLED) {
 +            qemu_fdt_setprop_string(s->fdt, name, "enable-method", "psci");
 +        }
 +        qemu_fdt_setprop_string(s->fdt, name, "device_type", "cpu");
 +        qemu_fdt_setprop_string(s->fdt, name, "compatible",
 +                                armcpu->dtb_compatible);
 +        g_free(name);
 +    }
 +}
 +
 +static void fdt_add_gic_nodes(VersalVirt *s)
 +{
 +    char *nodename;
 +
 +    nodename = g_strdup_printf("/gic@%x", MM_GIC_APU_DIST_MAIN);
 +    qemu_fdt_add_subnode(s->fdt, nodename);
 +    qemu_fdt_setprop_cell(s->fdt, nodename, "phandle", s->phandle.gic);
 +    qemu_fdt_setprop_cells(s->fdt, nodename, "interrupts",
 +                           GIC_FDT_IRQ_TYPE_PPI, VERSAL_GIC_MAINT_IRQ,
 +                           GIC_FDT_IRQ_FLAGS_LEVEL_HI);
 +    qemu_fdt_setprop(s->fdt, nodename, "interrupt-controller", NULL, 0);
 +    qemu_fdt_setprop_sized_cells(s->fdt, nodename, "reg",
 +                                 2, MM_GIC_APU_DIST_MAIN,
 +                                 2, MM_GIC_APU_DIST_MAIN_SIZE,
 +                                 2, MM_GIC_APU_REDIST_0,
 +                                 2, MM_GIC_APU_REDIST_0_SIZE);
 +    qemu_fdt_setprop_cell(s->fdt, nodename, "#interrupt-cells", 3);
 +    qemu_fdt_setprop_string(s->fdt, nodename, "compatible", "arm,gic-v3");
 +}
 +
 +static void fdt_add_timer_nodes(VersalVirt *s)
 +{
 +    const char compat[] = "arm,armv8-timer";
 +    uint32_t irqflags = GIC_FDT_IRQ_FLAGS_LEVEL_HI;
 +
 +    qemu_fdt_add_subnode(s->fdt, "/timer");
 +    qemu_fdt_setprop_cells(s->fdt, "/timer", "interrupts",
 +            GIC_FDT_IRQ_TYPE_PPI, VERSAL_TIMER_S_EL1_IRQ, irqflags,
 +            GIC_FDT_IRQ_TYPE_PPI, VERSAL_TIMER_NS_EL1_IRQ, irqflags,
 +            GIC_FDT_IRQ_TYPE_PPI, VERSAL_TIMER_VIRT_IRQ, irqflags,
 +            GIC_FDT_IRQ_TYPE_PPI, VERSAL_TIMER_NS_EL2_IRQ, irqflags);
 +    qemu_fdt_setprop(s->fdt, "/timer", "compatible",
 +                     compat, sizeof(compat));
 +}
 +
 +static void fdt_add_uart_nodes(VersalVirt *s)
 +{
 +    uint64_t addrs[] = { MM_UART1, MM_UART0 };
 +    unsigned int irqs[] = { VERSAL_UART1_IRQ_0, VERSAL_UART0_IRQ_0 };
 +    const char compat[] = "arm,pl011\0arm,sbsa-uart";
 +    const char clocknames[] = "uartclk\0apb_pclk";
 +    int i;
 +
 +    for (i = 0; i < ARRAY_SIZE(addrs); i++) {
 +        char *name = g_strdup_printf("/uart@%" PRIx64, addrs[i]);
 +        qemu_fdt_add_subnode(s->fdt, name);
 +        qemu_fdt_setprop_cell(s->fdt, name, "current-speed", 115200);
 +        qemu_fdt_setprop_cells(s->fdt, name, "clocks",
 +                               s->phandle.clk_125Mhz, s->phandle.clk_125Mhz);
 +        qemu_fdt_setprop(s->fdt, name, "clock-names",
 +                         clocknames, sizeof(clocknames));
 +
 +        qemu_fdt_setprop_cells(s->fdt, name, "interrupts",
 +                               GIC_FDT_IRQ_TYPE_SPI, irqs[i],
 +                               GIC_FDT_IRQ_FLAGS_LEVEL_HI);
 +        qemu_fdt_setprop_sized_cells(s->fdt, name, "reg",
 +                                     2, addrs[i], 2, 0x1000);
 +        qemu_fdt_setprop(s->fdt, name, "compatible",
 +                         compat, sizeof(compat));
 +        qemu_fdt_setprop(s->fdt, name, "u-boot,dm-pre-reloc", NULL, 0);
 +
 +        if (addrs[i] == MM_UART0) {
 +            /* Select UART0.  */
 +            qemu_fdt_setprop_string(s->fdt, "/chosen", "stdout-path", name);
 +        }
 +        g_free(name);
 +    }
 +}
 +
 +static void fdt_add_fixed_link_nodes(VersalVirt *s, char *gemname,
 +                                     uint32_t phandle)
 +{
 +    char *name = g_strdup_printf("%s/fixed-link", gemname);
 +
 +    qemu_fdt_add_subnode(s->fdt, name);
 +    qemu_fdt_setprop_cell(s->fdt, name, "phandle", phandle);
 +    qemu_fdt_setprop(s->fdt, name, "full-duplex", NULL, 0);
 +    qemu_fdt_setprop_cell(s->fdt, name, "speed", 1000);
 +    g_free(name);
 +}
 +
 +static void fdt_add_gem_nodes(VersalVirt *s)
 +{
 +    uint64_t addrs[] = { MM_GEM1, MM_GEM0 };
 +    unsigned int irqs[] = { VERSAL_GEM1_IRQ_0, VERSAL_GEM0_IRQ_0 };
 +    const char clocknames[] = "pclk\0hclk\0tx_clk\0rx_clk";
 +    const char compat_gem[] = "cdns,zynqmp-gem\0cdns,gem";
 +    int i;
 +
 +    for (i = 0; i < ARRAY_SIZE(addrs); i++) {
 +        char *name = g_strdup_printf("/ethernet@%" PRIx64, addrs[i]);
 +        qemu_fdt_add_subnode(s->fdt, name);
 +
 +        fdt_add_fixed_link_nodes(s, name, s->phandle.ethernet_phy[i]);
 +        qemu_fdt_setprop_string(s->fdt, name, "phy-mode", "rgmii-id");
 +        qemu_fdt_setprop_cell(s->fdt, name, "phy-handle",
 +                              s->phandle.ethernet_phy[i]);
 +        qemu_fdt_setprop_cells(s->fdt, name, "clocks",
 +                               s->phandle.clk_25Mhz, s->phandle.clk_25Mhz,
 +                               s->phandle.clk_25Mhz, s->phandle.clk_25Mhz);
 +        qemu_fdt_setprop(s->fdt, name, "clock-names",
 +                         clocknames, sizeof(clocknames));
 +        qemu_fdt_setprop_cells(s->fdt, name, "interrupts",
 +                               GIC_FDT_IRQ_TYPE_SPI, irqs[i],
 +                               GIC_FDT_IRQ_FLAGS_LEVEL_HI,
 +                               GIC_FDT_IRQ_TYPE_SPI, irqs[i],
 +                               GIC_FDT_IRQ_FLAGS_LEVEL_HI);
 +        qemu_fdt_setprop_sized_cells(s->fdt, name, "reg",
 +                                     2, addrs[i], 2, 0x1000);
 +        qemu_fdt_setprop(s->fdt, name, "compatible",
 +                         compat_gem, sizeof(compat_gem));
 +        qemu_fdt_setprop_cell(s->fdt, name, "#address-cells", 1);
 +        qemu_fdt_setprop_cell(s->fdt, name, "#size-cells", 0);
 +        g_free(name);
 +    }
 +}
 +
 +static void fdt_nop_memory_nodes(void *fdt, Error **errp)
 +{
 +    Error *err = NULL;
 +    char **node_path;
 +    int n = 0;
 +
 +    node_path = qemu_fdt_node_unit_path(fdt, "memory", &err);
 +    if (err) {
 +        error_propagate(errp, err);
 +        return;
 +    }
 +    while (node_path[n]) {
 +        if (g_str_has_prefix(node_path[n], "/memory")) {
 +            qemu_fdt_nop_node(fdt, node_path[n]);
 +        }
 +        n++;
 +    }
 +    g_strfreev(node_path);
 +}
 +
 +static void fdt_add_memory_nodes(VersalVirt *s, void *fdt, uint64_t ram_size)
 +{
 +    /* Describes the various split DDR access regions.  */
 +    static const struct {
 +        uint64_t base;
 +        uint64_t size;
 +    } addr_ranges[] = {
 +        { MM_TOP_DDR, MM_TOP_DDR_SIZE },
 +        { MM_TOP_DDR_2, MM_TOP_DDR_2_SIZE },
 +        { MM_TOP_DDR_3, MM_TOP_DDR_3_SIZE },
 +        { MM_TOP_DDR_4, MM_TOP_DDR_4_SIZE }
 +    };
 +    uint64_t mem_reg_prop[8] = {0};
 +    uint64_t size = ram_size;
 +    Error *err = NULL;
 +    char *name;
 +    int i;
 +
 +    fdt_nop_memory_nodes(fdt, &err);
 +    if (err) {
 +        error_report_err(err);
 +        return;
 +    }
 +
 +    name = g_strdup_printf("/memory@%x", MM_TOP_DDR);
 +    for (i = 0; i < ARRAY_SIZE(addr_ranges) && size; i++) {
 +        uint64_t mapsize;
 +
 +        mapsize = size < addr_ranges[i].size ? size : addr_ranges[i].size;
 +
 +        mem_reg_prop[i * 2] = addr_ranges[i].base;
 +        mem_reg_prop[i * 2 + 1] = mapsize;
 +        size -= mapsize;
 +    }
 +    qemu_fdt_add_subnode(fdt, name);
 +    qemu_fdt_setprop_string(fdt, name, "device_type", "memory");
 +
 +    switch (i) {
 +    case 1:
 +        qemu_fdt_setprop_sized_cells(fdt, name, "reg",
 +                                     2, mem_reg_prop[0],
 +                                     2, mem_reg_prop[1]);
 +        break;
 +    case 2:
 +        qemu_fdt_setprop_sized_cells(fdt, name, "reg",
 +                                     2, mem_reg_prop[0],
 +                                     2, mem_reg_prop[1],
 +                                     2, mem_reg_prop[2],
 +                                     2, mem_reg_prop[3]);
 +        break;
 +    case 3:
 +        qemu_fdt_setprop_sized_cells(fdt, name, "reg",
 +                                     2, mem_reg_prop[0],
 +                                     2, mem_reg_prop[1],
 +                                     2, mem_reg_prop[2],
 +                                     2, mem_reg_prop[3],
 +                                     2, mem_reg_prop[4],
 +                                     2, mem_reg_prop[5]);
 +        break;
 +    case 4:
 +        qemu_fdt_setprop_sized_cells(fdt, name, "reg",
 +                                     2, mem_reg_prop[0],
 +                                     2, mem_reg_prop[1],
 +                                     2, mem_reg_prop[2],
 +                                     2, mem_reg_prop[3],
 +                                     2, mem_reg_prop[4],
 +                                     2, mem_reg_prop[5],
 +                                     2, mem_reg_prop[6],
 +                                     2, mem_reg_prop[7]);
 +        break;
 +    default:
 +        g_assert_not_reached();
 +    }
 +    g_free(name);
 +}
 +
 +static void versal_virt_modify_dtb(const struct arm_boot_info *binfo,
 +                                    void *fdt)
 +{
 +    VersalVirt *s = container_of(binfo, VersalVirt, binfo);
 +
 +    fdt_add_memory_nodes(s, fdt, binfo->ram_size);
 +}
 +
 +static void *versal_virt_get_dtb(const struct arm_boot_info *binfo,
 +                                  int *fdt_size)
 +{
 +    const VersalVirt *board = container_of(binfo, VersalVirt, binfo);
 +
 +    *fdt_size = board->fdt_size;
 +    return board->fdt;
 +}
 +
 +#define NUM_VIRTIO_TRANSPORT 32
 +static void create_virtio_regions(VersalVirt *s)
 +{
 +    int virtio_mmio_size = 0x200;
 +    int i;
 +
 +    for (i = 0; i < NUM_VIRTIO_TRANSPORT; i++) {
 +        char *name = g_strdup_printf("virtio%d", i);;
 +        hwaddr base = MM_TOP_RSVD + i * virtio_mmio_size;
 +        int irq = VERSAL_RSVD_HIGH_IRQ_FIRST + i;
 +        MemoryRegion *mr;
 +        DeviceState *dev;
 +        qemu_irq pic_irq;
 +
 +        pic_irq = qdev_get_gpio_in(DEVICE(&s->soc.fpd.apu.gic), irq);
 +        dev = qdev_create(NULL, "virtio-mmio");
 +        object_property_add_child(OBJECT(&s->soc), name, OBJECT(dev),
 +                                  &error_fatal);
 +        qdev_init_nofail(dev);
 +        sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic_irq);
 +        mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0);
 +        memory_region_add_subregion(&s->soc.mr_ps, base, mr);
 +        sysbus_create_simple("virtio-mmio", base, pic_irq);
 +    }
 +
 +    for (i = 0; i < NUM_VIRTIO_TRANSPORT; i++) {
 +        hwaddr base = MM_TOP_RSVD + i * virtio_mmio_size;
 +        int irq = VERSAL_RSVD_HIGH_IRQ_FIRST + i;
 +        char *name = g_strdup_printf("/virtio_mmio@%" PRIx64, base);
 +
 +        qemu_fdt_add_subnode(s->fdt, name);
 +        qemu_fdt_setprop(s->fdt, name, "dma-coherent", NULL, 0);
 +        qemu_fdt_setprop_cells(s->fdt, name, "interrupts",
 +                               GIC_FDT_IRQ_TYPE_SPI, irq,
 +                               GIC_FDT_IRQ_FLAGS_EDGE_LO_HI);
 +        qemu_fdt_setprop_sized_cells(s->fdt, name, "reg",
 +                                     2, base, 2, virtio_mmio_size);
 +        qemu_fdt_setprop_string(s->fdt, name, "compatible", "virtio,mmio");
 +        g_free(name);
 +    }
 +}
 +
 +static void versal_virt_init(MachineState *machine)
 +{
 +    VersalVirt *s = XLNX_VERSAL_VIRT_MACHINE(machine);
 +    int psci_conduit = QEMU_PSCI_CONDUIT_DISABLED;
 +
 +    /*
-+     * We need to create splitters to feed the IRQ inputs
++     * If the user provides an Operating System to be loaded, we expect them
-+     * for each CPU in the SSE-200 from each device in the board.
++     * to use the -kernel command line option.
 +     *
 +     * Users can load firmware or boot-loaders with the -device loader options.
 +     *
 +     * When loading an OS, we generate a dtb and let arm_load_kernel() select
 +     * where it gets loaded. This dtb will be passed to the kernel in x0.
 +     *
 +     * If there's no -kernel option, we generate a DTB and place it at 0x1000
 +     * for the bootloaders or firmware to pick up.
 +     *
 +     * If users want to provide their own DTB, they can use the -dtb option.
 +     * These dtb's will have their memory nodes modified to match QEMU's
 +     * selected ram_size option before they get passed to the kernel or fw.
 +     *
 +     * When loading an OS, we turn on QEMU's PSCI implementation with SMC
 +     * as the PSCI conduit. When there's no -kernel, we assume the user
 +     * provides EL3 firmware to handle PSCI.
 +     */
-+    for (i = 0; i < mmc->num_irqs; i++) {
++    if (machine->kernel_filename) {
-+        char *name = g_strdup_printf("musca-irq-splitter%d", i);
++        psci_conduit = QEMU_PSCI_CONDUIT_SMC;
-+        SplitIRQ *splitter = &mms->cpu_irq_splitter[i];
++    }
 +
-+        object_initialize_child(OBJECT(machine), name,
++    memory_region_allocate_system_memory(&s->mr_ddr, NULL, "ddr",
-+                                splitter, sizeof(*splitter),
++                                         machine->ram_size);
-+                                TYPE_SPLIT_IRQ, &error_fatal, NULL);
++
-+        g_free(name);
++    sysbus_init_child_obj(OBJECT(machine), "xlnx-ve", &s->soc,
-+
++                          sizeof(s->soc), TYPE_XLNX_VERSAL);
-+        object_property_set_int(OBJECT(splitter), 2, "num-lines",
++    object_property_set_link(OBJECT(&s->soc), OBJECT(&s->mr_ddr),
-+                                &error_fatal);
++                             "ddr", &error_abort);
-+        object_property_set_bool(OBJECT(splitter), true, "realized",
++    object_property_set_int(OBJECT(&s->soc), psci_conduit,
-+                                 &error_fatal);
++                            "psci-conduit", &error_abort);
-+        qdev_connect_gpio_out(DEVICE(splitter), 0,
++    object_property_set_bool(OBJECT(&s->soc), true, "realized", &error_fatal);
-+                              qdev_get_gpio_in_named(ssedev, "EXP_IRQ", i));
++
-+        qdev_connect_gpio_out(DEVICE(splitter), 1,
++    fdt_create(s);
-+                              qdev_get_gpio_in_named(ssedev,
++    create_virtio_regions(s);
-+                                                     "EXP_CPU1_IRQ", i));
++    fdt_add_gem_nodes(s);
-+    }
++    fdt_add_uart_nodes(s);
-+
++    fdt_add_gic_nodes(s);
-+    armv7m_load_kernel(ARM_CPU(first_cpu), machine->kernel_filename, 0x2000000);
++    fdt_add_timer_nodes(s);
-+}
++    fdt_add_cpu_nodes(s, psci_conduit);
-+
++    fdt_add_clk_node(s, "/clk125", 125000000, s->phandle.clk_125Mhz);
-+static void musca_class_init(ObjectClass *oc, void *data)
++    fdt_add_clk_node(s, "/clk25", 25000000, s->phandle.clk_25Mhz);
 +
 +    /* Make the APU cpu address space visible to virtio and other
 +     * modules unaware of muliple address-spaces.  */
 +    memory_region_add_subregion_overlap(get_system_memory(),
 +                                        0, &s->soc.fpd.apu.mr, 0);
 +
 +    s->binfo.ram_size = machine->ram_size;
 +    s->binfo.kernel_filename = machine->kernel_filename;
 +    s->binfo.kernel_cmdline = machine->kernel_cmdline;
 +    s->binfo.initrd_filename = machine->initrd_filename;
 +    s->binfo.loader_start = 0x0;
 +    s->binfo.get_dtb = versal_virt_get_dtb;
 +    s->binfo.modify_dtb = versal_virt_modify_dtb;
 +    if (machine->kernel_filename) {
 +        arm_load_kernel(s->soc.fpd.apu.cpu[0], &s->binfo);
 +    } else {
 +        AddressSpace *as = arm_boot_address_space(s->soc.fpd.apu.cpu[0],
 +                                                  &s->binfo);
 +        /* Some boot-loaders (e.g u-boot) don't like blobs at address 0 (NULL).
 +         * Offset things by 4K.  */
 +        s->binfo.loader_start = 0x1000;
 +        s->binfo.dtb_limit = 0x1000000;
 +        if (arm_load_dtb(s->binfo.loader_start,
 +                         &s->binfo, s->binfo.dtb_limit, as) < 0) {
 +            exit(EXIT_FAILURE);
 +        }
 +    }
 +}
 +
 +static void versal_virt_machine_instance_init(Object *obj)
 +{
 +}
 +
 +static void versal_virt_machine_class_init(ObjectClass *oc, void *data)
 +{
 +    MachineClass *mc = MACHINE_CLASS(oc);
 +
-+    mc->default_cpus = 2;
++    mc->desc = "Xilinx Versal Virtual development board";
-+    mc->min_cpus = mc->default_cpus;
++    mc->init = versal_virt_init;
-+    mc->max_cpus = mc->default_cpus;
++    mc->max_cpus = XLNX_VERSAL_NR_ACPUS;
-+    mc->default_cpu_type = ARM_CPU_TYPE_NAME("cortex-m33");
++    mc->default_cpus = XLNX_VERSAL_NR_ACPUS;
-+    mc->init = musca_init;
++    mc->no_cdrom = true;
 +}
 +
-+static void musca_a_class_init(ObjectClass *oc, void *data)
++static const TypeInfo versal_virt_machine_init_typeinfo = {
-+{
++    .name       = TYPE_XLNX_VERSAL_VIRT_MACHINE,
-+    MachineClass *mc = MACHINE_CLASS(oc);
++    .parent     = TYPE_MACHINE,
-+    MuscaMachineClass *mmc = MUSCA_MACHINE_CLASS(oc);
++    .class_init = versal_virt_machine_class_init,
-+
++    .instance_init = versal_virt_machine_instance_init,
-+    mc->desc = "ARM Musca-A board (dual Cortex-M33)";
++    .instance_size = sizeof(VersalVirt),
 +    mmc->type = MUSCA_A;
 +    mmc->init_svtor = 0x10200000;
 +    mmc->sram_addr_width = 15;
 +    mmc->num_irqs = 64;
 +}
 +
 +static void musca_b1_class_init(ObjectClass *oc, void *data)
 +{
 +    MachineClass *mc = MACHINE_CLASS(oc);
 +    MuscaMachineClass *mmc = MUSCA_MACHINE_CLASS(oc);
 +
 +    mc->desc = "ARM Musca-B1 board (dual Cortex-M33)";
 +    mmc->type = MUSCA_B1;
 +    /*
 +     * This matches the DAPlink firmware which boots from QSPI. There
 +     * is also a firmware blob which boots from the eFlash, which
 +     * uses init_svtor = 0x1A000000. QEMU doesn't currently support that,
 +     * though we could in theory expose a machine property on the command
 +     * line to allow the user to request eFlash boot.
 +     */
 +    mmc->init_svtor = 0x10000000;
 +    mmc->sram_addr_width = 17;
 +    mmc->num_irqs = 96;
 +}
 +
 +static const TypeInfo musca_info = {
 +    .name = TYPE_MUSCA_MACHINE,
 +    .parent = TYPE_MACHINE,
 +    .abstract = true,
 +    .instance_size = sizeof(MuscaMachineState),
 +    .class_size = sizeof(MuscaMachineClass),
 +    .class_init = musca_class_init,
 +};
 +
-+static const TypeInfo musca_a_info = {
++static void versal_virt_machine_init_register_types(void)
-+    .name = TYPE_MUSCA_A_MACHINE,
++{
-+    .parent = TYPE_MUSCA_MACHINE,
++    type_register_static(&versal_virt_machine_init_typeinfo);
-+    .class_init = musca_a_class_init,
++}
-+};
++
-+
++type_init(versal_virt_machine_init_register_types)
-+static const TypeInfo musca_b1_info = {
++
 +    .name = TYPE_MUSCA_B1_MACHINE,
 +    .parent = TYPE_MUSCA_MACHINE,
 +    .class_init = musca_b1_class_init,
 +};
 +
 +static void musca_machine_init(void)
 +{
 +    type_register_static(&musca_info);
 +    type_register_static(&musca_a_info);
 +    type_register_static(&musca_b1_info);
 +}
 +
 +type_init(musca_machine_init);
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: include/hw/misc/iotkit-sysinfo.h
  F: hw/misc/armsse-cpuid.c
  F: include/hw/misc/armsse-cpuid.h
 +Musca
 +M: Peter Maydell <peter.maydell@linaro.org>
 +L: qemu-arm@nongnu.org
 +S: Maintained
 +F: hw/arm/musca.c
 +
  Musicpal
  M: Jan Kiszka <jan.kiszka@web.de>
  M: Peter Maydell <peter.maydell@linaro.org>
 diff --git a/default-configs/arm-softmmu.mak b/default-configs/arm-softmmu.mak
 index XXXXXXX..XXXXXXX 100644
 --- a/default-configs/arm-softmmu.mak
 +++ b/default-configs/arm-softmmu.mak
@@ -XXX,XX +XXX,XX @@ CONFIG_TUSB6010=y
  CONFIG_IMX=y
  CONFIG_MAINSTONE=y
  CONFIG_MPS2=y
 +CONFIG_MUSCA=y
  CONFIG_NSERIES=y
  CONFIG_RASPI=y
  CONFIG_REALVIEW=y
 --
-.20.1
+.19.1

-[Qemu-devel] [PULL 19/21] hw/arm/musca: Wire up PL031 RTC
+Deleted patch
-Wire up the PL031 RTC for the Musca board.
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
----
- hw/arm/musca.c | 26 +++++++++++++++++++++++---
-file changed, 23 insertions(+), 3 deletions(-)
-diff --git a/hw/arm/musca.c b/hw/arm/musca.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/arm/musca.c
-+++ b/hw/arm/musca.c
-@@ -XXX,XX +XXX,XX @@
- #include "hw/misc/tz-mpc.h"
- #include "hw/misc/tz-ppc.h"
- #include "hw/misc/unimp.h"
-+#include "hw/timer/pl031.h"
- #define MUSCA_NUMIRQ_MAX 96
- #define MUSCA_PPC_MAX 3
-@@ -XXX,XX +XXX,XX @@ typedef struct {
-     UnimplementedDeviceState spi;
-     UnimplementedDeviceState scc;
-     UnimplementedDeviceState timer;
--    UnimplementedDeviceState rtc;
-+    PL031State rtc;
-     UnimplementedDeviceState pvt;
-     UnimplementedDeviceState sdio;
-     UnimplementedDeviceState gpio;
-@@ -XXX,XX +XXX,XX @@ typedef struct {
-  */
- #define SYSCLK_FRQ 40000000
-+static qemu_irq get_sse_irq_in(MuscaMachineState *mms, int irqno)
-+{
-+    /* Return a qemu_irq which will signal IRQ n to all CPUs in the SSE. */
-+    assert(irqno < MUSCA_NUMIRQ_MAX);
-+
-+    return qdev_get_gpio_in(DEVICE(&mms->cpu_irq_splitter[irqno]), 0);
-+}
-+
- /*
-  * Most of the devices in the Musca board sit behind Peripheral Protection
-  * Controllers. These data structures define the layout of which devices
-@@ -XXX,XX +XXX,XX @@ static MemoryRegion *make_mpc(MuscaMachineState *mms, void *opaque,
-     return sysbus_mmio_get_region(SYS_BUS_DEVICE(mpc), 0);
- }
-+static MemoryRegion *make_rtc(MuscaMachineState *mms, void *opaque,
-+                              const char *name, hwaddr size)
-+{
-+    PL031State *rtc = opaque;
-+
-+    sysbus_init_child_obj(OBJECT(mms), name, rtc, sizeof(mms->rtc), TYPE_PL031);
-+    object_property_set_bool(OBJECT(rtc), true, "realized", &error_fatal);
-+    sysbus_connect_irq(SYS_BUS_DEVICE(rtc), 0, get_sse_irq_in(mms, 39));
-+    return sysbus_mmio_get_region(SYS_BUS_DEVICE(rtc), 0);
-+}
-+
- static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
-                                        const char *name, hwaddr size)
- {
-@@ -XXX,XX +XXX,XX @@ static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
-         { "i2c1", make_unimp_dev, &mms->i2c[1], 0x5000, 0x1000 },
-         { "i2s", make_unimp_dev, &mms->i2s, 0x6000, 0x1000 },
-         { "pwm0", make_unimp_dev, &mms->pwm[0], 0x7000, 0x1000 },
--        { "rtc", make_unimp_dev, &mms->rtc, 0x8000, 0x1000 },
-+        { "rtc", make_rtc, &mms->rtc, 0x8000, 0x1000 },
-         { "qspi", make_unimp_dev, &mms->qspi, 0xa000, 0x1000 },
-         { "timer", make_unimp_dev, &mms->timer, 0xb000, 0x1000 },
-         { "scc", make_unimp_dev, &mms->scc, 0xc000, 0x1000 },
-@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
-                 { "spi", make_unimp_dev, &mms->spi, 0x4010a000, 0x1000 },
-                 { "scc", make_unimp_dev, &mms->scc, 0x5010b000, 0x1000 },
-                 { "timer", make_unimp_dev, &mms->timer, 0x4010c000, 0x1000 },
--                { "rtc", make_unimp_dev, &mms->rtc, 0x4010d000, 0x1000 },
-+                { "rtc", make_rtc, &mms->rtc, 0x4010d000, 0x1000 },
-                 { "pvt", make_unimp_dev, &mms->pvt, 0x4010e000, 0x1000 },
-                 { "sdio", make_unimp_dev, &mms->sdio, 0x4010f000, 0x1000 },
-             },
---
-.20.1

-[Qemu-devel] [PULL 20/21] hw/arm/musca: Wire up PL011 UARTs
+Deleted patch
-Wire up the two PL011 UARTs in the Musca board.
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
----
- hw/arm/musca.c | 34 +++++++++++++++++++++++++++++-----
-file changed, 29 insertions(+), 5 deletions(-)
-diff --git a/hw/arm/musca.c b/hw/arm/musca.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/arm/musca.c
-+++ b/hw/arm/musca.c
-@@ -XXX,XX +XXX,XX @@
- #include "qemu/error-report.h"
- #include "qapi/error.h"
- #include "exec/address-spaces.h"
-+#include "sysemu/sysemu.h"
- #include "hw/arm/arm.h"
- #include "hw/arm/armsse.h"
- #include "hw/boards.h"
-+#include "hw/char/pl011.h"
- #include "hw/core/split-irq.h"
- #include "hw/misc/tz-mpc.h"
- #include "hw/misc/tz-ppc.h"
-@@ -XXX,XX +XXX,XX @@ typedef struct {
-     UnimplementedDeviceState mhu[2];
-     UnimplementedDeviceState pwm[3];
-     UnimplementedDeviceState i2s;
--    UnimplementedDeviceState uart[2];
-+    PL011State uart[2];
-     UnimplementedDeviceState i2c[2];
-     UnimplementedDeviceState spi;
-     UnimplementedDeviceState scc;
-@@ -XXX,XX +XXX,XX @@ static MemoryRegion *make_rtc(MuscaMachineState *mms, void *opaque,
-     return sysbus_mmio_get_region(SYS_BUS_DEVICE(rtc), 0);
- }
-+static MemoryRegion *make_uart(MuscaMachineState *mms, void *opaque,
-+                               const char *name, hwaddr size)
-+{
-+    PL011State *uart = opaque;
-+    int i = uart - &mms->uart[0];
-+    int irqbase = 7 + i * 6;
-+    SysBusDevice *s;
-+
-+    sysbus_init_child_obj(OBJECT(mms), name, uart, sizeof(mms->uart[0]),
-+                          TYPE_PL011);
-+    qdev_prop_set_chr(DEVICE(uart), "chardev", serial_hd(i));
-+    object_property_set_bool(OBJECT(uart), true, "realized", &error_fatal);
-+    s = SYS_BUS_DEVICE(uart);
-+    sysbus_connect_irq(s, 0, get_sse_irq_in(mms, irqbase + 5)); /* combined */
-+    sysbus_connect_irq(s, 1, get_sse_irq_in(mms, irqbase + 0)); /* RX */
-+    sysbus_connect_irq(s, 2, get_sse_irq_in(mms, irqbase + 1)); /* TX */
-+    sysbus_connect_irq(s, 3, get_sse_irq_in(mms, irqbase + 2)); /* RT */
-+    sysbus_connect_irq(s, 4, get_sse_irq_in(mms, irqbase + 3)); /* MS */
-+    sysbus_connect_irq(s, 5, get_sse_irq_in(mms, irqbase + 4)); /* E */
-+    return sysbus_mmio_get_region(SYS_BUS_DEVICE(uart), 0);
-+}
-+
- static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
-                                        const char *name, hwaddr size)
- {
-@@ -XXX,XX +XXX,XX @@ static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
-     MemoryRegion *container = &mms->container;
-     const PPCPortInfo devices[] = {
--        { "uart0", make_unimp_dev, &mms->uart[0], 0x1000, 0x1000 },
--        { "uart1", make_unimp_dev, &mms->uart[1], 0x2000, 0x1000 },
-+        { "uart0", make_uart, &mms->uart[0], 0x1000, 0x1000 },
-+        { "uart1", make_uart, &mms->uart[1], 0x2000, 0x1000 },
-         { "spi", make_unimp_dev, &mms->spi, 0x3000, 0x1000 },
-         { "i2c0", make_unimp_dev, &mms->i2c[0], 0x4000, 0x1000 },
-         { "i2c1", make_unimp_dev, &mms->i2c[1], 0x5000, 0x1000 },
-@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
-                 { "pwm1", make_unimp_dev, &mms->pwm[1], 0x40102000, 0x1000 },
-                 { "pwm2", make_unimp_dev, &mms->pwm[2], 0x40103000, 0x1000 },
-                 { "i2s", make_unimp_dev, &mms->i2s, 0x40104000, 0x1000 },
--                { "uart0", make_unimp_dev, &mms->uart[0], 0x40105000, 0x1000 },
--                { "uart1", make_unimp_dev, &mms->uart[1], 0x40106000, 0x1000 },
-+                { "uart0", make_uart, &mms->uart[0], 0x40105000, 0x1000 },
-+                { "uart1", make_uart, &mms->uart[1], 0x40106000, 0x1000 },
-                 { "i2c0", make_unimp_dev, &mms->i2c[0], 0x40108000, 0x1000 },
-                 { "i2c1", make_unimp_dev, &mms->i2c[1], 0x40109000, 0x1000 },
-                 { "spi", make_unimp_dev, &mms->spi, 0x4010a000, 0x1000 },
---
-.20.1

-[Qemu-devel] [PULL 21/21] hw/arm/armsse: Make 0x5... alias region work for per-CPU devices
+Deleted patch
-The region 0x40010000 .. 0x4001ffff and its secure-only alias
-at 0x50010000... are for per-CPU devices. We implement this by
-giving each CPU its own container memory region, where the
-per-CPU devices live. Unfortunately, the alias region which
-makes devices mapped at 0x4... addresses also appear at 0x5...
-is only implemented in the overall "all CPUs" container. The
-effect of this bug is that the CPU_IDENTITY register block appears
-only at 0x4001f000, but not at the 0x5001f000 alias where it should
-also appear. Guests (like very recent Arm Trusted Firmware-M)
-which try to access it at 0x5001f000 will crash.
-Fix this by moving the handling for this alias from the "all CPUs"
-container to the per-CPU container. (We leave the aliases for
-x1... and 0x3... in the overall container, because there are
-no per-CPU devices there.)
-Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
-Message-id: 20190215180500.6906-1-peter.maydell@linaro.org
-Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
----
- include/hw/arm/armsse.h |  2 +-
- hw/arm/armsse.c         | 26 ++++++++++++++++----------
-files changed, 17 insertions(+), 11 deletions(-)
-diff --git a/include/hw/arm/armsse.h b/include/hw/arm/armsse.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/hw/arm/armsse.h
-+++ b/include/hw/arm/armsse.h
-@@ -XXX,XX +XXX,XX @@ typedef struct ARMSSE {
-     MemoryRegion cpu_container[SSE_MAX_CPUS];
-     MemoryRegion alias1;
-     MemoryRegion alias2;
--    MemoryRegion alias3;
-+    MemoryRegion alias3[SSE_MAX_CPUS];
-     MemoryRegion sram[MAX_SRAM_BANKS];
-     qemu_irq *exp_irqs[SSE_MAX_CPUS];
-diff --git a/hw/arm/armsse.c b/hw/arm/armsse.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/arm/armsse.c
-+++ b/hw/arm/armsse.c
-@@ -XXX,XX +XXX,XX @@ static bool irq_is_common[32] = {
-     /* 30, 31: reserved */
- };
--/* Create an alias region of @size bytes starting at @base
-+/*
-+ * Create an alias region in @container of @size bytes starting at @base
-  * which mirrors the memory starting at @orig.
-  */
--static void make_alias(ARMSSE *s, MemoryRegion *mr, const char *name,
--                       hwaddr base, hwaddr size, hwaddr orig)
-+static void make_alias(ARMSSE *s, MemoryRegion *mr, MemoryRegion *container,
-+                       const char *name, hwaddr base, hwaddr size, hwaddr orig)
- {
--    memory_region_init_alias(mr, NULL, name, &s->container, orig, size);
-+    memory_region_init_alias(mr, NULL, name, container, orig, size);
-     /* The alias is even lower priority than unimplemented_device regions */
--    memory_region_add_subregion_overlap(&s->container, base, mr, -1500);
-+    memory_region_add_subregion_overlap(container, base, mr, -1500);
- }
- static void irq_status_forwarder(void *opaque, int n, int level)
-@@ -XXX,XX +XXX,XX @@ static void armsse_realize(DeviceState *dev, Error **errp)
-     }
-     /* Set up the big aliases first */
--    make_alias(s, &s->alias1, "alias 1", 0x10000000, 0x10000000, 0x00000000);
--    make_alias(s, &s->alias2, "alias 2", 0x30000000, 0x10000000, 0x20000000);
-+    make_alias(s, &s->alias1, &s->container, "alias 1",
-+               0x10000000, 0x10000000, 0x00000000);
-+    make_alias(s, &s->alias2, &s->container,
-+               "alias 2", 0x30000000, 0x10000000, 0x20000000);
-     /* The 0x50000000..0x5fffffff region is not a pure alias: it has
-      * a few extra devices that only appear there (generally the
-      * control interfaces for the protection controllers).
-      * We implement this by mapping those devices over the top of this
--     * alias MR at a higher priority.
-+     * alias MR at a higher priority. Some of the devices in this range
-+     * are per-CPU, so we must put this alias in the per-cpu containers.
-      */
--    make_alias(s, &s->alias3, "alias 3", 0x50000000, 0x10000000, 0x40000000);
--
-+    for (i = 0; i < info->num_cpus; i++) {
-+        make_alias(s, &s->alias3[i], &s->cpu_container[i],
-+                   "alias 3", 0x50000000, 0x10000000, 0x40000000);
-+    }
-     /* Security controller */
-     object_property_set_bool(OBJECT(&s->secctl), true, "realized", &err);
---
-.20.1

Arm queue -- mostly the first slice of my Musca patches.

thanks
-- PMM

The following changes since commit fc3dbb90f2eb069801bfb4cfe9cbc83cf9c5f4a9:

Merge remote-tracking branch 'remotes/jnsnow/tags/bitmaps-pull-request' into staging (2019-02-21 13:09:33 +0000)

are available in the Git repository at:

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

for you to fetch changes up to 3733f80308d2a7f23f5e39b039e0547aba6c07f1:

hw/arm/armsse: Make 0x5... alias region work for per-CPU devices (2019-02-21 18:17:48 +0000)

----------------------------------------------------------------
target-arm queue:
 * Model the Arm "Musca" development boards: "musca-a" and "musca-b1"
 * Implement the ARMv8.3-JSConv extension
 * v8M MPU should use background region as default, not always
 * Stop unintentional sign extension in pmu_init

----------------------------------------------------------------
Aaron Lindsay OS (1):
      target/arm: Stop unintentional sign extension in pmu_init

Peter Maydell (16):
      hw/arm/armsse: Fix memory leak in error-exit path
      target/arm: v8M MPU should use background region as default, not always
      hw/misc/tz-ppc: Support having unused ports in the middle of the range
      hw/timer/pl031: Allow use as an embedded-struct device
      hw/timer/pl031: Convert to using trace events
      hw/char/pl011: Allow use as an embedded-struct device
      hw/char/pl011: Support all interrupt lines
      hw/char/pl011: Use '0x' prefix when logging hex numbers
      hw/arm/armsse: Document SRAM_ADDR_WIDTH property in header comment
      hw/arm/armsse: Allow boards to specify init-svtor
      hw/arm/musca.c: Implement models of the Musca-A and -B1 boards
      hw/arm/musca: Add PPCs
      hw/arm/musca: Add MPCs
      hw/arm/musca: Wire up PL031 RTC
      hw/arm/musca: Wire up PL011 UARTs
      hw/arm/armsse: Make 0x5... alias region work for per-CPU devices

Richard Henderson (4):
      target/arm: Restructure disas_fp_int_conv
      target/arm: Split out vfp_helper.c
      target/arm: Rearrange Floating-point data-processing (2 regs)
      target/arm: Implement ARMv8.3-JSConv

Coverity points out (CID 1398632, CID 1398650) that we
leak a couple of allocated strings in the error-exit
code path for setting up the MHUs in the ARMSSE.
Fix this bug by moving the allocate-and-free of each
string to be closer to the use, so we do the free before
doing the error-exit check.

Fixes: f8574705f62b38a ("hw/arm/armsse: Add unimplemented-device stubs for MHUs")
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20190215113707.24553-1-peter.maydell@linaro.org
---
 hw/arm/armsse.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/hw/arm/armsse.c b/hw/arm/armsse.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/armsse.c
+++ b/hw/arm/armsse.c
@@ -XXX,XX +XXX,XX @@ static void armsse_realize(DeviceState *dev, Error **errp)
 
     if (info->has_mhus) {
         for (i = 0; i < ARRAY_SIZE(s->mhu); i++) {
-            char *name = g_strdup_printf("MHU%d", i);
-            char *port = g_strdup_printf("port[%d]", i + 3);
+            char *name;
+            char *port;
 
+            name = g_strdup_printf("MHU%d", i);
             qdev_prop_set_string(DEVICE(&s->mhu[i]), "name", name);
             qdev_prop_set_uint64(DEVICE(&s->mhu[i]), "size", 0x1000);
             object_property_set_bool(OBJECT(&s->mhu[i]), true,
                                      "realized", &err);
+            g_free(name);
             if (err) {
                 error_propagate(errp, err);
                 return;
             }
+            port = g_strdup_printf("port[%d]", i + 3);
             mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->mhu[i]), 0);
             object_property_set_link(OBJECT(&s->apb_ppc0), OBJECT(mr),
                                      port, &err);
+            g_free(port);
             if (err) {
                 error_propagate(errp, err);
                 return;
             }
-            g_free(name);
-            g_free(port);
         }
     }
 
-- 
2.20.1

The "background region" for a v8M MPU is a default which will be used
(if enabled, and if the access is privileged) if the access does
not match any specific MPU region. We were incorrectly using it
always (by putting the condition at the wrong nesting level). This
meant that we would always return the default background permissions
rather than the correct permissions for a specific region, and also
that we would not return the right information in response to a
TT instruction.

Move the check for the background region to the same place in the
logic as the equivalent v8M MPUCheck() pseudocode puts it.
This in turn means we must adjust the condition we use to detect
matches in multiple regions to avoid false-positives.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Message-id: 20190214113408.10214-1-peter.maydell@linaro.org
---
 target/arm/helper.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/target/arm/helper.c b/target/arm/helper.c
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/helper.c
+++ b/target/arm/helper.c
@@ -XXX,XX +XXX,XX @@ static bool pmsav8_mpu_lookup(CPUARMState *env, uint32_t address,
         hit = true;
     } else if (m_is_ppb_region(env, address)) {
         hit = true;
-    } else if (pmsav7_use_background_region(cpu, mmu_idx, is_user)) {
-        hit = true;
     } else {
+        if (pmsav7_use_background_region(cpu, mmu_idx, is_user)) {
+            hit = true;
+        }
+
         for (n = (int)cpu->pmsav7_dregion - 1; n >= 0; n--) {
             /* region search */
             /* Note that the base address is bits [31:5] from the register
@@ -XXX,XX +XXX,XX @@ static bool pmsav8_mpu_lookup(CPUARMState *env, uint32_t address,
                 *is_subpage = true;
             }
 
-            if (hit) {
+            if (matchregion != -1) {
                 /* Multiple regions match -- always a failure (unlike
                  * PMSAv7 where highest-numbered-region wins)
                  */
-- 
2.20.1

From: Aaron Lindsay OS <aaron@os.amperecomputing.com>

This was introduced by
    commit bf8d09694ccc07487cd73d7562081fdaec3370c8
    target/arm: Don't clear supported PMU events when initializing PMCEID1
and identified by Coverity (CID 1398645).

Signed-off-by: Aaron Lindsay <aaron@os.amperecomputing.com>
Reported-by: Peter Maydell <peter.maydell@linaro.org>
Message-id: 20190219144621.450-1-aaron@os.amperecomputing.com
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 target/arm/helper.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/target/arm/helper.c b/target/arm/helper.c
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/helper.c
+++ b/target/arm/helper.c
@@ -XXX,XX +XXX,XX @@ void pmu_init(ARMCPU *cpu)
 
         if (cnt->supported(&cpu->env)) {
             supported_event_map[cnt->number] = i;
-            uint64_t event_mask = 1 << (cnt->number & 0x1f);
+            uint64_t event_mask = 1ULL << (cnt->number & 0x1f);
             if (cnt->number & 0x20) {
                 cpu->pmceid1 |= event_mask;
             } else {
-- 
2.20.1

From: Richard Henderson <richard.henderson@linaro.org>

For opcodes 0-5, move some if conditions into the structure
of a switch statement.  For opcodes 6 & 7, decode everything
at once with a second switch.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-id: 20190215192302.27855-2-richard.henderson@linaro.org
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 target/arm/translate-a64.c | 94 ++++++++++++++++++++------------------
 1 file changed, 49 insertions(+), 45 deletions(-)

diff --git a/target/arm/translate-a64.c b/target/arm/translate-a64.c
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/translate-a64.c
+++ b/target/arm/translate-a64.c
@@ -XXX,XX +XXX,XX @@ static void disas_fp_int_conv(DisasContext *s, uint32_t insn)
     int type = extract32(insn, 22, 2);
     bool sbit = extract32(insn, 29, 1);
     bool sf = extract32(insn, 31, 1);
+    bool itof = false;
 
     if (sbit) {
-        unallocated_encoding(s);
-        return;
+        goto do_unallocated;
     }
 
-    if (opcode > 5) {
-        /* FMOV */
-        bool itof = opcode & 1;
-
-        if (rmode >= 2) {
-            unallocated_encoding(s);
-            return;
-        }
-
-        switch (sf << 3 | type << 1 | rmode) {
-        case 0x0: /* 32 bit */
-        case 0xa: /* 64 bit */
-        case 0xd: /* 64 bit to top half of quad */
-            break;
-        case 0x6: /* 16-bit float, 32-bit int */
-        case 0xe: /* 16-bit float, 64-bit int */
-            if (dc_isar_feature(aa64_fp16, s)) {
-                break;
-            }
-            /* fallthru */
-        default:
-            /* all other sf/type/rmode combinations are invalid */
-            unallocated_encoding(s);
-            return;
-        }
-
-        if (!fp_access_check(s)) {
-            return;
-        }
-        handle_fmov(s, rd, rn, type, itof);
-    } else {
-        /* actual FP conversions */
-        bool itof = extract32(opcode, 1, 1);
-
-        if (rmode != 0 && opcode > 1) {
-            unallocated_encoding(s);
-            return;
+    switch (opcode) {
+    case 2: /* SCVTF */
+    case 3: /* UCVTF */
+        itof = true;
+        /* fallthru */
+    case 4: /* FCVTAS */
+    case 5: /* FCVTAU */
+        if (rmode != 0) {
+            goto do_unallocated;
         }
+        /* fallthru */
+    case 0: /* FCVT[NPMZ]S */
+    case 1: /* FCVT[NPMZ]U */
         switch (type) {
         case 0: /* float32 */
         case 1: /* float64 */
             break;
         case 3: /* float16 */
-            if (dc_isar_feature(aa64_fp16, s)) {
-                break;
+            if (!dc_isar_feature(aa64_fp16, s)) {
+                goto do_unallocated;
             }
-            /* fallthru */
+            break;
         default:
-            unallocated_encoding(s);
-            return;
+            goto do_unallocated;
         }
-
         if (!fp_access_check(s)) {
             return;
         }
         handle_fpfpcvt(s, rd, rn, opcode, itof, rmode, 64, sf, type);
+        break;
+
+    default:
+        switch (sf << 7 | type << 5 | rmode << 3 | opcode) {
+        case 0b01100110: /* FMOV half <-> 32-bit int */
+        case 0b01100111:
+        case 0b11100110: /* FMOV half <-> 64-bit int */
+        case 0b11100111:
+            if (!dc_isar_feature(aa64_fp16, s)) {
+                goto do_unallocated;
+            }
+            /* fallthru */
+        case 0b00000110: /* FMOV 32-bit */
+        case 0b00000111:
+        case 0b10100110: /* FMOV 64-bit */
+        case 0b10100111:
+        case 0b11001110: /* FMOV top half of 128-bit */
+        case 0b11001111:
+            if (!fp_access_check(s)) {
+                return;
+            }
+            itof = opcode & 1;
+            handle_fmov(s, rd, rn, type, itof);
+            break;
+
+        default:
+        do_unallocated:
+            unallocated_encoding(s);
+            return;
+        }
+        break;
     }
 }
 
-- 
2.20.1

From: Richard Henderson <richard.henderson@linaro.org>

Move all of the fp helpers out of helper.c into a new file.
This is code movement only.  Since helper.c has no copyright
header, take the one from cpu.h for the new file.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-id: 20190215192302.27855-3-richard.henderson@linaro.org
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 target/arm/Makefile.objs |    2 +-
 target/arm/helper.c      | 1062 -------------------------------------
 target/arm/vfp_helper.c  | 1088 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 1089 insertions(+), 1063 deletions(-)
 create mode 100644 target/arm/vfp_helper.c

diff --git a/target/arm/Makefile.objs b/target/arm/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/Makefile.objs
+++ b/target/arm/Makefile.objs
@@ -XXX,XX +XXX,XX @@ obj-$(call land,$(CONFIG_KVM),$(call lnot,$(TARGET_AARCH64))) += kvm32.o
 obj-$(call land,$(CONFIG_KVM),$(TARGET_AARCH64)) += kvm64.o
 obj-$(call lnot,$(CONFIG_KVM)) += kvm-stub.o
 obj-y += translate.o op_helper.o helper.o cpu.o
-obj-y += neon_helper.o iwmmxt_helper.o vec_helper.o
+obj-y += neon_helper.o iwmmxt_helper.o vec_helper.o vfp_helper.o
 obj-y += gdbstub.o
 obj-$(TARGET_AARCH64) += cpu64.o translate-a64.o helper-a64.o gdbstub64.o
 obj-$(TARGET_AARCH64) += pauth_helper.o
diff --git a/target/arm/helper.c b/target/arm/helper.c
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/helper.c
+++ b/target/arm/helper.c
@@ -XXX,XX +XXX,XX @@ uint32_t HELPER(sel_flags)(uint32_t flags, uint32_t a, uint32_t b)
     return (a & mask) | (b & ~mask);
 }
 
-/* VFP support.  We follow the convention used for VFP instructions:
-   Single precision routines have a "s" suffix, double precision a
-   "d" suffix.  */
-
-/* Convert host exception flags to vfp form.  */
-static inline int vfp_exceptbits_from_host(int host_bits)
-{
-    int target_bits = 0;
-
-    if (host_bits & float_flag_invalid)
-        target_bits |= 1;
-    if (host_bits & float_flag_divbyzero)
-        target_bits |= 2;
-    if (host_bits & float_flag_overflow)
-        target_bits |= 4;
-    if (host_bits & (float_flag_underflow | float_flag_output_denormal))
-        target_bits |= 8;
-    if (host_bits & float_flag_inexact)
-        target_bits |= 0x10;
-    if (host_bits & float_flag_input_denormal)
-        target_bits |= 0x80;
-    return target_bits;
-}
-
-uint32_t HELPER(vfp_get_fpscr)(CPUARMState *env)
-{
-    uint32_t i, fpscr;
-
-    fpscr = env->vfp.xregs[ARM_VFP_FPSCR]
-            | (env->vfp.vec_len << 16)
-            | (env->vfp.vec_stride << 20);
-
-    i = get_float_exception_flags(&env->vfp.fp_status);
-    i |= get_float_exception_flags(&env->vfp.standard_fp_status);
-    /* FZ16 does not generate an input denormal exception.  */
-    i |= (get_float_exception_flags(&env->vfp.fp_status_f16)
-          & ~float_flag_input_denormal);
-    fpscr |= vfp_exceptbits_from_host(i);
-
-    i = env->vfp.qc[0] | env->vfp.qc[1] | env->vfp.qc[2] | env->vfp.qc[3];
-    fpscr |= i ? FPCR_QC : 0;
-
-    return fpscr;
-}
-
-uint32_t vfp_get_fpscr(CPUARMState *env)
-{
-    return HELPER(vfp_get_fpscr)(env);
-}
-
-/* Convert vfp exception flags to target form.  */
-static inline int vfp_exceptbits_to_host(int target_bits)
-{
-    int host_bits = 0;
-
-    if (target_bits & 1)
-        host_bits |= float_flag_invalid;
-    if (target_bits & 2)
-        host_bits |= float_flag_divbyzero;
-    if (target_bits & 4)
-        host_bits |= float_flag_overflow;
-    if (target_bits & 8)
-        host_bits |= float_flag_underflow;
-    if (target_bits & 0x10)
-        host_bits |= float_flag_inexact;
-    if (target_bits & 0x80)
-        host_bits |= float_flag_input_denormal;
-    return host_bits;
-}
-
-void HELPER(vfp_set_fpscr)(CPUARMState *env, uint32_t val)
-{
-    int i;
-    uint32_t changed = env->vfp.xregs[ARM_VFP_FPSCR];
-
-    /* When ARMv8.2-FP16 is not supported, FZ16 is RES0.  */
-    if (!cpu_isar_feature(aa64_fp16, arm_env_get_cpu(env))) {
-        val &= ~FPCR_FZ16;
-    }
-
-    /*
-     * We don't implement trapped exception handling, so the
-     * trap enable bits, IDE|IXE|UFE|OFE|DZE|IOE are all RAZ/WI (not RES0!)
-     *
-     * If we exclude the exception flags, IOC|DZC|OFC|UFC|IXC|IDC
-     * (which are stored in fp_status), and the other RES0 bits
-     * in between, then we clear all of the low 16 bits.
-     */
-    env->vfp.xregs[ARM_VFP_FPSCR] = val & 0xf7c80000;
-    env->vfp.vec_len = (val >> 16) & 7;
-    env->vfp.vec_stride = (val >> 20) & 3;
-
-    /*
-     * The bit we set within fpscr_q is arbitrary; the register as a
-     * whole being zero/non-zero is what counts.
-     */
-    env->vfp.qc[0] = val & FPCR_QC;
-    env->vfp.qc[1] = 0;
-    env->vfp.qc[2] = 0;
-    env->vfp.qc[3] = 0;
-
-    changed ^= val;
-    if (changed & (3 << 22)) {
-        i = (val >> 22) & 3;
-        switch (i) {
-        case FPROUNDING_TIEEVEN:
-            i = float_round_nearest_even;
-            break;
-        case FPROUNDING_POSINF:
-            i = float_round_up;
-            break;
-        case FPROUNDING_NEGINF:
-            i = float_round_down;
-            break;
-        case FPROUNDING_ZERO:
-            i = float_round_to_zero;
-            break;
-        }
-        set_float_rounding_mode(i, &env->vfp.fp_status);
-        set_float_rounding_mode(i, &env->vfp.fp_status_f16);
-    }
-    if (changed & FPCR_FZ16) {
-        bool ftz_enabled = val & FPCR_FZ16;
-        set_flush_to_zero(ftz_enabled, &env->vfp.fp_status_f16);
-        set_flush_inputs_to_zero(ftz_enabled, &env->vfp.fp_status_f16);
-    }
-    if (changed & FPCR_FZ) {
-        bool ftz_enabled = val & FPCR_FZ;
-        set_flush_to_zero(ftz_enabled, &env->vfp.fp_status);
-        set_flush_inputs_to_zero(ftz_enabled, &env->vfp.fp_status);
-    }
-    if (changed & FPCR_DN) {
-        bool dnan_enabled = val & FPCR_DN;
-        set_default_nan_mode(dnan_enabled, &env->vfp.fp_status);
-        set_default_nan_mode(dnan_enabled, &env->vfp.fp_status_f16);
-    }
-
-    /* The exception flags are ORed together when we read fpscr so we
-     * only need to preserve the current state in one of our
-     * float_status values.
-     */
-    i = vfp_exceptbits_to_host(val);
-    set_float_exception_flags(i, &env->vfp.fp_status);
-    set_float_exception_flags(0, &env->vfp.fp_status_f16);
-    set_float_exception_flags(0, &env->vfp.standard_fp_status);
-}
-
-void vfp_set_fpscr(CPUARMState *env, uint32_t val)
-{
-    HELPER(vfp_set_fpscr)(env, val);
-}
-
-#define VFP_HELPER(name, p) HELPER(glue(glue(vfp_,name),p))
-
-#define VFP_BINOP(name) \
-float32 VFP_HELPER(name, s)(float32 a, float32 b, void *fpstp) \
-{ \
-    float_status *fpst = fpstp; \
-    return float32_ ## name(a, b, fpst); \
-} \
-float64 VFP_HELPER(name, d)(float64 a, float64 b, void *fpstp) \
-{ \
-    float_status *fpst = fpstp; \
-    return float64_ ## name(a, b, fpst); \
-}
-VFP_BINOP(add)
-VFP_BINOP(sub)
-VFP_BINOP(mul)
-VFP_BINOP(div)
-VFP_BINOP(min)
-VFP_BINOP(max)
-VFP_BINOP(minnum)
-VFP_BINOP(maxnum)
-#undef VFP_BINOP
-
-float32 VFP_HELPER(neg, s)(float32 a)
-{
-    return float32_chs(a);
-}
-
-float64 VFP_HELPER(neg, d)(float64 a)
-{
-    return float64_chs(a);
-}
-
-float32 VFP_HELPER(abs, s)(float32 a)
-{
-    return float32_abs(a);
-}
-
-float64 VFP_HELPER(abs, d)(float64 a)
-{
-    return float64_abs(a);
-}
-
-float32 VFP_HELPER(sqrt, s)(float32 a, CPUARMState *env)
-{
-    return float32_sqrt(a, &env->vfp.fp_status);
-}
-
-float64 VFP_HELPER(sqrt, d)(float64 a, CPUARMState *env)
-{
-    return float64_sqrt(a, &env->vfp.fp_status);
-}
-
-static void softfloat_to_vfp_compare(CPUARMState *env, int cmp)
-{
-    uint32_t flags;
-    switch (cmp) {
-    case float_relation_equal:
-        flags = 0x6;
-        break;
-    case float_relation_less:
-        flags = 0x8;
-        break;
-    case float_relation_greater:
-        flags = 0x2;
-        break;
-    case float_relation_unordered:
-        flags = 0x3;
-        break;
-    default:
-        g_assert_not_reached();
-    }
-    env->vfp.xregs[ARM_VFP_FPSCR] =
-        deposit32(env->vfp.xregs[ARM_VFP_FPSCR], 28, 4, flags);
-}
-
-/* XXX: check quiet/signaling case */
-#define DO_VFP_cmp(p, type) \
-void VFP_HELPER(cmp, p)(type a, type b, CPUARMState *env)  \
-{ \
-    softfloat_to_vfp_compare(env, \
-        type ## _compare_quiet(a, b, &env->vfp.fp_status)); \
-} \
-void VFP_HELPER(cmpe, p)(type a, type b, CPUARMState *env) \
-{ \
-    softfloat_to_vfp_compare(env, \
-        type ## _compare(a, b, &env->vfp.fp_status)); \
-}
-DO_VFP_cmp(s, float32)
-DO_VFP_cmp(d, float64)
-#undef DO_VFP_cmp
-
-/* Integer to float and float to integer conversions */
-
-#define CONV_ITOF(name, ftype, fsz, sign)                           \
-ftype HELPER(name)(uint32_t x, void *fpstp)                         \
-{                                                                   \
-    float_status *fpst = fpstp;                                     \
-    return sign##int32_to_##float##fsz((sign##int32_t)x, fpst);     \
-}
-
-#define CONV_FTOI(name, ftype, fsz, sign, round)                \
-sign##int32_t HELPER(name)(ftype x, void *fpstp)                \
-{                                                               \
-    float_status *fpst = fpstp;                                 \
-    if (float##fsz##_is_any_nan(x)) {                           \
-        float_raise(float_flag_invalid, fpst);                  \
-        return 0;                                               \
-    }                                                           \
-    return float##fsz##_to_##sign##int32##round(x, fpst);       \
-}
-
-#define FLOAT_CONVS(name, p, ftype, fsz, sign)            \
-    CONV_ITOF(vfp_##name##to##p, ftype, fsz, sign)        \
-    CONV_FTOI(vfp_to##name##p, ftype, fsz, sign, )        \
-    CONV_FTOI(vfp_to##name##z##p, ftype, fsz, sign, _round_to_zero)
-
-FLOAT_CONVS(si, h, uint32_t, 16, )
-FLOAT_CONVS(si, s, float32, 32, )
-FLOAT_CONVS(si, d, float64, 64, )
-FLOAT_CONVS(ui, h, uint32_t, 16, u)
-FLOAT_CONVS(ui, s, float32, 32, u)
-FLOAT_CONVS(ui, d, float64, 64, u)
-
-#undef CONV_ITOF
-#undef CONV_FTOI
-#undef FLOAT_CONVS
-
-/* floating point conversion */
-float64 VFP_HELPER(fcvtd, s)(float32 x, CPUARMState *env)
-{
-    return float32_to_float64(x, &env->vfp.fp_status);
-}
-
-float32 VFP_HELPER(fcvts, d)(float64 x, CPUARMState *env)
-{
-    return float64_to_float32(x, &env->vfp.fp_status);
-}
-
-/* VFP3 fixed point conversion.  */
-#define VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype) \
-float##fsz HELPER(vfp_##name##to##p)(uint##isz##_t  x, uint32_t shift, \
-                                     void *fpstp) \
-{ return itype##_to_##float##fsz##_scalbn(x, -shift, fpstp); }
-
-#define VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype, ROUND, suff)   \
-uint##isz##_t HELPER(vfp_to##name##p##suff)(float##fsz x, uint32_t shift, \
-                                            void *fpst)                   \
-{                                                                         \
-    if (unlikely(float##fsz##_is_any_nan(x))) {                           \
-        float_raise(float_flag_invalid, fpst);                            \
-        return 0;                                                         \
-    }                                                                     \
-    return float##fsz##_to_##itype##_scalbn(x, ROUND, shift, fpst);       \
-}
-
-#define VFP_CONV_FIX(name, p, fsz, isz, itype)                   \
-VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype)                     \
-VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
-                         float_round_to_zero, _round_to_zero)    \
-VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
-                         get_float_rounding_mode(fpst), )
-
-#define VFP_CONV_FIX_A64(name, p, fsz, isz, itype)               \
-VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype)                     \
-VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
-                         get_float_rounding_mode(fpst), )
-
-VFP_CONV_FIX(sh, d, 64, 64, int16)
-VFP_CONV_FIX(sl, d, 64, 64, int32)
-VFP_CONV_FIX_A64(sq, d, 64, 64, int64)
-VFP_CONV_FIX(uh, d, 64, 64, uint16)
-VFP_CONV_FIX(ul, d, 64, 64, uint32)
-VFP_CONV_FIX_A64(uq, d, 64, 64, uint64)
-VFP_CONV_FIX(sh, s, 32, 32, int16)
-VFP_CONV_FIX(sl, s, 32, 32, int32)
-VFP_CONV_FIX_A64(sq, s, 32, 64, int64)
-VFP_CONV_FIX(uh, s, 32, 32, uint16)
-VFP_CONV_FIX(ul, s, 32, 32, uint32)
-VFP_CONV_FIX_A64(uq, s, 32, 64, uint64)
-
-#undef VFP_CONV_FIX
-#undef VFP_CONV_FIX_FLOAT
-#undef VFP_CONV_FLOAT_FIX_ROUND
-#undef VFP_CONV_FIX_A64
-
-uint32_t HELPER(vfp_sltoh)(uint32_t x, uint32_t shift, void *fpst)
-{
-    return int32_to_float16_scalbn(x, -shift, fpst);
-}
-
-uint32_t HELPER(vfp_ultoh)(uint32_t x, uint32_t shift, void *fpst)
-{
-    return uint32_to_float16_scalbn(x, -shift, fpst);
-}
-
-uint32_t HELPER(vfp_sqtoh)(uint64_t x, uint32_t shift, void *fpst)
-{
-    return int64_to_float16_scalbn(x, -shift, fpst);
-}
-
-uint32_t HELPER(vfp_uqtoh)(uint64_t x, uint32_t shift, void *fpst)
-{
-    return uint64_to_float16_scalbn(x, -shift, fpst);
-}
-
-uint32_t HELPER(vfp_toshh)(uint32_t x, uint32_t shift, void *fpst)
-{
-    if (unlikely(float16_is_any_nan(x))) {
-        float_raise(float_flag_invalid, fpst);
-        return 0;
-    }
-    return float16_to_int16_scalbn(x, get_float_rounding_mode(fpst),
-                                   shift, fpst);
-}
-
-uint32_t HELPER(vfp_touhh)(uint32_t x, uint32_t shift, void *fpst)
-{
-    if (unlikely(float16_is_any_nan(x))) {
-        float_raise(float_flag_invalid, fpst);
-        return 0;
-    }
-    return float16_to_uint16_scalbn(x, get_float_rounding_mode(fpst),
-                                    shift, fpst);
-}
-
-uint32_t HELPER(vfp_toslh)(uint32_t x, uint32_t shift, void *fpst)
-{
-    if (unlikely(float16_is_any_nan(x))) {
-        float_raise(float_flag_invalid, fpst);
-        return 0;
-    }
-    return float16_to_int32_scalbn(x, get_float_rounding_mode(fpst),
-                                   shift, fpst);
-}
-
-uint32_t HELPER(vfp_toulh)(uint32_t x, uint32_t shift, void *fpst)
-{
-    if (unlikely(float16_is_any_nan(x))) {
-        float_raise(float_flag_invalid, fpst);
-        return 0;
-    }
-    return float16_to_uint32_scalbn(x, get_float_rounding_mode(fpst),
-                                    shift, fpst);
-}
-
-uint64_t HELPER(vfp_tosqh)(uint32_t x, uint32_t shift, void *fpst)
-{
-    if (unlikely(float16_is_any_nan(x))) {
-        float_raise(float_flag_invalid, fpst);
-        return 0;
-    }
-    return float16_to_int64_scalbn(x, get_float_rounding_mode(fpst),
-                                   shift, fpst);
-}
-
-uint64_t HELPER(vfp_touqh)(uint32_t x, uint32_t shift, void *fpst)
-{
-    if (unlikely(float16_is_any_nan(x))) {
-        float_raise(float_flag_invalid, fpst);
-        return 0;
-    }
-    return float16_to_uint64_scalbn(x, get_float_rounding_mode(fpst),
-                                    shift, fpst);
-}
-
-/* Set the current fp rounding mode and return the old one.
- * The argument is a softfloat float_round_ value.
- */
-uint32_t HELPER(set_rmode)(uint32_t rmode, void *fpstp)
-{
-    float_status *fp_status = fpstp;
-
-    uint32_t prev_rmode = get_float_rounding_mode(fp_status);
-    set_float_rounding_mode(rmode, fp_status);
-
-    return prev_rmode;
-}
-
-/* Set the current fp rounding mode in the standard fp status and return
- * the old one. This is for NEON instructions that need to change the
- * rounding mode but wish to use the standard FPSCR values for everything
- * else. Always set the rounding mode back to the correct value after
- * modifying it.
- * The argument is a softfloat float_round_ value.
- */
-uint32_t HELPER(set_neon_rmode)(uint32_t rmode, CPUARMState *env)
-{
-    float_status *fp_status = &env->vfp.standard_fp_status;
-
-    uint32_t prev_rmode = get_float_rounding_mode(fp_status);
-    set_float_rounding_mode(rmode, fp_status);
-
-    return prev_rmode;
-}
-
-/* Half precision conversions.  */
-float32 HELPER(vfp_fcvt_f16_to_f32)(uint32_t a, void *fpstp, uint32_t ahp_mode)
-{
-    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
-     * it would affect flushing input denormals.
-     */
-    float_status *fpst = fpstp;
-    flag save = get_flush_inputs_to_zero(fpst);
-    set_flush_inputs_to_zero(false, fpst);
-    float32 r = float16_to_float32(a, !ahp_mode, fpst);
-    set_flush_inputs_to_zero(save, fpst);
-    return r;
-}
-
-uint32_t HELPER(vfp_fcvt_f32_to_f16)(float32 a, void *fpstp, uint32_t ahp_mode)
-{
-    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
-     * it would affect flushing output denormals.
-     */
-    float_status *fpst = fpstp;
-    flag save = get_flush_to_zero(fpst);
-    set_flush_to_zero(false, fpst);
-    float16 r = float32_to_float16(a, !ahp_mode, fpst);
-    set_flush_to_zero(save, fpst);
-    return r;
-}
-
-float64 HELPER(vfp_fcvt_f16_to_f64)(uint32_t a, void *fpstp, uint32_t ahp_mode)
-{
-    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
-     * it would affect flushing input denormals.
-     */
-    float_status *fpst = fpstp;
-    flag save = get_flush_inputs_to_zero(fpst);
-    set_flush_inputs_to_zero(false, fpst);
-    float64 r = float16_to_float64(a, !ahp_mode, fpst);
-    set_flush_inputs_to_zero(save, fpst);
-    return r;
-}
-
-uint32_t HELPER(vfp_fcvt_f64_to_f16)(float64 a, void *fpstp, uint32_t ahp_mode)
-{
-    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
-     * it would affect flushing output denormals.
-     */
-    float_status *fpst = fpstp;
-    flag save = get_flush_to_zero(fpst);
-    set_flush_to_zero(false, fpst);
-    float16 r = float64_to_float16(a, !ahp_mode, fpst);
-    set_flush_to_zero(save, fpst);
-    return r;
-}
-
-#define float32_two make_float32(0x40000000)
-#define float32_three make_float32(0x40400000)
-#define float32_one_point_five make_float32(0x3fc00000)
-
-float32 HELPER(recps_f32)(float32 a, float32 b, CPUARMState *env)
-{
-    float_status *s = &env->vfp.standard_fp_status;
-    if ((float32_is_infinity(a) && float32_is_zero_or_denormal(b)) ||
-        (float32_is_infinity(b) && float32_is_zero_or_denormal(a))) {
-        if (!(float32_is_zero(a) || float32_is_zero(b))) {
-            float_raise(float_flag_input_denormal, s);
-        }
-        return float32_two;
-    }
-    return float32_sub(float32_two, float32_mul(a, b, s), s);
-}
-
-float32 HELPER(rsqrts_f32)(float32 a, float32 b, CPUARMState *env)
-{
-    float_status *s = &env->vfp.standard_fp_status;
-    float32 product;
-    if ((float32_is_infinity(a) && float32_is_zero_or_denormal(b)) ||
-        (float32_is_infinity(b) && float32_is_zero_or_denormal(a))) {
-        if (!(float32_is_zero(a) || float32_is_zero(b))) {
-            float_raise(float_flag_input_denormal, s);
-        }
-        return float32_one_point_five;
-    }
-    product = float32_mul(a, b, s);
-    return float32_div(float32_sub(float32_three, product, s), float32_two, s);
-}
-
-/* NEON helpers.  */
-
-/* Constants 256 and 512 are used in some helpers; we avoid relying on
- * int->float conversions at run-time.  */
-#define float64_256 make_float64(0x4070000000000000LL)
-#define float64_512 make_float64(0x4080000000000000LL)
-#define float16_maxnorm make_float16(0x7bff)
-#define float32_maxnorm make_float32(0x7f7fffff)
-#define float64_maxnorm make_float64(0x7fefffffffffffffLL)
-
-/* Reciprocal functions
- *
- * The algorithm that must be used to calculate the estimate
- * is specified by the ARM ARM, see FPRecipEstimate()/RecipEstimate
- */
-
-/* See RecipEstimate()
- *
- * input is a 9 bit fixed point number
- * input range 256 .. 511 for a number from 0.5 <= x < 1.0.
- * result range 256 .. 511 for a number from 1.0 to 511/256.
- */
-
-static int recip_estimate(int input)
-{
-    int a, b, r;
-    assert(256 <= input && input < 512);
-    a = (input * 2) + 1;
-    b = (1 << 19) / a;
-    r = (b + 1) >> 1;
-    assert(256 <= r && r < 512);
-    return r;
-}
-
-/*
- * Common wrapper to call recip_estimate
- *
- * The parameters are exponent and 64 bit fraction (without implicit
- * bit) where the binary point is nominally at bit 52. Returns a
- * float64 which can then be rounded to the appropriate size by the
- * callee.
- */
-
-static uint64_t call_recip_estimate(int *exp, int exp_off, uint64_t frac)
-{
-    uint32_t scaled, estimate;
-    uint64_t result_frac;
-    int result_exp;
-
-    /* Handle sub-normals */
-    if (*exp == 0) {
-        if (extract64(frac, 51, 1) == 0) {
-            *exp = -1;
-            frac <<= 2;
-        } else {
-            frac <<= 1;
-        }
-    }
-
-    /* scaled = UInt('1':fraction<51:44>) */
-    scaled = deposit32(1 << 8, 0, 8, extract64(frac, 44, 8));
-    estimate = recip_estimate(scaled);
-
-    result_exp = exp_off - *exp;
-    result_frac = deposit64(0, 44, 8, estimate);
-    if (result_exp == 0) {
-        result_frac = deposit64(result_frac >> 1, 51, 1, 1);
-    } else if (result_exp == -1) {
-        result_frac = deposit64(result_frac >> 2, 50, 2, 1);
-        result_exp = 0;
-    }
-
-    *exp = result_exp;
-
-    return result_frac;
-}
-
-static bool round_to_inf(float_status *fpst, bool sign_bit)
-{
-    switch (fpst->float_rounding_mode) {
-    case float_round_nearest_even: /* Round to Nearest */
-        return true;
-    case float_round_up: /* Round to +Inf */
-        return !sign_bit;
-    case float_round_down: /* Round to -Inf */
-        return sign_bit;
-    case float_round_to_zero: /* Round to Zero */
-        return false;
-    }
-
-    g_assert_not_reached();
-}
-
-uint32_t HELPER(recpe_f16)(uint32_t input, void *fpstp)
-{
-    float_status *fpst = fpstp;
-    float16 f16 = float16_squash_input_denormal(input, fpst);
-    uint32_t f16_val = float16_val(f16);
-    uint32_t f16_sign = float16_is_neg(f16);
-    int f16_exp = extract32(f16_val, 10, 5);
-    uint32_t f16_frac = extract32(f16_val, 0, 10);
-    uint64_t f64_frac;
-
-    if (float16_is_any_nan(f16)) {
-        float16 nan = f16;
-        if (float16_is_signaling_nan(f16, fpst)) {
-            float_raise(float_flag_invalid, fpst);
-            nan = float16_silence_nan(f16, fpst);
-        }
-        if (fpst->default_nan_mode) {
-            nan =  float16_default_nan(fpst);
-        }
-        return nan;
-    } else if (float16_is_infinity(f16)) {
-        return float16_set_sign(float16_zero, float16_is_neg(f16));
-    } else if (float16_is_zero(f16)) {
-        float_raise(float_flag_divbyzero, fpst);
-        return float16_set_sign(float16_infinity, float16_is_neg(f16));
-    } else if (float16_abs(f16) < (1 << 8)) {
-        /* Abs(value) < 2.0^-16 */
-        float_raise(float_flag_overflow | float_flag_inexact, fpst);
-        if (round_to_inf(fpst, f16_sign)) {
-            return float16_set_sign(float16_infinity, f16_sign);
-        } else {
-            return float16_set_sign(float16_maxnorm, f16_sign);
-        }
-    } else if (f16_exp >= 29 && fpst->flush_to_zero) {
-        float_raise(float_flag_underflow, fpst);
-        return float16_set_sign(float16_zero, float16_is_neg(f16));
-    }
-
-    f64_frac = call_recip_estimate(&f16_exp, 29,
-                                   ((uint64_t) f16_frac) << (52 - 10));
-
-    /* result = sign : result_exp<4:0> : fraction<51:42> */
-    f16_val = deposit32(0, 15, 1, f16_sign);
-    f16_val = deposit32(f16_val, 10, 5, f16_exp);
-    f16_val = deposit32(f16_val, 0, 10, extract64(f64_frac, 52 - 10, 10));
-    return make_float16(f16_val);
-}
-
-float32 HELPER(recpe_f32)(float32 input, void *fpstp)
-{
-    float_status *fpst = fpstp;
-    float32 f32 = float32_squash_input_denormal(input, fpst);
-    uint32_t f32_val = float32_val(f32);
-    bool f32_sign = float32_is_neg(f32);
-    int f32_exp = extract32(f32_val, 23, 8);
-    uint32_t f32_frac = extract32(f32_val, 0, 23);
-    uint64_t f64_frac;
-
-    if (float32_is_any_nan(f32)) {
-        float32 nan = f32;
-        if (float32_is_signaling_nan(f32, fpst)) {
-            float_raise(float_flag_invalid, fpst);
-            nan = float32_silence_nan(f32, fpst);
-        }
-        if (fpst->default_nan_mode) {
-            nan =  float32_default_nan(fpst);
-        }
-        return nan;
-    } else if (float32_is_infinity(f32)) {
-        return float32_set_sign(float32_zero, float32_is_neg(f32));
-    } else if (float32_is_zero(f32)) {
-        float_raise(float_flag_divbyzero, fpst);
-        return float32_set_sign(float32_infinity, float32_is_neg(f32));
-    } else if (float32_abs(f32) < (1ULL << 21)) {
-        /* Abs(value) < 2.0^-128 */
-        float_raise(float_flag_overflow | float_flag_inexact, fpst);
-        if (round_to_inf(fpst, f32_sign)) {
-            return float32_set_sign(float32_infinity, f32_sign);
-        } else {
-            return float32_set_sign(float32_maxnorm, f32_sign);
-        }
-    } else if (f32_exp >= 253 && fpst->flush_to_zero) {
-        float_raise(float_flag_underflow, fpst);
-        return float32_set_sign(float32_zero, float32_is_neg(f32));
-    }
-
-    f64_frac = call_recip_estimate(&f32_exp, 253,
-                                   ((uint64_t) f32_frac) << (52 - 23));
-
-    /* result = sign : result_exp<7:0> : fraction<51:29> */
-    f32_val = deposit32(0, 31, 1, f32_sign);
-    f32_val = deposit32(f32_val, 23, 8, f32_exp);
-    f32_val = deposit32(f32_val, 0, 23, extract64(f64_frac, 52 - 23, 23));
-    return make_float32(f32_val);
-}
-
-float64 HELPER(recpe_f64)(float64 input, void *fpstp)
-{
-    float_status *fpst = fpstp;
-    float64 f64 = float64_squash_input_denormal(input, fpst);
-    uint64_t f64_val = float64_val(f64);
-    bool f64_sign = float64_is_neg(f64);
-    int f64_exp = extract64(f64_val, 52, 11);
-    uint64_t f64_frac = extract64(f64_val, 0, 52);
-
-    /* Deal with any special cases */
-    if (float64_is_any_nan(f64)) {
-        float64 nan = f64;
-        if (float64_is_signaling_nan(f64, fpst)) {
-            float_raise(float_flag_invalid, fpst);
-            nan = float64_silence_nan(f64, fpst);
-        }
-        if (fpst->default_nan_mode) {
-            nan =  float64_default_nan(fpst);
-        }
-        return nan;
-    } else if (float64_is_infinity(f64)) {
-        return float64_set_sign(float64_zero, float64_is_neg(f64));
-    } else if (float64_is_zero(f64)) {
-        float_raise(float_flag_divbyzero, fpst);
-        return float64_set_sign(float64_infinity, float64_is_neg(f64));
-    } else if ((f64_val & ~(1ULL << 63)) < (1ULL << 50)) {
-        /* Abs(value) < 2.0^-1024 */
-        float_raise(float_flag_overflow | float_flag_inexact, fpst);
-        if (round_to_inf(fpst, f64_sign)) {
-            return float64_set_sign(float64_infinity, f64_sign);
-        } else {
-            return float64_set_sign(float64_maxnorm, f64_sign);
-        }
-    } else if (f64_exp >= 2045 && fpst->flush_to_zero) {
-        float_raise(float_flag_underflow, fpst);
-        return float64_set_sign(float64_zero, float64_is_neg(f64));
-    }
-
-    f64_frac = call_recip_estimate(&f64_exp, 2045, f64_frac);
-
-    /* result = sign : result_exp<10:0> : fraction<51:0>; */
-    f64_val = deposit64(0, 63, 1, f64_sign);
-    f64_val = deposit64(f64_val, 52, 11, f64_exp);
-    f64_val = deposit64(f64_val, 0, 52, f64_frac);
-    return make_float64(f64_val);
-}
-
-/* The algorithm that must be used to calculate the estimate
- * is specified by the ARM ARM.
- */
-
-static int do_recip_sqrt_estimate(int a)
-{
-    int b, estimate;
-
-    assert(128 <= a && a < 512);
-    if (a < 256) {
-        a = a * 2 + 1;
-    } else {
-        a = (a >> 1) << 1;
-        a = (a + 1) * 2;
-    }
-    b = 512;
-    while (a * (b + 1) * (b + 1) < (1 << 28)) {
-        b += 1;
-    }
-    estimate = (b + 1) / 2;
-    assert(256 <= estimate && estimate < 512);
-
-    return estimate;
-}
-
-
-static uint64_t recip_sqrt_estimate(int *exp , int exp_off, uint64_t frac)
-{
-    int estimate;
-    uint32_t scaled;
-
-    if (*exp == 0) {
-        while (extract64(frac, 51, 1) == 0) {
-            frac = frac << 1;
-            *exp -= 1;
-        }
-        frac = extract64(frac, 0, 51) << 1;
-    }
-
-    if (*exp & 1) {
-        /* scaled = UInt('01':fraction<51:45>) */
-        scaled = deposit32(1 << 7, 0, 7, extract64(frac, 45, 7));
-    } else {
-        /* scaled = UInt('1':fraction<51:44>) */
-        scaled = deposit32(1 << 8, 0, 8, extract64(frac, 44, 8));
-    }
-    estimate = do_recip_sqrt_estimate(scaled);
-
-    *exp = (exp_off - *exp) / 2;
-    return extract64(estimate, 0, 8) << 44;
-}
-
-uint32_t HELPER(rsqrte_f16)(uint32_t input, void *fpstp)
-{
-    float_status *s = fpstp;
-    float16 f16 = float16_squash_input_denormal(input, s);
-    uint16_t val = float16_val(f16);
-    bool f16_sign = float16_is_neg(f16);
-    int f16_exp = extract32(val, 10, 5);
-    uint16_t f16_frac = extract32(val, 0, 10);
-    uint64_t f64_frac;
-
-    if (float16_is_any_nan(f16)) {
-        float16 nan = f16;
-        if (float16_is_signaling_nan(f16, s)) {
-            float_raise(float_flag_invalid, s);
-            nan = float16_silence_nan(f16, s);
-        }
-        if (s->default_nan_mode) {
-            nan =  float16_default_nan(s);
-        }
-        return nan;
-    } else if (float16_is_zero(f16)) {
-        float_raise(float_flag_divbyzero, s);
-        return float16_set_sign(float16_infinity, f16_sign);
-    } else if (f16_sign) {
-        float_raise(float_flag_invalid, s);
-        return float16_default_nan(s);
-    } else if (float16_is_infinity(f16)) {
-        return float16_zero;
-    }
-
-    /* Scale and normalize to a double-precision value between 0.25 and 1.0,
-     * preserving the parity of the exponent.  */
-
-    f64_frac = ((uint64_t) f16_frac) << (52 - 10);
-
-    f64_frac = recip_sqrt_estimate(&f16_exp, 44, f64_frac);
-
-    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(2) */
-    val = deposit32(0, 15, 1, f16_sign);
-    val = deposit32(val, 10, 5, f16_exp);
-    val = deposit32(val, 2, 8, extract64(f64_frac, 52 - 8, 8));
-    return make_float16(val);
-}
-
-float32 HELPER(rsqrte_f32)(float32 input, void *fpstp)
-{
-    float_status *s = fpstp;
-    float32 f32 = float32_squash_input_denormal(input, s);
-    uint32_t val = float32_val(f32);
-    uint32_t f32_sign = float32_is_neg(f32);
-    int f32_exp = extract32(val, 23, 8);
-    uint32_t f32_frac = extract32(val, 0, 23);
-    uint64_t f64_frac;
-
-    if (float32_is_any_nan(f32)) {
-        float32 nan = f32;
-        if (float32_is_signaling_nan(f32, s)) {
-            float_raise(float_flag_invalid, s);
-            nan = float32_silence_nan(f32, s);
-        }
-        if (s->default_nan_mode) {
-            nan =  float32_default_nan(s);
-        }
-        return nan;
-    } else if (float32_is_zero(f32)) {
-        float_raise(float_flag_divbyzero, s);
-        return float32_set_sign(float32_infinity, float32_is_neg(f32));
-    } else if (float32_is_neg(f32)) {
-        float_raise(float_flag_invalid, s);
-        return float32_default_nan(s);
-    } else if (float32_is_infinity(f32)) {
-        return float32_zero;
-    }
-
-    /* Scale and normalize to a double-precision value between 0.25 and 1.0,
-     * preserving the parity of the exponent.  */
-
-    f64_frac = ((uint64_t) f32_frac) << 29;
-
-    f64_frac = recip_sqrt_estimate(&f32_exp, 380, f64_frac);
-
-    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(15) */
-    val = deposit32(0, 31, 1, f32_sign);
-    val = deposit32(val, 23, 8, f32_exp);
-    val = deposit32(val, 15, 8, extract64(f64_frac, 52 - 8, 8));
-    return make_float32(val);
-}
-
-float64 HELPER(rsqrte_f64)(float64 input, void *fpstp)
-{
-    float_status *s = fpstp;
-    float64 f64 = float64_squash_input_denormal(input, s);
-    uint64_t val = float64_val(f64);
-    bool f64_sign = float64_is_neg(f64);
-    int f64_exp = extract64(val, 52, 11);
-    uint64_t f64_frac = extract64(val, 0, 52);
-
-    if (float64_is_any_nan(f64)) {
-        float64 nan = f64;
-        if (float64_is_signaling_nan(f64, s)) {
-            float_raise(float_flag_invalid, s);
-            nan = float64_silence_nan(f64, s);
-        }
-        if (s->default_nan_mode) {
-            nan =  float64_default_nan(s);
-        }
-        return nan;
-    } else if (float64_is_zero(f64)) {
-        float_raise(float_flag_divbyzero, s);
-        return float64_set_sign(float64_infinity, float64_is_neg(f64));
-    } else if (float64_is_neg(f64)) {
-        float_raise(float_flag_invalid, s);
-        return float64_default_nan(s);
-    } else if (float64_is_infinity(f64)) {
-        return float64_zero;
-    }
-
-    f64_frac = recip_sqrt_estimate(&f64_exp, 3068, f64_frac);
-
-    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(44) */
-    val = deposit64(0, 61, 1, f64_sign);
-    val = deposit64(val, 52, 11, f64_exp);
-    val = deposit64(val, 44, 8, extract64(f64_frac, 52 - 8, 8));
-    return make_float64(val);
-}
-
-uint32_t HELPER(recpe_u32)(uint32_t a, void *fpstp)
-{
-    /* float_status *s = fpstp; */
-    int input, estimate;
-
-    if ((a & 0x80000000) == 0) {
-        return 0xffffffff;
-    }
-
-    input = extract32(a, 23, 9);
-    estimate = recip_estimate(input);
-
-    return deposit32(0, (32 - 9), 9, estimate);
-}
-
-uint32_t HELPER(rsqrte_u32)(uint32_t a, void *fpstp)
-{
-    int estimate;
-
-    if ((a & 0xc0000000) == 0) {
-        return 0xffffffff;
-    }
-
-    estimate = do_recip_sqrt_estimate(extract32(a, 23, 9));
-
-    return deposit32(0, 23, 9, estimate);
-}
-
-/* VFPv4 fused multiply-accumulate */
-float32 VFP_HELPER(muladd, s)(float32 a, float32 b, float32 c, void *fpstp)
-{
-    float_status *fpst = fpstp;
-    return float32_muladd(a, b, c, 0, fpst);
-}
-
-float64 VFP_HELPER(muladd, d)(float64 a, float64 b, float64 c, void *fpstp)
-{
-    float_status *fpst = fpstp;
-    return float64_muladd(a, b, c, 0, fpst);
-}
-
-/* ARMv8 round to integral */
-float32 HELPER(rints_exact)(float32 x, void *fp_status)
-{
-    return float32_round_to_int(x, fp_status);
-}
-
-float64 HELPER(rintd_exact)(float64 x, void *fp_status)
-{
-    return float64_round_to_int(x, fp_status);
-}
-
-float32 HELPER(rints)(float32 x, void *fp_status)
-{
-    int old_flags = get_float_exception_flags(fp_status), new_flags;
-    float32 ret;
-
-    ret = float32_round_to_int(x, fp_status);
-
-    /* Suppress any inexact exceptions the conversion produced */
-    if (!(old_flags & float_flag_inexact)) {
-        new_flags = get_float_exception_flags(fp_status);
-        set_float_exception_flags(new_flags & ~float_flag_inexact, fp_status);
-    }
-
-    return ret;
-}
-
-float64 HELPER(rintd)(float64 x, void *fp_status)
-{
-    int old_flags = get_float_exception_flags(fp_status), new_flags;
-    float64 ret;
-
-    ret = float64_round_to_int(x, fp_status);
-
-    new_flags = get_float_exception_flags(fp_status);
-
-    /* Suppress any inexact exceptions the conversion produced */
-    if (!(old_flags & float_flag_inexact)) {
-        new_flags = get_float_exception_flags(fp_status);
-        set_float_exception_flags(new_flags & ~float_flag_inexact, fp_status);
-    }
-
-    return ret;
-}
-
-/* Convert ARM rounding mode to softfloat */
-int arm_rmode_to_sf(int rmode)
-{
-    switch (rmode) {
-    case FPROUNDING_TIEAWAY:
-        rmode = float_round_ties_away;
-        break;
-    case FPROUNDING_ODD:
-        /* FIXME: add support for TIEAWAY and ODD */
-        qemu_log_mask(LOG_UNIMP, "arm: unimplemented rounding mode: %d\n",
-                      rmode);
-        /* fall through for now */
-    case FPROUNDING_TIEEVEN:
-    default:
-        rmode = float_round_nearest_even;
-        break;
-    case FPROUNDING_POSINF:
-        rmode = float_round_up;
-        break;
-    case FPROUNDING_NEGINF:
-        rmode = float_round_down;
-        break;
-    case FPROUNDING_ZERO:
-        rmode = float_round_to_zero;
-        break;
-    }
-    return rmode;
-}
-
 /* CRC helpers.
  * The upper bytes of val (above the number specified by 'bytes') must have
  * been zeroed out by the caller.
diff --git a/target/arm/vfp_helper.c b/target/arm/vfp_helper.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/target/arm/vfp_helper.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * ARM VFP floating-point operations
+ *
+ *  Copyright (c) 2003 Fabrice Bellard
+ *
+ * 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 "qemu/log.h"
+#include "cpu.h"
+#include "exec/helper-proto.h"
+#include "fpu/softfloat.h"
+#include "internals.h"
+
+
+/* VFP support.  We follow the convention used for VFP instructions:
+   Single precision routines have a "s" suffix, double precision a
+   "d" suffix.  */
+
+/* Convert host exception flags to vfp form.  */
+static inline int vfp_exceptbits_from_host(int host_bits)
+{
+    int target_bits = 0;
+
+    if (host_bits & float_flag_invalid)
+        target_bits |= 1;
+    if (host_bits & float_flag_divbyzero)
+        target_bits |= 2;
+    if (host_bits & float_flag_overflow)
+        target_bits |= 4;
+    if (host_bits & (float_flag_underflow | float_flag_output_denormal))
+        target_bits |= 8;
+    if (host_bits & float_flag_inexact)
+        target_bits |= 0x10;
+    if (host_bits & float_flag_input_denormal)
+        target_bits |= 0x80;
+    return target_bits;
+}
+
+uint32_t HELPER(vfp_get_fpscr)(CPUARMState *env)
+{
+    uint32_t i, fpscr;
+
+    fpscr = env->vfp.xregs[ARM_VFP_FPSCR]
+            | (env->vfp.vec_len << 16)
+            | (env->vfp.vec_stride << 20);
+
+    i = get_float_exception_flags(&env->vfp.fp_status);
+    i |= get_float_exception_flags(&env->vfp.standard_fp_status);
+    /* FZ16 does not generate an input denormal exception.  */
+    i |= (get_float_exception_flags(&env->vfp.fp_status_f16)
+          & ~float_flag_input_denormal);
+    fpscr |= vfp_exceptbits_from_host(i);
+
+    i = env->vfp.qc[0] | env->vfp.qc[1] | env->vfp.qc[2] | env->vfp.qc[3];
+    fpscr |= i ? FPCR_QC : 0;
+
+    return fpscr;
+}
+
+uint32_t vfp_get_fpscr(CPUARMState *env)
+{
+    return HELPER(vfp_get_fpscr)(env);
+}
+
+/* Convert vfp exception flags to target form.  */
+static inline int vfp_exceptbits_to_host(int target_bits)
+{
+    int host_bits = 0;
+
+    if (target_bits & 1)
+        host_bits |= float_flag_invalid;
+    if (target_bits & 2)
+        host_bits |= float_flag_divbyzero;
+    if (target_bits & 4)
+        host_bits |= float_flag_overflow;
+    if (target_bits & 8)
+        host_bits |= float_flag_underflow;
+    if (target_bits & 0x10)
+        host_bits |= float_flag_inexact;
+    if (target_bits & 0x80)
+        host_bits |= float_flag_input_denormal;
+    return host_bits;
+}
+
+void HELPER(vfp_set_fpscr)(CPUARMState *env, uint32_t val)
+{
+    int i;
+    uint32_t changed = env->vfp.xregs[ARM_VFP_FPSCR];
+
+    /* When ARMv8.2-FP16 is not supported, FZ16 is RES0.  */
+    if (!cpu_isar_feature(aa64_fp16, arm_env_get_cpu(env))) {
+        val &= ~FPCR_FZ16;
+    }
+
+    /*
+     * We don't implement trapped exception handling, so the
+     * trap enable bits, IDE|IXE|UFE|OFE|DZE|IOE are all RAZ/WI (not RES0!)
+     *
+     * If we exclude the exception flags, IOC|DZC|OFC|UFC|IXC|IDC
+     * (which are stored in fp_status), and the other RES0 bits
+     * in between, then we clear all of the low 16 bits.
+     */
+    env->vfp.xregs[ARM_VFP_FPSCR] = val & 0xf7c80000;
+    env->vfp.vec_len = (val >> 16) & 7;
+    env->vfp.vec_stride = (val >> 20) & 3;
+
+    /*
+     * The bit we set within fpscr_q is arbitrary; the register as a
+     * whole being zero/non-zero is what counts.
+     */
+    env->vfp.qc[0] = val & FPCR_QC;
+    env->vfp.qc[1] = 0;
+    env->vfp.qc[2] = 0;
+    env->vfp.qc[3] = 0;
+
+    changed ^= val;
+    if (changed & (3 << 22)) {
+        i = (val >> 22) & 3;
+        switch (i) {
+        case FPROUNDING_TIEEVEN:
+            i = float_round_nearest_even;
+            break;
+        case FPROUNDING_POSINF:
+            i = float_round_up;
+            break;
+        case FPROUNDING_NEGINF:
+            i = float_round_down;
+            break;
+        case FPROUNDING_ZERO:
+            i = float_round_to_zero;
+            break;
+        }
+        set_float_rounding_mode(i, &env->vfp.fp_status);
+        set_float_rounding_mode(i, &env->vfp.fp_status_f16);
+    }
+    if (changed & FPCR_FZ16) {
+        bool ftz_enabled = val & FPCR_FZ16;
+        set_flush_to_zero(ftz_enabled, &env->vfp.fp_status_f16);
+        set_flush_inputs_to_zero(ftz_enabled, &env->vfp.fp_status_f16);
+    }
+    if (changed & FPCR_FZ) {
+        bool ftz_enabled = val & FPCR_FZ;
+        set_flush_to_zero(ftz_enabled, &env->vfp.fp_status);
+        set_flush_inputs_to_zero(ftz_enabled, &env->vfp.fp_status);
+    }
+    if (changed & FPCR_DN) {
+        bool dnan_enabled = val & FPCR_DN;
+        set_default_nan_mode(dnan_enabled, &env->vfp.fp_status);
+        set_default_nan_mode(dnan_enabled, &env->vfp.fp_status_f16);
+    }
+
+    /* The exception flags are ORed together when we read fpscr so we
+     * only need to preserve the current state in one of our
+     * float_status values.
+     */
+    i = vfp_exceptbits_to_host(val);
+    set_float_exception_flags(i, &env->vfp.fp_status);
+    set_float_exception_flags(0, &env->vfp.fp_status_f16);
+    set_float_exception_flags(0, &env->vfp.standard_fp_status);
+}
+
+void vfp_set_fpscr(CPUARMState *env, uint32_t val)
+{
+    HELPER(vfp_set_fpscr)(env, val);
+}
+
+#define VFP_HELPER(name, p) HELPER(glue(glue(vfp_,name),p))
+
+#define VFP_BINOP(name) \
+float32 VFP_HELPER(name, s)(float32 a, float32 b, void *fpstp) \
+{ \
+    float_status *fpst = fpstp; \
+    return float32_ ## name(a, b, fpst); \
+} \
+float64 VFP_HELPER(name, d)(float64 a, float64 b, void *fpstp) \
+{ \
+    float_status *fpst = fpstp; \
+    return float64_ ## name(a, b, fpst); \
+}
+VFP_BINOP(add)
+VFP_BINOP(sub)
+VFP_BINOP(mul)
+VFP_BINOP(div)
+VFP_BINOP(min)
+VFP_BINOP(max)
+VFP_BINOP(minnum)
+VFP_BINOP(maxnum)
+#undef VFP_BINOP
+
+float32 VFP_HELPER(neg, s)(float32 a)
+{
+    return float32_chs(a);
+}
+
+float64 VFP_HELPER(neg, d)(float64 a)
+{
+    return float64_chs(a);
+}
+
+float32 VFP_HELPER(abs, s)(float32 a)
+{
+    return float32_abs(a);
+}
+
+float64 VFP_HELPER(abs, d)(float64 a)
+{
+    return float64_abs(a);
+}
+
+float32 VFP_HELPER(sqrt, s)(float32 a, CPUARMState *env)
+{
+    return float32_sqrt(a, &env->vfp.fp_status);
+}
+
+float64 VFP_HELPER(sqrt, d)(float64 a, CPUARMState *env)
+{
+    return float64_sqrt(a, &env->vfp.fp_status);
+}
+
+static void softfloat_to_vfp_compare(CPUARMState *env, int cmp)
+{
+    uint32_t flags;
+    switch (cmp) {
+    case float_relation_equal:
+        flags = 0x6;
+        break;
+    case float_relation_less:
+        flags = 0x8;
+        break;
+    case float_relation_greater:
+        flags = 0x2;
+        break;
+    case float_relation_unordered:
+        flags = 0x3;
+        break;
+    default:
+        g_assert_not_reached();
+    }
+    env->vfp.xregs[ARM_VFP_FPSCR] =
+        deposit32(env->vfp.xregs[ARM_VFP_FPSCR], 28, 4, flags);
+}
+
+/* XXX: check quiet/signaling case */
+#define DO_VFP_cmp(p, type) \
+void VFP_HELPER(cmp, p)(type a, type b, CPUARMState *env)  \
+{ \
+    softfloat_to_vfp_compare(env, \
+        type ## _compare_quiet(a, b, &env->vfp.fp_status)); \
+} \
+void VFP_HELPER(cmpe, p)(type a, type b, CPUARMState *env) \
+{ \
+    softfloat_to_vfp_compare(env, \
+        type ## _compare(a, b, &env->vfp.fp_status)); \
+}
+DO_VFP_cmp(s, float32)
+DO_VFP_cmp(d, float64)
+#undef DO_VFP_cmp
+
+/* Integer to float and float to integer conversions */
+
+#define CONV_ITOF(name, ftype, fsz, sign)                           \
+ftype HELPER(name)(uint32_t x, void *fpstp)                         \
+{                                                                   \
+    float_status *fpst = fpstp;                                     \
+    return sign##int32_to_##float##fsz((sign##int32_t)x, fpst);     \
+}
+
+#define CONV_FTOI(name, ftype, fsz, sign, round)                \
+sign##int32_t HELPER(name)(ftype x, void *fpstp)                \
+{                                                               \
+    float_status *fpst = fpstp;                                 \
+    if (float##fsz##_is_any_nan(x)) {                           \
+        float_raise(float_flag_invalid, fpst);                  \
+        return 0;                                               \
+    }                                                           \
+    return float##fsz##_to_##sign##int32##round(x, fpst);       \
+}
+
+#define FLOAT_CONVS(name, p, ftype, fsz, sign)            \
+    CONV_ITOF(vfp_##name##to##p, ftype, fsz, sign)        \
+    CONV_FTOI(vfp_to##name##p, ftype, fsz, sign, )        \
+    CONV_FTOI(vfp_to##name##z##p, ftype, fsz, sign, _round_to_zero)
+
+FLOAT_CONVS(si, h, uint32_t, 16, )
+FLOAT_CONVS(si, s, float32, 32, )
+FLOAT_CONVS(si, d, float64, 64, )
+FLOAT_CONVS(ui, h, uint32_t, 16, u)
+FLOAT_CONVS(ui, s, float32, 32, u)
+FLOAT_CONVS(ui, d, float64, 64, u)
+
+#undef CONV_ITOF
+#undef CONV_FTOI
+#undef FLOAT_CONVS
+
+/* floating point conversion */
+float64 VFP_HELPER(fcvtd, s)(float32 x, CPUARMState *env)
+{
+    return float32_to_float64(x, &env->vfp.fp_status);
+}
+
+float32 VFP_HELPER(fcvts, d)(float64 x, CPUARMState *env)
+{
+    return float64_to_float32(x, &env->vfp.fp_status);
+}
+
+/* VFP3 fixed point conversion.  */
+#define VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype) \
+float##fsz HELPER(vfp_##name##to##p)(uint##isz##_t  x, uint32_t shift, \
+                                     void *fpstp) \
+{ return itype##_to_##float##fsz##_scalbn(x, -shift, fpstp); }
+
+#define VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype, ROUND, suff)   \
+uint##isz##_t HELPER(vfp_to##name##p##suff)(float##fsz x, uint32_t shift, \
+                                            void *fpst)                   \
+{                                                                         \
+    if (unlikely(float##fsz##_is_any_nan(x))) {                           \
+        float_raise(float_flag_invalid, fpst);                            \
+        return 0;                                                         \
+    }                                                                     \
+    return float##fsz##_to_##itype##_scalbn(x, ROUND, shift, fpst);       \
+}
+
+#define VFP_CONV_FIX(name, p, fsz, isz, itype)                   \
+VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype)                     \
+VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
+                         float_round_to_zero, _round_to_zero)    \
+VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
+                         get_float_rounding_mode(fpst), )
+
+#define VFP_CONV_FIX_A64(name, p, fsz, isz, itype)               \
+VFP_CONV_FIX_FLOAT(name, p, fsz, isz, itype)                     \
+VFP_CONV_FLOAT_FIX_ROUND(name, p, fsz, isz, itype,               \
+                         get_float_rounding_mode(fpst), )
+
+VFP_CONV_FIX(sh, d, 64, 64, int16)
+VFP_CONV_FIX(sl, d, 64, 64, int32)
+VFP_CONV_FIX_A64(sq, d, 64, 64, int64)
+VFP_CONV_FIX(uh, d, 64, 64, uint16)
+VFP_CONV_FIX(ul, d, 64, 64, uint32)
+VFP_CONV_FIX_A64(uq, d, 64, 64, uint64)
+VFP_CONV_FIX(sh, s, 32, 32, int16)
+VFP_CONV_FIX(sl, s, 32, 32, int32)
+VFP_CONV_FIX_A64(sq, s, 32, 64, int64)
+VFP_CONV_FIX(uh, s, 32, 32, uint16)
+VFP_CONV_FIX(ul, s, 32, 32, uint32)
+VFP_CONV_FIX_A64(uq, s, 32, 64, uint64)
+
+#undef VFP_CONV_FIX
+#undef VFP_CONV_FIX_FLOAT
+#undef VFP_CONV_FLOAT_FIX_ROUND
+#undef VFP_CONV_FIX_A64
+
+uint32_t HELPER(vfp_sltoh)(uint32_t x, uint32_t shift, void *fpst)
+{
+    return int32_to_float16_scalbn(x, -shift, fpst);
+}
+
+uint32_t HELPER(vfp_ultoh)(uint32_t x, uint32_t shift, void *fpst)
+{
+    return uint32_to_float16_scalbn(x, -shift, fpst);
+}
+
+uint32_t HELPER(vfp_sqtoh)(uint64_t x, uint32_t shift, void *fpst)
+{
+    return int64_to_float16_scalbn(x, -shift, fpst);
+}
+
+uint32_t HELPER(vfp_uqtoh)(uint64_t x, uint32_t shift, void *fpst)
+{
+    return uint64_to_float16_scalbn(x, -shift, fpst);
+}
+
+uint32_t HELPER(vfp_toshh)(uint32_t x, uint32_t shift, void *fpst)
+{
+    if (unlikely(float16_is_any_nan(x))) {
+        float_raise(float_flag_invalid, fpst);
+        return 0;
+    }
+    return float16_to_int16_scalbn(x, get_float_rounding_mode(fpst),
+                                   shift, fpst);
+}
+
+uint32_t HELPER(vfp_touhh)(uint32_t x, uint32_t shift, void *fpst)
+{
+    if (unlikely(float16_is_any_nan(x))) {
+        float_raise(float_flag_invalid, fpst);
+        return 0;
+    }
+    return float16_to_uint16_scalbn(x, get_float_rounding_mode(fpst),
+                                    shift, fpst);
+}
+
+uint32_t HELPER(vfp_toslh)(uint32_t x, uint32_t shift, void *fpst)
+{
+    if (unlikely(float16_is_any_nan(x))) {
+        float_raise(float_flag_invalid, fpst);
+        return 0;
+    }
+    return float16_to_int32_scalbn(x, get_float_rounding_mode(fpst),
+                                   shift, fpst);
+}
+
+uint32_t HELPER(vfp_toulh)(uint32_t x, uint32_t shift, void *fpst)
+{
+    if (unlikely(float16_is_any_nan(x))) {
+        float_raise(float_flag_invalid, fpst);
+        return 0;
+    }
+    return float16_to_uint32_scalbn(x, get_float_rounding_mode(fpst),
+                                    shift, fpst);
+}
+
+uint64_t HELPER(vfp_tosqh)(uint32_t x, uint32_t shift, void *fpst)
+{
+    if (unlikely(float16_is_any_nan(x))) {
+        float_raise(float_flag_invalid, fpst);
+        return 0;
+    }
+    return float16_to_int64_scalbn(x, get_float_rounding_mode(fpst),
+                                   shift, fpst);
+}
+
+uint64_t HELPER(vfp_touqh)(uint32_t x, uint32_t shift, void *fpst)
+{
+    if (unlikely(float16_is_any_nan(x))) {
+        float_raise(float_flag_invalid, fpst);
+        return 0;
+    }
+    return float16_to_uint64_scalbn(x, get_float_rounding_mode(fpst),
+                                    shift, fpst);
+}
+
+/* Set the current fp rounding mode and return the old one.
+ * The argument is a softfloat float_round_ value.
+ */
+uint32_t HELPER(set_rmode)(uint32_t rmode, void *fpstp)
+{
+    float_status *fp_status = fpstp;
+
+    uint32_t prev_rmode = get_float_rounding_mode(fp_status);
+    set_float_rounding_mode(rmode, fp_status);
+
+    return prev_rmode;
+}
+
+/* Set the current fp rounding mode in the standard fp status and return
+ * the old one. This is for NEON instructions that need to change the
+ * rounding mode but wish to use the standard FPSCR values for everything
+ * else. Always set the rounding mode back to the correct value after
+ * modifying it.
+ * The argument is a softfloat float_round_ value.
+ */
+uint32_t HELPER(set_neon_rmode)(uint32_t rmode, CPUARMState *env)
+{
+    float_status *fp_status = &env->vfp.standard_fp_status;
+
+    uint32_t prev_rmode = get_float_rounding_mode(fp_status);
+    set_float_rounding_mode(rmode, fp_status);
+
+    return prev_rmode;
+}
+
+/* Half precision conversions.  */
+float32 HELPER(vfp_fcvt_f16_to_f32)(uint32_t a, void *fpstp, uint32_t ahp_mode)
+{
+    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
+     * it would affect flushing input denormals.
+     */
+    float_status *fpst = fpstp;
+    flag save = get_flush_inputs_to_zero(fpst);
+    set_flush_inputs_to_zero(false, fpst);
+    float32 r = float16_to_float32(a, !ahp_mode, fpst);
+    set_flush_inputs_to_zero(save, fpst);
+    return r;
+}
+
+uint32_t HELPER(vfp_fcvt_f32_to_f16)(float32 a, void *fpstp, uint32_t ahp_mode)
+{
+    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
+     * it would affect flushing output denormals.
+     */
+    float_status *fpst = fpstp;
+    flag save = get_flush_to_zero(fpst);
+    set_flush_to_zero(false, fpst);
+    float16 r = float32_to_float16(a, !ahp_mode, fpst);
+    set_flush_to_zero(save, fpst);
+    return r;
+}
+
+float64 HELPER(vfp_fcvt_f16_to_f64)(uint32_t a, void *fpstp, uint32_t ahp_mode)
+{
+    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
+     * it would affect flushing input denormals.
+     */
+    float_status *fpst = fpstp;
+    flag save = get_flush_inputs_to_zero(fpst);
+    set_flush_inputs_to_zero(false, fpst);
+    float64 r = float16_to_float64(a, !ahp_mode, fpst);
+    set_flush_inputs_to_zero(save, fpst);
+    return r;
+}
+
+uint32_t HELPER(vfp_fcvt_f64_to_f16)(float64 a, void *fpstp, uint32_t ahp_mode)
+{
+    /* Squash FZ16 to 0 for the duration of conversion.  In this case,
+     * it would affect flushing output denormals.
+     */
+    float_status *fpst = fpstp;
+    flag save = get_flush_to_zero(fpst);
+    set_flush_to_zero(false, fpst);
+    float16 r = float64_to_float16(a, !ahp_mode, fpst);
+    set_flush_to_zero(save, fpst);
+    return r;
+}
+
+#define float32_two make_float32(0x40000000)
+#define float32_three make_float32(0x40400000)
+#define float32_one_point_five make_float32(0x3fc00000)
+
+float32 HELPER(recps_f32)(float32 a, float32 b, CPUARMState *env)
+{
+    float_status *s = &env->vfp.standard_fp_status;
+    if ((float32_is_infinity(a) && float32_is_zero_or_denormal(b)) ||
+        (float32_is_infinity(b) && float32_is_zero_or_denormal(a))) {
+        if (!(float32_is_zero(a) || float32_is_zero(b))) {
+            float_raise(float_flag_input_denormal, s);
+        }
+        return float32_two;
+    }
+    return float32_sub(float32_two, float32_mul(a, b, s), s);
+}
+
+float32 HELPER(rsqrts_f32)(float32 a, float32 b, CPUARMState *env)
+{
+    float_status *s = &env->vfp.standard_fp_status;
+    float32 product;
+    if ((float32_is_infinity(a) && float32_is_zero_or_denormal(b)) ||
+        (float32_is_infinity(b) && float32_is_zero_or_denormal(a))) {
+        if (!(float32_is_zero(a) || float32_is_zero(b))) {
+            float_raise(float_flag_input_denormal, s);
+        }
+        return float32_one_point_five;
+    }
+    product = float32_mul(a, b, s);
+    return float32_div(float32_sub(float32_three, product, s), float32_two, s);
+}
+
+/* NEON helpers.  */
+
+/* Constants 256 and 512 are used in some helpers; we avoid relying on
+ * int->float conversions at run-time.  */
+#define float64_256 make_float64(0x4070000000000000LL)
+#define float64_512 make_float64(0x4080000000000000LL)
+#define float16_maxnorm make_float16(0x7bff)
+#define float32_maxnorm make_float32(0x7f7fffff)
+#define float64_maxnorm make_float64(0x7fefffffffffffffLL)
+
+/* Reciprocal functions
+ *
+ * The algorithm that must be used to calculate the estimate
+ * is specified by the ARM ARM, see FPRecipEstimate()/RecipEstimate
+ */
+
+/* See RecipEstimate()
+ *
+ * input is a 9 bit fixed point number
+ * input range 256 .. 511 for a number from 0.5 <= x < 1.0.
+ * result range 256 .. 511 for a number from 1.0 to 511/256.
+ */
+
+static int recip_estimate(int input)
+{
+    int a, b, r;
+    assert(256 <= input && input < 512);
+    a = (input * 2) + 1;
+    b = (1 << 19) / a;
+    r = (b + 1) >> 1;
+    assert(256 <= r && r < 512);
+    return r;
+}
+
+/*
+ * Common wrapper to call recip_estimate
+ *
+ * The parameters are exponent and 64 bit fraction (without implicit
+ * bit) where the binary point is nominally at bit 52. Returns a
+ * float64 which can then be rounded to the appropriate size by the
+ * callee.
+ */
+
+static uint64_t call_recip_estimate(int *exp, int exp_off, uint64_t frac)
+{
+    uint32_t scaled, estimate;
+    uint64_t result_frac;
+    int result_exp;
+
+    /* Handle sub-normals */
+    if (*exp == 0) {
+        if (extract64(frac, 51, 1) == 0) {
+            *exp = -1;
+            frac <<= 2;
+        } else {
+            frac <<= 1;
+        }
+    }
+
+    /* scaled = UInt('1':fraction<51:44>) */
+    scaled = deposit32(1 << 8, 0, 8, extract64(frac, 44, 8));
+    estimate = recip_estimate(scaled);
+
+    result_exp = exp_off - *exp;
+    result_frac = deposit64(0, 44, 8, estimate);
+    if (result_exp == 0) {
+        result_frac = deposit64(result_frac >> 1, 51, 1, 1);
+    } else if (result_exp == -1) {
+        result_frac = deposit64(result_frac >> 2, 50, 2, 1);
+        result_exp = 0;
+    }
+
+    *exp = result_exp;
+
+    return result_frac;
+}
+
+static bool round_to_inf(float_status *fpst, bool sign_bit)
+{
+    switch (fpst->float_rounding_mode) {
+    case float_round_nearest_even: /* Round to Nearest */
+        return true;
+    case float_round_up: /* Round to +Inf */
+        return !sign_bit;
+    case float_round_down: /* Round to -Inf */
+        return sign_bit;
+    case float_round_to_zero: /* Round to Zero */
+        return false;
+    }
+
+    g_assert_not_reached();
+}
+
+uint32_t HELPER(recpe_f16)(uint32_t input, void *fpstp)
+{
+    float_status *fpst = fpstp;
+    float16 f16 = float16_squash_input_denormal(input, fpst);
+    uint32_t f16_val = float16_val(f16);
+    uint32_t f16_sign = float16_is_neg(f16);
+    int f16_exp = extract32(f16_val, 10, 5);
+    uint32_t f16_frac = extract32(f16_val, 0, 10);
+    uint64_t f64_frac;
+
+    if (float16_is_any_nan(f16)) {
+        float16 nan = f16;
+        if (float16_is_signaling_nan(f16, fpst)) {
+            float_raise(float_flag_invalid, fpst);
+            nan = float16_silence_nan(f16, fpst);
+        }
+        if (fpst->default_nan_mode) {
+            nan =  float16_default_nan(fpst);
+        }
+        return nan;
+    } else if (float16_is_infinity(f16)) {
+        return float16_set_sign(float16_zero, float16_is_neg(f16));
+    } else if (float16_is_zero(f16)) {
+        float_raise(float_flag_divbyzero, fpst);
+        return float16_set_sign(float16_infinity, float16_is_neg(f16));
+    } else if (float16_abs(f16) < (1 << 8)) {
+        /* Abs(value) < 2.0^-16 */
+        float_raise(float_flag_overflow | float_flag_inexact, fpst);
+        if (round_to_inf(fpst, f16_sign)) {
+            return float16_set_sign(float16_infinity, f16_sign);
+        } else {
+            return float16_set_sign(float16_maxnorm, f16_sign);
+        }
+    } else if (f16_exp >= 29 && fpst->flush_to_zero) {
+        float_raise(float_flag_underflow, fpst);
+        return float16_set_sign(float16_zero, float16_is_neg(f16));
+    }
+
+    f64_frac = call_recip_estimate(&f16_exp, 29,
+                                   ((uint64_t) f16_frac) << (52 - 10));
+
+    /* result = sign : result_exp<4:0> : fraction<51:42> */
+    f16_val = deposit32(0, 15, 1, f16_sign);
+    f16_val = deposit32(f16_val, 10, 5, f16_exp);
+    f16_val = deposit32(f16_val, 0, 10, extract64(f64_frac, 52 - 10, 10));
+    return make_float16(f16_val);
+}
+
+float32 HELPER(recpe_f32)(float32 input, void *fpstp)
+{
+    float_status *fpst = fpstp;
+    float32 f32 = float32_squash_input_denormal(input, fpst);
+    uint32_t f32_val = float32_val(f32);
+    bool f32_sign = float32_is_neg(f32);
+    int f32_exp = extract32(f32_val, 23, 8);
+    uint32_t f32_frac = extract32(f32_val, 0, 23);
+    uint64_t f64_frac;
+
+    if (float32_is_any_nan(f32)) {
+        float32 nan = f32;
+        if (float32_is_signaling_nan(f32, fpst)) {
+            float_raise(float_flag_invalid, fpst);
+            nan = float32_silence_nan(f32, fpst);
+        }
+        if (fpst->default_nan_mode) {
+            nan =  float32_default_nan(fpst);
+        }
+        return nan;
+    } else if (float32_is_infinity(f32)) {
+        return float32_set_sign(float32_zero, float32_is_neg(f32));
+    } else if (float32_is_zero(f32)) {
+        float_raise(float_flag_divbyzero, fpst);
+        return float32_set_sign(float32_infinity, float32_is_neg(f32));
+    } else if (float32_abs(f32) < (1ULL << 21)) {
+        /* Abs(value) < 2.0^-128 */
+        float_raise(float_flag_overflow | float_flag_inexact, fpst);
+        if (round_to_inf(fpst, f32_sign)) {
+            return float32_set_sign(float32_infinity, f32_sign);
+        } else {
+            return float32_set_sign(float32_maxnorm, f32_sign);
+        }
+    } else if (f32_exp >= 253 && fpst->flush_to_zero) {
+        float_raise(float_flag_underflow, fpst);
+        return float32_set_sign(float32_zero, float32_is_neg(f32));
+    }
+
+    f64_frac = call_recip_estimate(&f32_exp, 253,
+                                   ((uint64_t) f32_frac) << (52 - 23));
+
+    /* result = sign : result_exp<7:0> : fraction<51:29> */
+    f32_val = deposit32(0, 31, 1, f32_sign);
+    f32_val = deposit32(f32_val, 23, 8, f32_exp);
+    f32_val = deposit32(f32_val, 0, 23, extract64(f64_frac, 52 - 23, 23));
+    return make_float32(f32_val);
+}
+
+float64 HELPER(recpe_f64)(float64 input, void *fpstp)
+{
+    float_status *fpst = fpstp;
+    float64 f64 = float64_squash_input_denormal(input, fpst);
+    uint64_t f64_val = float64_val(f64);
+    bool f64_sign = float64_is_neg(f64);
+    int f64_exp = extract64(f64_val, 52, 11);
+    uint64_t f64_frac = extract64(f64_val, 0, 52);
+
+    /* Deal with any special cases */
+    if (float64_is_any_nan(f64)) {
+        float64 nan = f64;
+        if (float64_is_signaling_nan(f64, fpst)) {
+            float_raise(float_flag_invalid, fpst);
+            nan = float64_silence_nan(f64, fpst);
+        }
+        if (fpst->default_nan_mode) {
+            nan =  float64_default_nan(fpst);
+        }
+        return nan;
+    } else if (float64_is_infinity(f64)) {
+        return float64_set_sign(float64_zero, float64_is_neg(f64));
+    } else if (float64_is_zero(f64)) {
+        float_raise(float_flag_divbyzero, fpst);
+        return float64_set_sign(float64_infinity, float64_is_neg(f64));
+    } else if ((f64_val & ~(1ULL << 63)) < (1ULL << 50)) {
+        /* Abs(value) < 2.0^-1024 */
+        float_raise(float_flag_overflow | float_flag_inexact, fpst);
+        if (round_to_inf(fpst, f64_sign)) {
+            return float64_set_sign(float64_infinity, f64_sign);
+        } else {
+            return float64_set_sign(float64_maxnorm, f64_sign);
+        }
+    } else if (f64_exp >= 2045 && fpst->flush_to_zero) {
+        float_raise(float_flag_underflow, fpst);
+        return float64_set_sign(float64_zero, float64_is_neg(f64));
+    }
+
+    f64_frac = call_recip_estimate(&f64_exp, 2045, f64_frac);
+
+    /* result = sign : result_exp<10:0> : fraction<51:0>; */
+    f64_val = deposit64(0, 63, 1, f64_sign);
+    f64_val = deposit64(f64_val, 52, 11, f64_exp);
+    f64_val = deposit64(f64_val, 0, 52, f64_frac);
+    return make_float64(f64_val);
+}
+
+/* The algorithm that must be used to calculate the estimate
+ * is specified by the ARM ARM.
+ */
+
+static int do_recip_sqrt_estimate(int a)
+{
+    int b, estimate;
+
+    assert(128 <= a && a < 512);
+    if (a < 256) {
+        a = a * 2 + 1;
+    } else {
+        a = (a >> 1) << 1;
+        a = (a + 1) * 2;
+    }
+    b = 512;
+    while (a * (b + 1) * (b + 1) < (1 << 28)) {
+        b += 1;
+    }
+    estimate = (b + 1) / 2;
+    assert(256 <= estimate && estimate < 512);
+
+    return estimate;
+}
+
+
+static uint64_t recip_sqrt_estimate(int *exp , int exp_off, uint64_t frac)
+{
+    int estimate;
+    uint32_t scaled;
+
+    if (*exp == 0) {
+        while (extract64(frac, 51, 1) == 0) {
+            frac = frac << 1;
+            *exp -= 1;
+        }
+        frac = extract64(frac, 0, 51) << 1;
+    }
+
+    if (*exp & 1) {
+        /* scaled = UInt('01':fraction<51:45>) */
+        scaled = deposit32(1 << 7, 0, 7, extract64(frac, 45, 7));
+    } else {
+        /* scaled = UInt('1':fraction<51:44>) */
+        scaled = deposit32(1 << 8, 0, 8, extract64(frac, 44, 8));
+    }
+    estimate = do_recip_sqrt_estimate(scaled);
+
+    *exp = (exp_off - *exp) / 2;
+    return extract64(estimate, 0, 8) << 44;
+}
+
+uint32_t HELPER(rsqrte_f16)(uint32_t input, void *fpstp)
+{
+    float_status *s = fpstp;
+    float16 f16 = float16_squash_input_denormal(input, s);
+    uint16_t val = float16_val(f16);
+    bool f16_sign = float16_is_neg(f16);
+    int f16_exp = extract32(val, 10, 5);
+    uint16_t f16_frac = extract32(val, 0, 10);
+    uint64_t f64_frac;
+
+    if (float16_is_any_nan(f16)) {
+        float16 nan = f16;
+        if (float16_is_signaling_nan(f16, s)) {
+            float_raise(float_flag_invalid, s);
+            nan = float16_silence_nan(f16, s);
+        }
+        if (s->default_nan_mode) {
+            nan =  float16_default_nan(s);
+        }
+        return nan;
+    } else if (float16_is_zero(f16)) {
+        float_raise(float_flag_divbyzero, s);
+        return float16_set_sign(float16_infinity, f16_sign);
+    } else if (f16_sign) {
+        float_raise(float_flag_invalid, s);
+        return float16_default_nan(s);
+    } else if (float16_is_infinity(f16)) {
+        return float16_zero;
+    }
+
+    /* Scale and normalize to a double-precision value between 0.25 and 1.0,
+     * preserving the parity of the exponent.  */
+
+    f64_frac = ((uint64_t) f16_frac) << (52 - 10);
+
+    f64_frac = recip_sqrt_estimate(&f16_exp, 44, f64_frac);
+
+    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(2) */
+    val = deposit32(0, 15, 1, f16_sign);
+    val = deposit32(val, 10, 5, f16_exp);
+    val = deposit32(val, 2, 8, extract64(f64_frac, 52 - 8, 8));
+    return make_float16(val);
+}
+
+float32 HELPER(rsqrte_f32)(float32 input, void *fpstp)
+{
+    float_status *s = fpstp;
+    float32 f32 = float32_squash_input_denormal(input, s);
+    uint32_t val = float32_val(f32);
+    uint32_t f32_sign = float32_is_neg(f32);
+    int f32_exp = extract32(val, 23, 8);
+    uint32_t f32_frac = extract32(val, 0, 23);
+    uint64_t f64_frac;
+
+    if (float32_is_any_nan(f32)) {
+        float32 nan = f32;
+        if (float32_is_signaling_nan(f32, s)) {
+            float_raise(float_flag_invalid, s);
+            nan = float32_silence_nan(f32, s);
+        }
+        if (s->default_nan_mode) {
+            nan =  float32_default_nan(s);
+        }
+        return nan;
+    } else if (float32_is_zero(f32)) {
+        float_raise(float_flag_divbyzero, s);
+        return float32_set_sign(float32_infinity, float32_is_neg(f32));
+    } else if (float32_is_neg(f32)) {
+        float_raise(float_flag_invalid, s);
+        return float32_default_nan(s);
+    } else if (float32_is_infinity(f32)) {
+        return float32_zero;
+    }
+
+    /* Scale and normalize to a double-precision value between 0.25 and 1.0,
+     * preserving the parity of the exponent.  */
+
+    f64_frac = ((uint64_t) f32_frac) << 29;
+
+    f64_frac = recip_sqrt_estimate(&f32_exp, 380, f64_frac);
+
+    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(15) */
+    val = deposit32(0, 31, 1, f32_sign);
+    val = deposit32(val, 23, 8, f32_exp);
+    val = deposit32(val, 15, 8, extract64(f64_frac, 52 - 8, 8));
+    return make_float32(val);
+}
+
+float64 HELPER(rsqrte_f64)(float64 input, void *fpstp)
+{
+    float_status *s = fpstp;
+    float64 f64 = float64_squash_input_denormal(input, s);
+    uint64_t val = float64_val(f64);
+    bool f64_sign = float64_is_neg(f64);
+    int f64_exp = extract64(val, 52, 11);
+    uint64_t f64_frac = extract64(val, 0, 52);
+
+    if (float64_is_any_nan(f64)) {
+        float64 nan = f64;
+        if (float64_is_signaling_nan(f64, s)) {
+            float_raise(float_flag_invalid, s);
+            nan = float64_silence_nan(f64, s);
+        }
+        if (s->default_nan_mode) {
+            nan =  float64_default_nan(s);
+        }
+        return nan;
+    } else if (float64_is_zero(f64)) {
+        float_raise(float_flag_divbyzero, s);
+        return float64_set_sign(float64_infinity, float64_is_neg(f64));
+    } else if (float64_is_neg(f64)) {
+        float_raise(float_flag_invalid, s);
+        return float64_default_nan(s);
+    } else if (float64_is_infinity(f64)) {
+        return float64_zero;
+    }
+
+    f64_frac = recip_sqrt_estimate(&f64_exp, 3068, f64_frac);
+
+    /* result = sign : result_exp<4:0> : estimate<7:0> : Zeros(44) */
+    val = deposit64(0, 61, 1, f64_sign);
+    val = deposit64(val, 52, 11, f64_exp);
+    val = deposit64(val, 44, 8, extract64(f64_frac, 52 - 8, 8));
+    return make_float64(val);
+}
+
+uint32_t HELPER(recpe_u32)(uint32_t a, void *fpstp)
+{
+    /* float_status *s = fpstp; */
+    int input, estimate;
+
+    if ((a & 0x80000000) == 0) {
+        return 0xffffffff;
+    }
+
+    input = extract32(a, 23, 9);
+    estimate = recip_estimate(input);
+
+    return deposit32(0, (32 - 9), 9, estimate);
+}
+
+uint32_t HELPER(rsqrte_u32)(uint32_t a, void *fpstp)
+{
+    int estimate;
+
+    if ((a & 0xc0000000) == 0) {
+        return 0xffffffff;
+    }
+
+    estimate = do_recip_sqrt_estimate(extract32(a, 23, 9));
+
+    return deposit32(0, 23, 9, estimate);
+}
+
+/* VFPv4 fused multiply-accumulate */
+float32 VFP_HELPER(muladd, s)(float32 a, float32 b, float32 c, void *fpstp)
+{
+    float_status *fpst = fpstp;
+    return float32_muladd(a, b, c, 0, fpst);
+}
+
+float64 VFP_HELPER(muladd, d)(float64 a, float64 b, float64 c, void *fpstp)
+{
+    float_status *fpst = fpstp;
+    return float64_muladd(a, b, c, 0, fpst);
+}
+
+/* ARMv8 round to integral */
+float32 HELPER(rints_exact)(float32 x, void *fp_status)
+{
+    return float32_round_to_int(x, fp_status);
+}
+
+float64 HELPER(rintd_exact)(float64 x, void *fp_status)
+{
+    return float64_round_to_int(x, fp_status);
+}
+
+float32 HELPER(rints)(float32 x, void *fp_status)
+{
+    int old_flags = get_float_exception_flags(fp_status), new_flags;
+    float32 ret;
+
+    ret = float32_round_to_int(x, fp_status);
+
+    /* Suppress any inexact exceptions the conversion produced */
+    if (!(old_flags & float_flag_inexact)) {
+        new_flags = get_float_exception_flags(fp_status);
+        set_float_exception_flags(new_flags & ~float_flag_inexact, fp_status);
+    }
+
+    return ret;
+}
+
+float64 HELPER(rintd)(float64 x, void *fp_status)
+{
+    int old_flags = get_float_exception_flags(fp_status), new_flags;
+    float64 ret;
+
+    ret = float64_round_to_int(x, fp_status);
+
+    new_flags = get_float_exception_flags(fp_status);
+
+    /* Suppress any inexact exceptions the conversion produced */
+    if (!(old_flags & float_flag_inexact)) {
+        new_flags = get_float_exception_flags(fp_status);
+        set_float_exception_flags(new_flags & ~float_flag_inexact, fp_status);
+    }
+
+    return ret;
+}
+
+/* Convert ARM rounding mode to softfloat */
+int arm_rmode_to_sf(int rmode)
+{
+    switch (rmode) {
+    case FPROUNDING_TIEAWAY:
+        rmode = float_round_ties_away;
+        break;
+    case FPROUNDING_ODD:
+        /* FIXME: add support for TIEAWAY and ODD */
+        qemu_log_mask(LOG_UNIMP, "arm: unimplemented rounding mode: %d\n",
+                      rmode);
+        /* fall through for now */
+    case FPROUNDING_TIEEVEN:
+    default:
+        rmode = float_round_nearest_even;
+        break;
+    case FPROUNDING_POSINF:
+        rmode = float_round_up;
+        break;
+    case FPROUNDING_NEGINF:
+        rmode = float_round_down;
+        break;
+    case FPROUNDING_ZERO:
+        rmode = float_round_to_zero;
+        break;
+    }
+    return rmode;
+}
-- 
2.20.1

From: Richard Henderson <richard.henderson@linaro.org>

There are lots of special cases within these insns.  Split the
major argument decode/loading/saving into no_output (compares),
rd_is_dp, and rm_is_dp.

We still need to special case argument load for compare (rd as
input, rm as zero) and vcvt fixed (rd as input+output), but lots
of special cases do disappear.

Now that we have a full switch at the beginning, hoist the ISA
checks from the code generation.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-id: 20190215192302.27855-4-richard.henderson@linaro.org
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 target/arm/translate.c | 227 ++++++++++++++++++++---------------------
 1 file changed, 111 insertions(+), 116 deletions(-)

diff --git a/target/arm/translate.c b/target/arm/translate.c
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/translate.c
+++ b/target/arm/translate.c
@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
             }
         } else {
             /* data processing */
+            bool rd_is_dp = dp;
+            bool rm_is_dp = dp;
+            bool no_output = false;
+
             /* The opcode is in bits 23, 21, 20 and 6.  */
             op = ((insn >> 20) & 8) | ((insn >> 19) & 6) | ((insn >> 6) & 1);
-            if (dp) {
-                if (op == 15) {
-                    /* rn is opcode */
-                    rn = ((insn >> 15) & 0x1e) | ((insn >> 7) & 1);
-                } else {
-                    /* rn is register number */
-                    VFP_DREG_N(rn, insn);
-                }
+            rn = VFP_SREG_N(insn);
 
-                if (op == 15 && (rn == 15 || ((rn & 0x1c) == 0x18) ||
-                                 ((rn & 0x1e) == 0x6))) {
-                    /* Integer or single/half precision destination.  */
-                    rd = VFP_SREG_D(insn);
-                } else {
-                    VFP_DREG_D(rd, insn);
-                }
-                if (op == 15 &&
-                    (((rn & 0x1c) == 0x10) || ((rn & 0x14) == 0x14) ||
-                     ((rn & 0x1e) == 0x4))) {
-                    /* VCVT from int or half precision is always from S reg
-                     * regardless of dp bit. VCVT with immediate frac_bits
-                     * has same format as SREG_M.
+            if (op == 15) {
+                /* rn is opcode, encoded as per VFP_SREG_N. */
+                switch (rn) {
+                case 0x00: /* vmov */
+                case 0x01: /* vabs */
+                case 0x02: /* vneg */
+                case 0x03: /* vsqrt */
+                    break;
+
+                case 0x04: /* vcvtb.f64.f16, vcvtb.f32.f16 */
+                case 0x05: /* vcvtt.f64.f16, vcvtt.f32.f16 */
+                    /*
+                     * VCVTB, VCVTT: only present with the halfprec extension
+                     * UNPREDICTABLE if bit 8 is set prior to ARMv8
+                     * (we choose to UNDEF)
                      */
-                    rm = VFP_SREG_M(insn);
-                } else {
-                    VFP_DREG_M(rm, insn);
+                    if ((dp && !arm_dc_feature(s, ARM_FEATURE_V8)) ||
+                        !arm_dc_feature(s, ARM_FEATURE_VFP_FP16)) {
+                        return 1;
+                    }
+                    rm_is_dp = false;
+                    break;
+                case 0x06: /* vcvtb.f16.f32, vcvtb.f16.f64 */
+                case 0x07: /* vcvtt.f16.f32, vcvtt.f16.f64 */
+                    if ((dp && !arm_dc_feature(s, ARM_FEATURE_V8)) ||
+                        !arm_dc_feature(s, ARM_FEATURE_VFP_FP16)) {
+                        return 1;
+                    }
+                    rd_is_dp = false;
+                    break;
+
+                case 0x08: case 0x0a: /* vcmp, vcmpz */
+                case 0x09: case 0x0b: /* vcmpe, vcmpez */
+                    no_output = true;
+                    break;
+
+                case 0x0c: /* vrintr */
+                case 0x0d: /* vrintz */
+                case 0x0e: /* vrintx */
+                    break;
+
+                case 0x0f: /* vcvt double<->single */
+                    rd_is_dp = !dp;
+                    break;
+
+                case 0x10: /* vcvt.fxx.u32 */
+                case 0x11: /* vcvt.fxx.s32 */
+                    rm_is_dp = false;
+                    break;
+                case 0x18: /* vcvtr.u32.fxx */
+                case 0x19: /* vcvtz.u32.fxx */
+                case 0x1a: /* vcvtr.s32.fxx */
+                case 0x1b: /* vcvtz.s32.fxx */
+                    rd_is_dp = false;
+                    break;
+
+                case 0x14: /* vcvt fp <-> fixed */
+                case 0x15:
+                case 0x16:
+                case 0x17:
+                case 0x1c:
+                case 0x1d:
+                case 0x1e:
+                case 0x1f:
+                    if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
+                        return 1;
+                    }
+                    /* Immediate frac_bits has same format as SREG_M.  */
+                    rm_is_dp = false;
+                    break;
+
+                default:
+                    return 1;
                 }
+            } else if (dp) {
+                /* rn is register number */
+                VFP_DREG_N(rn, insn);
+            }
+
+            if (rd_is_dp) {
+                VFP_DREG_D(rd, insn);
+            } else {
+                rd = VFP_SREG_D(insn);
+            }
+            if (rm_is_dp) {
+                VFP_DREG_M(rm, insn);
             } else {
-                rn = VFP_SREG_N(insn);
-                if (op == 15 && rn == 15) {
-                    /* Double precision destination.  */
-                    VFP_DREG_D(rd, insn);
-                } else {
-                    rd = VFP_SREG_D(insn);
-                }
-                /* NB that we implicitly rely on the encoding for the frac_bits
-                 * in VCVT of fixed to float being the same as that of an SREG_M
-                 */
                 rm = VFP_SREG_M(insn);
             }
 
             veclen = s->vec_len;
-            if (op == 15 && rn > 3)
+            if (op == 15 && rn > 3) {
                 veclen = 0;
+            }
 
             /* Shut up compiler warnings.  */
             delta_m = 0;
@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
             /* Load the initial operands.  */
             if (op == 15) {
                 switch (rn) {
-                case 16:
-                case 17:
-                    /* Integer source */
-                    gen_mov_F0_vreg(0, rm);
-                    break;
-                case 8:
-                case 9:
-                    /* Compare */
+                case 0x08: case 0x09: /* Compare */
                     gen_mov_F0_vreg(dp, rd);
                     gen_mov_F1_vreg(dp, rm);
                     break;
-                case 10:
-                case 11:
-                    /* Compare with zero */
+                case 0x0a: case 0x0b: /* Compare with zero */
                     gen_mov_F0_vreg(dp, rd);
                     gen_vfp_F1_ld0(dp);
                     break;
-                case 20:
-                case 21:
-                case 22:
-                case 23:
-                case 28:
-                case 29:
-                case 30:
-                case 31:
+                case 0x14: /* vcvt fp <-> fixed */
+                case 0x15:
+                case 0x16:
+                case 0x17:
+                case 0x1c:
+                case 0x1d:
+                case 0x1e:
+                case 0x1f:
                     /* Source and destination the same.  */
                     gen_mov_F0_vreg(dp, rd);
                     break;
-                case 4:
-                case 5:
-                case 6:
-                case 7:
-                    /* VCVTB, VCVTT: only present with the halfprec extension
-                     * UNPREDICTABLE if bit 8 is set prior to ARMv8
-                     * (we choose to UNDEF)
-                     */
-                    if ((dp && !arm_dc_feature(s, ARM_FEATURE_V8)) ||
-                        !arm_dc_feature(s, ARM_FEATURE_VFP_FP16)) {
-                        return 1;
-                    }
-                    if (!extract32(rn, 1, 1)) {
-                        /* Half precision source.  */
-                        gen_mov_F0_vreg(0, rm);
-                        break;
-                    }
-                    /* Otherwise fall through */
                 default:
                     /* One source operand.  */
-                    gen_mov_F0_vreg(dp, rm);
+                    gen_mov_F0_vreg(rm_is_dp, rm);
                     break;
                 }
             } else {
@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
                         break;
                     }
                     case 15: /* single<->double conversion */
-                        if (dp)
+                        if (dp) {
                             gen_helper_vfp_fcvtsd(cpu_F0s, cpu_F0d, cpu_env);
-                        else
+                        } else {
                             gen_helper_vfp_fcvtds(cpu_F0d, cpu_F0s, cpu_env);
+                        }
                         break;
                     case 16: /* fuito */
                         gen_vfp_uito(dp, 0);
@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
                         gen_vfp_sito(dp, 0);
                         break;
                     case 20: /* fshto */
-                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
-                            return 1;
-                        }
                         gen_vfp_shto(dp, 16 - rm, 0);
                         break;
                     case 21: /* fslto */
-                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
-                            return 1;
-                        }
                         gen_vfp_slto(dp, 32 - rm, 0);
                         break;
                     case 22: /* fuhto */
-                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
-                            return 1;
-                        }
                         gen_vfp_uhto(dp, 16 - rm, 0);
                         break;
                     case 23: /* fulto */
-                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
-                            return 1;
-                        }
                         gen_vfp_ulto(dp, 32 - rm, 0);
                         break;
                     case 24: /* ftoui */
@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
                         gen_vfp_tosiz(dp, 0);
                         break;
                     case 28: /* ftosh */
-                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
-                            return 1;
-                        }
                         gen_vfp_tosh(dp, 16 - rm, 0);
                         break;
                     case 29: /* ftosl */
-                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
-                            return 1;
-                        }
                         gen_vfp_tosl(dp, 32 - rm, 0);
                         break;
                     case 30: /* ftouh */
-                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
-                            return 1;
-                        }
                         gen_vfp_touh(dp, 16 - rm, 0);
                         break;
                     case 31: /* ftoul */
-                        if (!arm_dc_feature(s, ARM_FEATURE_VFP3)) {
-                            return 1;
-                        }
                         gen_vfp_toul(dp, 32 - rm, 0);
                         break;
                     default: /* undefined */
-                        return 1;
+                        g_assert_not_reached();
                     }
                     break;
                 default: /* undefined */
                     return 1;
                 }
 
-                /* Write back the result.  */
-                if (op == 15 && (rn >= 8 && rn <= 11)) {
-                    /* Comparison, do nothing.  */
-                } else if (op == 15 && dp && ((rn & 0x1c) == 0x18 ||
-                                              (rn & 0x1e) == 0x6)) {
-                    /* VCVT double to int: always integer result.
-                     * VCVT double to half precision is always a single
-                     * precision result.
-                     */
-                    gen_mov_vreg_F0(0, rd);
-                } else if (op == 15 && rn == 15) {
-                    /* conversion */
-                    gen_mov_vreg_F0(!dp, rd);
-                } else {
-                    gen_mov_vreg_F0(dp, rd);
+                /* Write back the result, if any.  */
+                if (!no_output) {
+                    gen_mov_vreg_F0(rd_is_dp, rd);
                 }
 
                 /* break out of the loop if we have finished  */
-                if (veclen == 0)
+                if (veclen == 0) {
                     break;
+                }
 
                 if (op == 15 && delta_m == 0) {
                     /* single source one-many */
-- 
2.20.1

From: Richard Henderson <richard.henderson@linaro.org>

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-id: 20190215192302.27855-5-richard.henderson@linaro.org
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
[PMM: fixed a couple of comment typos]
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 target/arm/cpu.h           | 10 +++++
 target/arm/helper.h        |  3 ++
 target/arm/cpu.c           |  1 +
 target/arm/cpu64.c         |  2 +
 target/arm/translate-a64.c | 26 +++++++++++
 target/arm/translate.c     | 10 +++++
 target/arm/vfp_helper.c    | 88 ++++++++++++++++++++++++++++++++++++++
 7 files changed, 140 insertions(+)

diff --git a/target/arm/cpu.h b/target/arm/cpu.h
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/cpu.h
+++ b/target/arm/cpu.h
@@ -XXX,XX +XXX,XX @@ static inline bool isar_feature_aa32_vcma(const ARMISARegisters *id)
     return FIELD_EX32(id->id_isar5, ID_ISAR5, VCMA) != 0;
 }
 
+static inline bool isar_feature_aa32_jscvt(const ARMISARegisters *id)
+{
+    return FIELD_EX32(id->id_isar6, ID_ISAR6, JSCVT) != 0;
+}
+
 static inline bool isar_feature_aa32_dp(const ARMISARegisters *id)
 {
     return FIELD_EX32(id->id_isar6, ID_ISAR6, DP) != 0;
@@ -XXX,XX +XXX,XX @@ static inline bool isar_feature_aa64_dp(const ARMISARegisters *id)
     return FIELD_EX64(id->id_aa64isar0, ID_AA64ISAR0, DP) != 0;
 }
 
+static inline bool isar_feature_aa64_jscvt(const ARMISARegisters *id)
+{
+    return FIELD_EX64(id->id_aa64isar1, ID_AA64ISAR1, JSCVT) != 0;
+}
+
 static inline bool isar_feature_aa64_fcma(const ARMISARegisters *id)
 {
     return FIELD_EX64(id->id_aa64isar1, ID_AA64ISAR1, FCMA) != 0;
diff --git a/target/arm/helper.h b/target/arm/helper.h
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/helper.h
+++ b/target/arm/helper.h
@@ -XXX,XX +XXX,XX @@ DEF_HELPER_FLAGS_2(rintd_exact, TCG_CALL_NO_RWG, f64, f64, ptr)
 DEF_HELPER_FLAGS_2(rints, TCG_CALL_NO_RWG, f32, f32, ptr)
 DEF_HELPER_FLAGS_2(rintd, TCG_CALL_NO_RWG, f64, f64, ptr)
 
+DEF_HELPER_FLAGS_2(vjcvt, TCG_CALL_NO_RWG, i32, f64, env)
+DEF_HELPER_FLAGS_2(fjcvtzs, TCG_CALL_NO_RWG, i64, f64, ptr)
+
 /* neon_helper.c */
 DEF_HELPER_FLAGS_3(neon_qadd_u8, TCG_CALL_NO_RWG, i32, env, i32, i32)
 DEF_HELPER_FLAGS_3(neon_qadd_s8, TCG_CALL_NO_RWG, i32, env, i32, i32)
diff --git a/target/arm/cpu.c b/target/arm/cpu.c
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/cpu.c
+++ b/target/arm/cpu.c
@@ -XXX,XX +XXX,XX @@ static void arm_max_initfn(Object *obj)
             cpu->isar.id_isar5 = t;
 
             t = cpu->isar.id_isar6;
+            t = FIELD_DP32(t, ID_ISAR6, JSCVT, 1);
             t = FIELD_DP32(t, ID_ISAR6, DP, 1);
             cpu->isar.id_isar6 = t;
 
diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/cpu64.c
+++ b/target/arm/cpu64.c
@@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj)
         cpu->isar.id_aa64isar0 = t;
 
         t = cpu->isar.id_aa64isar1;
+        t = FIELD_DP64(t, ID_AA64ISAR1, JSCVT, 1);
         t = FIELD_DP64(t, ID_AA64ISAR1, FCMA, 1);
         t = FIELD_DP64(t, ID_AA64ISAR1, APA, 1); /* PAuth, architected only */
         t = FIELD_DP64(t, ID_AA64ISAR1, API, 0);
@@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj)
         cpu->isar.id_isar5 = u;
 
         u = cpu->isar.id_isar6;
+        u = FIELD_DP32(u, ID_ISAR6, JSCVT, 1);
         u = FIELD_DP32(u, ID_ISAR6, DP, 1);
         cpu->isar.id_isar6 = u;
 
diff --git a/target/arm/translate-a64.c b/target/arm/translate-a64.c
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/translate-a64.c
+++ b/target/arm/translate-a64.c
@@ -XXX,XX +XXX,XX @@ static void handle_fmov(DisasContext *s, int rd, int rn, int type, bool itof)
     }
 }
 
+static void handle_fjcvtzs(DisasContext *s, int rd, int rn)
+{
+    TCGv_i64 t = read_fp_dreg(s, rn);
+    TCGv_ptr fpstatus = get_fpstatus_ptr(false);
+
+    gen_helper_fjcvtzs(t, t, fpstatus);
+
+    tcg_temp_free_ptr(fpstatus);
+
+    tcg_gen_ext32u_i64(cpu_reg(s, rd), t);
+    tcg_gen_extrh_i64_i32(cpu_ZF, t);
+    tcg_gen_movi_i32(cpu_CF, 0);
+    tcg_gen_movi_i32(cpu_NF, 0);
+    tcg_gen_movi_i32(cpu_VF, 0);
+
+    tcg_temp_free_i64(t);
+}
+
 /* Floating point <-> integer conversions
  *   31   30  29 28       24 23  22  21 20   19 18 16 15         10 9  5 4  0
  * +----+---+---+-----------+------+---+-------+-----+-------------+----+----+
@@ -XXX,XX +XXX,XX @@ static void disas_fp_int_conv(DisasContext *s, uint32_t insn)
             handle_fmov(s, rd, rn, type, itof);
             break;
 
+        case 0b00111110: /* FJCVTZS */
+            if (!dc_isar_feature(aa64_jscvt, s)) {
+                goto do_unallocated;
+            } else if (fp_access_check(s)) {
+                handle_fjcvtzs(s, rd, rn);
+            }
+            break;
+
         default:
         do_unallocated:
             unallocated_encoding(s);
diff --git a/target/arm/translate.c b/target/arm/translate.c
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/translate.c
+++ b/target/arm/translate.c
@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
                     rm_is_dp = false;
                     break;
 
+                case 0x13: /* vjcvt */
+                    if (!dp || !dc_isar_feature(aa32_jscvt, s)) {
+                        return 1;
+                    }
+                    rd_is_dp = false;
+                    break;
+
                 default:
                     return 1;
                 }
@@ -XXX,XX +XXX,XX @@ static int disas_vfp_insn(DisasContext *s, uint32_t insn)
                     case 17: /* fsito */
                         gen_vfp_sito(dp, 0);
                         break;
+                    case 19: /* vjcvt */
+                        gen_helper_vjcvt(cpu_F0s, cpu_F0d, cpu_env);
+                        break;
                     case 20: /* fshto */
                         gen_vfp_shto(dp, 16 - rm, 0);
                         break;
diff --git a/target/arm/vfp_helper.c b/target/arm/vfp_helper.c
index XXXXXXX..XXXXXXX 100644
--- a/target/arm/vfp_helper.c
+++ b/target/arm/vfp_helper.c
@@ -XXX,XX +XXX,XX @@ int arm_rmode_to_sf(int rmode)
     }
     return rmode;
 }
+
+/*
+ * Implement float64 to int32_t conversion without saturation;
+ * the result is supplied modulo 2^32.
+ */
+uint64_t HELPER(fjcvtzs)(float64 value, void *vstatus)
+{
+    float_status *status = vstatus;
+    uint32_t exp, sign;
+    uint64_t frac;
+    uint32_t inexact = 1; /* !Z */
+
+    sign = extract64(value, 63, 1);
+    exp = extract64(value, 52, 11);
+    frac = extract64(value, 0, 52);
+
+    if (exp == 0) {
+        /* While not inexact for IEEE FP, -0.0 is inexact for JavaScript.  */
+        inexact = sign;
+        if (frac != 0) {
+            if (status->flush_inputs_to_zero) {
+                float_raise(float_flag_input_denormal, status);
+            } else {
+                float_raise(float_flag_inexact, status);
+                inexact = 1;
+            }
+        }
+        frac = 0;
+    } else if (exp == 0x7ff) {
+        /* This operation raises Invalid for both NaN and overflow (Inf).  */
+        float_raise(float_flag_invalid, status);
+        frac = 0;
+    } else {
+        int true_exp = exp - 1023;
+        int shift = true_exp - 52;
+
+        /* Restore implicit bit.  */
+        frac |= 1ull << 52;
+
+        /* Shift the fraction into place.  */
+        if (shift >= 0) {
+            /* The number is so large we must shift the fraction left.  */
+            if (shift >= 64) {
+                /* The fraction is shifted out entirely.  */
+                frac = 0;
+            } else {
+                frac <<= shift;
+            }
+        } else if (shift > -64) {
+            /* Normal case -- shift right and notice if bits shift out.  */
+            inexact = (frac << (64 + shift)) != 0;
+            frac >>= -shift;
+        } else {
+            /* The fraction is shifted out entirely.  */
+            frac = 0;
+        }
+
+        /* Notice overflow or inexact exceptions.  */
+        if (true_exp > 31 || frac > (sign ? 0x80000000ull : 0x7fffffff)) {
+            /* Overflow, for which this operation raises invalid.  */
+            float_raise(float_flag_invalid, status);
+            inexact = 1;
+        } else if (inexact) {
+            float_raise(float_flag_inexact, status);
+        }
+
+        /* Honor the sign.  */
+        if (sign) {
+            frac = -frac;
+        }
+    }
+
+    /* Pack the result and the env->ZF representation of Z together.  */
+    return deposit64(frac, 32, 32, inexact);
+}
+
+uint32_t HELPER(vjcvt)(float64 value, CPUARMState *env)
+{
+    uint64_t pair = HELPER(fjcvtzs)(value, &env->vfp.fp_status);
+    uint32_t result = pair;
+    uint32_t z = (pair >> 32) == 0;
+
+    /* Store Z, clear NCV, in FPSCR.NZCV.  */
+    env->vfp.xregs[ARM_VFP_FPSCR]
+        = (env->vfp.xregs[ARM_VFP_FPSCR] & ~CPSR_NZCV) | (z * CPSR_Z);
+
+    return result;
+}
-- 
2.20.1

The Peripheral Protection Controller's handling of unused ports
is that if there is nothing connected to the port's downstream
then it does not create the sysbus MMIO region for the upstream
end of the port. This results in odd behaviour when there is
an unused port in the middle of the range: since sysbus MMIO
regions are implicitly consecutively allocated, any used ports
above the unused ones end up with sysbus MMIO region numbers
that don't match the port number.

Avoid this numbering mismatch by creating dummy MMIO regions
for the unused ports. This doesn't change anything for our
existing boards, which don't have any gaps in the middle of
the port ranges they use; but it will be needed for the Musca
board.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 include/hw/misc/tz-ppc.h |  8 +++++++-
 hw/misc/tz-ppc.c         | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/include/hw/misc/tz-ppc.h b/include/hw/misc/tz-ppc.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/misc/tz-ppc.h
+++ b/include/hw/misc/tz-ppc.h
@@ -XXX,XX +XXX,XX @@
  *
  * QEMU interface:
  * + sysbus MMIO regions 0..15: MemoryRegions defining the upstream end
- *   of each of the 16 ports of the PPC
+ *   of each of the 16 ports of the PPC. When a port is unused (i.e. no
+ *   downstream MemoryRegion is connected to it) at the end of the 0..15
+ *   range then no sysbus MMIO region is created for its upstream. When an
+ *   unused port lies in the middle of the range with other used ports at
+ *   higher port numbers, a dummy MMIO region is created to ensure that
+ *   port N's upstream is always sysbus MMIO region N. Dummy regions should
+ *   not be mapped, and will assert if any access is made to them.
  * + Property "port[0..15]": MemoryRegion defining the downstream device(s)
  *   for each of the 16 ports of the PPC
  * + Named GPIO inputs "cfg_nonsec[0..15]": set to 1 if the port should be
diff --git a/hw/misc/tz-ppc.c b/hw/misc/tz-ppc.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/misc/tz-ppc.c
+++ b/hw/misc/tz-ppc.c
@@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps tz_ppc_ops = {
     .endianness = DEVICE_LITTLE_ENDIAN,
 };
 
+static bool tz_ppc_dummy_accepts(void *opaque, hwaddr addr,
+                                 unsigned size, bool is_write,
+                                 MemTxAttrs attrs)
+{
+    /*
+     * Board code should never map the upstream end of an unused port,
+     * so we should never try to make a memory access to it.
+     */
+    g_assert_not_reached();
+}
+
+static const MemoryRegionOps tz_ppc_dummy_ops = {
+    .valid.accepts = tz_ppc_dummy_accepts,
+};
+
 static void tz_ppc_reset(DeviceState *dev)
 {
     TZPPC *s = TZ_PPC(dev);
@@ -XXX,XX +XXX,XX @@ static void tz_ppc_realize(DeviceState *dev, Error **errp)
     SysBusDevice *sbd = SYS_BUS_DEVICE(dev);
     TZPPC *s = TZ_PPC(dev);
     int i;
+    int max_port = 0;
 
     /* We can't create the upstream end of the port until realize,
      * as we don't know the size of the MR used as the downstream until then.
      */
     for (i = 0; i < TZ_NUM_PORTS; i++) {
+        if (s->port[i].downstream) {
+            max_port = i;
+        }
+    }
+
+    for (i = 0; i <= max_port; i++) {
         TZPPCPort *port = &s->port[i];
         char *name;
         uint64_t size;
 
         if (!port->downstream) {
+            /*
+             * Create dummy sysbus MMIO region so the sysbus region
+             * numbering doesn't get out of sync with the port numbers.
+             * The size is entirely arbitrary.
+             */
+            name = g_strdup_printf("tz-ppc-dummy-port[%d]", i);
+            memory_region_init_io(&port->upstream, obj, &tz_ppc_dummy_ops,
+                                  port, name, 0x10000);
+            sysbus_init_mmio(sbd, &port->upstream);
+            g_free(name);
             continue;
         }
 
-- 
2.20.1

Create a new include file for the pl031's device struct,
type macros, etc, so that it can be instantiated using
the "embedded struct" coding style.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 include/hw/timer/pl031.h | 44 ++++++++++++++++++++++++++++++++++++++++
 hw/timer/pl031.c         | 25 +----------------------
 MAINTAINERS              |  1 +
 3 files changed, 46 insertions(+), 24 deletions(-)
 create mode 100644 include/hw/timer/pl031.h

diff --git a/include/hw/timer/pl031.h b/include/hw/timer/pl031.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/hw/timer/pl031.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * ARM AMBA PrimeCell PL031 RTC
+ *
+ * Copyright (c) 2007 CodeSourcery
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Contributions after 2012-01-13 are licensed under the terms of the
+ * GNU GPL, version 2 or (at your option) any later version.
+ */
+
+#ifndef HW_TIMER_PL031
+#define HW_TIMER_PL031
+
+#include "hw/sysbus.h"
+
+#define TYPE_PL031 "pl031"
+#define PL031(obj) OBJECT_CHECK(PL031State, (obj), TYPE_PL031)
+
+typedef struct PL031State {
+    SysBusDevice parent_obj;
+
+    MemoryRegion iomem;
+    QEMUTimer *timer;
+    qemu_irq irq;
+
+    /*
+     * Needed to preserve the tick_count across migration, even if the
+     * absolute value of the rtc_clock is different on the source and
+     * destination.
+     */
+    uint32_t tick_offset_vmstate;
+    uint32_t tick_offset;
+
+    uint32_t mr;
+    uint32_t lr;
+    uint32_t cr;
+    uint32_t im;
+    uint32_t is;
+} PL031State;
+
+#endif
diff --git a/hw/timer/pl031.c b/hw/timer/pl031.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/timer/pl031.c
+++ b/hw/timer/pl031.c
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
+#include "hw/timer/pl031.h"
 #include "hw/sysbus.h"
 #include "qemu/timer.h"
 #include "sysemu/sysemu.h"
@@ -XXX,XX +XXX,XX @@ do { printf("pl031: " fmt , ## __VA_ARGS__); } while (0)
 #define RTC_MIS     0x18    /* Masked interrupt status register */
 #define RTC_ICR     0x1c    /* Interrupt clear register */
 
-#define TYPE_PL031 "pl031"
-#define PL031(obj) OBJECT_CHECK(PL031State, (obj), TYPE_PL031)
-
-typedef struct PL031State {
-    SysBusDevice parent_obj;
-
-    MemoryRegion iomem;
-    QEMUTimer *timer;
-    qemu_irq irq;
-
-    /* Needed to preserve the tick_count across migration, even if the
-     * absolute value of the rtc_clock is different on the source and
-     * destination.
-     */
-    uint32_t tick_offset_vmstate;
-    uint32_t tick_offset;
-
-    uint32_t mr;
-    uint32_t lr;
-    uint32_t cr;
-    uint32_t im;
-    uint32_t is;
-} PL031State;
-
 static const unsigned char pl031_id[] = {
     0x31, 0x10, 0x14, 0x00,         /* Device ID        */
     0x0d, 0xf0, 0x05, 0xb1          /* Cell ID      */
diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: hw/sd/pl181.c
 F: hw/ssi/pl022.c
 F: include/hw/ssi/pl022.h
 F: hw/timer/pl031.c
+F: include/hw/timer/pl031.h
 F: include/hw/arm/primecell.h
 F: hw/timer/cmsdk-apb-timer.c
 F: include/hw/timer/cmsdk-apb-timer.h
-- 
2.20.1

Convert the debug printing in the PL031 device to use trace events,
and augment it to cover the interesting parts of device operation.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 hw/timer/pl031.c      | 55 +++++++++++++++++++++++--------------------
 hw/timer/trace-events |  6 +++++
 2 files changed, 36 insertions(+), 25 deletions(-)

diff --git a/hw/timer/pl031.c b/hw/timer/pl031.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/timer/pl031.c
+++ b/hw/timer/pl031.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/sysemu.h"
 #include "qemu/cutils.h"
 #include "qemu/log.h"
-
-//#define DEBUG_PL031
-
-#ifdef DEBUG_PL031
-#define DPRINTF(fmt, ...) \
-do { printf("pl031: " fmt , ## __VA_ARGS__); } while (0)
-#else
-#define DPRINTF(fmt, ...) do {} while(0)
-#endif
+#include "trace.h"
 
 #define RTC_DR      0x00    /* Data read register */
 #define RTC_MR      0x04    /* Match register */
@@ -XXX,XX +XXX,XX @@ static const unsigned char pl031_id[] = {
 
 static void pl031_update(PL031State *s)
 {
-    qemu_set_irq(s->irq, s->is & s->im);
+    uint32_t flags = s->is & s->im;
+
+    trace_pl031_irq_state(flags);
+    qemu_set_irq(s->irq, flags);
 }
 
 static void pl031_interrupt(void * opaque)
@@ -XXX,XX +XXX,XX @@ static void pl031_interrupt(void * opaque)
     PL031State *s = (PL031State *)opaque;
 
     s->is = 1;
-    DPRINTF("Alarm raised\n");
+    trace_pl031_alarm_raised();
     pl031_update(s);
 }
 
@@ -XXX,XX +XXX,XX @@ static void pl031_set_alarm(PL031State *s)
     /* The timer wraps around.  This subtraction also wraps in the same way,
        and gives correct results when alarm < now_ticks.  */
     ticks = s->mr - pl031_get_count(s);
-    DPRINTF("Alarm set in %ud ticks\n", ticks);
+    trace_pl031_set_alarm(ticks);
     if (ticks == 0) {
         timer_del(s->timer);
         pl031_interrupt(s);
@@ -XXX,XX +XXX,XX @@ static uint64_t pl031_read(void *opaque, hwaddr offset,
                            unsigned size)
 {
     PL031State *s = (PL031State *)opaque;
-
-    if (offset >= 0xfe0  &&  offset < 0x1000)
-        return pl031_id[(offset - 0xfe0) >> 2];
+    uint64_t r;
 
     switch (offset) {
     case RTC_DR:
-        return pl031_get_count(s);
+        r = pl031_get_count(s);
+        break;
     case RTC_MR:
-        return s->mr;
+        r = s->mr;
+        break;
     case RTC_IMSC:
-        return s->im;
+        r = s->im;
+        break;
     case RTC_RIS:
-        return s->is;
+        r = s->is;
+        break;
     case RTC_LR:
-        return s->lr;
+        r = s->lr;
+        break;
     case RTC_CR:
         /* RTC is permanently enabled.  */
-        return 1;
+        r = 1;
+        break;
     case RTC_MIS:
-        return s->is & s->im;
+        r = s->is & s->im;
+        break;
+    case 0xfe0 ... 0xfff:
+        r = pl031_id[(offset - 0xfe0) >> 2];
+        break;
     case RTC_ICR:
         qemu_log_mask(LOG_GUEST_ERROR,
                       "pl031: read of write-only register at offset 0x%x\n",
                       (int)offset);
+        r = 0;
         break;
     default:
         qemu_log_mask(LOG_GUEST_ERROR,
                       "pl031_read: Bad offset 0x%x\n", (int)offset);
+        r = 0;
         break;
     }
 
-    return 0;
+    trace_pl031_read(offset, r);
+    return r;
 }
 
 static void pl031_write(void * opaque, hwaddr offset,
@@ -XXX,XX +XXX,XX @@ static void pl031_write(void * opaque, hwaddr offset,
 {
     PL031State *s = (PL031State *)opaque;
 
+    trace_pl031_write(offset, value);
 
     switch (offset) {
     case RTC_LR:
@@ -XXX,XX +XXX,XX @@ static void pl031_write(void * opaque, hwaddr offset,
         break;
     case RTC_IMSC:
         s->im = value & 1;
-        DPRINTF("Interrupt mask %d\n", s->im);
         pl031_update(s);
         break;
     case RTC_ICR:
@@ -XXX,XX +XXX,XX @@ static void pl031_write(void * opaque, hwaddr offset,
            cleared when bit 0 of the written value is set.  However the
            arm926e documentation (DDI0287B) states that the interrupt is
            cleared when any value is written.  */
-        DPRINTF("Interrupt cleared");
         s->is = 0;
         pl031_update(s);
         break;
diff --git a/hw/timer/trace-events b/hw/timer/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/timer/trace-events
+++ b/hw/timer/trace-events
@@ -XXX,XX +XXX,XX @@ xlnx_zynqmp_rtc_gettime(int year, int month, int day, int hour, int min, int sec
 nrf51_timer_read(uint64_t addr, uint32_t value, unsigned size) "read addr 0x%" PRIx64 " data 0x%" PRIx32 " size %u"
 nrf51_timer_write(uint64_t addr, uint32_t value, unsigned size) "write addr 0x%" PRIx64 " data 0x%" PRIx32 " size %u"
 
+# hw/timer/pl031.c
+pl031_irq_state(int level) "irq state %d"
+pl031_read(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x"
+pl031_write(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x"
+pl031_alarm_raised(void) "alarm raised"
+pl031_set_alarm(uint32_t ticks) "alarm set for %u ticks"
-- 
2.20.1

Create a new include file for the pl011's device struct,
type macros, etc, so that it can be instantiated using
the "embedded struct" coding style.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 include/hw/char/pl011.h | 34 ++++++++++++++++++++++++++++++++++
 hw/char/pl011.c         | 31 ++-----------------------------
 2 files changed, 36 insertions(+), 29 deletions(-)

diff --git a/include/hw/char/pl011.h b/include/hw/char/pl011.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/char/pl011.h
+++ b/include/hw/char/pl011.h
@@ -XXX,XX +XXX,XX @@
 #ifndef HW_PL011_H
 #define HW_PL011_H
 
+#include "hw/sysbus.h"
+#include "chardev/char-fe.h"
+
+#define TYPE_PL011 "pl011"
+#define PL011(obj) OBJECT_CHECK(PL011State, (obj), TYPE_PL011)
+
+/* This shares the same struct (and cast macro) as the base pl011 device */
+#define TYPE_PL011_LUMINARY "pl011_luminary"
+
+typedef struct PL011State {
+    SysBusDevice parent_obj;
+
+    MemoryRegion iomem;
+    uint32_t readbuff;
+    uint32_t flags;
+    uint32_t lcr;
+    uint32_t rsr;
+    uint32_t cr;
+    uint32_t dmacr;
+    uint32_t int_enabled;
+    uint32_t int_level;
+    uint32_t read_fifo[16];
+    uint32_t ilpr;
+    uint32_t ibrd;
+    uint32_t fbrd;
+    uint32_t ifl;
+    int read_pos;
+    int read_count;
+    int read_trigger;
+    CharBackend chr;
+    qemu_irq irq;
+    const unsigned char *id;
+} PL011State;
+
 static inline DeviceState *pl011_create(hwaddr addr,
                                         qemu_irq irq,
                                         Chardev *chr)
diff --git a/hw/char/pl011.c b/hw/char/pl011.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/char/pl011.c
+++ b/hw/char/pl011.c
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
+#include "hw/char/pl011.h"
 #include "hw/sysbus.h"
 #include "chardev/char-fe.h"
 #include "qemu/log.h"
 #include "trace.h"
 
-#define TYPE_PL011 "pl011"
-#define PL011(obj) OBJECT_CHECK(PL011State, (obj), TYPE_PL011)
-
-typedef struct PL011State {
-    SysBusDevice parent_obj;
-
-    MemoryRegion iomem;
-    uint32_t readbuff;
-    uint32_t flags;
-    uint32_t lcr;
-    uint32_t rsr;
-    uint32_t cr;
-    uint32_t dmacr;
-    uint32_t int_enabled;
-    uint32_t int_level;
-    uint32_t read_fifo[16];
-    uint32_t ilpr;
-    uint32_t ibrd;
-    uint32_t fbrd;
-    uint32_t ifl;
-    int read_pos;
-    int read_count;
-    int read_trigger;
-    CharBackend chr;
-    qemu_irq irq;
-    const unsigned char *id;
-} PL011State;
-
 #define PL011_INT_TX 0x20
 #define PL011_INT_RX 0x10
 
@@ -XXX,XX +XXX,XX @@ static void pl011_luminary_init(Object *obj)
 }
 
 static const TypeInfo pl011_luminary_info = {
-    .name          = "pl011_luminary",
+    .name          = TYPE_PL011_LUMINARY,
     .parent        = TYPE_PL011,
     .instance_init = pl011_luminary_init,
 };
-- 
2.20.1

The PL011 UART has six interrupt lines:
 * RX (receive data)
 * TX (transmit data)
 * RT (receive timeout)
 * MS (modem status)
 * E (errors)
 * combined (logical OR of all the above)

So far we have only emulated the combined interrupt line;
add support for the others, so that boards that wire them
up to different interrupt controller inputs can do so.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 include/hw/char/pl011.h |  2 +-
 hw/char/pl011.c         | 46 +++++++++++++++++++++++++++++++++++++++--
 2 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/include/hw/char/pl011.h b/include/hw/char/pl011.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/char/pl011.h
+++ b/include/hw/char/pl011.h
@@ -XXX,XX +XXX,XX @@ typedef struct PL011State {
     int read_count;
     int read_trigger;
     CharBackend chr;
-    qemu_irq irq;
+    qemu_irq irq[6];
     const unsigned char *id;
 } PL011State;
 
diff --git a/hw/char/pl011.c b/hw/char/pl011.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/char/pl011.c
+++ b/hw/char/pl011.c
@@ -XXX,XX +XXX,XX @@
  * This code is licensed under the GPL.
  */
 
+/*
+ * QEMU interface:
+ *  + sysbus MMIO region 0: device registers
+ *  + sysbus IRQ 0: UARTINTR (combined interrupt line)
+ *  + sysbus IRQ 1: UARTRXINTR (receive FIFO interrupt line)
+ *  + sysbus IRQ 2: UARTTXINTR (transmit FIFO interrupt line)
+ *  + sysbus IRQ 3: UARTRTINTR (receive timeout interrupt line)
+ *  + sysbus IRQ 4: UARTMSINTR (momem status interrupt line)
+ *  + sysbus IRQ 5: UARTEINTR (error interrupt line)
+ */
+
 #include "qemu/osdep.h"
 #include "hw/char/pl011.h"
 #include "hw/sysbus.h"
@@ -XXX,XX +XXX,XX @@
 #define PL011_FLAG_TXFF 0x20
 #define PL011_FLAG_RXFE 0x10
 
+/* Interrupt status bits in UARTRIS, UARTMIS, UARTIMSC */
+#define INT_OE (1 << 10)
+#define INT_BE (1 << 9)
+#define INT_PE (1 << 8)
+#define INT_FE (1 << 7)
+#define INT_RT (1 << 6)
+#define INT_TX (1 << 5)
+#define INT_RX (1 << 4)
+#define INT_DSR (1 << 3)
+#define INT_DCD (1 << 2)
+#define INT_CTS (1 << 1)
+#define INT_RI (1 << 0)
+#define INT_E (INT_OE | INT_BE | INT_PE | INT_FE)
+#define INT_MS (INT_RI | INT_DSR | INT_DCD | INT_CTS)
+
 static const unsigned char pl011_id_arm[8] =
   { 0x11, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1 };
 static const unsigned char pl011_id_luminary[8] =
   { 0x11, 0x00, 0x18, 0x01, 0x0d, 0xf0, 0x05, 0xb1 };
 
+/* Which bits in the interrupt status matter for each outbound IRQ line ? */
+static const uint32_t irqmask[] = {
+    INT_E | INT_MS | INT_RT | INT_TX | INT_RX, /* combined IRQ */
+    INT_RX,
+    INT_TX,
+    INT_RT,
+    INT_MS,
+    INT_E,
+};
+
 static void pl011_update(PL011State *s)
 {
     uint32_t flags;
+    int i;
 
     flags = s->int_level & s->int_enabled;
     trace_pl011_irq_state(flags != 0);
-    qemu_set_irq(s->irq, flags != 0);
+    for (i = 0; i < ARRAY_SIZE(s->irq); i++) {
+        qemu_set_irq(s->irq[i], (flags & irqmask[i]) != 0);
+    }
 }
 
 static uint64_t pl011_read(void *opaque, hwaddr offset,
@@ -XXX,XX +XXX,XX @@ static void pl011_init(Object *obj)
 {
     SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
     PL011State *s = PL011(obj);
+    int i;
 
     memory_region_init_io(&s->iomem, OBJECT(s), &pl011_ops, s, "pl011", 0x1000);
     sysbus_init_mmio(sbd, &s->iomem);
-    sysbus_init_irq(sbd, &s->irq);
+    for (i = 0; i < ARRAY_SIZE(s->irq); i++) {
+        sysbus_init_irq(sbd, &s->irq[i]);
+    }
 
     s->read_trigger = 1;
     s->ifl = 0x12;
-- 
2.20.1

The pl011 logs when the guest makes a bad access. It prints
the address offset in hex but confusingly omits the '0x'
prefix; add it.

diff --git a/hw/char/pl011.c b/hw/char/pl011.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/char/pl011.c
+++ b/hw/char/pl011.c
@@ -XXX,XX +XXX,XX @@ static uint64_t pl011_read(void *opaque, hwaddr offset,
         break;
     default:
         qemu_log_mask(LOG_GUEST_ERROR,
-                      "pl011_read: Bad offset %x\n", (int)offset);
+                      "pl011_read: Bad offset 0x%x\n", (int)offset);
         r = 0;
         break;
     }
@@ -XXX,XX +XXX,XX @@ static void pl011_write(void *opaque, hwaddr offset,
         break;
     default:
         qemu_log_mask(LOG_GUEST_ERROR,
-                      "pl011_write: Bad offset %x\n", (int)offset);
+                      "pl011_write: Bad offset 0x%x\n", (int)offset);
     }
 }
 
-- 
2.20.1

In commit 4b635cf7a95e501211 we added a QOM property to the ARMSSE
object, but forgot to add it to the documentation comment in the
header. Correct the omission.

Fixes: 4b635cf7a95e501211 ("hw/arm/armsse: Make SRAM bank size configurable")
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 include/hw/arm/armsse.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/hw/arm/armsse.h b/include/hw/arm/armsse.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/arm/armsse.h
+++ b/include/hw/arm/armsse.h
@@ -XXX,XX +XXX,XX @@
  *    being the same for both, to avoid having to have separate Property
  *    lists for different variants. This restriction can be relaxed later
  *    if necessary.)
+ *  + QOM property "SRAM_ADDR_WIDTH" sets the number of bits used for the
+ *    address of each SRAM bank (and thus the total amount of internal SRAM)
  *  + Named GPIO inputs "EXP_IRQ" 0..n are the expansion interrupts for CPU 0,
  *    which are wired to its NVIC lines 32 .. n+32
  *  + Named GPIO inputs "EXP_CPU1_IRQ" 0..n are the expansion interrupts for
-- 
2.20.1

The Musca boards have DAPLink firmware that sets the initial
secure VTOR value (the location of the vector table) differently
depending on the boot mode (from flash, from RAM, etc). Export
the init-svtor as a QOM property of the ARMSSE object so that
the board can change it.

diff --git a/include/hw/arm/armsse.h b/include/hw/arm/armsse.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/arm/armsse.h
+++ b/include/hw/arm/armsse.h
@@ -XXX,XX +XXX,XX @@
  *    if necessary.)
  *  + QOM property "SRAM_ADDR_WIDTH" sets the number of bits used for the
  *    address of each SRAM bank (and thus the total amount of internal SRAM)
+ *  + QOM property "init-svtor" sets the initial value of the CPU SVTOR register
+ *    (where it expects to load the PC and SP from the vector table on reset)
  *  + Named GPIO inputs "EXP_IRQ" 0..n are the expansion interrupts for CPU 0,
  *    which are wired to its NVIC lines 32 .. n+32
  *  + Named GPIO inputs "EXP_CPU1_IRQ" 0..n are the expansion interrupts for
@@ -XXX,XX +XXX,XX @@ typedef struct ARMSSE {
     uint32_t exp_numirq;
     uint32_t mainclk_frq;
     uint32_t sram_addr_width;
+    uint32_t init_svtor;
 } ARMSSE;
 
 typedef struct ARMSSEInfo ARMSSEInfo;
diff --git a/hw/arm/armsse.c b/hw/arm/armsse.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/armsse.c
+++ b/hw/arm/armsse.c
@@ -XXX,XX +XXX,XX @@ static void armsse_realize(DeviceState *dev, Error **errp)
          * the INITSVTOR* registers before powering up the CPUs in any case,
          * so the hardware's default value doesn't matter. QEMU doesn't emulate
          * the control processor, so instead we behave in the way that the
-         * firmware does. All boards currently known about have firmware that
-         * sets the INITSVTOR0 and INITSVTOR1 registers to 0x10000000, like the
-         * IoTKit default. We can make this more configurable if necessary.
+         * firmware does. The initial value is configurable by the board code
+         * to match whatever its firmware does.
          */
-        qdev_prop_set_uint32(cpudev, "init-svtor", 0x10000000);
+        qdev_prop_set_uint32(cpudev, "init-svtor", s->init_svtor);
         /*
          * Start all CPUs except CPU0 powered down. In real hardware it is
          * a configurable property of the SSE-200 which CPUs start powered up
@@ -XXX,XX +XXX,XX @@ static Property armsse_properties[] = {
     DEFINE_PROP_UINT32("EXP_NUMIRQ", ARMSSE, exp_numirq, 64),
     DEFINE_PROP_UINT32("MAINCLK", ARMSSE, mainclk_frq, 0),
     DEFINE_PROP_UINT32("SRAM_ADDR_WIDTH", ARMSSE, sram_addr_width, 15),
+    DEFINE_PROP_UINT32("init-svtor", ARMSSE, init_svtor, 0x10000000),
     DEFINE_PROP_END_OF_LIST()
 };
 
-- 
2.20.1

The Musca-A and Musca-B1 development boards are based on the
SSE-200 subsystem for embedded. Implement an initial skeleton
model of these boards, which are similar but not identical.

This commit creates the board model with the SSE and the IRQ
splitters to wire IRQs up to its two CPUs. As yet there
are no devices and no memory: these will be added later.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 hw/arm/Makefile.objs            |   1 +
 hw/arm/musca.c                  | 197 ++++++++++++++++++++++++++++++++
 MAINTAINERS                     |   6 +
 default-configs/arm-softmmu.mak |   1 +
 4 files changed, 205 insertions(+)
 create mode 100644 hw/arm/musca.c

diff --git a/hw/arm/Makefile.objs b/hw/arm/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/Makefile.objs
+++ b/hw/arm/Makefile.objs
@@ -XXX,XX +XXX,XX @@ obj-$(CONFIG_ASPEED_SOC) += aspeed_soc.o aspeed.o
 obj-$(CONFIG_MPS2) += mps2.o
 obj-$(CONFIG_MPS2) += mps2-tz.o
 obj-$(CONFIG_MSF2) += msf2-soc.o msf2-som.o
+obj-$(CONFIG_MUSCA) += musca.o
 obj-$(CONFIG_ARMSSE) += armsse.o
 obj-$(CONFIG_FSL_IMX7) += fsl-imx7.o mcimx7d-sabre.o
 obj-$(CONFIG_ARM_SMMUV3) += smmu-common.o smmuv3.o
diff --git a/hw/arm/musca.c b/hw/arm/musca.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/hw/arm/musca.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Arm Musca-B1 test chip board emulation
+ *
+ * Copyright (c) 2019 Linaro Limited
+ * Written by Peter Maydell
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 or
+ *  (at your option) any later version.
+ */
+
+/*
+ * The Musca boards are a reference implementation of a system using
+ * the SSE-200 subsystem for embedded:
+ * https://developer.arm.com/products/system-design/development-boards/iot-test-chips-and-boards/musca-a-test-chip-board
+ * https://developer.arm.com/products/system-design/development-boards/iot-test-chips-and-boards/musca-b-test-chip-board
+ * We model the A and B1 variants of this board, as described in the TRMs:
+ * http://infocenter.arm.com/help/topic/com.arm.doc.101107_0000_00_en/index.html
+ * http://infocenter.arm.com/help/topic/com.arm.doc.101312_0000_00_en/index.html
+ */
+
+#include "qemu/osdep.h"
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+#include "exec/address-spaces.h"
+#include "hw/arm/arm.h"
+#include "hw/arm/armsse.h"
+#include "hw/boards.h"
+#include "hw/core/split-irq.h"
+
+#define MUSCA_NUMIRQ_MAX 96
+
+typedef enum MuscaType {
+    MUSCA_A,
+    MUSCA_B1,
+} MuscaType;
+
+typedef struct {
+    MachineClass parent;
+    MuscaType type;
+    uint32_t init_svtor;
+    int sram_addr_width;
+    int num_irqs;
+} MuscaMachineClass;
+
+typedef struct {
+    MachineState parent;
+
+    ARMSSE sse;
+    SplitIRQ cpu_irq_splitter[MUSCA_NUMIRQ_MAX];
+} MuscaMachineState;
+
+#define TYPE_MUSCA_MACHINE "musca"
+#define TYPE_MUSCA_A_MACHINE MACHINE_TYPE_NAME("musca-a")
+#define TYPE_MUSCA_B1_MACHINE MACHINE_TYPE_NAME("musca-b1")
+
+#define MUSCA_MACHINE(obj) \
+    OBJECT_CHECK(MuscaMachineState, obj, TYPE_MUSCA_MACHINE)
+#define MUSCA_MACHINE_GET_CLASS(obj) \
+    OBJECT_GET_CLASS(MuscaMachineClass, obj, TYPE_MUSCA_MACHINE)
+#define MUSCA_MACHINE_CLASS(klass) \
+    OBJECT_CLASS_CHECK(MuscaMachineClass, klass, TYPE_MUSCA_MACHINE)
+
+/*
+ * Main SYSCLK frequency in Hz
+ * TODO this should really be different for the two cores, but we
+ * don't model that in our SSE-200 model yet.
+ */
+#define SYSCLK_FRQ 40000000
+
+static void musca_init(MachineState *machine)
+{
+    MuscaMachineState *mms = MUSCA_MACHINE(machine);
+    MuscaMachineClass *mmc = MUSCA_MACHINE_GET_CLASS(mms);
+    MachineClass *mc = MACHINE_GET_CLASS(machine);
+    MemoryRegion *system_memory = get_system_memory();
+    DeviceState *ssedev;
+    int i;
+
+    assert(mmc->num_irqs <= MUSCA_NUMIRQ_MAX);
+
+    if (strcmp(machine->cpu_type, mc->default_cpu_type) != 0) {
+        error_report("This board can only be used with CPU %s",
+                     mc->default_cpu_type);
+        exit(1);
+    }
+
+    sysbus_init_child_obj(OBJECT(machine), "sse-200", &mms->sse,
+                          sizeof(mms->sse), TYPE_SSE200);
+    ssedev = DEVICE(&mms->sse);
+    object_property_set_link(OBJECT(&mms->sse), OBJECT(system_memory),
+                             "memory", &error_fatal);
+    qdev_prop_set_uint32(ssedev, "EXP_NUMIRQ", mmc->num_irqs);
+    qdev_prop_set_uint32(ssedev, "init-svtor", mmc->init_svtor);
+    qdev_prop_set_uint32(ssedev, "SRAM_ADDR_WIDTH", mmc->sram_addr_width);
+    qdev_prop_set_uint32(ssedev, "MAINCLK", SYSCLK_FRQ);
+    object_property_set_bool(OBJECT(&mms->sse), true, "realized",
+                             &error_fatal);
+
+    /*
+     * We need to create splitters to feed the IRQ inputs
+     * for each CPU in the SSE-200 from each device in the board.
+     */
+    for (i = 0; i < mmc->num_irqs; i++) {
+        char *name = g_strdup_printf("musca-irq-splitter%d", i);
+        SplitIRQ *splitter = &mms->cpu_irq_splitter[i];
+
+        object_initialize_child(OBJECT(machine), name,
+                                splitter, sizeof(*splitter),
+                                TYPE_SPLIT_IRQ, &error_fatal, NULL);
+        g_free(name);
+
+        object_property_set_int(OBJECT(splitter), 2, "num-lines",
+                                &error_fatal);
+        object_property_set_bool(OBJECT(splitter), true, "realized",
+                                 &error_fatal);
+        qdev_connect_gpio_out(DEVICE(splitter), 0,
+                              qdev_get_gpio_in_named(ssedev, "EXP_IRQ", i));
+        qdev_connect_gpio_out(DEVICE(splitter), 1,
+                              qdev_get_gpio_in_named(ssedev,
+                                                     "EXP_CPU1_IRQ", i));
+    }
+
+    armv7m_load_kernel(ARM_CPU(first_cpu), machine->kernel_filename, 0x2000000);
+}
+
+static void musca_class_init(ObjectClass *oc, void *data)
+{
+    MachineClass *mc = MACHINE_CLASS(oc);
+
+    mc->default_cpus = 2;
+    mc->min_cpus = mc->default_cpus;
+    mc->max_cpus = mc->default_cpus;
+    mc->default_cpu_type = ARM_CPU_TYPE_NAME("cortex-m33");
+    mc->init = musca_init;
+}
+
+static void musca_a_class_init(ObjectClass *oc, void *data)
+{
+    MachineClass *mc = MACHINE_CLASS(oc);
+    MuscaMachineClass *mmc = MUSCA_MACHINE_CLASS(oc);
+
+    mc->desc = "ARM Musca-A board (dual Cortex-M33)";
+    mmc->type = MUSCA_A;
+    mmc->init_svtor = 0x10200000;
+    mmc->sram_addr_width = 15;
+    mmc->num_irqs = 64;
+}
+
+static void musca_b1_class_init(ObjectClass *oc, void *data)
+{
+    MachineClass *mc = MACHINE_CLASS(oc);
+    MuscaMachineClass *mmc = MUSCA_MACHINE_CLASS(oc);
+
+    mc->desc = "ARM Musca-B1 board (dual Cortex-M33)";
+    mmc->type = MUSCA_B1;
+    /*
+     * This matches the DAPlink firmware which boots from QSPI. There
+     * is also a firmware blob which boots from the eFlash, which
+     * uses init_svtor = 0x1A000000. QEMU doesn't currently support that,
+     * though we could in theory expose a machine property on the command
+     * line to allow the user to request eFlash boot.
+     */
+    mmc->init_svtor = 0x10000000;
+    mmc->sram_addr_width = 17;
+    mmc->num_irqs = 96;
+}
+
+static const TypeInfo musca_info = {
+    .name = TYPE_MUSCA_MACHINE,
+    .parent = TYPE_MACHINE,
+    .abstract = true,
+    .instance_size = sizeof(MuscaMachineState),
+    .class_size = sizeof(MuscaMachineClass),
+    .class_init = musca_class_init,
+};
+
+static const TypeInfo musca_a_info = {
+    .name = TYPE_MUSCA_A_MACHINE,
+    .parent = TYPE_MUSCA_MACHINE,
+    .class_init = musca_a_class_init,
+};
+
+static const TypeInfo musca_b1_info = {
+    .name = TYPE_MUSCA_B1_MACHINE,
+    .parent = TYPE_MUSCA_MACHINE,
+    .class_init = musca_b1_class_init,
+};
+
+static void musca_machine_init(void)
+{
+    type_register_static(&musca_info);
+    type_register_static(&musca_a_info);
+    type_register_static(&musca_b1_info);
+}
+
+type_init(musca_machine_init);
diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: include/hw/misc/iotkit-sysinfo.h
 F: hw/misc/armsse-cpuid.c
 F: include/hw/misc/armsse-cpuid.h
 
+Musca
+M: Peter Maydell <peter.maydell@linaro.org>
+L: qemu-arm@nongnu.org
+S: Maintained
+F: hw/arm/musca.c
+
 Musicpal
 M: Jan Kiszka <jan.kiszka@web.de>
 M: Peter Maydell <peter.maydell@linaro.org>
diff --git a/default-configs/arm-softmmu.mak b/default-configs/arm-softmmu.mak
index XXXXXXX..XXXXXXX 100644
--- a/default-configs/arm-softmmu.mak
+++ b/default-configs/arm-softmmu.mak
@@ -XXX,XX +XXX,XX @@ CONFIG_TUSB6010=y
 CONFIG_IMX=y
 CONFIG_MAINSTONE=y
 CONFIG_MPS2=y
+CONFIG_MUSCA=y
 CONFIG_NSERIES=y
 CONFIG_RASPI=y
 CONFIG_REALVIEW=y
-- 
2.20.1

Many of the devices on the Musca board live behind TrustZone
Peripheral Protection Controllers (PPCs); add models of the
PPCs, using a similar scheme to the MPS2 board models.
This commit wires up the PPCs with "unimplemented device"
stubs behind them in the correct places in the address map.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 hw/arm/musca.c | 289 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 289 insertions(+)

diff --git a/hw/arm/musca.c b/hw/arm/musca.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/musca.c
+++ b/hw/arm/musca.c
@@ -XXX,XX +XXX,XX @@
 #include "hw/arm/armsse.h"
 #include "hw/boards.h"
 #include "hw/core/split-irq.h"
+#include "hw/misc/tz-ppc.h"
+#include "hw/misc/unimp.h"
 
 #define MUSCA_NUMIRQ_MAX 96
+#define MUSCA_PPC_MAX 3
 
 typedef enum MuscaType {
     MUSCA_A,
@@ -XXX,XX +XXX,XX @@ typedef struct {
 
     ARMSSE sse;
     SplitIRQ cpu_irq_splitter[MUSCA_NUMIRQ_MAX];
+    SplitIRQ sec_resp_splitter;
+    TZPPC ppc[MUSCA_PPC_MAX];
+    MemoryRegion container;
+    UnimplementedDeviceState eflash[2];
+    UnimplementedDeviceState qspi;
+    UnimplementedDeviceState mpc[5];
+    UnimplementedDeviceState mhu[2];
+    UnimplementedDeviceState pwm[3];
+    UnimplementedDeviceState i2s;
+    UnimplementedDeviceState uart[2];
+    UnimplementedDeviceState i2c[2];
+    UnimplementedDeviceState spi;
+    UnimplementedDeviceState scc;
+    UnimplementedDeviceState timer;
+    UnimplementedDeviceState rtc;
+    UnimplementedDeviceState pvt;
+    UnimplementedDeviceState sdio;
+    UnimplementedDeviceState gpio;
 } MuscaMachineState;
 
 #define TYPE_MUSCA_MACHINE "musca"
@@ -XXX,XX +XXX,XX @@ typedef struct {
  */
 #define SYSCLK_FRQ 40000000
 
+/*
+ * Most of the devices in the Musca board sit behind Peripheral Protection
+ * Controllers. These data structures define the layout of which devices
+ * sit behind which PPCs.
+ * The devfn for each port is a function which creates, configures
+ * and initializes the device, returning the MemoryRegion which
+ * needs to be plugged into the downstream end of the PPC port.
+ */
+typedef MemoryRegion *MakeDevFn(MuscaMachineState *mms, void *opaque,
+                                const char *name, hwaddr size);
+
+typedef struct PPCPortInfo {
+    const char *name;
+    MakeDevFn *devfn;
+    void *opaque;
+    hwaddr addr;
+    hwaddr size;
+} PPCPortInfo;
+
+typedef struct PPCInfo {
+    const char *name;
+    PPCPortInfo ports[TZ_NUM_PORTS];
+} PPCInfo;
+
+static MemoryRegion *make_unimp_dev(MuscaMachineState *mms,
+                                    void *opaque, const char *name, hwaddr size)
+{
+    /*
+     * Initialize, configure and realize a TYPE_UNIMPLEMENTED_DEVICE,
+     * and return a pointer to its MemoryRegion.
+     */
+    UnimplementedDeviceState *uds = opaque;
+
+    sysbus_init_child_obj(OBJECT(mms), name, uds,
+                          sizeof(UnimplementedDeviceState),
+                          TYPE_UNIMPLEMENTED_DEVICE);
+    qdev_prop_set_string(DEVICE(uds), "name", name);
+    qdev_prop_set_uint64(DEVICE(uds), "size", size);
+    object_property_set_bool(OBJECT(uds), true, "realized", &error_fatal);
+    return sysbus_mmio_get_region(SYS_BUS_DEVICE(uds), 0);
+}
+
+static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
+                                       const char *name, hwaddr size)
+{
+    /*
+     * Create the container MemoryRegion for all the devices that live
+     * behind the Musca-A PPC's single port. These devices don't have a PPC
+     * port each, but we use the PPCPortInfo struct as a convenient way
+     * to describe them. Note that addresses here are relative to the base
+     * address of the PPC port region: 0x40100000, and devices appear both
+     * at the 0x4... NS region and the 0x5... S region.
+     */
+    int i;
+    MemoryRegion *container = &mms->container;
+
+    const PPCPortInfo devices[] = {
+        { "uart0", make_unimp_dev, &mms->uart[0], 0x1000, 0x1000 },
+        { "uart1", make_unimp_dev, &mms->uart[1], 0x2000, 0x1000 },
+        { "spi", make_unimp_dev, &mms->spi, 0x3000, 0x1000 },
+        { "i2c0", make_unimp_dev, &mms->i2c[0], 0x4000, 0x1000 },
+        { "i2c1", make_unimp_dev, &mms->i2c[1], 0x5000, 0x1000 },
+        { "i2s", make_unimp_dev, &mms->i2s, 0x6000, 0x1000 },
+        { "pwm0", make_unimp_dev, &mms->pwm[0], 0x7000, 0x1000 },
+        { "rtc", make_unimp_dev, &mms->rtc, 0x8000, 0x1000 },
+        { "qspi", make_unimp_dev, &mms->qspi, 0xa000, 0x1000 },
+        { "timer", make_unimp_dev, &mms->timer, 0xb000, 0x1000 },
+        { "scc", make_unimp_dev, &mms->scc, 0xc000, 0x1000 },
+        { "pwm1", make_unimp_dev, &mms->pwm[1], 0xe000, 0x1000 },
+        { "pwm2", make_unimp_dev, &mms->pwm[2], 0xf000, 0x1000 },
+        { "gpio", make_unimp_dev, &mms->gpio, 0x10000, 0x1000 },
+        { "mpc0", make_unimp_dev, &mms->mpc[0], 0x12000, 0x1000 },
+        { "mpc1", make_unimp_dev, &mms->mpc[1], 0x13000, 0x1000 },
+    };
+
+    memory_region_init(container, OBJECT(mms), "musca-device-container", size);
+
+    for (i = 0; i < ARRAY_SIZE(devices); i++) {
+        const PPCPortInfo *pinfo = &devices[i];
+        MemoryRegion *mr;
+
+        mr = pinfo->devfn(mms, pinfo->opaque, pinfo->name, pinfo->size);
+        memory_region_add_subregion(container, pinfo->addr, mr);
+    }
+
+    return &mms->container;
+}
+
 static void musca_init(MachineState *machine)
 {
     MuscaMachineState *mms = MUSCA_MACHINE(machine);
@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
     MachineClass *mc = MACHINE_GET_CLASS(machine);
     MemoryRegion *system_memory = get_system_memory();
     DeviceState *ssedev;
+    DeviceState *dev_splitter;
+    const PPCInfo *ppcs;
+    int num_ppcs;
     int i;
 
     assert(mmc->num_irqs <= MUSCA_NUMIRQ_MAX);
@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
                                                      "EXP_CPU1_IRQ", i));
     }
 
+    /*
+     * The sec_resp_cfg output from the SSE-200 must be split into multiple
+     * lines, one for each of the PPCs we create here.
+     */
+    object_initialize(&mms->sec_resp_splitter, sizeof(mms->sec_resp_splitter),
+                      TYPE_SPLIT_IRQ);
+    object_property_add_child(OBJECT(machine), "sec-resp-splitter",
+                              OBJECT(&mms->sec_resp_splitter), &error_fatal);
+    object_property_set_int(OBJECT(&mms->sec_resp_splitter),
+                            ARRAY_SIZE(mms->ppc), "num-lines", &error_fatal);
+    object_property_set_bool(OBJECT(&mms->sec_resp_splitter), true,
+                             "realized", &error_fatal);
+    dev_splitter = DEVICE(&mms->sec_resp_splitter);
+    qdev_connect_gpio_out_named(ssedev, "sec_resp_cfg", 0,
+                                qdev_get_gpio_in(dev_splitter, 0));
+
+    /*
+     * Most of the devices in the board are behind Peripheral Protection
+     * Controllers. The required order for initializing things is:
+     *  + initialize the PPC
+     *  + initialize, configure and realize downstream devices
+     *  + connect downstream device MemoryRegions to the PPC
+     *  + realize the PPC
+     *  + map the PPC's MemoryRegions to the places in the address map
+     *    where the downstream devices should appear
+     *  + wire up the PPC's control lines to the SSE object
+     *
+     * The PPC mapping differs for the -A and -B1 variants; the -A version
+     * is much simpler, using only a single port of a single PPC and putting
+     * all the devices behind that.
+     */
+    const PPCInfo a_ppcs[] = { {
+            .name = "ahb_ppcexp0",
+            .ports = {
+                { "musca-devices", make_musca_a_devs, 0, 0x40100000, 0x100000 },
+            },
+        },
+    };
+
+    /*
+     * Devices listed with an 0x4.. address appear in both the NS 0x4.. region
+     * and the 0x5.. S region. Devices listed with an 0x5.. address appear
+     * only in the S region.
+     */
+    const PPCInfo b1_ppcs[] = { {
+            .name = "apb_ppcexp0",
+            .ports = {
+                { "eflash0", make_unimp_dev, &mms->eflash[0],
+                  0x52400000, 0x1000 },
+                { "eflash1", make_unimp_dev, &mms->eflash[1],
+                  0x52500000, 0x1000 },
+                { "qspi", make_unimp_dev, &mms->qspi, 0x42800000, 0x100000 },
+                { "mpc0", make_unimp_dev, &mms->mpc[0], 0x52000000, 0x1000 },
+                { "mpc1", make_unimp_dev, &mms->mpc[1], 0x52100000, 0x1000 },
+                { "mpc2", make_unimp_dev, &mms->mpc[2], 0x52200000, 0x1000 },
+                { "mpc3", make_unimp_dev, &mms->mpc[3], 0x52300000, 0x1000 },
+                { "mhu0", make_unimp_dev, &mms->mhu[0], 0x42600000, 0x100000 },
+                { "mhu1", make_unimp_dev, &mms->mhu[1], 0x42700000, 0x100000 },
+                { }, /* port 9: unused */
+                { }, /* port 10: unused */
+                { }, /* port 11: unused */
+                { }, /* port 12: unused */
+                { }, /* port 13: unused */
+                { "mpc4", make_unimp_dev, &mms->mpc[4], 0x52e00000, 0x1000 },
+            },
+        }, {
+            .name = "apb_ppcexp1",
+            .ports = {
+                { "pwm0", make_unimp_dev, &mms->pwm[0], 0x40101000, 0x1000 },
+                { "pwm1", make_unimp_dev, &mms->pwm[1], 0x40102000, 0x1000 },
+                { "pwm2", make_unimp_dev, &mms->pwm[2], 0x40103000, 0x1000 },
+                { "i2s", make_unimp_dev, &mms->i2s, 0x40104000, 0x1000 },
+                { "uart0", make_unimp_dev, &mms->uart[0], 0x40105000, 0x1000 },
+                { "uart1", make_unimp_dev, &mms->uart[1], 0x40106000, 0x1000 },
+                { "i2c0", make_unimp_dev, &mms->i2c[0], 0x40108000, 0x1000 },
+                { "i2c1", make_unimp_dev, &mms->i2c[1], 0x40109000, 0x1000 },
+                { "spi", make_unimp_dev, &mms->spi, 0x4010a000, 0x1000 },
+                { "scc", make_unimp_dev, &mms->scc, 0x5010b000, 0x1000 },
+                { "timer", make_unimp_dev, &mms->timer, 0x4010c000, 0x1000 },
+                { "rtc", make_unimp_dev, &mms->rtc, 0x4010d000, 0x1000 },
+                { "pvt", make_unimp_dev, &mms->pvt, 0x4010e000, 0x1000 },
+                { "sdio", make_unimp_dev, &mms->sdio, 0x4010f000, 0x1000 },
+            },
+        }, {
+            .name = "ahb_ppcexp0",
+            .ports = {
+                { }, /* port 0: unused */
+                { "gpio", make_unimp_dev, &mms->gpio, 0x41000000, 0x1000 },
+            },
+        },
+    };
+
+    switch (mmc->type) {
+    case MUSCA_A:
+        ppcs = a_ppcs;
+        num_ppcs = ARRAY_SIZE(a_ppcs);
+        break;
+    case MUSCA_B1:
+        ppcs = b1_ppcs;
+        num_ppcs = ARRAY_SIZE(b1_ppcs);
+        break;
+    default:
+        g_assert_not_reached();
+    }
+    assert(num_ppcs <= MUSCA_PPC_MAX);
+
+    for (i = 0; i < num_ppcs; i++) {
+        const PPCInfo *ppcinfo = &ppcs[i];
+        TZPPC *ppc = &mms->ppc[i];
+        DeviceState *ppcdev;
+        int port;
+        char *gpioname;
+
+        sysbus_init_child_obj(OBJECT(machine), ppcinfo->name, ppc,
+                              sizeof(TZPPC), TYPE_TZ_PPC);
+        ppcdev = DEVICE(ppc);
+
+        for (port = 0; port < TZ_NUM_PORTS; port++) {
+            const PPCPortInfo *pinfo = &ppcinfo->ports[port];
+            MemoryRegion *mr;
+            char *portname;
+
+            if (!pinfo->devfn) {
+                continue;
+            }
+
+            mr = pinfo->devfn(mms, pinfo->opaque, pinfo->name, pinfo->size);
+            portname = g_strdup_printf("port[%d]", port);
+            object_property_set_link(OBJECT(ppc), OBJECT(mr),
+                                     portname, &error_fatal);
+            g_free(portname);
+        }
+
+        object_property_set_bool(OBJECT(ppc), true, "realized", &error_fatal);
+
+        for (port = 0; port < TZ_NUM_PORTS; port++) {
+            const PPCPortInfo *pinfo = &ppcinfo->ports[port];
+
+            if (!pinfo->devfn) {
+                continue;
+            }
+            sysbus_mmio_map(SYS_BUS_DEVICE(ppc), port, pinfo->addr);
+
+            gpioname = g_strdup_printf("%s_nonsec", ppcinfo->name);
+            qdev_connect_gpio_out_named(ssedev, gpioname, port,
+                                        qdev_get_gpio_in_named(ppcdev,
+                                                               "cfg_nonsec",
+                                                               port));
+            g_free(gpioname);
+            gpioname = g_strdup_printf("%s_ap", ppcinfo->name);
+            qdev_connect_gpio_out_named(ssedev, gpioname, port,
+                                        qdev_get_gpio_in_named(ppcdev,
+                                                               "cfg_ap", port));
+            g_free(gpioname);
+        }
+
+        gpioname = g_strdup_printf("%s_irq_enable", ppcinfo->name);
+        qdev_connect_gpio_out_named(ssedev, gpioname, 0,
+                                    qdev_get_gpio_in_named(ppcdev,
+                                                           "irq_enable", 0));
+        g_free(gpioname);
+        gpioname = g_strdup_printf("%s_irq_clear", ppcinfo->name);
+        qdev_connect_gpio_out_named(ssedev, gpioname, 0,
+                                    qdev_get_gpio_in_named(ppcdev,
+                                                           "irq_clear", 0));
+        g_free(gpioname);
+        gpioname = g_strdup_printf("%s_irq_status", ppcinfo->name);
+        qdev_connect_gpio_out_named(ppcdev, "irq", 0,
+                                    qdev_get_gpio_in_named(ssedev,
+                                                           gpioname, 0));
+        g_free(gpioname);
+
+        qdev_connect_gpio_out(dev_splitter, i,
+                              qdev_get_gpio_in_named(ppcdev,
+                                                     "cfg_sec_resp", 0));
+    }
+
     armv7m_load_kernel(ARM_CPU(first_cpu), machine->kernel_filename, 0x2000000);
 }
 
-- 
2.20.1

The Musca board puts its SRAM and flash behind TrustZone
Memory Protection Controllers (MPCs). Each MPC sits between
the CPU and the RAM/flash, and also has a set of memory mapped
control registers. Wire up the MPCs, and the memory behind them.
For the moment we implement the flash as simple ROM, which
cannot be reprogrammed by the guest.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 hw/arm/musca.c | 155 ++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 147 insertions(+), 8 deletions(-)

Wire up the PL031 RTC for the Musca board.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 hw/arm/musca.c | 26 +++++++++++++++++++++++---
 1 file changed, 23 insertions(+), 3 deletions(-)

diff --git a/hw/arm/musca.c b/hw/arm/musca.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/musca.c
+++ b/hw/arm/musca.c
@@ -XXX,XX +XXX,XX @@
 #include "hw/misc/tz-mpc.h"
 #include "hw/misc/tz-ppc.h"
 #include "hw/misc/unimp.h"
+#include "hw/timer/pl031.h"
 
 #define MUSCA_NUMIRQ_MAX 96
 #define MUSCA_PPC_MAX 3
@@ -XXX,XX +XXX,XX @@ typedef struct {
     UnimplementedDeviceState spi;
     UnimplementedDeviceState scc;
     UnimplementedDeviceState timer;
-    UnimplementedDeviceState rtc;
+    PL031State rtc;
     UnimplementedDeviceState pvt;
     UnimplementedDeviceState sdio;
     UnimplementedDeviceState gpio;
@@ -XXX,XX +XXX,XX @@ typedef struct {
  */
 #define SYSCLK_FRQ 40000000
 
+static qemu_irq get_sse_irq_in(MuscaMachineState *mms, int irqno)
+{
+    /* Return a qemu_irq which will signal IRQ n to all CPUs in the SSE. */
+    assert(irqno < MUSCA_NUMIRQ_MAX);
+
+    return qdev_get_gpio_in(DEVICE(&mms->cpu_irq_splitter[irqno]), 0);
+}
+
 /*
  * Most of the devices in the Musca board sit behind Peripheral Protection
  * Controllers. These data structures define the layout of which devices
@@ -XXX,XX +XXX,XX @@ static MemoryRegion *make_mpc(MuscaMachineState *mms, void *opaque,
     return sysbus_mmio_get_region(SYS_BUS_DEVICE(mpc), 0);
 }
 
+static MemoryRegion *make_rtc(MuscaMachineState *mms, void *opaque,
+                              const char *name, hwaddr size)
+{
+    PL031State *rtc = opaque;
+
+    sysbus_init_child_obj(OBJECT(mms), name, rtc, sizeof(mms->rtc), TYPE_PL031);
+    object_property_set_bool(OBJECT(rtc), true, "realized", &error_fatal);
+    sysbus_connect_irq(SYS_BUS_DEVICE(rtc), 0, get_sse_irq_in(mms, 39));
+    return sysbus_mmio_get_region(SYS_BUS_DEVICE(rtc), 0);
+}
+
 static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
                                        const char *name, hwaddr size)
 {
@@ -XXX,XX +XXX,XX @@ static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
         { "i2c1", make_unimp_dev, &mms->i2c[1], 0x5000, 0x1000 },
         { "i2s", make_unimp_dev, &mms->i2s, 0x6000, 0x1000 },
         { "pwm0", make_unimp_dev, &mms->pwm[0], 0x7000, 0x1000 },
-        { "rtc", make_unimp_dev, &mms->rtc, 0x8000, 0x1000 },
+        { "rtc", make_rtc, &mms->rtc, 0x8000, 0x1000 },
         { "qspi", make_unimp_dev, &mms->qspi, 0xa000, 0x1000 },
         { "timer", make_unimp_dev, &mms->timer, 0xb000, 0x1000 },
         { "scc", make_unimp_dev, &mms->scc, 0xc000, 0x1000 },
@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
                 { "spi", make_unimp_dev, &mms->spi, 0x4010a000, 0x1000 },
                 { "scc", make_unimp_dev, &mms->scc, 0x5010b000, 0x1000 },
                 { "timer", make_unimp_dev, &mms->timer, 0x4010c000, 0x1000 },
-                { "rtc", make_unimp_dev, &mms->rtc, 0x4010d000, 0x1000 },
+                { "rtc", make_rtc, &mms->rtc, 0x4010d000, 0x1000 },
                 { "pvt", make_unimp_dev, &mms->pvt, 0x4010e000, 0x1000 },
                 { "sdio", make_unimp_dev, &mms->sdio, 0x4010f000, 0x1000 },
             },
-- 
2.20.1

Wire up the two PL011 UARTs in the Musca board.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
---
 hw/arm/musca.c | 34 +++++++++++++++++++++++++++++-----
 1 file changed, 29 insertions(+), 5 deletions(-)

diff --git a/hw/arm/musca.c b/hw/arm/musca.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/musca.c
+++ b/hw/arm/musca.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/error-report.h"
 #include "qapi/error.h"
 #include "exec/address-spaces.h"
+#include "sysemu/sysemu.h"
 #include "hw/arm/arm.h"
 #include "hw/arm/armsse.h"
 #include "hw/boards.h"
+#include "hw/char/pl011.h"
 #include "hw/core/split-irq.h"
 #include "hw/misc/tz-mpc.h"
 #include "hw/misc/tz-ppc.h"
@@ -XXX,XX +XXX,XX @@ typedef struct {
     UnimplementedDeviceState mhu[2];
     UnimplementedDeviceState pwm[3];
     UnimplementedDeviceState i2s;
-    UnimplementedDeviceState uart[2];
+    PL011State uart[2];
     UnimplementedDeviceState i2c[2];
     UnimplementedDeviceState spi;
     UnimplementedDeviceState scc;
@@ -XXX,XX +XXX,XX @@ static MemoryRegion *make_rtc(MuscaMachineState *mms, void *opaque,
     return sysbus_mmio_get_region(SYS_BUS_DEVICE(rtc), 0);
 }
 
+static MemoryRegion *make_uart(MuscaMachineState *mms, void *opaque,
+                               const char *name, hwaddr size)
+{
+    PL011State *uart = opaque;
+    int i = uart - &mms->uart[0];
+    int irqbase = 7 + i * 6;
+    SysBusDevice *s;
+
+    sysbus_init_child_obj(OBJECT(mms), name, uart, sizeof(mms->uart[0]),
+                          TYPE_PL011);
+    qdev_prop_set_chr(DEVICE(uart), "chardev", serial_hd(i));
+    object_property_set_bool(OBJECT(uart), true, "realized", &error_fatal);
+    s = SYS_BUS_DEVICE(uart);
+    sysbus_connect_irq(s, 0, get_sse_irq_in(mms, irqbase + 5)); /* combined */
+    sysbus_connect_irq(s, 1, get_sse_irq_in(mms, irqbase + 0)); /* RX */
+    sysbus_connect_irq(s, 2, get_sse_irq_in(mms, irqbase + 1)); /* TX */
+    sysbus_connect_irq(s, 3, get_sse_irq_in(mms, irqbase + 2)); /* RT */
+    sysbus_connect_irq(s, 4, get_sse_irq_in(mms, irqbase + 3)); /* MS */
+    sysbus_connect_irq(s, 5, get_sse_irq_in(mms, irqbase + 4)); /* E */
+    return sysbus_mmio_get_region(SYS_BUS_DEVICE(uart), 0);
+}
+
 static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
                                        const char *name, hwaddr size)
 {
@@ -XXX,XX +XXX,XX @@ static MemoryRegion *make_musca_a_devs(MuscaMachineState *mms, void *opaque,
     MemoryRegion *container = &mms->container;
 
     const PPCPortInfo devices[] = {
-        { "uart0", make_unimp_dev, &mms->uart[0], 0x1000, 0x1000 },
-        { "uart1", make_unimp_dev, &mms->uart[1], 0x2000, 0x1000 },
+        { "uart0", make_uart, &mms->uart[0], 0x1000, 0x1000 },
+        { "uart1", make_uart, &mms->uart[1], 0x2000, 0x1000 },
         { "spi", make_unimp_dev, &mms->spi, 0x3000, 0x1000 },
         { "i2c0", make_unimp_dev, &mms->i2c[0], 0x4000, 0x1000 },
         { "i2c1", make_unimp_dev, &mms->i2c[1], 0x5000, 0x1000 },
@@ -XXX,XX +XXX,XX @@ static void musca_init(MachineState *machine)
                 { "pwm1", make_unimp_dev, &mms->pwm[1], 0x40102000, 0x1000 },
                 { "pwm2", make_unimp_dev, &mms->pwm[2], 0x40103000, 0x1000 },
                 { "i2s", make_unimp_dev, &mms->i2s, 0x40104000, 0x1000 },
-                { "uart0", make_unimp_dev, &mms->uart[0], 0x40105000, 0x1000 },
-                { "uart1", make_unimp_dev, &mms->uart[1], 0x40106000, 0x1000 },
+                { "uart0", make_uart, &mms->uart[0], 0x40105000, 0x1000 },
+                { "uart1", make_uart, &mms->uart[1], 0x40106000, 0x1000 },
                 { "i2c0", make_unimp_dev, &mms->i2c[0], 0x40108000, 0x1000 },
                 { "i2c1", make_unimp_dev, &mms->i2c[1], 0x40109000, 0x1000 },
                 { "spi", make_unimp_dev, &mms->spi, 0x4010a000, 0x1000 },
-- 
2.20.1

The region 0x40010000 .. 0x4001ffff and its secure-only alias
at 0x50010000... are for per-CPU devices. We implement this by
giving each CPU its own container memory region, where the
per-CPU devices live. Unfortunately, the alias region which
makes devices mapped at 0x4... addresses also appear at 0x5...
is only implemented in the overall "all CPUs" container. The
effect of this bug is that the CPU_IDENTITY register block appears
only at 0x4001f000, but not at the 0x5001f000 alias where it should
also appear. Guests (like very recent Arm Trusted Firmware-M)
which try to access it at 0x5001f000 will crash.

Fix this by moving the handling for this alias from the "all CPUs"
container to the per-CPU container. (We leave the aliases for
0x1... and 0x3... in the overall container, because there are
no per-CPU devices there.)

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Message-id: 20190215180500.6906-1-peter.maydell@linaro.org
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
---
 include/hw/arm/armsse.h |  2 +-
 hw/arm/armsse.c         | 26 ++++++++++++++++----------
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/include/hw/arm/armsse.h b/include/hw/arm/armsse.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/arm/armsse.h
+++ b/include/hw/arm/armsse.h
@@ -XXX,XX +XXX,XX @@ typedef struct ARMSSE {
     MemoryRegion cpu_container[SSE_MAX_CPUS];
     MemoryRegion alias1;
     MemoryRegion alias2;
-    MemoryRegion alias3;
+    MemoryRegion alias3[SSE_MAX_CPUS];
     MemoryRegion sram[MAX_SRAM_BANKS];
 
     qemu_irq *exp_irqs[SSE_MAX_CPUS];
diff --git a/hw/arm/armsse.c b/hw/arm/armsse.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/armsse.c
+++ b/hw/arm/armsse.c
@@ -XXX,XX +XXX,XX @@ static bool irq_is_common[32] = {
     /* 30, 31: reserved */
 };
 
-/* Create an alias region of @size bytes starting at @base
+/*
+ * Create an alias region in @container of @size bytes starting at @base
  * which mirrors the memory starting at @orig.
  */
-static void make_alias(ARMSSE *s, MemoryRegion *mr, const char *name,
-                       hwaddr base, hwaddr size, hwaddr orig)
+static void make_alias(ARMSSE *s, MemoryRegion *mr, MemoryRegion *container,
+                       const char *name, hwaddr base, hwaddr size, hwaddr orig)
 {
-    memory_region_init_alias(mr, NULL, name, &s->container, orig, size);
+    memory_region_init_alias(mr, NULL, name, container, orig, size);
     /* The alias is even lower priority than unimplemented_device regions */
-    memory_region_add_subregion_overlap(&s->container, base, mr, -1500);
+    memory_region_add_subregion_overlap(container, base, mr, -1500);
 }
 
 static void irq_status_forwarder(void *opaque, int n, int level)
@@ -XXX,XX +XXX,XX @@ static void armsse_realize(DeviceState *dev, Error **errp)
     }
 
     /* Set up the big aliases first */
-    make_alias(s, &s->alias1, "alias 1", 0x10000000, 0x10000000, 0x00000000);
-    make_alias(s, &s->alias2, "alias 2", 0x30000000, 0x10000000, 0x20000000);
+    make_alias(s, &s->alias1, &s->container, "alias 1",
+               0x10000000, 0x10000000, 0x00000000);
+    make_alias(s, &s->alias2, &s->container,
+               "alias 2", 0x30000000, 0x10000000, 0x20000000);
     /* The 0x50000000..0x5fffffff region is not a pure alias: it has
      * a few extra devices that only appear there (generally the
      * control interfaces for the protection controllers).
      * We implement this by mapping those devices over the top of this
-     * alias MR at a higher priority.
+     * alias MR at a higher priority. Some of the devices in this range
+     * are per-CPU, so we must put this alias in the per-cpu containers.
      */
-    make_alias(s, &s->alias3, "alias 3", 0x50000000, 0x10000000, 0x40000000);
-
+    for (i = 0; i < info->num_cpus; i++) {
+        make_alias(s, &s->alias3[i], &s->cpu_container[i],
+                   "alias 3", 0x50000000, 0x10000000, 0x40000000);
+    }
 
     /* Security controller */
     object_property_set_bool(OBJECT(&s->secctl), true, "realized", &err);
-- 
2.20.1

This is a respin of my pull request from earlier this week:
 * versal board compile failure fixed
 * a few new patches:
  - MAINTAINERS file fix
  - use ARRAY_SIZE macro in xilinx_zynq
  - avoid an array overrun in strongarm GPIO irq handling
  - fix an assert running KVM on an aarch64-only host

The following changes since commit 69e2d03843412b9c076515b3aa9a71db161b6a1a:

Merge remote-tracking branch 'remotes/riscv/tags/riscv-for-master-3.1-sf1' into staging (2018-11-02 13:16:13 +0000)

are available in the Git repository at:

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

for you to fetch changes up to 6f16da53ffe4567c0353f85055df04860eb4e6fc:

hw/arm: versal: Add a virtual Xilinx Versal board (2018-11-02 14:11:31 +0000)

----------------------------------------------------------------
target-arm queue:
 * microbit: Add the UART to our nRF51 SoC model
 * Add a virtual Xilinx Versal board "xlnx-versal-virt"
 * hw/arm/virt: Set VIRT_COMPAT_3_0 compat
 * MAINTAINERS: Remove bouncing email in ARM ACPI
 * strongarm: mask off high[31:28] bits from dir and state registers
 * target/arm: Conditionalize some asserts on aarch32 support
 * hw/arm/xilinx_zynq: Use the ARRAY_SIZE macro

----------------------------------------------------------------
Edgar E. Iglesias (2):
      hw/arm: versal: Add a model of Xilinx Versal SoC
      hw/arm: versal: Add a virtual Xilinx Versal board

Eric Auger (1):
      hw/arm/virt: Set VIRT_COMPAT_3_0 compat

Julia Suvorova (3):
      hw/char: Implement nRF51 SoC UART
      hw/arm/nrf51_soc: Connect UART to nRF51 SoC
      tests/boot-serial-test: Add microbit board testcase

Philippe Mathieu-Daudé (2):
      MAINTAINERS: Remove bouncing email in ARM ACPI
      hw/arm/xilinx_zynq: Use the ARRAY_SIZE macro

Prasad J Pandit (1):
      strongarm: mask off high[31:28] bits from dir and state registers

Richard Henderson (1):
      target/arm: Conditionalize some asserts on aarch32 support

hw/arm/Makefile.objs                |   1 +
 hw/char/Makefile.objs               |   1 +
 include/hw/arm/nrf51_soc.h          |   3 +
 include/hw/arm/xlnx-versal.h        | 122 +++++++++
 include/hw/char/nrf51_uart.h        |  78 ++++++
 target/arm/cpu.h                    |   5 +
 hw/arm/microbit.c                   |   2 +
 hw/arm/nrf51_soc.c                  |  20 ++
 hw/arm/strongarm.c                  |   4 +-
 hw/arm/virt.c                       |   4 +
 hw/arm/xilinx_zynq.c                |   2 +-
 hw/arm/xlnx-versal-virt.c           | 494 ++++++++++++++++++++++++++++++++++++
 hw/arm/xlnx-versal.c                | 323 +++++++++++++++++++++++
 hw/char/nrf51_uart.c                | 330 ++++++++++++++++++++++++
 target/arm/cpu.c                    |  15 +-
 tests/boot-serial-test.c            |  19 ++
 MAINTAINERS                         |   1 -
 default-configs/aarch64-softmmu.mak |   1 +
 hw/char/trace-events                |   4 +
 19 files changed, 1423 insertions(+), 6 deletions(-)
 create mode 100644 include/hw/arm/xlnx-versal.h
 create mode 100644 include/hw/char/nrf51_uart.h
 create mode 100644 hw/arm/xlnx-versal-virt.c
 create mode 100644 hw/arm/xlnx-versal.c
 create mode 100644 hw/char/nrf51_uart.c

From: Eric Auger <eric.auger@redhat.com>

We are missing the VIRT_COMPAT_3_0 definition and setting.
Let's add them.

Signed-off-by: Eric Auger <eric.auger@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Message-id: 20181024085602.16611-1-eric.auger@redhat.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 hw/arm/virt.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/hw/arm/virt.c b/hw/arm/virt.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/virt.c
+++ b/hw/arm/virt.c
@@ -XXX,XX +XXX,XX @@ static void virt_machine_3_1_options(MachineClass *mc)
 }
 DEFINE_VIRT_MACHINE_AS_LATEST(3, 1)
 
+#define VIRT_COMPAT_3_0 \
+    HW_COMPAT_3_0
+
 static void virt_3_0_instance_init(Object *obj)
 {
     virt_3_1_instance_init(obj);
@@ -XXX,XX +XXX,XX @@ static void virt_3_0_instance_init(Object *obj)
 static void virt_machine_3_0_options(MachineClass *mc)
 {
     virt_machine_3_1_options(mc);
+    SET_MACHINE_COMPAT(mc, VIRT_COMPAT_3_0);
 }
 DEFINE_VIRT_MACHINE(3, 0)
 
-- 
2.19.1

From: Julia Suvorova <jusual@mail.ru>

Not implemented: CTS/NCTS, PSEL*.

Signed-off-by: Julia Suvorova <jusual@mail.ru>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 hw/char/Makefile.objs        |   1 +
 include/hw/char/nrf51_uart.h |  78 +++++++++
 hw/char/nrf51_uart.c         | 330 +++++++++++++++++++++++++++++++++++
 hw/char/trace-events         |   4 +
 4 files changed, 413 insertions(+)
 create mode 100644 include/hw/char/nrf51_uart.h
 create mode 100644 hw/char/nrf51_uart.c

diff --git a/hw/char/Makefile.objs b/hw/char/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/hw/char/Makefile.objs
+++ b/hw/char/Makefile.objs
@@ -XXX,XX +XXX,XX @@
 common-obj-$(CONFIG_IPACK) += ipoctal232.o
 common-obj-$(CONFIG_ESCC) += escc.o
+common-obj-$(CONFIG_NRF51_SOC) += nrf51_uart.o
 common-obj-$(CONFIG_PARALLEL) += parallel.o
 common-obj-$(CONFIG_PARALLEL) += parallel-isa.o
 common-obj-$(CONFIG_PL011) += pl011.o
diff --git a/include/hw/char/nrf51_uart.h b/include/hw/char/nrf51_uart.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/hw/char/nrf51_uart.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * nRF51 SoC UART emulation
+ *
+ * Copyright (c) 2018 Julia Suvorova <jusual@mail.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 or
+ * (at your option) any later version.
+ */
+
+#ifndef NRF51_UART_H
+#define NRF51_UART_H
+
+#include "hw/sysbus.h"
+#include "chardev/char-fe.h"
+#include "hw/registerfields.h"
+
+#define UART_FIFO_LENGTH 6
+#define UART_BASE 0x40002000
+#define UART_SIZE 0x1000
+
+#define TYPE_NRF51_UART "nrf51_soc.uart"
+#define NRF51_UART(obj) OBJECT_CHECK(NRF51UARTState, (obj), TYPE_NRF51_UART)
+
+REG32(UART_STARTRX, 0x000)
+REG32(UART_STOPRX, 0x004)
+REG32(UART_STARTTX, 0x008)
+REG32(UART_STOPTX, 0x00C)
+REG32(UART_SUSPEND, 0x01C)
+
+REG32(UART_CTS, 0x100)
+REG32(UART_NCTS, 0x104)
+REG32(UART_RXDRDY, 0x108)
+REG32(UART_TXDRDY, 0x11C)
+REG32(UART_ERROR, 0x124)
+REG32(UART_RXTO, 0x144)
+
+REG32(UART_INTEN, 0x300)
+    FIELD(UART_INTEN, CTS, 0, 1)
+    FIELD(UART_INTEN, NCTS, 1, 1)
+    FIELD(UART_INTEN, RXDRDY, 2, 1)
+    FIELD(UART_INTEN, TXDRDY, 7, 1)
+    FIELD(UART_INTEN, ERROR, 9, 1)
+    FIELD(UART_INTEN, RXTO, 17, 1)
+REG32(UART_INTENSET, 0x304)
+REG32(UART_INTENCLR, 0x308)
+REG32(UART_ERRORSRC, 0x480)
+REG32(UART_ENABLE, 0x500)
+REG32(UART_PSELRTS, 0x508)
+REG32(UART_PSELTXD, 0x50C)
+REG32(UART_PSELCTS, 0x510)
+REG32(UART_PSELRXD, 0x514)
+REG32(UART_RXD, 0x518)
+REG32(UART_TXD, 0x51C)
+REG32(UART_BAUDRATE, 0x524)
+REG32(UART_CONFIG, 0x56C)
+
+typedef struct NRF51UARTState {
+    SysBusDevice parent_obj;
+
+    MemoryRegion iomem;
+    CharBackend chr;
+    qemu_irq irq;
+    guint watch_tag;
+
+    uint8_t rx_fifo[UART_FIFO_LENGTH];
+    unsigned int rx_fifo_pos;
+    unsigned int rx_fifo_len;
+
+    uint32_t reg[0x56C];
+
+    bool rx_started;
+    bool tx_started;
+    bool pending_tx_byte;
+    bool enabled;
+} NRF51UARTState;
+
+#endif
diff --git a/hw/char/nrf51_uart.c b/hw/char/nrf51_uart.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/hw/char/nrf51_uart.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * nRF51 SoC UART emulation
+ *
+ * See nRF51 Series Reference Manual, "29 Universal Asynchronous
+ * Receiver/Transmitter" for hardware specifications:
+ * http://infocenter.nordicsemi.com/pdf/nRF51_RM_v3.0.pdf
+ *
+ * Copyright (c) 2018 Julia Suvorova <jusual@mail.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 or
+ * (at your option) any later version.
+ */
+
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "hw/char/nrf51_uart.h"
+#include "trace.h"
+
+static void nrf51_uart_update_irq(NRF51UARTState *s)
+{
+    bool irq = false;
+
+    irq |= (s->reg[R_UART_RXDRDY] &&
+            (s->reg[R_UART_INTEN] & R_UART_INTEN_RXDRDY_MASK));
+    irq |= (s->reg[R_UART_TXDRDY] &&
+            (s->reg[R_UART_INTEN] & R_UART_INTEN_TXDRDY_MASK));
+    irq |= (s->reg[R_UART_ERROR]  &&
+            (s->reg[R_UART_INTEN] & R_UART_INTEN_ERROR_MASK));
+    irq |= (s->reg[R_UART_RXTO]   &&
+            (s->reg[R_UART_INTEN] & R_UART_INTEN_RXTO_MASK));
+
+    qemu_set_irq(s->irq, irq);
+}
+
+static uint64_t uart_read(void *opaque, hwaddr addr, unsigned int size)
+{
+    NRF51UARTState *s = NRF51_UART(opaque);
+    uint64_t r;
+
+    if (!s->enabled) {
+        return 0;
+    }
+
+    switch (addr) {
+    case A_UART_RXD:
+        r = s->rx_fifo[s->rx_fifo_pos];
+        if (s->rx_started && s->rx_fifo_len) {
+            s->rx_fifo_pos = (s->rx_fifo_pos + 1) % UART_FIFO_LENGTH;
+            s->rx_fifo_len--;
+            if (s->rx_fifo_len) {
+                s->reg[R_UART_RXDRDY] = 1;
+                nrf51_uart_update_irq(s);
+            }
+            qemu_chr_fe_accept_input(&s->chr);
+        }
+        break;
+    case A_UART_INTENSET:
+    case A_UART_INTENCLR:
+    case A_UART_INTEN:
+        r = s->reg[R_UART_INTEN];
+        break;
+    default:
+        r = s->reg[addr / 4];
+        break;
+    }
+
+    trace_nrf51_uart_read(addr, r, size);
+
+    return r;
+}
+
+static gboolean uart_transmit(GIOChannel *chan, GIOCondition cond, void *opaque)
+{
+    NRF51UARTState *s = NRF51_UART(opaque);
+    int r;
+    uint8_t c = s->reg[R_UART_TXD];
+
+    s->watch_tag = 0;
+
+    r = qemu_chr_fe_write(&s->chr, &c, 1);
+    if (r <= 0) {
+        s->watch_tag = qemu_chr_fe_add_watch(&s->chr, G_IO_OUT | G_IO_HUP,
+                                             uart_transmit, s);
+        if (!s->watch_tag) {
+            /* The hardware has no transmit error reporting,
+             * so silently drop the byte
+             */
+            goto buffer_drained;
+        }
+        return FALSE;
+    }
+
+buffer_drained:
+    s->reg[R_UART_TXDRDY] = 1;
+    s->pending_tx_byte = false;
+    return FALSE;
+}
+
+static void uart_cancel_transmit(NRF51UARTState *s)
+{
+    if (s->watch_tag) {
+        g_source_remove(s->watch_tag);
+        s->watch_tag = 0;
+    }
+}
+
+static void uart_write(void *opaque, hwaddr addr,
+                       uint64_t value, unsigned int size)
+{
+    NRF51UARTState *s = NRF51_UART(opaque);
+
+    trace_nrf51_uart_write(addr, value, size);
+
+    if (!s->enabled && (addr != A_UART_ENABLE)) {
+        return;
+    }
+
+    switch (addr) {
+    case A_UART_TXD:
+        if (!s->pending_tx_byte && s->tx_started) {
+            s->reg[R_UART_TXD] = value;
+            s->pending_tx_byte = true;
+            uart_transmit(NULL, G_IO_OUT, s);
+        }
+        break;
+    case A_UART_INTEN:
+        s->reg[R_UART_INTEN] = value;
+        break;
+    case A_UART_INTENSET:
+        s->reg[R_UART_INTEN] |= value;
+        break;
+    case A_UART_INTENCLR:
+        s->reg[R_UART_INTEN] &= ~value;
+        break;
+    case A_UART_TXDRDY ... A_UART_RXTO:
+        s->reg[addr / 4] = value;
+        break;
+    case A_UART_ERRORSRC:
+        s->reg[addr / 4] &= ~value;
+        break;
+    case A_UART_RXD:
+        break;
+    case A_UART_RXDRDY:
+        if (value == 0) {
+            s->reg[R_UART_RXDRDY] = 0;
+        }
+        break;
+    case A_UART_STARTTX:
+        if (value == 1) {
+            s->tx_started = true;
+        }
+        break;
+    case A_UART_STARTRX:
+        if (value == 1) {
+            s->rx_started = true;
+        }
+        break;
+    case A_UART_ENABLE:
+        if (value) {
+            if (value == 4) {
+                s->enabled = true;
+            }
+            break;
+        }
+        s->enabled = false;
+        value = 1;
+        /* fall through */
+    case A_UART_SUSPEND:
+    case A_UART_STOPTX:
+        if (value == 1) {
+            s->tx_started = false;
+        }
+        /* fall through */
+    case A_UART_STOPRX:
+        if (addr != A_UART_STOPTX && value == 1) {
+            s->rx_started = false;
+            s->reg[R_UART_RXTO] = 1;
+        }
+        break;
+    default:
+        s->reg[addr / 4] = value;
+        break;
+    }
+    nrf51_uart_update_irq(s);
+}
+
+static const MemoryRegionOps uart_ops = {
+    .read =  uart_read,
+    .write = uart_write,
+    .endianness = DEVICE_LITTLE_ENDIAN,
+};
+
+static void nrf51_uart_reset(DeviceState *dev)
+{
+    NRF51UARTState *s = NRF51_UART(dev);
+
+    s->pending_tx_byte = 0;
+
+    uart_cancel_transmit(s);
+
+    memset(s->reg, 0, sizeof(s->reg));
+
+    s->reg[R_UART_PSELRTS] = 0xFFFFFFFF;
+    s->reg[R_UART_PSELTXD] = 0xFFFFFFFF;
+    s->reg[R_UART_PSELCTS] = 0xFFFFFFFF;
+    s->reg[R_UART_PSELRXD] = 0xFFFFFFFF;
+    s->reg[R_UART_BAUDRATE] = 0x4000000;
+
+    s->rx_fifo_len = 0;
+    s->rx_fifo_pos = 0;
+    s->rx_started = false;
+    s->tx_started = false;
+    s->enabled = false;
+}
+
+static void uart_receive(void *opaque, const uint8_t *buf, int size)
+{
+
+    NRF51UARTState *s = NRF51_UART(opaque);
+    int i;
+
+    if (size == 0 || s->rx_fifo_len >= UART_FIFO_LENGTH) {
+        return;
+    }
+
+    for (i = 0; i < size; i++) {
+        uint32_t pos = (s->rx_fifo_pos + s->rx_fifo_len) % UART_FIFO_LENGTH;
+        s->rx_fifo[pos] = buf[i];
+        s->rx_fifo_len++;
+    }
+
+    s->reg[R_UART_RXDRDY] = 1;
+    nrf51_uart_update_irq(s);
+}
+
+static int uart_can_receive(void *opaque)
+{
+    NRF51UARTState *s = NRF51_UART(opaque);
+
+    return s->rx_started ? (UART_FIFO_LENGTH - s->rx_fifo_len) : 0;
+}
+
+static void uart_event(void *opaque, int event)
+{
+    NRF51UARTState *s = NRF51_UART(opaque);
+
+    if (event == CHR_EVENT_BREAK) {
+        s->reg[R_UART_ERRORSRC] |= 3;
+        s->reg[R_UART_ERROR] = 1;
+        nrf51_uart_update_irq(s);
+    }
+}
+
+static void nrf51_uart_realize(DeviceState *dev, Error **errp)
+{
+    NRF51UARTState *s = NRF51_UART(dev);
+
+    qemu_chr_fe_set_handlers(&s->chr, uart_can_receive, uart_receive,
+                             uart_event, NULL, s, NULL, true);
+}
+
+static void nrf51_uart_init(Object *obj)
+{
+    NRF51UARTState *s = NRF51_UART(obj);
+    SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
+
+    memory_region_init_io(&s->iomem, obj, &uart_ops, s,
+                          "nrf51_soc.uart", UART_SIZE);
+    sysbus_init_mmio(sbd, &s->iomem);
+    sysbus_init_irq(sbd, &s->irq);
+}
+
+static int nrf51_uart_post_load(void *opaque, int version_id)
+{
+    NRF51UARTState *s = NRF51_UART(opaque);
+
+    if (s->pending_tx_byte) {
+        s->watch_tag = qemu_chr_fe_add_watch(&s->chr, G_IO_OUT | G_IO_HUP,
+                                             uart_transmit, s);
+    }
+
+    return 0;
+}
+
+static const VMStateDescription nrf51_uart_vmstate = {
+    .name = "nrf51_soc.uart",
+    .post_load = nrf51_uart_post_load,
+    .fields = (VMStateField[]) {
+        VMSTATE_UINT32_ARRAY(reg, NRF51UARTState, 0x56C),
+        VMSTATE_UINT8_ARRAY(rx_fifo, NRF51UARTState, UART_FIFO_LENGTH),
+        VMSTATE_UINT32(rx_fifo_pos, NRF51UARTState),
+        VMSTATE_UINT32(rx_fifo_len, NRF51UARTState),
+        VMSTATE_BOOL(rx_started, NRF51UARTState),
+        VMSTATE_BOOL(tx_started, NRF51UARTState),
+        VMSTATE_BOOL(pending_tx_byte, NRF51UARTState),
+        VMSTATE_BOOL(enabled, NRF51UARTState),
+        VMSTATE_END_OF_LIST()
+    }
+};
+
+static Property nrf51_uart_properties[] = {
+    DEFINE_PROP_CHR("chardev", NRF51UARTState, chr),
+    DEFINE_PROP_END_OF_LIST(),
+};
+
+static void nrf51_uart_class_init(ObjectClass *klass, void *data)
+{
+    DeviceClass *dc = DEVICE_CLASS(klass);
+
+    dc->reset = nrf51_uart_reset;
+    dc->realize = nrf51_uart_realize;
+    dc->props = nrf51_uart_properties;
+    dc->vmsd = &nrf51_uart_vmstate;
+}
+
+static const TypeInfo nrf51_uart_info = {
+    .name = TYPE_NRF51_UART,
+    .parent = TYPE_SYS_BUS_DEVICE,
+    .instance_size = sizeof(NRF51UARTState),
+    .instance_init = nrf51_uart_init,
+    .class_init = nrf51_uart_class_init
+};
+
+static void nrf51_uart_register_types(void)
+{
+    type_register_static(&nrf51_uart_info);
+}
+
+type_init(nrf51_uart_register_types)
diff --git a/hw/char/trace-events b/hw/char/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/char/trace-events
+++ b/hw/char/trace-events
@@ -XXX,XX +XXX,XX @@ cmsdk_apb_uart_receive(uint8_t c) "CMSDK APB UART: got character 0x%x from backe
 cmsdk_apb_uart_tx_pending(void) "CMSDK APB UART: character send to backend pending"
 cmsdk_apb_uart_tx(uint8_t c) "CMSDK APB UART: character 0x%x sent to backend"
 cmsdk_apb_uart_set_params(int speed) "CMSDK APB UART: params set to %d 8N1"
+
+# hw/char/nrf51_uart.c
+nrf51_uart_read(uint64_t addr, uint64_t r, unsigned int size) "addr 0x%" PRIx64 " value 0x%" PRIx64 " size %u"
+nrf51_uart_write(uint64_t addr, uint64_t value, unsigned int size) "addr 0x%" PRIx64 " value 0x%" PRIx64 " size %u"
-- 
2.19.1

From: Julia Suvorova <jusual@mail.ru>

Wire up nRF51 UART in the corresponding SoC.

Signed-off-by: Julia Suvorova <jusual@mail.ru>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 include/hw/arm/nrf51_soc.h |  3 +++
 hw/arm/microbit.c          |  2 ++
 hw/arm/nrf51_soc.c         | 20 ++++++++++++++++++++
 3 files changed, 25 insertions(+)

diff --git a/include/hw/arm/nrf51_soc.h b/include/hw/arm/nrf51_soc.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/arm/nrf51_soc.h
+++ b/include/hw/arm/nrf51_soc.h
@@ -XXX,XX +XXX,XX @@
 
 #include "hw/sysbus.h"
 #include "hw/arm/armv7m.h"
+#include "hw/char/nrf51_uart.h"
 
 #define TYPE_NRF51_SOC "nrf51-soc"
 #define NRF51_SOC(obj) \
@@ -XXX,XX +XXX,XX @@ typedef struct NRF51State {
     /*< public >*/
     ARMv7MState cpu;
 
+    NRF51UARTState uart;
+
     MemoryRegion iomem;
     MemoryRegion sram;
     MemoryRegion flash;
diff --git a/hw/arm/microbit.c b/hw/arm/microbit.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/microbit.c
+++ b/hw/arm/microbit.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/error.h"
 #include "hw/boards.h"
 #include "hw/arm/arm.h"
+#include "sysemu/sysemu.h"
 #include "exec/address-spaces.h"
 
 #include "hw/arm/nrf51_soc.h"
@@ -XXX,XX +XXX,XX @@ static void microbit_init(MachineState *machine)
 
     sysbus_init_child_obj(OBJECT(machine), "nrf51", soc, sizeof(s->nrf51),
                           TYPE_NRF51_SOC);
+    qdev_prop_set_chr(DEVICE(&s->nrf51), "serial0", serial_hd(0));
     object_property_set_link(soc, OBJECT(system_memory), "memory",
                              &error_fatal);
     object_property_set_bool(soc, true, "realized", &error_fatal);
diff --git a/hw/arm/nrf51_soc.c b/hw/arm/nrf51_soc.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/nrf51_soc.c
+++ b/hw/arm/nrf51_soc.c
@@ -XXX,XX +XXX,XX @@
 #define NRF51822_FLASH_SIZE     (256 * 1024)
 #define NRF51822_SRAM_SIZE      (16 * 1024)
 
+#define BASE_TO_IRQ(base) ((base >> 12) & 0x1F)
+
 static void nrf51_soc_realize(DeviceState *dev_soc, Error **errp)
 {
     NRF51State *s = NRF51_SOC(dev_soc);
+    MemoryRegion *mr;
     Error *err = NULL;
 
     if (!s->board_memory) {
@@ -XXX,XX +XXX,XX @@ static void nrf51_soc_realize(DeviceState *dev_soc, Error **errp)
     }
     memory_region_add_subregion(&s->container, SRAM_BASE, &s->sram);
 
+    /* UART */
+    object_property_set_bool(OBJECT(&s->uart), true, "realized", &err);
+    if (err) {
+        error_propagate(errp, err);
+        return;
+    }
+    mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->uart), 0);
+    memory_region_add_subregion_overlap(&s->container, UART_BASE, mr, 0);
+    sysbus_connect_irq(SYS_BUS_DEVICE(&s->uart), 0,
+                       qdev_get_gpio_in(DEVICE(&s->cpu),
+                       BASE_TO_IRQ(UART_BASE)));
+
     create_unimplemented_device("nrf51_soc.io", IOMEM_BASE, IOMEM_SIZE);
     create_unimplemented_device("nrf51_soc.ficr", FICR_BASE, FICR_SIZE);
     create_unimplemented_device("nrf51_soc.private",
@@ -XXX,XX +XXX,XX @@ static void nrf51_soc_init(Object *obj)
     qdev_prop_set_string(DEVICE(&s->cpu), "cpu-type",
                          ARM_CPU_TYPE_NAME("cortex-m0"));
     qdev_prop_set_uint32(DEVICE(&s->cpu), "num-irq", 32);
+
+    sysbus_init_child_obj(obj, "uart", &s->uart, sizeof(s->uart),
+                           TYPE_NRF51_UART);
+    object_property_add_alias(obj, "serial0", OBJECT(&s->uart), "chardev",
+                              &error_abort);
 }
 
 static Property nrf51_soc_properties[] = {
-- 
2.19.1

From: Julia Suvorova <jusual@mail.ru>

New mini-kernel test for nRF51 SoC UART.

Signed-off-by: Julia Suvorova <jusual@mail.ru>
Acked-by: Thomas Huth <thuth@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 tests/boot-serial-test.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/tests/boot-serial-test.c b/tests/boot-serial-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/boot-serial-test.c
+++ b/tests/boot-serial-test.c
@@ -XXX,XX +XXX,XX @@ static const uint8_t kernel_aarch64[] = {
     0xfd, 0xff, 0xff, 0x17,                 /* b       -12 (loop) */
 };
 
+static const uint8_t kernel_nrf51[] = {
+    0x00, 0x00, 0x00, 0x00,                 /* Stack top address */
+    0x09, 0x00, 0x00, 0x00,                 /* Reset handler address */
+    0x04, 0x4a,                             /* ldr  r2, [pc, #16] Get ENABLE */
+    0x04, 0x21,                             /* movs r1, #4 */
+    0x11, 0x60,                             /* str  r1, [r2] */
+    0x04, 0x4a,                             /* ldr  r2, [pc, #16] Get STARTTX */
+    0x01, 0x21,                             /* movs r1, #1 */
+    0x11, 0x60,                             /* str  r1, [r2] */
+    0x03, 0x4a,                             /* ldr  r2, [pc, #12] Get TXD */
+    0x54, 0x21,                             /* movs r1, 'T' */
+    0x11, 0x60,                             /* str  r1, [r2] */
+    0xfe, 0xe7,                             /* b    . */
+    0x00, 0x25, 0x00, 0x40,                 /* 0x40002500 = UART ENABLE */
+    0x08, 0x20, 0x00, 0x40,                 /* 0x40002008 = UART STARTTX */
+    0x1c, 0x25, 0x00, 0x40                  /* 0x4000251c = UART TXD */
+};
+
 typedef struct testdef {
     const char *arch;       /* Target architecture */
     const char *machine;    /* Name of the machine */
@@ -XXX,XX +XXX,XX @@ static testdef_t tests[] = {
     { "hppa", "hppa", "", "SeaBIOS wants SYSTEM HALT" },
     { "aarch64", "virt", "-cpu cortex-a57", "TT", sizeof(kernel_aarch64),
       kernel_aarch64 },
+    { "arm", "microbit", "", "T", sizeof(kernel_nrf51), kernel_nrf51 },
 
     { NULL }
 };
-- 
2.19.1

From: Prasad J Pandit <pjp@fedoraproject.org>

The high[31:28] bits of 'direction' and 'state' registers of
SA-1100/SA-1110 device are reserved. Setting them may lead to
OOB 's->handler[]' array access issue. Mask off [31:28] bits to
avoid it.

Reported-by: Moguofang <moguofang@huawei.com>
Signed-off-by: Prasad J Pandit <pjp@fedoraproject.org>
Message-id: 20181030114635.31232-1-ppandit@redhat.com
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 hw/arm/strongarm.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hw/arm/strongarm.c b/hw/arm/strongarm.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/strongarm.c
+++ b/hw/arm/strongarm.c
@@ -XXX,XX +XXX,XX @@ static void strongarm_gpio_write(void *opaque, hwaddr offset,
 
     switch (offset) {
     case GPDR:        /* GPIO Pin-Direction registers */
-        s->dir = value;
+        s->dir = value & 0x0fffffff;
         strongarm_gpio_handler_update(s);
         break;
 
     case GPSR:        /* GPIO Pin-Output Set registers */
-        s->olevel |= value;
+        s->olevel |= value & 0x0fffffff;
         strongarm_gpio_handler_update(s);
         break;
 
-- 
2.19.1

From: Richard Henderson <richard.henderson@linaro.org>

When populating id registers from kvm, on a host that doesn't support
aarch32 mode at all, neither arm_div nor jazelle will be supported either.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Tested-by: Alex Bennée <alex.bennee@linaro.org>
Message-id: 20181102102025.3546-1-richard.henderson@linaro.org
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 target/arm/cpu.h |  5 +++++
 target/arm/cpu.c | 15 +++++++++++++--
 2 files changed, 18 insertions(+), 2 deletions(-)

From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com>

Add a model of Xilinx Versal SoC.

Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com>
Message-id: 20181102131913.1535-2-edgar.iglesias@xilinx.com
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 hw/arm/Makefile.objs                |   1 +
 include/hw/arm/xlnx-versal.h        | 122 +++++++++++
 hw/arm/xlnx-versal.c                | 323 ++++++++++++++++++++++++++++
 default-configs/aarch64-softmmu.mak |   1 +
 4 files changed, 447 insertions(+)
 create mode 100644 include/hw/arm/xlnx-versal.h
 create mode 100644 hw/arm/xlnx-versal.c

diff --git a/hw/arm/Makefile.objs b/hw/arm/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/Makefile.objs
+++ b/hw/arm/Makefile.objs
@@ -XXX,XX +XXX,XX @@ obj-$(CONFIG_ALLWINNER_A10) += allwinner-a10.o cubieboard.o
 obj-$(CONFIG_RASPI) += bcm2835_peripherals.o bcm2836.o raspi.o
 obj-$(CONFIG_STM32F205_SOC) += stm32f205_soc.o
 obj-$(CONFIG_XLNX_ZYNQMP_ARM) += xlnx-zynqmp.o xlnx-zcu102.o
+obj-$(CONFIG_XLNX_VERSAL) += xlnx-versal.o
 obj-$(CONFIG_FSL_IMX25) += fsl-imx25.o imx25_pdk.o
 obj-$(CONFIG_FSL_IMX31) += fsl-imx31.o kzm.o
 obj-$(CONFIG_FSL_IMX6) += fsl-imx6.o sabrelite.o
diff --git a/include/hw/arm/xlnx-versal.h b/include/hw/arm/xlnx-versal.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/hw/arm/xlnx-versal.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * Model of the Xilinx Versal
+ *
+ * Copyright (c) 2018 Xilinx Inc.
+ * Written by Edgar E. Iglesias
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 or
+ * (at your option) any later version.
+ */
+
+#ifndef XLNX_VERSAL_H
+#define XLNX_VERSAL_H
+
+#include "hw/sysbus.h"
+#include "hw/arm/arm.h"
+#include "hw/intc/arm_gicv3.h"
+
+#define TYPE_XLNX_VERSAL "xlnx-versal"
+#define XLNX_VERSAL(obj) OBJECT_CHECK(Versal, (obj), TYPE_XLNX_VERSAL)
+
+#define XLNX_VERSAL_NR_ACPUS   2
+#define XLNX_VERSAL_NR_UARTS   2
+#define XLNX_VERSAL_NR_GEMS    2
+#define XLNX_VERSAL_NR_IRQS    256
+
+typedef struct Versal {
+    /*< private >*/
+    SysBusDevice parent_obj;
+
+    /*< public >*/
+    struct {
+        struct {
+            MemoryRegion mr;
+            ARMCPU *cpu[XLNX_VERSAL_NR_ACPUS];
+            GICv3State gic;
+        } apu;
+    } fpd;
+
+    MemoryRegion mr_ps;
+
+    struct {
+        /* 4 ranges to access DDR.  */
+        MemoryRegion mr_ddr_ranges[4];
+    } noc;
+
+    struct {
+        MemoryRegion mr_ocm;
+
+        struct {
+            SysBusDevice *uart[XLNX_VERSAL_NR_UARTS];
+            SysBusDevice *gem[XLNX_VERSAL_NR_GEMS];
+        } iou;
+    } lpd;
+
+    struct {
+        MemoryRegion *mr_ddr;
+        uint32_t psci_conduit;
+    } cfg;
+} Versal;
+
+/* Memory-map and IRQ definitions. Copied a subset from
+ * auto-generated files.  */
+
+#define VERSAL_GIC_MAINT_IRQ        9
+#define VERSAL_TIMER_VIRT_IRQ       11
+#define VERSAL_TIMER_S_EL1_IRQ      13
+#define VERSAL_TIMER_NS_EL1_IRQ     14
+#define VERSAL_TIMER_NS_EL2_IRQ     10
+
+#define VERSAL_UART0_IRQ_0         18
+#define VERSAL_UART1_IRQ_0         19
+#define VERSAL_GEM0_IRQ_0          56
+#define VERSAL_GEM0_WAKE_IRQ_0     57
+#define VERSAL_GEM1_IRQ_0          58
+#define VERSAL_GEM1_WAKE_IRQ_0     59
+
+/* Architecturally eserved IRQs suitable for virtualization.  */
+#define VERSAL_RSVD_HIGH_IRQ_FIRST 160
+#define VERSAL_RSVD_HIGH_IRQ_LAST  255
+
+#define MM_TOP_RSVD                 0xa0000000U
+#define MM_TOP_RSVD_SIZE            0x4000000
+#define MM_GIC_APU_DIST_MAIN        0xf9000000U
+#define MM_GIC_APU_DIST_MAIN_SIZE   0x10000
+#define MM_GIC_APU_REDIST_0         0xf9080000U
+#define MM_GIC_APU_REDIST_0_SIZE    0x80000
+
+#define MM_UART0                    0xff000000U
+#define MM_UART0_SIZE               0x10000
+#define MM_UART1                    0xff010000U
+#define MM_UART1_SIZE               0x10000
+
+#define MM_GEM0                     0xff0c0000U
+#define MM_GEM0_SIZE                0x10000
+#define MM_GEM1                     0xff0d0000U
+#define MM_GEM1_SIZE                0x10000
+
+#define MM_OCM                      0xfffc0000U
+#define MM_OCM_SIZE                 0x40000
+
+#define MM_TOP_DDR                  0x0
+#define MM_TOP_DDR_SIZE             0x80000000U
+#define MM_TOP_DDR_2                0x800000000ULL
+#define MM_TOP_DDR_2_SIZE           0x800000000ULL
+#define MM_TOP_DDR_3                0xc000000000ULL
+#define MM_TOP_DDR_3_SIZE           0x4000000000ULL
+#define MM_TOP_DDR_4                0x10000000000ULL
+#define MM_TOP_DDR_4_SIZE           0xb780000000ULL
+
+#define MM_PSM_START                0xffc80000U
+#define MM_PSM_END                  0xffcf0000U
+
+#define MM_CRL                      0xff5e0000U
+#define MM_CRL_SIZE                 0x300000
+#define MM_IOU_SCNTR                0xff130000U
+#define MM_IOU_SCNTR_SIZE           0x10000
+#define MM_IOU_SCNTRS               0xff140000U
+#define MM_IOU_SCNTRS_SIZE          0x10000
+#define MM_FPD_CRF                  0xfd1a0000U
+#define MM_FPD_CRF_SIZE             0x140000
+#endif
diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/hw/arm/xlnx-versal.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Xilinx Versal SoC model.
+ *
+ * Copyright (c) 2018 Xilinx Inc.
+ * Written by Edgar E. Iglesias
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 or
+ * (at your option) any later version.
+ */
+
+#include "qemu/osdep.h"
+#include "qapi/error.h"
+#include "qemu-common.h"
+#include "qemu/log.h"
+#include "hw/sysbus.h"
+#include "net/net.h"
+#include "sysemu/sysemu.h"
+#include "sysemu/kvm.h"
+#include "hw/arm/arm.h"
+#include "kvm_arm.h"
+#include "hw/misc/unimp.h"
+#include "hw/intc/arm_gicv3_common.h"
+#include "hw/arm/xlnx-versal.h"
+
+#define XLNX_VERSAL_ACPU_TYPE ARM_CPU_TYPE_NAME("cortex-a72")
+#define GEM_REVISION        0x40070106
+
+static void versal_create_apu_cpus(Versal *s)
+{
+    int i;
+
+    for (i = 0; i < ARRAY_SIZE(s->fpd.apu.cpu); i++) {
+        Object *obj;
+        char *name;
+
+        obj = object_new(XLNX_VERSAL_ACPU_TYPE);
+        if (!obj) {
+            /* Secondary CPUs start in PSCI powered-down state */
+            error_report("Unable to create apu.cpu[%d] of type %s",
+                         i, XLNX_VERSAL_ACPU_TYPE);
+            exit(EXIT_FAILURE);
+        }
+
+        name = g_strdup_printf("apu-cpu[%d]", i);
+        object_property_add_child(OBJECT(s), name, obj, &error_fatal);
+        g_free(name);
+
+        object_property_set_int(obj, s->cfg.psci_conduit,
+                                "psci-conduit", &error_abort);
+        if (i) {
+            object_property_set_bool(obj, true,
+                                     "start-powered-off", &error_abort);
+        }
+
+        object_property_set_int(obj, ARRAY_SIZE(s->fpd.apu.cpu),
+                                "core-count", &error_abort);
+        object_property_set_link(obj, OBJECT(&s->fpd.apu.mr), "memory",
+                                 &error_abort);
+        object_property_set_bool(obj, true, "realized", &error_fatal);
+        s->fpd.apu.cpu[i] = ARM_CPU(obj);
+    }
+}
+
+static void versal_create_apu_gic(Versal *s, qemu_irq *pic)
+{
+    static const uint64_t addrs[] = {
+        MM_GIC_APU_DIST_MAIN,
+        MM_GIC_APU_REDIST_0
+    };
+    SysBusDevice *gicbusdev;
+    DeviceState *gicdev;
+    int nr_apu_cpus = ARRAY_SIZE(s->fpd.apu.cpu);
+    int i;
+
+    sysbus_init_child_obj(OBJECT(s), "apu-gic",
+                          &s->fpd.apu.gic, sizeof(s->fpd.apu.gic),
+                          gicv3_class_name());
+    gicbusdev = SYS_BUS_DEVICE(&s->fpd.apu.gic);
+    gicdev = DEVICE(&s->fpd.apu.gic);
+    qdev_prop_set_uint32(gicdev, "revision", 3);
+    qdev_prop_set_uint32(gicdev, "num-cpu", 2);
+    qdev_prop_set_uint32(gicdev, "num-irq", XLNX_VERSAL_NR_IRQS + 32);
+    qdev_prop_set_uint32(gicdev, "len-redist-region-count", 1);
+    qdev_prop_set_uint32(gicdev, "redist-region-count[0]", 2);
+    qdev_prop_set_bit(gicdev, "has-security-extensions", true);
+
+    object_property_set_bool(OBJECT(&s->fpd.apu.gic), true, "realized",
+                                    &error_fatal);
+
+    for (i = 0; i < ARRAY_SIZE(addrs); i++) {
+        MemoryRegion *mr;
+
+        mr = sysbus_mmio_get_region(gicbusdev, i);
+        memory_region_add_subregion(&s->fpd.apu.mr, addrs[i], mr);
+    }
+
+    for (i = 0; i < nr_apu_cpus; i++) {
+        DeviceState *cpudev = DEVICE(s->fpd.apu.cpu[i]);
+        int ppibase = XLNX_VERSAL_NR_IRQS + i * GIC_INTERNAL + GIC_NR_SGIS;
+        qemu_irq maint_irq;
+        int ti;
+        /* Mapping from the output timer irq lines from the CPU to the
+         * GIC PPI inputs.
+         */
+        const int timer_irq[] = {
+            [GTIMER_PHYS] = VERSAL_TIMER_NS_EL1_IRQ,
+            [GTIMER_VIRT] = VERSAL_TIMER_VIRT_IRQ,
+            [GTIMER_HYP]  = VERSAL_TIMER_NS_EL2_IRQ,
+            [GTIMER_SEC]  = VERSAL_TIMER_S_EL1_IRQ,
+        };
+
+        for (ti = 0; ti < ARRAY_SIZE(timer_irq); ti++) {
+            qdev_connect_gpio_out(cpudev, ti,
+                                  qdev_get_gpio_in(gicdev,
+                                                   ppibase + timer_irq[ti]));
+        }
+        maint_irq = qdev_get_gpio_in(gicdev,
+                                        ppibase + VERSAL_GIC_MAINT_IRQ);
+        qdev_connect_gpio_out_named(cpudev, "gicv3-maintenance-interrupt",
+                                    0, maint_irq);
+        sysbus_connect_irq(gicbusdev, i, qdev_get_gpio_in(cpudev, ARM_CPU_IRQ));
+        sysbus_connect_irq(gicbusdev, i + nr_apu_cpus,
+                           qdev_get_gpio_in(cpudev, ARM_CPU_FIQ));
+        sysbus_connect_irq(gicbusdev, i + 2 * nr_apu_cpus,
+                           qdev_get_gpio_in(cpudev, ARM_CPU_VIRQ));
+        sysbus_connect_irq(gicbusdev, i + 3 * nr_apu_cpus,
+                           qdev_get_gpio_in(cpudev, ARM_CPU_VFIQ));
+    }
+
+    for (i = 0; i < XLNX_VERSAL_NR_IRQS; i++) {
+        pic[i] = qdev_get_gpio_in(gicdev, i);
+    }
+}
+
+static void versal_create_uarts(Versal *s, qemu_irq *pic)
+{
+    int i;
+
+    for (i = 0; i < ARRAY_SIZE(s->lpd.iou.uart); i++) {
+        static const int irqs[] = { VERSAL_UART0_IRQ_0, VERSAL_UART1_IRQ_0};
+        static const uint64_t addrs[] = { MM_UART0, MM_UART1 };
+        char *name = g_strdup_printf("uart%d", i);
+        DeviceState *dev;
+        MemoryRegion *mr;
+
+        dev = qdev_create(NULL, "pl011");
+        s->lpd.iou.uart[i] = SYS_BUS_DEVICE(dev);
+        qdev_prop_set_chr(dev, "chardev", serial_hd(i));
+        object_property_add_child(OBJECT(s), name, OBJECT(dev), &error_fatal);
+        qdev_init_nofail(dev);
+
+        mr = sysbus_mmio_get_region(s->lpd.iou.uart[i], 0);
+        memory_region_add_subregion(&s->mr_ps, addrs[i], mr);
+
+        sysbus_connect_irq(s->lpd.iou.uart[i], 0, pic[irqs[i]]);
+        g_free(name);
+    }
+}
+
+static void versal_create_gems(Versal *s, qemu_irq *pic)
+{
+    int i;
+
+    for (i = 0; i < ARRAY_SIZE(s->lpd.iou.gem); i++) {
+        static const int irqs[] = { VERSAL_GEM0_IRQ_0, VERSAL_GEM1_IRQ_0};
+        static const uint64_t addrs[] = { MM_GEM0, MM_GEM1 };
+        char *name = g_strdup_printf("gem%d", i);
+        NICInfo *nd = &nd_table[i];
+        DeviceState *dev;
+        MemoryRegion *mr;
+
+        dev = qdev_create(NULL, "cadence_gem");
+        s->lpd.iou.gem[i] = SYS_BUS_DEVICE(dev);
+        object_property_add_child(OBJECT(s), name, OBJECT(dev), &error_fatal);
+        if (nd->used) {
+            qemu_check_nic_model(nd, "cadence_gem");
+            qdev_set_nic_properties(dev, nd);
+        }
+        object_property_set_int(OBJECT(s->lpd.iou.gem[i]),
+                                2, "num-priority-queues",
+                                &error_abort);
+        object_property_set_link(OBJECT(s->lpd.iou.gem[i]),
+                                 OBJECT(&s->mr_ps), "dma",
+                                 &error_abort);
+        qdev_init_nofail(dev);
+
+        mr = sysbus_mmio_get_region(s->lpd.iou.gem[i], 0);
+        memory_region_add_subregion(&s->mr_ps, addrs[i], mr);
+
+        sysbus_connect_irq(s->lpd.iou.gem[i], 0, pic[irqs[i]]);
+        g_free(name);
+    }
+}
+
+/* This takes the board allocated linear DDR memory and creates aliases
+ * for each split DDR range/aperture on the Versal address map.
+ */
+static void versal_map_ddr(Versal *s)
+{
+    uint64_t size = memory_region_size(s->cfg.mr_ddr);
+    /* Describes the various split DDR access regions.  */
+    static const struct {
+        uint64_t base;
+        uint64_t size;
+    } addr_ranges[] = {
+        { MM_TOP_DDR, MM_TOP_DDR_SIZE },
+        { MM_TOP_DDR_2, MM_TOP_DDR_2_SIZE },
+        { MM_TOP_DDR_3, MM_TOP_DDR_3_SIZE },
+        { MM_TOP_DDR_4, MM_TOP_DDR_4_SIZE }
+    };
+    uint64_t offset = 0;
+    int i;
+
+    assert(ARRAY_SIZE(addr_ranges) == ARRAY_SIZE(s->noc.mr_ddr_ranges));
+    for (i = 0; i < ARRAY_SIZE(addr_ranges) && size; i++) {
+        char *name;
+        uint64_t mapsize;
+
+        mapsize = size < addr_ranges[i].size ? size : addr_ranges[i].size;
+        name = g_strdup_printf("noc-ddr-range%d", i);
+        /* Create the MR alias.  */
+        memory_region_init_alias(&s->noc.mr_ddr_ranges[i], OBJECT(s),
+                                 name, s->cfg.mr_ddr,
+                                 offset, mapsize);
+
+        /* Map it onto the NoC MR.  */
+        memory_region_add_subregion(&s->mr_ps, addr_ranges[i].base,
+                                    &s->noc.mr_ddr_ranges[i]);
+        offset += mapsize;
+        size -= mapsize;
+        g_free(name);
+    }
+}
+
+static void versal_unimp_area(Versal *s, const char *name,
+                                MemoryRegion *mr,
+                                hwaddr base, hwaddr size)
+{
+    DeviceState *dev = qdev_create(NULL, TYPE_UNIMPLEMENTED_DEVICE);
+    MemoryRegion *mr_dev;
+
+    qdev_prop_set_string(dev, "name", name);
+    qdev_prop_set_uint64(dev, "size", size);
+    object_property_add_child(OBJECT(s), name, OBJECT(dev), &error_fatal);
+    qdev_init_nofail(dev);
+
+    mr_dev = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0);
+    memory_region_add_subregion(mr, base, mr_dev);
+}
+
+static void versal_unimp(Versal *s)
+{
+    versal_unimp_area(s, "psm", &s->mr_ps,
+                        MM_PSM_START, MM_PSM_END - MM_PSM_START);
+    versal_unimp_area(s, "crl", &s->mr_ps,
+                        MM_CRL, MM_CRL_SIZE);
+    versal_unimp_area(s, "crf", &s->mr_ps,
+                        MM_FPD_CRF, MM_FPD_CRF_SIZE);
+    versal_unimp_area(s, "iou-scntr", &s->mr_ps,
+                        MM_IOU_SCNTR, MM_IOU_SCNTR_SIZE);
+    versal_unimp_area(s, "iou-scntr-seucre", &s->mr_ps,
+                        MM_IOU_SCNTRS, MM_IOU_SCNTRS_SIZE);
+}
+
+static void versal_realize(DeviceState *dev, Error **errp)
+{
+    Versal *s = XLNX_VERSAL(dev);
+    qemu_irq pic[XLNX_VERSAL_NR_IRQS];
+
+    versal_create_apu_cpus(s);
+    versal_create_apu_gic(s, pic);
+    versal_create_uarts(s, pic);
+    versal_create_gems(s, pic);
+    versal_map_ddr(s);
+    versal_unimp(s);
+
+    /* Create the On Chip Memory (OCM).  */
+    memory_region_init_ram(&s->lpd.mr_ocm, OBJECT(s), "ocm",
+                           MM_OCM_SIZE, &error_fatal);
+
+    memory_region_add_subregion_overlap(&s->mr_ps, MM_OCM, &s->lpd.mr_ocm, 0);
+    memory_region_add_subregion_overlap(&s->fpd.apu.mr, 0, &s->mr_ps, 0);
+}
+
+static void versal_init(Object *obj)
+{
+    Versal *s = XLNX_VERSAL(obj);
+
+    memory_region_init(&s->fpd.apu.mr, obj, "mr-apu", UINT64_MAX);
+    memory_region_init(&s->mr_ps, obj, "mr-ps-switch", UINT64_MAX);
+}
+
+static Property versal_properties[] = {
+    DEFINE_PROP_LINK("ddr", Versal, cfg.mr_ddr, TYPE_MEMORY_REGION,
+                     MemoryRegion *),
+    DEFINE_PROP_UINT32("psci-conduit", Versal, cfg.psci_conduit, 0),
+    DEFINE_PROP_END_OF_LIST()
+};
+
+static void versal_class_init(ObjectClass *klass, void *data)
+{
+    DeviceClass *dc = DEVICE_CLASS(klass);
+
+    dc->realize = versal_realize;
+    dc->props = versal_properties;
+    /* No VMSD since we haven't got any top-level SoC state to save.  */
+}
+
+static const TypeInfo versal_info = {
+    .name = TYPE_XLNX_VERSAL,
+    .parent = TYPE_SYS_BUS_DEVICE,
+    .instance_size = sizeof(Versal),
+    .instance_init = versal_init,
+    .class_init = versal_class_init,
+};
+
+static void versal_register_types(void)
+{
+    type_register_static(&versal_info);
+}
+
+type_init(versal_register_types);
diff --git a/default-configs/aarch64-softmmu.mak b/default-configs/aarch64-softmmu.mak
index XXXXXXX..XXXXXXX 100644
--- a/default-configs/aarch64-softmmu.mak
+++ b/default-configs/aarch64-softmmu.mak
@@ -XXX,XX +XXX,XX @@ CONFIG_DDC=y
 CONFIG_DPCD=y
 CONFIG_XLNX_ZYNQMP=y
 CONFIG_XLNX_ZYNQMP_ARM=y
+CONFIG_XLNX_VERSAL=y
 CONFIG_ARM_SMMUV3=y
-- 
2.19.1

From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com>

Add a virtual Xilinx Versal board.

This board is based on the Xilinx Versal SoC. The exact
details of what peripherals are attached to this board
will remain in control of QEMU. QEMU will generate an
FDT on the fly for Linux and other software to auto-discover
peripherals.

Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com>
Message-id: 20181102131913.1535-3-edgar.iglesias@xilinx.com
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
 hw/arm/Makefile.objs      |   2 +-
 hw/arm/xlnx-versal-virt.c | 494 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 495 insertions(+), 1 deletion(-)
 create mode 100644 hw/arm/xlnx-versal-virt.c

diff --git a/hw/arm/Makefile.objs b/hw/arm/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/Makefile.objs
+++ b/hw/arm/Makefile.objs
@@ -XXX,XX +XXX,XX @@ obj-$(CONFIG_ALLWINNER_A10) += allwinner-a10.o cubieboard.o
 obj-$(CONFIG_RASPI) += bcm2835_peripherals.o bcm2836.o raspi.o
 obj-$(CONFIG_STM32F205_SOC) += stm32f205_soc.o
 obj-$(CONFIG_XLNX_ZYNQMP_ARM) += xlnx-zynqmp.o xlnx-zcu102.o
-obj-$(CONFIG_XLNX_VERSAL) += xlnx-versal.o
+obj-$(CONFIG_XLNX_VERSAL) += xlnx-versal.o xlnx-versal-virt.o
 obj-$(CONFIG_FSL_IMX25) += fsl-imx25.o imx25_pdk.o
 obj-$(CONFIG_FSL_IMX31) += fsl-imx31.o kzm.o
 obj-$(CONFIG_FSL_IMX6) += fsl-imx6.o sabrelite.o
diff --git a/hw/arm/xlnx-versal-virt.c b/hw/arm/xlnx-versal-virt.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/hw/arm/xlnx-versal-virt.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Xilinx Versal Virtual board.
+ *
+ * Copyright (c) 2018 Xilinx Inc.
+ * Written by Edgar E. Iglesias
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 or
+ * (at your option) any later version.
+ */
+
+#include "qemu/osdep.h"
+#include "qemu/log.h"
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+#include "sysemu/device_tree.h"
+#include "exec/address-spaces.h"
+#include "hw/boards.h"
+#include "hw/sysbus.h"
+#include "hw/arm/sysbus-fdt.h"
+#include "hw/arm/fdt.h"
+#include "cpu.h"
+#include "hw/arm/xlnx-versal.h"
+
+#define TYPE_XLNX_VERSAL_VIRT_MACHINE MACHINE_TYPE_NAME("xlnx-versal-virt")
+#define XLNX_VERSAL_VIRT_MACHINE(obj) \
+    OBJECT_CHECK(VersalVirt, (obj), TYPE_XLNX_VERSAL_VIRT_MACHINE)
+
+typedef struct VersalVirt {
+    MachineState parent_obj;
+
+    Versal soc;
+    MemoryRegion mr_ddr;
+
+    void *fdt;
+    int fdt_size;
+    struct {
+        uint32_t gic;
+        uint32_t ethernet_phy[2];
+        uint32_t clk_125Mhz;
+        uint32_t clk_25Mhz;
+    } phandle;
+    struct arm_boot_info binfo;
+
+    struct {
+        bool secure;
+    } cfg;
+} VersalVirt;
+
+static void fdt_create(VersalVirt *s)
+{
+    MachineClass *mc = MACHINE_GET_CLASS(s);
+    int i;
+
+    s->fdt = create_device_tree(&s->fdt_size);
+    if (!s->fdt) {
+        error_report("create_device_tree() failed");
+        exit(1);
+    }
+
+    /* Allocate all phandles.  */
+    s->phandle.gic = qemu_fdt_alloc_phandle(s->fdt);
+    for (i = 0; i < ARRAY_SIZE(s->phandle.ethernet_phy); i++) {
+        s->phandle.ethernet_phy[i] = qemu_fdt_alloc_phandle(s->fdt);
+    }
+    s->phandle.clk_25Mhz = qemu_fdt_alloc_phandle(s->fdt);
+    s->phandle.clk_125Mhz = qemu_fdt_alloc_phandle(s->fdt);
+
+    /* Create /chosen node for load_dtb.  */
+    qemu_fdt_add_subnode(s->fdt, "/chosen");
+
+    /* Header */
+    qemu_fdt_setprop_cell(s->fdt, "/", "interrupt-parent", s->phandle.gic);
+    qemu_fdt_setprop_cell(s->fdt, "/", "#size-cells", 0x2);
+    qemu_fdt_setprop_cell(s->fdt, "/", "#address-cells", 0x2);
+    qemu_fdt_setprop_string(s->fdt, "/", "model", mc->desc);
+    qemu_fdt_setprop_string(s->fdt, "/", "compatible", "xlnx-versal-virt");
+}
+
+static void fdt_add_clk_node(VersalVirt *s, const char *name,
+                             unsigned int freq_hz, uint32_t phandle)
+{
+    qemu_fdt_add_subnode(s->fdt, name);
+    qemu_fdt_setprop_cell(s->fdt, name, "phandle", phandle);
+    qemu_fdt_setprop_cell(s->fdt, name, "clock-frequency", freq_hz);
+    qemu_fdt_setprop_cell(s->fdt, name, "#clock-cells", 0x0);
+    qemu_fdt_setprop_string(s->fdt, name, "compatible", "fixed-clock");
+    qemu_fdt_setprop(s->fdt, name, "u-boot,dm-pre-reloc", NULL, 0);
+}
+
+static void fdt_add_cpu_nodes(VersalVirt *s, uint32_t psci_conduit)
+{
+    int i;
+
+    qemu_fdt_add_subnode(s->fdt, "/cpus");
+    qemu_fdt_setprop_cell(s->fdt, "/cpus", "#size-cells", 0x0);
+    qemu_fdt_setprop_cell(s->fdt, "/cpus", "#address-cells", 1);
+
+    for (i = XLNX_VERSAL_NR_ACPUS - 1; i >= 0; i--) {
+        char *name = g_strdup_printf("/cpus/cpu@%d", i);
+        ARMCPU *armcpu = ARM_CPU(qemu_get_cpu(i));
+
+        qemu_fdt_add_subnode(s->fdt, name);
+        qemu_fdt_setprop_cell(s->fdt, name, "reg", armcpu->mp_affinity);
+        if (psci_conduit != QEMU_PSCI_CONDUIT_DISABLED) {
+            qemu_fdt_setprop_string(s->fdt, name, "enable-method", "psci");
+        }
+        qemu_fdt_setprop_string(s->fdt, name, "device_type", "cpu");
+        qemu_fdt_setprop_string(s->fdt, name, "compatible",
+                                armcpu->dtb_compatible);
+        g_free(name);
+    }
+}
+
+static void fdt_add_gic_nodes(VersalVirt *s)
+{
+    char *nodename;
+
+    nodename = g_strdup_printf("/gic@%x", MM_GIC_APU_DIST_MAIN);
+    qemu_fdt_add_subnode(s->fdt, nodename);
+    qemu_fdt_setprop_cell(s->fdt, nodename, "phandle", s->phandle.gic);
+    qemu_fdt_setprop_cells(s->fdt, nodename, "interrupts",
+                           GIC_FDT_IRQ_TYPE_PPI, VERSAL_GIC_MAINT_IRQ,
+                           GIC_FDT_IRQ_FLAGS_LEVEL_HI);
+    qemu_fdt_setprop(s->fdt, nodename, "interrupt-controller", NULL, 0);
+    qemu_fdt_setprop_sized_cells(s->fdt, nodename, "reg",
+                                 2, MM_GIC_APU_DIST_MAIN,
+                                 2, MM_GIC_APU_DIST_MAIN_SIZE,
+                                 2, MM_GIC_APU_REDIST_0,
+                                 2, MM_GIC_APU_REDIST_0_SIZE);
+    qemu_fdt_setprop_cell(s->fdt, nodename, "#interrupt-cells", 3);
+    qemu_fdt_setprop_string(s->fdt, nodename, "compatible", "arm,gic-v3");
+}
+
+static void fdt_add_timer_nodes(VersalVirt *s)
+{
+    const char compat[] = "arm,armv8-timer";
+    uint32_t irqflags = GIC_FDT_IRQ_FLAGS_LEVEL_HI;
+
+    qemu_fdt_add_subnode(s->fdt, "/timer");
+    qemu_fdt_setprop_cells(s->fdt, "/timer", "interrupts",
+            GIC_FDT_IRQ_TYPE_PPI, VERSAL_TIMER_S_EL1_IRQ, irqflags,
+            GIC_FDT_IRQ_TYPE_PPI, VERSAL_TIMER_NS_EL1_IRQ, irqflags,
+            GIC_FDT_IRQ_TYPE_PPI, VERSAL_TIMER_VIRT_IRQ, irqflags,
+            GIC_FDT_IRQ_TYPE_PPI, VERSAL_TIMER_NS_EL2_IRQ, irqflags);
+    qemu_fdt_setprop(s->fdt, "/timer", "compatible",
+                     compat, sizeof(compat));
+}
+
+static void fdt_add_uart_nodes(VersalVirt *s)
+{
+    uint64_t addrs[] = { MM_UART1, MM_UART0 };
+    unsigned int irqs[] = { VERSAL_UART1_IRQ_0, VERSAL_UART0_IRQ_0 };
+    const char compat[] = "arm,pl011\0arm,sbsa-uart";
+    const char clocknames[] = "uartclk\0apb_pclk";
+    int i;
+
+    for (i = 0; i < ARRAY_SIZE(addrs); i++) {
+        char *name = g_strdup_printf("/uart@%" PRIx64, addrs[i]);
+        qemu_fdt_add_subnode(s->fdt, name);
+        qemu_fdt_setprop_cell(s->fdt, name, "current-speed", 115200);
+        qemu_fdt_setprop_cells(s->fdt, name, "clocks",
+                               s->phandle.clk_125Mhz, s->phandle.clk_125Mhz);
+        qemu_fdt_setprop(s->fdt, name, "clock-names",
+                         clocknames, sizeof(clocknames));
+
+        qemu_fdt_setprop_cells(s->fdt, name, "interrupts",
+                               GIC_FDT_IRQ_TYPE_SPI, irqs[i],
+                               GIC_FDT_IRQ_FLAGS_LEVEL_HI);
+        qemu_fdt_setprop_sized_cells(s->fdt, name, "reg",
+                                     2, addrs[i], 2, 0x1000);
+        qemu_fdt_setprop(s->fdt, name, "compatible",
+                         compat, sizeof(compat));
+        qemu_fdt_setprop(s->fdt, name, "u-boot,dm-pre-reloc", NULL, 0);
+
+        if (addrs[i] == MM_UART0) {
+            /* Select UART0.  */
+            qemu_fdt_setprop_string(s->fdt, "/chosen", "stdout-path", name);
+        }
+        g_free(name);
+    }
+}
+
+static void fdt_add_fixed_link_nodes(VersalVirt *s, char *gemname,
+                                     uint32_t phandle)
+{
+    char *name = g_strdup_printf("%s/fixed-link", gemname);
+
+    qemu_fdt_add_subnode(s->fdt, name);
+    qemu_fdt_setprop_cell(s->fdt, name, "phandle", phandle);
+    qemu_fdt_setprop(s->fdt, name, "full-duplex", NULL, 0);
+    qemu_fdt_setprop_cell(s->fdt, name, "speed", 1000);
+    g_free(name);
+}
+
+static void fdt_add_gem_nodes(VersalVirt *s)
+{
+    uint64_t addrs[] = { MM_GEM1, MM_GEM0 };
+    unsigned int irqs[] = { VERSAL_GEM1_IRQ_0, VERSAL_GEM0_IRQ_0 };
+    const char clocknames[] = "pclk\0hclk\0tx_clk\0rx_clk";
+    const char compat_gem[] = "cdns,zynqmp-gem\0cdns,gem";
+    int i;
+
+    for (i = 0; i < ARRAY_SIZE(addrs); i++) {
+        char *name = g_strdup_printf("/ethernet@%" PRIx64, addrs[i]);
+        qemu_fdt_add_subnode(s->fdt, name);
+
+        fdt_add_fixed_link_nodes(s, name, s->phandle.ethernet_phy[i]);
+        qemu_fdt_setprop_string(s->fdt, name, "phy-mode", "rgmii-id");
+        qemu_fdt_setprop_cell(s->fdt, name, "phy-handle",
+                              s->phandle.ethernet_phy[i]);
+        qemu_fdt_setprop_cells(s->fdt, name, "clocks",
+                               s->phandle.clk_25Mhz, s->phandle.clk_25Mhz,
+                               s->phandle.clk_25Mhz, s->phandle.clk_25Mhz);
+        qemu_fdt_setprop(s->fdt, name, "clock-names",
+                         clocknames, sizeof(clocknames));
+        qemu_fdt_setprop_cells(s->fdt, name, "interrupts",
+                               GIC_FDT_IRQ_TYPE_SPI, irqs[i],
+                               GIC_FDT_IRQ_FLAGS_LEVEL_HI,
+                               GIC_FDT_IRQ_TYPE_SPI, irqs[i],
+                               GIC_FDT_IRQ_FLAGS_LEVEL_HI);
+        qemu_fdt_setprop_sized_cells(s->fdt, name, "reg",
+                                     2, addrs[i], 2, 0x1000);
+        qemu_fdt_setprop(s->fdt, name, "compatible",
+                         compat_gem, sizeof(compat_gem));
+        qemu_fdt_setprop_cell(s->fdt, name, "#address-cells", 1);
+        qemu_fdt_setprop_cell(s->fdt, name, "#size-cells", 0);
+        g_free(name);
+    }
+}
+
+static void fdt_nop_memory_nodes(void *fdt, Error **errp)
+{
+    Error *err = NULL;
+    char **node_path;
+    int n = 0;
+
+    node_path = qemu_fdt_node_unit_path(fdt, "memory", &err);
+    if (err) {
+        error_propagate(errp, err);
+        return;
+    }
+    while (node_path[n]) {
+        if (g_str_has_prefix(node_path[n], "/memory")) {
+            qemu_fdt_nop_node(fdt, node_path[n]);
+        }
+        n++;
+    }
+    g_strfreev(node_path);
+}
+
+static void fdt_add_memory_nodes(VersalVirt *s, void *fdt, uint64_t ram_size)
+{
+    /* Describes the various split DDR access regions.  */
+    static const struct {
+        uint64_t base;
+        uint64_t size;
+    } addr_ranges[] = {
+        { MM_TOP_DDR, MM_TOP_DDR_SIZE },
+        { MM_TOP_DDR_2, MM_TOP_DDR_2_SIZE },
+        { MM_TOP_DDR_3, MM_TOP_DDR_3_SIZE },
+        { MM_TOP_DDR_4, MM_TOP_DDR_4_SIZE }
+    };
+    uint64_t mem_reg_prop[8] = {0};
+    uint64_t size = ram_size;
+    Error *err = NULL;
+    char *name;
+    int i;
+
+    fdt_nop_memory_nodes(fdt, &err);
+    if (err) {
+        error_report_err(err);
+        return;
+    }
+
+    name = g_strdup_printf("/memory@%x", MM_TOP_DDR);
+    for (i = 0; i < ARRAY_SIZE(addr_ranges) && size; i++) {
+        uint64_t mapsize;
+
+        mapsize = size < addr_ranges[i].size ? size : addr_ranges[i].size;
+
+        mem_reg_prop[i * 2] = addr_ranges[i].base;
+        mem_reg_prop[i * 2 + 1] = mapsize;
+        size -= mapsize;
+    }
+    qemu_fdt_add_subnode(fdt, name);
+    qemu_fdt_setprop_string(fdt, name, "device_type", "memory");
+
+    switch (i) {
+    case 1:
+        qemu_fdt_setprop_sized_cells(fdt, name, "reg",
+                                     2, mem_reg_prop[0],
+                                     2, mem_reg_prop[1]);
+        break;
+    case 2:
+        qemu_fdt_setprop_sized_cells(fdt, name, "reg",
+                                     2, mem_reg_prop[0],
+                                     2, mem_reg_prop[1],
+                                     2, mem_reg_prop[2],
+                                     2, mem_reg_prop[3]);
+        break;
+    case 3:
+        qemu_fdt_setprop_sized_cells(fdt, name, "reg",
+                                     2, mem_reg_prop[0],
+                                     2, mem_reg_prop[1],
+                                     2, mem_reg_prop[2],
+                                     2, mem_reg_prop[3],
+                                     2, mem_reg_prop[4],
+                                     2, mem_reg_prop[5]);
+        break;
+    case 4:
+        qemu_fdt_setprop_sized_cells(fdt, name, "reg",
+                                     2, mem_reg_prop[0],
+                                     2, mem_reg_prop[1],
+                                     2, mem_reg_prop[2],
+                                     2, mem_reg_prop[3],
+                                     2, mem_reg_prop[4],
+                                     2, mem_reg_prop[5],
+                                     2, mem_reg_prop[6],
+                                     2, mem_reg_prop[7]);
+        break;
+    default:
+        g_assert_not_reached();
+    }
+    g_free(name);
+}
+
+static void versal_virt_modify_dtb(const struct arm_boot_info *binfo,
+                                    void *fdt)
+{
+    VersalVirt *s = container_of(binfo, VersalVirt, binfo);
+
+    fdt_add_memory_nodes(s, fdt, binfo->ram_size);
+}
+
+static void *versal_virt_get_dtb(const struct arm_boot_info *binfo,
+                                  int *fdt_size)
+{
+    const VersalVirt *board = container_of(binfo, VersalVirt, binfo);
+
+    *fdt_size = board->fdt_size;
+    return board->fdt;
+}
+
+#define NUM_VIRTIO_TRANSPORT 32
+static void create_virtio_regions(VersalVirt *s)
+{
+    int virtio_mmio_size = 0x200;
+    int i;
+
+    for (i = 0; i < NUM_VIRTIO_TRANSPORT; i++) {
+        char *name = g_strdup_printf("virtio%d", i);;
+        hwaddr base = MM_TOP_RSVD + i * virtio_mmio_size;
+        int irq = VERSAL_RSVD_HIGH_IRQ_FIRST + i;
+        MemoryRegion *mr;
+        DeviceState *dev;
+        qemu_irq pic_irq;
+
+        pic_irq = qdev_get_gpio_in(DEVICE(&s->soc.fpd.apu.gic), irq);
+        dev = qdev_create(NULL, "virtio-mmio");
+        object_property_add_child(OBJECT(&s->soc), name, OBJECT(dev),
+                                  &error_fatal);
+        qdev_init_nofail(dev);
+        sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic_irq);
+        mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0);
+        memory_region_add_subregion(&s->soc.mr_ps, base, mr);
+        sysbus_create_simple("virtio-mmio", base, pic_irq);
+    }
+
+    for (i = 0; i < NUM_VIRTIO_TRANSPORT; i++) {
+        hwaddr base = MM_TOP_RSVD + i * virtio_mmio_size;
+        int irq = VERSAL_RSVD_HIGH_IRQ_FIRST + i;
+        char *name = g_strdup_printf("/virtio_mmio@%" PRIx64, base);
+
+        qemu_fdt_add_subnode(s->fdt, name);
+        qemu_fdt_setprop(s->fdt, name, "dma-coherent", NULL, 0);
+        qemu_fdt_setprop_cells(s->fdt, name, "interrupts",
+                               GIC_FDT_IRQ_TYPE_SPI, irq,
+                               GIC_FDT_IRQ_FLAGS_EDGE_LO_HI);
+        qemu_fdt_setprop_sized_cells(s->fdt, name, "reg",
+                                     2, base, 2, virtio_mmio_size);
+        qemu_fdt_setprop_string(s->fdt, name, "compatible", "virtio,mmio");
+        g_free(name);
+    }
+}
+
+static void versal_virt_init(MachineState *machine)
+{
+    VersalVirt *s = XLNX_VERSAL_VIRT_MACHINE(machine);
+    int psci_conduit = QEMU_PSCI_CONDUIT_DISABLED;
+
+    /*
+     * If the user provides an Operating System to be loaded, we expect them
+     * to use the -kernel command line option.
+     *
+     * Users can load firmware or boot-loaders with the -device loader options.
+     *
+     * When loading an OS, we generate a dtb and let arm_load_kernel() select
+     * where it gets loaded. This dtb will be passed to the kernel in x0.
+     *
+     * If there's no -kernel option, we generate a DTB and place it at 0x1000
+     * for the bootloaders or firmware to pick up.
+     *
+     * If users want to provide their own DTB, they can use the -dtb option.
+     * These dtb's will have their memory nodes modified to match QEMU's
+     * selected ram_size option before they get passed to the kernel or fw.
+     *
+     * When loading an OS, we turn on QEMU's PSCI implementation with SMC
+     * as the PSCI conduit. When there's no -kernel, we assume the user
+     * provides EL3 firmware to handle PSCI.
+     */
+    if (machine->kernel_filename) {
+        psci_conduit = QEMU_PSCI_CONDUIT_SMC;
+    }
+
+    memory_region_allocate_system_memory(&s->mr_ddr, NULL, "ddr",
+                                         machine->ram_size);
+
+    sysbus_init_child_obj(OBJECT(machine), "xlnx-ve", &s->soc,
+                          sizeof(s->soc), TYPE_XLNX_VERSAL);
+    object_property_set_link(OBJECT(&s->soc), OBJECT(&s->mr_ddr),
+                             "ddr", &error_abort);
+    object_property_set_int(OBJECT(&s->soc), psci_conduit,
+                            "psci-conduit", &error_abort);
+    object_property_set_bool(OBJECT(&s->soc), true, "realized", &error_fatal);
+
+    fdt_create(s);
+    create_virtio_regions(s);
+    fdt_add_gem_nodes(s);
+    fdt_add_uart_nodes(s);
+    fdt_add_gic_nodes(s);
+    fdt_add_timer_nodes(s);
+    fdt_add_cpu_nodes(s, psci_conduit);
+    fdt_add_clk_node(s, "/clk125", 125000000, s->phandle.clk_125Mhz);
+    fdt_add_clk_node(s, "/clk25", 25000000, s->phandle.clk_25Mhz);
+
+    /* Make the APU cpu address space visible to virtio and other
+     * modules unaware of muliple address-spaces.  */
+    memory_region_add_subregion_overlap(get_system_memory(),
+                                        0, &s->soc.fpd.apu.mr, 0);
+
+    s->binfo.ram_size = machine->ram_size;
+    s->binfo.kernel_filename = machine->kernel_filename;
+    s->binfo.kernel_cmdline = machine->kernel_cmdline;
+    s->binfo.initrd_filename = machine->initrd_filename;
+    s->binfo.loader_start = 0x0;
+    s->binfo.get_dtb = versal_virt_get_dtb;
+    s->binfo.modify_dtb = versal_virt_modify_dtb;
+    if (machine->kernel_filename) {
+        arm_load_kernel(s->soc.fpd.apu.cpu[0], &s->binfo);
+    } else {
+        AddressSpace *as = arm_boot_address_space(s->soc.fpd.apu.cpu[0],
+                                                  &s->binfo);
+        /* Some boot-loaders (e.g u-boot) don't like blobs at address 0 (NULL).
+         * Offset things by 4K.  */
+        s->binfo.loader_start = 0x1000;
+        s->binfo.dtb_limit = 0x1000000;
+        if (arm_load_dtb(s->binfo.loader_start,
+                         &s->binfo, s->binfo.dtb_limit, as) < 0) {
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+static void versal_virt_machine_instance_init(Object *obj)
+{
+}
+
+static void versal_virt_machine_class_init(ObjectClass *oc, void *data)
+{
+    MachineClass *mc = MACHINE_CLASS(oc);
+
+    mc->desc = "Xilinx Versal Virtual development board";
+    mc->init = versal_virt_init;
+    mc->max_cpus = XLNX_VERSAL_NR_ACPUS;
+    mc->default_cpus = XLNX_VERSAL_NR_ACPUS;
+    mc->no_cdrom = true;
+}
+
+static const TypeInfo versal_virt_machine_init_typeinfo = {
+    .name       = TYPE_XLNX_VERSAL_VIRT_MACHINE,
+    .parent     = TYPE_MACHINE,
+    .class_init = versal_virt_machine_class_init,
+    .instance_init = versal_virt_machine_instance_init,
+    .instance_size = sizeof(VersalVirt),
+};
+
+static void versal_virt_machine_init_register_types(void)
+{
+    type_register_static(&versal_virt_machine_init_typeinfo);
+}
+
+type_init(versal_virt_machine_init_register_types)
+
-- 
2.19.1