1 | Most of this is the Neon decodetree patches, followed by Edgar's versal cleanups. | 1 | Nothing too exciting in this lot :-) |
---|---|---|---|
2 | 2 | ||
3 | thanks | 3 | The following changes since commit ba0fa56bc06e563de68d2a2bf3ddb0cfea1be4f9: |
4 | -- PMM | ||
5 | 4 | ||
6 | 5 | Merge remote-tracking branch 'remotes/vivier/tags/q800-for-6.2-pull-request' into staging (2021-09-29 21:20:49 +0100) | |
7 | The following changes since commit 2ef486e76d64436be90f7359a3071fb2a56ce835: | ||
8 | |||
9 | Merge remote-tracking branch 'remotes/marcel/tags/rdma-pull-request' into staging (2020-05-03 14:12:56 +0100) | ||
10 | 6 | ||
11 | are available in the Git repository at: | 7 | are available in the Git repository at: |
12 | 8 | ||
13 | https://git.linaro.org/people/pmaydell/qemu-arm.git tags/pull-target-arm-20200504 | 9 | https://git.linaro.org/people/pmaydell/qemu-arm.git tags/pull-target-arm-20210930 |
14 | 10 | ||
15 | for you to fetch changes up to 9aefc6cf9b73f66062d2f914a0136756e7a28211: | 11 | for you to fetch changes up to 1f4b2ec701b9d73d3fa7bb90c8b4376bc7d3c42b: |
16 | 12 | ||
17 | target/arm: Move gen_ function typedefs to translate.h (2020-05-04 12:59:26 +0100) | 13 | hw/arm: sabrelite: Connect SPI flash CS line to GPIO3_19 (2021-09-30 13:44:13 +0100) |
18 | 14 | ||
19 | ---------------------------------------------------------------- | 15 | ---------------------------------------------------------------- |
20 | target-arm queue: | 16 | target-arm queue: |
21 | * Start of conversion of Neon insns to decodetree | 17 | * allwinner-h3: Switch to SMC as PSCI conduit |
22 | * versal board: support SD and RTC | 18 | * arm: tcg: Adhere to SMCCC 1.3 section 5.2 |
23 | * Implement ARMv8.2-TTS2UXN | 19 | * xlnx-zcu102, xlnx-versal-virt: Support BBRAM and eFUSE devices |
24 | * Make VQDMULL undefined when U=1 | 20 | * gdbstub related code cleanups |
25 | * Some minor code cleanups | 21 | * Don't put FPEXC and FPSID in org.gnu.gdb.arm.vfp XML |
22 | * Use _init vs _new convention in bus creation function names | ||
23 | * sabrelite: Connect SPI flash CS line to GPIO3_19 | ||
26 | 24 | ||
27 | ---------------------------------------------------------------- | 25 | ---------------------------------------------------------------- |
28 | Edgar E. Iglesias (11): | 26 | Alexander Graf (2): |
29 | hw/arm: versal: Remove inclusion of arm_gicv3_common.h | 27 | allwinner-h3: Switch to SMC as PSCI conduit |
30 | hw/arm: versal: Move misplaced comment | 28 | arm: tcg: Adhere to SMCCC 1.3 section 5.2 |
31 | hw/arm: versal-virt: Fix typo xlnx-ve -> xlnx-versal | ||
32 | hw/arm: versal: Embed the UARTs into the SoC type | ||
33 | hw/arm: versal: Embed the GEMs into the SoC type | ||
34 | hw/arm: versal: Embed the ADMAs into the SoC type | ||
35 | hw/arm: versal: Embed the APUs into the SoC type | ||
36 | hw/arm: versal: Add support for SD | ||
37 | hw/arm: versal: Add support for the RTC | ||
38 | hw/arm: versal-virt: Add support for SD | ||
39 | hw/arm: versal-virt: Add support for the RTC | ||
40 | 29 | ||
41 | Fredrik Strupe (1): | 30 | Peter Maydell (10): |
42 | target/arm: Make VQDMULL undefined when U=1 | 31 | configs: Don't include 32-bit-only GDB XML in aarch64 linux configs |
32 | target/arm: Fix coding style issues in gdbstub code in helper.c | ||
33 | target/arm: Move gdbstub related code out of helper.c | ||
34 | target/arm: Don't put FPEXC and FPSID in org.gnu.gdb.arm.vfp XML | ||
35 | scsi: Replace scsi_bus_new() with scsi_bus_init(), scsi_bus_init_named() | ||
36 | ipack: Rename ipack_bus_new_inplace() to ipack_bus_init() | ||
37 | pci: Rename pci_root_bus_new_inplace() to pci_root_bus_init() | ||
38 | qbus: Rename qbus_create_inplace() to qbus_init() | ||
39 | qbus: Rename qbus_create() to qbus_new() | ||
40 | ide: Rename ide_bus_new() to ide_bus_init() | ||
43 | 41 | ||
44 | Peter Maydell (25): | 42 | Tong Ho (9): |
45 | target/arm: Don't use a TLB for ARMMMUIdx_Stage2 | 43 | hw/nvram: Introduce Xilinx eFuse QOM |
46 | target/arm: Use enum constant in get_phys_addr_lpae() call | 44 | hw/nvram: Introduce Xilinx Versal eFuse device |
47 | target/arm: Add new 's1_is_el0' argument to get_phys_addr_lpae() | 45 | hw/nvram: Introduce Xilinx ZynqMP eFuse device |
48 | target/arm: Implement ARMv8.2-TTS2UXN | 46 | hw/nvram: Introduce Xilinx battery-backed ram |
49 | target/arm: Use correct variable for setting 'max' cpu's ID_AA64DFR0 | 47 | hw/arm: xlnx-versal-virt: Add Xilinx BBRAM device |
50 | target/arm/translate-vfp.inc.c: Remove duplicate simd_r32 check | 48 | hw/arm: xlnx-versal-virt: Add Xilinx eFUSE device |
51 | target/arm: Don't allow Thumb Neon insns without FEATURE_NEON | 49 | hw/arm: xlnx-zcu102: Add Xilinx BBRAM device |
52 | target/arm: Add stubs for AArch32 Neon decodetree | 50 | hw/arm: xlnx-zcu102: Add Xilinx eFUSE device |
53 | target/arm: Convert VCMLA (vector) to decodetree | 51 | docs/system/arm: xlnx-versal-virt: BBRAM and eFUSE Usage |
54 | target/arm: Convert VCADD (vector) to decodetree | ||
55 | target/arm: Convert V[US]DOT (vector) to decodetree | ||
56 | target/arm: Convert VFM[AS]L (vector) to decodetree | ||
57 | target/arm: Convert VCMLA (scalar) to decodetree | ||
58 | target/arm: Convert V[US]DOT (scalar) to decodetree | ||
59 | target/arm: Convert VFM[AS]L (scalar) to decodetree | ||
60 | target/arm: Convert Neon load/store multiple structures to decodetree | ||
61 | target/arm: Convert Neon 'load single structure to all lanes' to decodetree | ||
62 | target/arm: Convert Neon 'load/store single structure' to decodetree | ||
63 | target/arm: Convert Neon 3-reg-same VADD/VSUB to decodetree | ||
64 | target/arm: Convert Neon 3-reg-same logic ops to decodetree | ||
65 | target/arm: Convert Neon 3-reg-same VMAX/VMIN to decodetree | ||
66 | target/arm: Convert Neon 3-reg-same comparisons to decodetree | ||
67 | target/arm: Convert Neon 3-reg-same VQADD/VQSUB to decodetree | ||
68 | target/arm: Convert Neon 3-reg-same VMUL, VMLA, VMLS, VSHL to decodetree | ||
69 | target/arm: Move gen_ function typedefs to translate.h | ||
70 | 52 | ||
71 | Philippe Mathieu-Daudé (2): | 53 | Xuzhou Cheng (1): |
72 | hw/arm/mps2-tz: Use TYPE_IOTKIT instead of hardcoded string | 54 | hw/arm: sabrelite: Connect SPI flash CS line to GPIO3_19 |
73 | target/arm: Use uint64_t for midr field in CPU state struct | ||
74 | 55 | ||
75 | include/hw/arm/xlnx-versal.h | 31 +- | 56 | docs/system/arm/xlnx-versal-virt.rst | 49 ++ |
76 | target/arm/cpu-param.h | 2 +- | 57 | configs/targets/aarch64-linux-user.mak | 2 +- |
77 | target/arm/cpu.h | 38 ++- | 58 | configs/targets/aarch64-softmmu.mak | 2 +- |
78 | target/arm/translate-a64.h | 9 - | 59 | configs/targets/aarch64_be-linux-user.mak | 2 +- |
79 | target/arm/translate.h | 26 ++ | 60 | configs/targets/arm-linux-user.mak | 2 +- |
80 | target/arm/neon-dp.decode | 86 +++++ | 61 | configs/targets/arm-softmmu.mak | 2 +- |
81 | target/arm/neon-ls.decode | 52 +++ | 62 | configs/targets/armeb-linux-user.mak | 2 +- |
82 | target/arm/neon-shared.decode | 66 ++++ | 63 | include/hw/arm/xlnx-versal.h | 15 + |
83 | hw/arm/mps2-tz.c | 2 +- | 64 | include/hw/arm/xlnx-zynqmp.h | 5 + |
84 | hw/arm/xlnx-versal-virt.c | 74 ++++- | 65 | include/hw/ide/internal.h | 4 +- |
85 | hw/arm/xlnx-versal.c | 115 +++++-- | 66 | include/hw/ipack/ipack.h | 8 +- |
86 | target/arm/cpu.c | 3 +- | 67 | include/hw/nvram/xlnx-bbram.h | 54 ++ |
87 | target/arm/cpu64.c | 8 +- | 68 | include/hw/nvram/xlnx-efuse.h | 132 +++++ |
88 | target/arm/helper.c | 183 ++++------ | 69 | include/hw/nvram/xlnx-versal-efuse.h | 68 +++ |
89 | target/arm/translate-a64.c | 17 - | 70 | include/hw/nvram/xlnx-zynqmp-efuse.h | 44 ++ |
90 | target/arm/translate-neon.inc.c | 714 +++++++++++++++++++++++++++++++++++++++ | 71 | include/hw/pci/pci.h | 10 +- |
91 | target/arm/translate-vfp.inc.c | 6 - | 72 | include/hw/qdev-core.h | 6 +- |
92 | target/arm/translate.c | 716 +++------------------------------------- | 73 | include/hw/scsi/scsi.h | 30 +- |
93 | target/arm/Makefile.objs | 18 + | 74 | target/arm/internals.h | 7 + |
94 | 19 files changed, 1302 insertions(+), 864 deletions(-) | 75 | hw/arm/allwinner-h3.c | 2 +- |
95 | create mode 100644 target/arm/neon-dp.decode | 76 | hw/arm/sabrelite.c | 2 +- |
96 | create mode 100644 target/arm/neon-ls.decode | 77 | hw/arm/xlnx-versal-virt.c | 88 +++ |
97 | create mode 100644 target/arm/neon-shared.decode | 78 | hw/arm/xlnx-versal.c | 57 ++ |
98 | create mode 100644 target/arm/translate-neon.inc.c | 79 | hw/arm/xlnx-zcu102.c | 30 ++ |
80 | hw/arm/xlnx-zynqmp.c | 49 ++ | ||
81 | hw/audio/intel-hda.c | 2 +- | ||
82 | hw/block/fdc.c | 2 +- | ||
83 | hw/block/swim.c | 3 +- | ||
84 | hw/char/virtio-serial-bus.c | 4 +- | ||
85 | hw/core/bus.c | 13 +- | ||
86 | hw/core/sysbus.c | 10 +- | ||
87 | hw/gpio/bcm2835_gpio.c | 3 +- | ||
88 | hw/hyperv/vmbus.c | 2 +- | ||
89 | hw/i2c/core.c | 2 +- | ||
90 | hw/ide/ahci.c | 2 +- | ||
91 | hw/ide/cmd646.c | 2 +- | ||
92 | hw/ide/isa.c | 2 +- | ||
93 | hw/ide/macio.c | 2 +- | ||
94 | hw/ide/microdrive.c | 2 +- | ||
95 | hw/ide/mmio.c | 2 +- | ||
96 | hw/ide/piix.c | 2 +- | ||
97 | hw/ide/qdev.c | 4 +- | ||
98 | hw/ide/sii3112.c | 2 +- | ||
99 | hw/ide/via.c | 2 +- | ||
100 | hw/ipack/ipack.c | 10 +- | ||
101 | hw/ipack/tpci200.c | 4 +- | ||
102 | hw/isa/isa-bus.c | 2 +- | ||
103 | hw/misc/auxbus.c | 2 +- | ||
104 | hw/misc/mac_via.c | 4 +- | ||
105 | hw/misc/macio/cuda.c | 4 +- | ||
106 | hw/misc/macio/macio.c | 4 +- | ||
107 | hw/misc/macio/pmu.c | 4 +- | ||
108 | hw/nubus/nubus-bridge.c | 2 +- | ||
109 | hw/nvme/ctrl.c | 4 +- | ||
110 | hw/nvme/subsys.c | 3 +- | ||
111 | hw/nvram/xlnx-bbram.c | 545 +++++++++++++++++++ | ||
112 | hw/nvram/xlnx-efuse-crc.c | 119 +++++ | ||
113 | hw/nvram/xlnx-efuse.c | 280 ++++++++++ | ||
114 | hw/nvram/xlnx-versal-efuse-cache.c | 114 ++++ | ||
115 | hw/nvram/xlnx-versal-efuse-ctrl.c | 783 +++++++++++++++++++++++++++ | ||
116 | hw/nvram/xlnx-zynqmp-efuse.c | 855 ++++++++++++++++++++++++++++++ | ||
117 | hw/pci-host/raven.c | 4 +- | ||
118 | hw/pci-host/versatile.c | 6 +- | ||
119 | hw/pci/pci.c | 30 +- | ||
120 | hw/pci/pci_bridge.c | 4 +- | ||
121 | hw/ppc/spapr_vio.c | 2 +- | ||
122 | hw/s390x/ap-bridge.c | 2 +- | ||
123 | hw/s390x/css-bridge.c | 2 +- | ||
124 | hw/s390x/event-facility.c | 4 +- | ||
125 | hw/s390x/s390-pci-bus.c | 2 +- | ||
126 | hw/s390x/virtio-ccw.c | 3 +- | ||
127 | hw/scsi/esp-pci.c | 2 +- | ||
128 | hw/scsi/esp.c | 2 +- | ||
129 | hw/scsi/lsi53c895a.c | 2 +- | ||
130 | hw/scsi/megasas.c | 3 +- | ||
131 | hw/scsi/mptsas.c | 2 +- | ||
132 | hw/scsi/scsi-bus.c | 6 +- | ||
133 | hw/scsi/spapr_vscsi.c | 3 +- | ||
134 | hw/scsi/virtio-scsi.c | 4 +- | ||
135 | hw/scsi/vmw_pvscsi.c | 3 +- | ||
136 | hw/sd/allwinner-sdhost.c | 4 +- | ||
137 | hw/sd/bcm2835_sdhost.c | 4 +- | ||
138 | hw/sd/pl181.c | 3 +- | ||
139 | hw/sd/pxa2xx_mmci.c | 4 +- | ||
140 | hw/sd/sdhci.c | 3 +- | ||
141 | hw/sd/ssi-sd.c | 3 +- | ||
142 | hw/ssi/ssi.c | 2 +- | ||
143 | hw/usb/bus.c | 2 +- | ||
144 | hw/usb/dev-smartcard-reader.c | 3 +- | ||
145 | hw/usb/dev-storage-bot.c | 3 +- | ||
146 | hw/usb/dev-storage-classic.c | 4 +- | ||
147 | hw/usb/dev-uas.c | 3 +- | ||
148 | hw/virtio/virtio-mmio.c | 3 +- | ||
149 | hw/virtio/virtio-pci.c | 3 +- | ||
150 | hw/xen/xen-bus.c | 2 +- | ||
151 | hw/xen/xen-legacy-backend.c | 2 +- | ||
152 | target/arm/gdbstub.c | 154 ++++++ | ||
153 | target/arm/gdbstub64.c | 140 +++++ | ||
154 | target/arm/helper.c | 262 --------- | ||
155 | target/arm/psci.c | 35 +- | ||
156 | gdb-xml/arm-neon.xml | 2 - | ||
157 | gdb-xml/arm-vfp-sysregs.xml | 17 + | ||
158 | gdb-xml/arm-vfp.xml | 2 - | ||
159 | gdb-xml/arm-vfp3.xml | 2 - | ||
160 | hw/Kconfig | 2 + | ||
161 | hw/arm/Kconfig | 2 + | ||
162 | hw/nvram/Kconfig | 19 + | ||
163 | hw/nvram/meson.build | 8 + | ||
164 | 108 files changed, 3806 insertions(+), 447 deletions(-) | ||
165 | create mode 100644 include/hw/nvram/xlnx-bbram.h | ||
166 | create mode 100644 include/hw/nvram/xlnx-efuse.h | ||
167 | create mode 100644 include/hw/nvram/xlnx-versal-efuse.h | ||
168 | create mode 100644 include/hw/nvram/xlnx-zynqmp-efuse.h | ||
169 | create mode 100644 hw/nvram/xlnx-bbram.c | ||
170 | create mode 100644 hw/nvram/xlnx-efuse-crc.c | ||
171 | create mode 100644 hw/nvram/xlnx-efuse.c | ||
172 | create mode 100644 hw/nvram/xlnx-versal-efuse-cache.c | ||
173 | create mode 100644 hw/nvram/xlnx-versal-efuse-ctrl.c | ||
174 | create mode 100644 hw/nvram/xlnx-zynqmp-efuse.c | ||
175 | create mode 100644 gdb-xml/arm-vfp-sysregs.xml | ||
99 | 176 | diff view generated by jsdifflib |
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | 1 | From: Alexander Graf <agraf@csgraf.de> |
---|---|---|---|
2 | 2 | ||
3 | Fix typo xlnx-ve -> xlnx-versal. | 3 | The Allwinner H3 SoC uses Cortex-A7 cores which support virtualization. |
4 | However, today we are configuring QEMU to use HVC as PSCI conduit. | ||
4 | 5 | ||
5 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 6 | That means HVC calls get trapped into QEMU instead of the guest's own |
6 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | 7 | emulated CPU and thus break the guest's ability to execute virtualization. |
8 | |||
9 | Fix this by moving to SMC as conduit, freeing up HYP completely to the VM. | ||
10 | |||
11 | Signed-off-by: Alexander Graf <agraf@csgraf.de> | ||
12 | Message-id: 20210920203931.66527-1-agraf@csgraf.de | ||
13 | Fixes: 740dafc0ba0 ("hw/arm: add Allwinner H3 System-on-Chip") | ||
14 | Reviewed-by: Niek Linnenbank <nieklinnenbank@gmail.com> | ||
15 | Tested-by: Niek Linnenbank <nieklinnenbank@gmail.com> | ||
16 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
7 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | 17 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> |
8 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | ||
9 | Message-id: 20200427181649.26851-4-edgar.iglesias@gmail.com | ||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 18 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | --- | 19 | --- |
12 | hw/arm/xlnx-versal-virt.c | 2 +- | 20 | hw/arm/allwinner-h3.c | 2 +- |
13 | 1 file changed, 1 insertion(+), 1 deletion(-) | 21 | 1 file changed, 1 insertion(+), 1 deletion(-) |
14 | 22 | ||
15 | diff --git a/hw/arm/xlnx-versal-virt.c b/hw/arm/xlnx-versal-virt.c | 23 | diff --git a/hw/arm/allwinner-h3.c b/hw/arm/allwinner-h3.c |
16 | index XXXXXXX..XXXXXXX 100644 | 24 | index XXXXXXX..XXXXXXX 100644 |
17 | --- a/hw/arm/xlnx-versal-virt.c | 25 | --- a/hw/arm/allwinner-h3.c |
18 | +++ b/hw/arm/xlnx-versal-virt.c | 26 | +++ b/hw/arm/allwinner-h3.c |
19 | @@ -XXX,XX +XXX,XX @@ static void versal_virt_init(MachineState *machine) | 27 | @@ -XXX,XX +XXX,XX @@ static void allwinner_h3_realize(DeviceState *dev, Error **errp) |
20 | psci_conduit = QEMU_PSCI_CONDUIT_SMC; | 28 | |
21 | } | 29 | /* Provide Power State Coordination Interface */ |
22 | 30 | qdev_prop_set_int32(DEVICE(&s->cpus[i]), "psci-conduit", | |
23 | - sysbus_init_child_obj(OBJECT(machine), "xlnx-ve", &s->soc, | 31 | - QEMU_PSCI_CONDUIT_HVC); |
24 | + sysbus_init_child_obj(OBJECT(machine), "xlnx-versal", &s->soc, | 32 | + QEMU_PSCI_CONDUIT_SMC); |
25 | sizeof(s->soc), TYPE_XLNX_VERSAL); | 33 | |
26 | object_property_set_link(OBJECT(&s->soc), OBJECT(machine->ram), | 34 | /* Disable secondary CPUs */ |
27 | "ddr", &error_abort); | 35 | qdev_prop_set_bit(DEVICE(&s->cpus[i]), "start-powered-off", |
28 | -- | 36 | -- |
29 | 2.20.1 | 37 | 2.20.1 |
30 | 38 | ||
31 | 39 | diff view generated by jsdifflib |
1 | From: Philippe Mathieu-Daudé <f4bug@amsat.org> | 1 | From: Alexander Graf <agraf@csgraf.de> |
---|---|---|---|
2 | 2 | ||
3 | By using the TYPE_* definitions for devices, we can: | 3 | The SMCCC 1.3 spec section 5.2 says |
4 | - quickly find where devices are used with 'git-grep' | ||
5 | - easily rename a device (one-line change). | ||
6 | 4 | ||
7 | Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | 5 | The Unknown SMC Function Identifier is a sign-extended value of (-1) |
8 | Message-id: 20200428154650.21991-1-f4bug@amsat.org | 6 | that is returned in the R0, W0 or X0 registers. An implementation must |
7 | return this error code when it receives: | ||
8 | |||
9 | * An SMC or HVC call with an unknown Function Identifier | ||
10 | * An SMC or HVC call for a removed Function Identifier | ||
11 | * An SMC64/HVC64 call from AArch32 state | ||
12 | |||
13 | To comply with these statements, let's always return -1 when we encounter | ||
14 | an unknown HVC or SMC call. | ||
15 | |||
16 | Signed-off-by: Alexander Graf <agraf@csgraf.de> | ||
9 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 17 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> |
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 18 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | --- | 19 | --- |
12 | hw/arm/mps2-tz.c | 2 +- | 20 | target/arm/psci.c | 35 ++++++----------------------------- |
13 | 1 file changed, 1 insertion(+), 1 deletion(-) | 21 | 1 file changed, 6 insertions(+), 29 deletions(-) |
14 | 22 | ||
15 | diff --git a/hw/arm/mps2-tz.c b/hw/arm/mps2-tz.c | 23 | diff --git a/target/arm/psci.c b/target/arm/psci.c |
16 | index XXXXXXX..XXXXXXX 100644 | 24 | index XXXXXXX..XXXXXXX 100644 |
17 | --- a/hw/arm/mps2-tz.c | 25 | --- a/target/arm/psci.c |
18 | +++ b/hw/arm/mps2-tz.c | 26 | +++ b/target/arm/psci.c |
19 | @@ -XXX,XX +XXX,XX @@ static void mps2tz_common_init(MachineState *machine) | 27 | @@ -XXX,XX +XXX,XX @@ |
20 | exit(EXIT_FAILURE); | 28 | |
29 | bool arm_is_psci_call(ARMCPU *cpu, int excp_type) | ||
30 | { | ||
31 | - /* Return true if the r0/x0 value indicates a PSCI call and | ||
32 | - * the exception type matches the configured PSCI conduit. This is | ||
33 | - * called before the SMC/HVC instruction is executed, to decide whether | ||
34 | - * we should treat it as a PSCI call or with the architecturally | ||
35 | + /* | ||
36 | + * Return true if the exception type matches the configured PSCI conduit. | ||
37 | + * This is called before the SMC/HVC instruction is executed, to decide | ||
38 | + * whether we should treat it as a PSCI call or with the architecturally | ||
39 | * defined behaviour for an SMC or HVC (which might be UNDEF or trap | ||
40 | * to EL2 or to EL3). | ||
41 | */ | ||
42 | - CPUARMState *env = &cpu->env; | ||
43 | - uint64_t param = is_a64(env) ? env->xregs[0] : env->regs[0]; | ||
44 | |||
45 | switch (excp_type) { | ||
46 | case EXCP_HVC: | ||
47 | @@ -XXX,XX +XXX,XX @@ bool arm_is_psci_call(ARMCPU *cpu, int excp_type) | ||
48 | return false; | ||
21 | } | 49 | } |
22 | 50 | ||
23 | - sysbus_init_child_obj(OBJECT(machine), "iotkit", &mms->iotkit, | 51 | - switch (param) { |
24 | + sysbus_init_child_obj(OBJECT(machine), TYPE_IOTKIT, &mms->iotkit, | 52 | - case QEMU_PSCI_0_2_FN_PSCI_VERSION: |
25 | sizeof(mms->iotkit), mmc->armsse_type); | 53 | - case QEMU_PSCI_0_2_FN_MIGRATE_INFO_TYPE: |
26 | iotkitdev = DEVICE(&mms->iotkit); | 54 | - case QEMU_PSCI_0_2_FN_AFFINITY_INFO: |
27 | object_property_set_link(OBJECT(&mms->iotkit), OBJECT(system_memory), | 55 | - case QEMU_PSCI_0_2_FN64_AFFINITY_INFO: |
56 | - case QEMU_PSCI_0_2_FN_SYSTEM_RESET: | ||
57 | - case QEMU_PSCI_0_2_FN_SYSTEM_OFF: | ||
58 | - case QEMU_PSCI_0_1_FN_CPU_ON: | ||
59 | - case QEMU_PSCI_0_2_FN_CPU_ON: | ||
60 | - case QEMU_PSCI_0_2_FN64_CPU_ON: | ||
61 | - case QEMU_PSCI_0_1_FN_CPU_OFF: | ||
62 | - case QEMU_PSCI_0_2_FN_CPU_OFF: | ||
63 | - case QEMU_PSCI_0_1_FN_CPU_SUSPEND: | ||
64 | - case QEMU_PSCI_0_2_FN_CPU_SUSPEND: | ||
65 | - case QEMU_PSCI_0_2_FN64_CPU_SUSPEND: | ||
66 | - case QEMU_PSCI_0_1_FN_MIGRATE: | ||
67 | - case QEMU_PSCI_0_2_FN_MIGRATE: | ||
68 | - return true; | ||
69 | - default: | ||
70 | - return false; | ||
71 | - } | ||
72 | + return true; | ||
73 | } | ||
74 | |||
75 | void arm_handle_psci_call(ARMCPU *cpu) | ||
76 | @@ -XXX,XX +XXX,XX @@ void arm_handle_psci_call(ARMCPU *cpu) | ||
77 | break; | ||
78 | case QEMU_PSCI_0_1_FN_MIGRATE: | ||
79 | case QEMU_PSCI_0_2_FN_MIGRATE: | ||
80 | + default: | ||
81 | ret = QEMU_PSCI_RET_NOT_SUPPORTED; | ||
82 | break; | ||
83 | - default: | ||
84 | - g_assert_not_reached(); | ||
85 | } | ||
86 | |||
87 | err: | ||
28 | -- | 88 | -- |
29 | 2.20.1 | 89 | 2.20.1 |
30 | 90 | ||
31 | 91 | diff view generated by jsdifflib |
1 | From: Fredrik Strupe <fredrik@strupe.net> | 1 | From: Tong Ho <tong.ho@xilinx.com> |
---|---|---|---|
2 | 2 | ||
3 | According to Arm ARM, VQDMULL is only valid when U=0, while having | 3 | This introduces the QOM for Xilinx eFuse, an one-time |
4 | U=1 is unallocated. | 4 | field-programmable storage bit array. |
5 | 5 | ||
6 | Signed-off-by: Fredrik Strupe <fredrik@strupe.net> | 6 | The actual mmio interface to the array varies by device |
7 | Fixes: 695272dcb976 ("target-arm: Handle UNDEF cases for Neon 3-regs-different-widths") | 7 | families and will be provided in different change-sets. |
8 | |||
9 | Co-authored-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | ||
10 | Co-authored-by: Sai Pavan Boddu <sai.pavan.boddu@xilinx.com> | ||
11 | |||
12 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | ||
13 | Signed-off-by: Sai Pavan Boddu <sai.pavan.boddu@xilinx.com> | ||
14 | Signed-off-by: Tong Ho <tong.ho@xilinx.com> | ||
15 | Message-id: 20210917052400.1249094-2-tong.ho@xilinx.com | ||
8 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 16 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> |
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 17 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
10 | --- | 18 | --- |
11 | target/arm/translate.c | 2 +- | 19 | include/hw/nvram/xlnx-efuse.h | 132 ++++++++++++++++ |
12 | 1 file changed, 1 insertion(+), 1 deletion(-) | 20 | hw/nvram/xlnx-efuse-crc.c | 119 +++++++++++++++ |
21 | hw/nvram/xlnx-efuse.c | 280 ++++++++++++++++++++++++++++++++++ | ||
22 | hw/nvram/Kconfig | 7 + | ||
23 | hw/nvram/meson.build | 2 + | ||
24 | 5 files changed, 540 insertions(+) | ||
25 | create mode 100644 include/hw/nvram/xlnx-efuse.h | ||
26 | create mode 100644 hw/nvram/xlnx-efuse-crc.c | ||
27 | create mode 100644 hw/nvram/xlnx-efuse.c | ||
13 | 28 | ||
14 | diff --git a/target/arm/translate.c b/target/arm/translate.c | 29 | diff --git a/include/hw/nvram/xlnx-efuse.h b/include/hw/nvram/xlnx-efuse.h |
30 | new file mode 100644 | ||
31 | index XXXXXXX..XXXXXXX | ||
32 | --- /dev/null | ||
33 | +++ b/include/hw/nvram/xlnx-efuse.h | ||
34 | @@ -XXX,XX +XXX,XX @@ | ||
35 | +/* | ||
36 | + * QEMU model of the Xilinx eFuse core | ||
37 | + * | ||
38 | + * Copyright (c) 2015 Xilinx Inc. | ||
39 | + * | ||
40 | + * Written by Edgar E. Iglesias <edgari@xilinx.com> | ||
41 | + * | ||
42 | + * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
43 | + * of this software and associated documentation files (the "Software"), to deal | ||
44 | + * in the Software without restriction, including without limitation the rights | ||
45 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
46 | + * copies of the Software, and to permit persons to whom the Software is | ||
47 | + * furnished to do so, subject to the following conditions: | ||
48 | + * | ||
49 | + * The above copyright notice and this permission notice shall be included in | ||
50 | + * all copies or substantial portions of the Software. | ||
51 | + * | ||
52 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
53 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
54 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
55 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
56 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
57 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
58 | + * THE SOFTWARE. | ||
59 | + */ | ||
60 | + | ||
61 | +#ifndef XLNX_EFUSE_H | ||
62 | +#define XLNX_EFUSE_H | ||
63 | + | ||
64 | +#include "sysemu/block-backend.h" | ||
65 | +#include "hw/qdev-core.h" | ||
66 | + | ||
67 | +#define TYPE_XLNX_EFUSE "xlnx,efuse" | ||
68 | +OBJECT_DECLARE_SIMPLE_TYPE(XlnxEFuse, XLNX_EFUSE); | ||
69 | + | ||
70 | +struct XlnxEFuse { | ||
71 | + DeviceState parent_obj; | ||
72 | + BlockBackend *blk; | ||
73 | + bool blk_ro; | ||
74 | + uint32_t *fuse32; | ||
75 | + | ||
76 | + DeviceState *dev; | ||
77 | + | ||
78 | + bool init_tbits; | ||
79 | + | ||
80 | + uint8_t efuse_nr; | ||
81 | + uint32_t efuse_size; | ||
82 | + | ||
83 | + uint32_t *ro_bits; | ||
84 | + uint32_t ro_bits_cnt; | ||
85 | +}; | ||
86 | + | ||
87 | +/** | ||
88 | + * xlnx_efuse_calc_crc: | ||
89 | + * @data: an array of 32-bit words for which the CRC should be computed | ||
90 | + * @u32_cnt: the array size in number of 32-bit words | ||
91 | + * @zpads: the number of 32-bit zeros prepended to @data before computation | ||
92 | + * | ||
93 | + * This function is used to compute the CRC for an array of 32-bit words, | ||
94 | + * using a Xilinx-specific data padding. | ||
95 | + * | ||
96 | + * Returns: the computed 32-bit CRC | ||
97 | + */ | ||
98 | +uint32_t xlnx_efuse_calc_crc(const uint32_t *data, unsigned u32_cnt, | ||
99 | + unsigned zpads); | ||
100 | + | ||
101 | +/** | ||
102 | + * xlnx_efuse_get_bit: | ||
103 | + * @s: the efuse object | ||
104 | + * @bit: the efuse bit-address to read the data | ||
105 | + * | ||
106 | + * Returns: the bit, 0 or 1, at @bit of object @s | ||
107 | + */ | ||
108 | +bool xlnx_efuse_get_bit(XlnxEFuse *s, unsigned int bit); | ||
109 | + | ||
110 | +/** | ||
111 | + * xlnx_efuse_set_bit: | ||
112 | + * @s: the efuse object | ||
113 | + * @bit: the efuse bit-address to be written a value of 1 | ||
114 | + * | ||
115 | + * Returns: true on success, false on failure | ||
116 | + */ | ||
117 | +bool xlnx_efuse_set_bit(XlnxEFuse *s, unsigned int bit); | ||
118 | + | ||
119 | +/** | ||
120 | + * xlnx_efuse_k256_check: | ||
121 | + * @s: the efuse object | ||
122 | + * @crc: the 32-bit CRC to be compared with | ||
123 | + * @start: the efuse bit-address (which must be multiple of 32) of the | ||
124 | + * start of a 256-bit array | ||
125 | + * | ||
126 | + * This function computes the CRC of a 256-bit array starting at @start | ||
127 | + * then compares to the given @crc | ||
128 | + * | ||
129 | + * Returns: true of @crc == computed, false otherwise | ||
130 | + */ | ||
131 | +bool xlnx_efuse_k256_check(XlnxEFuse *s, uint32_t crc, unsigned start); | ||
132 | + | ||
133 | +/** | ||
134 | + * xlnx_efuse_tbits_check: | ||
135 | + * @s: the efuse object | ||
136 | + * | ||
137 | + * This function inspects a number of efuse bits at specific addresses | ||
138 | + * to see if they match a validation pattern. Each pattern is a group | ||
139 | + * of 4 bits, and there are 3 groups. | ||
140 | + * | ||
141 | + * Returns: a 3-bit mask, where a bit of '1' means the corresponding | ||
142 | + * group has a valid pattern. | ||
143 | + */ | ||
144 | +uint32_t xlnx_efuse_tbits_check(XlnxEFuse *s); | ||
145 | + | ||
146 | +/** | ||
147 | + * xlnx_efuse_get_row: | ||
148 | + * @s: the efuse object | ||
149 | + * @bit: the efuse bit address for which a 32-bit value is read | ||
150 | + * | ||
151 | + * Returns: the entire 32 bits of the efuse, starting at a bit | ||
152 | + * address that is multiple of 32 and contains the bit at @bit | ||
153 | + */ | ||
154 | +static inline uint32_t xlnx_efuse_get_row(XlnxEFuse *s, unsigned int bit) | ||
155 | +{ | ||
156 | + if (!(s->fuse32)) { | ||
157 | + return 0; | ||
158 | + } else { | ||
159 | + unsigned int row_idx = bit / 32; | ||
160 | + | ||
161 | + assert(row_idx < (s->efuse_size * s->efuse_nr / 32)); | ||
162 | + return s->fuse32[row_idx]; | ||
163 | + } | ||
164 | +} | ||
165 | + | ||
166 | +#endif | ||
167 | diff --git a/hw/nvram/xlnx-efuse-crc.c b/hw/nvram/xlnx-efuse-crc.c | ||
168 | new file mode 100644 | ||
169 | index XXXXXXX..XXXXXXX | ||
170 | --- /dev/null | ||
171 | +++ b/hw/nvram/xlnx-efuse-crc.c | ||
172 | @@ -XXX,XX +XXX,XX @@ | ||
173 | +/* | ||
174 | + * Xilinx eFuse/bbram CRC calculator | ||
175 | + * | ||
176 | + * Copyright (c) 2021 Xilinx Inc. | ||
177 | + * | ||
178 | + * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
179 | + * of this software and associated documentation files (the "Software"), to deal | ||
180 | + * in the Software without restriction, including without limitation the rights | ||
181 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
182 | + * copies of the Software, and to permit persons to whom the Software is | ||
183 | + * furnished to do so, subject to the following conditions: | ||
184 | + * | ||
185 | + * The above copyright notice and this permission notice shall be included in | ||
186 | + * all copies or substantial portions of the Software. | ||
187 | + * | ||
188 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
189 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
190 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
191 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
192 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
193 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
194 | + * THE SOFTWARE. | ||
195 | + */ | ||
196 | +#include "qemu/osdep.h" | ||
197 | +#include "hw/nvram/xlnx-efuse.h" | ||
198 | + | ||
199 | +static uint32_t xlnx_efuse_u37_crc(uint32_t prev_crc, uint32_t data, | ||
200 | + uint32_t addr) | ||
201 | +{ | ||
202 | + /* A table for 7-bit slicing */ | ||
203 | + static const uint32_t crc_tab[128] = { | ||
204 | + 0x00000000, 0xe13b70f7, 0xc79a971f, 0x26a1e7e8, | ||
205 | + 0x8ad958cf, 0x6be22838, 0x4d43cfd0, 0xac78bf27, | ||
206 | + 0x105ec76f, 0xf165b798, 0xd7c45070, 0x36ff2087, | ||
207 | + 0x9a879fa0, 0x7bbcef57, 0x5d1d08bf, 0xbc267848, | ||
208 | + 0x20bd8ede, 0xc186fe29, 0xe72719c1, 0x061c6936, | ||
209 | + 0xaa64d611, 0x4b5fa6e6, 0x6dfe410e, 0x8cc531f9, | ||
210 | + 0x30e349b1, 0xd1d83946, 0xf779deae, 0x1642ae59, | ||
211 | + 0xba3a117e, 0x5b016189, 0x7da08661, 0x9c9bf696, | ||
212 | + 0x417b1dbc, 0xa0406d4b, 0x86e18aa3, 0x67dafa54, | ||
213 | + 0xcba24573, 0x2a993584, 0x0c38d26c, 0xed03a29b, | ||
214 | + 0x5125dad3, 0xb01eaa24, 0x96bf4dcc, 0x77843d3b, | ||
215 | + 0xdbfc821c, 0x3ac7f2eb, 0x1c661503, 0xfd5d65f4, | ||
216 | + 0x61c69362, 0x80fde395, 0xa65c047d, 0x4767748a, | ||
217 | + 0xeb1fcbad, 0x0a24bb5a, 0x2c855cb2, 0xcdbe2c45, | ||
218 | + 0x7198540d, 0x90a324fa, 0xb602c312, 0x5739b3e5, | ||
219 | + 0xfb410cc2, 0x1a7a7c35, 0x3cdb9bdd, 0xdde0eb2a, | ||
220 | + 0x82f63b78, 0x63cd4b8f, 0x456cac67, 0xa457dc90, | ||
221 | + 0x082f63b7, 0xe9141340, 0xcfb5f4a8, 0x2e8e845f, | ||
222 | + 0x92a8fc17, 0x73938ce0, 0x55326b08, 0xb4091bff, | ||
223 | + 0x1871a4d8, 0xf94ad42f, 0xdfeb33c7, 0x3ed04330, | ||
224 | + 0xa24bb5a6, 0x4370c551, 0x65d122b9, 0x84ea524e, | ||
225 | + 0x2892ed69, 0xc9a99d9e, 0xef087a76, 0x0e330a81, | ||
226 | + 0xb21572c9, 0x532e023e, 0x758fe5d6, 0x94b49521, | ||
227 | + 0x38cc2a06, 0xd9f75af1, 0xff56bd19, 0x1e6dcdee, | ||
228 | + 0xc38d26c4, 0x22b65633, 0x0417b1db, 0xe52cc12c, | ||
229 | + 0x49547e0b, 0xa86f0efc, 0x8ecee914, 0x6ff599e3, | ||
230 | + 0xd3d3e1ab, 0x32e8915c, 0x144976b4, 0xf5720643, | ||
231 | + 0x590ab964, 0xb831c993, 0x9e902e7b, 0x7fab5e8c, | ||
232 | + 0xe330a81a, 0x020bd8ed, 0x24aa3f05, 0xc5914ff2, | ||
233 | + 0x69e9f0d5, 0x88d28022, 0xae7367ca, 0x4f48173d, | ||
234 | + 0xf36e6f75, 0x12551f82, 0x34f4f86a, 0xd5cf889d, | ||
235 | + 0x79b737ba, 0x988c474d, 0xbe2da0a5, 0x5f16d052 | ||
236 | + }; | ||
237 | + | ||
238 | + /* | ||
239 | + * eFuse calculation is shown here: | ||
240 | + * https://github.com/Xilinx/embeddedsw/blob/release-2019.2/lib/sw_services/xilskey/src/xilskey_utils.c#L1496 | ||
241 | + * | ||
242 | + * Each u32 word is appended a 5-bit value, for a total of 37 bits; see: | ||
243 | + * https://github.com/Xilinx/embeddedsw/blob/release-2019.2/lib/sw_services/xilskey/src/xilskey_utils.c#L1356 | ||
244 | + */ | ||
245 | + uint32_t crc = prev_crc; | ||
246 | + const unsigned rshf = 7; | ||
247 | + const uint32_t im = (1 << rshf) - 1; | ||
248 | + const uint32_t rm = (1 << (32 - rshf)) - 1; | ||
249 | + const uint32_t i2 = (1 << 2) - 1; | ||
250 | + const uint32_t r2 = (1 << 30) - 1; | ||
251 | + | ||
252 | + unsigned j; | ||
253 | + uint32_t i, r; | ||
254 | + uint64_t w; | ||
255 | + | ||
256 | + w = (uint64_t)(addr) << 32; | ||
257 | + w |= data; | ||
258 | + | ||
259 | + /* Feed 35 bits, in 5 rounds, each a slice of 7 bits */ | ||
260 | + for (j = 0; j < 5; j++) { | ||
261 | + r = rm & (crc >> rshf); | ||
262 | + i = im & (crc ^ w); | ||
263 | + crc = crc_tab[i] ^ r; | ||
264 | + | ||
265 | + w >>= rshf; | ||
266 | + } | ||
267 | + | ||
268 | + /* Feed the remaining 2 bits */ | ||
269 | + r = r2 & (crc >> 2); | ||
270 | + i = i2 & (crc ^ w); | ||
271 | + crc = crc_tab[i << (rshf - 2)] ^ r; | ||
272 | + | ||
273 | + return crc; | ||
274 | +} | ||
275 | + | ||
276 | +uint32_t xlnx_efuse_calc_crc(const uint32_t *data, unsigned u32_cnt, | ||
277 | + unsigned zpads) | ||
278 | +{ | ||
279 | + uint32_t crc = 0; | ||
280 | + unsigned index; | ||
281 | + | ||
282 | + for (index = zpads; index; index--) { | ||
283 | + crc = xlnx_efuse_u37_crc(crc, 0, (index + u32_cnt)); | ||
284 | + } | ||
285 | + | ||
286 | + for (index = u32_cnt; index; index--) { | ||
287 | + crc = xlnx_efuse_u37_crc(crc, data[index - 1], index); | ||
288 | + } | ||
289 | + | ||
290 | + return crc; | ||
291 | +} | ||
292 | diff --git a/hw/nvram/xlnx-efuse.c b/hw/nvram/xlnx-efuse.c | ||
293 | new file mode 100644 | ||
294 | index XXXXXXX..XXXXXXX | ||
295 | --- /dev/null | ||
296 | +++ b/hw/nvram/xlnx-efuse.c | ||
297 | @@ -XXX,XX +XXX,XX @@ | ||
298 | +/* | ||
299 | + * QEMU model of the EFUSE eFuse | ||
300 | + * | ||
301 | + * Copyright (c) 2015 Xilinx Inc. | ||
302 | + * | ||
303 | + * Written by Edgar E. Iglesias <edgari@xilinx.com> | ||
304 | + * | ||
305 | + * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
306 | + * of this software and associated documentation files (the "Software"), to deal | ||
307 | + * in the Software without restriction, including without limitation the rights | ||
308 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
309 | + * copies of the Software, and to permit persons to whom the Software is | ||
310 | + * furnished to do so, subject to the following conditions: | ||
311 | + * | ||
312 | + * The above copyright notice and this permission notice shall be included in | ||
313 | + * all copies or substantial portions of the Software. | ||
314 | + * | ||
315 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
316 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
317 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
318 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
319 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
320 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
321 | + * THE SOFTWARE. | ||
322 | + */ | ||
323 | + | ||
324 | +#include "qemu/osdep.h" | ||
325 | +#include "hw/nvram/xlnx-efuse.h" | ||
326 | + | ||
327 | +#include "qemu/error-report.h" | ||
328 | +#include "qemu/log.h" | ||
329 | +#include "qapi/error.h" | ||
330 | +#include "sysemu/blockdev.h" | ||
331 | +#include "hw/qdev-properties.h" | ||
332 | +#include "hw/qdev-properties-system.h" | ||
333 | + | ||
334 | +#define TBIT0_OFFSET 28 | ||
335 | +#define TBIT1_OFFSET 29 | ||
336 | +#define TBIT2_OFFSET 30 | ||
337 | +#define TBIT3_OFFSET 31 | ||
338 | +#define TBITS_PATTERN (0x0AU << TBIT0_OFFSET) | ||
339 | +#define TBITS_MASK (0x0FU << TBIT0_OFFSET) | ||
340 | + | ||
341 | +bool xlnx_efuse_get_bit(XlnxEFuse *s, unsigned int bit) | ||
342 | +{ | ||
343 | + bool b = s->fuse32[bit / 32] & (1 << (bit % 32)); | ||
344 | + return b; | ||
345 | +} | ||
346 | + | ||
347 | +static int efuse_bytes(XlnxEFuse *s) | ||
348 | +{ | ||
349 | + return ROUND_UP((s->efuse_nr * s->efuse_size) / 8, 4); | ||
350 | +} | ||
351 | + | ||
352 | +static int efuse_bdrv_read(XlnxEFuse *s, Error **errp) | ||
353 | +{ | ||
354 | + uint32_t *ram = s->fuse32; | ||
355 | + int nr = efuse_bytes(s); | ||
356 | + | ||
357 | + if (!s->blk) { | ||
358 | + return 0; | ||
359 | + } | ||
360 | + | ||
361 | + s->blk_ro = !blk_supports_write_perm(s->blk); | ||
362 | + if (!s->blk_ro) { | ||
363 | + int rc; | ||
364 | + | ||
365 | + rc = blk_set_perm(s->blk, | ||
366 | + (BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE), | ||
367 | + BLK_PERM_ALL, NULL); | ||
368 | + if (rc) { | ||
369 | + s->blk_ro = true; | ||
370 | + } | ||
371 | + } | ||
372 | + if (s->blk_ro) { | ||
373 | + warn_report("%s: Skip saving updates to read-only eFUSE backstore.", | ||
374 | + blk_name(s->blk)); | ||
375 | + } | ||
376 | + | ||
377 | + if (blk_pread(s->blk, 0, ram, nr) < 0) { | ||
378 | + error_setg(errp, "%s: Failed to read %u bytes from eFUSE backstore.", | ||
379 | + blk_name(s->blk), nr); | ||
380 | + return -1; | ||
381 | + } | ||
382 | + | ||
383 | + /* Convert from little-endian backstore for each 32-bit row */ | ||
384 | + nr /= 4; | ||
385 | + while (nr--) { | ||
386 | + ram[nr] = le32_to_cpu(ram[nr]); | ||
387 | + } | ||
388 | + | ||
389 | + return 0; | ||
390 | +} | ||
391 | + | ||
392 | +static void efuse_bdrv_sync(XlnxEFuse *s, unsigned int bit) | ||
393 | +{ | ||
394 | + unsigned int row_offset; | ||
395 | + uint32_t le32; | ||
396 | + | ||
397 | + if (!s->blk || s->blk_ro) { | ||
398 | + return; /* Silent on read-only backend to avoid message flood */ | ||
399 | + } | ||
400 | + | ||
401 | + /* Backstore is always in little-endian */ | ||
402 | + le32 = cpu_to_le32(xlnx_efuse_get_row(s, bit)); | ||
403 | + | ||
404 | + row_offset = (bit / 32) * 4; | ||
405 | + if (blk_pwrite(s->blk, row_offset, &le32, 4, 0) < 0) { | ||
406 | + error_report("%s: Failed to write offset %u of eFUSE backstore.", | ||
407 | + blk_name(s->blk), row_offset); | ||
408 | + } | ||
409 | +} | ||
410 | + | ||
411 | +static int efuse_ro_bits_cmp(const void *a, const void *b) | ||
412 | +{ | ||
413 | + uint32_t i = *(const uint32_t *)a; | ||
414 | + uint32_t j = *(const uint32_t *)b; | ||
415 | + | ||
416 | + return (i > j) - (i < j); | ||
417 | +} | ||
418 | + | ||
419 | +static void efuse_ro_bits_sort(XlnxEFuse *s) | ||
420 | +{ | ||
421 | + uint32_t *ary = s->ro_bits; | ||
422 | + const uint32_t cnt = s->ro_bits_cnt; | ||
423 | + | ||
424 | + if (ary && cnt > 1) { | ||
425 | + qsort(ary, cnt, sizeof(ary[0]), efuse_ro_bits_cmp); | ||
426 | + } | ||
427 | +} | ||
428 | + | ||
429 | +static bool efuse_ro_bits_find(XlnxEFuse *s, uint32_t k) | ||
430 | +{ | ||
431 | + const uint32_t *ary = s->ro_bits; | ||
432 | + const uint32_t cnt = s->ro_bits_cnt; | ||
433 | + | ||
434 | + if (!ary || !cnt) { | ||
435 | + return false; | ||
436 | + } | ||
437 | + | ||
438 | + return bsearch(&k, ary, cnt, sizeof(ary[0]), efuse_ro_bits_cmp) != NULL; | ||
439 | +} | ||
440 | + | ||
441 | +bool xlnx_efuse_set_bit(XlnxEFuse *s, unsigned int bit) | ||
442 | +{ | ||
443 | + if (efuse_ro_bits_find(s, bit)) { | ||
444 | + qemu_log_mask(LOG_GUEST_ERROR, "%s: WARN: " | ||
445 | + "Ignored setting of readonly efuse bit<%u,%u>!\n", | ||
446 | + object_get_canonical_path(OBJECT(s)), | ||
447 | + (bit / 32), (bit % 32)); | ||
448 | + return false; | ||
449 | + } | ||
450 | + | ||
451 | + s->fuse32[bit / 32] |= 1 << (bit % 32); | ||
452 | + efuse_bdrv_sync(s, bit); | ||
453 | + return true; | ||
454 | +} | ||
455 | + | ||
456 | +bool xlnx_efuse_k256_check(XlnxEFuse *s, uint32_t crc, unsigned start) | ||
457 | +{ | ||
458 | + uint32_t calc; | ||
459 | + | ||
460 | + /* A key always occupies multiple of whole rows */ | ||
461 | + assert((start % 32) == 0); | ||
462 | + | ||
463 | + calc = xlnx_efuse_calc_crc(&s->fuse32[start / 32], (256 / 32), 0); | ||
464 | + return calc == crc; | ||
465 | +} | ||
466 | + | ||
467 | +uint32_t xlnx_efuse_tbits_check(XlnxEFuse *s) | ||
468 | +{ | ||
469 | + int nr; | ||
470 | + uint32_t check = 0; | ||
471 | + | ||
472 | + for (nr = s->efuse_nr; nr-- > 0; ) { | ||
473 | + int efuse_start_row_num = (s->efuse_size * nr) / 32; | ||
474 | + uint32_t data = s->fuse32[efuse_start_row_num]; | ||
475 | + | ||
476 | + /* | ||
477 | + * If the option is on, auto-init blank T-bits. | ||
478 | + * (non-blank will still be reported as '0' in the check, e.g., | ||
479 | + * for error-injection tests) | ||
480 | + */ | ||
481 | + if ((data & TBITS_MASK) == 0 && s->init_tbits) { | ||
482 | + data |= TBITS_PATTERN; | ||
483 | + | ||
484 | + s->fuse32[efuse_start_row_num] = data; | ||
485 | + efuse_bdrv_sync(s, (efuse_start_row_num * 32 + TBIT0_OFFSET)); | ||
486 | + } | ||
487 | + | ||
488 | + check = (check << 1) | ((data & TBITS_MASK) == TBITS_PATTERN); | ||
489 | + } | ||
490 | + | ||
491 | + return check; | ||
492 | +} | ||
493 | + | ||
494 | +static void efuse_realize(DeviceState *dev, Error **errp) | ||
495 | +{ | ||
496 | + XlnxEFuse *s = XLNX_EFUSE(dev); | ||
497 | + | ||
498 | + /* Sort readonly-list for bsearch lookup */ | ||
499 | + efuse_ro_bits_sort(s); | ||
500 | + | ||
501 | + if ((s->efuse_size % 32) != 0) { | ||
502 | + error_setg(errp, | ||
503 | + "%s.efuse-size: %u: property value not multiple of 32.", | ||
504 | + object_get_canonical_path(OBJECT(dev)), s->efuse_size); | ||
505 | + return; | ||
506 | + } | ||
507 | + | ||
508 | + s->fuse32 = g_malloc0(efuse_bytes(s)); | ||
509 | + if (efuse_bdrv_read(s, errp)) { | ||
510 | + g_free(s->fuse32); | ||
511 | + } | ||
512 | +} | ||
513 | + | ||
514 | +static void efuse_prop_set_drive(Object *obj, Visitor *v, const char *name, | ||
515 | + void *opaque, Error **errp) | ||
516 | +{ | ||
517 | + DeviceState *dev = DEVICE(obj); | ||
518 | + | ||
519 | + qdev_prop_drive.set(obj, v, name, opaque, errp); | ||
520 | + | ||
521 | + /* Fill initial data if backend is attached after realized */ | ||
522 | + if (dev->realized) { | ||
523 | + efuse_bdrv_read(XLNX_EFUSE(obj), errp); | ||
524 | + } | ||
525 | +} | ||
526 | + | ||
527 | +static void efuse_prop_get_drive(Object *obj, Visitor *v, const char *name, | ||
528 | + void *opaque, Error **errp) | ||
529 | +{ | ||
530 | + qdev_prop_drive.get(obj, v, name, opaque, errp); | ||
531 | +} | ||
532 | + | ||
533 | +static void efuse_prop_release_drive(Object *obj, const char *name, | ||
534 | + void *opaque) | ||
535 | +{ | ||
536 | + qdev_prop_drive.release(obj, name, opaque); | ||
537 | +} | ||
538 | + | ||
539 | +static const PropertyInfo efuse_prop_drive = { | ||
540 | + .name = "str", | ||
541 | + .description = "Node name or ID of a block device to use as eFUSE backend", | ||
542 | + .realized_set_allowed = true, | ||
543 | + .get = efuse_prop_get_drive, | ||
544 | + .set = efuse_prop_set_drive, | ||
545 | + .release = efuse_prop_release_drive, | ||
546 | +}; | ||
547 | + | ||
548 | +static Property efuse_properties[] = { | ||
549 | + DEFINE_PROP("drive", XlnxEFuse, blk, efuse_prop_drive, BlockBackend *), | ||
550 | + DEFINE_PROP_UINT8("efuse-nr", XlnxEFuse, efuse_nr, 3), | ||
551 | + DEFINE_PROP_UINT32("efuse-size", XlnxEFuse, efuse_size, 64 * 32), | ||
552 | + DEFINE_PROP_BOOL("init-factory-tbits", XlnxEFuse, init_tbits, true), | ||
553 | + DEFINE_PROP_ARRAY("read-only", XlnxEFuse, ro_bits_cnt, ro_bits, | ||
554 | + qdev_prop_uint32, uint32_t), | ||
555 | + DEFINE_PROP_END_OF_LIST(), | ||
556 | +}; | ||
557 | + | ||
558 | +static void efuse_class_init(ObjectClass *klass, void *data) | ||
559 | +{ | ||
560 | + DeviceClass *dc = DEVICE_CLASS(klass); | ||
561 | + | ||
562 | + dc->realize = efuse_realize; | ||
563 | + device_class_set_props(dc, efuse_properties); | ||
564 | +} | ||
565 | + | ||
566 | +static const TypeInfo efuse_info = { | ||
567 | + .name = TYPE_XLNX_EFUSE, | ||
568 | + .parent = TYPE_DEVICE, | ||
569 | + .instance_size = sizeof(XlnxEFuse), | ||
570 | + .class_init = efuse_class_init, | ||
571 | +}; | ||
572 | + | ||
573 | +static void efuse_register_types(void) | ||
574 | +{ | ||
575 | + type_register_static(&efuse_info); | ||
576 | +} | ||
577 | +type_init(efuse_register_types) | ||
578 | diff --git a/hw/nvram/Kconfig b/hw/nvram/Kconfig | ||
15 | index XXXXXXX..XXXXXXX 100644 | 579 | index XXXXXXX..XXXXXXX 100644 |
16 | --- a/target/arm/translate.c | 580 | --- a/hw/nvram/Kconfig |
17 | +++ b/target/arm/translate.c | 581 | +++ b/hw/nvram/Kconfig |
18 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | 582 | @@ -XXX,XX +XXX,XX @@ config NMC93XX_EEPROM |
19 | {0, 0, 0, 0}, /* VMLSL */ | 583 | |
20 | {0, 0, 0, 9}, /* VQDMLSL */ | 584 | config CHRP_NVRAM |
21 | {0, 0, 0, 0}, /* Integer VMULL */ | 585 | bool |
22 | - {0, 0, 0, 1}, /* VQDMULL */ | 586 | + |
23 | + {0, 0, 0, 9}, /* VQDMULL */ | 587 | +config XLNX_EFUSE_CRC |
24 | {0, 0, 0, 0xa}, /* Polynomial VMULL */ | 588 | + bool |
25 | {0, 0, 0, 7}, /* Reserved: always UNDEF */ | 589 | + |
26 | }; | 590 | +config XLNX_EFUSE |
591 | + bool | ||
592 | + select XLNX_EFUSE_CRC | ||
593 | diff --git a/hw/nvram/meson.build b/hw/nvram/meson.build | ||
594 | index XXXXXXX..XXXXXXX 100644 | ||
595 | --- a/hw/nvram/meson.build | ||
596 | +++ b/hw/nvram/meson.build | ||
597 | @@ -XXX,XX +XXX,XX @@ softmmu_ss.add(when: 'CONFIG_AT24C', if_true: files('eeprom_at24c.c')) | ||
598 | softmmu_ss.add(when: 'CONFIG_MAC_NVRAM', if_true: files('mac_nvram.c')) | ||
599 | softmmu_ss.add(when: 'CONFIG_NPCM7XX', if_true: files('npcm7xx_otp.c')) | ||
600 | softmmu_ss.add(when: 'CONFIG_NRF51_SOC', if_true: files('nrf51_nvm.c')) | ||
601 | +softmmu_ss.add(when: 'CONFIG_XLNX_EFUSE_CRC', if_true: files('xlnx-efuse-crc.c')) | ||
602 | +softmmu_ss.add(when: 'CONFIG_XLNX_EFUSE', if_true: files('xlnx-efuse.c')) | ||
603 | |||
604 | specific_ss.add(when: 'CONFIG_PSERIES', if_true: files('spapr_nvram.c')) | ||
27 | -- | 605 | -- |
28 | 2.20.1 | 606 | 2.20.1 |
29 | 607 | ||
30 | 608 | diff view generated by jsdifflib |
1 | Add the infrastructure for building and invoking a decodetree decoder | 1 | From: Tong Ho <tong.ho@xilinx.com> |
---|---|---|---|
2 | for the AArch32 Neon encodings. At the moment the new decoder covers | ||
3 | nothing, so we always fall back to the existing hand-written decode. | ||
4 | 2 | ||
5 | We follow the same pattern we did for the VFP decodetree conversion | 3 | This implements the Xilinx Versal eFuse, an one-time |
6 | (commit 78e138bc1f672c145ef6ace74617d and following): code that deals | 4 | field-programmable non-volatile storage device. There is |
7 | with Neon will be moving gradually out to translate-neon.vfp.inc, | 5 | only one such device in the Xilinx Versal product family. |
8 | which we #include into translate.c. | ||
9 | 6 | ||
10 | In order to share the decode files between A32 and T32, we | 7 | This device has two separate mmio interfaces, a controller |
11 | split Neon into 3 parts: | 8 | and a flatten readback. |
12 | * data-processing | ||
13 | * load-store | ||
14 | * 'shared' encodings | ||
15 | 9 | ||
16 | The first two groups of instructions have similar but not identical | 10 | The controller provides interfaces for field-programming, |
17 | A32 and T32 encodings, so we need to manually transform the T32 | 11 | configuration, control, and status. |
18 | encoding into the A32 one before calling the decoder; the third group | ||
19 | covers the Neon instructions which are identical in A32 and T32. | ||
20 | 12 | ||
13 | The flatten readback is a cache to provide a byte-accessible | ||
14 | read-only interface to efficiently read efuse array. | ||
15 | |||
16 | Co-authored-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | ||
17 | Co-authored-by: Sai Pavan Boddu <sai.pavan.boddu@xilinx.com> | ||
18 | |||
19 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | ||
20 | Signed-off-by: Sai Pavan Boddu <sai.pavan.boddu@xilinx.com> | ||
21 | Signed-off-by: Tong Ho <tong.ho@xilinx.com> | ||
22 | Message-id: 20210917052400.1249094-3-tong.ho@xilinx.com | ||
23 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
21 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 24 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
22 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
23 | Message-id: 20200430181003.21682-4-peter.maydell@linaro.org | ||
24 | --- | 25 | --- |
25 | target/arm/neon-dp.decode | 29 ++++++++++++++++++++++++++ | 26 | include/hw/nvram/xlnx-versal-efuse.h | 68 +++ |
26 | target/arm/neon-ls.decode | 29 ++++++++++++++++++++++++++ | 27 | hw/nvram/xlnx-versal-efuse-cache.c | 114 ++++ |
27 | target/arm/neon-shared.decode | 27 +++++++++++++++++++++++++ | 28 | hw/nvram/xlnx-versal-efuse-ctrl.c | 783 +++++++++++++++++++++++++++ |
28 | target/arm/translate-neon.inc.c | 32 +++++++++++++++++++++++++++++ | 29 | hw/nvram/Kconfig | 4 + |
29 | target/arm/translate.c | 36 +++++++++++++++++++++++++++++++-- | 30 | hw/nvram/meson.build | 3 + |
30 | target/arm/Makefile.objs | 18 +++++++++++++++++ | 31 | 5 files changed, 972 insertions(+) |
31 | 6 files changed, 169 insertions(+), 2 deletions(-) | 32 | create mode 100644 include/hw/nvram/xlnx-versal-efuse.h |
32 | create mode 100644 target/arm/neon-dp.decode | 33 | create mode 100644 hw/nvram/xlnx-versal-efuse-cache.c |
33 | create mode 100644 target/arm/neon-ls.decode | 34 | create mode 100644 hw/nvram/xlnx-versal-efuse-ctrl.c |
34 | create mode 100644 target/arm/neon-shared.decode | ||
35 | create mode 100644 target/arm/translate-neon.inc.c | ||
36 | 35 | ||
37 | diff --git a/target/arm/neon-dp.decode b/target/arm/neon-dp.decode | 36 | diff --git a/include/hw/nvram/xlnx-versal-efuse.h b/include/hw/nvram/xlnx-versal-efuse.h |
38 | new file mode 100644 | 37 | new file mode 100644 |
39 | index XXXXXXX..XXXXXXX | 38 | index XXXXXXX..XXXXXXX |
40 | --- /dev/null | 39 | --- /dev/null |
41 | +++ b/target/arm/neon-dp.decode | 40 | +++ b/include/hw/nvram/xlnx-versal-efuse.h |
42 | @@ -XXX,XX +XXX,XX @@ | 41 | @@ -XXX,XX +XXX,XX @@ |
43 | +# AArch32 Neon data-processing instruction descriptions | 42 | +/* |
44 | +# | 43 | + * Copyright (c) 2020 Xilinx Inc. |
45 | +# Copyright (c) 2020 Linaro, Ltd | 44 | + * |
46 | +# | 45 | + * Permission is hereby granted, free of charge, to any person obtaining a copy |
47 | +# This library is free software; you can redistribute it and/or | 46 | + * of this software and associated documentation files (the "Software"), to deal |
48 | +# modify it under the terms of the GNU Lesser General Public | 47 | + * in the Software without restriction, including without limitation the rights |
49 | +# License as published by the Free Software Foundation; either | 48 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
50 | +# version 2 of the License, or (at your option) any later version. | 49 | + * copies of the Software, and to permit persons to whom the Software is |
51 | +# | 50 | + * furnished to do so, subject to the following conditions: |
52 | +# This library is distributed in the hope that it will be useful, | 51 | + * |
53 | +# but WITHOUT ANY WARRANTY; without even the implied warranty of | 52 | + * The above copyright notice and this permission notice shall be included in |
54 | +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 53 | + * all copies or substantial portions of the Software. |
55 | +# Lesser General Public License for more details. | 54 | + * |
56 | +# | 55 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
57 | +# You should have received a copy of the GNU Lesser General Public | 56 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
58 | +# License along with this library; if not, see <http://www.gnu.org/licenses/>. | 57 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
59 | + | 58 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
60 | +# | 59 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
61 | +# This file is processed by scripts/decodetree.py | 60 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
62 | +# | 61 | + * THE SOFTWARE. |
63 | + | 62 | + */ |
64 | +# Encodings for Neon data processing instructions where the T32 encoding | 63 | +#ifndef XLNX_VERSAL_EFUSE_H |
65 | +# is a simple transformation of the A32 encoding. | 64 | +#define XLNX_VERSAL_EFUSE_H |
66 | +# More specifically, this file covers instructions where the A32 encoding is | 65 | + |
67 | +# 0b1111_001p_qqqq_qqqq_qqqq_qqqq_qqqq_qqqq | 66 | +#include "hw/irq.h" |
68 | +# and the T32 encoding is | 67 | +#include "hw/sysbus.h" |
69 | +# 0b111p_1111_qqqq_qqqq_qqqq_qqqq_qqqq_qqqq | 68 | +#include "hw/register.h" |
70 | +# This file works on the A32 encoding only; calling code for T32 has to | 69 | +#include "hw/nvram/xlnx-efuse.h" |
71 | +# transform the insn into the A32 version first. | 70 | + |
72 | diff --git a/target/arm/neon-ls.decode b/target/arm/neon-ls.decode | 71 | +#define XLNX_VERSAL_EFUSE_CTRL_R_MAX ((0x100 / 4) + 1) |
72 | + | ||
73 | +#define TYPE_XLNX_VERSAL_EFUSE_CTRL "xlnx,versal-efuse" | ||
74 | +#define TYPE_XLNX_VERSAL_EFUSE_CACHE "xlnx,pmc-efuse-cache" | ||
75 | + | ||
76 | +OBJECT_DECLARE_SIMPLE_TYPE(XlnxVersalEFuseCtrl, XLNX_VERSAL_EFUSE_CTRL); | ||
77 | +OBJECT_DECLARE_SIMPLE_TYPE(XlnxVersalEFuseCache, XLNX_VERSAL_EFUSE_CACHE); | ||
78 | + | ||
79 | +struct XlnxVersalEFuseCtrl { | ||
80 | + SysBusDevice parent_obj; | ||
81 | + qemu_irq irq_efuse_imr; | ||
82 | + | ||
83 | + XlnxEFuse *efuse; | ||
84 | + | ||
85 | + void *extra_pg0_lock_spec; /* Opaque property */ | ||
86 | + uint32_t extra_pg0_lock_n16; | ||
87 | + | ||
88 | + uint32_t regs[XLNX_VERSAL_EFUSE_CTRL_R_MAX]; | ||
89 | + RegisterInfo regs_info[XLNX_VERSAL_EFUSE_CTRL_R_MAX]; | ||
90 | +}; | ||
91 | + | ||
92 | +struct XlnxVersalEFuseCache { | ||
93 | + SysBusDevice parent_obj; | ||
94 | + MemoryRegion iomem; | ||
95 | + | ||
96 | + XlnxEFuse *efuse; | ||
97 | +}; | ||
98 | + | ||
99 | +/** | ||
100 | + * xlnx_versal_efuse_read_row: | ||
101 | + * @s: the efuse object | ||
102 | + * @bit: the bit-address within the 32-bit row to be read | ||
103 | + * @denied: if non-NULL, to receive true if the row is write-only | ||
104 | + * | ||
105 | + * Returns: the 32-bit word containing address @bit; 0 if @denies is true | ||
106 | + */ | ||
107 | +uint32_t xlnx_versal_efuse_read_row(XlnxEFuse *s, uint32_t bit, bool *denied); | ||
108 | + | ||
109 | +#endif | ||
110 | diff --git a/hw/nvram/xlnx-versal-efuse-cache.c b/hw/nvram/xlnx-versal-efuse-cache.c | ||
73 | new file mode 100644 | 111 | new file mode 100644 |
74 | index XXXXXXX..XXXXXXX | 112 | index XXXXXXX..XXXXXXX |
75 | --- /dev/null | 113 | --- /dev/null |
76 | +++ b/target/arm/neon-ls.decode | 114 | +++ b/hw/nvram/xlnx-versal-efuse-cache.c |
77 | @@ -XXX,XX +XXX,XX @@ | 115 | @@ -XXX,XX +XXX,XX @@ |
78 | +# AArch32 Neon load/store instruction descriptions | 116 | +/* |
79 | +# | 117 | + * QEMU model of the EFuse_Cache |
80 | +# Copyright (c) 2020 Linaro, Ltd | 118 | + * |
81 | +# | 119 | + * Copyright (c) 2017 Xilinx Inc. |
82 | +# This library is free software; you can redistribute it and/or | 120 | + * |
83 | +# modify it under the terms of the GNU Lesser General Public | 121 | + * Permission is hereby granted, free of charge, to any person obtaining a copy |
84 | +# License as published by the Free Software Foundation; either | 122 | + * of this software and associated documentation files (the "Software"), to deal |
85 | +# version 2 of the License, or (at your option) any later version. | 123 | + * in the Software without restriction, including without limitation the rights |
86 | +# | 124 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
87 | +# This library is distributed in the hope that it will be useful, | 125 | + * copies of the Software, and to permit persons to whom the Software is |
88 | +# but WITHOUT ANY WARRANTY; without even the implied warranty of | 126 | + * furnished to do so, subject to the following conditions: |
89 | +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 127 | + * |
90 | +# Lesser General Public License for more details. | 128 | + * The above copyright notice and this permission notice shall be included in |
91 | +# | 129 | + * all copies or substantial portions of the Software. |
92 | +# You should have received a copy of the GNU Lesser General Public | 130 | + * |
93 | +# License along with this library; if not, see <http://www.gnu.org/licenses/>. | 131 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
94 | + | 132 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
95 | +# | 133 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
96 | +# This file is processed by scripts/decodetree.py | 134 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
97 | +# | 135 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
98 | + | 136 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
99 | +# Encodings for Neon load/store instructions where the T32 encoding | 137 | + * THE SOFTWARE. |
100 | +# is a simple transformation of the A32 encoding. | 138 | + */ |
101 | +# More specifically, this file covers instructions where the A32 encoding is | 139 | + |
102 | +# 0b1111_0100_xxx0_xxxx_xxxx_xxxx_xxxx_xxxx | 140 | +#include "qemu/osdep.h" |
103 | +# and the T32 encoding is | 141 | +#include "hw/nvram/xlnx-versal-efuse.h" |
104 | +# 0b1111_1001_xxx0_xxxx_xxxx_xxxx_xxxx_xxxx | 142 | + |
105 | +# This file works on the A32 encoding only; calling code for T32 has to | 143 | +#include "qemu/log.h" |
106 | +# transform the insn into the A32 version first. | 144 | +#include "hw/qdev-properties.h" |
107 | diff --git a/target/arm/neon-shared.decode b/target/arm/neon-shared.decode | 145 | + |
146 | +#define MR_SIZE 0xC00 | ||
147 | + | ||
148 | +static uint64_t efuse_cache_read(void *opaque, hwaddr addr, unsigned size) | ||
149 | +{ | ||
150 | + XlnxVersalEFuseCache *s = XLNX_VERSAL_EFUSE_CACHE(opaque); | ||
151 | + unsigned int w0 = QEMU_ALIGN_DOWN(addr * 8, 32); | ||
152 | + unsigned int w1 = QEMU_ALIGN_DOWN((addr + size - 1) * 8, 32); | ||
153 | + | ||
154 | + uint64_t ret; | ||
155 | + | ||
156 | + assert(w0 == w1 || (w0 + 32) == w1); | ||
157 | + | ||
158 | + ret = xlnx_versal_efuse_read_row(s->efuse, w1, NULL); | ||
159 | + if (w0 < w1) { | ||
160 | + ret <<= 32; | ||
161 | + ret |= xlnx_versal_efuse_read_row(s->efuse, w0, NULL); | ||
162 | + } | ||
163 | + | ||
164 | + /* If 'addr' unaligned, the guest is always assumed to be little-endian. */ | ||
165 | + addr &= 3; | ||
166 | + if (addr) { | ||
167 | + ret >>= 8 * addr; | ||
168 | + } | ||
169 | + | ||
170 | + return ret; | ||
171 | +} | ||
172 | + | ||
173 | +static void efuse_cache_write(void *opaque, hwaddr addr, uint64_t value, | ||
174 | + unsigned size) | ||
175 | +{ | ||
176 | + /* No Register Writes allowed */ | ||
177 | + qemu_log_mask(LOG_GUEST_ERROR, "%s: efuse cache registers are read-only", | ||
178 | + __func__); | ||
179 | +} | ||
180 | + | ||
181 | +static const MemoryRegionOps efuse_cache_ops = { | ||
182 | + .read = efuse_cache_read, | ||
183 | + .write = efuse_cache_write, | ||
184 | + .endianness = DEVICE_LITTLE_ENDIAN, | ||
185 | + .valid = { | ||
186 | + .min_access_size = 1, | ||
187 | + .max_access_size = 4, | ||
188 | + }, | ||
189 | +}; | ||
190 | + | ||
191 | +static void efuse_cache_init(Object *obj) | ||
192 | +{ | ||
193 | + XlnxVersalEFuseCache *s = XLNX_VERSAL_EFUSE_CACHE(obj); | ||
194 | + SysBusDevice *sbd = SYS_BUS_DEVICE(obj); | ||
195 | + | ||
196 | + memory_region_init_io(&s->iomem, obj, &efuse_cache_ops, s, | ||
197 | + TYPE_XLNX_VERSAL_EFUSE_CACHE, MR_SIZE); | ||
198 | + sysbus_init_mmio(sbd, &s->iomem); | ||
199 | +} | ||
200 | + | ||
201 | +static Property efuse_cache_props[] = { | ||
202 | + DEFINE_PROP_LINK("efuse", | ||
203 | + XlnxVersalEFuseCache, efuse, | ||
204 | + TYPE_XLNX_EFUSE, XlnxEFuse *), | ||
205 | + | ||
206 | + DEFINE_PROP_END_OF_LIST(), | ||
207 | +}; | ||
208 | + | ||
209 | +static void efuse_cache_class_init(ObjectClass *klass, void *data) | ||
210 | +{ | ||
211 | + DeviceClass *dc = DEVICE_CLASS(klass); | ||
212 | + | ||
213 | + device_class_set_props(dc, efuse_cache_props); | ||
214 | +} | ||
215 | + | ||
216 | +static const TypeInfo efuse_cache_info = { | ||
217 | + .name = TYPE_XLNX_VERSAL_EFUSE_CACHE, | ||
218 | + .parent = TYPE_SYS_BUS_DEVICE, | ||
219 | + .instance_size = sizeof(XlnxVersalEFuseCache), | ||
220 | + .class_init = efuse_cache_class_init, | ||
221 | + .instance_init = efuse_cache_init, | ||
222 | +}; | ||
223 | + | ||
224 | +static void efuse_cache_register_types(void) | ||
225 | +{ | ||
226 | + type_register_static(&efuse_cache_info); | ||
227 | +} | ||
228 | + | ||
229 | +type_init(efuse_cache_register_types) | ||
230 | diff --git a/hw/nvram/xlnx-versal-efuse-ctrl.c b/hw/nvram/xlnx-versal-efuse-ctrl.c | ||
108 | new file mode 100644 | 231 | new file mode 100644 |
109 | index XXXXXXX..XXXXXXX | 232 | index XXXXXXX..XXXXXXX |
110 | --- /dev/null | 233 | --- /dev/null |
111 | +++ b/target/arm/neon-shared.decode | 234 | +++ b/hw/nvram/xlnx-versal-efuse-ctrl.c |
112 | @@ -XXX,XX +XXX,XX @@ | ||
113 | +# AArch32 Neon instruction descriptions | ||
114 | +# | ||
115 | +# Copyright (c) 2020 Linaro, Ltd | ||
116 | +# | ||
117 | +# This library is free software; you can redistribute it and/or | ||
118 | +# modify it under the terms of the GNU Lesser General Public | ||
119 | +# License as published by the Free Software Foundation; either | ||
120 | +# version 2 of the License, or (at your option) any later version. | ||
121 | +# | ||
122 | +# This library is distributed in the hope that it will be useful, | ||
123 | +# but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
124 | +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
125 | +# Lesser General Public License for more details. | ||
126 | +# | ||
127 | +# You should have received a copy of the GNU Lesser General Public | ||
128 | +# License along with this library; if not, see <http://www.gnu.org/licenses/>. | ||
129 | + | ||
130 | +# | ||
131 | +# This file is processed by scripts/decodetree.py | ||
132 | +# | ||
133 | + | ||
134 | +# Encodings for Neon instructions whose encoding is the same for | ||
135 | +# both A32 and T32. | ||
136 | + | ||
137 | +# More specifically, this covers: | ||
138 | +# 2reg scalar ext: 0b1111_1110_xxxx_xxxx_xxxx_1x0x_xxxx_xxxx | ||
139 | +# 3same ext: 0b1111_110x_xxxx_xxxx_xxxx_1x0x_xxxx_xxxx | ||
140 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
141 | new file mode 100644 | ||
142 | index XXXXXXX..XXXXXXX | ||
143 | --- /dev/null | ||
144 | +++ b/target/arm/translate-neon.inc.c | ||
145 | @@ -XXX,XX +XXX,XX @@ | 235 | @@ -XXX,XX +XXX,XX @@ |
146 | +/* | 236 | +/* |
147 | + * ARM translation: AArch32 Neon instructions | 237 | + * QEMU model of the Versal eFuse controller |
148 | + * | 238 | + * |
149 | + * Copyright (c) 2003 Fabrice Bellard | 239 | + * Copyright (c) 2020 Xilinx Inc. |
150 | + * Copyright (c) 2005-2007 CodeSourcery | 240 | + * |
151 | + * Copyright (c) 2007 OpenedHand, Ltd. | 241 | + * Permission is hereby granted, free of charge, to any person obtaining a copy |
152 | + * Copyright (c) 2020 Linaro, Ltd. | 242 | + * of this software and associated documentation files (the "Software"), to deal |
153 | + * | 243 | + * in the Software without restriction, including without limitation the rights |
154 | + * This library is free software; you can redistribute it and/or | 244 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
155 | + * modify it under the terms of the GNU Lesser General Public | 245 | + * copies of the Software, and to permit persons to whom the Software is |
156 | + * License as published by the Free Software Foundation; either | 246 | + * furnished to do so, subject to the following conditions: |
157 | + * version 2 of the License, or (at your option) any later version. | 247 | + * |
158 | + * | 248 | + * The above copyright notice and this permission notice shall be included in |
159 | + * This library is distributed in the hope that it will be useful, | 249 | + * all copies or substantial portions of the Software. |
160 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of | 250 | + * |
161 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 251 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
162 | + * Lesser General Public License for more details. | 252 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
163 | + * | 253 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
164 | + * You should have received a copy of the GNU Lesser General Public | 254 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
165 | + * License along with this library; if not, see <http://www.gnu.org/licenses/>. | 255 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
256 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
257 | + * THE SOFTWARE. | ||
166 | + */ | 258 | + */ |
167 | + | 259 | + |
260 | +#include "qemu/osdep.h" | ||
261 | +#include "hw/nvram/xlnx-versal-efuse.h" | ||
262 | + | ||
263 | +#include "qemu/log.h" | ||
264 | +#include "qapi/error.h" | ||
265 | +#include "migration/vmstate.h" | ||
266 | +#include "hw/qdev-properties.h" | ||
267 | + | ||
268 | +#ifndef XLNX_VERSAL_EFUSE_CTRL_ERR_DEBUG | ||
269 | +#define XLNX_VERSAL_EFUSE_CTRL_ERR_DEBUG 0 | ||
270 | +#endif | ||
271 | + | ||
272 | +REG32(WR_LOCK, 0x0) | ||
273 | + FIELD(WR_LOCK, LOCK, 0, 16) | ||
274 | +REG32(CFG, 0x4) | ||
275 | + FIELD(CFG, SLVERR_ENABLE, 5, 1) | ||
276 | + FIELD(CFG, MARGIN_RD, 2, 1) | ||
277 | + FIELD(CFG, PGM_EN, 1, 1) | ||
278 | +REG32(STATUS, 0x8) | ||
279 | + FIELD(STATUS, AES_USER_KEY_1_CRC_PASS, 11, 1) | ||
280 | + FIELD(STATUS, AES_USER_KEY_1_CRC_DONE, 10, 1) | ||
281 | + FIELD(STATUS, AES_USER_KEY_0_CRC_PASS, 9, 1) | ||
282 | + FIELD(STATUS, AES_USER_KEY_0_CRC_DONE, 8, 1) | ||
283 | + FIELD(STATUS, AES_CRC_PASS, 7, 1) | ||
284 | + FIELD(STATUS, AES_CRC_DONE, 6, 1) | ||
285 | + FIELD(STATUS, CACHE_DONE, 5, 1) | ||
286 | + FIELD(STATUS, CACHE_LOAD, 4, 1) | ||
287 | + FIELD(STATUS, EFUSE_2_TBIT, 2, 1) | ||
288 | + FIELD(STATUS, EFUSE_1_TBIT, 1, 1) | ||
289 | + FIELD(STATUS, EFUSE_0_TBIT, 0, 1) | ||
290 | +REG32(EFUSE_PGM_ADDR, 0xc) | ||
291 | + FIELD(EFUSE_PGM_ADDR, PAGE, 13, 4) | ||
292 | + FIELD(EFUSE_PGM_ADDR, ROW, 5, 8) | ||
293 | + FIELD(EFUSE_PGM_ADDR, COLUMN, 0, 5) | ||
294 | +REG32(EFUSE_RD_ADDR, 0x10) | ||
295 | + FIELD(EFUSE_RD_ADDR, PAGE, 13, 4) | ||
296 | + FIELD(EFUSE_RD_ADDR, ROW, 5, 8) | ||
297 | +REG32(EFUSE_RD_DATA, 0x14) | ||
298 | +REG32(TPGM, 0x18) | ||
299 | + FIELD(TPGM, VALUE, 0, 16) | ||
300 | +REG32(TRD, 0x1c) | ||
301 | + FIELD(TRD, VALUE, 0, 8) | ||
302 | +REG32(TSU_H_PS, 0x20) | ||
303 | + FIELD(TSU_H_PS, VALUE, 0, 8) | ||
304 | +REG32(TSU_H_PS_CS, 0x24) | ||
305 | + FIELD(TSU_H_PS_CS, VALUE, 0, 8) | ||
306 | +REG32(TRDM, 0x28) | ||
307 | + FIELD(TRDM, VALUE, 0, 8) | ||
308 | +REG32(TSU_H_CS, 0x2c) | ||
309 | + FIELD(TSU_H_CS, VALUE, 0, 8) | ||
310 | +REG32(EFUSE_ISR, 0x30) | ||
311 | + FIELD(EFUSE_ISR, APB_SLVERR, 31, 1) | ||
312 | + FIELD(EFUSE_ISR, CACHE_PARITY_E2, 14, 1) | ||
313 | + FIELD(EFUSE_ISR, CACHE_PARITY_E1, 13, 1) | ||
314 | + FIELD(EFUSE_ISR, CACHE_PARITY_E0S, 12, 1) | ||
315 | + FIELD(EFUSE_ISR, CACHE_PARITY_E0R, 11, 1) | ||
316 | + FIELD(EFUSE_ISR, CACHE_APB_SLVERR, 10, 1) | ||
317 | + FIELD(EFUSE_ISR, CACHE_REQ_ERROR, 9, 1) | ||
318 | + FIELD(EFUSE_ISR, MAIN_REQ_ERROR, 8, 1) | ||
319 | + FIELD(EFUSE_ISR, READ_ON_CACHE_LD, 7, 1) | ||
320 | + FIELD(EFUSE_ISR, CACHE_FSM_ERROR, 6, 1) | ||
321 | + FIELD(EFUSE_ISR, MAIN_FSM_ERROR, 5, 1) | ||
322 | + FIELD(EFUSE_ISR, CACHE_ERROR, 4, 1) | ||
323 | + FIELD(EFUSE_ISR, RD_ERROR, 3, 1) | ||
324 | + FIELD(EFUSE_ISR, RD_DONE, 2, 1) | ||
325 | + FIELD(EFUSE_ISR, PGM_ERROR, 1, 1) | ||
326 | + FIELD(EFUSE_ISR, PGM_DONE, 0, 1) | ||
327 | +REG32(EFUSE_IMR, 0x34) | ||
328 | + FIELD(EFUSE_IMR, APB_SLVERR, 31, 1) | ||
329 | + FIELD(EFUSE_IMR, CACHE_PARITY_E2, 14, 1) | ||
330 | + FIELD(EFUSE_IMR, CACHE_PARITY_E1, 13, 1) | ||
331 | + FIELD(EFUSE_IMR, CACHE_PARITY_E0S, 12, 1) | ||
332 | + FIELD(EFUSE_IMR, CACHE_PARITY_E0R, 11, 1) | ||
333 | + FIELD(EFUSE_IMR, CACHE_APB_SLVERR, 10, 1) | ||
334 | + FIELD(EFUSE_IMR, CACHE_REQ_ERROR, 9, 1) | ||
335 | + FIELD(EFUSE_IMR, MAIN_REQ_ERROR, 8, 1) | ||
336 | + FIELD(EFUSE_IMR, READ_ON_CACHE_LD, 7, 1) | ||
337 | + FIELD(EFUSE_IMR, CACHE_FSM_ERROR, 6, 1) | ||
338 | + FIELD(EFUSE_IMR, MAIN_FSM_ERROR, 5, 1) | ||
339 | + FIELD(EFUSE_IMR, CACHE_ERROR, 4, 1) | ||
340 | + FIELD(EFUSE_IMR, RD_ERROR, 3, 1) | ||
341 | + FIELD(EFUSE_IMR, RD_DONE, 2, 1) | ||
342 | + FIELD(EFUSE_IMR, PGM_ERROR, 1, 1) | ||
343 | + FIELD(EFUSE_IMR, PGM_DONE, 0, 1) | ||
344 | +REG32(EFUSE_IER, 0x38) | ||
345 | + FIELD(EFUSE_IER, APB_SLVERR, 31, 1) | ||
346 | + FIELD(EFUSE_IER, CACHE_PARITY_E2, 14, 1) | ||
347 | + FIELD(EFUSE_IER, CACHE_PARITY_E1, 13, 1) | ||
348 | + FIELD(EFUSE_IER, CACHE_PARITY_E0S, 12, 1) | ||
349 | + FIELD(EFUSE_IER, CACHE_PARITY_E0R, 11, 1) | ||
350 | + FIELD(EFUSE_IER, CACHE_APB_SLVERR, 10, 1) | ||
351 | + FIELD(EFUSE_IER, CACHE_REQ_ERROR, 9, 1) | ||
352 | + FIELD(EFUSE_IER, MAIN_REQ_ERROR, 8, 1) | ||
353 | + FIELD(EFUSE_IER, READ_ON_CACHE_LD, 7, 1) | ||
354 | + FIELD(EFUSE_IER, CACHE_FSM_ERROR, 6, 1) | ||
355 | + FIELD(EFUSE_IER, MAIN_FSM_ERROR, 5, 1) | ||
356 | + FIELD(EFUSE_IER, CACHE_ERROR, 4, 1) | ||
357 | + FIELD(EFUSE_IER, RD_ERROR, 3, 1) | ||
358 | + FIELD(EFUSE_IER, RD_DONE, 2, 1) | ||
359 | + FIELD(EFUSE_IER, PGM_ERROR, 1, 1) | ||
360 | + FIELD(EFUSE_IER, PGM_DONE, 0, 1) | ||
361 | +REG32(EFUSE_IDR, 0x3c) | ||
362 | + FIELD(EFUSE_IDR, APB_SLVERR, 31, 1) | ||
363 | + FIELD(EFUSE_IDR, CACHE_PARITY_E2, 14, 1) | ||
364 | + FIELD(EFUSE_IDR, CACHE_PARITY_E1, 13, 1) | ||
365 | + FIELD(EFUSE_IDR, CACHE_PARITY_E0S, 12, 1) | ||
366 | + FIELD(EFUSE_IDR, CACHE_PARITY_E0R, 11, 1) | ||
367 | + FIELD(EFUSE_IDR, CACHE_APB_SLVERR, 10, 1) | ||
368 | + FIELD(EFUSE_IDR, CACHE_REQ_ERROR, 9, 1) | ||
369 | + FIELD(EFUSE_IDR, MAIN_REQ_ERROR, 8, 1) | ||
370 | + FIELD(EFUSE_IDR, READ_ON_CACHE_LD, 7, 1) | ||
371 | + FIELD(EFUSE_IDR, CACHE_FSM_ERROR, 6, 1) | ||
372 | + FIELD(EFUSE_IDR, MAIN_FSM_ERROR, 5, 1) | ||
373 | + FIELD(EFUSE_IDR, CACHE_ERROR, 4, 1) | ||
374 | + FIELD(EFUSE_IDR, RD_ERROR, 3, 1) | ||
375 | + FIELD(EFUSE_IDR, RD_DONE, 2, 1) | ||
376 | + FIELD(EFUSE_IDR, PGM_ERROR, 1, 1) | ||
377 | + FIELD(EFUSE_IDR, PGM_DONE, 0, 1) | ||
378 | +REG32(EFUSE_CACHE_LOAD, 0x40) | ||
379 | + FIELD(EFUSE_CACHE_LOAD, LOAD, 0, 1) | ||
380 | +REG32(EFUSE_PGM_LOCK, 0x44) | ||
381 | + FIELD(EFUSE_PGM_LOCK, SPK_ID_LOCK, 0, 1) | ||
382 | +REG32(EFUSE_AES_CRC, 0x48) | ||
383 | +REG32(EFUSE_AES_USR_KEY0_CRC, 0x4c) | ||
384 | +REG32(EFUSE_AES_USR_KEY1_CRC, 0x50) | ||
385 | +REG32(EFUSE_PD, 0x54) | ||
386 | +REG32(EFUSE_ANLG_OSC_SW_1LP, 0x60) | ||
387 | +REG32(EFUSE_TEST_CTRL, 0x100) | ||
388 | + | ||
389 | +#define R_MAX (R_EFUSE_TEST_CTRL + 1) | ||
390 | + | ||
391 | +#define R_WR_LOCK_UNLOCK_PASSCODE (0xDF0D) | ||
392 | + | ||
168 | +/* | 393 | +/* |
169 | + * This file is intended to be included from translate.c; it uses | 394 | + * eFuse layout references: |
170 | + * some macros and definitions provided by that file. | 395 | + * https://github.com/Xilinx/embeddedsw/blob/release-2019.2/lib/sw_services/xilnvm/src/xnvm_efuse_hw.h |
171 | + * It might be possible to convert it to a standalone .c file eventually. | ||
172 | + */ | 396 | + */ |
173 | + | 397 | +#define BIT_POS_OF(A_) \ |
174 | +/* Include the generated Neon decoder */ | 398 | + ((uint32_t)((A_) & (R_EFUSE_PGM_ADDR_ROW_MASK | \ |
175 | +#include "decode-neon-dp.inc.c" | 399 | + R_EFUSE_PGM_ADDR_COLUMN_MASK))) |
176 | +#include "decode-neon-ls.inc.c" | 400 | + |
177 | +#include "decode-neon-shared.inc.c" | 401 | +#define BIT_POS(R_, C_) \ |
178 | diff --git a/target/arm/translate.c b/target/arm/translate.c | 402 | + ((uint32_t)((R_EFUSE_PGM_ADDR_ROW_MASK \ |
403 | + & ((R_) << R_EFUSE_PGM_ADDR_ROW_SHIFT)) \ | ||
404 | + | \ | ||
405 | + (R_EFUSE_PGM_ADDR_COLUMN_MASK \ | ||
406 | + & ((C_) << R_EFUSE_PGM_ADDR_COLUMN_SHIFT)))) | ||
407 | + | ||
408 | +#define EFUSE_TBIT_POS(A_) (BIT_POS_OF(A_) >= BIT_POS(0, 28)) | ||
409 | + | ||
410 | +#define EFUSE_ANCHOR_ROW (0) | ||
411 | +#define EFUSE_ANCHOR_3_COL (27) | ||
412 | +#define EFUSE_ANCHOR_1_COL (1) | ||
413 | + | ||
414 | +#define EFUSE_AES_KEY_START BIT_POS(12, 0) | ||
415 | +#define EFUSE_AES_KEY_END BIT_POS(19, 31) | ||
416 | +#define EFUSE_USER_KEY_0_START BIT_POS(20, 0) | ||
417 | +#define EFUSE_USER_KEY_0_END BIT_POS(27, 31) | ||
418 | +#define EFUSE_USER_KEY_1_START BIT_POS(28, 0) | ||
419 | +#define EFUSE_USER_KEY_1_END BIT_POS(35, 31) | ||
420 | + | ||
421 | +#define EFUSE_RD_BLOCKED_START EFUSE_AES_KEY_START | ||
422 | +#define EFUSE_RD_BLOCKED_END EFUSE_USER_KEY_1_END | ||
423 | + | ||
424 | +#define EFUSE_GLITCH_DET_WR_LK BIT_POS(4, 31) | ||
425 | +#define EFUSE_PPK0_WR_LK BIT_POS(43, 6) | ||
426 | +#define EFUSE_PPK1_WR_LK BIT_POS(43, 7) | ||
427 | +#define EFUSE_PPK2_WR_LK BIT_POS(43, 8) | ||
428 | +#define EFUSE_AES_WR_LK BIT_POS(43, 11) | ||
429 | +#define EFUSE_USER_KEY_0_WR_LK BIT_POS(43, 13) | ||
430 | +#define EFUSE_USER_KEY_1_WR_LK BIT_POS(43, 15) | ||
431 | +#define EFUSE_PUF_SYN_LK BIT_POS(43, 16) | ||
432 | +#define EFUSE_DNA_WR_LK BIT_POS(43, 27) | ||
433 | +#define EFUSE_BOOT_ENV_WR_LK BIT_POS(43, 28) | ||
434 | + | ||
435 | +#define EFUSE_PGM_LOCKED_START BIT_POS(44, 0) | ||
436 | +#define EFUSE_PGM_LOCKED_END BIT_POS(51, 31) | ||
437 | + | ||
438 | +#define EFUSE_PUF_PAGE (2) | ||
439 | +#define EFUSE_PUF_SYN_START BIT_POS(129, 0) | ||
440 | +#define EFUSE_PUF_SYN_END BIT_POS(255, 27) | ||
441 | + | ||
442 | +#define EFUSE_KEY_CRC_LK_ROW (43) | ||
443 | +#define EFUSE_AES_KEY_CRC_LK_MASK ((1U << 9) | (1U << 10)) | ||
444 | +#define EFUSE_USER_KEY_0_CRC_LK_MASK (1U << 12) | ||
445 | +#define EFUSE_USER_KEY_1_CRC_LK_MASK (1U << 14) | ||
446 | + | ||
447 | +/* | ||
448 | + * A handy macro to return value of an array element, | ||
449 | + * or a specific default if given index is out of bound. | ||
450 | + */ | ||
451 | +#define ARRAY_GET(A_, I_, D_) \ | ||
452 | + ((unsigned int)(I_) < ARRAY_SIZE(A_) ? (A_)[I_] : (D_)) | ||
453 | + | ||
454 | +QEMU_BUILD_BUG_ON(R_MAX != ARRAY_SIZE(((XlnxVersalEFuseCtrl *)0)->regs)); | ||
455 | + | ||
456 | +typedef struct XlnxEFuseLkSpec { | ||
457 | + uint16_t row; | ||
458 | + uint16_t lk_bit; | ||
459 | +} XlnxEFuseLkSpec; | ||
460 | + | ||
461 | +static void efuse_imr_update_irq(XlnxVersalEFuseCtrl *s) | ||
462 | +{ | ||
463 | + bool pending = s->regs[R_EFUSE_ISR] & ~s->regs[R_EFUSE_IMR]; | ||
464 | + qemu_set_irq(s->irq_efuse_imr, pending); | ||
465 | +} | ||
466 | + | ||
467 | +static void efuse_isr_postw(RegisterInfo *reg, uint64_t val64) | ||
468 | +{ | ||
469 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(reg->opaque); | ||
470 | + efuse_imr_update_irq(s); | ||
471 | +} | ||
472 | + | ||
473 | +static uint64_t efuse_ier_prew(RegisterInfo *reg, uint64_t val64) | ||
474 | +{ | ||
475 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(reg->opaque); | ||
476 | + uint32_t val = val64; | ||
477 | + | ||
478 | + s->regs[R_EFUSE_IMR] &= ~val; | ||
479 | + efuse_imr_update_irq(s); | ||
480 | + return 0; | ||
481 | +} | ||
482 | + | ||
483 | +static uint64_t efuse_idr_prew(RegisterInfo *reg, uint64_t val64) | ||
484 | +{ | ||
485 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(reg->opaque); | ||
486 | + uint32_t val = val64; | ||
487 | + | ||
488 | + s->regs[R_EFUSE_IMR] |= val; | ||
489 | + efuse_imr_update_irq(s); | ||
490 | + return 0; | ||
491 | +} | ||
492 | + | ||
493 | +static void efuse_status_tbits_sync(XlnxVersalEFuseCtrl *s) | ||
494 | +{ | ||
495 | + uint32_t check = xlnx_efuse_tbits_check(s->efuse); | ||
496 | + uint32_t val = s->regs[R_STATUS]; | ||
497 | + | ||
498 | + val = FIELD_DP32(val, STATUS, EFUSE_0_TBIT, !!(check & (1 << 0))); | ||
499 | + val = FIELD_DP32(val, STATUS, EFUSE_1_TBIT, !!(check & (1 << 1))); | ||
500 | + val = FIELD_DP32(val, STATUS, EFUSE_2_TBIT, !!(check & (1 << 2))); | ||
501 | + | ||
502 | + s->regs[R_STATUS] = val; | ||
503 | +} | ||
504 | + | ||
505 | +static void efuse_anchor_bits_check(XlnxVersalEFuseCtrl *s) | ||
506 | +{ | ||
507 | + unsigned page; | ||
508 | + | ||
509 | + if (!s->efuse || !s->efuse->init_tbits) { | ||
510 | + return; | ||
511 | + } | ||
512 | + | ||
513 | + for (page = 0; page < s->efuse->efuse_nr; page++) { | ||
514 | + uint32_t row = 0, bit; | ||
515 | + | ||
516 | + row = FIELD_DP32(row, EFUSE_PGM_ADDR, PAGE, page); | ||
517 | + row = FIELD_DP32(row, EFUSE_PGM_ADDR, ROW, EFUSE_ANCHOR_ROW); | ||
518 | + | ||
519 | + bit = FIELD_DP32(row, EFUSE_PGM_ADDR, COLUMN, EFUSE_ANCHOR_3_COL); | ||
520 | + if (!xlnx_efuse_get_bit(s->efuse, bit)) { | ||
521 | + xlnx_efuse_set_bit(s->efuse, bit); | ||
522 | + } | ||
523 | + | ||
524 | + bit = FIELD_DP32(row, EFUSE_PGM_ADDR, COLUMN, EFUSE_ANCHOR_1_COL); | ||
525 | + if (!xlnx_efuse_get_bit(s->efuse, bit)) { | ||
526 | + xlnx_efuse_set_bit(s->efuse, bit); | ||
527 | + } | ||
528 | + } | ||
529 | +} | ||
530 | + | ||
531 | +static void efuse_key_crc_check(RegisterInfo *reg, uint32_t crc, | ||
532 | + uint32_t pass_mask, uint32_t done_mask, | ||
533 | + unsigned first, uint32_t lk_mask) | ||
534 | +{ | ||
535 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(reg->opaque); | ||
536 | + uint32_t r, lk_bits; | ||
537 | + | ||
538 | + /* | ||
539 | + * To start, assume both DONE and PASS, and clear PASS by xor | ||
540 | + * if CRC-check fails or CRC-check disabled by lock fuse. | ||
541 | + */ | ||
542 | + r = s->regs[R_STATUS] | done_mask | pass_mask; | ||
543 | + | ||
544 | + lk_bits = xlnx_efuse_get_row(s->efuse, EFUSE_KEY_CRC_LK_ROW) & lk_mask; | ||
545 | + if (lk_bits == 0 && xlnx_efuse_k256_check(s->efuse, crc, first)) { | ||
546 | + pass_mask = 0; | ||
547 | + } | ||
548 | + | ||
549 | + s->regs[R_STATUS] = r ^ pass_mask; | ||
550 | +} | ||
551 | + | ||
552 | +static void efuse_data_sync(XlnxVersalEFuseCtrl *s) | ||
553 | +{ | ||
554 | + efuse_status_tbits_sync(s); | ||
555 | +} | ||
556 | + | ||
557 | +static int efuse_lk_spec_cmp(const void *a, const void *b) | ||
558 | +{ | ||
559 | + uint16_t r1 = ((const XlnxEFuseLkSpec *)a)->row; | ||
560 | + uint16_t r2 = ((const XlnxEFuseLkSpec *)b)->row; | ||
561 | + | ||
562 | + return (r1 > r2) - (r1 < r2); | ||
563 | +} | ||
564 | + | ||
565 | +static void efuse_lk_spec_sort(XlnxVersalEFuseCtrl *s) | ||
566 | +{ | ||
567 | + XlnxEFuseLkSpec *ary = s->extra_pg0_lock_spec; | ||
568 | + const uint32_t n8 = s->extra_pg0_lock_n16 * 2; | ||
569 | + const uint32_t sz = sizeof(ary[0]); | ||
570 | + const uint32_t cnt = n8 / sz; | ||
571 | + | ||
572 | + if (ary && cnt) { | ||
573 | + qsort(ary, cnt, sz, efuse_lk_spec_cmp); | ||
574 | + } | ||
575 | +} | ||
576 | + | ||
577 | +static uint32_t efuse_lk_spec_find(XlnxVersalEFuseCtrl *s, uint32_t row) | ||
578 | +{ | ||
579 | + const XlnxEFuseLkSpec *ary = s->extra_pg0_lock_spec; | ||
580 | + const uint32_t n8 = s->extra_pg0_lock_n16 * 2; | ||
581 | + const uint32_t sz = sizeof(ary[0]); | ||
582 | + const uint32_t cnt = n8 / sz; | ||
583 | + const XlnxEFuseLkSpec *item = NULL; | ||
584 | + | ||
585 | + if (ary && cnt) { | ||
586 | + XlnxEFuseLkSpec k = { .row = row, }; | ||
587 | + | ||
588 | + item = bsearch(&k, ary, cnt, sz, efuse_lk_spec_cmp); | ||
589 | + } | ||
590 | + | ||
591 | + return item ? item->lk_bit : 0; | ||
592 | +} | ||
593 | + | ||
594 | +static uint32_t efuse_bit_locked(XlnxVersalEFuseCtrl *s, uint32_t bit) | ||
595 | +{ | ||
596 | + /* Hard-coded locks */ | ||
597 | + static const uint16_t pg0_hard_lock[] = { | ||
598 | + [4] = EFUSE_GLITCH_DET_WR_LK, | ||
599 | + [37] = EFUSE_BOOT_ENV_WR_LK, | ||
600 | + | ||
601 | + [8 ... 11] = EFUSE_DNA_WR_LK, | ||
602 | + [12 ... 19] = EFUSE_AES_WR_LK, | ||
603 | + [20 ... 27] = EFUSE_USER_KEY_0_WR_LK, | ||
604 | + [28 ... 35] = EFUSE_USER_KEY_1_WR_LK, | ||
605 | + [64 ... 71] = EFUSE_PPK0_WR_LK, | ||
606 | + [72 ... 79] = EFUSE_PPK1_WR_LK, | ||
607 | + [80 ... 87] = EFUSE_PPK2_WR_LK, | ||
608 | + }; | ||
609 | + | ||
610 | + uint32_t row = FIELD_EX32(bit, EFUSE_PGM_ADDR, ROW); | ||
611 | + uint32_t lk_bit = ARRAY_GET(pg0_hard_lock, row, 0); | ||
612 | + | ||
613 | + return lk_bit ? lk_bit : efuse_lk_spec_find(s, row); | ||
614 | +} | ||
615 | + | ||
616 | +static bool efuse_pgm_locked(XlnxVersalEFuseCtrl *s, unsigned int bit) | ||
617 | +{ | ||
618 | + | ||
619 | + unsigned int lock = 1; | ||
620 | + | ||
621 | + /* Global lock */ | ||
622 | + if (!ARRAY_FIELD_EX32(s->regs, CFG, PGM_EN)) { | ||
623 | + goto ret_lock; | ||
624 | + } | ||
625 | + | ||
626 | + /* Row lock */ | ||
627 | + switch (FIELD_EX32(bit, EFUSE_PGM_ADDR, PAGE)) { | ||
628 | + case 0: | ||
629 | + if (ARRAY_FIELD_EX32(s->regs, EFUSE_PGM_LOCK, SPK_ID_LOCK) && | ||
630 | + bit >= EFUSE_PGM_LOCKED_START && bit <= EFUSE_PGM_LOCKED_END) { | ||
631 | + goto ret_lock; | ||
632 | + } | ||
633 | + | ||
634 | + lock = efuse_bit_locked(s, bit); | ||
635 | + break; | ||
636 | + case EFUSE_PUF_PAGE: | ||
637 | + if (bit < EFUSE_PUF_SYN_START || bit > EFUSE_PUF_SYN_END) { | ||
638 | + lock = 0; | ||
639 | + goto ret_lock; | ||
640 | + } | ||
641 | + | ||
642 | + lock = EFUSE_PUF_SYN_LK; | ||
643 | + break; | ||
644 | + default: | ||
645 | + lock = 0; | ||
646 | + goto ret_lock; | ||
647 | + } | ||
648 | + | ||
649 | + /* Row lock by an efuse bit */ | ||
650 | + if (lock) { | ||
651 | + lock = xlnx_efuse_get_bit(s->efuse, lock); | ||
652 | + } | ||
653 | + | ||
654 | + ret_lock: | ||
655 | + return lock != 0; | ||
656 | +} | ||
657 | + | ||
658 | +static void efuse_pgm_addr_postw(RegisterInfo *reg, uint64_t val64) | ||
659 | +{ | ||
660 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(reg->opaque); | ||
661 | + unsigned bit = val64; | ||
662 | + bool ok = false; | ||
663 | + | ||
664 | + /* Always zero out PGM_ADDR because it is write-only */ | ||
665 | + s->regs[R_EFUSE_PGM_ADDR] = 0; | ||
666 | + | ||
667 | + /* | ||
668 | + * Indicate error if bit is write-protected (or read-only | ||
669 | + * as guarded by efuse_set_bit()). | ||
670 | + * | ||
671 | + * Keep it simple by not modeling program timing. | ||
672 | + * | ||
673 | + * Note: model must NEVER clear the PGM_ERROR bit; it is | ||
674 | + * up to guest to do so (or by reset). | ||
675 | + */ | ||
676 | + if (efuse_pgm_locked(s, bit)) { | ||
677 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
678 | + "%s: Denied setting of efuse<%u, %u, %u>\n", | ||
679 | + object_get_canonical_path(OBJECT(s)), | ||
680 | + FIELD_EX32(bit, EFUSE_PGM_ADDR, PAGE), | ||
681 | + FIELD_EX32(bit, EFUSE_PGM_ADDR, ROW), | ||
682 | + FIELD_EX32(bit, EFUSE_PGM_ADDR, COLUMN)); | ||
683 | + } else if (xlnx_efuse_set_bit(s->efuse, bit)) { | ||
684 | + ok = true; | ||
685 | + if (EFUSE_TBIT_POS(bit)) { | ||
686 | + efuse_status_tbits_sync(s); | ||
687 | + } | ||
688 | + } | ||
689 | + | ||
690 | + if (!ok) { | ||
691 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, PGM_ERROR, 1); | ||
692 | + } | ||
693 | + | ||
694 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, PGM_DONE, 1); | ||
695 | + efuse_imr_update_irq(s); | ||
696 | +} | ||
697 | + | ||
698 | +static void efuse_rd_addr_postw(RegisterInfo *reg, uint64_t val64) | ||
699 | +{ | ||
700 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(reg->opaque); | ||
701 | + unsigned bit = val64; | ||
702 | + bool denied; | ||
703 | + | ||
704 | + /* Always zero out RD_ADDR because it is write-only */ | ||
705 | + s->regs[R_EFUSE_RD_ADDR] = 0; | ||
706 | + | ||
707 | + /* | ||
708 | + * Indicate error if row is read-blocked. | ||
709 | + * | ||
710 | + * Note: model must NEVER clear the RD_ERROR bit; it is | ||
711 | + * up to guest to do so (or by reset). | ||
712 | + */ | ||
713 | + s->regs[R_EFUSE_RD_DATA] = xlnx_versal_efuse_read_row(s->efuse, | ||
714 | + bit, &denied); | ||
715 | + if (denied) { | ||
716 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
717 | + "%s: Denied reading of efuse<%u, %u>\n", | ||
718 | + object_get_canonical_path(OBJECT(s)), | ||
719 | + FIELD_EX32(bit, EFUSE_RD_ADDR, PAGE), | ||
720 | + FIELD_EX32(bit, EFUSE_RD_ADDR, ROW)); | ||
721 | + | ||
722 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, RD_ERROR, 1); | ||
723 | + } | ||
724 | + | ||
725 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, RD_DONE, 1); | ||
726 | + efuse_imr_update_irq(s); | ||
727 | + return; | ||
728 | +} | ||
729 | + | ||
730 | +static uint64_t efuse_cache_load_prew(RegisterInfo *reg, uint64_t val64) | ||
731 | +{ | ||
732 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(reg->opaque); | ||
733 | + | ||
734 | + if (val64 & R_EFUSE_CACHE_LOAD_LOAD_MASK) { | ||
735 | + efuse_data_sync(s); | ||
736 | + | ||
737 | + ARRAY_FIELD_DP32(s->regs, STATUS, CACHE_DONE, 1); | ||
738 | + efuse_imr_update_irq(s); | ||
739 | + } | ||
740 | + | ||
741 | + return 0; | ||
742 | +} | ||
743 | + | ||
744 | +static uint64_t efuse_pgm_lock_prew(RegisterInfo *reg, uint64_t val64) | ||
745 | +{ | ||
746 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(reg->opaque); | ||
747 | + | ||
748 | + /* Ignore all other bits */ | ||
749 | + val64 = FIELD_EX32(val64, EFUSE_PGM_LOCK, SPK_ID_LOCK); | ||
750 | + | ||
751 | + /* Once the bit is written 1, only reset will clear it to 0 */ | ||
752 | + val64 |= ARRAY_FIELD_EX32(s->regs, EFUSE_PGM_LOCK, SPK_ID_LOCK); | ||
753 | + | ||
754 | + return val64; | ||
755 | +} | ||
756 | + | ||
757 | +static void efuse_aes_crc_postw(RegisterInfo *reg, uint64_t val64) | ||
758 | +{ | ||
759 | + efuse_key_crc_check(reg, val64, | ||
760 | + R_STATUS_AES_CRC_PASS_MASK, | ||
761 | + R_STATUS_AES_CRC_DONE_MASK, | ||
762 | + EFUSE_AES_KEY_START, | ||
763 | + EFUSE_AES_KEY_CRC_LK_MASK); | ||
764 | +} | ||
765 | + | ||
766 | +static void efuse_aes_u0_crc_postw(RegisterInfo *reg, uint64_t val64) | ||
767 | +{ | ||
768 | + efuse_key_crc_check(reg, val64, | ||
769 | + R_STATUS_AES_USER_KEY_0_CRC_PASS_MASK, | ||
770 | + R_STATUS_AES_USER_KEY_0_CRC_DONE_MASK, | ||
771 | + EFUSE_USER_KEY_0_START, | ||
772 | + EFUSE_USER_KEY_0_CRC_LK_MASK); | ||
773 | +} | ||
774 | + | ||
775 | +static void efuse_aes_u1_crc_postw(RegisterInfo *reg, uint64_t val64) | ||
776 | +{ | ||
777 | + efuse_key_crc_check(reg, val64, | ||
778 | + R_STATUS_AES_USER_KEY_1_CRC_PASS_MASK, | ||
779 | + R_STATUS_AES_USER_KEY_1_CRC_DONE_MASK, | ||
780 | + EFUSE_USER_KEY_1_START, | ||
781 | + EFUSE_USER_KEY_1_CRC_LK_MASK); | ||
782 | +} | ||
783 | + | ||
784 | +static uint64_t efuse_wr_lock_prew(RegisterInfo *reg, uint64_t val) | ||
785 | +{ | ||
786 | + return val != R_WR_LOCK_UNLOCK_PASSCODE; | ||
787 | +} | ||
788 | + | ||
789 | +static const RegisterAccessInfo efuse_ctrl_regs_info[] = { | ||
790 | + { .name = "WR_LOCK", .addr = A_WR_LOCK, | ||
791 | + .reset = 0x1, | ||
792 | + .pre_write = efuse_wr_lock_prew, | ||
793 | + },{ .name = "CFG", .addr = A_CFG, | ||
794 | + .rsvd = 0x9, | ||
795 | + },{ .name = "STATUS", .addr = A_STATUS, | ||
796 | + .rsvd = 0x8, | ||
797 | + .ro = 0xfff, | ||
798 | + },{ .name = "EFUSE_PGM_ADDR", .addr = A_EFUSE_PGM_ADDR, | ||
799 | + .post_write = efuse_pgm_addr_postw, | ||
800 | + },{ .name = "EFUSE_RD_ADDR", .addr = A_EFUSE_RD_ADDR, | ||
801 | + .rsvd = 0x1f, | ||
802 | + .post_write = efuse_rd_addr_postw, | ||
803 | + },{ .name = "EFUSE_RD_DATA", .addr = A_EFUSE_RD_DATA, | ||
804 | + .ro = 0xffffffff, | ||
805 | + },{ .name = "TPGM", .addr = A_TPGM, | ||
806 | + },{ .name = "TRD", .addr = A_TRD, | ||
807 | + .reset = 0x19, | ||
808 | + },{ .name = "TSU_H_PS", .addr = A_TSU_H_PS, | ||
809 | + .reset = 0xff, | ||
810 | + },{ .name = "TSU_H_PS_CS", .addr = A_TSU_H_PS_CS, | ||
811 | + .reset = 0x11, | ||
812 | + },{ .name = "TRDM", .addr = A_TRDM, | ||
813 | + .reset = 0x3a, | ||
814 | + },{ .name = "TSU_H_CS", .addr = A_TSU_H_CS, | ||
815 | + .reset = 0x16, | ||
816 | + },{ .name = "EFUSE_ISR", .addr = A_EFUSE_ISR, | ||
817 | + .rsvd = 0x7fff8000, | ||
818 | + .w1c = 0x80007fff, | ||
819 | + .post_write = efuse_isr_postw, | ||
820 | + },{ .name = "EFUSE_IMR", .addr = A_EFUSE_IMR, | ||
821 | + .reset = 0x80007fff, | ||
822 | + .rsvd = 0x7fff8000, | ||
823 | + .ro = 0xffffffff, | ||
824 | + },{ .name = "EFUSE_IER", .addr = A_EFUSE_IER, | ||
825 | + .rsvd = 0x7fff8000, | ||
826 | + .pre_write = efuse_ier_prew, | ||
827 | + },{ .name = "EFUSE_IDR", .addr = A_EFUSE_IDR, | ||
828 | + .rsvd = 0x7fff8000, | ||
829 | + .pre_write = efuse_idr_prew, | ||
830 | + },{ .name = "EFUSE_CACHE_LOAD", .addr = A_EFUSE_CACHE_LOAD, | ||
831 | + .pre_write = efuse_cache_load_prew, | ||
832 | + },{ .name = "EFUSE_PGM_LOCK", .addr = A_EFUSE_PGM_LOCK, | ||
833 | + .pre_write = efuse_pgm_lock_prew, | ||
834 | + },{ .name = "EFUSE_AES_CRC", .addr = A_EFUSE_AES_CRC, | ||
835 | + .post_write = efuse_aes_crc_postw, | ||
836 | + },{ .name = "EFUSE_AES_USR_KEY0_CRC", .addr = A_EFUSE_AES_USR_KEY0_CRC, | ||
837 | + .post_write = efuse_aes_u0_crc_postw, | ||
838 | + },{ .name = "EFUSE_AES_USR_KEY1_CRC", .addr = A_EFUSE_AES_USR_KEY1_CRC, | ||
839 | + .post_write = efuse_aes_u1_crc_postw, | ||
840 | + },{ .name = "EFUSE_PD", .addr = A_EFUSE_PD, | ||
841 | + .ro = 0xfffffffe, | ||
842 | + },{ .name = "EFUSE_ANLG_OSC_SW_1LP", .addr = A_EFUSE_ANLG_OSC_SW_1LP, | ||
843 | + },{ .name = "EFUSE_TEST_CTRL", .addr = A_EFUSE_TEST_CTRL, | ||
844 | + .reset = 0x8, | ||
845 | + } | ||
846 | +}; | ||
847 | + | ||
848 | +static void efuse_ctrl_reg_write(void *opaque, hwaddr addr, | ||
849 | + uint64_t data, unsigned size) | ||
850 | +{ | ||
851 | + RegisterInfoArray *reg_array = opaque; | ||
852 | + XlnxVersalEFuseCtrl *s; | ||
853 | + Object *dev; | ||
854 | + | ||
855 | + assert(reg_array != NULL); | ||
856 | + | ||
857 | + dev = reg_array->mem.owner; | ||
858 | + assert(dev); | ||
859 | + | ||
860 | + s = XLNX_VERSAL_EFUSE_CTRL(dev); | ||
861 | + | ||
862 | + if (addr != A_WR_LOCK && s->regs[R_WR_LOCK]) { | ||
863 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
864 | + "%s[reg_0x%02lx]: Attempt to write locked register.\n", | ||
865 | + object_get_canonical_path(OBJECT(s)), (long)addr); | ||
866 | + } else { | ||
867 | + register_write_memory(opaque, addr, data, size); | ||
868 | + } | ||
869 | +} | ||
870 | + | ||
871 | +static void efuse_ctrl_register_reset(RegisterInfo *reg) | ||
872 | +{ | ||
873 | + if (!reg->data || !reg->access) { | ||
874 | + return; | ||
875 | + } | ||
876 | + | ||
877 | + /* Reset must not trigger some registers' writers */ | ||
878 | + switch (reg->access->addr) { | ||
879 | + case A_EFUSE_AES_CRC: | ||
880 | + case A_EFUSE_AES_USR_KEY0_CRC: | ||
881 | + case A_EFUSE_AES_USR_KEY1_CRC: | ||
882 | + *(uint32_t *)reg->data = reg->access->reset; | ||
883 | + return; | ||
884 | + } | ||
885 | + | ||
886 | + register_reset(reg); | ||
887 | +} | ||
888 | + | ||
889 | +static void efuse_ctrl_reset(DeviceState *dev) | ||
890 | +{ | ||
891 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(dev); | ||
892 | + unsigned int i; | ||
893 | + | ||
894 | + for (i = 0; i < ARRAY_SIZE(s->regs_info); ++i) { | ||
895 | + efuse_ctrl_register_reset(&s->regs_info[i]); | ||
896 | + } | ||
897 | + | ||
898 | + efuse_anchor_bits_check(s); | ||
899 | + efuse_data_sync(s); | ||
900 | + efuse_imr_update_irq(s); | ||
901 | +} | ||
902 | + | ||
903 | +static const MemoryRegionOps efuse_ctrl_ops = { | ||
904 | + .read = register_read_memory, | ||
905 | + .write = efuse_ctrl_reg_write, | ||
906 | + .endianness = DEVICE_LITTLE_ENDIAN, | ||
907 | + .valid = { | ||
908 | + .min_access_size = 4, | ||
909 | + .max_access_size = 4, | ||
910 | + }, | ||
911 | +}; | ||
912 | + | ||
913 | +static void efuse_ctrl_realize(DeviceState *dev, Error **errp) | ||
914 | +{ | ||
915 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(dev); | ||
916 | + const uint32_t lks_sz = sizeof(XlnxEFuseLkSpec) / 2; | ||
917 | + | ||
918 | + if (!s->efuse) { | ||
919 | + error_setg(errp, "%s.efuse: link property not connected to XLNX-EFUSE", | ||
920 | + object_get_canonical_path(OBJECT(dev))); | ||
921 | + return; | ||
922 | + } | ||
923 | + | ||
924 | + /* Sort property-defined pgm-locks for bsearch lookup */ | ||
925 | + if ((s->extra_pg0_lock_n16 % lks_sz) != 0) { | ||
926 | + error_setg(errp, | ||
927 | + "%s.pg0-lock: array property item-count not multiple of %u", | ||
928 | + object_get_canonical_path(OBJECT(dev)), lks_sz); | ||
929 | + return; | ||
930 | + } | ||
931 | + | ||
932 | + efuse_lk_spec_sort(s); | ||
933 | +} | ||
934 | + | ||
935 | +static void efuse_ctrl_init(Object *obj) | ||
936 | +{ | ||
937 | + XlnxVersalEFuseCtrl *s = XLNX_VERSAL_EFUSE_CTRL(obj); | ||
938 | + SysBusDevice *sbd = SYS_BUS_DEVICE(obj); | ||
939 | + RegisterInfoArray *reg_array; | ||
940 | + | ||
941 | + reg_array = | ||
942 | + register_init_block32(DEVICE(obj), efuse_ctrl_regs_info, | ||
943 | + ARRAY_SIZE(efuse_ctrl_regs_info), | ||
944 | + s->regs_info, s->regs, | ||
945 | + &efuse_ctrl_ops, | ||
946 | + XLNX_VERSAL_EFUSE_CTRL_ERR_DEBUG, | ||
947 | + R_MAX * 4); | ||
948 | + | ||
949 | + sysbus_init_mmio(sbd, ®_array->mem); | ||
950 | + sysbus_init_irq(sbd, &s->irq_efuse_imr); | ||
951 | +} | ||
952 | + | ||
953 | +static const VMStateDescription vmstate_efuse_ctrl = { | ||
954 | + .name = TYPE_XLNX_VERSAL_EFUSE_CTRL, | ||
955 | + .version_id = 1, | ||
956 | + .minimum_version_id = 1, | ||
957 | + .fields = (VMStateField[]) { | ||
958 | + VMSTATE_UINT32_ARRAY(regs, XlnxVersalEFuseCtrl, R_MAX), | ||
959 | + VMSTATE_END_OF_LIST(), | ||
960 | + } | ||
961 | +}; | ||
962 | + | ||
963 | +static Property efuse_ctrl_props[] = { | ||
964 | + DEFINE_PROP_LINK("efuse", | ||
965 | + XlnxVersalEFuseCtrl, efuse, | ||
966 | + TYPE_XLNX_EFUSE, XlnxEFuse *), | ||
967 | + DEFINE_PROP_ARRAY("pg0-lock", | ||
968 | + XlnxVersalEFuseCtrl, extra_pg0_lock_n16, | ||
969 | + extra_pg0_lock_spec, qdev_prop_uint16, uint16_t), | ||
970 | + | ||
971 | + DEFINE_PROP_END_OF_LIST(), | ||
972 | +}; | ||
973 | + | ||
974 | +static void efuse_ctrl_class_init(ObjectClass *klass, void *data) | ||
975 | +{ | ||
976 | + DeviceClass *dc = DEVICE_CLASS(klass); | ||
977 | + | ||
978 | + dc->reset = efuse_ctrl_reset; | ||
979 | + dc->realize = efuse_ctrl_realize; | ||
980 | + dc->vmsd = &vmstate_efuse_ctrl; | ||
981 | + device_class_set_props(dc, efuse_ctrl_props); | ||
982 | +} | ||
983 | + | ||
984 | +static const TypeInfo efuse_ctrl_info = { | ||
985 | + .name = TYPE_XLNX_VERSAL_EFUSE_CTRL, | ||
986 | + .parent = TYPE_SYS_BUS_DEVICE, | ||
987 | + .instance_size = sizeof(XlnxVersalEFuseCtrl), | ||
988 | + .class_init = efuse_ctrl_class_init, | ||
989 | + .instance_init = efuse_ctrl_init, | ||
990 | +}; | ||
991 | + | ||
992 | +static void efuse_ctrl_register_types(void) | ||
993 | +{ | ||
994 | + type_register_static(&efuse_ctrl_info); | ||
995 | +} | ||
996 | + | ||
997 | +type_init(efuse_ctrl_register_types) | ||
998 | + | ||
999 | +/* | ||
1000 | + * Retrieve a row, with unreadable bits returned as 0. | ||
1001 | + */ | ||
1002 | +uint32_t xlnx_versal_efuse_read_row(XlnxEFuse *efuse, | ||
1003 | + uint32_t bit, bool *denied) | ||
1004 | +{ | ||
1005 | + bool dummy; | ||
1006 | + | ||
1007 | + if (!denied) { | ||
1008 | + denied = &dummy; | ||
1009 | + } | ||
1010 | + | ||
1011 | + if (bit >= EFUSE_RD_BLOCKED_START && bit <= EFUSE_RD_BLOCKED_END) { | ||
1012 | + *denied = true; | ||
1013 | + return 0; | ||
1014 | + } | ||
1015 | + | ||
1016 | + *denied = false; | ||
1017 | + return xlnx_efuse_get_row(efuse, bit); | ||
1018 | +} | ||
1019 | diff --git a/hw/nvram/Kconfig b/hw/nvram/Kconfig | ||
179 | index XXXXXXX..XXXXXXX 100644 | 1020 | index XXXXXXX..XXXXXXX 100644 |
180 | --- a/target/arm/translate.c | 1021 | --- a/hw/nvram/Kconfig |
181 | +++ b/target/arm/translate.c | 1022 | +++ b/hw/nvram/Kconfig |
182 | @@ -XXX,XX +XXX,XX @@ static TCGv_ptr vfp_reg_ptr(bool dp, int reg) | 1023 | @@ -XXX,XX +XXX,XX @@ config XLNX_EFUSE_CRC |
183 | 1024 | config XLNX_EFUSE | |
184 | #define ARM_CP_RW_BIT (1 << 20) | 1025 | bool |
185 | 1026 | select XLNX_EFUSE_CRC | |
186 | -/* Include the VFP decoder */ | 1027 | + |
187 | +/* Include the VFP and Neon decoders */ | 1028 | +config XLNX_EFUSE_VERSAL |
188 | #include "translate-vfp.inc.c" | 1029 | + bool |
189 | +#include "translate-neon.inc.c" | 1030 | + select XLNX_EFUSE |
190 | 1031 | diff --git a/hw/nvram/meson.build b/hw/nvram/meson.build | |
191 | static inline void iwmmxt_load_reg(TCGv_i64 var, int reg) | ||
192 | { | ||
193 | @@ -XXX,XX +XXX,XX @@ static void disas_arm_insn(DisasContext *s, unsigned int insn) | ||
194 | /* Unconditional instructions. */ | ||
195 | /* TODO: Perhaps merge these into one decodetree output file. */ | ||
196 | if (disas_a32_uncond(s, insn) || | ||
197 | - disas_vfp_uncond(s, insn)) { | ||
198 | + disas_vfp_uncond(s, insn) || | ||
199 | + disas_neon_dp(s, insn) || | ||
200 | + disas_neon_ls(s, insn) || | ||
201 | + disas_neon_shared(s, insn)) { | ||
202 | return; | ||
203 | } | ||
204 | /* fall back to legacy decoder */ | ||
205 | @@ -XXX,XX +XXX,XX @@ static void disas_thumb2_insn(DisasContext *s, uint32_t insn) | ||
206 | ARCH(6T2); | ||
207 | } | ||
208 | |||
209 | + if ((insn & 0xef000000) == 0xef000000) { | ||
210 | + /* | ||
211 | + * T32 encodings 0b111p_1111_qqqq_qqqq_qqqq_qqqq_qqqq_qqqq | ||
212 | + * transform into | ||
213 | + * A32 encodings 0b1111_001p_qqqq_qqqq_qqqq_qqqq_qqqq_qqqq | ||
214 | + */ | ||
215 | + uint32_t a32_insn = (insn & 0xe2ffffff) | | ||
216 | + ((insn & (1 << 28)) >> 4) | (1 << 28); | ||
217 | + | ||
218 | + if (disas_neon_dp(s, a32_insn)) { | ||
219 | + return; | ||
220 | + } | ||
221 | + } | ||
222 | + | ||
223 | + if ((insn & 0xff100000) == 0xf9000000) { | ||
224 | + /* | ||
225 | + * T32 encodings 0b1111_1001_ppp0_qqqq_qqqq_qqqq_qqqq_qqqq | ||
226 | + * transform into | ||
227 | + * A32 encodings 0b1111_0100_ppp0_qqqq_qqqq_qqqq_qqqq_qqqq | ||
228 | + */ | ||
229 | + uint32_t a32_insn = (insn & 0x00ffffff) | 0xf4000000; | ||
230 | + | ||
231 | + if (disas_neon_ls(s, a32_insn)) { | ||
232 | + return; | ||
233 | + } | ||
234 | + } | ||
235 | + | ||
236 | /* | ||
237 | * TODO: Perhaps merge these into one decodetree output file. | ||
238 | * Note disas_vfp is written for a32 with cond field in the | ||
239 | @@ -XXX,XX +XXX,XX @@ static void disas_thumb2_insn(DisasContext *s, uint32_t insn) | ||
240 | */ | ||
241 | if (disas_t32(s, insn) || | ||
242 | disas_vfp_uncond(s, insn) || | ||
243 | + disas_neon_shared(s, insn) || | ||
244 | ((insn >> 28) == 0xe && disas_vfp(s, insn))) { | ||
245 | return; | ||
246 | } | ||
247 | diff --git a/target/arm/Makefile.objs b/target/arm/Makefile.objs | ||
248 | index XXXXXXX..XXXXXXX 100644 | 1032 | index XXXXXXX..XXXXXXX 100644 |
249 | --- a/target/arm/Makefile.objs | 1033 | --- a/hw/nvram/meson.build |
250 | +++ b/target/arm/Makefile.objs | 1034 | +++ b/hw/nvram/meson.build |
251 | @@ -XXX,XX +XXX,XX @@ target/arm/decode-sve.inc.c: $(SRC_PATH)/target/arm/sve.decode $(DECODETREE) | 1035 | @@ -XXX,XX +XXX,XX @@ softmmu_ss.add(when: 'CONFIG_NPCM7XX', if_true: files('npcm7xx_otp.c')) |
252 | $(PYTHON) $(DECODETREE) --decode disas_sve -o $@ $<,\ | 1036 | softmmu_ss.add(when: 'CONFIG_NRF51_SOC', if_true: files('nrf51_nvm.c')) |
253 | "GEN", $(TARGET_DIR)$@) | 1037 | softmmu_ss.add(when: 'CONFIG_XLNX_EFUSE_CRC', if_true: files('xlnx-efuse-crc.c')) |
254 | 1038 | softmmu_ss.add(when: 'CONFIG_XLNX_EFUSE', if_true: files('xlnx-efuse.c')) | |
255 | +target/arm/decode-neon-shared.inc.c: $(SRC_PATH)/target/arm/neon-shared.decode $(DECODETREE) | 1039 | +softmmu_ss.add(when: 'CONFIG_XLNX_EFUSE_VERSAL', if_true: files( |
256 | + $(call quiet-command,\ | 1040 | + 'xlnx-versal-efuse-cache.c', |
257 | + $(PYTHON) $(DECODETREE) --static-decode disas_neon_shared -o $@ $<,\ | 1041 | + 'xlnx-versal-efuse-ctrl.c')) |
258 | + "GEN", $(TARGET_DIR)$@) | 1042 | |
259 | + | 1043 | specific_ss.add(when: 'CONFIG_PSERIES', if_true: files('spapr_nvram.c')) |
260 | +target/arm/decode-neon-dp.inc.c: $(SRC_PATH)/target/arm/neon-dp.decode $(DECODETREE) | ||
261 | + $(call quiet-command,\ | ||
262 | + $(PYTHON) $(DECODETREE) --static-decode disas_neon_dp -o $@ $<,\ | ||
263 | + "GEN", $(TARGET_DIR)$@) | ||
264 | + | ||
265 | +target/arm/decode-neon-ls.inc.c: $(SRC_PATH)/target/arm/neon-ls.decode $(DECODETREE) | ||
266 | + $(call quiet-command,\ | ||
267 | + $(PYTHON) $(DECODETREE) --static-decode disas_neon_ls -o $@ $<,\ | ||
268 | + "GEN", $(TARGET_DIR)$@) | ||
269 | + | ||
270 | target/arm/decode-vfp.inc.c: $(SRC_PATH)/target/arm/vfp.decode $(DECODETREE) | ||
271 | $(call quiet-command,\ | ||
272 | $(PYTHON) $(DECODETREE) --static-decode disas_vfp -o $@ $<,\ | ||
273 | @@ -XXX,XX +XXX,XX @@ target/arm/decode-t16.inc.c: $(SRC_PATH)/target/arm/t16.decode $(DECODETREE) | ||
274 | "GEN", $(TARGET_DIR)$@) | ||
275 | |||
276 | target/arm/translate-sve.o: target/arm/decode-sve.inc.c | ||
277 | +target/arm/translate.o: target/arm/decode-neon-shared.inc.c | ||
278 | +target/arm/translate.o: target/arm/decode-neon-dp.inc.c | ||
279 | +target/arm/translate.o: target/arm/decode-neon-ls.inc.c | ||
280 | target/arm/translate.o: target/arm/decode-vfp.inc.c | ||
281 | target/arm/translate.o: target/arm/decode-vfp-uncond.inc.c | ||
282 | target/arm/translate.o: target/arm/decode-a32.inc.c | ||
283 | -- | 1044 | -- |
284 | 2.20.1 | 1045 | 2.20.1 |
285 | 1046 | ||
286 | 1047 | diff view generated by jsdifflib |
1 | Convert the Neon "load/store multiple structures" insns to decodetree. | 1 | From: Tong Ho <tong.ho@xilinx.com> |
---|---|---|---|
2 | 2 | ||
3 | This implements the Xilinx ZynqMP eFuse, an one-time | ||
4 | field-programmable non-volatile storage device. There is | ||
5 | only one such device in the Xilinx ZynqMP product family. | ||
6 | |||
7 | Co-authored-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | ||
8 | Co-authored-by: Sai Pavan Boddu <sai.pavan.boddu@xilinx.com> | ||
9 | |||
10 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | ||
11 | Signed-off-by: Sai Pavan Boddu <sai.pavan.boddu@xilinx.com> | ||
12 | Signed-off-by: Tong Ho <tong.ho@xilinx.com> | ||
13 | Message-id: 20210917052400.1249094-4-tong.ho@xilinx.com | ||
14 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
3 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 15 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
4 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
5 | Message-id: 20200430181003.21682-12-peter.maydell@linaro.org | ||
6 | --- | 16 | --- |
7 | target/arm/neon-ls.decode | 7 ++ | 17 | include/hw/nvram/xlnx-zynqmp-efuse.h | 44 ++ |
8 | target/arm/translate-neon.inc.c | 124 ++++++++++++++++++++++++++++++++ | 18 | hw/nvram/xlnx-zynqmp-efuse.c | 855 +++++++++++++++++++++++++++ |
9 | target/arm/translate.c | 91 +---------------------- | 19 | hw/nvram/Kconfig | 4 + |
10 | 3 files changed, 133 insertions(+), 89 deletions(-) | 20 | hw/nvram/meson.build | 2 + |
21 | 4 files changed, 905 insertions(+) | ||
22 | create mode 100644 include/hw/nvram/xlnx-zynqmp-efuse.h | ||
23 | create mode 100644 hw/nvram/xlnx-zynqmp-efuse.c | ||
11 | 24 | ||
12 | diff --git a/target/arm/neon-ls.decode b/target/arm/neon-ls.decode | 25 | diff --git a/include/hw/nvram/xlnx-zynqmp-efuse.h b/include/hw/nvram/xlnx-zynqmp-efuse.h |
13 | index XXXXXXX..XXXXXXX 100644 | 26 | new file mode 100644 |
14 | --- a/target/arm/neon-ls.decode | 27 | index XXXXXXX..XXXXXXX |
15 | +++ b/target/arm/neon-ls.decode | 28 | --- /dev/null |
29 | +++ b/include/hw/nvram/xlnx-zynqmp-efuse.h | ||
16 | @@ -XXX,XX +XXX,XX @@ | 30 | @@ -XXX,XX +XXX,XX @@ |
17 | # 0b1111_1001_xxx0_xxxx_xxxx_xxxx_xxxx_xxxx | 31 | +/* |
18 | # This file works on the A32 encoding only; calling code for T32 has to | 32 | + * Copyright (c) 2021 Xilinx Inc. |
19 | # transform the insn into the A32 version first. | 33 | + * |
20 | + | 34 | + * Permission is hereby granted, free of charge, to any person obtaining a copy |
21 | +%vd_dp 22:1 12:4 | 35 | + * of this software and associated documentation files (the "Software"), to deal |
22 | + | 36 | + * in the Software without restriction, including without limitation the rights |
23 | +# Neon load/store multiple structures | 37 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
24 | + | 38 | + * copies of the Software, and to permit persons to whom the Software is |
25 | +VLDST_multiple 1111 0100 0 . l:1 0 rn:4 .... itype:4 size:2 align:2 rm:4 \ | 39 | + * furnished to do so, subject to the following conditions: |
26 | + vd=%vd_dp | 40 | + * |
27 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | 41 | + * The above copyright notice and this permission notice shall be included in |
28 | index XXXXXXX..XXXXXXX 100644 | 42 | + * all copies or substantial portions of the Software. |
29 | --- a/target/arm/translate-neon.inc.c | 43 | + * |
30 | +++ b/target/arm/translate-neon.inc.c | 44 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
31 | @@ -XXX,XX +XXX,XX @@ static bool trans_VFML_scalar(DisasContext *s, arg_VFML_scalar *a) | 45 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
32 | gen_helper_gvec_fmlal_idx_a32); | 46 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
33 | return true; | 47 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
34 | } | 48 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
35 | + | 49 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
36 | +static struct { | 50 | + * THE SOFTWARE. |
37 | + int nregs; | 51 | + */ |
38 | + int interleave; | 52 | +#ifndef XLNX_ZYNQMP_EFUSE_H |
39 | + int spacing; | 53 | +#define XLNX_ZYNQMP_EFUSE_H |
40 | +} const neon_ls_element_type[11] = { | 54 | + |
41 | + {1, 4, 1}, | 55 | +#include "hw/irq.h" |
42 | + {1, 4, 2}, | 56 | +#include "hw/sysbus.h" |
43 | + {4, 1, 1}, | 57 | +#include "hw/register.h" |
44 | + {2, 2, 2}, | 58 | +#include "hw/nvram/xlnx-efuse.h" |
45 | + {1, 3, 1}, | 59 | + |
46 | + {1, 3, 2}, | 60 | +#define XLNX_ZYNQMP_EFUSE_R_MAX ((0x10fc / 4) + 1) |
47 | + {3, 1, 1}, | 61 | + |
48 | + {1, 1, 1}, | 62 | +#define TYPE_XLNX_ZYNQMP_EFUSE "xlnx,zynqmp-efuse" |
49 | + {1, 2, 1}, | 63 | +OBJECT_DECLARE_SIMPLE_TYPE(XlnxZynqMPEFuse, XLNX_ZYNQMP_EFUSE); |
50 | + {1, 2, 2}, | 64 | + |
51 | + {2, 1, 1} | 65 | +struct XlnxZynqMPEFuse { |
66 | + SysBusDevice parent_obj; | ||
67 | + qemu_irq irq; | ||
68 | + | ||
69 | + XlnxEFuse *efuse; | ||
70 | + uint32_t regs[XLNX_ZYNQMP_EFUSE_R_MAX]; | ||
71 | + RegisterInfo regs_info[XLNX_ZYNQMP_EFUSE_R_MAX]; | ||
52 | +}; | 72 | +}; |
53 | + | 73 | + |
54 | +static void gen_neon_ldst_base_update(DisasContext *s, int rm, int rn, | 74 | +#endif |
55 | + int stride) | 75 | diff --git a/hw/nvram/xlnx-zynqmp-efuse.c b/hw/nvram/xlnx-zynqmp-efuse.c |
56 | +{ | 76 | new file mode 100644 |
57 | + if (rm != 15) { | 77 | index XXXXXXX..XXXXXXX |
58 | + TCGv_i32 base; | 78 | --- /dev/null |
59 | + | 79 | +++ b/hw/nvram/xlnx-zynqmp-efuse.c |
60 | + base = load_reg(s, rn); | 80 | @@ -XXX,XX +XXX,XX @@ |
61 | + if (rm == 13) { | 81 | +/* |
62 | + tcg_gen_addi_i32(base, base, stride); | 82 | + * QEMU model of the ZynqMP eFuse |
63 | + } else { | 83 | + * |
64 | + TCGv_i32 index; | 84 | + * Copyright (c) 2015 Xilinx Inc. |
65 | + index = load_reg(s, rm); | 85 | + * |
66 | + tcg_gen_add_i32(base, base, index); | 86 | + * Written by Edgar E. Iglesias <edgari@xilinx.com> |
67 | + tcg_temp_free_i32(index); | 87 | + * |
88 | + * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
89 | + * of this software and associated documentation files (the "Software"), to deal | ||
90 | + * in the Software without restriction, including without limitation the rights | ||
91 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
92 | + * copies of the Software, and to permit persons to whom the Software is | ||
93 | + * furnished to do so, subject to the following conditions: | ||
94 | + * | ||
95 | + * The above copyright notice and this permission notice shall be included in | ||
96 | + * all copies or substantial portions of the Software. | ||
97 | + * | ||
98 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
99 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
100 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
101 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
102 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
103 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
104 | + * THE SOFTWARE. | ||
105 | + */ | ||
106 | + | ||
107 | +#include "qemu/osdep.h" | ||
108 | +#include "hw/nvram/xlnx-zynqmp-efuse.h" | ||
109 | + | ||
110 | +#include "qemu/log.h" | ||
111 | +#include "qapi/error.h" | ||
112 | +#include "migration/vmstate.h" | ||
113 | +#include "hw/qdev-properties.h" | ||
114 | + | ||
115 | +#ifndef ZYNQMP_EFUSE_ERR_DEBUG | ||
116 | +#define ZYNQMP_EFUSE_ERR_DEBUG 0 | ||
117 | +#endif | ||
118 | + | ||
119 | +REG32(WR_LOCK, 0x0) | ||
120 | + FIELD(WR_LOCK, LOCK, 0, 16) | ||
121 | +REG32(CFG, 0x4) | ||
122 | + FIELD(CFG, SLVERR_ENABLE, 5, 1) | ||
123 | + FIELD(CFG, MARGIN_RD, 2, 2) | ||
124 | + FIELD(CFG, PGM_EN, 1, 1) | ||
125 | + FIELD(CFG, EFUSE_CLK_SEL, 0, 1) | ||
126 | +REG32(STATUS, 0x8) | ||
127 | + FIELD(STATUS, AES_CRC_PASS, 7, 1) | ||
128 | + FIELD(STATUS, AES_CRC_DONE, 6, 1) | ||
129 | + FIELD(STATUS, CACHE_DONE, 5, 1) | ||
130 | + FIELD(STATUS, CACHE_LOAD, 4, 1) | ||
131 | + FIELD(STATUS, EFUSE_3_TBIT, 2, 1) | ||
132 | + FIELD(STATUS, EFUSE_2_TBIT, 1, 1) | ||
133 | + FIELD(STATUS, EFUSE_0_TBIT, 0, 1) | ||
134 | +REG32(EFUSE_PGM_ADDR, 0xc) | ||
135 | + FIELD(EFUSE_PGM_ADDR, EFUSE, 11, 2) | ||
136 | + FIELD(EFUSE_PGM_ADDR, ROW, 5, 6) | ||
137 | + FIELD(EFUSE_PGM_ADDR, COLUMN, 0, 5) | ||
138 | +REG32(EFUSE_RD_ADDR, 0x10) | ||
139 | + FIELD(EFUSE_RD_ADDR, EFUSE, 11, 2) | ||
140 | + FIELD(EFUSE_RD_ADDR, ROW, 5, 6) | ||
141 | +REG32(EFUSE_RD_DATA, 0x14) | ||
142 | +REG32(TPGM, 0x18) | ||
143 | + FIELD(TPGM, VALUE, 0, 16) | ||
144 | +REG32(TRD, 0x1c) | ||
145 | + FIELD(TRD, VALUE, 0, 8) | ||
146 | +REG32(TSU_H_PS, 0x20) | ||
147 | + FIELD(TSU_H_PS, VALUE, 0, 8) | ||
148 | +REG32(TSU_H_PS_CS, 0x24) | ||
149 | + FIELD(TSU_H_PS_CS, VALUE, 0, 8) | ||
150 | +REG32(TSU_H_CS, 0x2c) | ||
151 | + FIELD(TSU_H_CS, VALUE, 0, 4) | ||
152 | +REG32(EFUSE_ISR, 0x30) | ||
153 | + FIELD(EFUSE_ISR, APB_SLVERR, 31, 1) | ||
154 | + FIELD(EFUSE_ISR, CACHE_ERROR, 4, 1) | ||
155 | + FIELD(EFUSE_ISR, RD_ERROR, 3, 1) | ||
156 | + FIELD(EFUSE_ISR, RD_DONE, 2, 1) | ||
157 | + FIELD(EFUSE_ISR, PGM_ERROR, 1, 1) | ||
158 | + FIELD(EFUSE_ISR, PGM_DONE, 0, 1) | ||
159 | +REG32(EFUSE_IMR, 0x34) | ||
160 | + FIELD(EFUSE_IMR, APB_SLVERR, 31, 1) | ||
161 | + FIELD(EFUSE_IMR, CACHE_ERROR, 4, 1) | ||
162 | + FIELD(EFUSE_IMR, RD_ERROR, 3, 1) | ||
163 | + FIELD(EFUSE_IMR, RD_DONE, 2, 1) | ||
164 | + FIELD(EFUSE_IMR, PGM_ERROR, 1, 1) | ||
165 | + FIELD(EFUSE_IMR, PGM_DONE, 0, 1) | ||
166 | +REG32(EFUSE_IER, 0x38) | ||
167 | + FIELD(EFUSE_IER, APB_SLVERR, 31, 1) | ||
168 | + FIELD(EFUSE_IER, CACHE_ERROR, 4, 1) | ||
169 | + FIELD(EFUSE_IER, RD_ERROR, 3, 1) | ||
170 | + FIELD(EFUSE_IER, RD_DONE, 2, 1) | ||
171 | + FIELD(EFUSE_IER, PGM_ERROR, 1, 1) | ||
172 | + FIELD(EFUSE_IER, PGM_DONE, 0, 1) | ||
173 | +REG32(EFUSE_IDR, 0x3c) | ||
174 | + FIELD(EFUSE_IDR, APB_SLVERR, 31, 1) | ||
175 | + FIELD(EFUSE_IDR, CACHE_ERROR, 4, 1) | ||
176 | + FIELD(EFUSE_IDR, RD_ERROR, 3, 1) | ||
177 | + FIELD(EFUSE_IDR, RD_DONE, 2, 1) | ||
178 | + FIELD(EFUSE_IDR, PGM_ERROR, 1, 1) | ||
179 | + FIELD(EFUSE_IDR, PGM_DONE, 0, 1) | ||
180 | +REG32(EFUSE_CACHE_LOAD, 0x40) | ||
181 | + FIELD(EFUSE_CACHE_LOAD, LOAD, 0, 1) | ||
182 | +REG32(EFUSE_PGM_LOCK, 0x44) | ||
183 | + FIELD(EFUSE_PGM_LOCK, SPK_ID_LOCK, 0, 1) | ||
184 | +REG32(EFUSE_AES_CRC, 0x48) | ||
185 | +REG32(EFUSE_TBITS_PRGRMG_EN, 0x100) | ||
186 | + FIELD(EFUSE_TBITS_PRGRMG_EN, TBITS_PRGRMG_EN, 3, 1) | ||
187 | +REG32(DNA_0, 0x100c) | ||
188 | +REG32(DNA_1, 0x1010) | ||
189 | +REG32(DNA_2, 0x1014) | ||
190 | +REG32(IPDISABLE, 0x1018) | ||
191 | + FIELD(IPDISABLE, VCU_DIS, 8, 1) | ||
192 | + FIELD(IPDISABLE, GPU_DIS, 5, 1) | ||
193 | + FIELD(IPDISABLE, APU3_DIS, 3, 1) | ||
194 | + FIELD(IPDISABLE, APU2_DIS, 2, 1) | ||
195 | + FIELD(IPDISABLE, APU1_DIS, 1, 1) | ||
196 | + FIELD(IPDISABLE, APU0_DIS, 0, 1) | ||
197 | +REG32(SYSOSC_CTRL, 0x101c) | ||
198 | + FIELD(SYSOSC_CTRL, SYSOSC_EN, 0, 1) | ||
199 | +REG32(USER_0, 0x1020) | ||
200 | +REG32(USER_1, 0x1024) | ||
201 | +REG32(USER_2, 0x1028) | ||
202 | +REG32(USER_3, 0x102c) | ||
203 | +REG32(USER_4, 0x1030) | ||
204 | +REG32(USER_5, 0x1034) | ||
205 | +REG32(USER_6, 0x1038) | ||
206 | +REG32(USER_7, 0x103c) | ||
207 | +REG32(MISC_USER_CTRL, 0x1040) | ||
208 | + FIELD(MISC_USER_CTRL, FPD_SC_EN_0, 14, 1) | ||
209 | + FIELD(MISC_USER_CTRL, LPD_SC_EN_0, 11, 1) | ||
210 | + FIELD(MISC_USER_CTRL, LBIST_EN, 10, 1) | ||
211 | + FIELD(MISC_USER_CTRL, USR_WRLK_7, 7, 1) | ||
212 | + FIELD(MISC_USER_CTRL, USR_WRLK_6, 6, 1) | ||
213 | + FIELD(MISC_USER_CTRL, USR_WRLK_5, 5, 1) | ||
214 | + FIELD(MISC_USER_CTRL, USR_WRLK_4, 4, 1) | ||
215 | + FIELD(MISC_USER_CTRL, USR_WRLK_3, 3, 1) | ||
216 | + FIELD(MISC_USER_CTRL, USR_WRLK_2, 2, 1) | ||
217 | + FIELD(MISC_USER_CTRL, USR_WRLK_1, 1, 1) | ||
218 | + FIELD(MISC_USER_CTRL, USR_WRLK_0, 0, 1) | ||
219 | +REG32(ROM_RSVD, 0x1044) | ||
220 | + FIELD(ROM_RSVD, PBR_BOOT_ERROR, 0, 3) | ||
221 | +REG32(PUF_CHASH, 0x1050) | ||
222 | +REG32(PUF_MISC, 0x1054) | ||
223 | + FIELD(PUF_MISC, REGISTER_DIS, 31, 1) | ||
224 | + FIELD(PUF_MISC, SYN_WRLK, 30, 1) | ||
225 | + FIELD(PUF_MISC, SYN_INVLD, 29, 1) | ||
226 | + FIELD(PUF_MISC, TEST2_DIS, 28, 1) | ||
227 | + FIELD(PUF_MISC, UNUSED27, 27, 1) | ||
228 | + FIELD(PUF_MISC, UNUSED26, 26, 1) | ||
229 | + FIELD(PUF_MISC, UNUSED25, 25, 1) | ||
230 | + FIELD(PUF_MISC, UNUSED24, 24, 1) | ||
231 | + FIELD(PUF_MISC, AUX, 0, 24) | ||
232 | +REG32(SEC_CTRL, 0x1058) | ||
233 | + FIELD(SEC_CTRL, PPK1_INVLD, 30, 2) | ||
234 | + FIELD(SEC_CTRL, PPK1_WRLK, 29, 1) | ||
235 | + FIELD(SEC_CTRL, PPK0_INVLD, 27, 2) | ||
236 | + FIELD(SEC_CTRL, PPK0_WRLK, 26, 1) | ||
237 | + FIELD(SEC_CTRL, RSA_EN, 11, 15) | ||
238 | + FIELD(SEC_CTRL, SEC_LOCK, 10, 1) | ||
239 | + FIELD(SEC_CTRL, PROG_GATE_2, 9, 1) | ||
240 | + FIELD(SEC_CTRL, PROG_GATE_1, 8, 1) | ||
241 | + FIELD(SEC_CTRL, PROG_GATE_0, 7, 1) | ||
242 | + FIELD(SEC_CTRL, DFT_DIS, 6, 1) | ||
243 | + FIELD(SEC_CTRL, JTAG_DIS, 5, 1) | ||
244 | + FIELD(SEC_CTRL, ERROR_DIS, 4, 1) | ||
245 | + FIELD(SEC_CTRL, BBRAM_DIS, 3, 1) | ||
246 | + FIELD(SEC_CTRL, ENC_ONLY, 2, 1) | ||
247 | + FIELD(SEC_CTRL, AES_WRLK, 1, 1) | ||
248 | + FIELD(SEC_CTRL, AES_RDLK, 0, 1) | ||
249 | +REG32(SPK_ID, 0x105c) | ||
250 | +REG32(PPK0_0, 0x10a0) | ||
251 | +REG32(PPK0_1, 0x10a4) | ||
252 | +REG32(PPK0_2, 0x10a8) | ||
253 | +REG32(PPK0_3, 0x10ac) | ||
254 | +REG32(PPK0_4, 0x10b0) | ||
255 | +REG32(PPK0_5, 0x10b4) | ||
256 | +REG32(PPK0_6, 0x10b8) | ||
257 | +REG32(PPK0_7, 0x10bc) | ||
258 | +REG32(PPK0_8, 0x10c0) | ||
259 | +REG32(PPK0_9, 0x10c4) | ||
260 | +REG32(PPK0_10, 0x10c8) | ||
261 | +REG32(PPK0_11, 0x10cc) | ||
262 | +REG32(PPK1_0, 0x10d0) | ||
263 | +REG32(PPK1_1, 0x10d4) | ||
264 | +REG32(PPK1_2, 0x10d8) | ||
265 | +REG32(PPK1_3, 0x10dc) | ||
266 | +REG32(PPK1_4, 0x10e0) | ||
267 | +REG32(PPK1_5, 0x10e4) | ||
268 | +REG32(PPK1_6, 0x10e8) | ||
269 | +REG32(PPK1_7, 0x10ec) | ||
270 | +REG32(PPK1_8, 0x10f0) | ||
271 | +REG32(PPK1_9, 0x10f4) | ||
272 | +REG32(PPK1_10, 0x10f8) | ||
273 | +REG32(PPK1_11, 0x10fc) | ||
274 | + | ||
275 | +#define BIT_POS(ROW, COLUMN) (ROW * 32 + COLUMN) | ||
276 | +#define R_MAX (R_PPK1_11 + 1) | ||
277 | + | ||
278 | +/* #define EFUSE_XOSC 26 */ | ||
279 | + | ||
280 | +/* | ||
281 | + * eFUSE layout references: | ||
282 | + * ZynqMP: UG1085 (v2.1) August 21, 2019, p.277, Table 12-13 | ||
283 | + */ | ||
284 | +#define EFUSE_AES_RDLK BIT_POS(22, 0) | ||
285 | +#define EFUSE_AES_WRLK BIT_POS(22, 1) | ||
286 | +#define EFUSE_ENC_ONLY BIT_POS(22, 2) | ||
287 | +#define EFUSE_BBRAM_DIS BIT_POS(22, 3) | ||
288 | +#define EFUSE_ERROR_DIS BIT_POS(22, 4) | ||
289 | +#define EFUSE_JTAG_DIS BIT_POS(22, 5) | ||
290 | +#define EFUSE_DFT_DIS BIT_POS(22, 6) | ||
291 | +#define EFUSE_PROG_GATE_0 BIT_POS(22, 7) | ||
292 | +#define EFUSE_PROG_GATE_1 BIT_POS(22, 7) | ||
293 | +#define EFUSE_PROG_GATE_2 BIT_POS(22, 9) | ||
294 | +#define EFUSE_SEC_LOCK BIT_POS(22, 10) | ||
295 | +#define EFUSE_RSA_EN BIT_POS(22, 11) | ||
296 | +#define EFUSE_RSA_EN14 BIT_POS(22, 25) | ||
297 | +#define EFUSE_PPK0_WRLK BIT_POS(22, 26) | ||
298 | +#define EFUSE_PPK0_INVLD BIT_POS(22, 27) | ||
299 | +#define EFUSE_PPK0_INVLD_1 BIT_POS(22, 28) | ||
300 | +#define EFUSE_PPK1_WRLK BIT_POS(22, 29) | ||
301 | +#define EFUSE_PPK1_INVLD BIT_POS(22, 30) | ||
302 | +#define EFUSE_PPK1_INVLD_1 BIT_POS(22, 31) | ||
303 | + | ||
304 | +/* Areas. */ | ||
305 | +#define EFUSE_TRIM_START BIT_POS(1, 0) | ||
306 | +#define EFUSE_TRIM_END BIT_POS(1, 30) | ||
307 | +#define EFUSE_DNA_START BIT_POS(3, 0) | ||
308 | +#define EFUSE_DNA_END BIT_POS(5, 31) | ||
309 | +#define EFUSE_AES_START BIT_POS(24, 0) | ||
310 | +#define EFUSE_AES_END BIT_POS(31, 31) | ||
311 | +#define EFUSE_ROM_START BIT_POS(17, 0) | ||
312 | +#define EFUSE_ROM_END BIT_POS(17, 31) | ||
313 | +#define EFUSE_IPDIS_START BIT_POS(6, 0) | ||
314 | +#define EFUSE_IPDIS_END BIT_POS(6, 31) | ||
315 | +#define EFUSE_USER_START BIT_POS(8, 0) | ||
316 | +#define EFUSE_USER_END BIT_POS(15, 31) | ||
317 | +#define EFUSE_BISR_START BIT_POS(32, 0) | ||
318 | +#define EFUSE_BISR_END BIT_POS(39, 31) | ||
319 | + | ||
320 | +#define EFUSE_USER_CTRL_START BIT_POS(16, 0) | ||
321 | +#define EFUSE_USER_CTRL_END BIT_POS(16, 16) | ||
322 | +#define EFUSE_USER_CTRL_MASK ((uint32_t)MAKE_64BIT_MASK(0, 17)) | ||
323 | + | ||
324 | +#define EFUSE_PUF_CHASH_START BIT_POS(20, 0) | ||
325 | +#define EFUSE_PUF_CHASH_END BIT_POS(20, 31) | ||
326 | +#define EFUSE_PUF_MISC_START BIT_POS(21, 0) | ||
327 | +#define EFUSE_PUF_MISC_END BIT_POS(21, 31) | ||
328 | +#define EFUSE_PUF_SYN_WRLK BIT_POS(21, 30) | ||
329 | + | ||
330 | +#define EFUSE_SPK_START BIT_POS(23, 0) | ||
331 | +#define EFUSE_SPK_END BIT_POS(23, 31) | ||
332 | + | ||
333 | +#define EFUSE_PPK0_START BIT_POS(40, 0) | ||
334 | +#define EFUSE_PPK0_END BIT_POS(51, 31) | ||
335 | +#define EFUSE_PPK1_START BIT_POS(52, 0) | ||
336 | +#define EFUSE_PPK1_END BIT_POS(63, 31) | ||
337 | + | ||
338 | +#define EFUSE_CACHE_FLD(s, reg, field) \ | ||
339 | + ARRAY_FIELD_DP32((s)->regs, reg, field, \ | ||
340 | + (xlnx_efuse_get_row((s->efuse), EFUSE_ ## field) \ | ||
341 | + >> (EFUSE_ ## field % 32))) | ||
342 | + | ||
343 | +#define EFUSE_CACHE_BIT(s, reg, field) \ | ||
344 | + ARRAY_FIELD_DP32((s)->regs, reg, field, xlnx_efuse_get_bit((s->efuse), \ | ||
345 | + EFUSE_ ## field)) | ||
346 | + | ||
347 | +#define FBIT_UNKNOWN (~0) | ||
348 | + | ||
349 | +QEMU_BUILD_BUG_ON(R_MAX != ARRAY_SIZE(((XlnxZynqMPEFuse *)0)->regs)); | ||
350 | + | ||
351 | +static void update_tbit_status(XlnxZynqMPEFuse *s) | ||
352 | +{ | ||
353 | + unsigned int check = xlnx_efuse_tbits_check(s->efuse); | ||
354 | + uint32_t val = s->regs[R_STATUS]; | ||
355 | + | ||
356 | + val = FIELD_DP32(val, STATUS, EFUSE_0_TBIT, !!(check & (1 << 0))); | ||
357 | + val = FIELD_DP32(val, STATUS, EFUSE_2_TBIT, !!(check & (1 << 1))); | ||
358 | + val = FIELD_DP32(val, STATUS, EFUSE_3_TBIT, !!(check & (1 << 2))); | ||
359 | + | ||
360 | + s->regs[R_STATUS] = val; | ||
361 | +} | ||
362 | + | ||
363 | +/* Update the u32 array from efuse bits. Slow but simple approach. */ | ||
364 | +static void cache_sync_u32(XlnxZynqMPEFuse *s, unsigned int r_start, | ||
365 | + unsigned int f_start, unsigned int f_end, | ||
366 | + unsigned int f_written) | ||
367 | +{ | ||
368 | + uint32_t *u32 = &s->regs[r_start]; | ||
369 | + unsigned int fbit, wbits = 0, u32_off = 0; | ||
370 | + | ||
371 | + /* Avoid working on bits that are not relevant. */ | ||
372 | + if (f_written != FBIT_UNKNOWN | ||
373 | + && (f_written < f_start || f_written > f_end)) { | ||
374 | + return; | ||
375 | + } | ||
376 | + | ||
377 | + for (fbit = f_start; fbit <= f_end; fbit++, wbits++) { | ||
378 | + if (wbits == 32) { | ||
379 | + /* Update the key offset. */ | ||
380 | + u32_off += 1; | ||
381 | + wbits = 0; | ||
68 | + } | 382 | + } |
69 | + store_reg(s, rn, base); | 383 | + u32[u32_off] |= xlnx_efuse_get_bit(s->efuse, fbit) << wbits; |
70 | + } | 384 | + } |
71 | +} | 385 | +} |
72 | + | 386 | + |
73 | +static bool trans_VLDST_multiple(DisasContext *s, arg_VLDST_multiple *a) | 387 | +/* |
74 | +{ | 388 | + * Keep the syncs in bit order so we can bail out for the |
75 | + /* Neon load/store multiple structures */ | 389 | + * slower ones. |
76 | + int nregs, interleave, spacing, reg, n; | 390 | + */ |
77 | + MemOp endian = s->be_data; | 391 | +static void zynqmp_efuse_sync_cache(XlnxZynqMPEFuse *s, unsigned int bit) |
78 | + int mmu_idx = get_mem_index(s); | 392 | +{ |
79 | + int size = a->size; | 393 | + EFUSE_CACHE_BIT(s, SEC_CTRL, AES_RDLK); |
80 | + TCGv_i64 tmp64; | 394 | + EFUSE_CACHE_BIT(s, SEC_CTRL, AES_WRLK); |
81 | + TCGv_i32 addr, tmp; | 395 | + EFUSE_CACHE_BIT(s, SEC_CTRL, ENC_ONLY); |
82 | + | 396 | + EFUSE_CACHE_BIT(s, SEC_CTRL, BBRAM_DIS); |
83 | + if (!arm_dc_feature(s, ARM_FEATURE_NEON)) { | 397 | + EFUSE_CACHE_BIT(s, SEC_CTRL, ERROR_DIS); |
84 | + return false; | 398 | + EFUSE_CACHE_BIT(s, SEC_CTRL, JTAG_DIS); |
85 | + } | 399 | + EFUSE_CACHE_BIT(s, SEC_CTRL, DFT_DIS); |
86 | + | 400 | + EFUSE_CACHE_BIT(s, SEC_CTRL, PROG_GATE_0); |
87 | + /* UNDEF accesses to D16-D31 if they don't exist */ | 401 | + EFUSE_CACHE_BIT(s, SEC_CTRL, PROG_GATE_1); |
88 | + if (!dc_isar_feature(aa32_simd_r32, s) && (a->vd & 0x10)) { | 402 | + EFUSE_CACHE_BIT(s, SEC_CTRL, PROG_GATE_2); |
89 | + return false; | 403 | + EFUSE_CACHE_BIT(s, SEC_CTRL, SEC_LOCK); |
90 | + } | 404 | + EFUSE_CACHE_BIT(s, SEC_CTRL, PPK0_WRLK); |
91 | + if (a->itype > 10) { | 405 | + EFUSE_CACHE_BIT(s, SEC_CTRL, PPK1_WRLK); |
92 | + return false; | 406 | + |
93 | + } | 407 | + EFUSE_CACHE_FLD(s, SEC_CTRL, RSA_EN); |
94 | + /* Catch UNDEF cases for bad values of align field */ | 408 | + EFUSE_CACHE_FLD(s, SEC_CTRL, PPK0_INVLD); |
95 | + switch (a->itype & 0xc) { | 409 | + EFUSE_CACHE_FLD(s, SEC_CTRL, PPK1_INVLD); |
96 | + case 4: | 410 | + |
97 | + if (a->align >= 2) { | 411 | + /* Update the tbits. */ |
98 | + return false; | 412 | + update_tbit_status(s); |
413 | + | ||
414 | + /* Sync the various areas. */ | ||
415 | + s->regs[R_MISC_USER_CTRL] = xlnx_efuse_get_row(s->efuse, | ||
416 | + EFUSE_USER_CTRL_START) | ||
417 | + & EFUSE_USER_CTRL_MASK; | ||
418 | + s->regs[R_PUF_CHASH] = xlnx_efuse_get_row(s->efuse, EFUSE_PUF_CHASH_START); | ||
419 | + s->regs[R_PUF_MISC] = xlnx_efuse_get_row(s->efuse, EFUSE_PUF_MISC_START); | ||
420 | + | ||
421 | + cache_sync_u32(s, R_DNA_0, EFUSE_DNA_START, EFUSE_DNA_END, bit); | ||
422 | + | ||
423 | + if (bit < EFUSE_AES_START) { | ||
424 | + return; | ||
425 | + } | ||
426 | + | ||
427 | + cache_sync_u32(s, R_ROM_RSVD, EFUSE_ROM_START, EFUSE_ROM_END, bit); | ||
428 | + cache_sync_u32(s, R_IPDISABLE, EFUSE_IPDIS_START, EFUSE_IPDIS_END, bit); | ||
429 | + cache_sync_u32(s, R_USER_0, EFUSE_USER_START, EFUSE_USER_END, bit); | ||
430 | + cache_sync_u32(s, R_SPK_ID, EFUSE_SPK_START, EFUSE_SPK_END, bit); | ||
431 | + cache_sync_u32(s, R_PPK0_0, EFUSE_PPK0_START, EFUSE_PPK0_END, bit); | ||
432 | + cache_sync_u32(s, R_PPK1_0, EFUSE_PPK1_START, EFUSE_PPK1_END, bit); | ||
433 | +} | ||
434 | + | ||
435 | +static void zynqmp_efuse_update_irq(XlnxZynqMPEFuse *s) | ||
436 | +{ | ||
437 | + bool pending = s->regs[R_EFUSE_ISR] & s->regs[R_EFUSE_IMR]; | ||
438 | + qemu_set_irq(s->irq, pending); | ||
439 | +} | ||
440 | + | ||
441 | +static void zynqmp_efuse_isr_postw(RegisterInfo *reg, uint64_t val64) | ||
442 | +{ | ||
443 | + XlnxZynqMPEFuse *s = XLNX_ZYNQMP_EFUSE(reg->opaque); | ||
444 | + zynqmp_efuse_update_irq(s); | ||
445 | +} | ||
446 | + | ||
447 | +static uint64_t zynqmp_efuse_ier_prew(RegisterInfo *reg, uint64_t val64) | ||
448 | +{ | ||
449 | + XlnxZynqMPEFuse *s = XLNX_ZYNQMP_EFUSE(reg->opaque); | ||
450 | + uint32_t val = val64; | ||
451 | + | ||
452 | + s->regs[R_EFUSE_IMR] |= val; | ||
453 | + zynqmp_efuse_update_irq(s); | ||
454 | + return 0; | ||
455 | +} | ||
456 | + | ||
457 | +static uint64_t zynqmp_efuse_idr_prew(RegisterInfo *reg, uint64_t val64) | ||
458 | +{ | ||
459 | + XlnxZynqMPEFuse *s = XLNX_ZYNQMP_EFUSE(reg->opaque); | ||
460 | + uint32_t val = val64; | ||
461 | + | ||
462 | + s->regs[R_EFUSE_IMR] &= ~val; | ||
463 | + zynqmp_efuse_update_irq(s); | ||
464 | + return 0; | ||
465 | +} | ||
466 | + | ||
467 | +static void zynqmp_efuse_pgm_addr_postw(RegisterInfo *reg, uint64_t val64) | ||
468 | +{ | ||
469 | + XlnxZynqMPEFuse *s = XLNX_ZYNQMP_EFUSE(reg->opaque); | ||
470 | + unsigned bit = val64; | ||
471 | + unsigned page = FIELD_EX32(bit, EFUSE_PGM_ADDR, EFUSE); | ||
472 | + bool puf_prot = false; | ||
473 | + const char *errmsg = NULL; | ||
474 | + | ||
475 | + /* Allow only valid array, and adjust for skipped array 1 */ | ||
476 | + switch (page) { | ||
477 | + case 0: | ||
478 | + break; | ||
479 | + case 2 ... 3: | ||
480 | + bit = FIELD_DP32(bit, EFUSE_PGM_ADDR, EFUSE, page - 1); | ||
481 | + puf_prot = xlnx_efuse_get_bit(s->efuse, EFUSE_PUF_SYN_WRLK); | ||
482 | + break; | ||
483 | + default: | ||
484 | + errmsg = "Invalid address"; | ||
485 | + goto pgm_done; | ||
486 | + } | ||
487 | + | ||
488 | + if (ARRAY_FIELD_EX32(s->regs, WR_LOCK, LOCK)) { | ||
489 | + errmsg = "Array write-locked"; | ||
490 | + goto pgm_done; | ||
491 | + } | ||
492 | + | ||
493 | + if (!ARRAY_FIELD_EX32(s->regs, CFG, PGM_EN)) { | ||
494 | + errmsg = "Array pgm-disabled"; | ||
495 | + goto pgm_done; | ||
496 | + } | ||
497 | + | ||
498 | + if (puf_prot) { | ||
499 | + errmsg = "PUF_HD-store write-locked"; | ||
500 | + goto pgm_done; | ||
501 | + } | ||
502 | + | ||
503 | + if (ARRAY_FIELD_EX32(s->regs, SEC_CTRL, AES_WRLK) | ||
504 | + && bit >= EFUSE_AES_START && bit <= EFUSE_AES_END) { | ||
505 | + errmsg = "AES key-store Write-locked"; | ||
506 | + goto pgm_done; | ||
507 | + } | ||
508 | + | ||
509 | + if (!xlnx_efuse_set_bit(s->efuse, bit)) { | ||
510 | + errmsg = "Write failed"; | ||
511 | + } | ||
512 | + | ||
513 | + pgm_done: | ||
514 | + if (!errmsg) { | ||
515 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, PGM_ERROR, 0); | ||
516 | + } else { | ||
517 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, PGM_ERROR, 1); | ||
518 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
519 | + "%s - eFuse write error: %s; addr=0x%x\n", | ||
520 | + object_get_canonical_path(OBJECT(s)), | ||
521 | + errmsg, (unsigned)val64); | ||
522 | + } | ||
523 | + | ||
524 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, PGM_DONE, 1); | ||
525 | + zynqmp_efuse_update_irq(s); | ||
526 | +} | ||
527 | + | ||
528 | +static void zynqmp_efuse_rd_addr_postw(RegisterInfo *reg, uint64_t val64) | ||
529 | +{ | ||
530 | + XlnxZynqMPEFuse *s = XLNX_ZYNQMP_EFUSE(reg->opaque); | ||
531 | + | ||
532 | + /* | ||
533 | + * Grant reads only to allowed bits; reference sources: | ||
534 | + * 1/ XilSKey - XilSKey_ZynqMp_EfusePs_ReadRow() | ||
535 | + * 2/ UG1085, v2.0, table 12-13 | ||
536 | + * (note: enumerates the masks as <first, last> per described in | ||
537 | + * references to avoid mental translation). | ||
538 | + */ | ||
539 | +#define COL_MASK(L_, H_) \ | ||
540 | + ((uint32_t)MAKE_64BIT_MASK((L_), (1 + (H_) - (L_)))) | ||
541 | + | ||
542 | + static const uint32_t ary0_col_mask[] = { | ||
543 | + /* XilSKey - XSK_ZYNQMP_EFUSEPS_TBITS_ROW */ | ||
544 | + [0] = COL_MASK(28, 31), | ||
545 | + | ||
546 | + /* XilSKey - XSK_ZYNQMP_EFUSEPS_USR{0:7}_FUSE_ROW */ | ||
547 | + [8] = COL_MASK(0, 31), [9] = COL_MASK(0, 31), | ||
548 | + [10] = COL_MASK(0, 31), [11] = COL_MASK(0, 31), | ||
549 | + [12] = COL_MASK(0, 31), [13] = COL_MASK(0, 31), | ||
550 | + [14] = COL_MASK(0, 31), [15] = COL_MASK(0, 31), | ||
551 | + | ||
552 | + /* XilSKey - XSK_ZYNQMP_EFUSEPS_MISC_USR_CTRL_ROW */ | ||
553 | + [16] = COL_MASK(0, 7) | COL_MASK(10, 16), | ||
554 | + | ||
555 | + /* XilSKey - XSK_ZYNQMP_EFUSEPS_PBR_BOOT_ERR_ROW */ | ||
556 | + [17] = COL_MASK(0, 2), | ||
557 | + | ||
558 | + /* XilSKey - XSK_ZYNQMP_EFUSEPS_PUF_CHASH_ROW */ | ||
559 | + [20] = COL_MASK(0, 31), | ||
560 | + | ||
561 | + /* XilSKey - XSK_ZYNQMP_EFUSEPS_PUF_AUX_ROW */ | ||
562 | + [21] = COL_MASK(0, 23) | COL_MASK(29, 31), | ||
563 | + | ||
564 | + /* XilSKey - XSK_ZYNQMP_EFUSEPS_SEC_CTRL_ROW */ | ||
565 | + [22] = COL_MASK(0, 31), | ||
566 | + | ||
567 | + /* XilSKey - XSK_ZYNQMP_EFUSEPS_SPK_ID_ROW */ | ||
568 | + [23] = COL_MASK(0, 31), | ||
569 | + | ||
570 | + /* XilSKey - XSK_ZYNQMP_EFUSEPS_PPK0_START_ROW */ | ||
571 | + [40] = COL_MASK(0, 31), [41] = COL_MASK(0, 31), | ||
572 | + [42] = COL_MASK(0, 31), [43] = COL_MASK(0, 31), | ||
573 | + [44] = COL_MASK(0, 31), [45] = COL_MASK(0, 31), | ||
574 | + [46] = COL_MASK(0, 31), [47] = COL_MASK(0, 31), | ||
575 | + [48] = COL_MASK(0, 31), [49] = COL_MASK(0, 31), | ||
576 | + [50] = COL_MASK(0, 31), [51] = COL_MASK(0, 31), | ||
577 | + | ||
578 | + /* XilSKey - XSK_ZYNQMP_EFUSEPS_PPK1_START_ROW */ | ||
579 | + [52] = COL_MASK(0, 31), [53] = COL_MASK(0, 31), | ||
580 | + [54] = COL_MASK(0, 31), [55] = COL_MASK(0, 31), | ||
581 | + [56] = COL_MASK(0, 31), [57] = COL_MASK(0, 31), | ||
582 | + [58] = COL_MASK(0, 31), [59] = COL_MASK(0, 31), | ||
583 | + [60] = COL_MASK(0, 31), [61] = COL_MASK(0, 31), | ||
584 | + [62] = COL_MASK(0, 31), [63] = COL_MASK(0, 31), | ||
585 | + }; | ||
586 | + | ||
587 | + uint32_t col_mask = COL_MASK(0, 31); | ||
588 | +#undef COL_MASK | ||
589 | + | ||
590 | + uint32_t efuse_idx = s->regs[R_EFUSE_RD_ADDR]; | ||
591 | + uint32_t efuse_ary = FIELD_EX32(efuse_idx, EFUSE_RD_ADDR, EFUSE); | ||
592 | + uint32_t efuse_row = FIELD_EX32(efuse_idx, EFUSE_RD_ADDR, ROW); | ||
593 | + | ||
594 | + switch (efuse_ary) { | ||
595 | + case 0: /* Various */ | ||
596 | + if (efuse_row >= ARRAY_SIZE(ary0_col_mask)) { | ||
597 | + goto denied; | ||
598 | + } | ||
599 | + | ||
600 | + col_mask = ary0_col_mask[efuse_row]; | ||
601 | + if (!col_mask) { | ||
602 | + goto denied; | ||
99 | + } | 603 | + } |
100 | + break; | 604 | + break; |
101 | + case 8: | 605 | + case 2: /* PUF helper data, adjust for skipped array 1 */ |
102 | + if (a->align == 3) { | 606 | + case 3: |
103 | + return false; | 607 | + val64 = FIELD_DP32(efuse_idx, EFUSE_RD_ADDR, EFUSE, efuse_ary - 1); |
104 | + } | ||
105 | + break; | 608 | + break; |
106 | + default: | 609 | + default: |
107 | + break; | 610 | + goto denied; |
108 | + } | 611 | + } |
109 | + nregs = neon_ls_element_type[a->itype].nregs; | 612 | + |
110 | + interleave = neon_ls_element_type[a->itype].interleave; | 613 | + s->regs[R_EFUSE_RD_DATA] = xlnx_efuse_get_row(s->efuse, val64) & col_mask; |
111 | + spacing = neon_ls_element_type[a->itype].spacing; | 614 | + |
112 | + if (size == 3 && (interleave | spacing) != 1) { | 615 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, RD_ERROR, 0); |
113 | + return false; | 616 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, RD_DONE, 1); |
114 | + } | 617 | + zynqmp_efuse_update_irq(s); |
115 | + | 618 | + return; |
116 | + if (!vfp_access_check(s)) { | 619 | + |
117 | + return true; | 620 | + denied: |
118 | + } | 621 | + qemu_log_mask(LOG_GUEST_ERROR, |
119 | + | 622 | + "%s: Denied efuse read from array %u, row %u\n", |
120 | + /* For our purposes, bytes are always little-endian. */ | 623 | + object_get_canonical_path(OBJECT(s)), |
121 | + if (size == 0) { | 624 | + efuse_ary, efuse_row); |
122 | + endian = MO_LE; | 625 | + |
123 | + } | 626 | + s->regs[R_EFUSE_RD_DATA] = 0; |
124 | + /* | 627 | + |
125 | + * Consecutive little-endian elements from a single register | 628 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, RD_ERROR, 1); |
126 | + * can be promoted to a larger little-endian operation. | 629 | + ARRAY_FIELD_DP32(s->regs, EFUSE_ISR, RD_DONE, 0); |
127 | + */ | 630 | + zynqmp_efuse_update_irq(s); |
128 | + if (interleave == 1 && endian == MO_LE) { | 631 | +} |
129 | + size = 3; | 632 | + |
130 | + } | 633 | +static void zynqmp_efuse_aes_crc_postw(RegisterInfo *reg, uint64_t val64) |
131 | + tmp64 = tcg_temp_new_i64(); | 634 | +{ |
132 | + addr = tcg_temp_new_i32(); | 635 | + XlnxZynqMPEFuse *s = XLNX_ZYNQMP_EFUSE(reg->opaque); |
133 | + tmp = tcg_const_i32(1 << size); | 636 | + bool ok; |
134 | + load_reg_var(s, addr, a->rn); | 637 | + |
135 | + for (reg = 0; reg < nregs; reg++) { | 638 | + ok = xlnx_efuse_k256_check(s->efuse, (uint32_t)val64, EFUSE_AES_START); |
136 | + for (n = 0; n < 8 >> size; n++) { | 639 | + |
137 | + int xs; | 640 | + ARRAY_FIELD_DP32(s->regs, STATUS, AES_CRC_PASS, (ok ? 1 : 0)); |
138 | + for (xs = 0; xs < interleave; xs++) { | 641 | + ARRAY_FIELD_DP32(s->regs, STATUS, AES_CRC_DONE, 1); |
139 | + int tt = a->vd + reg + spacing * xs; | 642 | + |
140 | + | 643 | + s->regs[R_EFUSE_AES_CRC] = 0; /* crc value is write-only */ |
141 | + if (a->l) { | 644 | +} |
142 | + gen_aa32_ld_i64(s, tmp64, addr, mmu_idx, endian | size); | 645 | + |
143 | + neon_store_element64(tt, n, size, tmp64); | 646 | +static uint64_t zynqmp_efuse_cache_load_prew(RegisterInfo *reg, |
144 | + } else { | 647 | + uint64_t valu64) |
145 | + neon_load_element64(tmp64, tt, n, size); | 648 | +{ |
146 | + gen_aa32_st_i64(s, tmp64, addr, mmu_idx, endian | size); | 649 | + XlnxZynqMPEFuse *s = XLNX_ZYNQMP_EFUSE(reg->opaque); |
147 | + } | 650 | + |
148 | + tcg_gen_add_i32(addr, addr, tmp); | 651 | + if (valu64 & R_EFUSE_CACHE_LOAD_LOAD_MASK) { |
149 | + } | 652 | + zynqmp_efuse_sync_cache(s, FBIT_UNKNOWN); |
150 | + } | 653 | + ARRAY_FIELD_DP32(s->regs, STATUS, CACHE_DONE, 1); |
151 | + } | 654 | + zynqmp_efuse_update_irq(s); |
152 | + tcg_temp_free_i32(addr); | 655 | + } |
153 | + tcg_temp_free_i32(tmp); | 656 | + |
154 | + tcg_temp_free_i64(tmp64); | 657 | + return 0; |
155 | + | 658 | +} |
156 | + gen_neon_ldst_base_update(s, a->rm, a->rn, nregs * interleave * 8); | 659 | + |
157 | + return true; | 660 | +static uint64_t zynqmp_efuse_wr_lock_prew(RegisterInfo *reg, uint64_t val) |
158 | +} | 661 | +{ |
159 | diff --git a/target/arm/translate.c b/target/arm/translate.c | 662 | + return val == 0xDF0D ? 0 : 1; |
663 | +} | ||
664 | + | ||
665 | +static RegisterAccessInfo zynqmp_efuse_regs_info[] = { | ||
666 | + { .name = "WR_LOCK", .addr = A_WR_LOCK, | ||
667 | + .reset = 0x1, | ||
668 | + .pre_write = zynqmp_efuse_wr_lock_prew, | ||
669 | + },{ .name = "CFG", .addr = A_CFG, | ||
670 | + },{ .name = "STATUS", .addr = A_STATUS, | ||
671 | + .rsvd = 0x8, | ||
672 | + .ro = 0xff, | ||
673 | + },{ .name = "EFUSE_PGM_ADDR", .addr = A_EFUSE_PGM_ADDR, | ||
674 | + .post_write = zynqmp_efuse_pgm_addr_postw | ||
675 | + },{ .name = "EFUSE_RD_ADDR", .addr = A_EFUSE_RD_ADDR, | ||
676 | + .rsvd = 0x1f, | ||
677 | + .post_write = zynqmp_efuse_rd_addr_postw, | ||
678 | + },{ .name = "EFUSE_RD_DATA", .addr = A_EFUSE_RD_DATA, | ||
679 | + .ro = 0xffffffff, | ||
680 | + },{ .name = "TPGM", .addr = A_TPGM, | ||
681 | + },{ .name = "TRD", .addr = A_TRD, | ||
682 | + .reset = 0x1b, | ||
683 | + },{ .name = "TSU_H_PS", .addr = A_TSU_H_PS, | ||
684 | + .reset = 0xff, | ||
685 | + },{ .name = "TSU_H_PS_CS", .addr = A_TSU_H_PS_CS, | ||
686 | + .reset = 0xb, | ||
687 | + },{ .name = "TSU_H_CS", .addr = A_TSU_H_CS, | ||
688 | + .reset = 0x7, | ||
689 | + },{ .name = "EFUSE_ISR", .addr = A_EFUSE_ISR, | ||
690 | + .rsvd = 0x7fffffe0, | ||
691 | + .w1c = 0x8000001f, | ||
692 | + .post_write = zynqmp_efuse_isr_postw, | ||
693 | + },{ .name = "EFUSE_IMR", .addr = A_EFUSE_IMR, | ||
694 | + .reset = 0x8000001f, | ||
695 | + .rsvd = 0x7fffffe0, | ||
696 | + .ro = 0xffffffff, | ||
697 | + },{ .name = "EFUSE_IER", .addr = A_EFUSE_IER, | ||
698 | + .rsvd = 0x7fffffe0, | ||
699 | + .pre_write = zynqmp_efuse_ier_prew, | ||
700 | + },{ .name = "EFUSE_IDR", .addr = A_EFUSE_IDR, | ||
701 | + .rsvd = 0x7fffffe0, | ||
702 | + .pre_write = zynqmp_efuse_idr_prew, | ||
703 | + },{ .name = "EFUSE_CACHE_LOAD", .addr = A_EFUSE_CACHE_LOAD, | ||
704 | + .pre_write = zynqmp_efuse_cache_load_prew, | ||
705 | + },{ .name = "EFUSE_PGM_LOCK", .addr = A_EFUSE_PGM_LOCK, | ||
706 | + },{ .name = "EFUSE_AES_CRC", .addr = A_EFUSE_AES_CRC, | ||
707 | + .post_write = zynqmp_efuse_aes_crc_postw, | ||
708 | + },{ .name = "EFUSE_TBITS_PRGRMG_EN", .addr = A_EFUSE_TBITS_PRGRMG_EN, | ||
709 | + .reset = R_EFUSE_TBITS_PRGRMG_EN_TBITS_PRGRMG_EN_MASK, | ||
710 | + },{ .name = "DNA_0", .addr = A_DNA_0, | ||
711 | + .ro = 0xffffffff, | ||
712 | + },{ .name = "DNA_1", .addr = A_DNA_1, | ||
713 | + .ro = 0xffffffff, | ||
714 | + },{ .name = "DNA_2", .addr = A_DNA_2, | ||
715 | + .ro = 0xffffffff, | ||
716 | + },{ .name = "IPDISABLE", .addr = A_IPDISABLE, | ||
717 | + .ro = 0xffffffff, | ||
718 | + },{ .name = "SYSOSC_CTRL", .addr = A_SYSOSC_CTRL, | ||
719 | + .ro = 0xffffffff, | ||
720 | + },{ .name = "USER_0", .addr = A_USER_0, | ||
721 | + .ro = 0xffffffff, | ||
722 | + },{ .name = "USER_1", .addr = A_USER_1, | ||
723 | + .ro = 0xffffffff, | ||
724 | + },{ .name = "USER_2", .addr = A_USER_2, | ||
725 | + .ro = 0xffffffff, | ||
726 | + },{ .name = "USER_3", .addr = A_USER_3, | ||
727 | + .ro = 0xffffffff, | ||
728 | + },{ .name = "USER_4", .addr = A_USER_4, | ||
729 | + .ro = 0xffffffff, | ||
730 | + },{ .name = "USER_5", .addr = A_USER_5, | ||
731 | + .ro = 0xffffffff, | ||
732 | + },{ .name = "USER_6", .addr = A_USER_6, | ||
733 | + .ro = 0xffffffff, | ||
734 | + },{ .name = "USER_7", .addr = A_USER_7, | ||
735 | + .ro = 0xffffffff, | ||
736 | + },{ .name = "MISC_USER_CTRL", .addr = A_MISC_USER_CTRL, | ||
737 | + .ro = 0xffffffff, | ||
738 | + },{ .name = "ROM_RSVD", .addr = A_ROM_RSVD, | ||
739 | + .ro = 0xffffffff, | ||
740 | + },{ .name = "PUF_CHASH", .addr = A_PUF_CHASH, | ||
741 | + .ro = 0xffffffff, | ||
742 | + },{ .name = "PUF_MISC", .addr = A_PUF_MISC, | ||
743 | + .ro = 0xffffffff, | ||
744 | + },{ .name = "SEC_CTRL", .addr = A_SEC_CTRL, | ||
745 | + .ro = 0xffffffff, | ||
746 | + },{ .name = "SPK_ID", .addr = A_SPK_ID, | ||
747 | + .ro = 0xffffffff, | ||
748 | + },{ .name = "PPK0_0", .addr = A_PPK0_0, | ||
749 | + .ro = 0xffffffff, | ||
750 | + },{ .name = "PPK0_1", .addr = A_PPK0_1, | ||
751 | + .ro = 0xffffffff, | ||
752 | + },{ .name = "PPK0_2", .addr = A_PPK0_2, | ||
753 | + .ro = 0xffffffff, | ||
754 | + },{ .name = "PPK0_3", .addr = A_PPK0_3, | ||
755 | + .ro = 0xffffffff, | ||
756 | + },{ .name = "PPK0_4", .addr = A_PPK0_4, | ||
757 | + .ro = 0xffffffff, | ||
758 | + },{ .name = "PPK0_5", .addr = A_PPK0_5, | ||
759 | + .ro = 0xffffffff, | ||
760 | + },{ .name = "PPK0_6", .addr = A_PPK0_6, | ||
761 | + .ro = 0xffffffff, | ||
762 | + },{ .name = "PPK0_7", .addr = A_PPK0_7, | ||
763 | + .ro = 0xffffffff, | ||
764 | + },{ .name = "PPK0_8", .addr = A_PPK0_8, | ||
765 | + .ro = 0xffffffff, | ||
766 | + },{ .name = "PPK0_9", .addr = A_PPK0_9, | ||
767 | + .ro = 0xffffffff, | ||
768 | + },{ .name = "PPK0_10", .addr = A_PPK0_10, | ||
769 | + .ro = 0xffffffff, | ||
770 | + },{ .name = "PPK0_11", .addr = A_PPK0_11, | ||
771 | + .ro = 0xffffffff, | ||
772 | + },{ .name = "PPK1_0", .addr = A_PPK1_0, | ||
773 | + .ro = 0xffffffff, | ||
774 | + },{ .name = "PPK1_1", .addr = A_PPK1_1, | ||
775 | + .ro = 0xffffffff, | ||
776 | + },{ .name = "PPK1_2", .addr = A_PPK1_2, | ||
777 | + .ro = 0xffffffff, | ||
778 | + },{ .name = "PPK1_3", .addr = A_PPK1_3, | ||
779 | + .ro = 0xffffffff, | ||
780 | + },{ .name = "PPK1_4", .addr = A_PPK1_4, | ||
781 | + .ro = 0xffffffff, | ||
782 | + },{ .name = "PPK1_5", .addr = A_PPK1_5, | ||
783 | + .ro = 0xffffffff, | ||
784 | + },{ .name = "PPK1_6", .addr = A_PPK1_6, | ||
785 | + .ro = 0xffffffff, | ||
786 | + },{ .name = "PPK1_7", .addr = A_PPK1_7, | ||
787 | + .ro = 0xffffffff, | ||
788 | + },{ .name = "PPK1_8", .addr = A_PPK1_8, | ||
789 | + .ro = 0xffffffff, | ||
790 | + },{ .name = "PPK1_9", .addr = A_PPK1_9, | ||
791 | + .ro = 0xffffffff, | ||
792 | + },{ .name = "PPK1_10", .addr = A_PPK1_10, | ||
793 | + .ro = 0xffffffff, | ||
794 | + },{ .name = "PPK1_11", .addr = A_PPK1_11, | ||
795 | + .ro = 0xffffffff, | ||
796 | + } | ||
797 | +}; | ||
798 | + | ||
799 | +static void zynqmp_efuse_reg_write(void *opaque, hwaddr addr, | ||
800 | + uint64_t data, unsigned size) | ||
801 | +{ | ||
802 | + RegisterInfoArray *reg_array = opaque; | ||
803 | + XlnxZynqMPEFuse *s; | ||
804 | + Object *dev; | ||
805 | + | ||
806 | + assert(reg_array != NULL); | ||
807 | + | ||
808 | + dev = reg_array->mem.owner; | ||
809 | + assert(dev); | ||
810 | + | ||
811 | + s = XLNX_ZYNQMP_EFUSE(dev); | ||
812 | + | ||
813 | + if (addr != A_WR_LOCK && s->regs[R_WR_LOCK]) { | ||
814 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
815 | + "%s[reg_0x%02lx]: Attempt to write locked register.\n", | ||
816 | + object_get_canonical_path(OBJECT(s)), (long)addr); | ||
817 | + } else { | ||
818 | + register_write_memory(opaque, addr, data, size); | ||
819 | + } | ||
820 | +} | ||
821 | + | ||
822 | +static const MemoryRegionOps zynqmp_efuse_ops = { | ||
823 | + .read = register_read_memory, | ||
824 | + .write = zynqmp_efuse_reg_write, | ||
825 | + .endianness = DEVICE_LITTLE_ENDIAN, | ||
826 | + .valid = { | ||
827 | + .min_access_size = 4, | ||
828 | + .max_access_size = 4, | ||
829 | + }, | ||
830 | +}; | ||
831 | + | ||
832 | +static void zynqmp_efuse_register_reset(RegisterInfo *reg) | ||
833 | +{ | ||
834 | + if (!reg->data || !reg->access) { | ||
835 | + return; | ||
836 | + } | ||
837 | + | ||
838 | + /* Reset must not trigger some registers' writers */ | ||
839 | + switch (reg->access->addr) { | ||
840 | + case A_EFUSE_AES_CRC: | ||
841 | + *(uint32_t *)reg->data = reg->access->reset; | ||
842 | + return; | ||
843 | + } | ||
844 | + | ||
845 | + register_reset(reg); | ||
846 | +} | ||
847 | + | ||
848 | +static void zynqmp_efuse_reset(DeviceState *dev) | ||
849 | +{ | ||
850 | + XlnxZynqMPEFuse *s = XLNX_ZYNQMP_EFUSE(dev); | ||
851 | + unsigned int i; | ||
852 | + | ||
853 | + for (i = 0; i < ARRAY_SIZE(s->regs_info); ++i) { | ||
854 | + zynqmp_efuse_register_reset(&s->regs_info[i]); | ||
855 | + } | ||
856 | + | ||
857 | + zynqmp_efuse_sync_cache(s, FBIT_UNKNOWN); | ||
858 | + ARRAY_FIELD_DP32(s->regs, STATUS, CACHE_DONE, 1); | ||
859 | + zynqmp_efuse_update_irq(s); | ||
860 | +} | ||
861 | + | ||
862 | +static void zynqmp_efuse_realize(DeviceState *dev, Error **errp) | ||
863 | +{ | ||
864 | + XlnxZynqMPEFuse *s = XLNX_ZYNQMP_EFUSE(dev); | ||
865 | + | ||
866 | + if (!s->efuse) { | ||
867 | + error_setg(errp, "%s.efuse: link property not connected to XLNX-EFUSE", | ||
868 | + object_get_canonical_path(OBJECT(dev))); | ||
869 | + return; | ||
870 | + } | ||
871 | + | ||
872 | + s->efuse->dev = dev; | ||
873 | +} | ||
874 | + | ||
875 | +static void zynqmp_efuse_init(Object *obj) | ||
876 | +{ | ||
877 | + XlnxZynqMPEFuse *s = XLNX_ZYNQMP_EFUSE(obj); | ||
878 | + SysBusDevice *sbd = SYS_BUS_DEVICE(obj); | ||
879 | + RegisterInfoArray *reg_array; | ||
880 | + | ||
881 | + reg_array = | ||
882 | + register_init_block32(DEVICE(obj), zynqmp_efuse_regs_info, | ||
883 | + ARRAY_SIZE(zynqmp_efuse_regs_info), | ||
884 | + s->regs_info, s->regs, | ||
885 | + &zynqmp_efuse_ops, | ||
886 | + ZYNQMP_EFUSE_ERR_DEBUG, | ||
887 | + R_MAX * 4); | ||
888 | + | ||
889 | + sysbus_init_mmio(sbd, ®_array->mem); | ||
890 | + sysbus_init_irq(sbd, &s->irq); | ||
891 | +} | ||
892 | + | ||
893 | +static const VMStateDescription vmstate_efuse = { | ||
894 | + .name = TYPE_XLNX_ZYNQMP_EFUSE, | ||
895 | + .version_id = 1, | ||
896 | + .minimum_version_id = 1, | ||
897 | + .fields = (VMStateField[]) { | ||
898 | + VMSTATE_UINT32_ARRAY(regs, XlnxZynqMPEFuse, R_MAX), | ||
899 | + VMSTATE_END_OF_LIST(), | ||
900 | + } | ||
901 | +}; | ||
902 | + | ||
903 | +static Property zynqmp_efuse_props[] = { | ||
904 | + DEFINE_PROP_LINK("efuse", | ||
905 | + XlnxZynqMPEFuse, efuse, | ||
906 | + TYPE_XLNX_EFUSE, XlnxEFuse *), | ||
907 | + | ||
908 | + DEFINE_PROP_END_OF_LIST(), | ||
909 | +}; | ||
910 | + | ||
911 | +static void zynqmp_efuse_class_init(ObjectClass *klass, void *data) | ||
912 | +{ | ||
913 | + DeviceClass *dc = DEVICE_CLASS(klass); | ||
914 | + | ||
915 | + dc->reset = zynqmp_efuse_reset; | ||
916 | + dc->realize = zynqmp_efuse_realize; | ||
917 | + dc->vmsd = &vmstate_efuse; | ||
918 | + device_class_set_props(dc, zynqmp_efuse_props); | ||
919 | +} | ||
920 | + | ||
921 | + | ||
922 | +static const TypeInfo efuse_info = { | ||
923 | + .name = TYPE_XLNX_ZYNQMP_EFUSE, | ||
924 | + .parent = TYPE_SYS_BUS_DEVICE, | ||
925 | + .instance_size = sizeof(XlnxZynqMPEFuse), | ||
926 | + .class_init = zynqmp_efuse_class_init, | ||
927 | + .instance_init = zynqmp_efuse_init, | ||
928 | +}; | ||
929 | + | ||
930 | +static void efuse_register_types(void) | ||
931 | +{ | ||
932 | + type_register_static(&efuse_info); | ||
933 | +} | ||
934 | + | ||
935 | +type_init(efuse_register_types) | ||
936 | diff --git a/hw/nvram/Kconfig b/hw/nvram/Kconfig | ||
160 | index XXXXXXX..XXXXXXX 100644 | 937 | index XXXXXXX..XXXXXXX 100644 |
161 | --- a/target/arm/translate.c | 938 | --- a/hw/nvram/Kconfig |
162 | +++ b/target/arm/translate.c | 939 | +++ b/hw/nvram/Kconfig |
163 | @@ -XXX,XX +XXX,XX @@ static void gen_neon_trn_u16(TCGv_i32 t0, TCGv_i32 t1) | 940 | @@ -XXX,XX +XXX,XX @@ config XLNX_EFUSE |
164 | } | 941 | config XLNX_EFUSE_VERSAL |
165 | 942 | bool | |
166 | 943 | select XLNX_EFUSE | |
167 | -static struct { | 944 | + |
168 | - int nregs; | 945 | +config XLNX_EFUSE_ZYNQMP |
169 | - int interleave; | 946 | + bool |
170 | - int spacing; | 947 | + select XLNX_EFUSE |
171 | -} const neon_ls_element_type[11] = { | 948 | diff --git a/hw/nvram/meson.build b/hw/nvram/meson.build |
172 | - {1, 4, 1}, | 949 | index XXXXXXX..XXXXXXX 100644 |
173 | - {1, 4, 2}, | 950 | --- a/hw/nvram/meson.build |
174 | - {4, 1, 1}, | 951 | +++ b/hw/nvram/meson.build |
175 | - {2, 2, 2}, | 952 | @@ -XXX,XX +XXX,XX @@ softmmu_ss.add(when: 'CONFIG_XLNX_EFUSE', if_true: files('xlnx-efuse.c')) |
176 | - {1, 3, 1}, | 953 | softmmu_ss.add(when: 'CONFIG_XLNX_EFUSE_VERSAL', if_true: files( |
177 | - {1, 3, 2}, | 954 | 'xlnx-versal-efuse-cache.c', |
178 | - {3, 1, 1}, | 955 | 'xlnx-versal-efuse-ctrl.c')) |
179 | - {1, 1, 1}, | 956 | +softmmu_ss.add(when: 'CONFIG_XLNX_EFUSE_ZYNQMP', if_true: files( |
180 | - {1, 2, 1}, | 957 | + 'xlnx-zynqmp-efuse.c')) |
181 | - {1, 2, 2}, | 958 | |
182 | - {2, 1, 1} | 959 | specific_ss.add(when: 'CONFIG_PSERIES', if_true: files('spapr_nvram.c')) |
183 | -}; | ||
184 | - | ||
185 | /* Translate a NEON load/store element instruction. Return nonzero if the | ||
186 | instruction is invalid. */ | ||
187 | static int disas_neon_ls_insn(DisasContext *s, uint32_t insn) | ||
188 | { | ||
189 | int rd, rn, rm; | ||
190 | - int op; | ||
191 | int nregs; | ||
192 | - int interleave; | ||
193 | - int spacing; | ||
194 | int stride; | ||
195 | int size; | ||
196 | int reg; | ||
197 | int load; | ||
198 | - int n; | ||
199 | int vec_size; | ||
200 | - int mmu_idx; | ||
201 | - MemOp endian; | ||
202 | TCGv_i32 addr; | ||
203 | TCGv_i32 tmp; | ||
204 | - TCGv_i32 tmp2; | ||
205 | - TCGv_i64 tmp64; | ||
206 | |||
207 | if (!arm_dc_feature(s, ARM_FEATURE_NEON)) { | ||
208 | return 1; | ||
209 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_ls_insn(DisasContext *s, uint32_t insn) | ||
210 | rn = (insn >> 16) & 0xf; | ||
211 | rm = insn & 0xf; | ||
212 | load = (insn & (1 << 21)) != 0; | ||
213 | - endian = s->be_data; | ||
214 | - mmu_idx = get_mem_index(s); | ||
215 | if ((insn & (1 << 23)) == 0) { | ||
216 | - /* Load store all elements. */ | ||
217 | - op = (insn >> 8) & 0xf; | ||
218 | - size = (insn >> 6) & 3; | ||
219 | - if (op > 10) | ||
220 | - return 1; | ||
221 | - /* Catch UNDEF cases for bad values of align field */ | ||
222 | - switch (op & 0xc) { | ||
223 | - case 4: | ||
224 | - if (((insn >> 5) & 1) == 1) { | ||
225 | - return 1; | ||
226 | - } | ||
227 | - break; | ||
228 | - case 8: | ||
229 | - if (((insn >> 4) & 3) == 3) { | ||
230 | - return 1; | ||
231 | - } | ||
232 | - break; | ||
233 | - default: | ||
234 | - break; | ||
235 | - } | ||
236 | - nregs = neon_ls_element_type[op].nregs; | ||
237 | - interleave = neon_ls_element_type[op].interleave; | ||
238 | - spacing = neon_ls_element_type[op].spacing; | ||
239 | - if (size == 3 && (interleave | spacing) != 1) { | ||
240 | - return 1; | ||
241 | - } | ||
242 | - /* For our purposes, bytes are always little-endian. */ | ||
243 | - if (size == 0) { | ||
244 | - endian = MO_LE; | ||
245 | - } | ||
246 | - /* Consecutive little-endian elements from a single register | ||
247 | - * can be promoted to a larger little-endian operation. | ||
248 | - */ | ||
249 | - if (interleave == 1 && endian == MO_LE) { | ||
250 | - size = 3; | ||
251 | - } | ||
252 | - tmp64 = tcg_temp_new_i64(); | ||
253 | - addr = tcg_temp_new_i32(); | ||
254 | - tmp2 = tcg_const_i32(1 << size); | ||
255 | - load_reg_var(s, addr, rn); | ||
256 | - for (reg = 0; reg < nregs; reg++) { | ||
257 | - for (n = 0; n < 8 >> size; n++) { | ||
258 | - int xs; | ||
259 | - for (xs = 0; xs < interleave; xs++) { | ||
260 | - int tt = rd + reg + spacing * xs; | ||
261 | - | ||
262 | - if (load) { | ||
263 | - gen_aa32_ld_i64(s, tmp64, addr, mmu_idx, endian | size); | ||
264 | - neon_store_element64(tt, n, size, tmp64); | ||
265 | - } else { | ||
266 | - neon_load_element64(tmp64, tt, n, size); | ||
267 | - gen_aa32_st_i64(s, tmp64, addr, mmu_idx, endian | size); | ||
268 | - } | ||
269 | - tcg_gen_add_i32(addr, addr, tmp2); | ||
270 | - } | ||
271 | - } | ||
272 | - } | ||
273 | - tcg_temp_free_i32(addr); | ||
274 | - tcg_temp_free_i32(tmp2); | ||
275 | - tcg_temp_free_i64(tmp64); | ||
276 | - stride = nregs * interleave * 8; | ||
277 | + /* Load store all elements -- handled already by decodetree */ | ||
278 | + return 1; | ||
279 | } else { | ||
280 | size = (insn >> 10) & 3; | ||
281 | if (size == 3) { | ||
282 | -- | 960 | -- |
283 | 2.20.1 | 961 | 2.20.1 |
284 | 962 | ||
285 | 963 | diff view generated by jsdifflib |
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | 1 | From: Tong Ho <tong.ho@xilinx.com> |
---|---|---|---|
2 | 2 | ||
3 | Remove inclusion of arm_gicv3_common.h, this already gets | 3 | This device is present in Versal and ZynqMP product |
4 | included via xlnx-versal.h. | 4 | families to store a 256-bit encryption key. |
5 | |||
6 | Co-authored-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | ||
7 | Co-authored-by: Sai Pavan Boddu <sai.pavan.boddu@xilinx.com> | ||
5 | 8 | ||
6 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 9 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> |
7 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | 10 | Signed-off-by: Sai Pavan Boddu <sai.pavan.boddu@xilinx.com> |
8 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | 11 | Signed-off-by: Tong Ho <tong.ho@xilinx.com> |
9 | Message-id: 20200427181649.26851-2-edgar.iglesias@gmail.com | 12 | Message-id: 20210917052400.1249094-5-tong.ho@xilinx.com |
13 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 14 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | --- | 15 | --- |
12 | hw/arm/xlnx-versal.c | 1 - | 16 | include/hw/nvram/xlnx-bbram.h | 54 ++++ |
13 | 1 file changed, 1 deletion(-) | 17 | hw/nvram/xlnx-bbram.c | 545 ++++++++++++++++++++++++++++++++++ |
18 | hw/nvram/Kconfig | 4 + | ||
19 | hw/nvram/meson.build | 1 + | ||
20 | 4 files changed, 604 insertions(+) | ||
21 | create mode 100644 include/hw/nvram/xlnx-bbram.h | ||
22 | create mode 100644 hw/nvram/xlnx-bbram.c | ||
14 | 23 | ||
15 | diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c | 24 | diff --git a/include/hw/nvram/xlnx-bbram.h b/include/hw/nvram/xlnx-bbram.h |
25 | new file mode 100644 | ||
26 | index XXXXXXX..XXXXXXX | ||
27 | --- /dev/null | ||
28 | +++ b/include/hw/nvram/xlnx-bbram.h | ||
29 | @@ -XXX,XX +XXX,XX @@ | ||
30 | +/* | ||
31 | + * QEMU model of the Xilinx BBRAM Battery Backed RAM | ||
32 | + * | ||
33 | + * Copyright (c) 2015-2021 Xilinx Inc. | ||
34 | + * | ||
35 | + * Written by Edgar E. Iglesias <edgari@xilinx.com> | ||
36 | + * | ||
37 | + * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
38 | + * of this software and associated documentation files (the "Software"), to deal | ||
39 | + * in the Software without restriction, including without limitation the rights | ||
40 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
41 | + * copies of the Software, and to permit persons to whom the Software is | ||
42 | + * furnished to do so, subject to the following conditions: | ||
43 | + * | ||
44 | + * The above copyright notice and this permission notice shall be included in | ||
45 | + * all copies or substantial portions of the Software. | ||
46 | + * | ||
47 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
48 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
49 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
50 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
51 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
52 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
53 | + * THE SOFTWARE. | ||
54 | + */ | ||
55 | +#ifndef XLNX_BBRAM_H | ||
56 | +#define XLNX_BBRAM_H | ||
57 | + | ||
58 | +#include "sysemu/block-backend.h" | ||
59 | +#include "hw/qdev-core.h" | ||
60 | +#include "hw/irq.h" | ||
61 | +#include "hw/sysbus.h" | ||
62 | +#include "hw/register.h" | ||
63 | + | ||
64 | +#define RMAX_XLNX_BBRAM ((0x4c / 4) + 1) | ||
65 | + | ||
66 | +#define TYPE_XLNX_BBRAM "xlnx,bbram-ctrl" | ||
67 | +OBJECT_DECLARE_SIMPLE_TYPE(XlnxBBRam, XLNX_BBRAM); | ||
68 | + | ||
69 | +struct XlnxBBRam { | ||
70 | + SysBusDevice parent_obj; | ||
71 | + qemu_irq irq_bbram; | ||
72 | + | ||
73 | + BlockBackend *blk; | ||
74 | + | ||
75 | + uint32_t crc_zpads; | ||
76 | + bool bbram8_wo; | ||
77 | + bool blk_ro; | ||
78 | + | ||
79 | + uint32_t regs[RMAX_XLNX_BBRAM]; | ||
80 | + RegisterInfo regs_info[RMAX_XLNX_BBRAM]; | ||
81 | +}; | ||
82 | + | ||
83 | +#endif | ||
84 | diff --git a/hw/nvram/xlnx-bbram.c b/hw/nvram/xlnx-bbram.c | ||
85 | new file mode 100644 | ||
86 | index XXXXXXX..XXXXXXX | ||
87 | --- /dev/null | ||
88 | +++ b/hw/nvram/xlnx-bbram.c | ||
89 | @@ -XXX,XX +XXX,XX @@ | ||
90 | +/* | ||
91 | + * QEMU model of the Xilinx BBRAM Battery Backed RAM | ||
92 | + * | ||
93 | + * Copyright (c) 2014-2021 Xilinx Inc. | ||
94 | + * | ||
95 | + * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
96 | + * of this software and associated documentation files (the "Software"), to deal | ||
97 | + * in the Software without restriction, including without limitation the rights | ||
98 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
99 | + * copies of the Software, and to permit persons to whom the Software is | ||
100 | + * furnished to do so, subject to the following conditions: | ||
101 | + * | ||
102 | + * The above copyright notice and this permission notice shall be included in | ||
103 | + * all copies or substantial portions of the Software. | ||
104 | + * | ||
105 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
106 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
107 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
108 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
109 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
110 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
111 | + * THE SOFTWARE. | ||
112 | + */ | ||
113 | + | ||
114 | +#include "qemu/osdep.h" | ||
115 | +#include "hw/nvram/xlnx-bbram.h" | ||
116 | + | ||
117 | +#include "qemu/error-report.h" | ||
118 | +#include "qemu/log.h" | ||
119 | +#include "qapi/error.h" | ||
120 | +#include "sysemu/blockdev.h" | ||
121 | +#include "migration/vmstate.h" | ||
122 | +#include "hw/qdev-properties.h" | ||
123 | +#include "hw/qdev-properties-system.h" | ||
124 | +#include "hw/nvram/xlnx-efuse.h" | ||
125 | + | ||
126 | +#ifndef XLNX_BBRAM_ERR_DEBUG | ||
127 | +#define XLNX_BBRAM_ERR_DEBUG 0 | ||
128 | +#endif | ||
129 | + | ||
130 | +REG32(BBRAM_STATUS, 0x0) | ||
131 | + FIELD(BBRAM_STATUS, AES_CRC_PASS, 9, 1) | ||
132 | + FIELD(BBRAM_STATUS, AES_CRC_DONE, 8, 1) | ||
133 | + FIELD(BBRAM_STATUS, BBRAM_ZEROIZED, 4, 1) | ||
134 | + FIELD(BBRAM_STATUS, PGM_MODE, 0, 1) | ||
135 | +REG32(BBRAM_CTRL, 0x4) | ||
136 | + FIELD(BBRAM_CTRL, ZEROIZE, 0, 1) | ||
137 | +REG32(PGM_MODE, 0x8) | ||
138 | +REG32(BBRAM_AES_CRC, 0xc) | ||
139 | +REG32(BBRAM_0, 0x10) | ||
140 | +REG32(BBRAM_1, 0x14) | ||
141 | +REG32(BBRAM_2, 0x18) | ||
142 | +REG32(BBRAM_3, 0x1c) | ||
143 | +REG32(BBRAM_4, 0x20) | ||
144 | +REG32(BBRAM_5, 0x24) | ||
145 | +REG32(BBRAM_6, 0x28) | ||
146 | +REG32(BBRAM_7, 0x2c) | ||
147 | +REG32(BBRAM_8, 0x30) | ||
148 | +REG32(BBRAM_SLVERR, 0x34) | ||
149 | + FIELD(BBRAM_SLVERR, ENABLE, 0, 1) | ||
150 | +REG32(BBRAM_ISR, 0x38) | ||
151 | + FIELD(BBRAM_ISR, APB_SLVERR, 0, 1) | ||
152 | +REG32(BBRAM_IMR, 0x3c) | ||
153 | + FIELD(BBRAM_IMR, APB_SLVERR, 0, 1) | ||
154 | +REG32(BBRAM_IER, 0x40) | ||
155 | + FIELD(BBRAM_IER, APB_SLVERR, 0, 1) | ||
156 | +REG32(BBRAM_IDR, 0x44) | ||
157 | + FIELD(BBRAM_IDR, APB_SLVERR, 0, 1) | ||
158 | +REG32(BBRAM_MSW_LOCK, 0x4c) | ||
159 | + FIELD(BBRAM_MSW_LOCK, VAL, 0, 1) | ||
160 | + | ||
161 | +#define R_MAX (R_BBRAM_MSW_LOCK + 1) | ||
162 | + | ||
163 | +#define RAM_MAX (A_BBRAM_8 + 4 - A_BBRAM_0) | ||
164 | + | ||
165 | +#define BBRAM_PGM_MAGIC 0x757bdf0d | ||
166 | + | ||
167 | +QEMU_BUILD_BUG_ON(R_MAX != ARRAY_SIZE(((XlnxBBRam *)0)->regs)); | ||
168 | + | ||
169 | +static bool bbram_msw_locked(XlnxBBRam *s) | ||
170 | +{ | ||
171 | + return ARRAY_FIELD_EX32(s->regs, BBRAM_MSW_LOCK, VAL) != 0; | ||
172 | +} | ||
173 | + | ||
174 | +static bool bbram_pgm_enabled(XlnxBBRam *s) | ||
175 | +{ | ||
176 | + return ARRAY_FIELD_EX32(s->regs, BBRAM_STATUS, PGM_MODE) != 0; | ||
177 | +} | ||
178 | + | ||
179 | +static void bbram_bdrv_error(XlnxBBRam *s, int rc, gchar *detail) | ||
180 | +{ | ||
181 | + Error *errp; | ||
182 | + | ||
183 | + error_setg_errno(&errp, -rc, "%s: BBRAM backstore %s failed.", | ||
184 | + blk_name(s->blk), detail); | ||
185 | + error_report("%s", error_get_pretty(errp)); | ||
186 | + error_free(errp); | ||
187 | + | ||
188 | + g_free(detail); | ||
189 | +} | ||
190 | + | ||
191 | +static void bbram_bdrv_read(XlnxBBRam *s, Error **errp) | ||
192 | +{ | ||
193 | + uint32_t *ram = &s->regs[R_BBRAM_0]; | ||
194 | + int nr = RAM_MAX; | ||
195 | + | ||
196 | + if (!s->blk) { | ||
197 | + return; | ||
198 | + } | ||
199 | + | ||
200 | + s->blk_ro = !blk_supports_write_perm(s->blk); | ||
201 | + if (!s->blk_ro) { | ||
202 | + int rc; | ||
203 | + | ||
204 | + rc = blk_set_perm(s->blk, | ||
205 | + (BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE), | ||
206 | + BLK_PERM_ALL, NULL); | ||
207 | + if (rc) { | ||
208 | + s->blk_ro = true; | ||
209 | + } | ||
210 | + } | ||
211 | + if (s->blk_ro) { | ||
212 | + warn_report("%s: Skip saving updates to read-only BBRAM backstore.", | ||
213 | + blk_name(s->blk)); | ||
214 | + } | ||
215 | + | ||
216 | + if (blk_pread(s->blk, 0, ram, nr) < 0) { | ||
217 | + error_setg(errp, | ||
218 | + "%s: Failed to read %u bytes from BBRAM backstore.", | ||
219 | + blk_name(s->blk), nr); | ||
220 | + return; | ||
221 | + } | ||
222 | + | ||
223 | + /* Convert from little-endian backstore for each 32-bit word */ | ||
224 | + nr /= 4; | ||
225 | + while (nr--) { | ||
226 | + ram[nr] = le32_to_cpu(ram[nr]); | ||
227 | + } | ||
228 | +} | ||
229 | + | ||
230 | +static void bbram_bdrv_sync(XlnxBBRam *s, uint64_t hwaddr) | ||
231 | +{ | ||
232 | + uint32_t le32; | ||
233 | + unsigned offset; | ||
234 | + int rc; | ||
235 | + | ||
236 | + assert(A_BBRAM_0 <= hwaddr && hwaddr <= A_BBRAM_8); | ||
237 | + | ||
238 | + /* Backstore is always in little-endian */ | ||
239 | + le32 = cpu_to_le32(s->regs[hwaddr / 4]); | ||
240 | + | ||
241 | + /* Update zeroized flag */ | ||
242 | + if (le32 && (hwaddr != A_BBRAM_8 || s->bbram8_wo)) { | ||
243 | + ARRAY_FIELD_DP32(s->regs, BBRAM_STATUS, BBRAM_ZEROIZED, 0); | ||
244 | + } | ||
245 | + | ||
246 | + if (!s->blk || s->blk_ro) { | ||
247 | + return; | ||
248 | + } | ||
249 | + | ||
250 | + offset = hwaddr - A_BBRAM_0; | ||
251 | + rc = blk_pwrite(s->blk, offset, &le32, 4, 0); | ||
252 | + if (rc < 0) { | ||
253 | + bbram_bdrv_error(s, rc, g_strdup_printf("write to offset %u", offset)); | ||
254 | + } | ||
255 | +} | ||
256 | + | ||
257 | +static void bbram_bdrv_zero(XlnxBBRam *s) | ||
258 | +{ | ||
259 | + int rc; | ||
260 | + | ||
261 | + ARRAY_FIELD_DP32(s->regs, BBRAM_STATUS, BBRAM_ZEROIZED, 1); | ||
262 | + | ||
263 | + if (!s->blk || s->blk_ro) { | ||
264 | + return; | ||
265 | + } | ||
266 | + | ||
267 | + rc = blk_make_zero(s->blk, 0); | ||
268 | + if (rc < 0) { | ||
269 | + bbram_bdrv_error(s, rc, g_strdup("zeroizing")); | ||
270 | + } | ||
271 | + | ||
272 | + /* Restore bbram8 if it is non-zero */ | ||
273 | + if (s->regs[R_BBRAM_8]) { | ||
274 | + bbram_bdrv_sync(s, A_BBRAM_8); | ||
275 | + } | ||
276 | +} | ||
277 | + | ||
278 | +static void bbram_zeroize(XlnxBBRam *s) | ||
279 | +{ | ||
280 | + int nr = RAM_MAX - (s->bbram8_wo ? 0 : 4); /* only wo bbram8 is cleared */ | ||
281 | + | ||
282 | + memset(&s->regs[R_BBRAM_0], 0, nr); | ||
283 | + bbram_bdrv_zero(s); | ||
284 | +} | ||
285 | + | ||
286 | +static void bbram_update_irq(XlnxBBRam *s) | ||
287 | +{ | ||
288 | + bool pending = s->regs[R_BBRAM_ISR] & ~s->regs[R_BBRAM_IMR]; | ||
289 | + | ||
290 | + qemu_set_irq(s->irq_bbram, pending); | ||
291 | +} | ||
292 | + | ||
293 | +static void bbram_ctrl_postw(RegisterInfo *reg, uint64_t val64) | ||
294 | +{ | ||
295 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
296 | + uint32_t val = val64; | ||
297 | + | ||
298 | + if (val & R_BBRAM_CTRL_ZEROIZE_MASK) { | ||
299 | + bbram_zeroize(s); | ||
300 | + /* The bit is self clearing */ | ||
301 | + s->regs[R_BBRAM_CTRL] &= ~R_BBRAM_CTRL_ZEROIZE_MASK; | ||
302 | + } | ||
303 | +} | ||
304 | + | ||
305 | +static void bbram_pgm_mode_postw(RegisterInfo *reg, uint64_t val64) | ||
306 | +{ | ||
307 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
308 | + uint32_t val = val64; | ||
309 | + | ||
310 | + if (val == BBRAM_PGM_MAGIC) { | ||
311 | + bbram_zeroize(s); | ||
312 | + | ||
313 | + /* The status bit is cleared only by POR */ | ||
314 | + ARRAY_FIELD_DP32(s->regs, BBRAM_STATUS, PGM_MODE, 1); | ||
315 | + } | ||
316 | +} | ||
317 | + | ||
318 | +static void bbram_aes_crc_postw(RegisterInfo *reg, uint64_t val64) | ||
319 | +{ | ||
320 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
321 | + uint32_t calc_crc; | ||
322 | + | ||
323 | + if (!bbram_pgm_enabled(s)) { | ||
324 | + /* We are not in programming mode, don't do anything */ | ||
325 | + return; | ||
326 | + } | ||
327 | + | ||
328 | + /* Perform the AES integrity check */ | ||
329 | + s->regs[R_BBRAM_STATUS] |= R_BBRAM_STATUS_AES_CRC_DONE_MASK; | ||
330 | + | ||
331 | + /* | ||
332 | + * Set check status. | ||
333 | + * | ||
334 | + * ZynqMP BBRAM check has a zero-u32 prepended; see: | ||
335 | + * https://github.com/Xilinx/embeddedsw/blob/release-2019.2/lib/sw_services/xilskey/src/xilskey_bbramps_zynqmp.c#L311 | ||
336 | + */ | ||
337 | + calc_crc = xlnx_efuse_calc_crc(&s->regs[R_BBRAM_0], | ||
338 | + (R_BBRAM_8 - R_BBRAM_0), s->crc_zpads); | ||
339 | + | ||
340 | + ARRAY_FIELD_DP32(s->regs, BBRAM_STATUS, AES_CRC_PASS, | ||
341 | + (s->regs[R_BBRAM_AES_CRC] == calc_crc)); | ||
342 | +} | ||
343 | + | ||
344 | +static uint64_t bbram_key_prew(RegisterInfo *reg, uint64_t val64) | ||
345 | +{ | ||
346 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
347 | + uint32_t original_data = *(uint32_t *) reg->data; | ||
348 | + | ||
349 | + if (bbram_pgm_enabled(s)) { | ||
350 | + return val64; | ||
351 | + } else { | ||
352 | + /* We are not in programming mode, don't do anything */ | ||
353 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
354 | + "Not in programming mode, dropping the write\n"); | ||
355 | + return original_data; | ||
356 | + } | ||
357 | +} | ||
358 | + | ||
359 | +static void bbram_key_postw(RegisterInfo *reg, uint64_t val64) | ||
360 | +{ | ||
361 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
362 | + | ||
363 | + bbram_bdrv_sync(s, reg->access->addr); | ||
364 | +} | ||
365 | + | ||
366 | +static uint64_t bbram_wo_postr(RegisterInfo *reg, uint64_t val) | ||
367 | +{ | ||
368 | + return 0; | ||
369 | +} | ||
370 | + | ||
371 | +static uint64_t bbram_r8_postr(RegisterInfo *reg, uint64_t val) | ||
372 | +{ | ||
373 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
374 | + | ||
375 | + return s->bbram8_wo ? bbram_wo_postr(reg, val) : val; | ||
376 | +} | ||
377 | + | ||
378 | +static bool bbram_r8_readonly(XlnxBBRam *s) | ||
379 | +{ | ||
380 | + return !bbram_pgm_enabled(s) || bbram_msw_locked(s); | ||
381 | +} | ||
382 | + | ||
383 | +static uint64_t bbram_r8_prew(RegisterInfo *reg, uint64_t val64) | ||
384 | +{ | ||
385 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
386 | + | ||
387 | + if (bbram_r8_readonly(s)) { | ||
388 | + val64 = *(uint32_t *)reg->data; | ||
389 | + } | ||
390 | + | ||
391 | + return val64; | ||
392 | +} | ||
393 | + | ||
394 | +static void bbram_r8_postw(RegisterInfo *reg, uint64_t val64) | ||
395 | +{ | ||
396 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
397 | + | ||
398 | + if (!bbram_r8_readonly(s)) { | ||
399 | + bbram_bdrv_sync(s, A_BBRAM_8); | ||
400 | + } | ||
401 | +} | ||
402 | + | ||
403 | +static uint64_t bbram_msw_lock_prew(RegisterInfo *reg, uint64_t val64) | ||
404 | +{ | ||
405 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
406 | + | ||
407 | + /* Never lock if bbram8 is wo; and, only POR can clear the lock */ | ||
408 | + if (s->bbram8_wo) { | ||
409 | + val64 = 0; | ||
410 | + } else { | ||
411 | + val64 |= s->regs[R_BBRAM_MSW_LOCK]; | ||
412 | + } | ||
413 | + | ||
414 | + return val64; | ||
415 | +} | ||
416 | + | ||
417 | +static void bbram_isr_postw(RegisterInfo *reg, uint64_t val64) | ||
418 | +{ | ||
419 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
420 | + | ||
421 | + bbram_update_irq(s); | ||
422 | +} | ||
423 | + | ||
424 | +static uint64_t bbram_ier_prew(RegisterInfo *reg, uint64_t val64) | ||
425 | +{ | ||
426 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
427 | + uint32_t val = val64; | ||
428 | + | ||
429 | + s->regs[R_BBRAM_IMR] &= ~val; | ||
430 | + bbram_update_irq(s); | ||
431 | + return 0; | ||
432 | +} | ||
433 | + | ||
434 | +static uint64_t bbram_idr_prew(RegisterInfo *reg, uint64_t val64) | ||
435 | +{ | ||
436 | + XlnxBBRam *s = XLNX_BBRAM(reg->opaque); | ||
437 | + uint32_t val = val64; | ||
438 | + | ||
439 | + s->regs[R_BBRAM_IMR] |= val; | ||
440 | + bbram_update_irq(s); | ||
441 | + return 0; | ||
442 | +} | ||
443 | + | ||
444 | +static RegisterAccessInfo bbram_ctrl_regs_info[] = { | ||
445 | + { .name = "BBRAM_STATUS", .addr = A_BBRAM_STATUS, | ||
446 | + .rsvd = 0xee, | ||
447 | + .ro = 0x3ff, | ||
448 | + },{ .name = "BBRAM_CTRL", .addr = A_BBRAM_CTRL, | ||
449 | + .post_write = bbram_ctrl_postw, | ||
450 | + },{ .name = "PGM_MODE", .addr = A_PGM_MODE, | ||
451 | + .post_write = bbram_pgm_mode_postw, | ||
452 | + },{ .name = "BBRAM_AES_CRC", .addr = A_BBRAM_AES_CRC, | ||
453 | + .post_write = bbram_aes_crc_postw, | ||
454 | + .post_read = bbram_wo_postr, | ||
455 | + },{ .name = "BBRAM_0", .addr = A_BBRAM_0, | ||
456 | + .pre_write = bbram_key_prew, | ||
457 | + .post_write = bbram_key_postw, | ||
458 | + .post_read = bbram_wo_postr, | ||
459 | + },{ .name = "BBRAM_1", .addr = A_BBRAM_1, | ||
460 | + .pre_write = bbram_key_prew, | ||
461 | + .post_write = bbram_key_postw, | ||
462 | + .post_read = bbram_wo_postr, | ||
463 | + },{ .name = "BBRAM_2", .addr = A_BBRAM_2, | ||
464 | + .pre_write = bbram_key_prew, | ||
465 | + .post_write = bbram_key_postw, | ||
466 | + .post_read = bbram_wo_postr, | ||
467 | + },{ .name = "BBRAM_3", .addr = A_BBRAM_3, | ||
468 | + .pre_write = bbram_key_prew, | ||
469 | + .post_write = bbram_key_postw, | ||
470 | + .post_read = bbram_wo_postr, | ||
471 | + },{ .name = "BBRAM_4", .addr = A_BBRAM_4, | ||
472 | + .pre_write = bbram_key_prew, | ||
473 | + .post_write = bbram_key_postw, | ||
474 | + .post_read = bbram_wo_postr, | ||
475 | + },{ .name = "BBRAM_5", .addr = A_BBRAM_5, | ||
476 | + .pre_write = bbram_key_prew, | ||
477 | + .post_write = bbram_key_postw, | ||
478 | + .post_read = bbram_wo_postr, | ||
479 | + },{ .name = "BBRAM_6", .addr = A_BBRAM_6, | ||
480 | + .pre_write = bbram_key_prew, | ||
481 | + .post_write = bbram_key_postw, | ||
482 | + .post_read = bbram_wo_postr, | ||
483 | + },{ .name = "BBRAM_7", .addr = A_BBRAM_7, | ||
484 | + .pre_write = bbram_key_prew, | ||
485 | + .post_write = bbram_key_postw, | ||
486 | + .post_read = bbram_wo_postr, | ||
487 | + },{ .name = "BBRAM_8", .addr = A_BBRAM_8, | ||
488 | + .pre_write = bbram_r8_prew, | ||
489 | + .post_write = bbram_r8_postw, | ||
490 | + .post_read = bbram_r8_postr, | ||
491 | + },{ .name = "BBRAM_SLVERR", .addr = A_BBRAM_SLVERR, | ||
492 | + .rsvd = ~1, | ||
493 | + },{ .name = "BBRAM_ISR", .addr = A_BBRAM_ISR, | ||
494 | + .w1c = 0x1, | ||
495 | + .post_write = bbram_isr_postw, | ||
496 | + },{ .name = "BBRAM_IMR", .addr = A_BBRAM_IMR, | ||
497 | + .ro = 0x1, | ||
498 | + },{ .name = "BBRAM_IER", .addr = A_BBRAM_IER, | ||
499 | + .pre_write = bbram_ier_prew, | ||
500 | + },{ .name = "BBRAM_IDR", .addr = A_BBRAM_IDR, | ||
501 | + .pre_write = bbram_idr_prew, | ||
502 | + },{ .name = "BBRAM_MSW_LOCK", .addr = A_BBRAM_MSW_LOCK, | ||
503 | + .pre_write = bbram_msw_lock_prew, | ||
504 | + .ro = ~R_BBRAM_MSW_LOCK_VAL_MASK, | ||
505 | + } | ||
506 | +}; | ||
507 | + | ||
508 | +static void bbram_ctrl_reset(DeviceState *dev) | ||
509 | +{ | ||
510 | + XlnxBBRam *s = XLNX_BBRAM(dev); | ||
511 | + unsigned int i; | ||
512 | + | ||
513 | + for (i = 0; i < ARRAY_SIZE(s->regs_info); ++i) { | ||
514 | + if (i < R_BBRAM_0 || i > R_BBRAM_8) { | ||
515 | + register_reset(&s->regs_info[i]); | ||
516 | + } | ||
517 | + } | ||
518 | + | ||
519 | + bbram_update_irq(s); | ||
520 | +} | ||
521 | + | ||
522 | +static const MemoryRegionOps bbram_ctrl_ops = { | ||
523 | + .read = register_read_memory, | ||
524 | + .write = register_write_memory, | ||
525 | + .endianness = DEVICE_LITTLE_ENDIAN, | ||
526 | + .valid = { | ||
527 | + .min_access_size = 4, | ||
528 | + .max_access_size = 4, | ||
529 | + }, | ||
530 | +}; | ||
531 | + | ||
532 | +static void bbram_ctrl_realize(DeviceState *dev, Error **errp) | ||
533 | +{ | ||
534 | + XlnxBBRam *s = XLNX_BBRAM(dev); | ||
535 | + | ||
536 | + if (s->crc_zpads) { | ||
537 | + s->bbram8_wo = true; | ||
538 | + } | ||
539 | + | ||
540 | + bbram_bdrv_read(s, errp); | ||
541 | +} | ||
542 | + | ||
543 | +static void bbram_ctrl_init(Object *obj) | ||
544 | +{ | ||
545 | + XlnxBBRam *s = XLNX_BBRAM(obj); | ||
546 | + SysBusDevice *sbd = SYS_BUS_DEVICE(obj); | ||
547 | + RegisterInfoArray *reg_array; | ||
548 | + | ||
549 | + reg_array = | ||
550 | + register_init_block32(DEVICE(obj), bbram_ctrl_regs_info, | ||
551 | + ARRAY_SIZE(bbram_ctrl_regs_info), | ||
552 | + s->regs_info, s->regs, | ||
553 | + &bbram_ctrl_ops, | ||
554 | + XLNX_BBRAM_ERR_DEBUG, | ||
555 | + R_MAX * 4); | ||
556 | + | ||
557 | + sysbus_init_mmio(sbd, ®_array->mem); | ||
558 | + sysbus_init_irq(sbd, &s->irq_bbram); | ||
559 | +} | ||
560 | + | ||
561 | +static void bbram_prop_set_drive(Object *obj, Visitor *v, const char *name, | ||
562 | + void *opaque, Error **errp) | ||
563 | +{ | ||
564 | + DeviceState *dev = DEVICE(obj); | ||
565 | + | ||
566 | + qdev_prop_drive.set(obj, v, name, opaque, errp); | ||
567 | + | ||
568 | + /* Fill initial data if backend is attached after realized */ | ||
569 | + if (dev->realized) { | ||
570 | + bbram_bdrv_read(XLNX_BBRAM(obj), errp); | ||
571 | + } | ||
572 | +} | ||
573 | + | ||
574 | +static void bbram_prop_get_drive(Object *obj, Visitor *v, const char *name, | ||
575 | + void *opaque, Error **errp) | ||
576 | +{ | ||
577 | + qdev_prop_drive.get(obj, v, name, opaque, errp); | ||
578 | +} | ||
579 | + | ||
580 | +static void bbram_prop_release_drive(Object *obj, const char *name, | ||
581 | + void *opaque) | ||
582 | +{ | ||
583 | + qdev_prop_drive.release(obj, name, opaque); | ||
584 | +} | ||
585 | + | ||
586 | +static const PropertyInfo bbram_prop_drive = { | ||
587 | + .name = "str", | ||
588 | + .description = "Node name or ID of a block device to use as BBRAM backend", | ||
589 | + .realized_set_allowed = true, | ||
590 | + .get = bbram_prop_get_drive, | ||
591 | + .set = bbram_prop_set_drive, | ||
592 | + .release = bbram_prop_release_drive, | ||
593 | +}; | ||
594 | + | ||
595 | +static const VMStateDescription vmstate_bbram_ctrl = { | ||
596 | + .name = TYPE_XLNX_BBRAM, | ||
597 | + .version_id = 1, | ||
598 | + .minimum_version_id = 1, | ||
599 | + .fields = (VMStateField[]) { | ||
600 | + VMSTATE_UINT32_ARRAY(regs, XlnxBBRam, R_MAX), | ||
601 | + VMSTATE_END_OF_LIST(), | ||
602 | + } | ||
603 | +}; | ||
604 | + | ||
605 | +static Property bbram_ctrl_props[] = { | ||
606 | + DEFINE_PROP("drive", XlnxBBRam, blk, bbram_prop_drive, BlockBackend *), | ||
607 | + DEFINE_PROP_UINT32("crc-zpads", XlnxBBRam, crc_zpads, 1), | ||
608 | + DEFINE_PROP_END_OF_LIST(), | ||
609 | +}; | ||
610 | + | ||
611 | +static void bbram_ctrl_class_init(ObjectClass *klass, void *data) | ||
612 | +{ | ||
613 | + DeviceClass *dc = DEVICE_CLASS(klass); | ||
614 | + | ||
615 | + dc->reset = bbram_ctrl_reset; | ||
616 | + dc->realize = bbram_ctrl_realize; | ||
617 | + dc->vmsd = &vmstate_bbram_ctrl; | ||
618 | + device_class_set_props(dc, bbram_ctrl_props); | ||
619 | +} | ||
620 | + | ||
621 | +static const TypeInfo bbram_ctrl_info = { | ||
622 | + .name = TYPE_XLNX_BBRAM, | ||
623 | + .parent = TYPE_SYS_BUS_DEVICE, | ||
624 | + .instance_size = sizeof(XlnxBBRam), | ||
625 | + .class_init = bbram_ctrl_class_init, | ||
626 | + .instance_init = bbram_ctrl_init, | ||
627 | +}; | ||
628 | + | ||
629 | +static void bbram_ctrl_register_types(void) | ||
630 | +{ | ||
631 | + type_register_static(&bbram_ctrl_info); | ||
632 | +} | ||
633 | + | ||
634 | +type_init(bbram_ctrl_register_types) | ||
635 | diff --git a/hw/nvram/Kconfig b/hw/nvram/Kconfig | ||
16 | index XXXXXXX..XXXXXXX 100644 | 636 | index XXXXXXX..XXXXXXX 100644 |
17 | --- a/hw/arm/xlnx-versal.c | 637 | --- a/hw/nvram/Kconfig |
18 | +++ b/hw/arm/xlnx-versal.c | 638 | +++ b/hw/nvram/Kconfig |
19 | @@ -XXX,XX +XXX,XX @@ | 639 | @@ -XXX,XX +XXX,XX @@ config XLNX_EFUSE_VERSAL |
20 | #include "hw/arm/boot.h" | 640 | config XLNX_EFUSE_ZYNQMP |
21 | #include "kvm_arm.h" | 641 | bool |
22 | #include "hw/misc/unimp.h" | 642 | select XLNX_EFUSE |
23 | -#include "hw/intc/arm_gicv3_common.h" | 643 | + |
24 | #include "hw/arm/xlnx-versal.h" | 644 | +config XLNX_BBRAM |
25 | #include "hw/char/pl011.h" | 645 | + bool |
26 | 646 | + select XLNX_EFUSE_CRC | |
647 | diff --git a/hw/nvram/meson.build b/hw/nvram/meson.build | ||
648 | index XXXXXXX..XXXXXXX 100644 | ||
649 | --- a/hw/nvram/meson.build | ||
650 | +++ b/hw/nvram/meson.build | ||
651 | @@ -XXX,XX +XXX,XX @@ softmmu_ss.add(when: 'CONFIG_XLNX_EFUSE_VERSAL', if_true: files( | ||
652 | 'xlnx-versal-efuse-ctrl.c')) | ||
653 | softmmu_ss.add(when: 'CONFIG_XLNX_EFUSE_ZYNQMP', if_true: files( | ||
654 | 'xlnx-zynqmp-efuse.c')) | ||
655 | +softmmu_ss.add(when: 'CONFIG_XLNX_BBRAM', if_true: files('xlnx-bbram.c')) | ||
656 | |||
657 | specific_ss.add(when: 'CONFIG_PSERIES', if_true: files('spapr_nvram.c')) | ||
27 | -- | 658 | -- |
28 | 2.20.1 | 659 | 2.20.1 |
29 | 660 | ||
30 | 661 | diff view generated by jsdifflib |
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | 1 | From: Tong Ho <tong.ho@xilinx.com> |
---|---|---|---|
2 | 2 | ||
3 | hw/arm: versal: Add support for the RTC. | 3 | Connect the support for Versal Battery-Backed RAM (BBRAM) |
4 | 4 | ||
5 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 5 | The command argument: |
6 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | 6 | -drive if=pflash,index=0,... |
7 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | 7 | Can be used to optionally connect the bbram to a backend |
8 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | 8 | storage, such that field-programmed values in one |
9 | Message-id: 20200427181649.26851-10-edgar.iglesias@gmail.com | 9 | invocation can be made available to next invocation. |
10 | |||
11 | The backend storage must be a seekable binary file, and | ||
12 | its size must be 36 bytes or larger. A file with all | ||
13 | binary 0's is a 'blank'. | ||
14 | |||
15 | Signed-off-by: Tong Ho <tong.ho@xilinx.com> | ||
16 | Message-id: 20210917052400.1249094-6-tong.ho@xilinx.com | ||
17 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 18 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | --- | 19 | --- |
12 | include/hw/arm/xlnx-versal.h | 8 ++++++++ | 20 | include/hw/arm/xlnx-versal.h | 5 +++++ |
13 | hw/arm/xlnx-versal.c | 21 +++++++++++++++++++++ | 21 | hw/arm/xlnx-versal-virt.c | 36 ++++++++++++++++++++++++++++++++++++ |
14 | 2 files changed, 29 insertions(+) | 22 | hw/arm/xlnx-versal.c | 18 ++++++++++++++++++ |
23 | hw/arm/Kconfig | 1 + | ||
24 | 4 files changed, 60 insertions(+) | ||
15 | 25 | ||
16 | diff --git a/include/hw/arm/xlnx-versal.h b/include/hw/arm/xlnx-versal.h | 26 | diff --git a/include/hw/arm/xlnx-versal.h b/include/hw/arm/xlnx-versal.h |
17 | index XXXXXXX..XXXXXXX 100644 | 27 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/include/hw/arm/xlnx-versal.h | 28 | --- a/include/hw/arm/xlnx-versal.h |
19 | +++ b/include/hw/arm/xlnx-versal.h | 29 | +++ b/include/hw/arm/xlnx-versal.h |
20 | @@ -XXX,XX +XXX,XX @@ | 30 | @@ -XXX,XX +XXX,XX @@ |
21 | #include "hw/char/pl011.h" | 31 | #include "qom/object.h" |
22 | #include "hw/dma/xlnx-zdma.h" | 32 | #include "hw/usb/xlnx-usb-subsystem.h" |
23 | #include "hw/net/cadence_gem.h" | 33 | #include "hw/misc/xlnx-versal-xramc.h" |
24 | +#include "hw/rtc/xlnx-zynqmp-rtc.h" | 34 | +#include "hw/nvram/xlnx-bbram.h" |
25 | 35 | ||
26 | #define TYPE_XLNX_VERSAL "xlnx-versal" | 36 | #define TYPE_XLNX_VERSAL "xlnx-versal" |
27 | #define XLNX_VERSAL(obj) OBJECT_CHECK(Versal, (obj), TYPE_XLNX_VERSAL) | 37 | OBJECT_DECLARE_SIMPLE_TYPE(Versal, XLNX_VERSAL) |
28 | @@ -XXX,XX +XXX,XX @@ typedef struct Versal { | 38 | @@ -XXX,XX +XXX,XX @@ struct Versal { |
29 | struct { | ||
30 | SDHCIState sd[XLNX_VERSAL_NR_SDS]; | ||
31 | } iou; | 39 | } iou; |
32 | + | 40 | |
33 | + XlnxZynqMPRTC rtc; | 41 | XlnxZynqMPRTC rtc; |
42 | + XlnxBBRam bbram; | ||
34 | } pmc; | 43 | } pmc; |
35 | 44 | ||
36 | struct { | 45 | struct { |
37 | @@ -XXX,XX +XXX,XX @@ typedef struct Versal { | 46 | @@ -XXX,XX +XXX,XX @@ struct Versal { |
38 | #define VERSAL_GEM1_IRQ_0 58 | ||
39 | #define VERSAL_GEM1_WAKE_IRQ_0 59 | 47 | #define VERSAL_GEM1_WAKE_IRQ_0 59 |
40 | #define VERSAL_ADMA_IRQ_0 60 | 48 | #define VERSAL_ADMA_IRQ_0 60 |
41 | +#define VERSAL_RTC_APB_ERR_IRQ 121 | 49 | #define VERSAL_XRAM_IRQ_0 79 |
50 | +#define VERSAL_BBRAM_APB_IRQ_0 121 | ||
51 | #define VERSAL_RTC_APB_ERR_IRQ 121 | ||
42 | #define VERSAL_SD0_IRQ_0 126 | 52 | #define VERSAL_SD0_IRQ_0 126 |
43 | +#define VERSAL_RTC_ALARM_IRQ 142 | 53 | #define VERSAL_RTC_ALARM_IRQ 142 |
44 | +#define VERSAL_RTC_SECONDS_IRQ 143 | 54 | @@ -XXX,XX +XXX,XX @@ struct Versal { |
45 | 55 | ||
46 | /* Architecturally reserved IRQs suitable for virtualization. */ | 56 | #define MM_PMC_SD0 0xf1040000U |
47 | #define VERSAL_RSVD_IRQ_FIRST 111 | ||
48 | @@ -XXX,XX +XXX,XX @@ typedef struct Versal { | ||
49 | #define MM_PMC_SD0_SIZE 0x10000 | 57 | #define MM_PMC_SD0_SIZE 0x10000 |
58 | +#define MM_PMC_BBRAM_CTRL 0xf11f0000 | ||
59 | +#define MM_PMC_BBRAM_CTRL_SIZE 0x00050 | ||
50 | #define MM_PMC_CRP 0xf1260000U | 60 | #define MM_PMC_CRP 0xf1260000U |
51 | #define MM_PMC_CRP_SIZE 0x10000 | 61 | #define MM_PMC_CRP_SIZE 0x10000 |
52 | +#define MM_PMC_RTC 0xf12a0000 | 62 | #define MM_PMC_RTC 0xf12a0000 |
53 | +#define MM_PMC_RTC_SIZE 0x10000 | 63 | diff --git a/hw/arm/xlnx-versal-virt.c b/hw/arm/xlnx-versal-virt.c |
54 | #endif | 64 | index XXXXXXX..XXXXXXX 100644 |
65 | --- a/hw/arm/xlnx-versal-virt.c | ||
66 | +++ b/hw/arm/xlnx-versal-virt.c | ||
67 | @@ -XXX,XX +XXX,XX @@ static void fdt_add_rtc_node(VersalVirt *s) | ||
68 | g_free(name); | ||
69 | } | ||
70 | |||
71 | +static void fdt_add_bbram_node(VersalVirt *s) | ||
72 | +{ | ||
73 | + const char compat[] = TYPE_XLNX_BBRAM; | ||
74 | + const char interrupt_names[] = "bbram-error"; | ||
75 | + char *name = g_strdup_printf("/bbram@%x", MM_PMC_BBRAM_CTRL); | ||
76 | + | ||
77 | + qemu_fdt_add_subnode(s->fdt, name); | ||
78 | + | ||
79 | + qemu_fdt_setprop_cells(s->fdt, name, "interrupts", | ||
80 | + GIC_FDT_IRQ_TYPE_SPI, VERSAL_BBRAM_APB_IRQ_0, | ||
81 | + GIC_FDT_IRQ_FLAGS_LEVEL_HI); | ||
82 | + qemu_fdt_setprop(s->fdt, name, "interrupt-names", | ||
83 | + interrupt_names, sizeof(interrupt_names)); | ||
84 | + qemu_fdt_setprop_sized_cells(s->fdt, name, "reg", | ||
85 | + 2, MM_PMC_BBRAM_CTRL, | ||
86 | + 2, MM_PMC_BBRAM_CTRL_SIZE); | ||
87 | + qemu_fdt_setprop(s->fdt, name, "compatible", compat, sizeof(compat)); | ||
88 | + g_free(name); | ||
89 | +} | ||
90 | + | ||
91 | static void fdt_nop_memory_nodes(void *fdt, Error **errp) | ||
92 | { | ||
93 | Error *err = NULL; | ||
94 | @@ -XXX,XX +XXX,XX @@ static void create_virtio_regions(VersalVirt *s) | ||
95 | } | ||
96 | } | ||
97 | |||
98 | +static void bbram_attach_drive(XlnxBBRam *dev) | ||
99 | +{ | ||
100 | + DriveInfo *dinfo; | ||
101 | + BlockBackend *blk; | ||
102 | + | ||
103 | + dinfo = drive_get_by_index(IF_PFLASH, 0); | ||
104 | + blk = dinfo ? blk_by_legacy_dinfo(dinfo) : NULL; | ||
105 | + if (blk) { | ||
106 | + qdev_prop_set_drive(DEVICE(dev), "drive", blk); | ||
107 | + } | ||
108 | +} | ||
109 | + | ||
110 | static void sd_plugin_card(SDHCIState *sd, DriveInfo *di) | ||
111 | { | ||
112 | BlockBackend *blk = di ? blk_by_legacy_dinfo(di) : NULL; | ||
113 | @@ -XXX,XX +XXX,XX @@ static void versal_virt_init(MachineState *machine) | ||
114 | fdt_add_usb_xhci_nodes(s); | ||
115 | fdt_add_sd_nodes(s); | ||
116 | fdt_add_rtc_node(s); | ||
117 | + fdt_add_bbram_node(s); | ||
118 | fdt_add_cpu_nodes(s, psci_conduit); | ||
119 | fdt_add_clk_node(s, "/clk125", 125000000, s->phandle.clk_125Mhz); | ||
120 | fdt_add_clk_node(s, "/clk25", 25000000, s->phandle.clk_25Mhz); | ||
121 | @@ -XXX,XX +XXX,XX @@ static void versal_virt_init(MachineState *machine) | ||
122 | memory_region_add_subregion_overlap(get_system_memory(), | ||
123 | 0, &s->soc.fpd.apu.mr, 0); | ||
124 | |||
125 | + /* Attach bbram backend, if given */ | ||
126 | + bbram_attach_drive(&s->soc.pmc.bbram); | ||
127 | + | ||
128 | /* Plugin SD cards. */ | ||
129 | for (i = 0; i < ARRAY_SIZE(s->soc.pmc.iou.sd); i++) { | ||
130 | sd_plugin_card(&s->soc.pmc.iou.sd[i], drive_get_next(IF_SD)); | ||
55 | diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c | 131 | diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c |
56 | index XXXXXXX..XXXXXXX 100644 | 132 | index XXXXXXX..XXXXXXX 100644 |
57 | --- a/hw/arm/xlnx-versal.c | 133 | --- a/hw/arm/xlnx-versal.c |
58 | +++ b/hw/arm/xlnx-versal.c | 134 | +++ b/hw/arm/xlnx-versal.c |
59 | @@ -XXX,XX +XXX,XX @@ static void versal_create_sds(Versal *s, qemu_irq *pic) | 135 | @@ -XXX,XX +XXX,XX @@ static void versal_create_xrams(Versal *s, qemu_irq *pic) |
60 | } | 136 | } |
61 | } | 137 | } |
62 | 138 | ||
63 | +static void versal_create_rtc(Versal *s, qemu_irq *pic) | 139 | +static void versal_create_bbram(Versal *s, qemu_irq *pic) |
64 | +{ | 140 | +{ |
65 | + SysBusDevice *sbd; | 141 | + SysBusDevice *sbd; |
66 | + MemoryRegion *mr; | ||
67 | + | 142 | + |
68 | + sysbus_init_child_obj(OBJECT(s), "rtc", &s->pmc.rtc, sizeof(s->pmc.rtc), | 143 | + object_initialize_child_with_props(OBJECT(s), "bbram", &s->pmc.bbram, |
69 | + TYPE_XLNX_ZYNQMP_RTC); | 144 | + sizeof(s->pmc.bbram), TYPE_XLNX_BBRAM, |
70 | + sbd = SYS_BUS_DEVICE(&s->pmc.rtc); | 145 | + &error_fatal, |
71 | + qdev_init_nofail(DEVICE(sbd)); | 146 | + "crc-zpads", "0", |
147 | + NULL); | ||
148 | + sbd = SYS_BUS_DEVICE(&s->pmc.bbram); | ||
72 | + | 149 | + |
73 | + mr = sysbus_mmio_get_region(sbd, 0); | 150 | + sysbus_realize(sbd, &error_fatal); |
74 | + memory_region_add_subregion(&s->mr_ps, MM_PMC_RTC, mr); | 151 | + memory_region_add_subregion(&s->mr_ps, MM_PMC_BBRAM_CTRL, |
75 | + | 152 | + sysbus_mmio_get_region(sbd, 0)); |
76 | + /* | 153 | + sysbus_connect_irq(sbd, 0, pic[VERSAL_BBRAM_APB_IRQ_0]); |
77 | + * TODO: Connect the ALARM and SECONDS interrupts once our RTC model | ||
78 | + * supports them. | ||
79 | + */ | ||
80 | + sysbus_connect_irq(sbd, 1, pic[VERSAL_RTC_APB_ERR_IRQ]); | ||
81 | +} | 154 | +} |
82 | + | 155 | + |
83 | /* This takes the board allocated linear DDR memory and creates aliases | 156 | /* This takes the board allocated linear DDR memory and creates aliases |
84 | * for each split DDR range/aperture on the Versal address map. | 157 | * for each split DDR range/aperture on the Versal address map. |
85 | */ | 158 | */ |
86 | @@ -XXX,XX +XXX,XX @@ static void versal_realize(DeviceState *dev, Error **errp) | 159 | @@ -XXX,XX +XXX,XX @@ static void versal_realize(DeviceState *dev, Error **errp) |
87 | versal_create_gems(s, pic); | ||
88 | versal_create_admas(s, pic); | ||
89 | versal_create_sds(s, pic); | 160 | versal_create_sds(s, pic); |
90 | + versal_create_rtc(s, pic); | 161 | versal_create_rtc(s, pic); |
162 | versal_create_xrams(s, pic); | ||
163 | + versal_create_bbram(s, pic); | ||
91 | versal_map_ddr(s); | 164 | versal_map_ddr(s); |
92 | versal_unimp(s); | 165 | versal_unimp(s); |
93 | 166 | ||
167 | diff --git a/hw/arm/Kconfig b/hw/arm/Kconfig | ||
168 | index XXXXXXX..XXXXXXX 100644 | ||
169 | --- a/hw/arm/Kconfig | ||
170 | +++ b/hw/arm/Kconfig | ||
171 | @@ -XXX,XX +XXX,XX @@ config XLNX_VERSAL | ||
172 | select XLNX_ZDMA | ||
173 | select XLNX_ZYNQMP | ||
174 | select OR_IRQ | ||
175 | + select XLNX_BBRAM | ||
176 | |||
177 | config NPCM7XX | ||
178 | bool | ||
94 | -- | 179 | -- |
95 | 2.20.1 | 180 | 2.20.1 |
96 | 181 | ||
97 | 182 | diff view generated by jsdifflib |
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | 1 | From: Tong Ho <tong.ho@xilinx.com> |
---|---|---|---|
2 | 2 | ||
3 | Add support for the RTC. | 3 | Connect the support for Versal eFUSE one-time field-programmable |
4 | 4 | bit array. | |
5 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 5 | |
6 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | 6 | The command argument: |
7 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | 7 | -drive if=pflash,index=1,... |
8 | Message-id: 20200427181649.26851-12-edgar.iglesias@gmail.com | 8 | Can be used to optionally connect the bit array to a |
9 | backend storage, such that field-programmed values | ||
10 | in one invocation can be made available to next | ||
11 | invocation. | ||
12 | |||
13 | The backend storage must be a seekable binary file, and | ||
14 | its size must be 3072 bytes or larger. A file with all | ||
15 | binary 0's is a 'blank'. | ||
16 | |||
17 | Signed-off-by: Tong Ho <tong.ho@xilinx.com> | ||
18 | Message-id: 20210917052400.1249094-7-tong.ho@xilinx.com | ||
19 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 20 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
10 | --- | 21 | --- |
11 | hw/arm/xlnx-versal-virt.c | 22 ++++++++++++++++++++++ | 22 | include/hw/arm/xlnx-versal.h | 10 +++++++ |
12 | 1 file changed, 22 insertions(+) | 23 | hw/arm/xlnx-versal-virt.c | 52 ++++++++++++++++++++++++++++++++++++ |
13 | 24 | hw/arm/xlnx-versal.c | 39 +++++++++++++++++++++++++++ | |
25 | hw/arm/Kconfig | 1 + | ||
26 | 4 files changed, 102 insertions(+) | ||
27 | |||
28 | diff --git a/include/hw/arm/xlnx-versal.h b/include/hw/arm/xlnx-versal.h | ||
29 | index XXXXXXX..XXXXXXX 100644 | ||
30 | --- a/include/hw/arm/xlnx-versal.h | ||
31 | +++ b/include/hw/arm/xlnx-versal.h | ||
32 | @@ -XXX,XX +XXX,XX @@ | ||
33 | #include "hw/usb/xlnx-usb-subsystem.h" | ||
34 | #include "hw/misc/xlnx-versal-xramc.h" | ||
35 | #include "hw/nvram/xlnx-bbram.h" | ||
36 | +#include "hw/nvram/xlnx-versal-efuse.h" | ||
37 | |||
38 | #define TYPE_XLNX_VERSAL "xlnx-versal" | ||
39 | OBJECT_DECLARE_SIMPLE_TYPE(Versal, XLNX_VERSAL) | ||
40 | @@ -XXX,XX +XXX,XX @@ struct Versal { | ||
41 | |||
42 | XlnxZynqMPRTC rtc; | ||
43 | XlnxBBRam bbram; | ||
44 | + XlnxEFuse efuse; | ||
45 | + XlnxVersalEFuseCtrl efuse_ctrl; | ||
46 | + XlnxVersalEFuseCache efuse_cache; | ||
47 | } pmc; | ||
48 | |||
49 | struct { | ||
50 | @@ -XXX,XX +XXX,XX @@ struct Versal { | ||
51 | #define VERSAL_BBRAM_APB_IRQ_0 121 | ||
52 | #define VERSAL_RTC_APB_ERR_IRQ 121 | ||
53 | #define VERSAL_SD0_IRQ_0 126 | ||
54 | +#define VERSAL_EFUSE_IRQ 139 | ||
55 | #define VERSAL_RTC_ALARM_IRQ 142 | ||
56 | #define VERSAL_RTC_SECONDS_IRQ 143 | ||
57 | |||
58 | @@ -XXX,XX +XXX,XX @@ struct Versal { | ||
59 | #define MM_PMC_SD0_SIZE 0x10000 | ||
60 | #define MM_PMC_BBRAM_CTRL 0xf11f0000 | ||
61 | #define MM_PMC_BBRAM_CTRL_SIZE 0x00050 | ||
62 | +#define MM_PMC_EFUSE_CTRL 0xf1240000 | ||
63 | +#define MM_PMC_EFUSE_CTRL_SIZE 0x00104 | ||
64 | +#define MM_PMC_EFUSE_CACHE 0xf1250000 | ||
65 | +#define MM_PMC_EFUSE_CACHE_SIZE 0x00C00 | ||
66 | + | ||
67 | #define MM_PMC_CRP 0xf1260000U | ||
68 | #define MM_PMC_CRP_SIZE 0x10000 | ||
69 | #define MM_PMC_RTC 0xf12a0000 | ||
14 | diff --git a/hw/arm/xlnx-versal-virt.c b/hw/arm/xlnx-versal-virt.c | 70 | diff --git a/hw/arm/xlnx-versal-virt.c b/hw/arm/xlnx-versal-virt.c |
15 | index XXXXXXX..XXXXXXX 100644 | 71 | index XXXXXXX..XXXXXXX 100644 |
16 | --- a/hw/arm/xlnx-versal-virt.c | 72 | --- a/hw/arm/xlnx-versal-virt.c |
17 | +++ b/hw/arm/xlnx-versal-virt.c | 73 | +++ b/hw/arm/xlnx-versal-virt.c |
18 | @@ -XXX,XX +XXX,XX @@ static void fdt_add_sd_nodes(VersalVirt *s) | 74 | @@ -XXX,XX +XXX,XX @@ static void fdt_add_bbram_node(VersalVirt *s) |
19 | } | 75 | g_free(name); |
20 | } | 76 | } |
21 | 77 | ||
22 | +static void fdt_add_rtc_node(VersalVirt *s) | 78 | +static void fdt_add_efuse_ctrl_node(VersalVirt *s) |
23 | +{ | 79 | +{ |
24 | + const char compat[] = "xlnx,zynqmp-rtc"; | 80 | + const char compat[] = TYPE_XLNX_VERSAL_EFUSE_CTRL; |
25 | + const char interrupt_names[] = "alarm\0sec"; | 81 | + const char interrupt_names[] = "pmc_efuse"; |
26 | + char *name = g_strdup_printf("/rtc@%x", MM_PMC_RTC); | 82 | + char *name = g_strdup_printf("/pmc_efuse@%x", MM_PMC_EFUSE_CTRL); |
27 | + | 83 | + |
28 | + qemu_fdt_add_subnode(s->fdt, name); | 84 | + qemu_fdt_add_subnode(s->fdt, name); |
29 | + | 85 | + |
30 | + qemu_fdt_setprop_cells(s->fdt, name, "interrupts", | 86 | + qemu_fdt_setprop_cells(s->fdt, name, "interrupts", |
31 | + GIC_FDT_IRQ_TYPE_SPI, VERSAL_RTC_ALARM_IRQ, | 87 | + GIC_FDT_IRQ_TYPE_SPI, VERSAL_EFUSE_IRQ, |
32 | + GIC_FDT_IRQ_FLAGS_LEVEL_HI, | ||
33 | + GIC_FDT_IRQ_TYPE_SPI, VERSAL_RTC_SECONDS_IRQ, | ||
34 | + GIC_FDT_IRQ_FLAGS_LEVEL_HI); | 88 | + GIC_FDT_IRQ_FLAGS_LEVEL_HI); |
35 | + qemu_fdt_setprop(s->fdt, name, "interrupt-names", | 89 | + qemu_fdt_setprop(s->fdt, name, "interrupt-names", |
36 | + interrupt_names, sizeof(interrupt_names)); | 90 | + interrupt_names, sizeof(interrupt_names)); |
37 | + qemu_fdt_setprop_sized_cells(s->fdt, name, "reg", | 91 | + qemu_fdt_setprop_sized_cells(s->fdt, name, "reg", |
38 | + 2, MM_PMC_RTC, 2, MM_PMC_RTC_SIZE); | 92 | + 2, MM_PMC_EFUSE_CTRL, |
93 | + 2, MM_PMC_EFUSE_CTRL_SIZE); | ||
94 | + qemu_fdt_setprop(s->fdt, name, "compatible", compat, sizeof(compat)); | ||
95 | + g_free(name); | ||
96 | +} | ||
97 | + | ||
98 | +static void fdt_add_efuse_cache_node(VersalVirt *s) | ||
99 | +{ | ||
100 | + const char compat[] = TYPE_XLNX_VERSAL_EFUSE_CACHE; | ||
101 | + char *name = g_strdup_printf("/xlnx_pmc_efuse_cache@%x", | ||
102 | + MM_PMC_EFUSE_CACHE); | ||
103 | + | ||
104 | + qemu_fdt_add_subnode(s->fdt, name); | ||
105 | + | ||
106 | + qemu_fdt_setprop_sized_cells(s->fdt, name, "reg", | ||
107 | + 2, MM_PMC_EFUSE_CACHE, | ||
108 | + 2, MM_PMC_EFUSE_CACHE_SIZE); | ||
39 | + qemu_fdt_setprop(s->fdt, name, "compatible", compat, sizeof(compat)); | 109 | + qemu_fdt_setprop(s->fdt, name, "compatible", compat, sizeof(compat)); |
40 | + g_free(name); | 110 | + g_free(name); |
41 | +} | 111 | +} |
42 | + | 112 | + |
43 | static void fdt_nop_memory_nodes(void *fdt, Error **errp) | 113 | static void fdt_nop_memory_nodes(void *fdt, Error **errp) |
44 | { | 114 | { |
45 | Error *err = NULL; | 115 | Error *err = NULL; |
116 | @@ -XXX,XX +XXX,XX @@ static void bbram_attach_drive(XlnxBBRam *dev) | ||
117 | } | ||
118 | } | ||
119 | |||
120 | +static void efuse_attach_drive(XlnxEFuse *dev) | ||
121 | +{ | ||
122 | + DriveInfo *dinfo; | ||
123 | + BlockBackend *blk; | ||
124 | + | ||
125 | + dinfo = drive_get_by_index(IF_PFLASH, 1); | ||
126 | + blk = dinfo ? blk_by_legacy_dinfo(dinfo) : NULL; | ||
127 | + if (blk) { | ||
128 | + qdev_prop_set_drive(DEVICE(dev), "drive", blk); | ||
129 | + } | ||
130 | +} | ||
131 | + | ||
132 | static void sd_plugin_card(SDHCIState *sd, DriveInfo *di) | ||
133 | { | ||
134 | BlockBackend *blk = di ? blk_by_legacy_dinfo(di) : NULL; | ||
46 | @@ -XXX,XX +XXX,XX @@ static void versal_virt_init(MachineState *machine) | 135 | @@ -XXX,XX +XXX,XX @@ static void versal_virt_init(MachineState *machine) |
47 | fdt_add_timer_nodes(s); | ||
48 | fdt_add_zdma_nodes(s); | ||
49 | fdt_add_sd_nodes(s); | 136 | fdt_add_sd_nodes(s); |
50 | + fdt_add_rtc_node(s); | 137 | fdt_add_rtc_node(s); |
138 | fdt_add_bbram_node(s); | ||
139 | + fdt_add_efuse_ctrl_node(s); | ||
140 | + fdt_add_efuse_cache_node(s); | ||
51 | fdt_add_cpu_nodes(s, psci_conduit); | 141 | fdt_add_cpu_nodes(s, psci_conduit); |
52 | fdt_add_clk_node(s, "/clk125", 125000000, s->phandle.clk_125Mhz); | 142 | fdt_add_clk_node(s, "/clk125", 125000000, s->phandle.clk_125Mhz); |
53 | fdt_add_clk_node(s, "/clk25", 25000000, s->phandle.clk_25Mhz); | 143 | fdt_add_clk_node(s, "/clk25", 25000000, s->phandle.clk_25Mhz); |
144 | @@ -XXX,XX +XXX,XX @@ static void versal_virt_init(MachineState *machine) | ||
145 | /* Attach bbram backend, if given */ | ||
146 | bbram_attach_drive(&s->soc.pmc.bbram); | ||
147 | |||
148 | + /* Attach efuse backend, if given */ | ||
149 | + efuse_attach_drive(&s->soc.pmc.efuse); | ||
150 | + | ||
151 | /* Plugin SD cards. */ | ||
152 | for (i = 0; i < ARRAY_SIZE(s->soc.pmc.iou.sd); i++) { | ||
153 | sd_plugin_card(&s->soc.pmc.iou.sd[i], drive_get_next(IF_SD)); | ||
154 | diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c | ||
155 | index XXXXXXX..XXXXXXX 100644 | ||
156 | --- a/hw/arm/xlnx-versal.c | ||
157 | +++ b/hw/arm/xlnx-versal.c | ||
158 | @@ -XXX,XX +XXX,XX @@ static void versal_create_bbram(Versal *s, qemu_irq *pic) | ||
159 | sysbus_connect_irq(sbd, 0, pic[VERSAL_BBRAM_APB_IRQ_0]); | ||
160 | } | ||
161 | |||
162 | +static void versal_realize_efuse_part(Versal *s, Object *dev, hwaddr base) | ||
163 | +{ | ||
164 | + SysBusDevice *part = SYS_BUS_DEVICE(dev); | ||
165 | + | ||
166 | + object_property_set_link(OBJECT(part), "efuse", | ||
167 | + OBJECT(&s->pmc.efuse), &error_abort); | ||
168 | + | ||
169 | + sysbus_realize(part, &error_abort); | ||
170 | + memory_region_add_subregion(&s->mr_ps, base, | ||
171 | + sysbus_mmio_get_region(part, 0)); | ||
172 | +} | ||
173 | + | ||
174 | +static void versal_create_efuse(Versal *s, qemu_irq *pic) | ||
175 | +{ | ||
176 | + Object *bits = OBJECT(&s->pmc.efuse); | ||
177 | + Object *ctrl = OBJECT(&s->pmc.efuse_ctrl); | ||
178 | + Object *cache = OBJECT(&s->pmc.efuse_cache); | ||
179 | + | ||
180 | + object_initialize_child(OBJECT(s), "efuse-ctrl", &s->pmc.efuse_ctrl, | ||
181 | + TYPE_XLNX_VERSAL_EFUSE_CTRL); | ||
182 | + | ||
183 | + object_initialize_child(OBJECT(s), "efuse-cache", &s->pmc.efuse_cache, | ||
184 | + TYPE_XLNX_VERSAL_EFUSE_CACHE); | ||
185 | + | ||
186 | + object_initialize_child_with_props(ctrl, "xlnx-efuse@0", bits, | ||
187 | + sizeof(s->pmc.efuse), | ||
188 | + TYPE_XLNX_EFUSE, &error_abort, | ||
189 | + "efuse-nr", "3", | ||
190 | + "efuse-size", "8192", | ||
191 | + NULL); | ||
192 | + | ||
193 | + qdev_realize(DEVICE(bits), NULL, &error_abort); | ||
194 | + versal_realize_efuse_part(s, ctrl, MM_PMC_EFUSE_CTRL); | ||
195 | + versal_realize_efuse_part(s, cache, MM_PMC_EFUSE_CACHE); | ||
196 | + | ||
197 | + sysbus_connect_irq(SYS_BUS_DEVICE(ctrl), 0, pic[VERSAL_EFUSE_IRQ]); | ||
198 | +} | ||
199 | + | ||
200 | /* This takes the board allocated linear DDR memory and creates aliases | ||
201 | * for each split DDR range/aperture on the Versal address map. | ||
202 | */ | ||
203 | @@ -XXX,XX +XXX,XX @@ static void versal_realize(DeviceState *dev, Error **errp) | ||
204 | versal_create_rtc(s, pic); | ||
205 | versal_create_xrams(s, pic); | ||
206 | versal_create_bbram(s, pic); | ||
207 | + versal_create_efuse(s, pic); | ||
208 | versal_map_ddr(s); | ||
209 | versal_unimp(s); | ||
210 | |||
211 | diff --git a/hw/arm/Kconfig b/hw/arm/Kconfig | ||
212 | index XXXXXXX..XXXXXXX 100644 | ||
213 | --- a/hw/arm/Kconfig | ||
214 | +++ b/hw/arm/Kconfig | ||
215 | @@ -XXX,XX +XXX,XX @@ config XLNX_VERSAL | ||
216 | select XLNX_ZYNQMP | ||
217 | select OR_IRQ | ||
218 | select XLNX_BBRAM | ||
219 | + select XLNX_EFUSE_VERSAL | ||
220 | |||
221 | config NPCM7XX | ||
222 | bool | ||
54 | -- | 223 | -- |
55 | 2.20.1 | 224 | 2.20.1 |
56 | 225 | ||
57 | 226 | diff view generated by jsdifflib |
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | 1 | From: Tong Ho <tong.ho@xilinx.com> |
---|---|---|---|
2 | 2 | ||
3 | Add support for SD. | 3 | Connect the support for Xilinx ZynqMP Battery-Backed RAM (BBRAM) |
4 | 4 | ||
5 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 5 | The command argument: |
6 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | 6 | -drive if=pflash,index=2,... |
7 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | 7 | Can be used to optionally connect the bbram to a backend |
8 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | 8 | storage, such that field-programmed values in one |
9 | Message-id: 20200427181649.26851-9-edgar.iglesias@gmail.com | 9 | invocation can be made available to next invocation. |
10 | |||
11 | The backend storage must be a seekable binary file, and | ||
12 | its size must be 36 bytes or larger. A file with all | ||
13 | binary 0's is a 'blank'. | ||
14 | |||
15 | Signed-off-by: Tong Ho <tong.ho@xilinx.com> | ||
16 | Message-id: 20210917052400.1249094-8-tong.ho@xilinx.com | ||
17 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 18 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | --- | 19 | --- |
12 | include/hw/arm/xlnx-versal.h | 12 ++++++++++++ | 20 | include/hw/arm/xlnx-zynqmp.h | 2 ++ |
13 | hw/arm/xlnx-versal.c | 31 +++++++++++++++++++++++++++++++ | 21 | hw/arm/xlnx-zcu102.c | 15 +++++++++++++++ |
14 | 2 files changed, 43 insertions(+) | 22 | hw/arm/xlnx-zynqmp.c | 20 ++++++++++++++++++++ |
23 | hw/Kconfig | 1 + | ||
24 | 4 files changed, 38 insertions(+) | ||
15 | 25 | ||
16 | diff --git a/include/hw/arm/xlnx-versal.h b/include/hw/arm/xlnx-versal.h | 26 | diff --git a/include/hw/arm/xlnx-zynqmp.h b/include/hw/arm/xlnx-zynqmp.h |
17 | index XXXXXXX..XXXXXXX 100644 | 27 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/include/hw/arm/xlnx-versal.h | 28 | --- a/include/hw/arm/xlnx-zynqmp.h |
19 | +++ b/include/hw/arm/xlnx-versal.h | 29 | +++ b/include/hw/arm/xlnx-zynqmp.h |
20 | @@ -XXX,XX +XXX,XX @@ | 30 | @@ -XXX,XX +XXX,XX @@ |
21 | 31 | #include "qom/object.h" | |
22 | #include "hw/sysbus.h" | 32 | #include "net/can_emu.h" |
23 | #include "hw/arm/boot.h" | 33 | #include "hw/dma/xlnx_csu_dma.h" |
24 | +#include "hw/sd/sdhci.h" | 34 | +#include "hw/nvram/xlnx-bbram.h" |
25 | #include "hw/intc/arm_gicv3.h" | 35 | |
26 | #include "hw/char/pl011.h" | 36 | #define TYPE_XLNX_ZYNQMP "xlnx-zynqmp" |
27 | #include "hw/dma/xlnx-zdma.h" | 37 | OBJECT_DECLARE_SIMPLE_TYPE(XlnxZynqMPState, XLNX_ZYNQMP) |
28 | @@ -XXX,XX +XXX,XX @@ | 38 | @@ -XXX,XX +XXX,XX @@ struct XlnxZynqMPState { |
29 | #define XLNX_VERSAL_NR_UARTS 2 | 39 | |
30 | #define XLNX_VERSAL_NR_GEMS 2 | 40 | MemoryRegion *ddr_ram; |
31 | #define XLNX_VERSAL_NR_ADMAS 8 | 41 | MemoryRegion ddr_ram_low, ddr_ram_high; |
32 | +#define XLNX_VERSAL_NR_SDS 2 | 42 | + XlnxBBRam bbram; |
33 | #define XLNX_VERSAL_NR_IRQS 192 | 43 | |
34 | 44 | MemoryRegion mr_unimp[XLNX_ZYNQMP_NUM_UNIMP_AREAS]; | |
35 | typedef struct Versal { | 45 | |
36 | @@ -XXX,XX +XXX,XX @@ typedef struct Versal { | 46 | diff --git a/hw/arm/xlnx-zcu102.c b/hw/arm/xlnx-zcu102.c |
37 | } iou; | ||
38 | } lpd; | ||
39 | |||
40 | + /* The Platform Management Controller subsystem. */ | ||
41 | + struct { | ||
42 | + struct { | ||
43 | + SDHCIState sd[XLNX_VERSAL_NR_SDS]; | ||
44 | + } iou; | ||
45 | + } pmc; | ||
46 | + | ||
47 | struct { | ||
48 | MemoryRegion *mr_ddr; | ||
49 | uint32_t psci_conduit; | ||
50 | @@ -XXX,XX +XXX,XX @@ typedef struct Versal { | ||
51 | #define VERSAL_GEM1_IRQ_0 58 | ||
52 | #define VERSAL_GEM1_WAKE_IRQ_0 59 | ||
53 | #define VERSAL_ADMA_IRQ_0 60 | ||
54 | +#define VERSAL_SD0_IRQ_0 126 | ||
55 | |||
56 | /* Architecturally reserved IRQs suitable for virtualization. */ | ||
57 | #define VERSAL_RSVD_IRQ_FIRST 111 | ||
58 | @@ -XXX,XX +XXX,XX @@ typedef struct Versal { | ||
59 | #define MM_FPD_CRF 0xfd1a0000U | ||
60 | #define MM_FPD_CRF_SIZE 0x140000 | ||
61 | |||
62 | +#define MM_PMC_SD0 0xf1040000U | ||
63 | +#define MM_PMC_SD0_SIZE 0x10000 | ||
64 | #define MM_PMC_CRP 0xf1260000U | ||
65 | #define MM_PMC_CRP_SIZE 0x10000 | ||
66 | #endif | ||
67 | diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c | ||
68 | index XXXXXXX..XXXXXXX 100644 | 47 | index XXXXXXX..XXXXXXX 100644 |
69 | --- a/hw/arm/xlnx-versal.c | 48 | --- a/hw/arm/xlnx-zcu102.c |
70 | +++ b/hw/arm/xlnx-versal.c | 49 | +++ b/hw/arm/xlnx-zcu102.c |
71 | @@ -XXX,XX +XXX,XX @@ static void versal_create_admas(Versal *s, qemu_irq *pic) | 50 | @@ -XXX,XX +XXX,XX @@ static void zcu102_modify_dtb(const struct arm_boot_info *binfo, void *fdt) |
72 | } | 51 | } |
73 | } | 52 | } |
74 | 53 | ||
75 | +#define SDHCI_CAPABILITIES 0x280737ec6481 /* Same as on ZynqMP. */ | 54 | +static void bbram_attach_drive(XlnxBBRam *dev) |
76 | +static void versal_create_sds(Versal *s, qemu_irq *pic) | ||
77 | +{ | 55 | +{ |
78 | + int i; | 56 | + DriveInfo *dinfo; |
57 | + BlockBackend *blk; | ||
79 | + | 58 | + |
80 | + for (i = 0; i < ARRAY_SIZE(s->pmc.iou.sd); i++) { | 59 | + dinfo = drive_get_by_index(IF_PFLASH, 2); |
81 | + DeviceState *dev; | 60 | + blk = dinfo ? blk_by_legacy_dinfo(dinfo) : NULL; |
82 | + MemoryRegion *mr; | 61 | + if (blk) { |
83 | + | 62 | + qdev_prop_set_drive(DEVICE(dev), "drive", blk); |
84 | + sysbus_init_child_obj(OBJECT(s), "sd[*]", | ||
85 | + &s->pmc.iou.sd[i], sizeof(s->pmc.iou.sd[i]), | ||
86 | + TYPE_SYSBUS_SDHCI); | ||
87 | + dev = DEVICE(&s->pmc.iou.sd[i]); | ||
88 | + | ||
89 | + object_property_set_uint(OBJECT(dev), | ||
90 | + 3, "sd-spec-version", &error_fatal); | ||
91 | + object_property_set_uint(OBJECT(dev), SDHCI_CAPABILITIES, "capareg", | ||
92 | + &error_fatal); | ||
93 | + object_property_set_uint(OBJECT(dev), UHS_I, "uhs", &error_fatal); | ||
94 | + qdev_init_nofail(dev); | ||
95 | + | ||
96 | + mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0); | ||
97 | + memory_region_add_subregion(&s->mr_ps, | ||
98 | + MM_PMC_SD0 + i * MM_PMC_SD0_SIZE, mr); | ||
99 | + | ||
100 | + sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, | ||
101 | + pic[VERSAL_SD0_IRQ_0 + i * 2]); | ||
102 | + } | 63 | + } |
103 | +} | 64 | +} |
104 | + | 65 | + |
105 | /* This takes the board allocated linear DDR memory and creates aliases | 66 | static void xlnx_zcu102_init(MachineState *machine) |
106 | * for each split DDR range/aperture on the Versal address map. | 67 | { |
107 | */ | 68 | XlnxZCU102 *s = ZCU102_MACHINE(machine); |
108 | @@ -XXX,XX +XXX,XX @@ static void versal_realize(DeviceState *dev, Error **errp) | 69 | @@ -XXX,XX +XXX,XX @@ static void xlnx_zcu102_init(MachineState *machine) |
109 | versal_create_uarts(s, pic); | 70 | |
110 | versal_create_gems(s, pic); | 71 | qdev_realize(DEVICE(&s->soc), NULL, &error_fatal); |
111 | versal_create_admas(s, pic); | 72 | |
112 | + versal_create_sds(s, pic); | 73 | + /* Attach bbram backend, if given */ |
113 | versal_map_ddr(s); | 74 | + bbram_attach_drive(&s->soc.bbram); |
114 | versal_unimp(s); | 75 | + |
115 | 76 | /* Create and plug in the SD cards */ | |
77 | for (i = 0; i < XLNX_ZYNQMP_NUM_SDHCI; i++) { | ||
78 | BusState *bus; | ||
79 | diff --git a/hw/arm/xlnx-zynqmp.c b/hw/arm/xlnx-zynqmp.c | ||
80 | index XXXXXXX..XXXXXXX 100644 | ||
81 | --- a/hw/arm/xlnx-zynqmp.c | ||
82 | +++ b/hw/arm/xlnx-zynqmp.c | ||
83 | @@ -XXX,XX +XXX,XX @@ | ||
84 | #define RTC_ADDR 0xffa60000 | ||
85 | #define RTC_IRQ 26 | ||
86 | |||
87 | +#define BBRAM_ADDR 0xffcd0000 | ||
88 | +#define BBRAM_IRQ 11 | ||
89 | + | ||
90 | #define SDHCI_CAPABILITIES 0x280737ec6481 /* Datasheet: UG1085 (v1.7) */ | ||
91 | |||
92 | static const uint64_t gem_addr[XLNX_ZYNQMP_NUM_GEMS] = { | ||
93 | @@ -XXX,XX +XXX,XX @@ static void xlnx_zynqmp_create_rpu(MachineState *ms, XlnxZynqMPState *s, | ||
94 | qdev_realize(DEVICE(&s->rpu_cluster), NULL, &error_fatal); | ||
95 | } | ||
96 | |||
97 | +static void xlnx_zynqmp_create_bbram(XlnxZynqMPState *s, qemu_irq *gic) | ||
98 | +{ | ||
99 | + SysBusDevice *sbd; | ||
100 | + | ||
101 | + object_initialize_child_with_props(OBJECT(s), "bbram", &s->bbram, | ||
102 | + sizeof(s->bbram), TYPE_XLNX_BBRAM, | ||
103 | + &error_fatal, | ||
104 | + "crc-zpads", "1", | ||
105 | + NULL); | ||
106 | + sbd = SYS_BUS_DEVICE(&s->bbram); | ||
107 | + | ||
108 | + sysbus_realize(sbd, &error_fatal); | ||
109 | + sysbus_mmio_map(sbd, 0, BBRAM_ADDR); | ||
110 | + sysbus_connect_irq(sbd, 0, gic[BBRAM_IRQ]); | ||
111 | +} | ||
112 | + | ||
113 | static void xlnx_zynqmp_create_unimp_mmio(XlnxZynqMPState *s) | ||
114 | { | ||
115 | static const struct UnimpInfo { | ||
116 | @@ -XXX,XX +XXX,XX @@ static void xlnx_zynqmp_realize(DeviceState *dev, Error **errp) | ||
117 | sysbus_mmio_map(SYS_BUS_DEVICE(&s->rtc), 0, RTC_ADDR); | ||
118 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->rtc), 0, gic_spi[RTC_IRQ]); | ||
119 | |||
120 | + xlnx_zynqmp_create_bbram(s, gic_spi); | ||
121 | xlnx_zynqmp_create_unimp_mmio(s); | ||
122 | |||
123 | for (i = 0; i < XLNX_ZYNQMP_NUM_GDMA_CH; i++) { | ||
124 | diff --git a/hw/Kconfig b/hw/Kconfig | ||
125 | index XXXXXXX..XXXXXXX 100644 | ||
126 | --- a/hw/Kconfig | ||
127 | +++ b/hw/Kconfig | ||
128 | @@ -XXX,XX +XXX,XX @@ config XLNX_ZYNQMP | ||
129 | select REGISTER | ||
130 | select CAN_BUS | ||
131 | select PTIMER | ||
132 | + select XLNX_BBRAM | ||
116 | -- | 133 | -- |
117 | 2.20.1 | 134 | 2.20.1 |
118 | 135 | ||
119 | 136 | diff view generated by jsdifflib |
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | 1 | From: Tong Ho <tong.ho@xilinx.com> |
---|---|---|---|
2 | 2 | ||
3 | Add support for SD. | 3 | Connect the support for ZynqMP eFUSE one-time field-programmable |
4 | bit array. | ||
4 | 5 | ||
5 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 6 | The command argument: |
6 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | 7 | -drive if=pflash,index=3,... |
7 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | 8 | Can be used to optionally connect the bit array to a |
8 | Message-id: 20200427181649.26851-11-edgar.iglesias@gmail.com | 9 | backend storage, such that field-programmed values |
10 | in one invocation can be made available to next | ||
11 | invocation. | ||
12 | |||
13 | The backend storage must be a seekable binary file, and | ||
14 | its size must be 768 bytes or larger. A file with all | ||
15 | binary 0's is a 'blank'. | ||
16 | |||
17 | Signed-off-by: Tong Ho <tong.ho@xilinx.com> | ||
18 | Message-id: 20210917052400.1249094-9-tong.ho@xilinx.com | ||
19 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 20 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
10 | --- | 21 | --- |
11 | hw/arm/xlnx-versal-virt.c | 46 +++++++++++++++++++++++++++++++++++++++ | 22 | include/hw/arm/xlnx-zynqmp.h | 3 +++ |
12 | 1 file changed, 46 insertions(+) | 23 | hw/arm/xlnx-zcu102.c | 15 +++++++++++++++ |
24 | hw/arm/xlnx-zynqmp.c | 29 +++++++++++++++++++++++++++++ | ||
25 | hw/Kconfig | 1 + | ||
26 | 4 files changed, 48 insertions(+) | ||
13 | 27 | ||
14 | diff --git a/hw/arm/xlnx-versal-virt.c b/hw/arm/xlnx-versal-virt.c | 28 | diff --git a/include/hw/arm/xlnx-zynqmp.h b/include/hw/arm/xlnx-zynqmp.h |
15 | index XXXXXXX..XXXXXXX 100644 | 29 | index XXXXXXX..XXXXXXX 100644 |
16 | --- a/hw/arm/xlnx-versal-virt.c | 30 | --- a/include/hw/arm/xlnx-zynqmp.h |
17 | +++ b/hw/arm/xlnx-versal-virt.c | 31 | +++ b/include/hw/arm/xlnx-zynqmp.h |
18 | @@ -XXX,XX +XXX,XX @@ | 32 | @@ -XXX,XX +XXX,XX @@ |
19 | #include "hw/arm/sysbus-fdt.h" | 33 | #include "net/can_emu.h" |
20 | #include "hw/arm/fdt.h" | 34 | #include "hw/dma/xlnx_csu_dma.h" |
21 | #include "cpu.h" | 35 | #include "hw/nvram/xlnx-bbram.h" |
22 | +#include "hw/qdev-properties.h" | 36 | +#include "hw/nvram/xlnx-zynqmp-efuse.h" |
23 | #include "hw/arm/xlnx-versal.h" | 37 | |
24 | 38 | #define TYPE_XLNX_ZYNQMP "xlnx-zynqmp" | |
25 | #define TYPE_XLNX_VERSAL_VIRT_MACHINE MACHINE_TYPE_NAME("xlnx-versal-virt") | 39 | OBJECT_DECLARE_SIMPLE_TYPE(XlnxZynqMPState, XLNX_ZYNQMP) |
26 | @@ -XXX,XX +XXX,XX @@ static void fdt_add_zdma_nodes(VersalVirt *s) | 40 | @@ -XXX,XX +XXX,XX @@ struct XlnxZynqMPState { |
41 | MemoryRegion *ddr_ram; | ||
42 | MemoryRegion ddr_ram_low, ddr_ram_high; | ||
43 | XlnxBBRam bbram; | ||
44 | + XlnxEFuse efuse; | ||
45 | + XlnxZynqMPEFuse efuse_ctrl; | ||
46 | |||
47 | MemoryRegion mr_unimp[XLNX_ZYNQMP_NUM_UNIMP_AREAS]; | ||
48 | |||
49 | diff --git a/hw/arm/xlnx-zcu102.c b/hw/arm/xlnx-zcu102.c | ||
50 | index XXXXXXX..XXXXXXX 100644 | ||
51 | --- a/hw/arm/xlnx-zcu102.c | ||
52 | +++ b/hw/arm/xlnx-zcu102.c | ||
53 | @@ -XXX,XX +XXX,XX @@ static void bbram_attach_drive(XlnxBBRam *dev) | ||
27 | } | 54 | } |
28 | } | 55 | } |
29 | 56 | ||
30 | +static void fdt_add_sd_nodes(VersalVirt *s) | 57 | +static void efuse_attach_drive(XlnxEFuse *dev) |
31 | +{ | 58 | +{ |
32 | + const char clocknames[] = "clk_xin\0clk_ahb"; | 59 | + DriveInfo *dinfo; |
33 | + const char compat[] = "arasan,sdhci-8.9a"; | 60 | + BlockBackend *blk; |
34 | + int i; | ||
35 | + | 61 | + |
36 | + for (i = ARRAY_SIZE(s->soc.pmc.iou.sd) - 1; i >= 0; i--) { | 62 | + dinfo = drive_get_by_index(IF_PFLASH, 3); |
37 | + uint64_t addr = MM_PMC_SD0 + MM_PMC_SD0_SIZE * i; | 63 | + blk = dinfo ? blk_by_legacy_dinfo(dinfo) : NULL; |
38 | + char *name = g_strdup_printf("/sdhci@%" PRIx64, addr); | 64 | + if (blk) { |
39 | + | 65 | + qdev_prop_set_drive(DEVICE(dev), "drive", blk); |
40 | + qemu_fdt_add_subnode(s->fdt, name); | ||
41 | + | ||
42 | + qemu_fdt_setprop_cells(s->fdt, name, "clocks", | ||
43 | + s->phandle.clk_25Mhz, s->phandle.clk_25Mhz); | ||
44 | + qemu_fdt_setprop(s->fdt, name, "clock-names", | ||
45 | + clocknames, sizeof(clocknames)); | ||
46 | + qemu_fdt_setprop_cells(s->fdt, name, "interrupts", | ||
47 | + GIC_FDT_IRQ_TYPE_SPI, VERSAL_SD0_IRQ_0 + i * 2, | ||
48 | + GIC_FDT_IRQ_FLAGS_LEVEL_HI); | ||
49 | + qemu_fdt_setprop_sized_cells(s->fdt, name, "reg", | ||
50 | + 2, addr, 2, MM_PMC_SD0_SIZE); | ||
51 | + qemu_fdt_setprop(s->fdt, name, "compatible", compat, sizeof(compat)); | ||
52 | + g_free(name); | ||
53 | + } | 66 | + } |
54 | +} | 67 | +} |
55 | + | 68 | + |
56 | static void fdt_nop_memory_nodes(void *fdt, Error **errp) | 69 | static void xlnx_zcu102_init(MachineState *machine) |
57 | { | 70 | { |
58 | Error *err = NULL; | 71 | XlnxZCU102 *s = ZCU102_MACHINE(machine); |
59 | @@ -XXX,XX +XXX,XX @@ static void create_virtio_regions(VersalVirt *s) | 72 | @@ -XXX,XX +XXX,XX @@ static void xlnx_zcu102_init(MachineState *machine) |
60 | } | 73 | /* Attach bbram backend, if given */ |
74 | bbram_attach_drive(&s->soc.bbram); | ||
75 | |||
76 | + /* Attach efuse backend, if given */ | ||
77 | + efuse_attach_drive(&s->soc.efuse); | ||
78 | + | ||
79 | /* Create and plug in the SD cards */ | ||
80 | for (i = 0; i < XLNX_ZYNQMP_NUM_SDHCI; i++) { | ||
81 | BusState *bus; | ||
82 | diff --git a/hw/arm/xlnx-zynqmp.c b/hw/arm/xlnx-zynqmp.c | ||
83 | index XXXXXXX..XXXXXXX 100644 | ||
84 | --- a/hw/arm/xlnx-zynqmp.c | ||
85 | +++ b/hw/arm/xlnx-zynqmp.c | ||
86 | @@ -XXX,XX +XXX,XX @@ | ||
87 | #define BBRAM_ADDR 0xffcd0000 | ||
88 | #define BBRAM_IRQ 11 | ||
89 | |||
90 | +#define EFUSE_ADDR 0xffcc0000 | ||
91 | +#define EFUSE_IRQ 87 | ||
92 | + | ||
93 | #define SDHCI_CAPABILITIES 0x280737ec6481 /* Datasheet: UG1085 (v1.7) */ | ||
94 | |||
95 | static const uint64_t gem_addr[XLNX_ZYNQMP_NUM_GEMS] = { | ||
96 | @@ -XXX,XX +XXX,XX @@ static void xlnx_zynqmp_create_bbram(XlnxZynqMPState *s, qemu_irq *gic) | ||
97 | sysbus_connect_irq(sbd, 0, gic[BBRAM_IRQ]); | ||
61 | } | 98 | } |
62 | 99 | ||
63 | +static void sd_plugin_card(SDHCIState *sd, DriveInfo *di) | 100 | +static void xlnx_zynqmp_create_efuse(XlnxZynqMPState *s, qemu_irq *gic) |
64 | +{ | 101 | +{ |
65 | + BlockBackend *blk = di ? blk_by_legacy_dinfo(di) : NULL; | 102 | + Object *bits = OBJECT(&s->efuse); |
66 | + DeviceState *card; | 103 | + Object *ctrl = OBJECT(&s->efuse_ctrl); |
104 | + SysBusDevice *sbd; | ||
67 | + | 105 | + |
68 | + card = qdev_create(qdev_get_child_bus(DEVICE(sd), "sd-bus"), TYPE_SD_CARD); | 106 | + object_initialize_child(OBJECT(s), "efuse-ctrl", &s->efuse_ctrl, |
69 | + object_property_add_child(OBJECT(sd), "card[*]", OBJECT(card), | 107 | + TYPE_XLNX_ZYNQMP_EFUSE); |
70 | + &error_fatal); | 108 | + |
71 | + qdev_prop_set_drive(card, "drive", blk, &error_fatal); | 109 | + object_initialize_child_with_props(ctrl, "xlnx-efuse@0", bits, |
72 | + object_property_set_bool(OBJECT(card), true, "realized", &error_fatal); | 110 | + sizeof(s->efuse), |
111 | + TYPE_XLNX_EFUSE, &error_abort, | ||
112 | + "efuse-nr", "3", | ||
113 | + "efuse-size", "2048", | ||
114 | + NULL); | ||
115 | + | ||
116 | + qdev_realize(DEVICE(bits), NULL, &error_abort); | ||
117 | + object_property_set_link(ctrl, "efuse", bits, &error_abort); | ||
118 | + | ||
119 | + sbd = SYS_BUS_DEVICE(ctrl); | ||
120 | + sysbus_realize(sbd, &error_abort); | ||
121 | + sysbus_mmio_map(sbd, 0, EFUSE_ADDR); | ||
122 | + sysbus_connect_irq(sbd, 0, gic[EFUSE_IRQ]); | ||
73 | +} | 123 | +} |
74 | + | 124 | + |
75 | static void versal_virt_init(MachineState *machine) | 125 | static void xlnx_zynqmp_create_unimp_mmio(XlnxZynqMPState *s) |
76 | { | 126 | { |
77 | VersalVirt *s = XLNX_VERSAL_VIRT_MACHINE(machine); | 127 | static const struct UnimpInfo { |
78 | int psci_conduit = QEMU_PSCI_CONDUIT_DISABLED; | 128 | @@ -XXX,XX +XXX,XX @@ static void xlnx_zynqmp_realize(DeviceState *dev, Error **errp) |
79 | + int i; | 129 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->rtc), 0, gic_spi[RTC_IRQ]); |
80 | 130 | ||
81 | /* | 131 | xlnx_zynqmp_create_bbram(s, gic_spi); |
82 | * If the user provides an Operating System to be loaded, we expect them | 132 | + xlnx_zynqmp_create_efuse(s, gic_spi); |
83 | @@ -XXX,XX +XXX,XX @@ static void versal_virt_init(MachineState *machine) | 133 | xlnx_zynqmp_create_unimp_mmio(s); |
84 | fdt_add_gic_nodes(s); | 134 | |
85 | fdt_add_timer_nodes(s); | 135 | for (i = 0; i < XLNX_ZYNQMP_NUM_GDMA_CH; i++) { |
86 | fdt_add_zdma_nodes(s); | 136 | diff --git a/hw/Kconfig b/hw/Kconfig |
87 | + fdt_add_sd_nodes(s); | 137 | index XXXXXXX..XXXXXXX 100644 |
88 | fdt_add_cpu_nodes(s, psci_conduit); | 138 | --- a/hw/Kconfig |
89 | fdt_add_clk_node(s, "/clk125", 125000000, s->phandle.clk_125Mhz); | 139 | +++ b/hw/Kconfig |
90 | fdt_add_clk_node(s, "/clk25", 25000000, s->phandle.clk_25Mhz); | 140 | @@ -XXX,XX +XXX,XX @@ config XLNX_ZYNQMP |
91 | @@ -XXX,XX +XXX,XX @@ static void versal_virt_init(MachineState *machine) | 141 | select CAN_BUS |
92 | memory_region_add_subregion_overlap(get_system_memory(), | 142 | select PTIMER |
93 | 0, &s->soc.fpd.apu.mr, 0); | 143 | select XLNX_BBRAM |
94 | 144 | + select XLNX_EFUSE_ZYNQMP | |
95 | + /* Plugin SD cards. */ | ||
96 | + for (i = 0; i < ARRAY_SIZE(s->soc.pmc.iou.sd); i++) { | ||
97 | + sd_plugin_card(&s->soc.pmc.iou.sd[i], drive_get_next(IF_SD)); | ||
98 | + } | ||
99 | + | ||
100 | s->binfo.ram_size = machine->ram_size; | ||
101 | s->binfo.loader_start = 0x0; | ||
102 | s->binfo.get_dtb = versal_virt_get_dtb; | ||
103 | -- | 145 | -- |
104 | 2.20.1 | 146 | 2.20.1 |
105 | 147 | ||
106 | 148 | diff view generated by jsdifflib |
1 | From: Philippe Mathieu-Daudé <f4bug@amsat.org> | 1 | From: Tong Ho <tong.ho@xilinx.com> |
---|---|---|---|
2 | 2 | ||
3 | MIDR_EL1 is a 64-bit system register with the top 32-bit being RES0. | 3 | Add BBRAM and eFUSE usage to the Xilinx Versal Virt board |
4 | Represent it in QEMU's ARMCPU struct with a uint64_t, not a | 4 | document. |
5 | uint32_t. | ||
6 | 5 | ||
7 | This fixes an error when compiling with -Werror=conversion | 6 | Signed-off-by: Tong Ho <tong.ho@xilinx.com> |
8 | because we were manipulating the register value using a | 7 | Message-id: 20210917052400.1249094-10-tong.ho@xilinx.com |
9 | local uint64_t variable: | ||
10 | |||
11 | target/arm/cpu64.c: In function ‘aarch64_max_initfn’: | ||
12 | target/arm/cpu64.c:628:21: error: conversion from ‘uint64_t’ {aka ‘long unsigned int’} to ‘uint32_t’ {aka ‘unsigned int’} may change value [-Werror=conversion] | ||
13 | 628 | cpu->midr = t; | ||
14 | | ^ | ||
15 | |||
16 | and future-proofs us against a possible future architecture | ||
17 | change using some of the top 32 bits. | ||
18 | |||
19 | Suggested-by: Laurent Desnogues <laurent.desnogues@gmail.com> | ||
20 | Suggested-by: Peter Maydell <peter.maydell@linaro.org> | ||
21 | Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
22 | Reviewed-by: Laurent Desnogues <laurent.desnogues@gmail.com> | ||
23 | Message-id: 20200428172634.29707-1-f4bug@amsat.org | ||
24 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 8 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> |
25 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
26 | --- | 10 | --- |
27 | target/arm/cpu.h | 2 +- | 11 | docs/system/arm/xlnx-versal-virt.rst | 49 ++++++++++++++++++++++++++++ |
28 | target/arm/cpu.c | 2 +- | 12 | 1 file changed, 49 insertions(+) |
29 | 2 files changed, 2 insertions(+), 2 deletions(-) | ||
30 | 13 | ||
31 | diff --git a/target/arm/cpu.h b/target/arm/cpu.h | 14 | diff --git a/docs/system/arm/xlnx-versal-virt.rst b/docs/system/arm/xlnx-versal-virt.rst |
32 | index XXXXXXX..XXXXXXX 100644 | 15 | index XXXXXXX..XXXXXXX 100644 |
33 | --- a/target/arm/cpu.h | 16 | --- a/docs/system/arm/xlnx-versal-virt.rst |
34 | +++ b/target/arm/cpu.h | 17 | +++ b/docs/system/arm/xlnx-versal-virt.rst |
35 | @@ -XXX,XX +XXX,XX @@ struct ARMCPU { | 18 | @@ -XXX,XX +XXX,XX @@ Implemented devices: |
36 | uint64_t id_aa64dfr0; | 19 | - OCM (256KB of On Chip Memory) |
37 | uint64_t id_aa64dfr1; | 20 | - XRAM (4MB of on chip Accelerator RAM) |
38 | } isar; | 21 | - DDR memory |
39 | - uint32_t midr; | 22 | +- BBRAM (36 bytes of Battery-backed RAM) |
40 | + uint64_t midr; | 23 | +- eFUSE (3072 bytes of one-time field-programmable bit array) |
41 | uint32_t revidr; | 24 | |
42 | uint32_t reset_fpsid; | 25 | QEMU does not yet model any other devices, including the PL and the AI Engine. |
43 | uint32_t ctr; | 26 | |
44 | diff --git a/target/arm/cpu.c b/target/arm/cpu.c | 27 | @@ -XXX,XX +XXX,XX @@ Run the following at the U-Boot prompt: |
45 | index XXXXXXX..XXXXXXX 100644 | 28 | fdt set /chosen/dom0 reg <0x00000000 0x40000000 0x0 0x03100000> |
46 | --- a/target/arm/cpu.c | 29 | booti 30000000 - 20000000 |
47 | +++ b/target/arm/cpu.c | 30 | |
48 | @@ -XXX,XX +XXX,XX @@ static const ARMCPUInfo arm_cpus[] = { | 31 | +BBRAM File Backend |
49 | static Property arm_cpu_properties[] = { | 32 | +"""""""""""""""""" |
50 | DEFINE_PROP_BOOL("start-powered-off", ARMCPU, start_powered_off, false), | 33 | +BBRAM can have an optional file backend, which must be a seekable |
51 | DEFINE_PROP_UINT32("psci-conduit", ARMCPU, psci_conduit, 0), | 34 | +binary file with a size of 36 bytes or larger. A file with all |
52 | - DEFINE_PROP_UINT32("midr", ARMCPU, midr, 0), | 35 | +binary 0s is a 'blank'. |
53 | + DEFINE_PROP_UINT64("midr", ARMCPU, midr, 0), | 36 | + |
54 | DEFINE_PROP_UINT64("mp-affinity", ARMCPU, | 37 | +To add a file-backend for the BBRAM: |
55 | mp_affinity, ARM64_AFFINITY_INVALID), | 38 | + |
56 | DEFINE_PROP_INT32("node-id", ARMCPU, node_id, CPU_UNSET_NUMA_NODE_ID), | 39 | +.. code-block:: bash |
40 | + | ||
41 | + -drive if=pflash,index=0,file=versal-bbram.bin,format=raw | ||
42 | + | ||
43 | +To use a different index value, N, from default of 0, add: | ||
44 | + | ||
45 | +.. code-block:: bash | ||
46 | + | ||
47 | + -global xlnx,bbram-ctrl.drive-index=N | ||
48 | + | ||
49 | +eFUSE File Backend | ||
50 | +"""""""""""""""""" | ||
51 | +eFUSE can have an optional file backend, which must be a seekable | ||
52 | +binary file with a size of 3072 bytes or larger. A file with all | ||
53 | +binary 0s is a 'blank'. | ||
54 | + | ||
55 | +To add a file-backend for the eFUSE: | ||
56 | + | ||
57 | +.. code-block:: bash | ||
58 | + | ||
59 | + -drive if=pflash,index=1,file=versal-efuse.bin,format=raw | ||
60 | + | ||
61 | +To use a different index value, N, from default of 1, add: | ||
62 | + | ||
63 | +.. code-block:: bash | ||
64 | + | ||
65 | + -global xlnx,efuse.drive-index=N | ||
66 | + | ||
67 | +.. warning:: | ||
68 | + In actual physical Versal, BBRAM and eFUSE contain sensitive data. | ||
69 | + The QEMU device models do **not** encrypt nor obfuscate any data | ||
70 | + when holding them in models' memory or when writing them to their | ||
71 | + file backends. | ||
72 | + | ||
73 | + Thus, a file backend should be used with caution, and 'format=luks' | ||
74 | + is highly recommended (albeit with usage complexity). | ||
75 | + | ||
76 | + Better yet, do not use actual product data when running guest image | ||
77 | + on this Xilinx Versal Virt board. | ||
57 | -- | 78 | -- |
58 | 2.20.1 | 79 | 2.20.1 |
59 | 80 | ||
60 | 81 | diff view generated by jsdifflib |
1 | We're going to want at least some of the NeonGen* typedefs | 1 | The aarch64-linux QEMU usermode binaries can never run 32-bit |
---|---|---|---|
2 | for the refactored 32-bit Neon decoder, so move them all | 2 | code, so they do not need to include the GDB XML for it. |
3 | to translate.h since it makes more sense to keep them in | 3 | (arm_cpu_register_gdb_regs_for_features() will not use these |
4 | one group. | 4 | XML files if the CPU has ARM_FEATURE_AARCH64, so we will not |
5 | advertise to gdb that we have them.) | ||
5 | 6 | ||
6 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 7 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
7 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
8 | Message-id: 20200430181003.21682-23-peter.maydell@linaro.org | 9 | Message-id: 20210921162901.17508-2-peter.maydell@linaro.org |
9 | --- | 10 | --- |
10 | target/arm/translate.h | 17 +++++++++++++++++ | 11 | configs/targets/aarch64-linux-user.mak | 2 +- |
11 | target/arm/translate-a64.c | 17 ----------------- | 12 | configs/targets/aarch64_be-linux-user.mak | 2 +- |
12 | 2 files changed, 17 insertions(+), 17 deletions(-) | 13 | 2 files changed, 2 insertions(+), 2 deletions(-) |
13 | 14 | ||
14 | diff --git a/target/arm/translate.h b/target/arm/translate.h | 15 | diff --git a/configs/targets/aarch64-linux-user.mak b/configs/targets/aarch64-linux-user.mak |
15 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
16 | --- a/target/arm/translate.h | 17 | --- a/configs/targets/aarch64-linux-user.mak |
17 | +++ b/target/arm/translate.h | 18 | +++ b/configs/targets/aarch64-linux-user.mak |
18 | @@ -XXX,XX +XXX,XX @@ typedef void GVecGen3Fn(unsigned, uint32_t, uint32_t, | 19 | @@ -XXX,XX +XXX,XX @@ |
19 | typedef void GVecGen4Fn(unsigned, uint32_t, uint32_t, uint32_t, | 20 | TARGET_ARCH=aarch64 |
20 | uint32_t, uint32_t, uint32_t); | 21 | TARGET_BASE_ARCH=arm |
21 | 22 | -TARGET_XML_FILES= gdb-xml/aarch64-core.xml gdb-xml/aarch64-fpu.xml gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml | |
22 | +/* Function prototype for gen_ functions for calling Neon helpers */ | 23 | +TARGET_XML_FILES= gdb-xml/aarch64-core.xml gdb-xml/aarch64-fpu.xml |
23 | +typedef void NeonGenOneOpEnvFn(TCGv_i32, TCGv_ptr, TCGv_i32); | 24 | TARGET_HAS_BFLT=y |
24 | +typedef void NeonGenTwoOpFn(TCGv_i32, TCGv_i32, TCGv_i32); | 25 | CONFIG_ARM_COMPATIBLE_SEMIHOSTING=y |
25 | +typedef void NeonGenTwoOpEnvFn(TCGv_i32, TCGv_ptr, TCGv_i32, TCGv_i32); | 26 | diff --git a/configs/targets/aarch64_be-linux-user.mak b/configs/targets/aarch64_be-linux-user.mak |
26 | +typedef void NeonGenTwo64OpFn(TCGv_i64, TCGv_i64, TCGv_i64); | ||
27 | +typedef void NeonGenTwo64OpEnvFn(TCGv_i64, TCGv_ptr, TCGv_i64, TCGv_i64); | ||
28 | +typedef void NeonGenNarrowFn(TCGv_i32, TCGv_i64); | ||
29 | +typedef void NeonGenNarrowEnvFn(TCGv_i32, TCGv_ptr, TCGv_i64); | ||
30 | +typedef void NeonGenWidenFn(TCGv_i64, TCGv_i32); | ||
31 | +typedef void NeonGenTwoSingleOPFn(TCGv_i32, TCGv_i32, TCGv_i32, TCGv_ptr); | ||
32 | +typedef void NeonGenTwoDoubleOPFn(TCGv_i64, TCGv_i64, TCGv_i64, TCGv_ptr); | ||
33 | +typedef void NeonGenOneOpFn(TCGv_i64, TCGv_i64); | ||
34 | +typedef void CryptoTwoOpFn(TCGv_ptr, TCGv_ptr); | ||
35 | +typedef void CryptoThreeOpIntFn(TCGv_ptr, TCGv_ptr, TCGv_i32); | ||
36 | +typedef void CryptoThreeOpFn(TCGv_ptr, TCGv_ptr, TCGv_ptr); | ||
37 | +typedef void AtomicThreeOpFn(TCGv_i64, TCGv_i64, TCGv_i64, TCGArg, MemOp); | ||
38 | + | ||
39 | #endif /* TARGET_ARM_TRANSLATE_H */ | ||
40 | diff --git a/target/arm/translate-a64.c b/target/arm/translate-a64.c | ||
41 | index XXXXXXX..XXXXXXX 100644 | 27 | index XXXXXXX..XXXXXXX 100644 |
42 | --- a/target/arm/translate-a64.c | 28 | --- a/configs/targets/aarch64_be-linux-user.mak |
43 | +++ b/target/arm/translate-a64.c | 29 | +++ b/configs/targets/aarch64_be-linux-user.mak |
44 | @@ -XXX,XX +XXX,XX @@ typedef struct AArch64DecodeTable { | 30 | @@ -XXX,XX +XXX,XX @@ |
45 | AArch64DecodeFn *disas_fn; | 31 | TARGET_ARCH=aarch64 |
46 | } AArch64DecodeTable; | 32 | TARGET_BASE_ARCH=arm |
47 | 33 | TARGET_WORDS_BIGENDIAN=y | |
48 | -/* Function prototype for gen_ functions for calling Neon helpers */ | 34 | -TARGET_XML_FILES= gdb-xml/aarch64-core.xml gdb-xml/aarch64-fpu.xml gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml |
49 | -typedef void NeonGenOneOpEnvFn(TCGv_i32, TCGv_ptr, TCGv_i32); | 35 | +TARGET_XML_FILES= gdb-xml/aarch64-core.xml gdb-xml/aarch64-fpu.xml |
50 | -typedef void NeonGenTwoOpFn(TCGv_i32, TCGv_i32, TCGv_i32); | 36 | TARGET_HAS_BFLT=y |
51 | -typedef void NeonGenTwoOpEnvFn(TCGv_i32, TCGv_ptr, TCGv_i32, TCGv_i32); | 37 | CONFIG_ARM_COMPATIBLE_SEMIHOSTING=y |
52 | -typedef void NeonGenTwo64OpFn(TCGv_i64, TCGv_i64, TCGv_i64); | ||
53 | -typedef void NeonGenTwo64OpEnvFn(TCGv_i64, TCGv_ptr, TCGv_i64, TCGv_i64); | ||
54 | -typedef void NeonGenNarrowFn(TCGv_i32, TCGv_i64); | ||
55 | -typedef void NeonGenNarrowEnvFn(TCGv_i32, TCGv_ptr, TCGv_i64); | ||
56 | -typedef void NeonGenWidenFn(TCGv_i64, TCGv_i32); | ||
57 | -typedef void NeonGenTwoSingleOPFn(TCGv_i32, TCGv_i32, TCGv_i32, TCGv_ptr); | ||
58 | -typedef void NeonGenTwoDoubleOPFn(TCGv_i64, TCGv_i64, TCGv_i64, TCGv_ptr); | ||
59 | -typedef void NeonGenOneOpFn(TCGv_i64, TCGv_i64); | ||
60 | -typedef void CryptoTwoOpFn(TCGv_ptr, TCGv_ptr); | ||
61 | -typedef void CryptoThreeOpIntFn(TCGv_ptr, TCGv_ptr, TCGv_i32); | ||
62 | -typedef void CryptoThreeOpFn(TCGv_ptr, TCGv_ptr, TCGv_ptr); | ||
63 | -typedef void AtomicThreeOpFn(TCGv_i64, TCGv_i64, TCGv_i64, TCGArg, MemOp); | ||
64 | - | ||
65 | /* initialize TCG globals. */ | ||
66 | void a64_translate_init(void) | ||
67 | { | ||
68 | -- | 38 | -- |
69 | 2.20.1 | 39 | 2.20.1 |
70 | 40 | ||
71 | 41 | diff view generated by jsdifflib |
1 | The access_type argument to get_phys_addr_lpae() is an MMUAccessType; | 1 | We're going to move this code to a different file; fix the coding |
---|---|---|---|
2 | use the enum constant MMU_DATA_LOAD rather than a literal 0 when we | 2 | style first so checkpatch doesn't complain. This includes deleting |
3 | call it in S1_ptw_translate(). | 3 | the spurious 'break' statements after returns in the |
4 | vfp_gdb_get_reg() function. | ||
4 | 5 | ||
5 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 6 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
6 | Reviewed-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 7 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> |
7 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
8 | Message-id: 20200330210400.11724-3-peter.maydell@linaro.org | 9 | Message-id: 20210921162901.17508-3-peter.maydell@linaro.org |
9 | --- | 10 | --- |
10 | target/arm/helper.c | 5 +++-- | 11 | target/arm/helper.c | 23 ++++++++++++++++------- |
11 | 1 file changed, 3 insertions(+), 2 deletions(-) | 12 | 1 file changed, 16 insertions(+), 7 deletions(-) |
12 | 13 | ||
13 | diff --git a/target/arm/helper.c b/target/arm/helper.c | 14 | diff --git a/target/arm/helper.c b/target/arm/helper.c |
14 | index XXXXXXX..XXXXXXX 100644 | 15 | index XXXXXXX..XXXXXXX 100644 |
15 | --- a/target/arm/helper.c | 16 | --- a/target/arm/helper.c |
16 | +++ b/target/arm/helper.c | 17 | +++ b/target/arm/helper.c |
17 | @@ -XXX,XX +XXX,XX @@ static hwaddr S1_ptw_translate(CPUARMState *env, ARMMMUIdx mmu_idx, | 18 | @@ -XXX,XX +XXX,XX @@ static int vfp_gdb_get_reg(CPUARMState *env, GByteArray *buf, int reg) |
18 | pcacheattrs = &cacheattrs; | ||
19 | } | 19 | } |
20 | 20 | } | |
21 | - ret = get_phys_addr_lpae(env, addr, 0, ARMMMUIdx_Stage2, &s2pa, | 21 | switch (reg - nregs) { |
22 | - &txattrs, &s2prot, &s2size, fi, pcacheattrs); | 22 | - case 0: return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPSID]); break; |
23 | + ret = get_phys_addr_lpae(env, addr, MMU_DATA_LOAD, ARMMMUIdx_Stage2, | 23 | - case 1: return gdb_get_reg32(buf, vfp_get_fpscr(env)); break; |
24 | + &s2pa, &txattrs, &s2prot, &s2size, fi, | 24 | - case 2: return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPEXC]); break; |
25 | + pcacheattrs); | 25 | + case 0: |
26 | if (ret) { | 26 | + return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPSID]); |
27 | assert(fi->type != ARMFault_None); | 27 | + case 1: |
28 | fi->s2addr = addr; | 28 | + return gdb_get_reg32(buf, vfp_get_fpscr(env)); |
29 | + case 2: | ||
30 | + return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPEXC]); | ||
31 | } | ||
32 | return 0; | ||
33 | } | ||
34 | @@ -XXX,XX +XXX,XX @@ static int vfp_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg) | ||
35 | } | ||
36 | } | ||
37 | switch (reg - nregs) { | ||
38 | - case 0: env->vfp.xregs[ARM_VFP_FPSID] = ldl_p(buf); return 4; | ||
39 | - case 1: vfp_set_fpscr(env, ldl_p(buf)); return 4; | ||
40 | - case 2: env->vfp.xregs[ARM_VFP_FPEXC] = ldl_p(buf) & (1 << 30); return 4; | ||
41 | + case 0: | ||
42 | + env->vfp.xregs[ARM_VFP_FPSID] = ldl_p(buf); | ||
43 | + return 4; | ||
44 | + case 1: | ||
45 | + vfp_set_fpscr(env, ldl_p(buf)); | ||
46 | + return 4; | ||
47 | + case 2: | ||
48 | + env->vfp.xregs[ARM_VFP_FPEXC] = ldl_p(buf) & (1 << 30); | ||
49 | + return 4; | ||
50 | } | ||
51 | return 0; | ||
52 | } | ||
53 | @@ -XXX,XX +XXX,XX @@ static int aarch64_fpu_gdb_get_reg(CPUARMState *env, GByteArray *buf, int reg) | ||
54 | return gdb_get_reg32(buf, vfp_get_fpsr(env)); | ||
55 | case 33: | ||
56 | /* FPCR */ | ||
57 | - return gdb_get_reg32(buf,vfp_get_fpcr(env)); | ||
58 | + return gdb_get_reg32(buf, vfp_get_fpcr(env)); | ||
59 | default: | ||
60 | return 0; | ||
61 | } | ||
29 | -- | 62 | -- |
30 | 2.20.1 | 63 | 2.20.1 |
31 | 64 | ||
32 | 65 | diff view generated by jsdifflib |
1 | For ARMv8.2-TTS2UXN, the stage 2 page table walk wants to know | 1 | Currently helper.c includes some code which is part of the arm |
---|---|---|---|
2 | whether the stage 1 access is for EL0 or not, because whether | 2 | target's gdbstub support. This code has a better home: in gdbstub.c |
3 | exec permission is given can depend on whether this is an EL0 | 3 | and gdbstub64.c. Move it there. |
4 | or EL1 access. Add a new argument to get_phys_addr_lpae() so | ||
5 | the call sites can pass this information in. | ||
6 | 4 | ||
7 | Since get_phys_addr_lpae() doesn't already have a doc comment, | 5 | Because aarch64_fpu_gdb_get_reg() and aarch64_fpu_gdb_set_reg() move |
8 | add one so we have a place to put the documentation of the | 6 | into gdbstub64.c, this means that they're now compiled only for |
9 | semantics of the new s1_is_el0 argument. | 7 | TARGET_AARCH64 rather than always. That is the only case when they |
8 | would ever be used, but it does mean that the ifdef in | ||
9 | arm_cpu_register_gdb_regs_for_features() needs to be adjusted to | ||
10 | match. | ||
10 | 11 | ||
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 12 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
12 | Reviewed-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 13 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> |
13 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | 14 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
14 | Message-id: 20200330210400.11724-4-peter.maydell@linaro.org | 15 | Message-id: 20210921162901.17508-4-peter.maydell@linaro.org |
15 | --- | 16 | --- |
16 | target/arm/helper.c | 29 ++++++++++++++++++++++++++++- | 17 | target/arm/internals.h | 7 ++ |
17 | 1 file changed, 28 insertions(+), 1 deletion(-) | 18 | target/arm/gdbstub.c | 130 ++++++++++++++++++++ |
19 | target/arm/gdbstub64.c | 140 +++++++++++++++++++++ | ||
20 | target/arm/helper.c | 271 ----------------------------------------- | ||
21 | 4 files changed, 277 insertions(+), 271 deletions(-) | ||
18 | 22 | ||
23 | diff --git a/target/arm/internals.h b/target/arm/internals.h | ||
24 | index XXXXXXX..XXXXXXX 100644 | ||
25 | --- a/target/arm/internals.h | ||
26 | +++ b/target/arm/internals.h | ||
27 | @@ -XXX,XX +XXX,XX @@ static inline uint64_t pmu_counter_mask(CPUARMState *env) | ||
28 | return (1 << 31) | ((1 << pmu_num_counters(env)) - 1); | ||
29 | } | ||
30 | |||
31 | +#ifdef TARGET_AARCH64 | ||
32 | +int arm_gdb_get_svereg(CPUARMState *env, GByteArray *buf, int reg); | ||
33 | +int arm_gdb_set_svereg(CPUARMState *env, uint8_t *buf, int reg); | ||
34 | +int aarch64_fpu_gdb_get_reg(CPUARMState *env, GByteArray *buf, int reg); | ||
35 | +int aarch64_fpu_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg); | ||
36 | +#endif | ||
37 | + | ||
38 | #endif | ||
39 | diff --git a/target/arm/gdbstub.c b/target/arm/gdbstub.c | ||
40 | index XXXXXXX..XXXXXXX 100644 | ||
41 | --- a/target/arm/gdbstub.c | ||
42 | +++ b/target/arm/gdbstub.c | ||
43 | @@ -XXX,XX +XXX,XX @@ | ||
44 | */ | ||
45 | #include "qemu/osdep.h" | ||
46 | #include "cpu.h" | ||
47 | +#include "internals.h" | ||
48 | #include "exec/gdbstub.h" | ||
49 | |||
50 | typedef struct RegisterSysregXmlParam { | ||
51 | @@ -XXX,XX +XXX,XX @@ int arm_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n) | ||
52 | return 0; | ||
53 | } | ||
54 | |||
55 | +static int vfp_gdb_get_reg(CPUARMState *env, GByteArray *buf, int reg) | ||
56 | +{ | ||
57 | + ARMCPU *cpu = env_archcpu(env); | ||
58 | + int nregs = cpu_isar_feature(aa32_simd_r32, cpu) ? 32 : 16; | ||
59 | + | ||
60 | + /* VFP data registers are always little-endian. */ | ||
61 | + if (reg < nregs) { | ||
62 | + return gdb_get_reg64(buf, *aa32_vfp_dreg(env, reg)); | ||
63 | + } | ||
64 | + if (arm_feature(env, ARM_FEATURE_NEON)) { | ||
65 | + /* Aliases for Q regs. */ | ||
66 | + nregs += 16; | ||
67 | + if (reg < nregs) { | ||
68 | + uint64_t *q = aa32_vfp_qreg(env, reg - 32); | ||
69 | + return gdb_get_reg128(buf, q[0], q[1]); | ||
70 | + } | ||
71 | + } | ||
72 | + switch (reg - nregs) { | ||
73 | + case 0: | ||
74 | + return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPSID]); | ||
75 | + case 1: | ||
76 | + return gdb_get_reg32(buf, vfp_get_fpscr(env)); | ||
77 | + case 2: | ||
78 | + return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPEXC]); | ||
79 | + } | ||
80 | + return 0; | ||
81 | +} | ||
82 | + | ||
83 | +static int vfp_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg) | ||
84 | +{ | ||
85 | + ARMCPU *cpu = env_archcpu(env); | ||
86 | + int nregs = cpu_isar_feature(aa32_simd_r32, cpu) ? 32 : 16; | ||
87 | + | ||
88 | + if (reg < nregs) { | ||
89 | + *aa32_vfp_dreg(env, reg) = ldq_le_p(buf); | ||
90 | + return 8; | ||
91 | + } | ||
92 | + if (arm_feature(env, ARM_FEATURE_NEON)) { | ||
93 | + nregs += 16; | ||
94 | + if (reg < nregs) { | ||
95 | + uint64_t *q = aa32_vfp_qreg(env, reg - 32); | ||
96 | + q[0] = ldq_le_p(buf); | ||
97 | + q[1] = ldq_le_p(buf + 8); | ||
98 | + return 16; | ||
99 | + } | ||
100 | + } | ||
101 | + switch (reg - nregs) { | ||
102 | + case 0: | ||
103 | + env->vfp.xregs[ARM_VFP_FPSID] = ldl_p(buf); | ||
104 | + return 4; | ||
105 | + case 1: | ||
106 | + vfp_set_fpscr(env, ldl_p(buf)); | ||
107 | + return 4; | ||
108 | + case 2: | ||
109 | + env->vfp.xregs[ARM_VFP_FPEXC] = ldl_p(buf) & (1 << 30); | ||
110 | + return 4; | ||
111 | + } | ||
112 | + return 0; | ||
113 | +} | ||
114 | + | ||
115 | +/** | ||
116 | + * arm_get/set_gdb_*: get/set a gdb register | ||
117 | + * @env: the CPU state | ||
118 | + * @buf: a buffer to copy to/from | ||
119 | + * @reg: register number (offset from start of group) | ||
120 | + * | ||
121 | + * We return the number of bytes copied | ||
122 | + */ | ||
123 | + | ||
124 | +static int arm_gdb_get_sysreg(CPUARMState *env, GByteArray *buf, int reg) | ||
125 | +{ | ||
126 | + ARMCPU *cpu = env_archcpu(env); | ||
127 | + const ARMCPRegInfo *ri; | ||
128 | + uint32_t key; | ||
129 | + | ||
130 | + key = cpu->dyn_sysreg_xml.data.cpregs.keys[reg]; | ||
131 | + ri = get_arm_cp_reginfo(cpu->cp_regs, key); | ||
132 | + if (ri) { | ||
133 | + if (cpreg_field_is_64bit(ri)) { | ||
134 | + return gdb_get_reg64(buf, (uint64_t)read_raw_cp_reg(env, ri)); | ||
135 | + } else { | ||
136 | + return gdb_get_reg32(buf, (uint32_t)read_raw_cp_reg(env, ri)); | ||
137 | + } | ||
138 | + } | ||
139 | + return 0; | ||
140 | +} | ||
141 | + | ||
142 | +static int arm_gdb_set_sysreg(CPUARMState *env, uint8_t *buf, int reg) | ||
143 | +{ | ||
144 | + return 0; | ||
145 | +} | ||
146 | + | ||
147 | static void arm_gen_one_xml_sysreg_tag(GString *s, DynamicGDBXMLInfo *dyn_xml, | ||
148 | ARMCPRegInfo *ri, uint32_t ri_key, | ||
149 | int bitsize, int regnum) | ||
150 | @@ -XXX,XX +XXX,XX @@ const char *arm_gdb_get_dynamic_xml(CPUState *cs, const char *xmlname) | ||
151 | } | ||
152 | return NULL; | ||
153 | } | ||
154 | + | ||
155 | +void arm_cpu_register_gdb_regs_for_features(ARMCPU *cpu) | ||
156 | +{ | ||
157 | + CPUState *cs = CPU(cpu); | ||
158 | + CPUARMState *env = &cpu->env; | ||
159 | + | ||
160 | + if (arm_feature(env, ARM_FEATURE_AARCH64)) { | ||
161 | + /* | ||
162 | + * The lower part of each SVE register aliases to the FPU | ||
163 | + * registers so we don't need to include both. | ||
164 | + */ | ||
165 | +#ifdef TARGET_AARCH64 | ||
166 | + if (isar_feature_aa64_sve(&cpu->isar)) { | ||
167 | + gdb_register_coprocessor(cs, arm_gdb_get_svereg, arm_gdb_set_svereg, | ||
168 | + arm_gen_dynamic_svereg_xml(cs, cs->gdb_num_regs), | ||
169 | + "sve-registers.xml", 0); | ||
170 | + } else { | ||
171 | + gdb_register_coprocessor(cs, aarch64_fpu_gdb_get_reg, | ||
172 | + aarch64_fpu_gdb_set_reg, | ||
173 | + 34, "aarch64-fpu.xml", 0); | ||
174 | + } | ||
175 | +#endif | ||
176 | + } else if (arm_feature(env, ARM_FEATURE_NEON)) { | ||
177 | + gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
178 | + 51, "arm-neon.xml", 0); | ||
179 | + } else if (cpu_isar_feature(aa32_simd_r32, cpu)) { | ||
180 | + gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
181 | + 35, "arm-vfp3.xml", 0); | ||
182 | + } else if (cpu_isar_feature(aa32_vfp_simd, cpu)) { | ||
183 | + gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
184 | + 19, "arm-vfp.xml", 0); | ||
185 | + } | ||
186 | + gdb_register_coprocessor(cs, arm_gdb_get_sysreg, arm_gdb_set_sysreg, | ||
187 | + arm_gen_dynamic_sysreg_xml(cs, cs->gdb_num_regs), | ||
188 | + "system-registers.xml", 0); | ||
189 | + | ||
190 | +} | ||
191 | diff --git a/target/arm/gdbstub64.c b/target/arm/gdbstub64.c | ||
192 | index XXXXXXX..XXXXXXX 100644 | ||
193 | --- a/target/arm/gdbstub64.c | ||
194 | +++ b/target/arm/gdbstub64.c | ||
195 | @@ -XXX,XX +XXX,XX @@ | ||
196 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. | ||
197 | */ | ||
198 | #include "qemu/osdep.h" | ||
199 | +#include "qemu/log.h" | ||
200 | #include "cpu.h" | ||
201 | +#include "internals.h" | ||
202 | #include "exec/gdbstub.h" | ||
203 | |||
204 | int aarch64_cpu_gdb_read_register(CPUState *cs, GByteArray *mem_buf, int n) | ||
205 | @@ -XXX,XX +XXX,XX @@ int aarch64_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n) | ||
206 | /* Unknown register. */ | ||
207 | return 0; | ||
208 | } | ||
209 | + | ||
210 | +int aarch64_fpu_gdb_get_reg(CPUARMState *env, GByteArray *buf, int reg) | ||
211 | +{ | ||
212 | + switch (reg) { | ||
213 | + case 0 ... 31: | ||
214 | + { | ||
215 | + /* 128 bit FP register - quads are in LE order */ | ||
216 | + uint64_t *q = aa64_vfp_qreg(env, reg); | ||
217 | + return gdb_get_reg128(buf, q[1], q[0]); | ||
218 | + } | ||
219 | + case 32: | ||
220 | + /* FPSR */ | ||
221 | + return gdb_get_reg32(buf, vfp_get_fpsr(env)); | ||
222 | + case 33: | ||
223 | + /* FPCR */ | ||
224 | + return gdb_get_reg32(buf, vfp_get_fpcr(env)); | ||
225 | + default: | ||
226 | + return 0; | ||
227 | + } | ||
228 | +} | ||
229 | + | ||
230 | +int aarch64_fpu_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg) | ||
231 | +{ | ||
232 | + switch (reg) { | ||
233 | + case 0 ... 31: | ||
234 | + /* 128 bit FP register */ | ||
235 | + { | ||
236 | + uint64_t *q = aa64_vfp_qreg(env, reg); | ||
237 | + q[0] = ldq_le_p(buf); | ||
238 | + q[1] = ldq_le_p(buf + 8); | ||
239 | + return 16; | ||
240 | + } | ||
241 | + case 32: | ||
242 | + /* FPSR */ | ||
243 | + vfp_set_fpsr(env, ldl_p(buf)); | ||
244 | + return 4; | ||
245 | + case 33: | ||
246 | + /* FPCR */ | ||
247 | + vfp_set_fpcr(env, ldl_p(buf)); | ||
248 | + return 4; | ||
249 | + default: | ||
250 | + return 0; | ||
251 | + } | ||
252 | +} | ||
253 | + | ||
254 | +int arm_gdb_get_svereg(CPUARMState *env, GByteArray *buf, int reg) | ||
255 | +{ | ||
256 | + ARMCPU *cpu = env_archcpu(env); | ||
257 | + | ||
258 | + switch (reg) { | ||
259 | + /* The first 32 registers are the zregs */ | ||
260 | + case 0 ... 31: | ||
261 | + { | ||
262 | + int vq, len = 0; | ||
263 | + for (vq = 0; vq < cpu->sve_max_vq; vq++) { | ||
264 | + len += gdb_get_reg128(buf, | ||
265 | + env->vfp.zregs[reg].d[vq * 2 + 1], | ||
266 | + env->vfp.zregs[reg].d[vq * 2]); | ||
267 | + } | ||
268 | + return len; | ||
269 | + } | ||
270 | + case 32: | ||
271 | + return gdb_get_reg32(buf, vfp_get_fpsr(env)); | ||
272 | + case 33: | ||
273 | + return gdb_get_reg32(buf, vfp_get_fpcr(env)); | ||
274 | + /* then 16 predicates and the ffr */ | ||
275 | + case 34 ... 50: | ||
276 | + { | ||
277 | + int preg = reg - 34; | ||
278 | + int vq, len = 0; | ||
279 | + for (vq = 0; vq < cpu->sve_max_vq; vq = vq + 4) { | ||
280 | + len += gdb_get_reg64(buf, env->vfp.pregs[preg].p[vq / 4]); | ||
281 | + } | ||
282 | + return len; | ||
283 | + } | ||
284 | + case 51: | ||
285 | + { | ||
286 | + /* | ||
287 | + * We report in Vector Granules (VG) which is 64bit in a Z reg | ||
288 | + * while the ZCR works in Vector Quads (VQ) which is 128bit chunks. | ||
289 | + */ | ||
290 | + int vq = sve_zcr_len_for_el(env, arm_current_el(env)) + 1; | ||
291 | + return gdb_get_reg64(buf, vq * 2); | ||
292 | + } | ||
293 | + default: | ||
294 | + /* gdbstub asked for something out our range */ | ||
295 | + qemu_log_mask(LOG_UNIMP, "%s: out of range register %d", __func__, reg); | ||
296 | + break; | ||
297 | + } | ||
298 | + | ||
299 | + return 0; | ||
300 | +} | ||
301 | + | ||
302 | +int arm_gdb_set_svereg(CPUARMState *env, uint8_t *buf, int reg) | ||
303 | +{ | ||
304 | + ARMCPU *cpu = env_archcpu(env); | ||
305 | + | ||
306 | + /* The first 32 registers are the zregs */ | ||
307 | + switch (reg) { | ||
308 | + /* The first 32 registers are the zregs */ | ||
309 | + case 0 ... 31: | ||
310 | + { | ||
311 | + int vq, len = 0; | ||
312 | + uint64_t *p = (uint64_t *) buf; | ||
313 | + for (vq = 0; vq < cpu->sve_max_vq; vq++) { | ||
314 | + env->vfp.zregs[reg].d[vq * 2 + 1] = *p++; | ||
315 | + env->vfp.zregs[reg].d[vq * 2] = *p++; | ||
316 | + len += 16; | ||
317 | + } | ||
318 | + return len; | ||
319 | + } | ||
320 | + case 32: | ||
321 | + vfp_set_fpsr(env, *(uint32_t *)buf); | ||
322 | + return 4; | ||
323 | + case 33: | ||
324 | + vfp_set_fpcr(env, *(uint32_t *)buf); | ||
325 | + return 4; | ||
326 | + case 34 ... 50: | ||
327 | + { | ||
328 | + int preg = reg - 34; | ||
329 | + int vq, len = 0; | ||
330 | + uint64_t *p = (uint64_t *) buf; | ||
331 | + for (vq = 0; vq < cpu->sve_max_vq; vq = vq + 4) { | ||
332 | + env->vfp.pregs[preg].p[vq / 4] = *p++; | ||
333 | + len += 8; | ||
334 | + } | ||
335 | + return len; | ||
336 | + } | ||
337 | + case 51: | ||
338 | + /* cannot set vg via gdbstub */ | ||
339 | + return 0; | ||
340 | + default: | ||
341 | + /* gdbstub asked for something out our range */ | ||
342 | + break; | ||
343 | + } | ||
344 | + | ||
345 | + return 0; | ||
346 | +} | ||
19 | diff --git a/target/arm/helper.c b/target/arm/helper.c | 347 | diff --git a/target/arm/helper.c b/target/arm/helper.c |
20 | index XXXXXXX..XXXXXXX 100644 | 348 | index XXXXXXX..XXXXXXX 100644 |
21 | --- a/target/arm/helper.c | 349 | --- a/target/arm/helper.c |
22 | +++ b/target/arm/helper.c | 350 | +++ b/target/arm/helper.c |
23 | @@ -XXX,XX +XXX,XX @@ | 351 | @@ -XXX,XX +XXX,XX @@ |
24 | 352 | #include "trace.h" | |
25 | static bool get_phys_addr_lpae(CPUARMState *env, target_ulong address, | 353 | #include "cpu.h" |
26 | MMUAccessType access_type, ARMMMUIdx mmu_idx, | 354 | #include "internals.h" |
27 | + bool s1_is_el0, | 355 | -#include "exec/gdbstub.h" |
28 | hwaddr *phys_ptr, MemTxAttrs *txattrs, int *prot, | 356 | #include "exec/helper-proto.h" |
29 | target_ulong *page_size_ptr, | 357 | #include "qemu/host-utils.h" |
30 | ARMMMUFaultInfo *fi, ARMCacheAttrs *cacheattrs); | 358 | #include "qemu/main-loop.h" |
31 | @@ -XXX,XX +XXX,XX @@ static hwaddr S1_ptw_translate(CPUARMState *env, ARMMMUIdx mmu_idx, | 359 | @@ -XXX,XX +XXX,XX @@ static bool get_phys_addr_lpae(CPUARMState *env, uint64_t address, |
32 | } | 360 | static void switch_mode(CPUARMState *env, int mode); |
33 | 361 | static int aa64_va_parameter_tbi(uint64_t tcr, ARMMMUIdx mmu_idx); | |
34 | ret = get_phys_addr_lpae(env, addr, MMU_DATA_LOAD, ARMMMUIdx_Stage2, | 362 | |
35 | + false, | 363 | -static int vfp_gdb_get_reg(CPUARMState *env, GByteArray *buf, int reg) |
36 | &s2pa, &txattrs, &s2prot, &s2size, fi, | 364 | -{ |
37 | pcacheattrs); | 365 | - ARMCPU *cpu = env_archcpu(env); |
38 | if (ret) { | 366 | - int nregs = cpu_isar_feature(aa32_simd_r32, cpu) ? 32 : 16; |
39 | @@ -XXX,XX +XXX,XX @@ static ARMVAParameters aa32_va_parameters(CPUARMState *env, uint32_t va, | 367 | - |
40 | }; | 368 | - /* VFP data registers are always little-endian. */ |
369 | - if (reg < nregs) { | ||
370 | - return gdb_get_reg64(buf, *aa32_vfp_dreg(env, reg)); | ||
371 | - } | ||
372 | - if (arm_feature(env, ARM_FEATURE_NEON)) { | ||
373 | - /* Aliases for Q regs. */ | ||
374 | - nregs += 16; | ||
375 | - if (reg < nregs) { | ||
376 | - uint64_t *q = aa32_vfp_qreg(env, reg - 32); | ||
377 | - return gdb_get_reg128(buf, q[0], q[1]); | ||
378 | - } | ||
379 | - } | ||
380 | - switch (reg - nregs) { | ||
381 | - case 0: | ||
382 | - return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPSID]); | ||
383 | - case 1: | ||
384 | - return gdb_get_reg32(buf, vfp_get_fpscr(env)); | ||
385 | - case 2: | ||
386 | - return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPEXC]); | ||
387 | - } | ||
388 | - return 0; | ||
389 | -} | ||
390 | - | ||
391 | -static int vfp_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg) | ||
392 | -{ | ||
393 | - ARMCPU *cpu = env_archcpu(env); | ||
394 | - int nregs = cpu_isar_feature(aa32_simd_r32, cpu) ? 32 : 16; | ||
395 | - | ||
396 | - if (reg < nregs) { | ||
397 | - *aa32_vfp_dreg(env, reg) = ldq_le_p(buf); | ||
398 | - return 8; | ||
399 | - } | ||
400 | - if (arm_feature(env, ARM_FEATURE_NEON)) { | ||
401 | - nregs += 16; | ||
402 | - if (reg < nregs) { | ||
403 | - uint64_t *q = aa32_vfp_qreg(env, reg - 32); | ||
404 | - q[0] = ldq_le_p(buf); | ||
405 | - q[1] = ldq_le_p(buf + 8); | ||
406 | - return 16; | ||
407 | - } | ||
408 | - } | ||
409 | - switch (reg - nregs) { | ||
410 | - case 0: | ||
411 | - env->vfp.xregs[ARM_VFP_FPSID] = ldl_p(buf); | ||
412 | - return 4; | ||
413 | - case 1: | ||
414 | - vfp_set_fpscr(env, ldl_p(buf)); | ||
415 | - return 4; | ||
416 | - case 2: | ||
417 | - env->vfp.xregs[ARM_VFP_FPEXC] = ldl_p(buf) & (1 << 30); | ||
418 | - return 4; | ||
419 | - } | ||
420 | - return 0; | ||
421 | -} | ||
422 | - | ||
423 | -static int aarch64_fpu_gdb_get_reg(CPUARMState *env, GByteArray *buf, int reg) | ||
424 | -{ | ||
425 | - switch (reg) { | ||
426 | - case 0 ... 31: | ||
427 | - { | ||
428 | - /* 128 bit FP register - quads are in LE order */ | ||
429 | - uint64_t *q = aa64_vfp_qreg(env, reg); | ||
430 | - return gdb_get_reg128(buf, q[1], q[0]); | ||
431 | - } | ||
432 | - case 32: | ||
433 | - /* FPSR */ | ||
434 | - return gdb_get_reg32(buf, vfp_get_fpsr(env)); | ||
435 | - case 33: | ||
436 | - /* FPCR */ | ||
437 | - return gdb_get_reg32(buf, vfp_get_fpcr(env)); | ||
438 | - default: | ||
439 | - return 0; | ||
440 | - } | ||
441 | -} | ||
442 | - | ||
443 | -static int aarch64_fpu_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg) | ||
444 | -{ | ||
445 | - switch (reg) { | ||
446 | - case 0 ... 31: | ||
447 | - /* 128 bit FP register */ | ||
448 | - { | ||
449 | - uint64_t *q = aa64_vfp_qreg(env, reg); | ||
450 | - q[0] = ldq_le_p(buf); | ||
451 | - q[1] = ldq_le_p(buf + 8); | ||
452 | - return 16; | ||
453 | - } | ||
454 | - case 32: | ||
455 | - /* FPSR */ | ||
456 | - vfp_set_fpsr(env, ldl_p(buf)); | ||
457 | - return 4; | ||
458 | - case 33: | ||
459 | - /* FPCR */ | ||
460 | - vfp_set_fpcr(env, ldl_p(buf)); | ||
461 | - return 4; | ||
462 | - default: | ||
463 | - return 0; | ||
464 | - } | ||
465 | -} | ||
466 | - | ||
467 | static uint64_t raw_read(CPUARMState *env, const ARMCPRegInfo *ri) | ||
468 | { | ||
469 | assert(ri->fieldoffset); | ||
470 | @@ -XXX,XX +XXX,XX @@ static void write_raw_cp_reg(CPUARMState *env, const ARMCPRegInfo *ri, | ||
471 | } | ||
41 | } | 472 | } |
42 | 473 | ||
43 | +/** | 474 | -/** |
44 | + * get_phys_addr_lpae: perform one stage of page table walk, LPAE format | 475 | - * arm_get/set_gdb_*: get/set a gdb register |
45 | + * | 476 | - * @env: the CPU state |
46 | + * Returns false if the translation was successful. Otherwise, phys_ptr, attrs, | 477 | - * @buf: a buffer to copy to/from |
47 | + * prot and page_size may not be filled in, and the populated fsr value provides | 478 | - * @reg: register number (offset from start of group) |
48 | + * information on why the translation aborted, in the format of a long-format | 479 | - * |
49 | + * DFSR/IFSR fault register, with the following caveats: | 480 | - * We return the number of bytes copied |
50 | + * * the WnR bit is never set (the caller must do this). | 481 | - */ |
51 | + * | 482 | - |
52 | + * @env: CPUARMState | 483 | -static int arm_gdb_get_sysreg(CPUARMState *env, GByteArray *buf, int reg) |
53 | + * @address: virtual address to get physical address for | 484 | -{ |
54 | + * @access_type: MMU_DATA_LOAD, MMU_DATA_STORE or MMU_INST_FETCH | 485 | - ARMCPU *cpu = env_archcpu(env); |
55 | + * @mmu_idx: MMU index indicating required translation regime | 486 | - const ARMCPRegInfo *ri; |
56 | + * @s1_is_el0: if @mmu_idx is ARMMMUIdx_Stage2 (so this is a stage 2 page table | 487 | - uint32_t key; |
57 | + * walk), must be true if this is stage 2 of a stage 1+2 walk for an | 488 | - |
58 | + * EL0 access). If @mmu_idx is anything else, @s1_is_el0 is ignored. | 489 | - key = cpu->dyn_sysreg_xml.data.cpregs.keys[reg]; |
59 | + * @phys_ptr: set to the physical address corresponding to the virtual address | 490 | - ri = get_arm_cp_reginfo(cpu->cp_regs, key); |
60 | + * @attrs: set to the memory transaction attributes to use | 491 | - if (ri) { |
61 | + * @prot: set to the permissions for the page containing phys_ptr | 492 | - if (cpreg_field_is_64bit(ri)) { |
62 | + * @page_size_ptr: set to the size of the page containing phys_ptr | 493 | - return gdb_get_reg64(buf, (uint64_t)read_raw_cp_reg(env, ri)); |
63 | + * @fi: set to fault info if the translation fails | 494 | - } else { |
64 | + * @cacheattrs: (if non-NULL) set to the cacheability/shareability attributes | 495 | - return gdb_get_reg32(buf, (uint32_t)read_raw_cp_reg(env, ri)); |
65 | + */ | 496 | - } |
66 | static bool get_phys_addr_lpae(CPUARMState *env, target_ulong address, | 497 | - } |
67 | MMUAccessType access_type, ARMMMUIdx mmu_idx, | 498 | - return 0; |
68 | + bool s1_is_el0, | 499 | -} |
69 | hwaddr *phys_ptr, MemTxAttrs *txattrs, int *prot, | 500 | - |
70 | target_ulong *page_size_ptr, | 501 | -static int arm_gdb_set_sysreg(CPUARMState *env, uint8_t *buf, int reg) |
71 | ARMMMUFaultInfo *fi, ARMCacheAttrs *cacheattrs) | 502 | -{ |
72 | @@ -XXX,XX +XXX,XX @@ bool get_phys_addr(CPUARMState *env, target_ulong address, | 503 | - return 0; |
73 | 504 | -} | |
74 | /* S1 is done. Now do S2 translation. */ | 505 | - |
75 | ret = get_phys_addr_lpae(env, ipa, access_type, ARMMMUIdx_Stage2, | 506 | -#ifdef TARGET_AARCH64 |
76 | + mmu_idx == ARMMMUIdx_E10_0, | 507 | -static int arm_gdb_get_svereg(CPUARMState *env, GByteArray *buf, int reg) |
77 | phys_ptr, attrs, &s2_prot, | 508 | -{ |
78 | page_size, fi, | 509 | - ARMCPU *cpu = env_archcpu(env); |
79 | cacheattrs != NULL ? &cacheattrs2 : NULL); | 510 | - |
80 | @@ -XXX,XX +XXX,XX @@ bool get_phys_addr(CPUARMState *env, target_ulong address, | 511 | - switch (reg) { |
81 | } | 512 | - /* The first 32 registers are the zregs */ |
82 | 513 | - case 0 ... 31: | |
83 | if (regime_using_lpae_format(env, mmu_idx)) { | 514 | - { |
84 | - return get_phys_addr_lpae(env, address, access_type, mmu_idx, | 515 | - int vq, len = 0; |
85 | + return get_phys_addr_lpae(env, address, access_type, mmu_idx, false, | 516 | - for (vq = 0; vq < cpu->sve_max_vq; vq++) { |
86 | phys_ptr, attrs, prot, page_size, | 517 | - len += gdb_get_reg128(buf, |
87 | fi, cacheattrs); | 518 | - env->vfp.zregs[reg].d[vq * 2 + 1], |
88 | } else if (regime_sctlr(env, mmu_idx) & SCTLR_XP) { | 519 | - env->vfp.zregs[reg].d[vq * 2]); |
520 | - } | ||
521 | - return len; | ||
522 | - } | ||
523 | - case 32: | ||
524 | - return gdb_get_reg32(buf, vfp_get_fpsr(env)); | ||
525 | - case 33: | ||
526 | - return gdb_get_reg32(buf, vfp_get_fpcr(env)); | ||
527 | - /* then 16 predicates and the ffr */ | ||
528 | - case 34 ... 50: | ||
529 | - { | ||
530 | - int preg = reg - 34; | ||
531 | - int vq, len = 0; | ||
532 | - for (vq = 0; vq < cpu->sve_max_vq; vq = vq + 4) { | ||
533 | - len += gdb_get_reg64(buf, env->vfp.pregs[preg].p[vq / 4]); | ||
534 | - } | ||
535 | - return len; | ||
536 | - } | ||
537 | - case 51: | ||
538 | - { | ||
539 | - /* | ||
540 | - * We report in Vector Granules (VG) which is 64bit in a Z reg | ||
541 | - * while the ZCR works in Vector Quads (VQ) which is 128bit chunks. | ||
542 | - */ | ||
543 | - int vq = sve_zcr_len_for_el(env, arm_current_el(env)) + 1; | ||
544 | - return gdb_get_reg64(buf, vq * 2); | ||
545 | - } | ||
546 | - default: | ||
547 | - /* gdbstub asked for something out our range */ | ||
548 | - qemu_log_mask(LOG_UNIMP, "%s: out of range register %d", __func__, reg); | ||
549 | - break; | ||
550 | - } | ||
551 | - | ||
552 | - return 0; | ||
553 | -} | ||
554 | - | ||
555 | -static int arm_gdb_set_svereg(CPUARMState *env, uint8_t *buf, int reg) | ||
556 | -{ | ||
557 | - ARMCPU *cpu = env_archcpu(env); | ||
558 | - | ||
559 | - /* The first 32 registers are the zregs */ | ||
560 | - switch (reg) { | ||
561 | - /* The first 32 registers are the zregs */ | ||
562 | - case 0 ... 31: | ||
563 | - { | ||
564 | - int vq, len = 0; | ||
565 | - uint64_t *p = (uint64_t *) buf; | ||
566 | - for (vq = 0; vq < cpu->sve_max_vq; vq++) { | ||
567 | - env->vfp.zregs[reg].d[vq * 2 + 1] = *p++; | ||
568 | - env->vfp.zregs[reg].d[vq * 2] = *p++; | ||
569 | - len += 16; | ||
570 | - } | ||
571 | - return len; | ||
572 | - } | ||
573 | - case 32: | ||
574 | - vfp_set_fpsr(env, *(uint32_t *)buf); | ||
575 | - return 4; | ||
576 | - case 33: | ||
577 | - vfp_set_fpcr(env, *(uint32_t *)buf); | ||
578 | - return 4; | ||
579 | - case 34 ... 50: | ||
580 | - { | ||
581 | - int preg = reg - 34; | ||
582 | - int vq, len = 0; | ||
583 | - uint64_t *p = (uint64_t *) buf; | ||
584 | - for (vq = 0; vq < cpu->sve_max_vq; vq = vq + 4) { | ||
585 | - env->vfp.pregs[preg].p[vq / 4] = *p++; | ||
586 | - len += 8; | ||
587 | - } | ||
588 | - return len; | ||
589 | - } | ||
590 | - case 51: | ||
591 | - /* cannot set vg via gdbstub */ | ||
592 | - return 0; | ||
593 | - default: | ||
594 | - /* gdbstub asked for something out our range */ | ||
595 | - break; | ||
596 | - } | ||
597 | - | ||
598 | - return 0; | ||
599 | -} | ||
600 | -#endif /* TARGET_AARCH64 */ | ||
601 | - | ||
602 | static bool raw_accessors_invalid(const ARMCPRegInfo *ri) | ||
603 | { | ||
604 | /* Return true if the regdef would cause an assertion if you called | ||
605 | @@ -XXX,XX +XXX,XX @@ void register_cp_regs_for_features(ARMCPU *cpu) | ||
606 | #endif | ||
607 | } | ||
608 | |||
609 | -void arm_cpu_register_gdb_regs_for_features(ARMCPU *cpu) | ||
610 | -{ | ||
611 | - CPUState *cs = CPU(cpu); | ||
612 | - CPUARMState *env = &cpu->env; | ||
613 | - | ||
614 | - if (arm_feature(env, ARM_FEATURE_AARCH64)) { | ||
615 | - /* | ||
616 | - * The lower part of each SVE register aliases to the FPU | ||
617 | - * registers so we don't need to include both. | ||
618 | - */ | ||
619 | -#ifdef TARGET_AARCH64 | ||
620 | - if (isar_feature_aa64_sve(&cpu->isar)) { | ||
621 | - gdb_register_coprocessor(cs, arm_gdb_get_svereg, arm_gdb_set_svereg, | ||
622 | - arm_gen_dynamic_svereg_xml(cs, cs->gdb_num_regs), | ||
623 | - "sve-registers.xml", 0); | ||
624 | - } else | ||
625 | -#endif | ||
626 | - { | ||
627 | - gdb_register_coprocessor(cs, aarch64_fpu_gdb_get_reg, | ||
628 | - aarch64_fpu_gdb_set_reg, | ||
629 | - 34, "aarch64-fpu.xml", 0); | ||
630 | - } | ||
631 | - } else if (arm_feature(env, ARM_FEATURE_NEON)) { | ||
632 | - gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
633 | - 51, "arm-neon.xml", 0); | ||
634 | - } else if (cpu_isar_feature(aa32_simd_r32, cpu)) { | ||
635 | - gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
636 | - 35, "arm-vfp3.xml", 0); | ||
637 | - } else if (cpu_isar_feature(aa32_vfp_simd, cpu)) { | ||
638 | - gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
639 | - 19, "arm-vfp.xml", 0); | ||
640 | - } | ||
641 | - gdb_register_coprocessor(cs, arm_gdb_get_sysreg, arm_gdb_set_sysreg, | ||
642 | - arm_gen_dynamic_sysreg_xml(cs, cs->gdb_num_regs), | ||
643 | - "system-registers.xml", 0); | ||
644 | - | ||
645 | -} | ||
646 | - | ||
647 | /* Sort alphabetically by type name, except for "any". */ | ||
648 | static gint arm_cpu_list_compare(gconstpointer a, gconstpointer b) | ||
649 | { | ||
89 | -- | 650 | -- |
90 | 2.20.1 | 651 | 2.20.1 |
91 | 652 | ||
92 | 653 | diff view generated by jsdifflib |
1 | Convert the Neon VMUL, VMLA, VMLS and VSHL insns in the | 1 | Currently we send VFP XML which includes D0..D15 or D0..D31, plus |
---|---|---|---|
2 | 3-reg-same grouping to decodetree. | 2 | FPSID, FPSCR and FPEXC. The upstream GDB tolerates this, but its |
3 | definition of this XML feature does not include FPSID or FPEXC. In | ||
4 | particular, for M-profile cores there are no FPSID or FPEXC | ||
5 | registers, so advertising those is wrong. | ||
6 | |||
7 | Move FPSID and FPEXC into their own bit of XML which we only send for | ||
8 | A and R profile cores. This brings our definition of the XML | ||
9 | org.gnu.gdb.arm.vfp feature into line with GDB's own (at least for | ||
10 | non-Neon cores...) and means we don't claim to have FPSID and FPEXC | ||
11 | on M-profile. | ||
12 | |||
13 | (It seems unlikely to me that any gdbstub users really care about | ||
14 | being able to look at FPEXC and FPSID; but we've supplied them to gdb | ||
15 | for a decade and it's not hard to keep doing so.) | ||
3 | 16 | ||
4 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 17 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
5 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | 18 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
6 | Message-id: 20200430181003.21682-20-peter.maydell@linaro.org | 19 | Message-id: 20210921162901.17508-5-peter.maydell@linaro.org |
7 | --- | 20 | --- |
8 | target/arm/neon-dp.decode | 9 +++++++ | 21 | configs/targets/aarch64-softmmu.mak | 2 +- |
9 | target/arm/translate-neon.inc.c | 44 +++++++++++++++++++++++++++++++++ | 22 | configs/targets/arm-linux-user.mak | 2 +- |
10 | target/arm/translate.c | 28 +++------------------ | 23 | configs/targets/arm-softmmu.mak | 2 +- |
11 | 3 files changed, 56 insertions(+), 25 deletions(-) | 24 | configs/targets/armeb-linux-user.mak | 2 +- |
12 | 25 | target/arm/gdbstub.c | 56 ++++++++++++++++++++-------- | |
13 | diff --git a/target/arm/neon-dp.decode b/target/arm/neon-dp.decode | 26 | gdb-xml/arm-neon.xml | 2 - |
14 | index XXXXXXX..XXXXXXX 100644 | 27 | gdb-xml/arm-vfp-sysregs.xml | 17 +++++++++ |
15 | --- a/target/arm/neon-dp.decode | 28 | gdb-xml/arm-vfp.xml | 2 - |
16 | +++ b/target/arm/neon-dp.decode | 29 | gdb-xml/arm-vfp3.xml | 2 - |
17 | @@ -XXX,XX +XXX,XX @@ VCGT_U_3s 1111 001 1 0 . .. .... .... 0011 . . . 0 .... @3same | 30 | 9 files changed, 61 insertions(+), 26 deletions(-) |
18 | VCGE_S_3s 1111 001 0 0 . .. .... .... 0011 . . . 1 .... @3same | 31 | create mode 100644 gdb-xml/arm-vfp-sysregs.xml |
19 | VCGE_U_3s 1111 001 1 0 . .. .... .... 0011 . . . 1 .... @3same | 32 | |
20 | 33 | diff --git a/configs/targets/aarch64-softmmu.mak b/configs/targets/aarch64-softmmu.mak | |
21 | +VSHL_S_3s 1111 001 0 0 . .. .... .... 0100 . . . 0 .... @3same | 34 | index XXXXXXX..XXXXXXX 100644 |
22 | +VSHL_U_3s 1111 001 1 0 . .. .... .... 0100 . . . 0 .... @3same | 35 | --- a/configs/targets/aarch64-softmmu.mak |
23 | + | 36 | +++ b/configs/targets/aarch64-softmmu.mak |
24 | VMAX_S_3s 1111 001 0 0 . .. .... .... 0110 . . . 0 .... @3same | 37 | @@ -XXX,XX +XXX,XX @@ |
25 | VMAX_U_3s 1111 001 1 0 . .. .... .... 0110 . . . 0 .... @3same | 38 | TARGET_ARCH=aarch64 |
26 | VMIN_S_3s 1111 001 0 0 . .. .... .... 0110 . . . 1 .... @3same | 39 | TARGET_BASE_ARCH=arm |
27 | @@ -XXX,XX +XXX,XX @@ VSUB_3s 1111 001 1 0 . .. .... .... 1000 . . . 0 .... @3same | 40 | TARGET_SUPPORTS_MTTCG=y |
28 | 41 | -TARGET_XML_FILES= gdb-xml/aarch64-core.xml gdb-xml/aarch64-fpu.xml gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml | |
29 | VTST_3s 1111 001 0 0 . .. .... .... 1000 . . . 1 .... @3same | 42 | +TARGET_XML_FILES= gdb-xml/aarch64-core.xml gdb-xml/aarch64-fpu.xml gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-vfp-sysregs.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml |
30 | VCEQ_3s 1111 001 1 0 . .. .... .... 1000 . . . 1 .... @3same | 43 | TARGET_NEED_FDT=y |
31 | + | 44 | diff --git a/configs/targets/arm-linux-user.mak b/configs/targets/arm-linux-user.mak |
32 | +VMLA_3s 1111 001 0 0 . .. .... .... 1001 . . . 0 .... @3same | 45 | index XXXXXXX..XXXXXXX 100644 |
33 | +VMLS_3s 1111 001 1 0 . .. .... .... 1001 . . . 0 .... @3same | 46 | --- a/configs/targets/arm-linux-user.mak |
34 | + | 47 | +++ b/configs/targets/arm-linux-user.mak |
35 | +VMUL_3s 1111 001 0 0 . .. .... .... 1001 . . . 1 .... @3same | 48 | @@ -XXX,XX +XXX,XX @@ |
36 | +VMUL_p_3s 1111 001 1 0 . .. .... .... 1001 . . . 1 .... @3same | 49 | TARGET_ARCH=arm |
37 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | 50 | TARGET_SYSTBL_ABI=common,oabi |
38 | index XXXXXXX..XXXXXXX 100644 | 51 | TARGET_SYSTBL=syscall.tbl |
39 | --- a/target/arm/translate-neon.inc.c | 52 | -TARGET_XML_FILES= gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml |
40 | +++ b/target/arm/translate-neon.inc.c | 53 | +TARGET_XML_FILES= gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-vfp-sysregs.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml |
41 | @@ -XXX,XX +XXX,XX @@ DO_3SAME_NO_SZ_3(VMAX_S, tcg_gen_gvec_smax) | 54 | TARGET_HAS_BFLT=y |
42 | DO_3SAME_NO_SZ_3(VMAX_U, tcg_gen_gvec_umax) | 55 | CONFIG_ARM_COMPATIBLE_SEMIHOSTING=y |
43 | DO_3SAME_NO_SZ_3(VMIN_S, tcg_gen_gvec_smin) | 56 | diff --git a/configs/targets/arm-softmmu.mak b/configs/targets/arm-softmmu.mak |
44 | DO_3SAME_NO_SZ_3(VMIN_U, tcg_gen_gvec_umin) | 57 | index XXXXXXX..XXXXXXX 100644 |
45 | +DO_3SAME_NO_SZ_3(VMUL, tcg_gen_gvec_mul) | 58 | --- a/configs/targets/arm-softmmu.mak |
46 | 59 | +++ b/configs/targets/arm-softmmu.mak | |
47 | #define DO_3SAME_CMP(INSN, COND) \ | 60 | @@ -XXX,XX +XXX,XX @@ |
48 | static void gen_##INSN##_3s(unsigned vece, uint32_t rd_ofs, \ | 61 | TARGET_ARCH=arm |
49 | @@ -XXX,XX +XXX,XX @@ DO_3SAME_GVEC4(VQADD_S, sqadd_op) | 62 | TARGET_SUPPORTS_MTTCG=y |
50 | DO_3SAME_GVEC4(VQADD_U, uqadd_op) | 63 | -TARGET_XML_FILES= gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml |
51 | DO_3SAME_GVEC4(VQSUB_S, sqsub_op) | 64 | +TARGET_XML_FILES= gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-vfp-sysregs.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml |
52 | DO_3SAME_GVEC4(VQSUB_U, uqsub_op) | 65 | TARGET_NEED_FDT=y |
53 | + | 66 | diff --git a/configs/targets/armeb-linux-user.mak b/configs/targets/armeb-linux-user.mak |
54 | +static void gen_VMUL_p_3s(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs, | 67 | index XXXXXXX..XXXXXXX 100644 |
55 | + uint32_t rm_ofs, uint32_t oprsz, uint32_t maxsz) | 68 | --- a/configs/targets/armeb-linux-user.mak |
69 | +++ b/configs/targets/armeb-linux-user.mak | ||
70 | @@ -XXX,XX +XXX,XX @@ TARGET_ARCH=arm | ||
71 | TARGET_SYSTBL_ABI=common,oabi | ||
72 | TARGET_SYSTBL=syscall.tbl | ||
73 | TARGET_WORDS_BIGENDIAN=y | ||
74 | -TARGET_XML_FILES= gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml | ||
75 | +TARGET_XML_FILES= gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-vfp-sysregs.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml | ||
76 | TARGET_HAS_BFLT=y | ||
77 | CONFIG_ARM_COMPATIBLE_SEMIHOSTING=y | ||
78 | diff --git a/target/arm/gdbstub.c b/target/arm/gdbstub.c | ||
79 | index XXXXXXX..XXXXXXX 100644 | ||
80 | --- a/target/arm/gdbstub.c | ||
81 | +++ b/target/arm/gdbstub.c | ||
82 | @@ -XXX,XX +XXX,XX @@ static int vfp_gdb_get_reg(CPUARMState *env, GByteArray *buf, int reg) | ||
83 | } | ||
84 | switch (reg - nregs) { | ||
85 | case 0: | ||
86 | - return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPSID]); | ||
87 | - case 1: | ||
88 | return gdb_get_reg32(buf, vfp_get_fpscr(env)); | ||
89 | - case 2: | ||
90 | - return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPEXC]); | ||
91 | } | ||
92 | return 0; | ||
93 | } | ||
94 | @@ -XXX,XX +XXX,XX @@ static int vfp_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg) | ||
95 | } | ||
96 | } | ||
97 | switch (reg - nregs) { | ||
98 | + case 0: | ||
99 | + vfp_set_fpscr(env, ldl_p(buf)); | ||
100 | + return 4; | ||
101 | + } | ||
102 | + return 0; | ||
103 | +} | ||
104 | + | ||
105 | +static int vfp_gdb_get_sysreg(CPUARMState *env, GByteArray *buf, int reg) | ||
56 | +{ | 106 | +{ |
57 | + tcg_gen_gvec_3_ool(rd_ofs, rn_ofs, rm_ofs, oprsz, maxsz, | 107 | + switch (reg) { |
58 | + 0, gen_helper_gvec_pmul_b); | 108 | + case 0: |
109 | + return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPSID]); | ||
110 | + case 1: | ||
111 | + return gdb_get_reg32(buf, env->vfp.xregs[ARM_VFP_FPEXC]); | ||
112 | + } | ||
113 | + return 0; | ||
59 | +} | 114 | +} |
60 | + | 115 | + |
61 | +static bool trans_VMUL_p_3s(DisasContext *s, arg_3same *a) | 116 | +static int vfp_gdb_set_sysreg(CPUARMState *env, uint8_t *buf, int reg) |
62 | +{ | 117 | +{ |
63 | + if (a->size != 0) { | 118 | + switch (reg) { |
64 | + return false; | 119 | case 0: |
65 | + } | 120 | env->vfp.xregs[ARM_VFP_FPSID] = ldl_p(buf); |
66 | + return do_3same(s, a, gen_VMUL_p_3s); | 121 | return 4; |
67 | +} | 122 | case 1: |
68 | + | 123 | - vfp_set_fpscr(env, ldl_p(buf)); |
69 | +#define DO_3SAME_GVEC3_NO_SZ_3(INSN, OPARRAY) \ | 124 | - return 4; |
70 | + static void gen_##INSN##_3s(unsigned vece, uint32_t rd_ofs, \ | 125 | - case 2: |
71 | + uint32_t rn_ofs, uint32_t rm_ofs, \ | 126 | env->vfp.xregs[ARM_VFP_FPEXC] = ldl_p(buf) & (1 << 30); |
72 | + uint32_t oprsz, uint32_t maxsz) \ | 127 | return 4; |
73 | + { \ | 128 | } |
74 | + tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, \ | 129 | @@ -XXX,XX +XXX,XX @@ void arm_cpu_register_gdb_regs_for_features(ARMCPU *cpu) |
75 | + oprsz, maxsz, &OPARRAY[vece]); \ | 130 | 34, "aarch64-fpu.xml", 0); |
76 | + } \ | ||
77 | + DO_3SAME_NO_SZ_3(INSN, gen_##INSN##_3s) | ||
78 | + | ||
79 | + | ||
80 | +DO_3SAME_GVEC3_NO_SZ_3(VMLA, mla_op) | ||
81 | +DO_3SAME_GVEC3_NO_SZ_3(VMLS, mls_op) | ||
82 | + | ||
83 | +#define DO_3SAME_GVEC3_SHIFT(INSN, OPARRAY) \ | ||
84 | + static void gen_##INSN##_3s(unsigned vece, uint32_t rd_ofs, \ | ||
85 | + uint32_t rn_ofs, uint32_t rm_ofs, \ | ||
86 | + uint32_t oprsz, uint32_t maxsz) \ | ||
87 | + { \ | ||
88 | + /* Note the operation is vshl vd,vm,vn */ \ | ||
89 | + tcg_gen_gvec_3(rd_ofs, rm_ofs, rn_ofs, \ | ||
90 | + oprsz, maxsz, &OPARRAY[vece]); \ | ||
91 | + } \ | ||
92 | + DO_3SAME(INSN, gen_##INSN##_3s) | ||
93 | + | ||
94 | +DO_3SAME_GVEC3_SHIFT(VSHL_S, sshl_op) | ||
95 | +DO_3SAME_GVEC3_SHIFT(VSHL_U, ushl_op) | ||
96 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
97 | index XXXXXXX..XXXXXXX 100644 | ||
98 | --- a/target/arm/translate.c | ||
99 | +++ b/target/arm/translate.c | ||
100 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
101 | } | ||
102 | return 1; | ||
103 | |||
104 | - case NEON_3R_VMUL: /* VMUL */ | ||
105 | - if (u) { | ||
106 | - /* Polynomial case allows only P8. */ | ||
107 | - if (size != 0) { | ||
108 | - return 1; | ||
109 | - } | ||
110 | - tcg_gen_gvec_3_ool(rd_ofs, rn_ofs, rm_ofs, vec_size, vec_size, | ||
111 | - 0, gen_helper_gvec_pmul_b); | ||
112 | - } else { | ||
113 | - tcg_gen_gvec_mul(size, rd_ofs, rn_ofs, rm_ofs, | ||
114 | - vec_size, vec_size); | ||
115 | - } | ||
116 | - return 0; | ||
117 | - | ||
118 | - case NEON_3R_VML: /* VMLA, VMLS */ | ||
119 | - tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, vec_size, vec_size, | ||
120 | - u ? &mls_op[size] : &mla_op[size]); | ||
121 | - return 0; | ||
122 | - | ||
123 | - case NEON_3R_VSHL: | ||
124 | - /* Note the operation is vshl vd,vm,vn */ | ||
125 | - tcg_gen_gvec_3(rd_ofs, rm_ofs, rn_ofs, vec_size, vec_size, | ||
126 | - u ? &ushl_op[size] : &sshl_op[size]); | ||
127 | - return 0; | ||
128 | - | ||
129 | case NEON_3R_VADD_VSUB: | ||
130 | case NEON_3R_LOGIC: | ||
131 | case NEON_3R_VMAX: | ||
132 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
133 | case NEON_3R_VCGE: | ||
134 | case NEON_3R_VQADD: | ||
135 | case NEON_3R_VQSUB: | ||
136 | + case NEON_3R_VMUL: | ||
137 | + case NEON_3R_VML: | ||
138 | + case NEON_3R_VSHL: | ||
139 | /* Already handled by decodetree */ | ||
140 | return 1; | ||
141 | } | 131 | } |
132 | #endif | ||
133 | - } else if (arm_feature(env, ARM_FEATURE_NEON)) { | ||
134 | - gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
135 | - 51, "arm-neon.xml", 0); | ||
136 | - } else if (cpu_isar_feature(aa32_simd_r32, cpu)) { | ||
137 | - gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
138 | - 35, "arm-vfp3.xml", 0); | ||
139 | - } else if (cpu_isar_feature(aa32_vfp_simd, cpu)) { | ||
140 | - gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
141 | - 19, "arm-vfp.xml", 0); | ||
142 | + } else { | ||
143 | + if (arm_feature(env, ARM_FEATURE_NEON)) { | ||
144 | + gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
145 | + 49, "arm-neon.xml", 0); | ||
146 | + } else if (cpu_isar_feature(aa32_simd_r32, cpu)) { | ||
147 | + gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
148 | + 33, "arm-vfp3.xml", 0); | ||
149 | + } else if (cpu_isar_feature(aa32_vfp_simd, cpu)) { | ||
150 | + gdb_register_coprocessor(cs, vfp_gdb_get_reg, vfp_gdb_set_reg, | ||
151 | + 17, "arm-vfp.xml", 0); | ||
152 | + } | ||
153 | + if (!arm_feature(env, ARM_FEATURE_M)) { | ||
154 | + /* | ||
155 | + * A and R profile have FP sysregs FPEXC and FPSID that we | ||
156 | + * expose to gdb. | ||
157 | + */ | ||
158 | + gdb_register_coprocessor(cs, vfp_gdb_get_sysreg, vfp_gdb_set_sysreg, | ||
159 | + 2, "arm-vfp-sysregs.xml", 0); | ||
160 | + } | ||
161 | } | ||
162 | gdb_register_coprocessor(cs, arm_gdb_get_sysreg, arm_gdb_set_sysreg, | ||
163 | arm_gen_dynamic_sysreg_xml(cs, cs->gdb_num_regs), | ||
164 | diff --git a/gdb-xml/arm-neon.xml b/gdb-xml/arm-neon.xml | ||
165 | index XXXXXXX..XXXXXXX 100644 | ||
166 | --- a/gdb-xml/arm-neon.xml | ||
167 | +++ b/gdb-xml/arm-neon.xml | ||
168 | @@ -XXX,XX +XXX,XX @@ | ||
169 | <reg name="q14" bitsize="128" type="neon_q"/> | ||
170 | <reg name="q15" bitsize="128" type="neon_q"/> | ||
171 | |||
172 | - <reg name="fpsid" bitsize="32" type="int" group="float"/> | ||
173 | <reg name="fpscr" bitsize="32" type="int" group="float"/> | ||
174 | - <reg name="fpexc" bitsize="32" type="int" group="float"/> | ||
175 | </feature> | ||
176 | diff --git a/gdb-xml/arm-vfp-sysregs.xml b/gdb-xml/arm-vfp-sysregs.xml | ||
177 | new file mode 100644 | ||
178 | index XXXXXXX..XXXXXXX | ||
179 | --- /dev/null | ||
180 | +++ b/gdb-xml/arm-vfp-sysregs.xml | ||
181 | @@ -XXX,XX +XXX,XX @@ | ||
182 | +<?xml version="1.0"?> | ||
183 | +<!-- Copyright (C) 2021 Linaro Ltd. | ||
184 | + | ||
185 | + Copying and distribution of this file, with or without modification, | ||
186 | + are permitted in any medium without royalty provided the copyright | ||
187 | + notice and this notice are preserved. | ||
188 | + | ||
189 | + These are A/R profile VFP system registers. Debugger users probably | ||
190 | + don't really care about these, but because we used to (incorrectly) | ||
191 | + provide them to gdb in the org.gnu.gdb.arm.vfp XML we continue | ||
192 | + to do so via this separate XML. | ||
193 | + --> | ||
194 | +<!DOCTYPE feature SYSTEM "gdb-target.dtd"> | ||
195 | +<feature name="org.qemu.gdb.arm.vfp-sysregs"> | ||
196 | + <reg name="fpsid" bitsize="32" type="int" group="float"/> | ||
197 | + <reg name="fpexc" bitsize="32" type="int" group="float"/> | ||
198 | +</feature> | ||
199 | diff --git a/gdb-xml/arm-vfp.xml b/gdb-xml/arm-vfp.xml | ||
200 | index XXXXXXX..XXXXXXX 100644 | ||
201 | --- a/gdb-xml/arm-vfp.xml | ||
202 | +++ b/gdb-xml/arm-vfp.xml | ||
203 | @@ -XXX,XX +XXX,XX @@ | ||
204 | <reg name="d14" bitsize="64" type="float"/> | ||
205 | <reg name="d15" bitsize="64" type="float"/> | ||
206 | |||
207 | - <reg name="fpsid" bitsize="32" type="int" group="float"/> | ||
208 | <reg name="fpscr" bitsize="32" type="int" group="float"/> | ||
209 | - <reg name="fpexc" bitsize="32" type="int" group="float"/> | ||
210 | </feature> | ||
211 | diff --git a/gdb-xml/arm-vfp3.xml b/gdb-xml/arm-vfp3.xml | ||
212 | index XXXXXXX..XXXXXXX 100644 | ||
213 | --- a/gdb-xml/arm-vfp3.xml | ||
214 | +++ b/gdb-xml/arm-vfp3.xml | ||
215 | @@ -XXX,XX +XXX,XX @@ | ||
216 | <reg name="d30" bitsize="64" type="float"/> | ||
217 | <reg name="d31" bitsize="64" type="float"/> | ||
218 | |||
219 | - <reg name="fpsid" bitsize="32" type="int" group="float"/> | ||
220 | <reg name="fpscr" bitsize="32" type="int" group="float"/> | ||
221 | - <reg name="fpexc" bitsize="32" type="int" group="float"/> | ||
222 | </feature> | ||
142 | -- | 223 | -- |
143 | 2.20.1 | 224 | 2.20.1 |
144 | 225 | ||
145 | 226 | diff view generated by jsdifflib |
1 | Somewhere along theline we accidentally added a duplicate | 1 | The function scsi_bus_new() creates a new SCSI bus; callers can |
---|---|---|---|
2 | "using D16-D31 when they don't exist" check to do_vfm_dp() | 2 | either pass in a name argument to specify the name of the new bus, or |
3 | (probably an artifact of a patchseries rebase). Remove it. | 3 | they can pass in NULL to allow the bus to be given an automatically |
4 | generated unique name. Almost all callers want to use the | ||
5 | autogenerated name; the only exception is the virtio-scsi device. | ||
6 | |||
7 | Taking a name argument that should almost always be NULL is an | ||
8 | easy-to-misuse API design -- it encourages callers to think perhaps | ||
9 | they should pass in some standard name like "scsi" or "scsi-bus". We | ||
10 | don't do this anywhere for SCSI, but we do (incorrectly) do it for | ||
11 | other bus types such as i2c. | ||
12 | |||
13 | The function name also implies that it will return a newly allocated | ||
14 | object, when it in fact does in-place allocation. We more commonly | ||
15 | name such functions foo_init(), with foo_new() being the | ||
16 | allocate-and-return variant. | ||
17 | |||
18 | Replace all the scsi_bus_new() callsites with either: | ||
19 | * scsi_bus_init() for the usual case where the caller wants | ||
20 | an autogenerated bus name | ||
21 | * scsi_bus_init_named() for the rare case where the caller | ||
22 | needs to specify the bus name | ||
23 | |||
24 | and document that for the _named() version it's then the caller's | ||
25 | responsibility to think about uniqueness of bus names. | ||
4 | 26 | ||
5 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 27 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
6 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | 28 | Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com> |
7 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | 29 | Reviewed-by: Michael S. Tsirkin <mst@redhat.com> |
8 | Message-id: 20200430181003.21682-2-peter.maydell@linaro.org | 30 | Acked-by: Paolo Bonzini <pbonzini@redhat.com> |
31 | Message-id: 20210923121153.23754-2-peter.maydell@linaro.org | ||
9 | --- | 32 | --- |
10 | target/arm/translate-vfp.inc.c | 6 ------ | 33 | include/hw/scsi/scsi.h | 30 ++++++++++++++++++++++++++++-- |
11 | 1 file changed, 6 deletions(-) | 34 | hw/scsi/esp-pci.c | 2 +- |
12 | 35 | hw/scsi/esp.c | 2 +- | |
13 | diff --git a/target/arm/translate-vfp.inc.c b/target/arm/translate-vfp.inc.c | 36 | hw/scsi/lsi53c895a.c | 2 +- |
14 | index XXXXXXX..XXXXXXX 100644 | 37 | hw/scsi/megasas.c | 3 +-- |
15 | --- a/target/arm/translate-vfp.inc.c | 38 | hw/scsi/mptsas.c | 2 +- |
16 | +++ b/target/arm/translate-vfp.inc.c | 39 | hw/scsi/scsi-bus.c | 4 ++-- |
17 | @@ -XXX,XX +XXX,XX @@ static bool do_vfm_dp(DisasContext *s, arg_VFMA_dp *a, bool neg_n, bool neg_d) | 40 | hw/scsi/spapr_vscsi.c | 3 +-- |
18 | return false; | 41 | hw/scsi/virtio-scsi.c | 4 ++-- |
42 | hw/scsi/vmw_pvscsi.c | 3 +-- | ||
43 | hw/usb/dev-storage-bot.c | 3 +-- | ||
44 | hw/usb/dev-storage-classic.c | 4 ++-- | ||
45 | hw/usb/dev-uas.c | 3 +-- | ||
46 | 13 files changed, 43 insertions(+), 22 deletions(-) | ||
47 | |||
48 | diff --git a/include/hw/scsi/scsi.h b/include/hw/scsi/scsi.h | ||
49 | index XXXXXXX..XXXXXXX 100644 | ||
50 | --- a/include/hw/scsi/scsi.h | ||
51 | +++ b/include/hw/scsi/scsi.h | ||
52 | @@ -XXX,XX +XXX,XX @@ struct SCSIBus { | ||
53 | const SCSIBusInfo *info; | ||
54 | }; | ||
55 | |||
56 | -void scsi_bus_new(SCSIBus *bus, size_t bus_size, DeviceState *host, | ||
57 | - const SCSIBusInfo *info, const char *bus_name); | ||
58 | +/** | ||
59 | + * scsi_bus_init_named: Initialize a SCSI bus with the specified name | ||
60 | + * @bus: SCSIBus object to initialize | ||
61 | + * @bus_size: size of @bus object | ||
62 | + * @host: Device which owns the bus (generally the SCSI controller) | ||
63 | + * @info: structure defining callbacks etc for the controller | ||
64 | + * @bus_name: Name to use for this bus | ||
65 | + * | ||
66 | + * This in-place initializes @bus as a new SCSI bus with a name | ||
67 | + * provided by the caller. It is the caller's responsibility to make | ||
68 | + * sure that name does not clash with the name of any other bus in the | ||
69 | + * system. Unless you need the new bus to have a specific name, you | ||
70 | + * should use scsi_bus_new() instead. | ||
71 | + */ | ||
72 | +void scsi_bus_init_named(SCSIBus *bus, size_t bus_size, DeviceState *host, | ||
73 | + const SCSIBusInfo *info, const char *bus_name); | ||
74 | + | ||
75 | +/** | ||
76 | + * scsi_bus_init: Initialize a SCSI bus | ||
77 | + * | ||
78 | + * This in-place-initializes @bus as a new SCSI bus and gives it | ||
79 | + * an automatically generated unique name. | ||
80 | + */ | ||
81 | +static inline void scsi_bus_init(SCSIBus *bus, size_t bus_size, | ||
82 | + DeviceState *host, const SCSIBusInfo *info) | ||
83 | +{ | ||
84 | + scsi_bus_init_named(bus, bus_size, host, info, NULL); | ||
85 | +} | ||
86 | |||
87 | static inline SCSIBus *scsi_bus_from_device(SCSIDevice *d) | ||
88 | { | ||
89 | diff --git a/hw/scsi/esp-pci.c b/hw/scsi/esp-pci.c | ||
90 | index XXXXXXX..XXXXXXX 100644 | ||
91 | --- a/hw/scsi/esp-pci.c | ||
92 | +++ b/hw/scsi/esp-pci.c | ||
93 | @@ -XXX,XX +XXX,XX @@ static void esp_pci_scsi_realize(PCIDevice *dev, Error **errp) | ||
94 | pci_register_bar(dev, 0, PCI_BASE_ADDRESS_SPACE_IO, &pci->io); | ||
95 | s->irq = pci_allocate_irq(dev); | ||
96 | |||
97 | - scsi_bus_new(&s->bus, sizeof(s->bus), d, &esp_pci_scsi_info, NULL); | ||
98 | + scsi_bus_init(&s->bus, sizeof(s->bus), d, &esp_pci_scsi_info); | ||
99 | } | ||
100 | |||
101 | static void esp_pci_scsi_exit(PCIDevice *d) | ||
102 | diff --git a/hw/scsi/esp.c b/hw/scsi/esp.c | ||
103 | index XXXXXXX..XXXXXXX 100644 | ||
104 | --- a/hw/scsi/esp.c | ||
105 | +++ b/hw/scsi/esp.c | ||
106 | @@ -XXX,XX +XXX,XX @@ static void sysbus_esp_realize(DeviceState *dev, Error **errp) | ||
107 | |||
108 | qdev_init_gpio_in(dev, sysbus_esp_gpio_demux, 2); | ||
109 | |||
110 | - scsi_bus_new(&s->bus, sizeof(s->bus), dev, &esp_scsi_info, NULL); | ||
111 | + scsi_bus_init(&s->bus, sizeof(s->bus), dev, &esp_scsi_info); | ||
112 | } | ||
113 | |||
114 | static void sysbus_esp_hard_reset(DeviceState *dev) | ||
115 | diff --git a/hw/scsi/lsi53c895a.c b/hw/scsi/lsi53c895a.c | ||
116 | index XXXXXXX..XXXXXXX 100644 | ||
117 | --- a/hw/scsi/lsi53c895a.c | ||
118 | +++ b/hw/scsi/lsi53c895a.c | ||
119 | @@ -XXX,XX +XXX,XX @@ static void lsi_scsi_realize(PCIDevice *dev, Error **errp) | ||
120 | pci_register_bar(dev, 2, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->ram_io); | ||
121 | QTAILQ_INIT(&s->queue); | ||
122 | |||
123 | - scsi_bus_new(&s->bus, sizeof(s->bus), d, &lsi_scsi_info, NULL); | ||
124 | + scsi_bus_init(&s->bus, sizeof(s->bus), d, &lsi_scsi_info); | ||
125 | } | ||
126 | |||
127 | static void lsi_scsi_exit(PCIDevice *dev) | ||
128 | diff --git a/hw/scsi/megasas.c b/hw/scsi/megasas.c | ||
129 | index XXXXXXX..XXXXXXX 100644 | ||
130 | --- a/hw/scsi/megasas.c | ||
131 | +++ b/hw/scsi/megasas.c | ||
132 | @@ -XXX,XX +XXX,XX @@ static void megasas_scsi_realize(PCIDevice *dev, Error **errp) | ||
133 | s->frames[i].state = s; | ||
19 | } | 134 | } |
20 | 135 | ||
21 | - /* UNDEF accesses to D16-D31 if they don't exist. */ | 136 | - scsi_bus_new(&s->bus, sizeof(s->bus), DEVICE(dev), |
22 | - if (!dc_isar_feature(aa32_simd_r32, s) && | 137 | - &megasas_scsi_info, NULL); |
23 | - ((a->vd | a->vn | a->vm) & 0x10)) { | 138 | + scsi_bus_init(&s->bus, sizeof(s->bus), DEVICE(dev), &megasas_scsi_info); |
24 | - return false; | 139 | } |
25 | - } | 140 | |
26 | - | 141 | static Property megasas_properties_gen1[] = { |
27 | if (!vfp_access_check(s)) { | 142 | diff --git a/hw/scsi/mptsas.c b/hw/scsi/mptsas.c |
28 | return true; | 143 | index XXXXXXX..XXXXXXX 100644 |
144 | --- a/hw/scsi/mptsas.c | ||
145 | +++ b/hw/scsi/mptsas.c | ||
146 | @@ -XXX,XX +XXX,XX @@ static void mptsas_scsi_realize(PCIDevice *dev, Error **errp) | ||
147 | |||
148 | s->request_bh = qemu_bh_new(mptsas_fetch_requests, s); | ||
149 | |||
150 | - scsi_bus_new(&s->bus, sizeof(s->bus), &dev->qdev, &mptsas_scsi_info, NULL); | ||
151 | + scsi_bus_init(&s->bus, sizeof(s->bus), &dev->qdev, &mptsas_scsi_info); | ||
152 | } | ||
153 | |||
154 | static void mptsas_scsi_uninit(PCIDevice *dev) | ||
155 | diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c | ||
156 | index XXXXXXX..XXXXXXX 100644 | ||
157 | --- a/hw/scsi/scsi-bus.c | ||
158 | +++ b/hw/scsi/scsi-bus.c | ||
159 | @@ -XXX,XX +XXX,XX @@ void scsi_device_unit_attention_reported(SCSIDevice *s) | ||
160 | } | ||
161 | |||
162 | /* Create a scsi bus, and attach devices to it. */ | ||
163 | -void scsi_bus_new(SCSIBus *bus, size_t bus_size, DeviceState *host, | ||
164 | - const SCSIBusInfo *info, const char *bus_name) | ||
165 | +void scsi_bus_init_named(SCSIBus *bus, size_t bus_size, DeviceState *host, | ||
166 | + const SCSIBusInfo *info, const char *bus_name) | ||
167 | { | ||
168 | qbus_create_inplace(bus, bus_size, TYPE_SCSI_BUS, host, bus_name); | ||
169 | bus->busnr = next_scsi_bus++; | ||
170 | diff --git a/hw/scsi/spapr_vscsi.c b/hw/scsi/spapr_vscsi.c | ||
171 | index XXXXXXX..XXXXXXX 100644 | ||
172 | --- a/hw/scsi/spapr_vscsi.c | ||
173 | +++ b/hw/scsi/spapr_vscsi.c | ||
174 | @@ -XXX,XX +XXX,XX @@ static void spapr_vscsi_realize(SpaprVioDevice *dev, Error **errp) | ||
175 | |||
176 | dev->crq.SendFunc = vscsi_do_crq; | ||
177 | |||
178 | - scsi_bus_new(&s->bus, sizeof(s->bus), DEVICE(dev), | ||
179 | - &vscsi_scsi_info, NULL); | ||
180 | + scsi_bus_init(&s->bus, sizeof(s->bus), DEVICE(dev), &vscsi_scsi_info); | ||
181 | |||
182 | /* ibmvscsi SCSI bus does not allow hotplug. */ | ||
183 | qbus_set_hotplug_handler(BUS(&s->bus), NULL); | ||
184 | diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c | ||
185 | index XXXXXXX..XXXXXXX 100644 | ||
186 | --- a/hw/scsi/virtio-scsi.c | ||
187 | +++ b/hw/scsi/virtio-scsi.c | ||
188 | @@ -XXX,XX +XXX,XX @@ static void virtio_scsi_device_realize(DeviceState *dev, Error **errp) | ||
189 | return; | ||
29 | } | 190 | } |
191 | |||
192 | - scsi_bus_new(&s->bus, sizeof(s->bus), dev, | ||
193 | - &virtio_scsi_scsi_info, vdev->bus_name); | ||
194 | + scsi_bus_init_named(&s->bus, sizeof(s->bus), dev, | ||
195 | + &virtio_scsi_scsi_info, vdev->bus_name); | ||
196 | /* override default SCSI bus hotplug-handler, with virtio-scsi's one */ | ||
197 | qbus_set_hotplug_handler(BUS(&s->bus), OBJECT(dev)); | ||
198 | |||
199 | diff --git a/hw/scsi/vmw_pvscsi.c b/hw/scsi/vmw_pvscsi.c | ||
200 | index XXXXXXX..XXXXXXX 100644 | ||
201 | --- a/hw/scsi/vmw_pvscsi.c | ||
202 | +++ b/hw/scsi/vmw_pvscsi.c | ||
203 | @@ -XXX,XX +XXX,XX @@ pvscsi_realizefn(PCIDevice *pci_dev, Error **errp) | ||
204 | |||
205 | s->completion_worker = qemu_bh_new(pvscsi_process_completion_queue, s); | ||
206 | |||
207 | - scsi_bus_new(&s->bus, sizeof(s->bus), DEVICE(pci_dev), | ||
208 | - &pvscsi_scsi_info, NULL); | ||
209 | + scsi_bus_init(&s->bus, sizeof(s->bus), DEVICE(pci_dev), &pvscsi_scsi_info); | ||
210 | /* override default SCSI bus hotplug-handler, with pvscsi's one */ | ||
211 | qbus_set_hotplug_handler(BUS(&s->bus), OBJECT(s)); | ||
212 | pvscsi_reset_state(s); | ||
213 | diff --git a/hw/usb/dev-storage-bot.c b/hw/usb/dev-storage-bot.c | ||
214 | index XXXXXXX..XXXXXXX 100644 | ||
215 | --- a/hw/usb/dev-storage-bot.c | ||
216 | +++ b/hw/usb/dev-storage-bot.c | ||
217 | @@ -XXX,XX +XXX,XX @@ static void usb_msd_bot_realize(USBDevice *dev, Error **errp) | ||
218 | s->dev.auto_attach = 0; | ||
219 | } | ||
220 | |||
221 | - scsi_bus_new(&s->bus, sizeof(s->bus), DEVICE(dev), | ||
222 | - &usb_msd_scsi_info_bot, NULL); | ||
223 | + scsi_bus_init(&s->bus, sizeof(s->bus), DEVICE(dev), &usb_msd_scsi_info_bot); | ||
224 | usb_msd_handle_reset(dev); | ||
225 | } | ||
226 | |||
227 | diff --git a/hw/usb/dev-storage-classic.c b/hw/usb/dev-storage-classic.c | ||
228 | index XXXXXXX..XXXXXXX 100644 | ||
229 | --- a/hw/usb/dev-storage-classic.c | ||
230 | +++ b/hw/usb/dev-storage-classic.c | ||
231 | @@ -XXX,XX +XXX,XX @@ static void usb_msd_storage_realize(USBDevice *dev, Error **errp) | ||
232 | usb_desc_create_serial(dev); | ||
233 | usb_desc_init(dev); | ||
234 | dev->flags |= (1 << USB_DEV_FLAG_IS_SCSI_STORAGE); | ||
235 | - scsi_bus_new(&s->bus, sizeof(s->bus), DEVICE(dev), | ||
236 | - &usb_msd_scsi_info_storage, NULL); | ||
237 | + scsi_bus_init(&s->bus, sizeof(s->bus), DEVICE(dev), | ||
238 | + &usb_msd_scsi_info_storage); | ||
239 | scsi_dev = scsi_bus_legacy_add_drive(&s->bus, blk, 0, !!s->removable, | ||
240 | s->conf.bootindex, s->conf.share_rw, | ||
241 | s->conf.rerror, s->conf.werror, | ||
242 | diff --git a/hw/usb/dev-uas.c b/hw/usb/dev-uas.c | ||
243 | index XXXXXXX..XXXXXXX 100644 | ||
244 | --- a/hw/usb/dev-uas.c | ||
245 | +++ b/hw/usb/dev-uas.c | ||
246 | @@ -XXX,XX +XXX,XX @@ static void usb_uas_realize(USBDevice *dev, Error **errp) | ||
247 | uas->status_bh = qemu_bh_new(usb_uas_send_status_bh, uas); | ||
248 | |||
249 | dev->flags |= (1 << USB_DEV_FLAG_IS_SCSI_STORAGE); | ||
250 | - scsi_bus_new(&uas->bus, sizeof(uas->bus), DEVICE(dev), | ||
251 | - &usb_uas_scsi_info, NULL); | ||
252 | + scsi_bus_init(&uas->bus, sizeof(uas->bus), DEVICE(dev), &usb_uas_scsi_info); | ||
253 | } | ||
254 | |||
255 | static const VMStateDescription vmstate_usb_uas = { | ||
30 | -- | 256 | -- |
31 | 2.20.1 | 257 | 2.20.1 |
32 | 258 | ||
33 | 259 | diff view generated by jsdifflib |
1 | Convert the Neon "load/store single structure to one lane" insns to | 1 | Rename ipack_bus_new_inplace() to ipack_bus_init(), to bring it in to |
---|---|---|---|
2 | decodetree. | 2 | line with a "_init for in-place init, _new for allocate-and-return" |
3 | 3 | convention. Drop the 'name' argument, because the only caller does | |
4 | As this is the last set of insns in the neon load/store group, | 4 | not pass in a name. If a future caller does need to specify the bus |
5 | we can remove the whole disas_neon_ls_insn() function. | 5 | name, we should create an ipack_bus_init_named() function at that |
6 | point. | ||
6 | 7 | ||
7 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 8 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | 9 | Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com> |
9 | Message-id: 20200430181003.21682-14-peter.maydell@linaro.org | 10 | Reviewed-by: Michael S. Tsirkin <mst@redhat.com> |
11 | Message-id: 20210923121153.23754-3-peter.maydell@linaro.org | ||
10 | --- | 12 | --- |
11 | target/arm/neon-ls.decode | 11 +++ | 13 | include/hw/ipack/ipack.h | 8 ++++---- |
12 | target/arm/translate-neon.inc.c | 89 +++++++++++++++++++ | 14 | hw/ipack/ipack.c | 10 +++++----- |
13 | target/arm/translate.c | 147 -------------------------------- | 15 | hw/ipack/tpci200.c | 4 ++-- |
14 | 3 files changed, 100 insertions(+), 147 deletions(-) | 16 | 3 files changed, 11 insertions(+), 11 deletions(-) |
15 | 17 | ||
16 | diff --git a/target/arm/neon-ls.decode b/target/arm/neon-ls.decode | 18 | diff --git a/include/hw/ipack/ipack.h b/include/hw/ipack/ipack.h |
17 | index XXXXXXX..XXXXXXX 100644 | 19 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/target/arm/neon-ls.decode | 20 | --- a/include/hw/ipack/ipack.h |
19 | +++ b/target/arm/neon-ls.decode | 21 | +++ b/include/hw/ipack/ipack.h |
20 | @@ -XXX,XX +XXX,XX @@ VLDST_multiple 1111 0100 0 . l:1 0 rn:4 .... itype:4 size:2 align:2 rm:4 \ | 22 | @@ -XXX,XX +XXX,XX @@ extern const VMStateDescription vmstate_ipack_device; |
21 | 23 | VMSTATE_STRUCT(_field, _state, 1, vmstate_ipack_device, IPackDevice) | |
22 | VLD_all_lanes 1111 0100 1 . 1 0 rn:4 .... 11 n:2 size:2 t:1 a:1 rm:4 \ | 24 | |
23 | vd=%vd_dp | 25 | IPackDevice *ipack_device_find(IPackBus *bus, int32_t slot); |
24 | + | 26 | -void ipack_bus_new_inplace(IPackBus *bus, size_t bus_size, |
25 | +# Neon load/store single structure to one lane | 27 | - DeviceState *parent, |
26 | +%imm1_5_p1 5:1 !function=plus1 | 28 | - const char *name, uint8_t n_slots, |
27 | +%imm1_6_p1 6:1 !function=plus1 | 29 | - qemu_irq_handler handler); |
28 | + | 30 | +void ipack_bus_init(IPackBus *bus, size_t bus_size, |
29 | +VLDST_single 1111 0100 1 . l:1 0 rn:4 .... 00 n:2 reg_idx:3 align:1 rm:4 \ | 31 | + DeviceState *parent, |
30 | + vd=%vd_dp size=0 stride=1 | 32 | + uint8_t n_slots, |
31 | +VLDST_single 1111 0100 1 . l:1 0 rn:4 .... 01 n:2 reg_idx:2 align:2 rm:4 \ | 33 | + qemu_irq_handler handler); |
32 | + vd=%vd_dp size=1 stride=%imm1_5_p1 | 34 | |
33 | +VLDST_single 1111 0100 1 . l:1 0 rn:4 .... 10 n:2 reg_idx:1 align:3 rm:4 \ | 35 | #endif |
34 | + vd=%vd_dp size=2 stride=%imm1_6_p1 | 36 | diff --git a/hw/ipack/ipack.c b/hw/ipack/ipack.c |
35 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
36 | index XXXXXXX..XXXXXXX 100644 | 37 | index XXXXXXX..XXXXXXX 100644 |
37 | --- a/target/arm/translate-neon.inc.c | 38 | --- a/hw/ipack/ipack.c |
38 | +++ b/target/arm/translate-neon.inc.c | 39 | +++ b/hw/ipack/ipack.c |
39 | @@ -XXX,XX +XXX,XX @@ | 40 | @@ -XXX,XX +XXX,XX @@ IPackDevice *ipack_device_find(IPackBus *bus, int32_t slot) |
40 | * It might be possible to convert it to a standalone .c file eventually. | 41 | return NULL; |
41 | */ | ||
42 | |||
43 | +static inline int plus1(DisasContext *s, int x) | ||
44 | +{ | ||
45 | + return x + 1; | ||
46 | +} | ||
47 | + | ||
48 | /* Include the generated Neon decoder */ | ||
49 | #include "decode-neon-dp.inc.c" | ||
50 | #include "decode-neon-ls.inc.c" | ||
51 | @@ -XXX,XX +XXX,XX @@ static bool trans_VLD_all_lanes(DisasContext *s, arg_VLD_all_lanes *a) | ||
52 | |||
53 | return true; | ||
54 | } | 42 | } |
55 | + | 43 | |
56 | +static bool trans_VLDST_single(DisasContext *s, arg_VLDST_single *a) | 44 | -void ipack_bus_new_inplace(IPackBus *bus, size_t bus_size, |
57 | +{ | 45 | - DeviceState *parent, |
58 | + /* Neon load/store single structure to one lane */ | 46 | - const char *name, uint8_t n_slots, |
59 | + int reg; | 47 | - qemu_irq_handler handler) |
60 | + int nregs = a->n + 1; | 48 | +void ipack_bus_init(IPackBus *bus, size_t bus_size, |
61 | + int vd = a->vd; | 49 | + DeviceState *parent, |
62 | + TCGv_i32 addr, tmp; | 50 | + uint8_t n_slots, |
63 | + | 51 | + qemu_irq_handler handler) |
64 | + if (!arm_dc_feature(s, ARM_FEATURE_NEON)) { | 52 | { |
65 | + return false; | 53 | - qbus_create_inplace(bus, bus_size, TYPE_IPACK_BUS, parent, name); |
66 | + } | 54 | + qbus_create_inplace(bus, bus_size, TYPE_IPACK_BUS, parent, NULL); |
67 | + | 55 | bus->n_slots = n_slots; |
68 | + /* UNDEF accesses to D16-D31 if they don't exist */ | 56 | bus->set_irq = handler; |
69 | + if (!dc_isar_feature(aa32_simd_r32, s) && (a->vd & 0x10)) { | 57 | } |
70 | + return false; | 58 | diff --git a/hw/ipack/tpci200.c b/hw/ipack/tpci200.c |
71 | + } | ||
72 | + | ||
73 | + /* Catch the UNDEF cases. This is unavoidably a bit messy. */ | ||
74 | + switch (nregs) { | ||
75 | + case 1: | ||
76 | + if (((a->align & (1 << a->size)) != 0) || | ||
77 | + (a->size == 2 && ((a->align & 3) == 1 || (a->align & 3) == 2))) { | ||
78 | + return false; | ||
79 | + } | ||
80 | + break; | ||
81 | + case 3: | ||
82 | + if ((a->align & 1) != 0) { | ||
83 | + return false; | ||
84 | + } | ||
85 | + /* fall through */ | ||
86 | + case 2: | ||
87 | + if (a->size == 2 && (a->align & 2) != 0) { | ||
88 | + return false; | ||
89 | + } | ||
90 | + break; | ||
91 | + case 4: | ||
92 | + if ((a->size == 2) && ((a->align & 3) == 3)) { | ||
93 | + return false; | ||
94 | + } | ||
95 | + break; | ||
96 | + default: | ||
97 | + abort(); | ||
98 | + } | ||
99 | + if ((vd + a->stride * (nregs - 1)) > 31) { | ||
100 | + /* | ||
101 | + * Attempts to write off the end of the register file are | ||
102 | + * UNPREDICTABLE; we choose to UNDEF because otherwise we would | ||
103 | + * access off the end of the array that holds the register data. | ||
104 | + */ | ||
105 | + return false; | ||
106 | + } | ||
107 | + | ||
108 | + if (!vfp_access_check(s)) { | ||
109 | + return true; | ||
110 | + } | ||
111 | + | ||
112 | + tmp = tcg_temp_new_i32(); | ||
113 | + addr = tcg_temp_new_i32(); | ||
114 | + load_reg_var(s, addr, a->rn); | ||
115 | + /* | ||
116 | + * TODO: if we implemented alignment exceptions, we should check | ||
117 | + * addr against the alignment encoded in a->align here. | ||
118 | + */ | ||
119 | + for (reg = 0; reg < nregs; reg++) { | ||
120 | + if (a->l) { | ||
121 | + gen_aa32_ld_i32(s, tmp, addr, get_mem_index(s), | ||
122 | + s->be_data | a->size); | ||
123 | + neon_store_element(vd, a->reg_idx, a->size, tmp); | ||
124 | + } else { /* Store */ | ||
125 | + neon_load_element(tmp, vd, a->reg_idx, a->size); | ||
126 | + gen_aa32_st_i32(s, tmp, addr, get_mem_index(s), | ||
127 | + s->be_data | a->size); | ||
128 | + } | ||
129 | + vd += a->stride; | ||
130 | + tcg_gen_addi_i32(addr, addr, 1 << a->size); | ||
131 | + } | ||
132 | + tcg_temp_free_i32(addr); | ||
133 | + tcg_temp_free_i32(tmp); | ||
134 | + | ||
135 | + gen_neon_ldst_base_update(s, a->rm, a->rn, (1 << a->size) * nregs); | ||
136 | + | ||
137 | + return true; | ||
138 | +} | ||
139 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
140 | index XXXXXXX..XXXXXXX 100644 | 59 | index XXXXXXX..XXXXXXX 100644 |
141 | --- a/target/arm/translate.c | 60 | --- a/hw/ipack/tpci200.c |
142 | +++ b/target/arm/translate.c | 61 | +++ b/hw/ipack/tpci200.c |
143 | @@ -XXX,XX +XXX,XX @@ static void gen_neon_trn_u16(TCGv_i32 t0, TCGv_i32 t1) | 62 | @@ -XXX,XX +XXX,XX @@ static void tpci200_realize(PCIDevice *pci_dev, Error **errp) |
144 | tcg_temp_free_i32(rd); | 63 | pci_register_bar(&s->dev, 4, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->las2); |
64 | pci_register_bar(&s->dev, 5, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->las3); | ||
65 | |||
66 | - ipack_bus_new_inplace(&s->bus, sizeof(s->bus), DEVICE(pci_dev), NULL, | ||
67 | - N_MODULES, tpci200_set_irq); | ||
68 | + ipack_bus_init(&s->bus, sizeof(s->bus), DEVICE(pci_dev), | ||
69 | + N_MODULES, tpci200_set_irq); | ||
145 | } | 70 | } |
146 | 71 | ||
147 | - | 72 | static const VMStateDescription vmstate_tpci200 = { |
148 | -/* Translate a NEON load/store element instruction. Return nonzero if the | ||
149 | - instruction is invalid. */ | ||
150 | -static int disas_neon_ls_insn(DisasContext *s, uint32_t insn) | ||
151 | -{ | ||
152 | - int rd, rn, rm; | ||
153 | - int nregs; | ||
154 | - int stride; | ||
155 | - int size; | ||
156 | - int reg; | ||
157 | - int load; | ||
158 | - TCGv_i32 addr; | ||
159 | - TCGv_i32 tmp; | ||
160 | - | ||
161 | - if (!arm_dc_feature(s, ARM_FEATURE_NEON)) { | ||
162 | - return 1; | ||
163 | - } | ||
164 | - | ||
165 | - /* FIXME: this access check should not take precedence over UNDEF | ||
166 | - * for invalid encodings; we will generate incorrect syndrome information | ||
167 | - * for attempts to execute invalid vfp/neon encodings with FP disabled. | ||
168 | - */ | ||
169 | - if (s->fp_excp_el) { | ||
170 | - gen_exception_insn(s, s->pc_curr, EXCP_UDEF, | ||
171 | - syn_simd_access_trap(1, 0xe, false), s->fp_excp_el); | ||
172 | - return 0; | ||
173 | - } | ||
174 | - | ||
175 | - if (!s->vfp_enabled) | ||
176 | - return 1; | ||
177 | - VFP_DREG_D(rd, insn); | ||
178 | - rn = (insn >> 16) & 0xf; | ||
179 | - rm = insn & 0xf; | ||
180 | - load = (insn & (1 << 21)) != 0; | ||
181 | - if ((insn & (1 << 23)) == 0) { | ||
182 | - /* Load store all elements -- handled already by decodetree */ | ||
183 | - return 1; | ||
184 | - } else { | ||
185 | - size = (insn >> 10) & 3; | ||
186 | - if (size == 3) { | ||
187 | - /* Load single element to all lanes -- handled by decodetree */ | ||
188 | - return 1; | ||
189 | - } else { | ||
190 | - /* Single element. */ | ||
191 | - int idx = (insn >> 4) & 0xf; | ||
192 | - int reg_idx; | ||
193 | - switch (size) { | ||
194 | - case 0: | ||
195 | - reg_idx = (insn >> 5) & 7; | ||
196 | - stride = 1; | ||
197 | - break; | ||
198 | - case 1: | ||
199 | - reg_idx = (insn >> 6) & 3; | ||
200 | - stride = (insn & (1 << 5)) ? 2 : 1; | ||
201 | - break; | ||
202 | - case 2: | ||
203 | - reg_idx = (insn >> 7) & 1; | ||
204 | - stride = (insn & (1 << 6)) ? 2 : 1; | ||
205 | - break; | ||
206 | - default: | ||
207 | - abort(); | ||
208 | - } | ||
209 | - nregs = ((insn >> 8) & 3) + 1; | ||
210 | - /* Catch the UNDEF cases. This is unavoidably a bit messy. */ | ||
211 | - switch (nregs) { | ||
212 | - case 1: | ||
213 | - if (((idx & (1 << size)) != 0) || | ||
214 | - (size == 2 && ((idx & 3) == 1 || (idx & 3) == 2))) { | ||
215 | - return 1; | ||
216 | - } | ||
217 | - break; | ||
218 | - case 3: | ||
219 | - if ((idx & 1) != 0) { | ||
220 | - return 1; | ||
221 | - } | ||
222 | - /* fall through */ | ||
223 | - case 2: | ||
224 | - if (size == 2 && (idx & 2) != 0) { | ||
225 | - return 1; | ||
226 | - } | ||
227 | - break; | ||
228 | - case 4: | ||
229 | - if ((size == 2) && ((idx & 3) == 3)) { | ||
230 | - return 1; | ||
231 | - } | ||
232 | - break; | ||
233 | - default: | ||
234 | - abort(); | ||
235 | - } | ||
236 | - if ((rd + stride * (nregs - 1)) > 31) { | ||
237 | - /* Attempts to write off the end of the register file | ||
238 | - * are UNPREDICTABLE; we choose to UNDEF because otherwise | ||
239 | - * the neon_load_reg() would write off the end of the array. | ||
240 | - */ | ||
241 | - return 1; | ||
242 | - } | ||
243 | - tmp = tcg_temp_new_i32(); | ||
244 | - addr = tcg_temp_new_i32(); | ||
245 | - load_reg_var(s, addr, rn); | ||
246 | - for (reg = 0; reg < nregs; reg++) { | ||
247 | - if (load) { | ||
248 | - gen_aa32_ld_i32(s, tmp, addr, get_mem_index(s), | ||
249 | - s->be_data | size); | ||
250 | - neon_store_element(rd, reg_idx, size, tmp); | ||
251 | - } else { /* Store */ | ||
252 | - neon_load_element(tmp, rd, reg_idx, size); | ||
253 | - gen_aa32_st_i32(s, tmp, addr, get_mem_index(s), | ||
254 | - s->be_data | size); | ||
255 | - } | ||
256 | - rd += stride; | ||
257 | - tcg_gen_addi_i32(addr, addr, 1 << size); | ||
258 | - } | ||
259 | - tcg_temp_free_i32(addr); | ||
260 | - tcg_temp_free_i32(tmp); | ||
261 | - stride = nregs * (1 << size); | ||
262 | - } | ||
263 | - } | ||
264 | - if (rm != 15) { | ||
265 | - TCGv_i32 base; | ||
266 | - | ||
267 | - base = load_reg(s, rn); | ||
268 | - if (rm == 13) { | ||
269 | - tcg_gen_addi_i32(base, base, stride); | ||
270 | - } else { | ||
271 | - TCGv_i32 index; | ||
272 | - index = load_reg(s, rm); | ||
273 | - tcg_gen_add_i32(base, base, index); | ||
274 | - tcg_temp_free_i32(index); | ||
275 | - } | ||
276 | - store_reg(s, rn, base); | ||
277 | - } | ||
278 | - return 0; | ||
279 | -} | ||
280 | - | ||
281 | static inline void gen_neon_narrow(int size, TCGv_i32 dest, TCGv_i64 src) | ||
282 | { | ||
283 | switch (size) { | ||
284 | @@ -XXX,XX +XXX,XX @@ static void disas_arm_insn(DisasContext *s, unsigned int insn) | ||
285 | } | ||
286 | return; | ||
287 | } | ||
288 | - if ((insn & 0x0f100000) == 0x04000000) { | ||
289 | - /* NEON load/store. */ | ||
290 | - if (disas_neon_ls_insn(s, insn)) { | ||
291 | - goto illegal_op; | ||
292 | - } | ||
293 | - return; | ||
294 | - } | ||
295 | if ((insn & 0x0e000f00) == 0x0c000100) { | ||
296 | if (arm_dc_feature(s, ARM_FEATURE_IWMMXT)) { | ||
297 | /* iWMMXt register transfer. */ | ||
298 | @@ -XXX,XX +XXX,XX @@ static void disas_thumb2_insn(DisasContext *s, uint32_t insn) | ||
299 | } | ||
300 | break; | ||
301 | case 12: | ||
302 | - if ((insn & 0x01100000) == 0x01000000) { | ||
303 | - if (disas_neon_ls_insn(s, insn)) { | ||
304 | - goto illegal_op; | ||
305 | - } | ||
306 | - break; | ||
307 | - } | ||
308 | goto illegal_op; | ||
309 | default: | ||
310 | illegal_op: | ||
311 | -- | 73 | -- |
312 | 2.20.1 | 74 | 2.20.1 |
313 | 75 | ||
314 | 76 | diff view generated by jsdifflib |
1 | Convert the VFM[AS]L (scalar) insns in the 2reg-scalar-ext group | 1 | Rename the pci_root_bus_new_inplace() function to |
---|---|---|---|
2 | to decodetree. These are the last ones in the group so we can remove | 2 | pci_root_bus_init(); this brings the bus type in to line with a |
3 | all the legacy decode for the group. | 3 | "_init for in-place init, _new for allocate-and-return" convention. |
4 | 4 | To do this we need to rename the implementation-internal function | |
5 | Note that in disas_thumb2_insn() the parts of this encoding space | 5 | that was using the pci_root_bus_init() name to |
6 | where the decodetree decoder returns false will correctly be directed | 6 | pci_root_bus_internal_init(). |
7 | to illegal_op by the "(insn & (1 << 28))" check so they won't fall | ||
8 | into disas_coproc_insn() by mistake. | ||
9 | 7 | ||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 8 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | 9 | Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com> |
12 | Message-id: 20200430181003.21682-11-peter.maydell@linaro.org | 10 | Reviewed-by: Michael S. Tsirkin <mst@redhat.com> |
11 | Message-id: 20210923121153.23754-4-peter.maydell@linaro.org | ||
13 | --- | 12 | --- |
14 | target/arm/neon-shared.decode | 7 +++ | 13 | include/hw/pci/pci.h | 10 +++++----- |
15 | target/arm/translate-neon.inc.c | 32 ++++++++++ | 14 | hw/pci-host/raven.c | 4 ++-- |
16 | target/arm/translate.c | 107 +------------------------------- | 15 | hw/pci-host/versatile.c | 6 +++--- |
17 | 3 files changed, 40 insertions(+), 106 deletions(-) | 16 | hw/pci/pci.c | 26 +++++++++++++------------- |
17 | 4 files changed, 23 insertions(+), 23 deletions(-) | ||
18 | 18 | ||
19 | diff --git a/target/arm/neon-shared.decode b/target/arm/neon-shared.decode | 19 | diff --git a/include/hw/pci/pci.h b/include/hw/pci/pci.h |
20 | index XXXXXXX..XXXXXXX 100644 | 20 | index XXXXXXX..XXXXXXX 100644 |
21 | --- a/target/arm/neon-shared.decode | 21 | --- a/include/hw/pci/pci.h |
22 | +++ b/target/arm/neon-shared.decode | 22 | +++ b/include/hw/pci/pci.h |
23 | @@ -XXX,XX +XXX,XX @@ VCMLA_scalar 1111 1110 1 . rot:2 .... .... 1000 . q:1 . 0 .... \ | 23 | @@ -XXX,XX +XXX,XX @@ OBJECT_DECLARE_TYPE(PCIBus, PCIBusClass, PCI_BUS) |
24 | 24 | ||
25 | VDOT_scalar 1111 1110 0 . 10 .... .... 1101 . q:1 index:1 u:1 rm:4 \ | 25 | bool pci_bus_is_express(PCIBus *bus); |
26 | vm=%vm_dp vn=%vn_dp vd=%vd_dp | 26 | |
27 | + | 27 | -void pci_root_bus_new_inplace(PCIBus *bus, size_t bus_size, DeviceState *parent, |
28 | +%vfml_scalar_q0_rm 0:3 5:1 | 28 | - const char *name, |
29 | +%vfml_scalar_q1_index 5:1 3:1 | 29 | - MemoryRegion *address_space_mem, |
30 | +VFML_scalar 1111 1110 0 . 0 s:1 .... .... 1000 . 0 . 1 index:1 ... \ | 30 | - MemoryRegion *address_space_io, |
31 | + rm=%vfml_scalar_q0_rm vn=%vn_sp vd=%vd_dp q=0 | 31 | - uint8_t devfn_min, const char *typename); |
32 | +VFML_scalar 1111 1110 0 . 0 s:1 .... .... 1000 . 1 . 1 . rm:3 \ | 32 | +void pci_root_bus_init(PCIBus *bus, size_t bus_size, DeviceState *parent, |
33 | + index=%vfml_scalar_q1_index vn=%vn_dp vd=%vd_dp q=1 | 33 | + const char *name, |
34 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | 34 | + MemoryRegion *address_space_mem, |
35 | + MemoryRegion *address_space_io, | ||
36 | + uint8_t devfn_min, const char *typename); | ||
37 | PCIBus *pci_root_bus_new(DeviceState *parent, const char *name, | ||
38 | MemoryRegion *address_space_mem, | ||
39 | MemoryRegion *address_space_io, | ||
40 | diff --git a/hw/pci-host/raven.c b/hw/pci-host/raven.c | ||
35 | index XXXXXXX..XXXXXXX 100644 | 41 | index XXXXXXX..XXXXXXX 100644 |
36 | --- a/target/arm/translate-neon.inc.c | 42 | --- a/hw/pci-host/raven.c |
37 | +++ b/target/arm/translate-neon.inc.c | 43 | +++ b/hw/pci-host/raven.c |
38 | @@ -XXX,XX +XXX,XX @@ static bool trans_VDOT_scalar(DisasContext *s, arg_VDOT_scalar *a) | 44 | @@ -XXX,XX +XXX,XX @@ static void raven_pcihost_initfn(Object *obj) |
39 | tcg_temp_free_ptr(fpst); | 45 | memory_region_add_subregion_overlap(address_space_mem, PCI_IO_BASE_ADDR, |
40 | return true; | 46 | &s->pci_io_non_contiguous, 1); |
47 | memory_region_add_subregion(address_space_mem, 0xc0000000, &s->pci_memory); | ||
48 | - pci_root_bus_new_inplace(&s->pci_bus, sizeof(s->pci_bus), DEVICE(obj), NULL, | ||
49 | - &s->pci_memory, &s->pci_io, 0, TYPE_PCI_BUS); | ||
50 | + pci_root_bus_init(&s->pci_bus, sizeof(s->pci_bus), DEVICE(obj), NULL, | ||
51 | + &s->pci_memory, &s->pci_io, 0, TYPE_PCI_BUS); | ||
52 | |||
53 | /* Bus master address space */ | ||
54 | memory_region_init(&s->bm, obj, "bm-raven", 4 * GiB); | ||
55 | diff --git a/hw/pci-host/versatile.c b/hw/pci-host/versatile.c | ||
56 | index XXXXXXX..XXXXXXX 100644 | ||
57 | --- a/hw/pci-host/versatile.c | ||
58 | +++ b/hw/pci-host/versatile.c | ||
59 | @@ -XXX,XX +XXX,XX @@ static void pci_vpb_realize(DeviceState *dev, Error **errp) | ||
60 | memory_region_init(&s->pci_io_space, OBJECT(s), "pci_io", 4 * GiB); | ||
61 | memory_region_init(&s->pci_mem_space, OBJECT(s), "pci_mem", 4 * GiB); | ||
62 | |||
63 | - pci_root_bus_new_inplace(&s->pci_bus, sizeof(s->pci_bus), dev, "pci", | ||
64 | - &s->pci_mem_space, &s->pci_io_space, | ||
65 | - PCI_DEVFN(11, 0), TYPE_PCI_BUS); | ||
66 | + pci_root_bus_init(&s->pci_bus, sizeof(s->pci_bus), dev, "pci", | ||
67 | + &s->pci_mem_space, &s->pci_io_space, | ||
68 | + PCI_DEVFN(11, 0), TYPE_PCI_BUS); | ||
69 | h->bus = &s->pci_bus; | ||
70 | |||
71 | object_initialize(&s->pci_dev, sizeof(s->pci_dev), TYPE_VERSATILE_PCI_HOST); | ||
72 | diff --git a/hw/pci/pci.c b/hw/pci/pci.c | ||
73 | index XXXXXXX..XXXXXXX 100644 | ||
74 | --- a/hw/pci/pci.c | ||
75 | +++ b/hw/pci/pci.c | ||
76 | @@ -XXX,XX +XXX,XX @@ bool pci_bus_bypass_iommu(PCIBus *bus) | ||
77 | return host_bridge->bypass_iommu; | ||
41 | } | 78 | } |
42 | + | 79 | |
43 | +static bool trans_VFML_scalar(DisasContext *s, arg_VFML_scalar *a) | 80 | -static void pci_root_bus_init(PCIBus *bus, DeviceState *parent, |
44 | +{ | 81 | - MemoryRegion *address_space_mem, |
45 | + int opr_sz; | 82 | - MemoryRegion *address_space_io, |
46 | + | 83 | - uint8_t devfn_min) |
47 | + if (!dc_isar_feature(aa32_fhm, s)) { | 84 | +static void pci_root_bus_internal_init(PCIBus *bus, DeviceState *parent, |
48 | + return false; | 85 | + MemoryRegion *address_space_mem, |
49 | + } | 86 | + MemoryRegion *address_space_io, |
50 | + | 87 | + uint8_t devfn_min) |
51 | + /* UNDEF accesses to D16-D31 if they don't exist. */ | 88 | { |
52 | + if (!dc_isar_feature(aa32_simd_r32, s) && | 89 | assert(PCI_FUNC(devfn_min) == 0); |
53 | + ((a->vd & 0x10) || (a->q && (a->vn & 0x10)))) { | 90 | bus->devfn_min = devfn_min; |
54 | + return false; | 91 | @@ -XXX,XX +XXX,XX @@ bool pci_bus_is_express(PCIBus *bus) |
55 | + } | 92 | return object_dynamic_cast(OBJECT(bus), TYPE_PCIE_BUS); |
56 | + | ||
57 | + if (a->vd & a->q) { | ||
58 | + return false; | ||
59 | + } | ||
60 | + | ||
61 | + if (!vfp_access_check(s)) { | ||
62 | + return true; | ||
63 | + } | ||
64 | + | ||
65 | + opr_sz = (1 + a->q) * 8; | ||
66 | + tcg_gen_gvec_3_ptr(vfp_reg_offset(1, a->vd), | ||
67 | + vfp_reg_offset(a->q, a->vn), | ||
68 | + vfp_reg_offset(a->q, a->rm), | ||
69 | + cpu_env, opr_sz, opr_sz, | ||
70 | + (a->index << 2) | a->s, /* is_2 == 0 */ | ||
71 | + gen_helper_gvec_fmlal_idx_a32); | ||
72 | + return true; | ||
73 | +} | ||
74 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
75 | index XXXXXXX..XXXXXXX 100644 | ||
76 | --- a/target/arm/translate.c | ||
77 | +++ b/target/arm/translate.c | ||
78 | @@ -XXX,XX +XXX,XX @@ static int disas_dsp_insn(DisasContext *s, uint32_t insn) | ||
79 | } | 93 | } |
80 | 94 | ||
81 | #define VFP_REG_SHR(x, n) (((n) > 0) ? (x) >> (n) : (x) << -(n)) | 95 | -void pci_root_bus_new_inplace(PCIBus *bus, size_t bus_size, DeviceState *parent, |
82 | -#define VFP_SREG(insn, bigbit, smallbit) \ | 96 | - const char *name, |
83 | - ((VFP_REG_SHR(insn, bigbit - 1) & 0x1e) | (((insn) >> (smallbit)) & 1)) | 97 | - MemoryRegion *address_space_mem, |
84 | #define VFP_DREG(reg, insn, bigbit, smallbit) do { \ | 98 | - MemoryRegion *address_space_io, |
85 | if (dc_isar_feature(aa32_simd_r32, s)) { \ | 99 | - uint8_t devfn_min, const char *typename) |
86 | reg = (((insn) >> (bigbit)) & 0x0f) \ | 100 | +void pci_root_bus_init(PCIBus *bus, size_t bus_size, DeviceState *parent, |
87 | @@ -XXX,XX +XXX,XX @@ static int disas_dsp_insn(DisasContext *s, uint32_t insn) | 101 | + const char *name, |
88 | reg = ((insn) >> (bigbit)) & 0x0f; \ | 102 | + MemoryRegion *address_space_mem, |
89 | }} while (0) | 103 | + MemoryRegion *address_space_io, |
90 | 104 | + uint8_t devfn_min, const char *typename) | |
91 | -#define VFP_SREG_D(insn) VFP_SREG(insn, 12, 22) | 105 | { |
92 | #define VFP_DREG_D(reg, insn) VFP_DREG(reg, insn, 12, 22) | 106 | qbus_create_inplace(bus, bus_size, typename, parent, name); |
93 | -#define VFP_SREG_N(insn) VFP_SREG(insn, 16, 7) | 107 | - pci_root_bus_init(bus, parent, address_space_mem, address_space_io, |
94 | #define VFP_DREG_N(reg, insn) VFP_DREG(reg, insn, 16, 7) | 108 | - devfn_min); |
95 | -#define VFP_SREG_M(insn) VFP_SREG(insn, 0, 5) | 109 | + pci_root_bus_internal_init(bus, parent, address_space_mem, |
96 | #define VFP_DREG_M(reg, insn) VFP_DREG(reg, insn, 0, 5) | 110 | + address_space_io, devfn_min); |
97 | |||
98 | static void gen_neon_dup_low16(TCGv_i32 var) | ||
99 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
100 | return 0; | ||
101 | } | 111 | } |
102 | 112 | ||
103 | -/* Advanced SIMD two registers and a scalar extension. | 113 | PCIBus *pci_root_bus_new(DeviceState *parent, const char *name, |
104 | - * 31 24 23 22 20 16 12 11 10 9 8 3 0 | 114 | @@ -XXX,XX +XXX,XX @@ PCIBus *pci_root_bus_new(DeviceState *parent, const char *name, |
105 | - * +-----------------+----+---+----+----+----+---+----+---+----+---------+----+ | 115 | PCIBus *bus; |
106 | - * | 1 1 1 1 1 1 1 0 | o1 | D | o2 | Vn | Vd | 1 | o3 | 0 | o4 | N Q M U | Vm | | 116 | |
107 | - * +-----------------+----+---+----+----+----+---+----+---+----+---------+----+ | 117 | bus = PCI_BUS(qbus_create(typename, parent, name)); |
108 | - * | 118 | - pci_root_bus_init(bus, parent, address_space_mem, address_space_io, |
109 | - */ | 119 | - devfn_min); |
110 | - | 120 | + pci_root_bus_internal_init(bus, parent, address_space_mem, |
111 | -static int disas_neon_insn_2reg_scalar_ext(DisasContext *s, uint32_t insn) | 121 | + address_space_io, devfn_min); |
112 | -{ | 122 | return bus; |
113 | - gen_helper_gvec_3 *fn_gvec = NULL; | 123 | } |
114 | - gen_helper_gvec_3_ptr *fn_gvec_ptr = NULL; | 124 | |
115 | - int rd, rn, rm, opr_sz, data; | ||
116 | - int off_rn, off_rm; | ||
117 | - bool is_long = false, q = extract32(insn, 6, 1); | ||
118 | - bool ptr_is_env = false; | ||
119 | - | ||
120 | - if ((insn & 0xffa00f10) == 0xfe000810) { | ||
121 | - /* VFM[AS]L -- 1111 1110 0.0S .... .... 1000 .Q.1 .... */ | ||
122 | - int is_s = extract32(insn, 20, 1); | ||
123 | - int vm20 = extract32(insn, 0, 3); | ||
124 | - int vm3 = extract32(insn, 3, 1); | ||
125 | - int m = extract32(insn, 5, 1); | ||
126 | - int index; | ||
127 | - | ||
128 | - if (!dc_isar_feature(aa32_fhm, s)) { | ||
129 | - return 1; | ||
130 | - } | ||
131 | - if (q) { | ||
132 | - rm = vm20; | ||
133 | - index = m * 2 + vm3; | ||
134 | - } else { | ||
135 | - rm = vm20 * 2 + m; | ||
136 | - index = vm3; | ||
137 | - } | ||
138 | - is_long = true; | ||
139 | - data = (index << 2) | is_s; /* is_2 == 0 */ | ||
140 | - fn_gvec_ptr = gen_helper_gvec_fmlal_idx_a32; | ||
141 | - ptr_is_env = true; | ||
142 | - } else { | ||
143 | - return 1; | ||
144 | - } | ||
145 | - | ||
146 | - VFP_DREG_D(rd, insn); | ||
147 | - if (rd & q) { | ||
148 | - return 1; | ||
149 | - } | ||
150 | - if (q || !is_long) { | ||
151 | - VFP_DREG_N(rn, insn); | ||
152 | - if (rn & q & !is_long) { | ||
153 | - return 1; | ||
154 | - } | ||
155 | - off_rn = vfp_reg_offset(1, rn); | ||
156 | - off_rm = vfp_reg_offset(1, rm); | ||
157 | - } else { | ||
158 | - rn = VFP_SREG_N(insn); | ||
159 | - off_rn = vfp_reg_offset(0, rn); | ||
160 | - off_rm = vfp_reg_offset(0, rm); | ||
161 | - } | ||
162 | - if (s->fp_excp_el) { | ||
163 | - gen_exception_insn(s, s->pc_curr, EXCP_UDEF, | ||
164 | - syn_simd_access_trap(1, 0xe, false), s->fp_excp_el); | ||
165 | - return 0; | ||
166 | - } | ||
167 | - if (!s->vfp_enabled) { | ||
168 | - return 1; | ||
169 | - } | ||
170 | - | ||
171 | - opr_sz = (1 + q) * 8; | ||
172 | - if (fn_gvec_ptr) { | ||
173 | - TCGv_ptr ptr; | ||
174 | - if (ptr_is_env) { | ||
175 | - ptr = cpu_env; | ||
176 | - } else { | ||
177 | - ptr = get_fpstatus_ptr(1); | ||
178 | - } | ||
179 | - tcg_gen_gvec_3_ptr(vfp_reg_offset(1, rd), off_rn, off_rm, ptr, | ||
180 | - opr_sz, opr_sz, data, fn_gvec_ptr); | ||
181 | - if (!ptr_is_env) { | ||
182 | - tcg_temp_free_ptr(ptr); | ||
183 | - } | ||
184 | - } else { | ||
185 | - tcg_gen_gvec_3_ool(vfp_reg_offset(1, rd), off_rn, off_rm, | ||
186 | - opr_sz, opr_sz, data, fn_gvec); | ||
187 | - } | ||
188 | - return 0; | ||
189 | -} | ||
190 | - | ||
191 | static int disas_coproc_insn(DisasContext *s, uint32_t insn) | ||
192 | { | ||
193 | int cpnum, is64, crn, crm, opc1, opc2, isread, rt, rt2; | ||
194 | @@ -XXX,XX +XXX,XX @@ static void disas_arm_insn(DisasContext *s, unsigned int insn) | ||
195 | } | ||
196 | } | ||
197 | } | ||
198 | - } else if ((insn & 0x0f000a00) == 0x0e000800 | ||
199 | - && arm_dc_feature(s, ARM_FEATURE_V8)) { | ||
200 | - if (disas_neon_insn_2reg_scalar_ext(s, insn)) { | ||
201 | - goto illegal_op; | ||
202 | - } | ||
203 | - return; | ||
204 | } | ||
205 | goto illegal_op; | ||
206 | } | ||
207 | @@ -XXX,XX +XXX,XX @@ static void disas_thumb2_insn(DisasContext *s, uint32_t insn) | ||
208 | } | ||
209 | break; | ||
210 | } | ||
211 | - if ((insn & 0xff000a00) == 0xfe000800 | ||
212 | - && arm_dc_feature(s, ARM_FEATURE_V8)) { | ||
213 | - /* The Thumb2 and ARM encodings are identical. */ | ||
214 | - if (disas_neon_insn_2reg_scalar_ext(s, insn)) { | ||
215 | - goto illegal_op; | ||
216 | - } | ||
217 | - } else if (((insn >> 24) & 3) == 3) { | ||
218 | + if (((insn >> 24) & 3) == 3) { | ||
219 | /* Translate into the equivalent ARM encoding. */ | ||
220 | insn = (insn & 0xe2ffffff) | ((insn & (1 << 28)) >> 4) | (1 << 28); | ||
221 | if (disas_neon_data_insn(s, insn)) { | ||
222 | -- | 125 | -- |
223 | 2.20.1 | 126 | 2.20.1 |
224 | 127 | ||
225 | 128 | diff view generated by jsdifflib |
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | 1 | Rename qbus_create_inplace() to qbus_init(); this is more in line |
---|---|---|---|
2 | with our usual naming convention for functions that in-place | ||
3 | initialize objects. | ||
2 | 4 | ||
3 | Embed the APUs into the SoC type. | 5 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
6 | Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com> | ||
7 | Reviewed-by: Michael S. Tsirkin <mst@redhat.com> | ||
8 | Message-id: 20210923121153.23754-5-peter.maydell@linaro.org | ||
9 | --- | ||
10 | include/hw/qdev-core.h | 4 ++-- | ||
11 | hw/audio/intel-hda.c | 2 +- | ||
12 | hw/block/fdc.c | 2 +- | ||
13 | hw/block/swim.c | 3 +-- | ||
14 | hw/char/virtio-serial-bus.c | 4 ++-- | ||
15 | hw/core/bus.c | 11 ++++++----- | ||
16 | hw/core/sysbus.c | 10 ++++++---- | ||
17 | hw/gpio/bcm2835_gpio.c | 3 +-- | ||
18 | hw/ide/qdev.c | 2 +- | ||
19 | hw/ipack/ipack.c | 2 +- | ||
20 | hw/misc/mac_via.c | 4 ++-- | ||
21 | hw/misc/macio/cuda.c | 4 ++-- | ||
22 | hw/misc/macio/macio.c | 4 ++-- | ||
23 | hw/misc/macio/pmu.c | 4 ++-- | ||
24 | hw/nubus/nubus-bridge.c | 2 +- | ||
25 | hw/nvme/ctrl.c | 4 ++-- | ||
26 | hw/nvme/subsys.c | 3 +-- | ||
27 | hw/pci/pci.c | 2 +- | ||
28 | hw/pci/pci_bridge.c | 4 ++-- | ||
29 | hw/s390x/event-facility.c | 4 ++-- | ||
30 | hw/s390x/virtio-ccw.c | 3 +-- | ||
31 | hw/scsi/scsi-bus.c | 2 +- | ||
32 | hw/sd/allwinner-sdhost.c | 4 ++-- | ||
33 | hw/sd/bcm2835_sdhost.c | 4 ++-- | ||
34 | hw/sd/pl181.c | 3 +-- | ||
35 | hw/sd/pxa2xx_mmci.c | 4 ++-- | ||
36 | hw/sd/sdhci.c | 3 +-- | ||
37 | hw/sd/ssi-sd.c | 3 +-- | ||
38 | hw/usb/bus.c | 2 +- | ||
39 | hw/usb/dev-smartcard-reader.c | 3 +-- | ||
40 | hw/virtio/virtio-mmio.c | 3 +-- | ||
41 | hw/virtio/virtio-pci.c | 3 +-- | ||
42 | 32 files changed, 54 insertions(+), 61 deletions(-) | ||
4 | 43 | ||
5 | Suggested-by: Peter Maydell <peter.maydell@linaro.org> | 44 | diff --git a/include/hw/qdev-core.h b/include/hw/qdev-core.h |
6 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 45 | index XXXXXXX..XXXXXXX 100644 |
7 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | 46 | --- a/include/hw/qdev-core.h |
8 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | 47 | +++ b/include/hw/qdev-core.h |
9 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | 48 | @@ -XXX,XX +XXX,XX @@ DeviceState *qdev_find_recursive(BusState *bus, const char *id); |
10 | Message-id: 20200427181649.26851-8-edgar.iglesias@gmail.com | 49 | typedef int (qbus_walkerfn)(BusState *bus, void *opaque); |
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 50 | typedef int (qdev_walkerfn)(DeviceState *dev, void *opaque); |
12 | --- | 51 | |
13 | include/hw/arm/xlnx-versal.h | 2 +- | 52 | -void qbus_create_inplace(void *bus, size_t size, const char *typename, |
14 | hw/arm/xlnx-versal-virt.c | 4 ++-- | 53 | - DeviceState *parent, const char *name); |
15 | hw/arm/xlnx-versal.c | 19 +++++-------------- | 54 | +void qbus_init(void *bus, size_t size, const char *typename, |
16 | 3 files changed, 8 insertions(+), 17 deletions(-) | 55 | + DeviceState *parent, const char *name); |
17 | 56 | BusState *qbus_create(const char *typename, DeviceState *parent, const char *name); | |
18 | diff --git a/include/hw/arm/xlnx-versal.h b/include/hw/arm/xlnx-versal.h | 57 | bool qbus_realize(BusState *bus, Error **errp); |
19 | index XXXXXXX..XXXXXXX 100644 | 58 | void qbus_unrealize(BusState *bus); |
20 | --- a/include/hw/arm/xlnx-versal.h | 59 | diff --git a/hw/audio/intel-hda.c b/hw/audio/intel-hda.c |
21 | +++ b/include/hw/arm/xlnx-versal.h | 60 | index XXXXXXX..XXXXXXX 100644 |
22 | @@ -XXX,XX +XXX,XX @@ typedef struct Versal { | 61 | --- a/hw/audio/intel-hda.c |
23 | struct { | 62 | +++ b/hw/audio/intel-hda.c |
24 | struct { | 63 | @@ -XXX,XX +XXX,XX @@ void hda_codec_bus_init(DeviceState *dev, HDACodecBus *bus, size_t bus_size, |
25 | MemoryRegion mr; | 64 | hda_codec_response_func response, |
26 | - ARMCPU *cpu[XLNX_VERSAL_NR_ACPUS]; | 65 | hda_codec_xfer_func xfer) |
27 | + ARMCPU cpu[XLNX_VERSAL_NR_ACPUS]; | 66 | { |
28 | GICv3State gic; | 67 | - qbus_create_inplace(bus, bus_size, TYPE_HDA_BUS, dev, NULL); |
29 | } apu; | 68 | + qbus_init(bus, bus_size, TYPE_HDA_BUS, dev, NULL); |
30 | } fpd; | 69 | bus->response = response; |
31 | diff --git a/hw/arm/xlnx-versal-virt.c b/hw/arm/xlnx-versal-virt.c | 70 | bus->xfer = xfer; |
32 | index XXXXXXX..XXXXXXX 100644 | 71 | } |
33 | --- a/hw/arm/xlnx-versal-virt.c | 72 | diff --git a/hw/block/fdc.c b/hw/block/fdc.c |
34 | +++ b/hw/arm/xlnx-versal-virt.c | 73 | index XXXXXXX..XXXXXXX 100644 |
35 | @@ -XXX,XX +XXX,XX @@ static void versal_virt_init(MachineState *machine) | 74 | --- a/hw/block/fdc.c |
36 | s->binfo.get_dtb = versal_virt_get_dtb; | 75 | +++ b/hw/block/fdc.c |
37 | s->binfo.modify_dtb = versal_virt_modify_dtb; | 76 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo floppy_bus_info = { |
38 | if (machine->kernel_filename) { | 77 | |
39 | - arm_load_kernel(s->soc.fpd.apu.cpu[0], machine, &s->binfo); | 78 | static void floppy_bus_create(FDCtrl *fdc, FloppyBus *bus, DeviceState *dev) |
40 | + arm_load_kernel(&s->soc.fpd.apu.cpu[0], machine, &s->binfo); | 79 | { |
41 | } else { | 80 | - qbus_create_inplace(bus, sizeof(FloppyBus), TYPE_FLOPPY_BUS, dev, NULL); |
42 | - AddressSpace *as = arm_boot_address_space(s->soc.fpd.apu.cpu[0], | 81 | + qbus_init(bus, sizeof(FloppyBus), TYPE_FLOPPY_BUS, dev, NULL); |
43 | + AddressSpace *as = arm_boot_address_space(&s->soc.fpd.apu.cpu[0], | 82 | bus->fdc = fdc; |
44 | &s->binfo); | 83 | } |
45 | /* Some boot-loaders (e.g u-boot) don't like blobs at address 0 (NULL). | 84 | |
46 | * Offset things by 4K. */ | 85 | diff --git a/hw/block/swim.c b/hw/block/swim.c |
47 | diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c | 86 | index XXXXXXX..XXXXXXX 100644 |
48 | index XXXXXXX..XXXXXXX 100644 | 87 | --- a/hw/block/swim.c |
49 | --- a/hw/arm/xlnx-versal.c | 88 | +++ b/hw/block/swim.c |
50 | +++ b/hw/arm/xlnx-versal.c | 89 | @@ -XXX,XX +XXX,XX @@ static void sysbus_swim_realize(DeviceState *dev, Error **errp) |
51 | @@ -XXX,XX +XXX,XX @@ static void versal_create_apu_cpus(Versal *s) | 90 | Swim *sys = SWIM(dev); |
52 | 91 | SWIMCtrl *swimctrl = &sys->ctrl; | |
53 | for (i = 0; i < ARRAY_SIZE(s->fpd.apu.cpu); i++) { | 92 | |
54 | Object *obj; | 93 | - qbus_create_inplace(&swimctrl->bus, sizeof(SWIMBus), TYPE_SWIM_BUS, dev, |
55 | - char *name; | 94 | - NULL); |
56 | - | 95 | + qbus_init(&swimctrl->bus, sizeof(SWIMBus), TYPE_SWIM_BUS, dev, NULL); |
57 | - obj = object_new(XLNX_VERSAL_ACPU_TYPE); | 96 | swimctrl->bus.ctrl = swimctrl; |
58 | - if (!obj) { | 97 | } |
59 | - error_report("Unable to create apu.cpu[%d] of type %s", | 98 | |
60 | - i, XLNX_VERSAL_ACPU_TYPE); | 99 | diff --git a/hw/char/virtio-serial-bus.c b/hw/char/virtio-serial-bus.c |
61 | - exit(EXIT_FAILURE); | 100 | index XXXXXXX..XXXXXXX 100644 |
62 | - } | 101 | --- a/hw/char/virtio-serial-bus.c |
63 | - | 102 | +++ b/hw/char/virtio-serial-bus.c |
64 | - name = g_strdup_printf("apu-cpu[%d]", i); | 103 | @@ -XXX,XX +XXX,XX @@ static void virtio_serial_device_realize(DeviceState *dev, Error **errp) |
65 | - object_property_add_child(OBJECT(s), name, obj, &error_fatal); | 104 | config_size); |
66 | - g_free(name); | 105 | |
67 | 106 | /* Spawn a new virtio-serial bus on which the ports will ride as devices */ | |
68 | + object_initialize_child(OBJECT(s), "apu-cpu[*]", | 107 | - qbus_create_inplace(&vser->bus, sizeof(vser->bus), TYPE_VIRTIO_SERIAL_BUS, |
69 | + &s->fpd.apu.cpu[i], sizeof(s->fpd.apu.cpu[i]), | 108 | - dev, vdev->bus_name); |
70 | + XLNX_VERSAL_ACPU_TYPE, &error_abort, NULL); | 109 | + qbus_init(&vser->bus, sizeof(vser->bus), TYPE_VIRTIO_SERIAL_BUS, |
71 | + obj = OBJECT(&s->fpd.apu.cpu[i]); | 110 | + dev, vdev->bus_name); |
72 | object_property_set_int(obj, s->cfg.psci_conduit, | 111 | qbus_set_hotplug_handler(BUS(&vser->bus), OBJECT(vser)); |
73 | "psci-conduit", &error_abort); | 112 | vser->bus.vser = vser; |
74 | if (i) { | 113 | QTAILQ_INIT(&vser->ports); |
75 | @@ -XXX,XX +XXX,XX @@ static void versal_create_apu_cpus(Versal *s) | 114 | diff --git a/hw/core/bus.c b/hw/core/bus.c |
76 | object_property_set_link(obj, OBJECT(&s->fpd.apu.mr), "memory", | 115 | index XXXXXXX..XXXXXXX 100644 |
77 | &error_abort); | 116 | --- a/hw/core/bus.c |
78 | object_property_set_bool(obj, true, "realized", &error_fatal); | 117 | +++ b/hw/core/bus.c |
79 | - s->fpd.apu.cpu[i] = ARM_CPU(obj); | 118 | @@ -XXX,XX +XXX,XX @@ static void bus_reset_child_foreach(Object *obj, ResettableChildCallback cb, |
80 | } | 119 | } |
81 | } | 120 | } |
82 | 121 | ||
83 | @@ -XXX,XX +XXX,XX @@ static void versal_create_apu_gic(Versal *s, qemu_irq *pic) | 122 | -static void qbus_init(BusState *bus, DeviceState *parent, const char *name) |
123 | +static void qbus_init_internal(BusState *bus, DeviceState *parent, | ||
124 | + const char *name) | ||
125 | { | ||
126 | const char *typename = object_get_typename(OBJECT(bus)); | ||
127 | BusClass *bc; | ||
128 | @@ -XXX,XX +XXX,XX @@ static void bus_unparent(Object *obj) | ||
129 | bus->parent = NULL; | ||
130 | } | ||
131 | |||
132 | -void qbus_create_inplace(void *bus, size_t size, const char *typename, | ||
133 | - DeviceState *parent, const char *name) | ||
134 | +void qbus_init(void *bus, size_t size, const char *typename, | ||
135 | + DeviceState *parent, const char *name) | ||
136 | { | ||
137 | object_initialize(bus, size, typename); | ||
138 | - qbus_init(bus, parent, name); | ||
139 | + qbus_init_internal(bus, parent, name); | ||
140 | } | ||
141 | |||
142 | BusState *qbus_create(const char *typename, DeviceState *parent, const char *name) | ||
143 | @@ -XXX,XX +XXX,XX @@ BusState *qbus_create(const char *typename, DeviceState *parent, const char *nam | ||
144 | BusState *bus; | ||
145 | |||
146 | bus = BUS(object_new(typename)); | ||
147 | - qbus_init(bus, parent, name); | ||
148 | + qbus_init_internal(bus, parent, name); | ||
149 | |||
150 | return bus; | ||
151 | } | ||
152 | diff --git a/hw/core/sysbus.c b/hw/core/sysbus.c | ||
153 | index XXXXXXX..XXXXXXX 100644 | ||
154 | --- a/hw/core/sysbus.c | ||
155 | +++ b/hw/core/sysbus.c | ||
156 | @@ -XXX,XX +XXX,XX @@ static BusState *main_system_bus; | ||
157 | |||
158 | static void main_system_bus_create(void) | ||
159 | { | ||
160 | - /* assign main_system_bus before qbus_create_inplace() | ||
161 | - * in order to make "if (bus != sysbus_get_default())" work */ | ||
162 | + /* | ||
163 | + * assign main_system_bus before qbus_init() | ||
164 | + * in order to make "if (bus != sysbus_get_default())" work | ||
165 | + */ | ||
166 | main_system_bus = g_malloc0(system_bus_info.instance_size); | ||
167 | - qbus_create_inplace(main_system_bus, system_bus_info.instance_size, | ||
168 | - TYPE_SYSTEM_BUS, NULL, "main-system-bus"); | ||
169 | + qbus_init(main_system_bus, system_bus_info.instance_size, | ||
170 | + TYPE_SYSTEM_BUS, NULL, "main-system-bus"); | ||
171 | OBJECT(main_system_bus)->free = g_free; | ||
172 | } | ||
173 | |||
174 | diff --git a/hw/gpio/bcm2835_gpio.c b/hw/gpio/bcm2835_gpio.c | ||
175 | index XXXXXXX..XXXXXXX 100644 | ||
176 | --- a/hw/gpio/bcm2835_gpio.c | ||
177 | +++ b/hw/gpio/bcm2835_gpio.c | ||
178 | @@ -XXX,XX +XXX,XX @@ static void bcm2835_gpio_init(Object *obj) | ||
179 | DeviceState *dev = DEVICE(obj); | ||
180 | SysBusDevice *sbd = SYS_BUS_DEVICE(obj); | ||
181 | |||
182 | - qbus_create_inplace(&s->sdbus, sizeof(s->sdbus), | ||
183 | - TYPE_SD_BUS, DEVICE(s), "sd-bus"); | ||
184 | + qbus_init(&s->sdbus, sizeof(s->sdbus), TYPE_SD_BUS, DEVICE(s), "sd-bus"); | ||
185 | |||
186 | memory_region_init_io(&s->iomem, obj, | ||
187 | &bcm2835_gpio_ops, s, "bcm2835_gpio", 0x1000); | ||
188 | diff --git a/hw/ide/qdev.c b/hw/ide/qdev.c | ||
189 | index XXXXXXX..XXXXXXX 100644 | ||
190 | --- a/hw/ide/qdev.c | ||
191 | +++ b/hw/ide/qdev.c | ||
192 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo ide_bus_info = { | ||
193 | void ide_bus_new(IDEBus *idebus, size_t idebus_size, DeviceState *dev, | ||
194 | int bus_id, int max_units) | ||
195 | { | ||
196 | - qbus_create_inplace(idebus, idebus_size, TYPE_IDE_BUS, dev, NULL); | ||
197 | + qbus_init(idebus, idebus_size, TYPE_IDE_BUS, dev, NULL); | ||
198 | idebus->bus_id = bus_id; | ||
199 | idebus->max_units = max_units; | ||
200 | } | ||
201 | diff --git a/hw/ipack/ipack.c b/hw/ipack/ipack.c | ||
202 | index XXXXXXX..XXXXXXX 100644 | ||
203 | --- a/hw/ipack/ipack.c | ||
204 | +++ b/hw/ipack/ipack.c | ||
205 | @@ -XXX,XX +XXX,XX @@ void ipack_bus_init(IPackBus *bus, size_t bus_size, | ||
206 | uint8_t n_slots, | ||
207 | qemu_irq_handler handler) | ||
208 | { | ||
209 | - qbus_create_inplace(bus, bus_size, TYPE_IPACK_BUS, parent, NULL); | ||
210 | + qbus_init(bus, bus_size, TYPE_IPACK_BUS, parent, NULL); | ||
211 | bus->n_slots = n_slots; | ||
212 | bus->set_irq = handler; | ||
213 | } | ||
214 | diff --git a/hw/misc/mac_via.c b/hw/misc/mac_via.c | ||
215 | index XXXXXXX..XXXXXXX 100644 | ||
216 | --- a/hw/misc/mac_via.c | ||
217 | +++ b/hw/misc/mac_via.c | ||
218 | @@ -XXX,XX +XXX,XX @@ static void mos6522_q800_via1_init(Object *obj) | ||
219 | sysbus_init_mmio(sbd, &v1s->via_mem); | ||
220 | |||
221 | /* ADB */ | ||
222 | - qbus_create_inplace((BusState *)&v1s->adb_bus, sizeof(v1s->adb_bus), | ||
223 | - TYPE_ADB_BUS, DEVICE(v1s), "adb.0"); | ||
224 | + qbus_init((BusState *)&v1s->adb_bus, sizeof(v1s->adb_bus), | ||
225 | + TYPE_ADB_BUS, DEVICE(v1s), "adb.0"); | ||
226 | |||
227 | qdev_init_gpio_in(DEVICE(obj), via1_irq_request, VIA1_IRQ_NB); | ||
228 | } | ||
229 | diff --git a/hw/misc/macio/cuda.c b/hw/misc/macio/cuda.c | ||
230 | index XXXXXXX..XXXXXXX 100644 | ||
231 | --- a/hw/misc/macio/cuda.c | ||
232 | +++ b/hw/misc/macio/cuda.c | ||
233 | @@ -XXX,XX +XXX,XX @@ static void cuda_init(Object *obj) | ||
234 | memory_region_init_io(&s->mem, obj, &mos6522_cuda_ops, s, "cuda", 0x2000); | ||
235 | sysbus_init_mmio(sbd, &s->mem); | ||
236 | |||
237 | - qbus_create_inplace(&s->adb_bus, sizeof(s->adb_bus), TYPE_ADB_BUS, | ||
238 | - DEVICE(obj), "adb.0"); | ||
239 | + qbus_init(&s->adb_bus, sizeof(s->adb_bus), TYPE_ADB_BUS, | ||
240 | + DEVICE(obj), "adb.0"); | ||
241 | } | ||
242 | |||
243 | static Property cuda_properties[] = { | ||
244 | diff --git a/hw/misc/macio/macio.c b/hw/misc/macio/macio.c | ||
245 | index XXXXXXX..XXXXXXX 100644 | ||
246 | --- a/hw/misc/macio/macio.c | ||
247 | +++ b/hw/misc/macio/macio.c | ||
248 | @@ -XXX,XX +XXX,XX @@ static void macio_instance_init(Object *obj) | ||
249 | |||
250 | memory_region_init(&s->bar, obj, "macio", 0x80000); | ||
251 | |||
252 | - qbus_create_inplace(&s->macio_bus, sizeof(s->macio_bus), TYPE_MACIO_BUS, | ||
253 | - DEVICE(obj), "macio.0"); | ||
254 | + qbus_init(&s->macio_bus, sizeof(s->macio_bus), TYPE_MACIO_BUS, | ||
255 | + DEVICE(obj), "macio.0"); | ||
256 | |||
257 | object_initialize_child(OBJECT(s), "dbdma", &s->dbdma, TYPE_MAC_DBDMA); | ||
258 | |||
259 | diff --git a/hw/misc/macio/pmu.c b/hw/misc/macio/pmu.c | ||
260 | index XXXXXXX..XXXXXXX 100644 | ||
261 | --- a/hw/misc/macio/pmu.c | ||
262 | +++ b/hw/misc/macio/pmu.c | ||
263 | @@ -XXX,XX +XXX,XX @@ static void pmu_realize(DeviceState *dev, Error **errp) | ||
264 | timer_mod(s->one_sec_timer, s->one_sec_target); | ||
265 | |||
266 | if (s->has_adb) { | ||
267 | - qbus_create_inplace(&s->adb_bus, sizeof(s->adb_bus), TYPE_ADB_BUS, | ||
268 | - dev, "adb.0"); | ||
269 | + qbus_init(&s->adb_bus, sizeof(s->adb_bus), TYPE_ADB_BUS, | ||
270 | + dev, "adb.0"); | ||
271 | adb_register_autopoll_callback(adb_bus, pmu_adb_poll, s); | ||
84 | } | 272 | } |
85 | 273 | } | |
86 | for (i = 0; i < nr_apu_cpus; i++) { | 274 | diff --git a/hw/nubus/nubus-bridge.c b/hw/nubus/nubus-bridge.c |
87 | - DeviceState *cpudev = DEVICE(s->fpd.apu.cpu[i]); | 275 | index XXXXXXX..XXXXXXX 100644 |
88 | + DeviceState *cpudev = DEVICE(&s->fpd.apu.cpu[i]); | 276 | --- a/hw/nubus/nubus-bridge.c |
89 | int ppibase = XLNX_VERSAL_NR_IRQS + i * GIC_INTERNAL + GIC_NR_SGIS; | 277 | +++ b/hw/nubus/nubus-bridge.c |
90 | qemu_irq maint_irq; | 278 | @@ -XXX,XX +XXX,XX @@ static void nubus_bridge_init(Object *obj) |
91 | int ti; | 279 | NubusBridge *s = NUBUS_BRIDGE(obj); |
280 | NubusBus *bus = &s->bus; | ||
281 | |||
282 | - qbus_create_inplace(bus, sizeof(s->bus), TYPE_NUBUS_BUS, DEVICE(s), NULL); | ||
283 | + qbus_init(bus, sizeof(s->bus), TYPE_NUBUS_BUS, DEVICE(s), NULL); | ||
284 | |||
285 | qdev_init_gpio_out(DEVICE(s), bus->irqs, NUBUS_IRQS); | ||
286 | } | ||
287 | diff --git a/hw/nvme/ctrl.c b/hw/nvme/ctrl.c | ||
288 | index XXXXXXX..XXXXXXX 100644 | ||
289 | --- a/hw/nvme/ctrl.c | ||
290 | +++ b/hw/nvme/ctrl.c | ||
291 | @@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp) | ||
292 | return; | ||
293 | } | ||
294 | |||
295 | - qbus_create_inplace(&n->bus, sizeof(NvmeBus), TYPE_NVME_BUS, | ||
296 | - &pci_dev->qdev, n->parent_obj.qdev.id); | ||
297 | + qbus_init(&n->bus, sizeof(NvmeBus), TYPE_NVME_BUS, | ||
298 | + &pci_dev->qdev, n->parent_obj.qdev.id); | ||
299 | |||
300 | nvme_init_state(n); | ||
301 | if (nvme_init_pci(n, pci_dev, errp)) { | ||
302 | diff --git a/hw/nvme/subsys.c b/hw/nvme/subsys.c | ||
303 | index XXXXXXX..XXXXXXX 100644 | ||
304 | --- a/hw/nvme/subsys.c | ||
305 | +++ b/hw/nvme/subsys.c | ||
306 | @@ -XXX,XX +XXX,XX @@ static void nvme_subsys_realize(DeviceState *dev, Error **errp) | ||
307 | { | ||
308 | NvmeSubsystem *subsys = NVME_SUBSYS(dev); | ||
309 | |||
310 | - qbus_create_inplace(&subsys->bus, sizeof(NvmeBus), TYPE_NVME_BUS, dev, | ||
311 | - dev->id); | ||
312 | + qbus_init(&subsys->bus, sizeof(NvmeBus), TYPE_NVME_BUS, dev, dev->id); | ||
313 | |||
314 | nvme_subsys_setup(subsys); | ||
315 | } | ||
316 | diff --git a/hw/pci/pci.c b/hw/pci/pci.c | ||
317 | index XXXXXXX..XXXXXXX 100644 | ||
318 | --- a/hw/pci/pci.c | ||
319 | +++ b/hw/pci/pci.c | ||
320 | @@ -XXX,XX +XXX,XX @@ void pci_root_bus_init(PCIBus *bus, size_t bus_size, DeviceState *parent, | ||
321 | MemoryRegion *address_space_io, | ||
322 | uint8_t devfn_min, const char *typename) | ||
323 | { | ||
324 | - qbus_create_inplace(bus, bus_size, typename, parent, name); | ||
325 | + qbus_init(bus, bus_size, typename, parent, name); | ||
326 | pci_root_bus_internal_init(bus, parent, address_space_mem, | ||
327 | address_space_io, devfn_min); | ||
328 | } | ||
329 | diff --git a/hw/pci/pci_bridge.c b/hw/pci/pci_bridge.c | ||
330 | index XXXXXXX..XXXXXXX 100644 | ||
331 | --- a/hw/pci/pci_bridge.c | ||
332 | +++ b/hw/pci/pci_bridge.c | ||
333 | @@ -XXX,XX +XXX,XX @@ void pci_bridge_initfn(PCIDevice *dev, const char *typename) | ||
334 | br->bus_name = dev->qdev.id; | ||
335 | } | ||
336 | |||
337 | - qbus_create_inplace(sec_bus, sizeof(br->sec_bus), typename, DEVICE(dev), | ||
338 | - br->bus_name); | ||
339 | + qbus_init(sec_bus, sizeof(br->sec_bus), typename, DEVICE(dev), | ||
340 | + br->bus_name); | ||
341 | sec_bus->parent_dev = dev; | ||
342 | sec_bus->map_irq = br->map_irq ? br->map_irq : pci_swizzle_map_irq_fn; | ||
343 | sec_bus->address_space_mem = &br->address_space_mem; | ||
344 | diff --git a/hw/s390x/event-facility.c b/hw/s390x/event-facility.c | ||
345 | index XXXXXXX..XXXXXXX 100644 | ||
346 | --- a/hw/s390x/event-facility.c | ||
347 | +++ b/hw/s390x/event-facility.c | ||
348 | @@ -XXX,XX +XXX,XX @@ static void init_event_facility(Object *obj) | ||
349 | sclp_event_set_allow_all_mask_sizes); | ||
350 | |||
351 | /* Spawn a new bus for SCLP events */ | ||
352 | - qbus_create_inplace(&event_facility->sbus, sizeof(event_facility->sbus), | ||
353 | - TYPE_SCLP_EVENTS_BUS, sdev, NULL); | ||
354 | + qbus_init(&event_facility->sbus, sizeof(event_facility->sbus), | ||
355 | + TYPE_SCLP_EVENTS_BUS, sdev, NULL); | ||
356 | |||
357 | object_initialize_child(obj, TYPE_SCLP_QUIESCE, | ||
358 | &event_facility->quiesce, | ||
359 | diff --git a/hw/s390x/virtio-ccw.c b/hw/s390x/virtio-ccw.c | ||
360 | index XXXXXXX..XXXXXXX 100644 | ||
361 | --- a/hw/s390x/virtio-ccw.c | ||
362 | +++ b/hw/s390x/virtio-ccw.c | ||
363 | @@ -XXX,XX +XXX,XX @@ static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size, | ||
364 | DeviceState *qdev = DEVICE(dev); | ||
365 | char virtio_bus_name[] = "virtio-bus"; | ||
366 | |||
367 | - qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_CCW_BUS, | ||
368 | - qdev, virtio_bus_name); | ||
369 | + qbus_init(bus, bus_size, TYPE_VIRTIO_CCW_BUS, qdev, virtio_bus_name); | ||
370 | } | ||
371 | |||
372 | static void virtio_ccw_bus_class_init(ObjectClass *klass, void *data) | ||
373 | diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c | ||
374 | index XXXXXXX..XXXXXXX 100644 | ||
375 | --- a/hw/scsi/scsi-bus.c | ||
376 | +++ b/hw/scsi/scsi-bus.c | ||
377 | @@ -XXX,XX +XXX,XX @@ void scsi_device_unit_attention_reported(SCSIDevice *s) | ||
378 | void scsi_bus_init_named(SCSIBus *bus, size_t bus_size, DeviceState *host, | ||
379 | const SCSIBusInfo *info, const char *bus_name) | ||
380 | { | ||
381 | - qbus_create_inplace(bus, bus_size, TYPE_SCSI_BUS, host, bus_name); | ||
382 | + qbus_init(bus, bus_size, TYPE_SCSI_BUS, host, bus_name); | ||
383 | bus->busnr = next_scsi_bus++; | ||
384 | bus->info = info; | ||
385 | qbus_set_bus_hotplug_handler(BUS(bus)); | ||
386 | diff --git a/hw/sd/allwinner-sdhost.c b/hw/sd/allwinner-sdhost.c | ||
387 | index XXXXXXX..XXXXXXX 100644 | ||
388 | --- a/hw/sd/allwinner-sdhost.c | ||
389 | +++ b/hw/sd/allwinner-sdhost.c | ||
390 | @@ -XXX,XX +XXX,XX @@ static void allwinner_sdhost_init(Object *obj) | ||
391 | { | ||
392 | AwSdHostState *s = AW_SDHOST(obj); | ||
393 | |||
394 | - qbus_create_inplace(&s->sdbus, sizeof(s->sdbus), | ||
395 | - TYPE_AW_SDHOST_BUS, DEVICE(s), "sd-bus"); | ||
396 | + qbus_init(&s->sdbus, sizeof(s->sdbus), | ||
397 | + TYPE_AW_SDHOST_BUS, DEVICE(s), "sd-bus"); | ||
398 | |||
399 | memory_region_init_io(&s->iomem, obj, &allwinner_sdhost_ops, s, | ||
400 | TYPE_AW_SDHOST, 4 * KiB); | ||
401 | diff --git a/hw/sd/bcm2835_sdhost.c b/hw/sd/bcm2835_sdhost.c | ||
402 | index XXXXXXX..XXXXXXX 100644 | ||
403 | --- a/hw/sd/bcm2835_sdhost.c | ||
404 | +++ b/hw/sd/bcm2835_sdhost.c | ||
405 | @@ -XXX,XX +XXX,XX @@ static void bcm2835_sdhost_init(Object *obj) | ||
406 | { | ||
407 | BCM2835SDHostState *s = BCM2835_SDHOST(obj); | ||
408 | |||
409 | - qbus_create_inplace(&s->sdbus, sizeof(s->sdbus), | ||
410 | - TYPE_BCM2835_SDHOST_BUS, DEVICE(s), "sd-bus"); | ||
411 | + qbus_init(&s->sdbus, sizeof(s->sdbus), | ||
412 | + TYPE_BCM2835_SDHOST_BUS, DEVICE(s), "sd-bus"); | ||
413 | |||
414 | memory_region_init_io(&s->iomem, obj, &bcm2835_sdhost_ops, s, | ||
415 | TYPE_BCM2835_SDHOST, 0x1000); | ||
416 | diff --git a/hw/sd/pl181.c b/hw/sd/pl181.c | ||
417 | index XXXXXXX..XXXXXXX 100644 | ||
418 | --- a/hw/sd/pl181.c | ||
419 | +++ b/hw/sd/pl181.c | ||
420 | @@ -XXX,XX +XXX,XX @@ static void pl181_init(Object *obj) | ||
421 | qdev_init_gpio_out_named(dev, &s->card_readonly, "card-read-only", 1); | ||
422 | qdev_init_gpio_out_named(dev, &s->card_inserted, "card-inserted", 1); | ||
423 | |||
424 | - qbus_create_inplace(&s->sdbus, sizeof(s->sdbus), | ||
425 | - TYPE_PL181_BUS, dev, "sd-bus"); | ||
426 | + qbus_init(&s->sdbus, sizeof(s->sdbus), TYPE_PL181_BUS, dev, "sd-bus"); | ||
427 | } | ||
428 | |||
429 | static void pl181_class_init(ObjectClass *klass, void *data) | ||
430 | diff --git a/hw/sd/pxa2xx_mmci.c b/hw/sd/pxa2xx_mmci.c | ||
431 | index XXXXXXX..XXXXXXX 100644 | ||
432 | --- a/hw/sd/pxa2xx_mmci.c | ||
433 | +++ b/hw/sd/pxa2xx_mmci.c | ||
434 | @@ -XXX,XX +XXX,XX @@ static void pxa2xx_mmci_instance_init(Object *obj) | ||
435 | qdev_init_gpio_out_named(dev, &s->rx_dma, "rx-dma", 1); | ||
436 | qdev_init_gpio_out_named(dev, &s->tx_dma, "tx-dma", 1); | ||
437 | |||
438 | - qbus_create_inplace(&s->sdbus, sizeof(s->sdbus), | ||
439 | - TYPE_PXA2XX_MMCI_BUS, DEVICE(obj), "sd-bus"); | ||
440 | + qbus_init(&s->sdbus, sizeof(s->sdbus), | ||
441 | + TYPE_PXA2XX_MMCI_BUS, DEVICE(obj), "sd-bus"); | ||
442 | } | ||
443 | |||
444 | static void pxa2xx_mmci_class_init(ObjectClass *klass, void *data) | ||
445 | diff --git a/hw/sd/sdhci.c b/hw/sd/sdhci.c | ||
446 | index XXXXXXX..XXXXXXX 100644 | ||
447 | --- a/hw/sd/sdhci.c | ||
448 | +++ b/hw/sd/sdhci.c | ||
449 | @@ -XXX,XX +XXX,XX @@ static void sdhci_init_readonly_registers(SDHCIState *s, Error **errp) | ||
450 | |||
451 | void sdhci_initfn(SDHCIState *s) | ||
452 | { | ||
453 | - qbus_create_inplace(&s->sdbus, sizeof(s->sdbus), | ||
454 | - TYPE_SDHCI_BUS, DEVICE(s), "sd-bus"); | ||
455 | + qbus_init(&s->sdbus, sizeof(s->sdbus), TYPE_SDHCI_BUS, DEVICE(s), "sd-bus"); | ||
456 | |||
457 | s->insert_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, sdhci_raise_insertion_irq, s); | ||
458 | s->transfer_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, sdhci_data_transfer, s); | ||
459 | diff --git a/hw/sd/ssi-sd.c b/hw/sd/ssi-sd.c | ||
460 | index XXXXXXX..XXXXXXX 100644 | ||
461 | --- a/hw/sd/ssi-sd.c | ||
462 | +++ b/hw/sd/ssi-sd.c | ||
463 | @@ -XXX,XX +XXX,XX @@ static void ssi_sd_realize(SSIPeripheral *d, Error **errp) | ||
464 | DeviceState *carddev; | ||
465 | DriveInfo *dinfo; | ||
466 | |||
467 | - qbus_create_inplace(&s->sdbus, sizeof(s->sdbus), TYPE_SD_BUS, | ||
468 | - DEVICE(d), "sd-bus"); | ||
469 | + qbus_init(&s->sdbus, sizeof(s->sdbus), TYPE_SD_BUS, DEVICE(d), "sd-bus"); | ||
470 | |||
471 | /* Create and plug in the sd card */ | ||
472 | /* FIXME use a qdev drive property instead of drive_get_next() */ | ||
473 | diff --git a/hw/usb/bus.c b/hw/usb/bus.c | ||
474 | index XXXXXXX..XXXXXXX 100644 | ||
475 | --- a/hw/usb/bus.c | ||
476 | +++ b/hw/usb/bus.c | ||
477 | @@ -XXX,XX +XXX,XX @@ const VMStateDescription vmstate_usb_device = { | ||
478 | void usb_bus_new(USBBus *bus, size_t bus_size, | ||
479 | USBBusOps *ops, DeviceState *host) | ||
480 | { | ||
481 | - qbus_create_inplace(bus, bus_size, TYPE_USB_BUS, host, NULL); | ||
482 | + qbus_init(bus, bus_size, TYPE_USB_BUS, host, NULL); | ||
483 | qbus_set_bus_hotplug_handler(BUS(bus)); | ||
484 | bus->ops = ops; | ||
485 | bus->busnr = next_usb_bus++; | ||
486 | diff --git a/hw/usb/dev-smartcard-reader.c b/hw/usb/dev-smartcard-reader.c | ||
487 | index XXXXXXX..XXXXXXX 100644 | ||
488 | --- a/hw/usb/dev-smartcard-reader.c | ||
489 | +++ b/hw/usb/dev-smartcard-reader.c | ||
490 | @@ -XXX,XX +XXX,XX @@ static void ccid_realize(USBDevice *dev, Error **errp) | ||
491 | |||
492 | usb_desc_create_serial(dev); | ||
493 | usb_desc_init(dev); | ||
494 | - qbus_create_inplace(&s->bus, sizeof(s->bus), TYPE_CCID_BUS, DEVICE(dev), | ||
495 | - NULL); | ||
496 | + qbus_init(&s->bus, sizeof(s->bus), TYPE_CCID_BUS, DEVICE(dev), NULL); | ||
497 | qbus_set_hotplug_handler(BUS(&s->bus), OBJECT(dev)); | ||
498 | s->intr = usb_ep_get(dev, USB_TOKEN_IN, CCID_INT_IN_EP); | ||
499 | s->bulk = usb_ep_get(dev, USB_TOKEN_IN, CCID_BULK_IN_EP); | ||
500 | diff --git a/hw/virtio/virtio-mmio.c b/hw/virtio/virtio-mmio.c | ||
501 | index XXXXXXX..XXXXXXX 100644 | ||
502 | --- a/hw/virtio/virtio-mmio.c | ||
503 | +++ b/hw/virtio/virtio-mmio.c | ||
504 | @@ -XXX,XX +XXX,XX @@ static void virtio_mmio_realizefn(DeviceState *d, Error **errp) | ||
505 | VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); | ||
506 | SysBusDevice *sbd = SYS_BUS_DEVICE(d); | ||
507 | |||
508 | - qbus_create_inplace(&proxy->bus, sizeof(proxy->bus), TYPE_VIRTIO_MMIO_BUS, | ||
509 | - d, NULL); | ||
510 | + qbus_init(&proxy->bus, sizeof(proxy->bus), TYPE_VIRTIO_MMIO_BUS, d, NULL); | ||
511 | sysbus_init_irq(sbd, &proxy->irq); | ||
512 | |||
513 | if (!kvm_eventfds_enabled()) { | ||
514 | diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c | ||
515 | index XXXXXXX..XXXXXXX 100644 | ||
516 | --- a/hw/virtio/virtio-pci.c | ||
517 | +++ b/hw/virtio/virtio-pci.c | ||
518 | @@ -XXX,XX +XXX,XX @@ static void virtio_pci_bus_new(VirtioBusState *bus, size_t bus_size, | ||
519 | DeviceState *qdev = DEVICE(dev); | ||
520 | char virtio_bus_name[] = "virtio-bus"; | ||
521 | |||
522 | - qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_PCI_BUS, qdev, | ||
523 | - virtio_bus_name); | ||
524 | + qbus_init(bus, bus_size, TYPE_VIRTIO_PCI_BUS, qdev, virtio_bus_name); | ||
525 | } | ||
526 | |||
527 | static void virtio_pci_bus_class_init(ObjectClass *klass, void *data) | ||
92 | -- | 528 | -- |
93 | 2.20.1 | 529 | 2.20.1 |
94 | 530 | ||
95 | 531 | diff view generated by jsdifflib |
1 | The ARMv8.2-TTS2UXN feature extends the XN field in stage 2 | 1 | Rename the "allocate and return" qbus creation function to |
---|---|---|---|
2 | translation table descriptors from just bit [54] to bits [54:53], | 2 | qbus_new(), to bring it into line with our _init vs _new convention. |
3 | allowing stage 2 to control execution permissions separately for EL0 | ||
4 | and EL1. Implement the new semantics of the XN field and enable | ||
5 | the feature for our 'max' CPU. | ||
6 | 3 | ||
7 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 4 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
8 | Reviewed-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 5 | Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com> |
9 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | 6 | Reviewed-by: Michael S. Tsirkin <mst@redhat.com> |
10 | Message-id: 20200330210400.11724-5-peter.maydell@linaro.org | 7 | Reviewed-by: Corey Minyard <cminyard@mvista.com> |
8 | Message-id: 20210923121153.23754-6-peter.maydell@linaro.org | ||
11 | --- | 9 | --- |
12 | target/arm/cpu.h | 15 +++++++++++++++ | 10 | include/hw/qdev-core.h | 2 +- |
13 | target/arm/cpu.c | 1 + | 11 | hw/core/bus.c | 2 +- |
14 | target/arm/cpu64.c | 2 ++ | 12 | hw/hyperv/vmbus.c | 2 +- |
15 | target/arm/helper.c | 37 +++++++++++++++++++++++++++++++------ | 13 | hw/i2c/core.c | 2 +- |
16 | 4 files changed, 49 insertions(+), 6 deletions(-) | 14 | hw/isa/isa-bus.c | 2 +- |
17 | 15 | hw/misc/auxbus.c | 2 +- | |
18 | diff --git a/target/arm/cpu.h b/target/arm/cpu.h | 16 | hw/pci/pci.c | 2 +- |
19 | index XXXXXXX..XXXXXXX 100644 | 17 | hw/ppc/spapr_vio.c | 2 +- |
20 | --- a/target/arm/cpu.h | 18 | hw/s390x/ap-bridge.c | 2 +- |
21 | +++ b/target/arm/cpu.h | 19 | hw/s390x/css-bridge.c | 2 +- |
22 | @@ -XXX,XX +XXX,XX @@ static inline bool isar_feature_aa32_ccidx(const ARMISARegisters *id) | 20 | hw/s390x/s390-pci-bus.c | 2 +- |
23 | return FIELD_EX32(id->id_mmfr4, ID_MMFR4, CCIDX) != 0; | 21 | hw/ssi/ssi.c | 2 +- |
22 | hw/xen/xen-bus.c | 2 +- | ||
23 | hw/xen/xen-legacy-backend.c | 2 +- | ||
24 | 14 files changed, 14 insertions(+), 14 deletions(-) | ||
25 | |||
26 | diff --git a/include/hw/qdev-core.h b/include/hw/qdev-core.h | ||
27 | index XXXXXXX..XXXXXXX 100644 | ||
28 | --- a/include/hw/qdev-core.h | ||
29 | +++ b/include/hw/qdev-core.h | ||
30 | @@ -XXX,XX +XXX,XX @@ typedef int (qdev_walkerfn)(DeviceState *dev, void *opaque); | ||
31 | |||
32 | void qbus_init(void *bus, size_t size, const char *typename, | ||
33 | DeviceState *parent, const char *name); | ||
34 | -BusState *qbus_create(const char *typename, DeviceState *parent, const char *name); | ||
35 | +BusState *qbus_new(const char *typename, DeviceState *parent, const char *name); | ||
36 | bool qbus_realize(BusState *bus, Error **errp); | ||
37 | void qbus_unrealize(BusState *bus); | ||
38 | |||
39 | diff --git a/hw/core/bus.c b/hw/core/bus.c | ||
40 | index XXXXXXX..XXXXXXX 100644 | ||
41 | --- a/hw/core/bus.c | ||
42 | +++ b/hw/core/bus.c | ||
43 | @@ -XXX,XX +XXX,XX @@ void qbus_init(void *bus, size_t size, const char *typename, | ||
44 | qbus_init_internal(bus, parent, name); | ||
24 | } | 45 | } |
25 | 46 | ||
26 | +static inline bool isar_feature_aa32_tts2uxn(const ARMISARegisters *id) | 47 | -BusState *qbus_create(const char *typename, DeviceState *parent, const char *name) |
27 | +{ | 48 | +BusState *qbus_new(const char *typename, DeviceState *parent, const char *name) |
28 | + return FIELD_EX32(id->id_mmfr4, ID_MMFR4, XNX) != 0; | 49 | { |
29 | +} | 50 | BusState *bus; |
30 | + | 51 | |
31 | /* | 52 | diff --git a/hw/hyperv/vmbus.c b/hw/hyperv/vmbus.c |
32 | * 64-bit feature tests via id registers. | 53 | index XXXXXXX..XXXXXXX 100644 |
33 | */ | 54 | --- a/hw/hyperv/vmbus.c |
34 | @@ -XXX,XX +XXX,XX @@ static inline bool isar_feature_aa64_ccidx(const ARMISARegisters *id) | 55 | +++ b/hw/hyperv/vmbus.c |
35 | return FIELD_EX64(id->id_aa64mmfr2, ID_AA64MMFR2, CCIDX) != 0; | 56 | @@ -XXX,XX +XXX,XX @@ static void vmbus_bridge_realize(DeviceState *dev, Error **errp) |
57 | return; | ||
58 | } | ||
59 | |||
60 | - bridge->bus = VMBUS(qbus_create(TYPE_VMBUS, dev, "vmbus")); | ||
61 | + bridge->bus = VMBUS(qbus_new(TYPE_VMBUS, dev, "vmbus")); | ||
36 | } | 62 | } |
37 | 63 | ||
38 | +static inline bool isar_feature_aa64_tts2uxn(const ARMISARegisters *id) | 64 | static char *vmbus_bridge_ofw_unit_address(const SysBusDevice *dev) |
39 | +{ | 65 | diff --git a/hw/i2c/core.c b/hw/i2c/core.c |
40 | + return FIELD_EX64(id->id_aa64mmfr1, ID_AA64MMFR1, XNX) != 0; | 66 | index XXXXXXX..XXXXXXX 100644 |
41 | +} | 67 | --- a/hw/i2c/core.c |
42 | + | 68 | +++ b/hw/i2c/core.c |
43 | /* | 69 | @@ -XXX,XX +XXX,XX @@ I2CBus *i2c_init_bus(DeviceState *parent, const char *name) |
44 | * Feature tests for "does this exist in either 32-bit or 64-bit?" | 70 | { |
45 | */ | 71 | I2CBus *bus; |
46 | @@ -XXX,XX +XXX,XX @@ static inline bool isar_feature_any_ccidx(const ARMISARegisters *id) | 72 | |
47 | return isar_feature_aa64_ccidx(id) || isar_feature_aa32_ccidx(id); | 73 | - bus = I2C_BUS(qbus_create(TYPE_I2C_BUS, parent, name)); |
74 | + bus = I2C_BUS(qbus_new(TYPE_I2C_BUS, parent, name)); | ||
75 | QLIST_INIT(&bus->current_devs); | ||
76 | vmstate_register(NULL, VMSTATE_INSTANCE_ID_ANY, &vmstate_i2c_bus, bus); | ||
77 | return bus; | ||
78 | diff --git a/hw/isa/isa-bus.c b/hw/isa/isa-bus.c | ||
79 | index XXXXXXX..XXXXXXX 100644 | ||
80 | --- a/hw/isa/isa-bus.c | ||
81 | +++ b/hw/isa/isa-bus.c | ||
82 | @@ -XXX,XX +XXX,XX @@ ISABus *isa_bus_new(DeviceState *dev, MemoryRegion* address_space, | ||
83 | sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal); | ||
84 | } | ||
85 | |||
86 | - isabus = ISA_BUS(qbus_create(TYPE_ISA_BUS, dev, NULL)); | ||
87 | + isabus = ISA_BUS(qbus_new(TYPE_ISA_BUS, dev, NULL)); | ||
88 | isabus->address_space = address_space; | ||
89 | isabus->address_space_io = address_space_io; | ||
90 | return isabus; | ||
91 | diff --git a/hw/misc/auxbus.c b/hw/misc/auxbus.c | ||
92 | index XXXXXXX..XXXXXXX 100644 | ||
93 | --- a/hw/misc/auxbus.c | ||
94 | +++ b/hw/misc/auxbus.c | ||
95 | @@ -XXX,XX +XXX,XX @@ AUXBus *aux_bus_init(DeviceState *parent, const char *name) | ||
96 | AUXBus *bus; | ||
97 | Object *auxtoi2c; | ||
98 | |||
99 | - bus = AUX_BUS(qbus_create(TYPE_AUX_BUS, parent, name)); | ||
100 | + bus = AUX_BUS(qbus_new(TYPE_AUX_BUS, parent, name)); | ||
101 | auxtoi2c = object_new_with_props(TYPE_AUXTOI2C, OBJECT(bus), "i2c", | ||
102 | &error_abort, NULL); | ||
103 | |||
104 | diff --git a/hw/pci/pci.c b/hw/pci/pci.c | ||
105 | index XXXXXXX..XXXXXXX 100644 | ||
106 | --- a/hw/pci/pci.c | ||
107 | +++ b/hw/pci/pci.c | ||
108 | @@ -XXX,XX +XXX,XX @@ PCIBus *pci_root_bus_new(DeviceState *parent, const char *name, | ||
109 | { | ||
110 | PCIBus *bus; | ||
111 | |||
112 | - bus = PCI_BUS(qbus_create(typename, parent, name)); | ||
113 | + bus = PCI_BUS(qbus_new(typename, parent, name)); | ||
114 | pci_root_bus_internal_init(bus, parent, address_space_mem, | ||
115 | address_space_io, devfn_min); | ||
116 | return bus; | ||
117 | diff --git a/hw/ppc/spapr_vio.c b/hw/ppc/spapr_vio.c | ||
118 | index XXXXXXX..XXXXXXX 100644 | ||
119 | --- a/hw/ppc/spapr_vio.c | ||
120 | +++ b/hw/ppc/spapr_vio.c | ||
121 | @@ -XXX,XX +XXX,XX @@ SpaprVioBus *spapr_vio_bus_init(void) | ||
122 | sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal); | ||
123 | |||
124 | /* Create bus on bridge device */ | ||
125 | - qbus = qbus_create(TYPE_SPAPR_VIO_BUS, dev, "spapr-vio"); | ||
126 | + qbus = qbus_new(TYPE_SPAPR_VIO_BUS, dev, "spapr-vio"); | ||
127 | bus = SPAPR_VIO_BUS(qbus); | ||
128 | bus->next_reg = SPAPR_VIO_REG_BASE; | ||
129 | |||
130 | diff --git a/hw/s390x/ap-bridge.c b/hw/s390x/ap-bridge.c | ||
131 | index XXXXXXX..XXXXXXX 100644 | ||
132 | --- a/hw/s390x/ap-bridge.c | ||
133 | +++ b/hw/s390x/ap-bridge.c | ||
134 | @@ -XXX,XX +XXX,XX @@ void s390_init_ap(void) | ||
135 | sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal); | ||
136 | |||
137 | /* Create bus on bridge device */ | ||
138 | - bus = qbus_create(TYPE_AP_BUS, dev, TYPE_AP_BUS); | ||
139 | + bus = qbus_new(TYPE_AP_BUS, dev, TYPE_AP_BUS); | ||
140 | |||
141 | /* Enable hotplugging */ | ||
142 | qbus_set_hotplug_handler(bus, OBJECT(dev)); | ||
143 | diff --git a/hw/s390x/css-bridge.c b/hw/s390x/css-bridge.c | ||
144 | index XXXXXXX..XXXXXXX 100644 | ||
145 | --- a/hw/s390x/css-bridge.c | ||
146 | +++ b/hw/s390x/css-bridge.c | ||
147 | @@ -XXX,XX +XXX,XX @@ VirtualCssBus *virtual_css_bus_init(void) | ||
148 | sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal); | ||
149 | |||
150 | /* Create bus on bridge device */ | ||
151 | - bus = qbus_create(TYPE_VIRTUAL_CSS_BUS, dev, "virtual-css"); | ||
152 | + bus = qbus_new(TYPE_VIRTUAL_CSS_BUS, dev, "virtual-css"); | ||
153 | cbus = VIRTUAL_CSS_BUS(bus); | ||
154 | |||
155 | /* Enable hotplugging */ | ||
156 | diff --git a/hw/s390x/s390-pci-bus.c b/hw/s390x/s390-pci-bus.c | ||
157 | index XXXXXXX..XXXXXXX 100644 | ||
158 | --- a/hw/s390x/s390-pci-bus.c | ||
159 | +++ b/hw/s390x/s390-pci-bus.c | ||
160 | @@ -XXX,XX +XXX,XX @@ static void s390_pcihost_realize(DeviceState *dev, Error **errp) | ||
161 | qbus_set_hotplug_handler(bus, OBJECT(dev)); | ||
162 | phb->bus = b; | ||
163 | |||
164 | - s->bus = S390_PCI_BUS(qbus_create(TYPE_S390_PCI_BUS, dev, NULL)); | ||
165 | + s->bus = S390_PCI_BUS(qbus_new(TYPE_S390_PCI_BUS, dev, NULL)); | ||
166 | qbus_set_hotplug_handler(BUS(s->bus), OBJECT(dev)); | ||
167 | |||
168 | s->iommu_table = g_hash_table_new_full(g_int64_hash, g_int64_equal, | ||
169 | diff --git a/hw/ssi/ssi.c b/hw/ssi/ssi.c | ||
170 | index XXXXXXX..XXXXXXX 100644 | ||
171 | --- a/hw/ssi/ssi.c | ||
172 | +++ b/hw/ssi/ssi.c | ||
173 | @@ -XXX,XX +XXX,XX @@ DeviceState *ssi_create_peripheral(SSIBus *bus, const char *name) | ||
174 | SSIBus *ssi_create_bus(DeviceState *parent, const char *name) | ||
175 | { | ||
176 | BusState *bus; | ||
177 | - bus = qbus_create(TYPE_SSI_BUS, parent, name); | ||
178 | + bus = qbus_new(TYPE_SSI_BUS, parent, name); | ||
179 | return SSI_BUS(bus); | ||
48 | } | 180 | } |
49 | 181 | ||
50 | +static inline bool isar_feature_any_tts2uxn(const ARMISARegisters *id) | 182 | diff --git a/hw/xen/xen-bus.c b/hw/xen/xen-bus.c |
51 | +{ | 183 | index XXXXXXX..XXXXXXX 100644 |
52 | + return isar_feature_aa64_tts2uxn(id) || isar_feature_aa32_tts2uxn(id); | 184 | --- a/hw/xen/xen-bus.c |
53 | +} | 185 | +++ b/hw/xen/xen-bus.c |
54 | + | 186 | @@ -XXX,XX +XXX,XX @@ type_init(xen_register_types) |
55 | /* | 187 | void xen_bus_init(void) |
56 | * Forward to the above feature tests given an ARMCPU pointer. | 188 | { |
57 | */ | 189 | DeviceState *dev = qdev_new(TYPE_XEN_BRIDGE); |
58 | diff --git a/target/arm/cpu.c b/target/arm/cpu.c | 190 | - BusState *bus = qbus_create(TYPE_XEN_BUS, dev, NULL); |
59 | index XXXXXXX..XXXXXXX 100644 | 191 | + BusState *bus = qbus_new(TYPE_XEN_BUS, dev, NULL); |
60 | --- a/target/arm/cpu.c | 192 | |
61 | +++ b/target/arm/cpu.c | 193 | sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal); |
62 | @@ -XXX,XX +XXX,XX @@ static void arm_max_initfn(Object *obj) | 194 | qbus_set_bus_hotplug_handler(bus); |
63 | t = FIELD_DP32(t, ID_MMFR4, HPDS, 1); /* AA32HPD */ | 195 | diff --git a/hw/xen/xen-legacy-backend.c b/hw/xen/xen-legacy-backend.c |
64 | t = FIELD_DP32(t, ID_MMFR4, AC2, 1); /* ACTLR2, HACTLR2 */ | 196 | index XXXXXXX..XXXXXXX 100644 |
65 | t = FIELD_DP32(t, ID_MMFR4, CNP, 1); /* TTCNP */ | 197 | --- a/hw/xen/xen-legacy-backend.c |
66 | + t = FIELD_DP32(t, ID_MMFR4, XNX, 1); /* TTS2UXN */ | 198 | +++ b/hw/xen/xen-legacy-backend.c |
67 | cpu->isar.id_mmfr4 = t; | 199 | @@ -XXX,XX +XXX,XX @@ int xen_be_init(void) |
68 | } | 200 | |
69 | #endif | 201 | xen_sysdev = qdev_new(TYPE_XENSYSDEV); |
70 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 202 | sysbus_realize_and_unref(SYS_BUS_DEVICE(xen_sysdev), &error_fatal); |
71 | index XXXXXXX..XXXXXXX 100644 | 203 | - xen_sysbus = qbus_create(TYPE_XENSYSBUS, xen_sysdev, "xen-sysbus"); |
72 | --- a/target/arm/cpu64.c | 204 | + xen_sysbus = qbus_new(TYPE_XENSYSBUS, xen_sysdev, "xen-sysbus"); |
73 | +++ b/target/arm/cpu64.c | 205 | qbus_set_bus_hotplug_handler(xen_sysbus); |
74 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | 206 | |
75 | t = FIELD_DP64(t, ID_AA64MMFR1, VH, 1); | 207 | return 0; |
76 | t = FIELD_DP64(t, ID_AA64MMFR1, PAN, 2); /* ATS1E1 */ | ||
77 | t = FIELD_DP64(t, ID_AA64MMFR1, VMIDBITS, 2); /* VMID16 */ | ||
78 | + t = FIELD_DP64(t, ID_AA64MMFR1, XNX, 1); /* TTS2UXN */ | ||
79 | cpu->isar.id_aa64mmfr1 = t; | ||
80 | |||
81 | t = cpu->isar.id_aa64mmfr2; | ||
82 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | ||
83 | u = FIELD_DP32(u, ID_MMFR4, HPDS, 1); /* AA32HPD */ | ||
84 | u = FIELD_DP32(u, ID_MMFR4, AC2, 1); /* ACTLR2, HACTLR2 */ | ||
85 | u = FIELD_DP32(u, ID_MMFR4, CNP, 1); /* TTCNP */ | ||
86 | + u = FIELD_DP32(u, ID_MMFR4, XNX, 1); /* TTS2UXN */ | ||
87 | cpu->isar.id_mmfr4 = u; | ||
88 | |||
89 | u = cpu->isar.id_aa64dfr0; | ||
90 | diff --git a/target/arm/helper.c b/target/arm/helper.c | ||
91 | index XXXXXXX..XXXXXXX 100644 | ||
92 | --- a/target/arm/helper.c | ||
93 | +++ b/target/arm/helper.c | ||
94 | @@ -XXX,XX +XXX,XX @@ simple_ap_to_rw_prot(CPUARMState *env, ARMMMUIdx mmu_idx, int ap) | ||
95 | * | ||
96 | * @env: CPUARMState | ||
97 | * @s2ap: The 2-bit stage2 access permissions (S2AP) | ||
98 | - * @xn: XN (execute-never) bit | ||
99 | + * @xn: XN (execute-never) bits | ||
100 | + * @s1_is_el0: true if this is S2 of an S1+2 walk for EL0 | ||
101 | */ | ||
102 | -static int get_S2prot(CPUARMState *env, int s2ap, int xn) | ||
103 | +static int get_S2prot(CPUARMState *env, int s2ap, int xn, bool s1_is_el0) | ||
104 | { | ||
105 | int prot = 0; | ||
106 | |||
107 | @@ -XXX,XX +XXX,XX @@ static int get_S2prot(CPUARMState *env, int s2ap, int xn) | ||
108 | if (s2ap & 2) { | ||
109 | prot |= PAGE_WRITE; | ||
110 | } | ||
111 | - if (!xn) { | ||
112 | - if (arm_el_is_aa64(env, 2) || prot & PAGE_READ) { | ||
113 | + | ||
114 | + if (cpu_isar_feature(any_tts2uxn, env_archcpu(env))) { | ||
115 | + switch (xn) { | ||
116 | + case 0: | ||
117 | prot |= PAGE_EXEC; | ||
118 | + break; | ||
119 | + case 1: | ||
120 | + if (s1_is_el0) { | ||
121 | + prot |= PAGE_EXEC; | ||
122 | + } | ||
123 | + break; | ||
124 | + case 2: | ||
125 | + break; | ||
126 | + case 3: | ||
127 | + if (!s1_is_el0) { | ||
128 | + prot |= PAGE_EXEC; | ||
129 | + } | ||
130 | + break; | ||
131 | + default: | ||
132 | + g_assert_not_reached(); | ||
133 | + } | ||
134 | + } else { | ||
135 | + if (!extract32(xn, 1, 1)) { | ||
136 | + if (arm_el_is_aa64(env, 2) || prot & PAGE_READ) { | ||
137 | + prot |= PAGE_EXEC; | ||
138 | + } | ||
139 | } | ||
140 | } | ||
141 | return prot; | ||
142 | @@ -XXX,XX +XXX,XX @@ static bool get_phys_addr_lpae(CPUARMState *env, target_ulong address, | ||
143 | } | ||
144 | |||
145 | ap = extract32(attrs, 4, 2); | ||
146 | - xn = extract32(attrs, 12, 1); | ||
147 | |||
148 | if (mmu_idx == ARMMMUIdx_Stage2) { | ||
149 | ns = true; | ||
150 | - *prot = get_S2prot(env, ap, xn); | ||
151 | + xn = extract32(attrs, 11, 2); | ||
152 | + *prot = get_S2prot(env, ap, xn, s1_is_el0); | ||
153 | } else { | ||
154 | ns = extract32(attrs, 3, 1); | ||
155 | + xn = extract32(attrs, 12, 1); | ||
156 | pxn = extract32(attrs, 11, 1); | ||
157 | *prot = get_S1prot(env, mmu_idx, aarch64, ap, ns, xn, pxn); | ||
158 | } | ||
159 | -- | 208 | -- |
160 | 2.20.1 | 209 | 2.20.1 |
161 | 210 | ||
162 | 211 | diff view generated by jsdifflib |
1 | We define ARMMMUIdx_Stage2 as being an MMU index which uses a QEMU | 1 | The function ide_bus_new() does an in-place initialization. Rename |
---|---|---|---|
2 | TLB. However we never actually use the TLB -- all stage 2 lookups | 2 | it to ide_bus_init() to follow our _init vs _new convention. |
3 | are done by direct calls to get_phys_addr_lpae() followed by a | ||
4 | physical address load via address_space_ld*(). | ||
5 | |||
6 | Remove Stage2 from the list of ARM MMU indexes which correspond to | ||
7 | real core MMU indexes, and instead put it in the set of "NOTLB" ARM | ||
8 | MMU indexes. | ||
9 | |||
10 | This allows us to drop NB_MMU_MODES to 11. It also means we can | ||
11 | safely add support for the ARMv8.3-TTS2UXN extension, which adds | ||
12 | permission bits to the stage 2 descriptors which define execute | ||
13 | permission separatel for EL0 and EL1; supporting that while keeping | ||
14 | Stage2 in a QEMU TLB would require us to use separate TLBs for | ||
15 | "Stage2 for an EL0 access" and "Stage2 for an EL1 access", which is a | ||
16 | lot of extra complication given we aren't even using the QEMU TLB. | ||
17 | |||
18 | In the process of updating the comment on our MMU index use, | ||
19 | fix a couple of other minor errors: | ||
20 | * NS EL2 EL2&0 was missing from the list in the comment | ||
21 | * some text hadn't been updated from when we bumped NB_MMU_MODES | ||
22 | above 8 | ||
23 | 3 | ||
24 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 4 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
25 | Reviewed-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 5 | Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com> |
26 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | 6 | Reviewed-by: Michael S. Tsirkin <mst@redhat.com> |
27 | Message-id: 20200330210400.11724-2-peter.maydell@linaro.org | 7 | Reviewed-by: Corey Minyard <cminyard@mvista.com> |
8 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
9 | Acked-by: John Snow <jsnow@redhat.com> (Feel free to merge.) | ||
10 | Message-id: 20210923121153.23754-7-peter.maydell@linaro.org | ||
28 | --- | 11 | --- |
29 | target/arm/cpu-param.h | 2 +- | 12 | include/hw/ide/internal.h | 4 ++-- |
30 | target/arm/cpu.h | 21 +++++--- | 13 | hw/ide/ahci.c | 2 +- |
31 | target/arm/helper.c | 112 ++++------------------------------------- | 14 | hw/ide/cmd646.c | 2 +- |
32 | 3 files changed, 27 insertions(+), 108 deletions(-) | 15 | hw/ide/isa.c | 2 +- |
16 | hw/ide/macio.c | 2 +- | ||
17 | hw/ide/microdrive.c | 2 +- | ||
18 | hw/ide/mmio.c | 2 +- | ||
19 | hw/ide/piix.c | 2 +- | ||
20 | hw/ide/qdev.c | 2 +- | ||
21 | hw/ide/sii3112.c | 2 +- | ||
22 | hw/ide/via.c | 2 +- | ||
23 | 11 files changed, 12 insertions(+), 12 deletions(-) | ||
33 | 24 | ||
34 | diff --git a/target/arm/cpu-param.h b/target/arm/cpu-param.h | 25 | diff --git a/include/hw/ide/internal.h b/include/hw/ide/internal.h |
35 | index XXXXXXX..XXXXXXX 100644 | 26 | index XXXXXXX..XXXXXXX 100644 |
36 | --- a/target/arm/cpu-param.h | 27 | --- a/include/hw/ide/internal.h |
37 | +++ b/target/arm/cpu-param.h | 28 | +++ b/include/hw/ide/internal.h |
38 | @@ -XXX,XX +XXX,XX @@ | 29 | @@ -XXX,XX +XXX,XX @@ void ide_atapi_cmd(IDEState *s); |
39 | # define TARGET_PAGE_BITS_MIN 10 | 30 | void ide_atapi_cmd_reply_end(IDEState *s); |
40 | #endif | 31 | |
41 | 32 | /* hw/ide/qdev.c */ | |
42 | -#define NB_MMU_MODES 12 | 33 | -void ide_bus_new(IDEBus *idebus, size_t idebus_size, DeviceState *dev, |
43 | +#define NB_MMU_MODES 11 | 34 | - int bus_id, int max_units); |
44 | 35 | +void ide_bus_init(IDEBus *idebus, size_t idebus_size, DeviceState *dev, | |
45 | #endif | 36 | + int bus_id, int max_units); |
46 | diff --git a/target/arm/cpu.h b/target/arm/cpu.h | 37 | IDEDevice *ide_create_drive(IDEBus *bus, int unit, DriveInfo *drive); |
38 | |||
39 | int ide_handle_rw_error(IDEState *s, int error, int op); | ||
40 | diff --git a/hw/ide/ahci.c b/hw/ide/ahci.c | ||
47 | index XXXXXXX..XXXXXXX 100644 | 41 | index XXXXXXX..XXXXXXX 100644 |
48 | --- a/target/arm/cpu.h | 42 | --- a/hw/ide/ahci.c |
49 | +++ b/target/arm/cpu.h | 43 | +++ b/hw/ide/ahci.c |
50 | @@ -XXX,XX +XXX,XX @@ bool write_cpustate_to_list(ARMCPU *cpu, bool kvm_sync); | 44 | @@ -XXX,XX +XXX,XX @@ void ahci_realize(AHCIState *s, DeviceState *qdev, AddressSpace *as, int ports) |
51 | * handling via the TLB. The only way to do a stage 1 translation without | 45 | for (i = 0; i < s->ports; i++) { |
52 | * the immediate stage 2 translation is via the ATS or AT system insns, | 46 | AHCIDevice *ad = &s->dev[i]; |
53 | * which can be slow-pathed and always do a page table walk. | 47 | |
54 | + * The only use of stage 2 translations is either as part of an s1+2 | 48 | - ide_bus_new(&ad->port, sizeof(ad->port), qdev, i, 1); |
55 | + * lookup or when loading the descriptors during a stage 1 page table walk, | 49 | + ide_bus_init(&ad->port, sizeof(ad->port), qdev, i, 1); |
56 | + * and in both those cases we don't use the TLB. | 50 | ide_init2(&ad->port, irqs[i]); |
57 | * 4. we can also safely fold together the "32 bit EL3" and "64 bit EL3" | 51 | |
58 | * translation regimes, because they map reasonably well to each other | 52 | ad->hba = s; |
59 | * and they can't both be active at the same time. | 53 | diff --git a/hw/ide/cmd646.c b/hw/ide/cmd646.c |
60 | @@ -XXX,XX +XXX,XX @@ bool write_cpustate_to_list(ARMCPU *cpu, bool kvm_sync); | ||
61 | * NS EL1 EL1&0 stage 1+2 (aka NS PL1) | ||
62 | * NS EL1 EL1&0 stage 1+2 +PAN | ||
63 | * NS EL0 EL2&0 | ||
64 | + * NS EL2 EL2&0 | ||
65 | * NS EL2 EL2&0 +PAN | ||
66 | * NS EL2 (aka NS PL2) | ||
67 | * S EL0 EL1&0 (aka S PL0) | ||
68 | * S EL1 EL1&0 (not used if EL3 is 32 bit) | ||
69 | * S EL1 EL1&0 +PAN | ||
70 | * S EL3 (aka S PL1) | ||
71 | - * NS EL1&0 stage 2 | ||
72 | * | ||
73 | - * for a total of 12 different mmu_idx. | ||
74 | + * for a total of 11 different mmu_idx. | ||
75 | * | ||
76 | * R profile CPUs have an MPU, but can use the same set of MMU indexes | ||
77 | * as A profile. They only need to distinguish NS EL0 and NS EL1 (and | ||
78 | @@ -XXX,XX +XXX,XX @@ bool write_cpustate_to_list(ARMCPU *cpu, bool kvm_sync); | ||
79 | * are not quite the same -- different CPU types (most notably M profile | ||
80 | * vs A/R profile) would like to use MMU indexes with different semantics, | ||
81 | * but since we don't ever need to use all of those in a single CPU we | ||
82 | - * can avoid setting NB_MMU_MODES to more than 8. The lower bits of | ||
83 | + * can avoid having to set NB_MMU_MODES to "total number of A profile MMU | ||
84 | + * modes + total number of M profile MMU modes". The lower bits of | ||
85 | * ARMMMUIdx are the core TLB mmu index, and the higher bits are always | ||
86 | * the same for any particular CPU. | ||
87 | * Variables of type ARMMUIdx are always full values, and the core | ||
88 | @@ -XXX,XX +XXX,XX @@ typedef enum ARMMMUIdx { | ||
89 | ARMMMUIdx_SE10_1_PAN = 9 | ARM_MMU_IDX_A, | ||
90 | ARMMMUIdx_SE3 = 10 | ARM_MMU_IDX_A, | ||
91 | |||
92 | - ARMMMUIdx_Stage2 = 11 | ARM_MMU_IDX_A, | ||
93 | - | ||
94 | /* | ||
95 | * These are not allocated TLBs and are used only for AT system | ||
96 | * instructions or for the first stage of an S12 page table walk. | ||
97 | @@ -XXX,XX +XXX,XX @@ typedef enum ARMMMUIdx { | ||
98 | ARMMMUIdx_Stage1_E0 = 0 | ARM_MMU_IDX_NOTLB, | ||
99 | ARMMMUIdx_Stage1_E1 = 1 | ARM_MMU_IDX_NOTLB, | ||
100 | ARMMMUIdx_Stage1_E1_PAN = 2 | ARM_MMU_IDX_NOTLB, | ||
101 | + /* | ||
102 | + * Not allocated a TLB: used only for second stage of an S12 page | ||
103 | + * table walk, or for descriptor loads during first stage of an S1 | ||
104 | + * page table walk. Note that if we ever want to have a TLB for this | ||
105 | + * then various TLB flush insns which currently are no-ops or flush | ||
106 | + * only stage 1 MMU indexes will need to change to flush stage 2. | ||
107 | + */ | ||
108 | + ARMMMUIdx_Stage2 = 3 | ARM_MMU_IDX_NOTLB, | ||
109 | |||
110 | /* | ||
111 | * M-profile. | ||
112 | @@ -XXX,XX +XXX,XX @@ typedef enum ARMMMUIdxBit { | ||
113 | TO_CORE_BIT(SE10_1), | ||
114 | TO_CORE_BIT(SE10_1_PAN), | ||
115 | TO_CORE_BIT(SE3), | ||
116 | - TO_CORE_BIT(Stage2), | ||
117 | |||
118 | TO_CORE_BIT(MUser), | ||
119 | TO_CORE_BIT(MPriv), | ||
120 | diff --git a/target/arm/helper.c b/target/arm/helper.c | ||
121 | index XXXXXXX..XXXXXXX 100644 | 54 | index XXXXXXX..XXXXXXX 100644 |
122 | --- a/target/arm/helper.c | 55 | --- a/hw/ide/cmd646.c |
123 | +++ b/target/arm/helper.c | 56 | +++ b/hw/ide/cmd646.c |
124 | @@ -XXX,XX +XXX,XX @@ static void tlbiall_nsnh_write(CPUARMState *env, const ARMCPRegInfo *ri, | 57 | @@ -XXX,XX +XXX,XX @@ static void pci_cmd646_ide_realize(PCIDevice *dev, Error **errp) |
125 | tlb_flush_by_mmuidx(cs, | 58 | |
126 | ARMMMUIdxBit_E10_1 | | 59 | qdev_init_gpio_in(ds, cmd646_set_irq, 2); |
127 | ARMMMUIdxBit_E10_1_PAN | | 60 | for (i = 0; i < 2; i++) { |
128 | - ARMMMUIdxBit_E10_0 | | 61 | - ide_bus_new(&d->bus[i], sizeof(d->bus[i]), ds, i, 2); |
129 | - ARMMMUIdxBit_Stage2); | 62 | + ide_bus_init(&d->bus[i], sizeof(d->bus[i]), ds, i, 2); |
130 | + ARMMMUIdxBit_E10_0); | 63 | ide_init2(&d->bus[i], qdev_get_gpio_in(ds, i)); |
64 | |||
65 | bmdma_init(&d->bus[i], &d->bmdma[i], d); | ||
66 | diff --git a/hw/ide/isa.c b/hw/ide/isa.c | ||
67 | index XXXXXXX..XXXXXXX 100644 | ||
68 | --- a/hw/ide/isa.c | ||
69 | +++ b/hw/ide/isa.c | ||
70 | @@ -XXX,XX +XXX,XX @@ static void isa_ide_realizefn(DeviceState *dev, Error **errp) | ||
71 | ISADevice *isadev = ISA_DEVICE(dev); | ||
72 | ISAIDEState *s = ISA_IDE(dev); | ||
73 | |||
74 | - ide_bus_new(&s->bus, sizeof(s->bus), dev, 0, 2); | ||
75 | + ide_bus_init(&s->bus, sizeof(s->bus), dev, 0, 2); | ||
76 | ide_init_ioport(&s->bus, isadev, s->iobase, s->iobase2); | ||
77 | isa_init_irq(isadev, &s->irq, s->isairq); | ||
78 | ide_init2(&s->bus, s->irq); | ||
79 | diff --git a/hw/ide/macio.c b/hw/ide/macio.c | ||
80 | index XXXXXXX..XXXXXXX 100644 | ||
81 | --- a/hw/ide/macio.c | ||
82 | +++ b/hw/ide/macio.c | ||
83 | @@ -XXX,XX +XXX,XX @@ static void macio_ide_initfn(Object *obj) | ||
84 | SysBusDevice *d = SYS_BUS_DEVICE(obj); | ||
85 | MACIOIDEState *s = MACIO_IDE(obj); | ||
86 | |||
87 | - ide_bus_new(&s->bus, sizeof(s->bus), DEVICE(obj), 0, 2); | ||
88 | + ide_bus_init(&s->bus, sizeof(s->bus), DEVICE(obj), 0, 2); | ||
89 | memory_region_init_io(&s->mem, obj, &pmac_ide_ops, s, "pmac-ide", 0x1000); | ||
90 | sysbus_init_mmio(d, &s->mem); | ||
91 | sysbus_init_irq(d, &s->real_ide_irq); | ||
92 | diff --git a/hw/ide/microdrive.c b/hw/ide/microdrive.c | ||
93 | index XXXXXXX..XXXXXXX 100644 | ||
94 | --- a/hw/ide/microdrive.c | ||
95 | +++ b/hw/ide/microdrive.c | ||
96 | @@ -XXX,XX +XXX,XX @@ static void microdrive_init(Object *obj) | ||
97 | { | ||
98 | MicroDriveState *md = MICRODRIVE(obj); | ||
99 | |||
100 | - ide_bus_new(&md->bus, sizeof(md->bus), DEVICE(obj), 0, 1); | ||
101 | + ide_bus_init(&md->bus, sizeof(md->bus), DEVICE(obj), 0, 1); | ||
131 | } | 102 | } |
132 | 103 | ||
133 | static void tlbiall_nsnh_is_write(CPUARMState *env, const ARMCPRegInfo *ri, | 104 | static void microdrive_class_init(ObjectClass *oc, void *data) |
134 | @@ -XXX,XX +XXX,XX @@ static void tlbiall_nsnh_is_write(CPUARMState *env, const ARMCPRegInfo *ri, | 105 | diff --git a/hw/ide/mmio.c b/hw/ide/mmio.c |
135 | tlb_flush_by_mmuidx_all_cpus_synced(cs, | 106 | index XXXXXXX..XXXXXXX 100644 |
136 | ARMMMUIdxBit_E10_1 | | 107 | --- a/hw/ide/mmio.c |
137 | ARMMMUIdxBit_E10_1_PAN | | 108 | +++ b/hw/ide/mmio.c |
138 | - ARMMMUIdxBit_E10_0 | | 109 | @@ -XXX,XX +XXX,XX @@ static void mmio_ide_initfn(Object *obj) |
139 | - ARMMMUIdxBit_Stage2); | 110 | SysBusDevice *d = SYS_BUS_DEVICE(obj); |
140 | + ARMMMUIdxBit_E10_0); | 111 | MMIOState *s = MMIO_IDE(obj); |
112 | |||
113 | - ide_bus_new(&s->bus, sizeof(s->bus), DEVICE(obj), 0, 2); | ||
114 | + ide_bus_init(&s->bus, sizeof(s->bus), DEVICE(obj), 0, 2); | ||
115 | sysbus_init_irq(d, &s->irq); | ||
141 | } | 116 | } |
142 | 117 | ||
143 | -static void tlbiipas2_write(CPUARMState *env, const ARMCPRegInfo *ri, | 118 | diff --git a/hw/ide/piix.c b/hw/ide/piix.c |
144 | - uint64_t value) | 119 | index XXXXXXX..XXXXXXX 100644 |
145 | -{ | 120 | --- a/hw/ide/piix.c |
146 | - /* Invalidate by IPA. This has to invalidate any structures that | 121 | +++ b/hw/ide/piix.c |
147 | - * contain only stage 2 translation information, but does not need | 122 | @@ -XXX,XX +XXX,XX @@ static int pci_piix_init_ports(PCIIDEState *d) |
148 | - * to apply to structures that contain combined stage 1 and stage 2 | 123 | int i, ret; |
149 | - * translation information. | 124 | |
150 | - * This must NOP if EL2 isn't implemented or SCR_EL3.NS is zero. | 125 | for (i = 0; i < 2; i++) { |
151 | - */ | 126 | - ide_bus_new(&d->bus[i], sizeof(d->bus[i]), DEVICE(d), i, 2); |
152 | - CPUState *cs = env_cpu(env); | 127 | + ide_bus_init(&d->bus[i], sizeof(d->bus[i]), DEVICE(d), i, 2); |
153 | - uint64_t pageaddr; | 128 | ret = ide_init_ioport(&d->bus[i], NULL, port_info[i].iobase, |
154 | - | 129 | port_info[i].iobase2); |
155 | - if (!arm_feature(env, ARM_FEATURE_EL2) || !(env->cp15.scr_el3 & SCR_NS)) { | 130 | if (ret) { |
156 | - return; | 131 | diff --git a/hw/ide/qdev.c b/hw/ide/qdev.c |
157 | - } | 132 | index XXXXXXX..XXXXXXX 100644 |
158 | - | 133 | --- a/hw/ide/qdev.c |
159 | - pageaddr = sextract64(value << 12, 0, 40); | 134 | +++ b/hw/ide/qdev.c |
160 | - | 135 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo ide_bus_info = { |
161 | - tlb_flush_page_by_mmuidx(cs, pageaddr, ARMMMUIdxBit_Stage2); | 136 | .class_init = ide_bus_class_init, |
162 | -} | 137 | }; |
163 | - | 138 | |
164 | -static void tlbiipas2_is_write(CPUARMState *env, const ARMCPRegInfo *ri, | 139 | -void ide_bus_new(IDEBus *idebus, size_t idebus_size, DeviceState *dev, |
165 | - uint64_t value) | 140 | +void ide_bus_init(IDEBus *idebus, size_t idebus_size, DeviceState *dev, |
166 | -{ | 141 | int bus_id, int max_units) |
167 | - CPUState *cs = env_cpu(env); | ||
168 | - uint64_t pageaddr; | ||
169 | - | ||
170 | - if (!arm_feature(env, ARM_FEATURE_EL2) || !(env->cp15.scr_el3 & SCR_NS)) { | ||
171 | - return; | ||
172 | - } | ||
173 | - | ||
174 | - pageaddr = sextract64(value << 12, 0, 40); | ||
175 | - | ||
176 | - tlb_flush_page_by_mmuidx_all_cpus_synced(cs, pageaddr, | ||
177 | - ARMMMUIdxBit_Stage2); | ||
178 | -} | ||
179 | |||
180 | static void tlbiall_hyp_write(CPUARMState *env, const ARMCPRegInfo *ri, | ||
181 | uint64_t value) | ||
182 | @@ -XXX,XX +XXX,XX @@ static void vttbr_write(CPUARMState *env, const ARMCPRegInfo *ri, | ||
183 | tlb_flush_by_mmuidx(cs, | ||
184 | ARMMMUIdxBit_E10_1 | | ||
185 | ARMMMUIdxBit_E10_1_PAN | | ||
186 | - ARMMMUIdxBit_E10_0 | | ||
187 | - ARMMMUIdxBit_Stage2); | ||
188 | + ARMMMUIdxBit_E10_0); | ||
189 | raw_write(env, ri, value); | ||
190 | } | ||
191 | } | ||
192 | @@ -XXX,XX +XXX,XX @@ static int alle1_tlbmask(CPUARMState *env) | ||
193 | return ARMMMUIdxBit_SE10_1 | | ||
194 | ARMMMUIdxBit_SE10_1_PAN | | ||
195 | ARMMMUIdxBit_SE10_0; | ||
196 | - } else if (arm_feature(env, ARM_FEATURE_EL2)) { | ||
197 | - return ARMMMUIdxBit_E10_1 | | ||
198 | - ARMMMUIdxBit_E10_1_PAN | | ||
199 | - ARMMMUIdxBit_E10_0 | | ||
200 | - ARMMMUIdxBit_Stage2; | ||
201 | } else { | ||
202 | return ARMMMUIdxBit_E10_1 | | ||
203 | ARMMMUIdxBit_E10_1_PAN | | ||
204 | @@ -XXX,XX +XXX,XX @@ static void tlbi_aa64_vae3is_write(CPUARMState *env, const ARMCPRegInfo *ri, | ||
205 | ARMMMUIdxBit_SE3); | ||
206 | } | ||
207 | |||
208 | -static void tlbi_aa64_ipas2e1_write(CPUARMState *env, const ARMCPRegInfo *ri, | ||
209 | - uint64_t value) | ||
210 | -{ | ||
211 | - /* Invalidate by IPA. This has to invalidate any structures that | ||
212 | - * contain only stage 2 translation information, but does not need | ||
213 | - * to apply to structures that contain combined stage 1 and stage 2 | ||
214 | - * translation information. | ||
215 | - * This must NOP if EL2 isn't implemented or SCR_EL3.NS is zero. | ||
216 | - */ | ||
217 | - ARMCPU *cpu = env_archcpu(env); | ||
218 | - CPUState *cs = CPU(cpu); | ||
219 | - uint64_t pageaddr; | ||
220 | - | ||
221 | - if (!arm_feature(env, ARM_FEATURE_EL2) || !(env->cp15.scr_el3 & SCR_NS)) { | ||
222 | - return; | ||
223 | - } | ||
224 | - | ||
225 | - pageaddr = sextract64(value << 12, 0, 48); | ||
226 | - | ||
227 | - tlb_flush_page_by_mmuidx(cs, pageaddr, ARMMMUIdxBit_Stage2); | ||
228 | -} | ||
229 | - | ||
230 | -static void tlbi_aa64_ipas2e1is_write(CPUARMState *env, const ARMCPRegInfo *ri, | ||
231 | - uint64_t value) | ||
232 | -{ | ||
233 | - CPUState *cs = env_cpu(env); | ||
234 | - uint64_t pageaddr; | ||
235 | - | ||
236 | - if (!arm_feature(env, ARM_FEATURE_EL2) || !(env->cp15.scr_el3 & SCR_NS)) { | ||
237 | - return; | ||
238 | - } | ||
239 | - | ||
240 | - pageaddr = sextract64(value << 12, 0, 48); | ||
241 | - | ||
242 | - tlb_flush_page_by_mmuidx_all_cpus_synced(cs, pageaddr, | ||
243 | - ARMMMUIdxBit_Stage2); | ||
244 | -} | ||
245 | - | ||
246 | static CPAccessResult aa64_zva_access(CPUARMState *env, const ARMCPRegInfo *ri, | ||
247 | bool isread) | ||
248 | { | 142 | { |
249 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo v8_cp_reginfo[] = { | 143 | qbus_init(idebus, idebus_size, TYPE_IDE_BUS, dev, NULL); |
250 | .writefn = tlbi_aa64_vae1_write }, | 144 | diff --git a/hw/ide/sii3112.c b/hw/ide/sii3112.c |
251 | { .name = "TLBI_IPAS2E1IS", .state = ARM_CP_STATE_AA64, | 145 | index XXXXXXX..XXXXXXX 100644 |
252 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 0, .opc2 = 1, | 146 | --- a/hw/ide/sii3112.c |
253 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | 147 | +++ b/hw/ide/sii3112.c |
254 | - .writefn = tlbi_aa64_ipas2e1is_write }, | 148 | @@ -XXX,XX +XXX,XX @@ static void sii3112_pci_realize(PCIDevice *dev, Error **errp) |
255 | + .access = PL2_W, .type = ARM_CP_NOP }, | 149 | |
256 | { .name = "TLBI_IPAS2LE1IS", .state = ARM_CP_STATE_AA64, | 150 | qdev_init_gpio_in(ds, sii3112_set_irq, 2); |
257 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 0, .opc2 = 5, | 151 | for (i = 0; i < 2; i++) { |
258 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | 152 | - ide_bus_new(&s->bus[i], sizeof(s->bus[i]), ds, i, 1); |
259 | - .writefn = tlbi_aa64_ipas2e1is_write }, | 153 | + ide_bus_init(&s->bus[i], sizeof(s->bus[i]), ds, i, 1); |
260 | + .access = PL2_W, .type = ARM_CP_NOP }, | 154 | ide_init2(&s->bus[i], qdev_get_gpio_in(ds, i)); |
261 | { .name = "TLBI_ALLE1IS", .state = ARM_CP_STATE_AA64, | 155 | |
262 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 4, | 156 | bmdma_init(&s->bus[i], &s->bmdma[i], s); |
263 | .access = PL2_W, .type = ARM_CP_NO_RAW, | 157 | diff --git a/hw/ide/via.c b/hw/ide/via.c |
264 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo v8_cp_reginfo[] = { | 158 | index XXXXXXX..XXXXXXX 100644 |
265 | .writefn = tlbi_aa64_alle1is_write }, | 159 | --- a/hw/ide/via.c |
266 | { .name = "TLBI_IPAS2E1", .state = ARM_CP_STATE_AA64, | 160 | +++ b/hw/ide/via.c |
267 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 4, .opc2 = 1, | 161 | @@ -XXX,XX +XXX,XX @@ static void via_ide_realize(PCIDevice *dev, Error **errp) |
268 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | 162 | |
269 | - .writefn = tlbi_aa64_ipas2e1_write }, | 163 | qdev_init_gpio_in(ds, via_ide_set_irq, 2); |
270 | + .access = PL2_W, .type = ARM_CP_NOP }, | 164 | for (i = 0; i < 2; i++) { |
271 | { .name = "TLBI_IPAS2LE1", .state = ARM_CP_STATE_AA64, | 165 | - ide_bus_new(&d->bus[i], sizeof(d->bus[i]), ds, i, 2); |
272 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 4, .opc2 = 5, | 166 | + ide_bus_init(&d->bus[i], sizeof(d->bus[i]), ds, i, 2); |
273 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | 167 | ide_init2(&d->bus[i], qdev_get_gpio_in(ds, i)); |
274 | - .writefn = tlbi_aa64_ipas2e1_write }, | 168 | |
275 | + .access = PL2_W, .type = ARM_CP_NOP }, | 169 | bmdma_init(&d->bus[i], &d->bmdma[i], d); |
276 | { .name = "TLBI_ALLE1", .state = ARM_CP_STATE_AA64, | ||
277 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 4, | ||
278 | .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
279 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo v8_cp_reginfo[] = { | ||
280 | .writefn = tlbimva_hyp_is_write }, | ||
281 | { .name = "TLBIIPAS2", | ||
282 | .cp = 15, .opc1 = 4, .crn = 8, .crm = 4, .opc2 = 1, | ||
283 | - .type = ARM_CP_NO_RAW, .access = PL2_W, | ||
284 | - .writefn = tlbiipas2_write }, | ||
285 | + .type = ARM_CP_NOP, .access = PL2_W }, | ||
286 | { .name = "TLBIIPAS2IS", | ||
287 | .cp = 15, .opc1 = 4, .crn = 8, .crm = 0, .opc2 = 1, | ||
288 | - .type = ARM_CP_NO_RAW, .access = PL2_W, | ||
289 | - .writefn = tlbiipas2_is_write }, | ||
290 | + .type = ARM_CP_NOP, .access = PL2_W }, | ||
291 | { .name = "TLBIIPAS2L", | ||
292 | .cp = 15, .opc1 = 4, .crn = 8, .crm = 4, .opc2 = 5, | ||
293 | - .type = ARM_CP_NO_RAW, .access = PL2_W, | ||
294 | - .writefn = tlbiipas2_write }, | ||
295 | + .type = ARM_CP_NOP, .access = PL2_W }, | ||
296 | { .name = "TLBIIPAS2LIS", | ||
297 | .cp = 15, .opc1 = 4, .crn = 8, .crm = 0, .opc2 = 5, | ||
298 | - .type = ARM_CP_NO_RAW, .access = PL2_W, | ||
299 | - .writefn = tlbiipas2_is_write }, | ||
300 | + .type = ARM_CP_NOP, .access = PL2_W }, | ||
301 | /* 32 bit cache operations */ | ||
302 | { .name = "ICIALLUIS", .cp = 15, .opc1 = 0, .crn = 7, .crm = 1, .opc2 = 0, | ||
303 | .type = ARM_CP_NOP, .access = PL1_W, .accessfn = aa64_cacheop_pou_access }, | ||
304 | -- | 170 | -- |
305 | 2.20.1 | 171 | 2.20.1 |
306 | 172 | ||
307 | 173 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | In aarch64_max_initfn() we update both 32-bit and 64-bit ID | ||
2 | registers. The intended pattern is that for 64-bit ID registers we | ||
3 | use FIELD_DP64 and the uint64_t 't' register, while 32-bit ID | ||
4 | registers use FIELD_DP32 and the uint32_t 'u' register. For | ||
5 | ID_AA64DFR0 we accidentally used 'u', meaning that the top 32 bits of | ||
6 | this 64-bit ID register would end up always zero. Luckily at the | ||
7 | moment that's what they should be anyway, so this bug has no visible | ||
8 | effects. | ||
9 | 1 | ||
10 | Use the right-sized variable. | ||
11 | |||
12 | Fixes: 3bec78447a958d481991 | ||
13 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
14 | Reviewed-by: Laurent Desnogues <laurent.desnogues@gmail.com> | ||
15 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
16 | Message-id: 20200423110915.10527-1-peter.maydell@linaro.org | ||
17 | --- | ||
18 | target/arm/cpu64.c | 6 +++--- | ||
19 | 1 file changed, 3 insertions(+), 3 deletions(-) | ||
20 | |||
21 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | ||
22 | index XXXXXXX..XXXXXXX 100644 | ||
23 | --- a/target/arm/cpu64.c | ||
24 | +++ b/target/arm/cpu64.c | ||
25 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | ||
26 | u = FIELD_DP32(u, ID_MMFR4, XNX, 1); /* TTS2UXN */ | ||
27 | cpu->isar.id_mmfr4 = u; | ||
28 | |||
29 | - u = cpu->isar.id_aa64dfr0; | ||
30 | - u = FIELD_DP64(u, ID_AA64DFR0, PMUVER, 5); /* v8.4-PMU */ | ||
31 | - cpu->isar.id_aa64dfr0 = u; | ||
32 | + t = cpu->isar.id_aa64dfr0; | ||
33 | + t = FIELD_DP64(t, ID_AA64DFR0, PMUVER, 5); /* v8.4-PMU */ | ||
34 | + cpu->isar.id_aa64dfr0 = t; | ||
35 | |||
36 | u = cpu->isar.id_dfr0; | ||
37 | u = FIELD_DP32(u, ID_DFR0, PERFMON, 5); /* v8.4-PMU */ | ||
38 | -- | ||
39 | 2.20.1 | ||
40 | |||
41 | diff view generated by jsdifflib |
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | 1 | From: Xuzhou Cheng <xuzhou.cheng@windriver.com> |
---|---|---|---|
2 | 2 | ||
3 | Move misplaced comment. | 3 | The Linux spi-imx driver does not work on QEMU. The reason is that the |
4 | state of m25p80 loops in STATE_READING_DATA state after receiving | ||
5 | RDSR command, the new command is ignored. Before sending a new command, | ||
6 | CS line should be pulled high to make the state of m25p80 back to IDLE. | ||
4 | 7 | ||
5 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | 8 | Currently the SPI flash CS line is connected to the SPI controller, but |
6 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | 9 | on the real board, it's connected to GPIO3_19. This matches the ecspi1 |
10 | device node in the board dts. | ||
11 | |||
12 | ecspi1 node in imx6qdl-sabrelite.dtsi: | ||
13 | &ecspi1 { | ||
14 | cs-gpios = <&gpio3 19 GPIO_ACTIVE_LOW>; | ||
15 | pinctrl-names = "default"; | ||
16 | pinctrl-0 = <&pinctrl_ecspi1>; | ||
17 | status = "okay"; | ||
18 | |||
19 | flash: m25p80@0 { | ||
20 | compatible = "sst,sst25vf016b", "jedec,spi-nor"; | ||
21 | spi-max-frequency = <20000000>; | ||
22 | reg = <0>; | ||
23 | }; | ||
24 | }; | ||
25 | |||
26 | Should connect the SSI_GPIO_CS to GPIO3_19 when adding a spi-nor to | ||
27 | spi1 on sabrelite machine. | ||
28 | |||
29 | Verified this patch on Linux v5.14. | ||
30 | |||
31 | Logs: | ||
32 | # echo "01234567899876543210" > test | ||
33 | # mtd_debug erase /dev/mtd0 0x0 0x1000 | ||
34 | Erased 4096 bytes from address 0x00000000 in flash | ||
35 | # mtd_debug write /dev/mtdblock0 0x0 20 test | ||
36 | Copied 20 bytes from test to address 0x00000000 in flash | ||
37 | # mtd_debug read /dev/mtdblock0 0x0 20 test_out | ||
38 | Copied 20 bytes from address 0x00000000 in flash to test_out | ||
39 | # cat test_out | ||
40 | 01234567899876543210# | ||
41 | |||
42 | Signed-off-by: Xuzhou Cheng <xuzhou.cheng@windriver.com> | ||
43 | Reported-by: Guenter Roeck <linux@roeck-us.net> | ||
44 | Reviewed-by: Bin Meng <bin.meng@windriver.com> | ||
7 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | 45 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> |
8 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | 46 | Message-id: 20210927142825.491-1-xchengl.cn@gmail.com |
9 | Message-id: 20200427181649.26851-3-edgar.iglesias@gmail.com | ||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 47 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | --- | 48 | --- |
12 | hw/arm/xlnx-versal.c | 2 +- | 49 | hw/arm/sabrelite.c | 2 +- |
13 | 1 file changed, 1 insertion(+), 1 deletion(-) | 50 | 1 file changed, 1 insertion(+), 1 deletion(-) |
14 | 51 | ||
15 | diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c | 52 | diff --git a/hw/arm/sabrelite.c b/hw/arm/sabrelite.c |
16 | index XXXXXXX..XXXXXXX 100644 | 53 | index XXXXXXX..XXXXXXX 100644 |
17 | --- a/hw/arm/xlnx-versal.c | 54 | --- a/hw/arm/sabrelite.c |
18 | +++ b/hw/arm/xlnx-versal.c | 55 | +++ b/hw/arm/sabrelite.c |
19 | @@ -XXX,XX +XXX,XX @@ static void versal_create_apu_cpus(Versal *s) | 56 | @@ -XXX,XX +XXX,XX @@ static void sabrelite_init(MachineState *machine) |
20 | 57 | qdev_realize_and_unref(flash_dev, BUS(spi_bus), &error_fatal); | |
21 | obj = object_new(XLNX_VERSAL_ACPU_TYPE); | 58 | |
22 | if (!obj) { | 59 | cs_line = qdev_get_gpio_in_named(flash_dev, SSI_GPIO_CS, 0); |
23 | - /* Secondary CPUs start in PSCI powered-down state */ | 60 | - sysbus_connect_irq(SYS_BUS_DEVICE(spi_dev), 1, cs_line); |
24 | error_report("Unable to create apu.cpu[%d] of type %s", | 61 | + qdev_connect_gpio_out(DEVICE(&s->gpio[2]), 19, cs_line); |
25 | i, XLNX_VERSAL_ACPU_TYPE); | 62 | } |
26 | exit(EXIT_FAILURE); | ||
27 | @@ -XXX,XX +XXX,XX @@ static void versal_create_apu_cpus(Versal *s) | ||
28 | object_property_set_int(obj, s->cfg.psci_conduit, | ||
29 | "psci-conduit", &error_abort); | ||
30 | if (i) { | ||
31 | + /* Secondary CPUs start in PSCI powered-down state */ | ||
32 | object_property_set_bool(obj, true, | ||
33 | "start-powered-off", &error_abort); | ||
34 | } | 63 | } |
64 | } | ||
35 | -- | 65 | -- |
36 | 2.20.1 | 66 | 2.20.1 |
37 | 67 | ||
38 | 68 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | ||
2 | 1 | ||
3 | Embed the UARTs into the SoC type. | ||
4 | |||
5 | Suggested-by: Peter Maydell <peter.maydell@linaro.org> | ||
6 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | ||
7 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | ||
8 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
9 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | ||
10 | Message-id: 20200427181649.26851-5-edgar.iglesias@gmail.com | ||
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
12 | --- | ||
13 | include/hw/arm/xlnx-versal.h | 3 ++- | ||
14 | hw/arm/xlnx-versal.c | 12 ++++++------ | ||
15 | 2 files changed, 8 insertions(+), 7 deletions(-) | ||
16 | |||
17 | diff --git a/include/hw/arm/xlnx-versal.h b/include/hw/arm/xlnx-versal.h | ||
18 | index XXXXXXX..XXXXXXX 100644 | ||
19 | --- a/include/hw/arm/xlnx-versal.h | ||
20 | +++ b/include/hw/arm/xlnx-versal.h | ||
21 | @@ -XXX,XX +XXX,XX @@ | ||
22 | #include "hw/sysbus.h" | ||
23 | #include "hw/arm/boot.h" | ||
24 | #include "hw/intc/arm_gicv3.h" | ||
25 | +#include "hw/char/pl011.h" | ||
26 | |||
27 | #define TYPE_XLNX_VERSAL "xlnx-versal" | ||
28 | #define XLNX_VERSAL(obj) OBJECT_CHECK(Versal, (obj), TYPE_XLNX_VERSAL) | ||
29 | @@ -XXX,XX +XXX,XX @@ typedef struct Versal { | ||
30 | MemoryRegion mr_ocm; | ||
31 | |||
32 | struct { | ||
33 | - SysBusDevice *uart[XLNX_VERSAL_NR_UARTS]; | ||
34 | + PL011State uart[XLNX_VERSAL_NR_UARTS]; | ||
35 | SysBusDevice *gem[XLNX_VERSAL_NR_GEMS]; | ||
36 | SysBusDevice *adma[XLNX_VERSAL_NR_ADMAS]; | ||
37 | } iou; | ||
38 | diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c | ||
39 | index XXXXXXX..XXXXXXX 100644 | ||
40 | --- a/hw/arm/xlnx-versal.c | ||
41 | +++ b/hw/arm/xlnx-versal.c | ||
42 | @@ -XXX,XX +XXX,XX @@ | ||
43 | #include "kvm_arm.h" | ||
44 | #include "hw/misc/unimp.h" | ||
45 | #include "hw/arm/xlnx-versal.h" | ||
46 | -#include "hw/char/pl011.h" | ||
47 | |||
48 | #define XLNX_VERSAL_ACPU_TYPE ARM_CPU_TYPE_NAME("cortex-a72") | ||
49 | #define GEM_REVISION 0x40070106 | ||
50 | @@ -XXX,XX +XXX,XX @@ static void versal_create_uarts(Versal *s, qemu_irq *pic) | ||
51 | DeviceState *dev; | ||
52 | MemoryRegion *mr; | ||
53 | |||
54 | - dev = qdev_create(NULL, TYPE_PL011); | ||
55 | - s->lpd.iou.uart[i] = SYS_BUS_DEVICE(dev); | ||
56 | + sysbus_init_child_obj(OBJECT(s), name, | ||
57 | + &s->lpd.iou.uart[i], sizeof(s->lpd.iou.uart[i]), | ||
58 | + TYPE_PL011); | ||
59 | + dev = DEVICE(&s->lpd.iou.uart[i]); | ||
60 | qdev_prop_set_chr(dev, "chardev", serial_hd(i)); | ||
61 | - object_property_add_child(OBJECT(s), name, OBJECT(dev), &error_fatal); | ||
62 | qdev_init_nofail(dev); | ||
63 | |||
64 | - mr = sysbus_mmio_get_region(s->lpd.iou.uart[i], 0); | ||
65 | + mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0); | ||
66 | memory_region_add_subregion(&s->mr_ps, addrs[i], mr); | ||
67 | |||
68 | - sysbus_connect_irq(s->lpd.iou.uart[i], 0, pic[irqs[i]]); | ||
69 | + sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[irqs[i]]); | ||
70 | g_free(name); | ||
71 | } | ||
72 | } | ||
73 | -- | ||
74 | 2.20.1 | ||
75 | |||
76 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | ||
2 | 1 | ||
3 | Embed the GEMs into the SoC type. | ||
4 | |||
5 | Suggested-by: Peter Maydell <peter.maydell@linaro.org> | ||
6 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | ||
7 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | ||
8 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
9 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | ||
10 | Message-id: 20200427181649.26851-6-edgar.iglesias@gmail.com | ||
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
12 | --- | ||
13 | include/hw/arm/xlnx-versal.h | 3 ++- | ||
14 | hw/arm/xlnx-versal.c | 15 ++++++++------- | ||
15 | 2 files changed, 10 insertions(+), 8 deletions(-) | ||
16 | |||
17 | diff --git a/include/hw/arm/xlnx-versal.h b/include/hw/arm/xlnx-versal.h | ||
18 | index XXXXXXX..XXXXXXX 100644 | ||
19 | --- a/include/hw/arm/xlnx-versal.h | ||
20 | +++ b/include/hw/arm/xlnx-versal.h | ||
21 | @@ -XXX,XX +XXX,XX @@ | ||
22 | #include "hw/arm/boot.h" | ||
23 | #include "hw/intc/arm_gicv3.h" | ||
24 | #include "hw/char/pl011.h" | ||
25 | +#include "hw/net/cadence_gem.h" | ||
26 | |||
27 | #define TYPE_XLNX_VERSAL "xlnx-versal" | ||
28 | #define XLNX_VERSAL(obj) OBJECT_CHECK(Versal, (obj), TYPE_XLNX_VERSAL) | ||
29 | @@ -XXX,XX +XXX,XX @@ typedef struct Versal { | ||
30 | |||
31 | struct { | ||
32 | PL011State uart[XLNX_VERSAL_NR_UARTS]; | ||
33 | - SysBusDevice *gem[XLNX_VERSAL_NR_GEMS]; | ||
34 | + CadenceGEMState gem[XLNX_VERSAL_NR_GEMS]; | ||
35 | SysBusDevice *adma[XLNX_VERSAL_NR_ADMAS]; | ||
36 | } iou; | ||
37 | } lpd; | ||
38 | diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c | ||
39 | index XXXXXXX..XXXXXXX 100644 | ||
40 | --- a/hw/arm/xlnx-versal.c | ||
41 | +++ b/hw/arm/xlnx-versal.c | ||
42 | @@ -XXX,XX +XXX,XX @@ static void versal_create_gems(Versal *s, qemu_irq *pic) | ||
43 | DeviceState *dev; | ||
44 | MemoryRegion *mr; | ||
45 | |||
46 | - dev = qdev_create(NULL, "cadence_gem"); | ||
47 | - s->lpd.iou.gem[i] = SYS_BUS_DEVICE(dev); | ||
48 | - object_property_add_child(OBJECT(s), name, OBJECT(dev), &error_fatal); | ||
49 | + sysbus_init_child_obj(OBJECT(s), name, | ||
50 | + &s->lpd.iou.gem[i], sizeof(s->lpd.iou.gem[i]), | ||
51 | + TYPE_CADENCE_GEM); | ||
52 | + dev = DEVICE(&s->lpd.iou.gem[i]); | ||
53 | if (nd->used) { | ||
54 | qemu_check_nic_model(nd, "cadence_gem"); | ||
55 | qdev_set_nic_properties(dev, nd); | ||
56 | } | ||
57 | - object_property_set_int(OBJECT(s->lpd.iou.gem[i]), | ||
58 | + object_property_set_int(OBJECT(dev), | ||
59 | 2, "num-priority-queues", | ||
60 | &error_abort); | ||
61 | - object_property_set_link(OBJECT(s->lpd.iou.gem[i]), | ||
62 | + object_property_set_link(OBJECT(dev), | ||
63 | OBJECT(&s->mr_ps), "dma", | ||
64 | &error_abort); | ||
65 | qdev_init_nofail(dev); | ||
66 | |||
67 | - mr = sysbus_mmio_get_region(s->lpd.iou.gem[i], 0); | ||
68 | + mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0); | ||
69 | memory_region_add_subregion(&s->mr_ps, addrs[i], mr); | ||
70 | |||
71 | - sysbus_connect_irq(s->lpd.iou.gem[i], 0, pic[irqs[i]]); | ||
72 | + sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[irqs[i]]); | ||
73 | g_free(name); | ||
74 | } | ||
75 | } | ||
76 | -- | ||
77 | 2.20.1 | ||
78 | |||
79 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | From: "Edgar E. Iglesias" <edgar.iglesias@xilinx.com> | ||
2 | 1 | ||
3 | Embed the ADMAs into the SoC type. | ||
4 | |||
5 | Suggested-by: Peter Maydell <peter.maydell@linaro.org> | ||
6 | Signed-off-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> | ||
7 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> | ||
8 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
9 | Reviewed-by: Luc Michel <luc.michel@greensocs.com> | ||
10 | Message-id: 20200427181649.26851-7-edgar.iglesias@gmail.com | ||
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
12 | --- | ||
13 | include/hw/arm/xlnx-versal.h | 3 ++- | ||
14 | hw/arm/xlnx-versal.c | 14 +++++++------- | ||
15 | 2 files changed, 9 insertions(+), 8 deletions(-) | ||
16 | |||
17 | diff --git a/include/hw/arm/xlnx-versal.h b/include/hw/arm/xlnx-versal.h | ||
18 | index XXXXXXX..XXXXXXX 100644 | ||
19 | --- a/include/hw/arm/xlnx-versal.h | ||
20 | +++ b/include/hw/arm/xlnx-versal.h | ||
21 | @@ -XXX,XX +XXX,XX @@ | ||
22 | #include "hw/arm/boot.h" | ||
23 | #include "hw/intc/arm_gicv3.h" | ||
24 | #include "hw/char/pl011.h" | ||
25 | +#include "hw/dma/xlnx-zdma.h" | ||
26 | #include "hw/net/cadence_gem.h" | ||
27 | |||
28 | #define TYPE_XLNX_VERSAL "xlnx-versal" | ||
29 | @@ -XXX,XX +XXX,XX @@ typedef struct Versal { | ||
30 | struct { | ||
31 | PL011State uart[XLNX_VERSAL_NR_UARTS]; | ||
32 | CadenceGEMState gem[XLNX_VERSAL_NR_GEMS]; | ||
33 | - SysBusDevice *adma[XLNX_VERSAL_NR_ADMAS]; | ||
34 | + XlnxZDMA adma[XLNX_VERSAL_NR_ADMAS]; | ||
35 | } iou; | ||
36 | } lpd; | ||
37 | |||
38 | diff --git a/hw/arm/xlnx-versal.c b/hw/arm/xlnx-versal.c | ||
39 | index XXXXXXX..XXXXXXX 100644 | ||
40 | --- a/hw/arm/xlnx-versal.c | ||
41 | +++ b/hw/arm/xlnx-versal.c | ||
42 | @@ -XXX,XX +XXX,XX @@ static void versal_create_admas(Versal *s, qemu_irq *pic) | ||
43 | DeviceState *dev; | ||
44 | MemoryRegion *mr; | ||
45 | |||
46 | - dev = qdev_create(NULL, "xlnx.zdma"); | ||
47 | - s->lpd.iou.adma[i] = SYS_BUS_DEVICE(dev); | ||
48 | - object_property_set_int(OBJECT(s->lpd.iou.adma[i]), 128, "bus-width", | ||
49 | - &error_abort); | ||
50 | - object_property_add_child(OBJECT(s), name, OBJECT(dev), &error_fatal); | ||
51 | + sysbus_init_child_obj(OBJECT(s), name, | ||
52 | + &s->lpd.iou.adma[i], sizeof(s->lpd.iou.adma[i]), | ||
53 | + TYPE_XLNX_ZDMA); | ||
54 | + dev = DEVICE(&s->lpd.iou.adma[i]); | ||
55 | + object_property_set_int(OBJECT(dev), 128, "bus-width", &error_abort); | ||
56 | qdev_init_nofail(dev); | ||
57 | |||
58 | - mr = sysbus_mmio_get_region(s->lpd.iou.adma[i], 0); | ||
59 | + mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0); | ||
60 | memory_region_add_subregion(&s->mr_ps, | ||
61 | MM_ADMA_CH0 + i * MM_ADMA_CH0_SIZE, mr); | ||
62 | |||
63 | - sysbus_connect_irq(s->lpd.iou.adma[i], 0, pic[VERSAL_ADMA_IRQ_0 + i]); | ||
64 | + sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[VERSAL_ADMA_IRQ_0 + i]); | ||
65 | g_free(name); | ||
66 | } | ||
67 | } | ||
68 | -- | ||
69 | 2.20.1 | ||
70 | |||
71 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | We were accidentally permitting decode of Thumb Neon insns even if | ||
2 | the CPU didn't have the FEATURE_NEON bit set, because the feature | ||
3 | check was being done before the call to disas_neon_data_insn() and | ||
4 | disas_neon_ls_insn() in the Arm decoder but was omitted from the | ||
5 | Thumb decoder. Push the feature bit check down into the called | ||
6 | functions so it is done for both Arm and Thumb encodings. | ||
7 | 1 | ||
8 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
9 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
10 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
11 | Message-id: 20200430181003.21682-3-peter.maydell@linaro.org | ||
12 | --- | ||
13 | target/arm/translate.c | 16 ++++++++-------- | ||
14 | 1 file changed, 8 insertions(+), 8 deletions(-) | ||
15 | |||
16 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
17 | index XXXXXXX..XXXXXXX 100644 | ||
18 | --- a/target/arm/translate.c | ||
19 | +++ b/target/arm/translate.c | ||
20 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_ls_insn(DisasContext *s, uint32_t insn) | ||
21 | TCGv_i32 tmp2; | ||
22 | TCGv_i64 tmp64; | ||
23 | |||
24 | + if (!arm_dc_feature(s, ARM_FEATURE_NEON)) { | ||
25 | + return 1; | ||
26 | + } | ||
27 | + | ||
28 | /* FIXME: this access check should not take precedence over UNDEF | ||
29 | * for invalid encodings; we will generate incorrect syndrome information | ||
30 | * for attempts to execute invalid vfp/neon encodings with FP disabled. | ||
31 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
32 | TCGv_ptr ptr1, ptr2, ptr3; | ||
33 | TCGv_i64 tmp64; | ||
34 | |||
35 | + if (!arm_dc_feature(s, ARM_FEATURE_NEON)) { | ||
36 | + return 1; | ||
37 | + } | ||
38 | + | ||
39 | /* FIXME: this access check should not take precedence over UNDEF | ||
40 | * for invalid encodings; we will generate incorrect syndrome information | ||
41 | * for attempts to execute invalid vfp/neon encodings with FP disabled. | ||
42 | @@ -XXX,XX +XXX,XX @@ static void disas_arm_insn(DisasContext *s, unsigned int insn) | ||
43 | |||
44 | if (((insn >> 25) & 7) == 1) { | ||
45 | /* NEON Data processing. */ | ||
46 | - if (!arm_dc_feature(s, ARM_FEATURE_NEON)) { | ||
47 | - goto illegal_op; | ||
48 | - } | ||
49 | - | ||
50 | if (disas_neon_data_insn(s, insn)) { | ||
51 | goto illegal_op; | ||
52 | } | ||
53 | @@ -XXX,XX +XXX,XX @@ static void disas_arm_insn(DisasContext *s, unsigned int insn) | ||
54 | } | ||
55 | if ((insn & 0x0f100000) == 0x04000000) { | ||
56 | /* NEON load/store. */ | ||
57 | - if (!arm_dc_feature(s, ARM_FEATURE_NEON)) { | ||
58 | - goto illegal_op; | ||
59 | - } | ||
60 | - | ||
61 | if (disas_neon_ls_insn(s, insn)) { | ||
62 | goto illegal_op; | ||
63 | } | ||
64 | -- | ||
65 | 2.20.1 | ||
66 | |||
67 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the VCMLA (vector) insns in the 3same extension group to | ||
2 | decodetree. | ||
3 | 1 | ||
4 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
5 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
6 | Message-id: 20200430181003.21682-5-peter.maydell@linaro.org | ||
7 | --- | ||
8 | target/arm/neon-shared.decode | 11 ++++++++++ | ||
9 | target/arm/translate-neon.inc.c | 37 +++++++++++++++++++++++++++++++++ | ||
10 | target/arm/translate.c | 11 +--------- | ||
11 | 3 files changed, 49 insertions(+), 10 deletions(-) | ||
12 | |||
13 | diff --git a/target/arm/neon-shared.decode b/target/arm/neon-shared.decode | ||
14 | index XXXXXXX..XXXXXXX 100644 | ||
15 | --- a/target/arm/neon-shared.decode | ||
16 | +++ b/target/arm/neon-shared.decode | ||
17 | @@ -XXX,XX +XXX,XX @@ | ||
18 | # More specifically, this covers: | ||
19 | # 2reg scalar ext: 0b1111_1110_xxxx_xxxx_xxxx_1x0x_xxxx_xxxx | ||
20 | # 3same ext: 0b1111_110x_xxxx_xxxx_xxxx_1x0x_xxxx_xxxx | ||
21 | + | ||
22 | +# VFP/Neon register fields; same as vfp.decode | ||
23 | +%vm_dp 5:1 0:4 | ||
24 | +%vm_sp 0:4 5:1 | ||
25 | +%vn_dp 7:1 16:4 | ||
26 | +%vn_sp 16:4 7:1 | ||
27 | +%vd_dp 22:1 12:4 | ||
28 | +%vd_sp 12:4 22:1 | ||
29 | + | ||
30 | +VCMLA 1111 110 rot:2 . 1 size:1 .... .... 1000 . q:1 . 0 .... \ | ||
31 | + vm=%vm_dp vn=%vn_dp vd=%vd_dp | ||
32 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
33 | index XXXXXXX..XXXXXXX 100644 | ||
34 | --- a/target/arm/translate-neon.inc.c | ||
35 | +++ b/target/arm/translate-neon.inc.c | ||
36 | @@ -XXX,XX +XXX,XX @@ | ||
37 | #include "decode-neon-dp.inc.c" | ||
38 | #include "decode-neon-ls.inc.c" | ||
39 | #include "decode-neon-shared.inc.c" | ||
40 | + | ||
41 | +static bool trans_VCMLA(DisasContext *s, arg_VCMLA *a) | ||
42 | +{ | ||
43 | + int opr_sz; | ||
44 | + TCGv_ptr fpst; | ||
45 | + gen_helper_gvec_3_ptr *fn_gvec_ptr; | ||
46 | + | ||
47 | + if (!dc_isar_feature(aa32_vcma, s) | ||
48 | + || (!a->size && !dc_isar_feature(aa32_fp16_arith, s))) { | ||
49 | + return false; | ||
50 | + } | ||
51 | + | ||
52 | + /* UNDEF accesses to D16-D31 if they don't exist. */ | ||
53 | + if (!dc_isar_feature(aa32_simd_r32, s) && | ||
54 | + ((a->vd | a->vn | a->vm) & 0x10)) { | ||
55 | + return false; | ||
56 | + } | ||
57 | + | ||
58 | + if ((a->vn | a->vm | a->vd) & a->q) { | ||
59 | + return false; | ||
60 | + } | ||
61 | + | ||
62 | + if (!vfp_access_check(s)) { | ||
63 | + return true; | ||
64 | + } | ||
65 | + | ||
66 | + opr_sz = (1 + a->q) * 8; | ||
67 | + fpst = get_fpstatus_ptr(1); | ||
68 | + fn_gvec_ptr = a->size ? gen_helper_gvec_fcmlas : gen_helper_gvec_fcmlah; | ||
69 | + tcg_gen_gvec_3_ptr(vfp_reg_offset(1, a->vd), | ||
70 | + vfp_reg_offset(1, a->vn), | ||
71 | + vfp_reg_offset(1, a->vm), | ||
72 | + fpst, opr_sz, opr_sz, a->rot, | ||
73 | + fn_gvec_ptr); | ||
74 | + tcg_temp_free_ptr(fpst); | ||
75 | + return true; | ||
76 | +} | ||
77 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
78 | index XXXXXXX..XXXXXXX 100644 | ||
79 | --- a/target/arm/translate.c | ||
80 | +++ b/target/arm/translate.c | ||
81 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_insn_3same_ext(DisasContext *s, uint32_t insn) | ||
82 | bool is_long = false, q = extract32(insn, 6, 1); | ||
83 | bool ptr_is_env = false; | ||
84 | |||
85 | - if ((insn & 0xfe200f10) == 0xfc200800) { | ||
86 | - /* VCMLA -- 1111 110R R.1S .... .... 1000 ...0 .... */ | ||
87 | - int size = extract32(insn, 20, 1); | ||
88 | - data = extract32(insn, 23, 2); /* rot */ | ||
89 | - if (!dc_isar_feature(aa32_vcma, s) | ||
90 | - || (!size && !dc_isar_feature(aa32_fp16_arith, s))) { | ||
91 | - return 1; | ||
92 | - } | ||
93 | - fn_gvec_ptr = size ? gen_helper_gvec_fcmlas : gen_helper_gvec_fcmlah; | ||
94 | - } else if ((insn & 0xfea00f10) == 0xfc800800) { | ||
95 | + if ((insn & 0xfea00f10) == 0xfc800800) { | ||
96 | /* VCADD -- 1111 110R 1.0S .... .... 1000 ...0 .... */ | ||
97 | int size = extract32(insn, 20, 1); | ||
98 | data = extract32(insn, 24, 1); /* rot */ | ||
99 | -- | ||
100 | 2.20.1 | ||
101 | |||
102 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the VCADD (vector) insns to decodetree. | ||
2 | 1 | ||
3 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
4 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
5 | Message-id: 20200430181003.21682-6-peter.maydell@linaro.org | ||
6 | --- | ||
7 | target/arm/neon-shared.decode | 3 +++ | ||
8 | target/arm/translate-neon.inc.c | 37 +++++++++++++++++++++++++++++++++ | ||
9 | target/arm/translate.c | 11 +--------- | ||
10 | 3 files changed, 41 insertions(+), 10 deletions(-) | ||
11 | |||
12 | diff --git a/target/arm/neon-shared.decode b/target/arm/neon-shared.decode | ||
13 | index XXXXXXX..XXXXXXX 100644 | ||
14 | --- a/target/arm/neon-shared.decode | ||
15 | +++ b/target/arm/neon-shared.decode | ||
16 | @@ -XXX,XX +XXX,XX @@ | ||
17 | |||
18 | VCMLA 1111 110 rot:2 . 1 size:1 .... .... 1000 . q:1 . 0 .... \ | ||
19 | vm=%vm_dp vn=%vn_dp vd=%vd_dp | ||
20 | + | ||
21 | +VCADD 1111 110 rot:1 1 . 0 size:1 .... .... 1000 . q:1 . 0 .... \ | ||
22 | + vm=%vm_dp vn=%vn_dp vd=%vd_dp | ||
23 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
24 | index XXXXXXX..XXXXXXX 100644 | ||
25 | --- a/target/arm/translate-neon.inc.c | ||
26 | +++ b/target/arm/translate-neon.inc.c | ||
27 | @@ -XXX,XX +XXX,XX @@ static bool trans_VCMLA(DisasContext *s, arg_VCMLA *a) | ||
28 | tcg_temp_free_ptr(fpst); | ||
29 | return true; | ||
30 | } | ||
31 | + | ||
32 | +static bool trans_VCADD(DisasContext *s, arg_VCADD *a) | ||
33 | +{ | ||
34 | + int opr_sz; | ||
35 | + TCGv_ptr fpst; | ||
36 | + gen_helper_gvec_3_ptr *fn_gvec_ptr; | ||
37 | + | ||
38 | + if (!dc_isar_feature(aa32_vcma, s) | ||
39 | + || (!a->size && !dc_isar_feature(aa32_fp16_arith, s))) { | ||
40 | + return false; | ||
41 | + } | ||
42 | + | ||
43 | + /* UNDEF accesses to D16-D31 if they don't exist. */ | ||
44 | + if (!dc_isar_feature(aa32_simd_r32, s) && | ||
45 | + ((a->vd | a->vn | a->vm) & 0x10)) { | ||
46 | + return false; | ||
47 | + } | ||
48 | + | ||
49 | + if ((a->vn | a->vm | a->vd) & a->q) { | ||
50 | + return false; | ||
51 | + } | ||
52 | + | ||
53 | + if (!vfp_access_check(s)) { | ||
54 | + return true; | ||
55 | + } | ||
56 | + | ||
57 | + opr_sz = (1 + a->q) * 8; | ||
58 | + fpst = get_fpstatus_ptr(1); | ||
59 | + fn_gvec_ptr = a->size ? gen_helper_gvec_fcadds : gen_helper_gvec_fcaddh; | ||
60 | + tcg_gen_gvec_3_ptr(vfp_reg_offset(1, a->vd), | ||
61 | + vfp_reg_offset(1, a->vn), | ||
62 | + vfp_reg_offset(1, a->vm), | ||
63 | + fpst, opr_sz, opr_sz, a->rot, | ||
64 | + fn_gvec_ptr); | ||
65 | + tcg_temp_free_ptr(fpst); | ||
66 | + return true; | ||
67 | +} | ||
68 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
69 | index XXXXXXX..XXXXXXX 100644 | ||
70 | --- a/target/arm/translate.c | ||
71 | +++ b/target/arm/translate.c | ||
72 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_insn_3same_ext(DisasContext *s, uint32_t insn) | ||
73 | bool is_long = false, q = extract32(insn, 6, 1); | ||
74 | bool ptr_is_env = false; | ||
75 | |||
76 | - if ((insn & 0xfea00f10) == 0xfc800800) { | ||
77 | - /* VCADD -- 1111 110R 1.0S .... .... 1000 ...0 .... */ | ||
78 | - int size = extract32(insn, 20, 1); | ||
79 | - data = extract32(insn, 24, 1); /* rot */ | ||
80 | - if (!dc_isar_feature(aa32_vcma, s) | ||
81 | - || (!size && !dc_isar_feature(aa32_fp16_arith, s))) { | ||
82 | - return 1; | ||
83 | - } | ||
84 | - fn_gvec_ptr = size ? gen_helper_gvec_fcadds : gen_helper_gvec_fcaddh; | ||
85 | - } else if ((insn & 0xfeb00f00) == 0xfc200d00) { | ||
86 | + if ((insn & 0xfeb00f00) == 0xfc200d00) { | ||
87 | /* V[US]DOT -- 1111 1100 0.10 .... .... 1101 .Q.U .... */ | ||
88 | bool u = extract32(insn, 4, 1); | ||
89 | if (!dc_isar_feature(aa32_dp, s)) { | ||
90 | -- | ||
91 | 2.20.1 | ||
92 | |||
93 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the V[US]DOT (vector) insns to decodetree. | ||
2 | 1 | ||
3 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
4 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
5 | Message-id: 20200430181003.21682-7-peter.maydell@linaro.org | ||
6 | --- | ||
7 | target/arm/neon-shared.decode | 4 ++++ | ||
8 | target/arm/translate-neon.inc.c | 32 ++++++++++++++++++++++++++++++++ | ||
9 | target/arm/translate.c | 9 +-------- | ||
10 | 3 files changed, 37 insertions(+), 8 deletions(-) | ||
11 | |||
12 | diff --git a/target/arm/neon-shared.decode b/target/arm/neon-shared.decode | ||
13 | index XXXXXXX..XXXXXXX 100644 | ||
14 | --- a/target/arm/neon-shared.decode | ||
15 | +++ b/target/arm/neon-shared.decode | ||
16 | @@ -XXX,XX +XXX,XX @@ VCMLA 1111 110 rot:2 . 1 size:1 .... .... 1000 . q:1 . 0 .... \ | ||
17 | |||
18 | VCADD 1111 110 rot:1 1 . 0 size:1 .... .... 1000 . q:1 . 0 .... \ | ||
19 | vm=%vm_dp vn=%vn_dp vd=%vd_dp | ||
20 | + | ||
21 | +# VUDOT and VSDOT | ||
22 | +VDOT 1111 110 00 . 10 .... .... 1101 . q:1 . u:1 .... \ | ||
23 | + vm=%vm_dp vn=%vn_dp vd=%vd_dp | ||
24 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
25 | index XXXXXXX..XXXXXXX 100644 | ||
26 | --- a/target/arm/translate-neon.inc.c | ||
27 | +++ b/target/arm/translate-neon.inc.c | ||
28 | @@ -XXX,XX +XXX,XX @@ static bool trans_VCADD(DisasContext *s, arg_VCADD *a) | ||
29 | tcg_temp_free_ptr(fpst); | ||
30 | return true; | ||
31 | } | ||
32 | + | ||
33 | +static bool trans_VDOT(DisasContext *s, arg_VDOT *a) | ||
34 | +{ | ||
35 | + int opr_sz; | ||
36 | + gen_helper_gvec_3 *fn_gvec; | ||
37 | + | ||
38 | + if (!dc_isar_feature(aa32_dp, s)) { | ||
39 | + return false; | ||
40 | + } | ||
41 | + | ||
42 | + /* UNDEF accesses to D16-D31 if they don't exist. */ | ||
43 | + if (!dc_isar_feature(aa32_simd_r32, s) && | ||
44 | + ((a->vd | a->vn | a->vm) & 0x10)) { | ||
45 | + return false; | ||
46 | + } | ||
47 | + | ||
48 | + if ((a->vn | a->vm | a->vd) & a->q) { | ||
49 | + return false; | ||
50 | + } | ||
51 | + | ||
52 | + if (!vfp_access_check(s)) { | ||
53 | + return true; | ||
54 | + } | ||
55 | + | ||
56 | + opr_sz = (1 + a->q) * 8; | ||
57 | + fn_gvec = a->u ? gen_helper_gvec_udot_b : gen_helper_gvec_sdot_b; | ||
58 | + tcg_gen_gvec_3_ool(vfp_reg_offset(1, a->vd), | ||
59 | + vfp_reg_offset(1, a->vn), | ||
60 | + vfp_reg_offset(1, a->vm), | ||
61 | + opr_sz, opr_sz, 0, fn_gvec); | ||
62 | + return true; | ||
63 | +} | ||
64 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
65 | index XXXXXXX..XXXXXXX 100644 | ||
66 | --- a/target/arm/translate.c | ||
67 | +++ b/target/arm/translate.c | ||
68 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_insn_3same_ext(DisasContext *s, uint32_t insn) | ||
69 | bool is_long = false, q = extract32(insn, 6, 1); | ||
70 | bool ptr_is_env = false; | ||
71 | |||
72 | - if ((insn & 0xfeb00f00) == 0xfc200d00) { | ||
73 | - /* V[US]DOT -- 1111 1100 0.10 .... .... 1101 .Q.U .... */ | ||
74 | - bool u = extract32(insn, 4, 1); | ||
75 | - if (!dc_isar_feature(aa32_dp, s)) { | ||
76 | - return 1; | ||
77 | - } | ||
78 | - fn_gvec = u ? gen_helper_gvec_udot_b : gen_helper_gvec_sdot_b; | ||
79 | - } else if ((insn & 0xff300f10) == 0xfc200810) { | ||
80 | + if ((insn & 0xff300f10) == 0xfc200810) { | ||
81 | /* VFM[AS]L -- 1111 1100 S.10 .... .... 1000 .Q.1 .... */ | ||
82 | int is_s = extract32(insn, 23, 1); | ||
83 | if (!dc_isar_feature(aa32_fhm, s)) { | ||
84 | -- | ||
85 | 2.20.1 | ||
86 | |||
87 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the VFM[AS]L (vector) insns to decodetree. This is the last | ||
2 | insn in the legacy decoder for the 3same_ext group, so we can | ||
3 | delete the legacy decoder function for the group entirely. | ||
4 | 1 | ||
5 | Note that in disas_thumb2_insn() the parts of this encoding space | ||
6 | where the decodetree decoder returns false will correctly be directed | ||
7 | to illegal_op by the "(insn & (1 << 28))" check so they won't fall | ||
8 | into disas_coproc_insn() by mistake. | ||
9 | |||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
11 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
12 | Message-id: 20200430181003.21682-8-peter.maydell@linaro.org | ||
13 | --- | ||
14 | target/arm/neon-shared.decode | 6 +++ | ||
15 | target/arm/translate-neon.inc.c | 31 +++++++++++ | ||
16 | target/arm/translate.c | 92 +-------------------------------- | ||
17 | 3 files changed, 38 insertions(+), 91 deletions(-) | ||
18 | |||
19 | diff --git a/target/arm/neon-shared.decode b/target/arm/neon-shared.decode | ||
20 | index XXXXXXX..XXXXXXX 100644 | ||
21 | --- a/target/arm/neon-shared.decode | ||
22 | +++ b/target/arm/neon-shared.decode | ||
23 | @@ -XXX,XX +XXX,XX @@ VCADD 1111 110 rot:1 1 . 0 size:1 .... .... 1000 . q:1 . 0 .... \ | ||
24 | # VUDOT and VSDOT | ||
25 | VDOT 1111 110 00 . 10 .... .... 1101 . q:1 . u:1 .... \ | ||
26 | vm=%vm_dp vn=%vn_dp vd=%vd_dp | ||
27 | + | ||
28 | +# VFM[AS]L | ||
29 | +VFML 1111 110 0 s:1 . 10 .... .... 1000 . 0 . 1 .... \ | ||
30 | + vm=%vm_sp vn=%vn_sp vd=%vd_dp q=0 | ||
31 | +VFML 1111 110 0 s:1 . 10 .... .... 1000 . 1 . 1 .... \ | ||
32 | + vm=%vm_dp vn=%vn_dp vd=%vd_dp q=1 | ||
33 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
34 | index XXXXXXX..XXXXXXX 100644 | ||
35 | --- a/target/arm/translate-neon.inc.c | ||
36 | +++ b/target/arm/translate-neon.inc.c | ||
37 | @@ -XXX,XX +XXX,XX @@ static bool trans_VDOT(DisasContext *s, arg_VDOT *a) | ||
38 | opr_sz, opr_sz, 0, fn_gvec); | ||
39 | return true; | ||
40 | } | ||
41 | + | ||
42 | +static bool trans_VFML(DisasContext *s, arg_VFML *a) | ||
43 | +{ | ||
44 | + int opr_sz; | ||
45 | + | ||
46 | + if (!dc_isar_feature(aa32_fhm, s)) { | ||
47 | + return false; | ||
48 | + } | ||
49 | + | ||
50 | + /* UNDEF accesses to D16-D31 if they don't exist. */ | ||
51 | + if (!dc_isar_feature(aa32_simd_r32, s) && | ||
52 | + (a->vd & 0x10)) { | ||
53 | + return false; | ||
54 | + } | ||
55 | + | ||
56 | + if (a->vd & a->q) { | ||
57 | + return false; | ||
58 | + } | ||
59 | + | ||
60 | + if (!vfp_access_check(s)) { | ||
61 | + return true; | ||
62 | + } | ||
63 | + | ||
64 | + opr_sz = (1 + a->q) * 8; | ||
65 | + tcg_gen_gvec_3_ptr(vfp_reg_offset(1, a->vd), | ||
66 | + vfp_reg_offset(a->q, a->vn), | ||
67 | + vfp_reg_offset(a->q, a->vm), | ||
68 | + cpu_env, opr_sz, opr_sz, a->s, /* is_2 == 0 */ | ||
69 | + gen_helper_gvec_fmlal_a32); | ||
70 | + return true; | ||
71 | +} | ||
72 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
73 | index XXXXXXX..XXXXXXX 100644 | ||
74 | --- a/target/arm/translate.c | ||
75 | +++ b/target/arm/translate.c | ||
76 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
77 | return 0; | ||
78 | } | ||
79 | |||
80 | -/* Advanced SIMD three registers of the same length extension. | ||
81 | - * 31 25 23 22 20 16 12 11 10 9 8 3 0 | ||
82 | - * +---------------+-----+---+-----+----+----+---+----+---+----+---------+----+ | ||
83 | - * | 1 1 1 1 1 1 0 | op1 | D | op2 | Vn | Vd | 1 | o3 | 0 | o4 | N Q M U | Vm | | ||
84 | - * +---------------+-----+---+-----+----+----+---+----+---+----+---------+----+ | ||
85 | - */ | ||
86 | -static int disas_neon_insn_3same_ext(DisasContext *s, uint32_t insn) | ||
87 | -{ | ||
88 | - gen_helper_gvec_3 *fn_gvec = NULL; | ||
89 | - gen_helper_gvec_3_ptr *fn_gvec_ptr = NULL; | ||
90 | - int rd, rn, rm, opr_sz; | ||
91 | - int data = 0; | ||
92 | - int off_rn, off_rm; | ||
93 | - bool is_long = false, q = extract32(insn, 6, 1); | ||
94 | - bool ptr_is_env = false; | ||
95 | - | ||
96 | - if ((insn & 0xff300f10) == 0xfc200810) { | ||
97 | - /* VFM[AS]L -- 1111 1100 S.10 .... .... 1000 .Q.1 .... */ | ||
98 | - int is_s = extract32(insn, 23, 1); | ||
99 | - if (!dc_isar_feature(aa32_fhm, s)) { | ||
100 | - return 1; | ||
101 | - } | ||
102 | - is_long = true; | ||
103 | - data = is_s; /* is_2 == 0 */ | ||
104 | - fn_gvec_ptr = gen_helper_gvec_fmlal_a32; | ||
105 | - ptr_is_env = true; | ||
106 | - } else { | ||
107 | - return 1; | ||
108 | - } | ||
109 | - | ||
110 | - VFP_DREG_D(rd, insn); | ||
111 | - if (rd & q) { | ||
112 | - return 1; | ||
113 | - } | ||
114 | - if (q || !is_long) { | ||
115 | - VFP_DREG_N(rn, insn); | ||
116 | - VFP_DREG_M(rm, insn); | ||
117 | - if ((rn | rm) & q & !is_long) { | ||
118 | - return 1; | ||
119 | - } | ||
120 | - off_rn = vfp_reg_offset(1, rn); | ||
121 | - off_rm = vfp_reg_offset(1, rm); | ||
122 | - } else { | ||
123 | - rn = VFP_SREG_N(insn); | ||
124 | - rm = VFP_SREG_M(insn); | ||
125 | - off_rn = vfp_reg_offset(0, rn); | ||
126 | - off_rm = vfp_reg_offset(0, rm); | ||
127 | - } | ||
128 | - | ||
129 | - if (s->fp_excp_el) { | ||
130 | - gen_exception_insn(s, s->pc_curr, EXCP_UDEF, | ||
131 | - syn_simd_access_trap(1, 0xe, false), s->fp_excp_el); | ||
132 | - return 0; | ||
133 | - } | ||
134 | - if (!s->vfp_enabled) { | ||
135 | - return 1; | ||
136 | - } | ||
137 | - | ||
138 | - opr_sz = (1 + q) * 8; | ||
139 | - if (fn_gvec_ptr) { | ||
140 | - TCGv_ptr ptr; | ||
141 | - if (ptr_is_env) { | ||
142 | - ptr = cpu_env; | ||
143 | - } else { | ||
144 | - ptr = get_fpstatus_ptr(1); | ||
145 | - } | ||
146 | - tcg_gen_gvec_3_ptr(vfp_reg_offset(1, rd), off_rn, off_rm, ptr, | ||
147 | - opr_sz, opr_sz, data, fn_gvec_ptr); | ||
148 | - if (!ptr_is_env) { | ||
149 | - tcg_temp_free_ptr(ptr); | ||
150 | - } | ||
151 | - } else { | ||
152 | - tcg_gen_gvec_3_ool(vfp_reg_offset(1, rd), off_rn, off_rm, | ||
153 | - opr_sz, opr_sz, data, fn_gvec); | ||
154 | - } | ||
155 | - return 0; | ||
156 | -} | ||
157 | - | ||
158 | /* Advanced SIMD two registers and a scalar extension. | ||
159 | * 31 24 23 22 20 16 12 11 10 9 8 3 0 | ||
160 | * +-----------------+----+---+----+----+----+---+----+---+----+---------+----+ | ||
161 | @@ -XXX,XX +XXX,XX @@ static void disas_arm_insn(DisasContext *s, unsigned int insn) | ||
162 | } | ||
163 | } | ||
164 | } | ||
165 | - } else if ((insn & 0x0e000a00) == 0x0c000800 | ||
166 | - && arm_dc_feature(s, ARM_FEATURE_V8)) { | ||
167 | - if (disas_neon_insn_3same_ext(s, insn)) { | ||
168 | - goto illegal_op; | ||
169 | - } | ||
170 | - return; | ||
171 | } else if ((insn & 0x0f000a00) == 0x0e000800 | ||
172 | && arm_dc_feature(s, ARM_FEATURE_V8)) { | ||
173 | if (disas_neon_insn_2reg_scalar_ext(s, insn)) { | ||
174 | @@ -XXX,XX +XXX,XX @@ static void disas_thumb2_insn(DisasContext *s, uint32_t insn) | ||
175 | } | ||
176 | break; | ||
177 | } | ||
178 | - if ((insn & 0xfe000a00) == 0xfc000800 | ||
179 | + if ((insn & 0xff000a00) == 0xfe000800 | ||
180 | && arm_dc_feature(s, ARM_FEATURE_V8)) { | ||
181 | /* The Thumb2 and ARM encodings are identical. */ | ||
182 | - if (disas_neon_insn_3same_ext(s, insn)) { | ||
183 | - goto illegal_op; | ||
184 | - } | ||
185 | - } else if ((insn & 0xff000a00) == 0xfe000800 | ||
186 | - && arm_dc_feature(s, ARM_FEATURE_V8)) { | ||
187 | - /* The Thumb2 and ARM encodings are identical. */ | ||
188 | if (disas_neon_insn_2reg_scalar_ext(s, insn)) { | ||
189 | goto illegal_op; | ||
190 | } | ||
191 | -- | ||
192 | 2.20.1 | ||
193 | |||
194 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert VCMLA (scalar) in the 2reg-scalar-ext group to decodetree. | ||
2 | 1 | ||
3 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
4 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
5 | Message-id: 20200430181003.21682-9-peter.maydell@linaro.org | ||
6 | --- | ||
7 | target/arm/neon-shared.decode | 5 +++++ | ||
8 | target/arm/translate-neon.inc.c | 40 +++++++++++++++++++++++++++++++++ | ||
9 | target/arm/translate.c | 26 +-------------------- | ||
10 | 3 files changed, 46 insertions(+), 25 deletions(-) | ||
11 | |||
12 | diff --git a/target/arm/neon-shared.decode b/target/arm/neon-shared.decode | ||
13 | index XXXXXXX..XXXXXXX 100644 | ||
14 | --- a/target/arm/neon-shared.decode | ||
15 | +++ b/target/arm/neon-shared.decode | ||
16 | @@ -XXX,XX +XXX,XX @@ VFML 1111 110 0 s:1 . 10 .... .... 1000 . 0 . 1 .... \ | ||
17 | vm=%vm_sp vn=%vn_sp vd=%vd_dp q=0 | ||
18 | VFML 1111 110 0 s:1 . 10 .... .... 1000 . 1 . 1 .... \ | ||
19 | vm=%vm_dp vn=%vn_dp vd=%vd_dp q=1 | ||
20 | + | ||
21 | +VCMLA_scalar 1111 1110 0 . rot:2 .... .... 1000 . q:1 index:1 0 vm:4 \ | ||
22 | + vn=%vn_dp vd=%vd_dp size=0 | ||
23 | +VCMLA_scalar 1111 1110 1 . rot:2 .... .... 1000 . q:1 . 0 .... \ | ||
24 | + vm=%vm_dp vn=%vn_dp vd=%vd_dp size=1 index=0 | ||
25 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
26 | index XXXXXXX..XXXXXXX 100644 | ||
27 | --- a/target/arm/translate-neon.inc.c | ||
28 | +++ b/target/arm/translate-neon.inc.c | ||
29 | @@ -XXX,XX +XXX,XX @@ static bool trans_VFML(DisasContext *s, arg_VFML *a) | ||
30 | gen_helper_gvec_fmlal_a32); | ||
31 | return true; | ||
32 | } | ||
33 | + | ||
34 | +static bool trans_VCMLA_scalar(DisasContext *s, arg_VCMLA_scalar *a) | ||
35 | +{ | ||
36 | + gen_helper_gvec_3_ptr *fn_gvec_ptr; | ||
37 | + int opr_sz; | ||
38 | + TCGv_ptr fpst; | ||
39 | + | ||
40 | + if (!dc_isar_feature(aa32_vcma, s)) { | ||
41 | + return false; | ||
42 | + } | ||
43 | + if (a->size == 0 && !dc_isar_feature(aa32_fp16_arith, s)) { | ||
44 | + return false; | ||
45 | + } | ||
46 | + | ||
47 | + /* UNDEF accesses to D16-D31 if they don't exist. */ | ||
48 | + if (!dc_isar_feature(aa32_simd_r32, s) && | ||
49 | + ((a->vd | a->vn | a->vm) & 0x10)) { | ||
50 | + return false; | ||
51 | + } | ||
52 | + | ||
53 | + if ((a->vd | a->vn) & a->q) { | ||
54 | + return false; | ||
55 | + } | ||
56 | + | ||
57 | + if (!vfp_access_check(s)) { | ||
58 | + return true; | ||
59 | + } | ||
60 | + | ||
61 | + fn_gvec_ptr = (a->size ? gen_helper_gvec_fcmlas_idx | ||
62 | + : gen_helper_gvec_fcmlah_idx); | ||
63 | + opr_sz = (1 + a->q) * 8; | ||
64 | + fpst = get_fpstatus_ptr(1); | ||
65 | + tcg_gen_gvec_3_ptr(vfp_reg_offset(1, a->vd), | ||
66 | + vfp_reg_offset(1, a->vn), | ||
67 | + vfp_reg_offset(1, a->vm), | ||
68 | + fpst, opr_sz, opr_sz, | ||
69 | + (a->index << 2) | a->rot, fn_gvec_ptr); | ||
70 | + tcg_temp_free_ptr(fpst); | ||
71 | + return true; | ||
72 | +} | ||
73 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
74 | index XXXXXXX..XXXXXXX 100644 | ||
75 | --- a/target/arm/translate.c | ||
76 | +++ b/target/arm/translate.c | ||
77 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_insn_2reg_scalar_ext(DisasContext *s, uint32_t insn) | ||
78 | bool is_long = false, q = extract32(insn, 6, 1); | ||
79 | bool ptr_is_env = false; | ||
80 | |||
81 | - if ((insn & 0xff000f10) == 0xfe000800) { | ||
82 | - /* VCMLA (indexed) -- 1111 1110 S.RR .... .... 1000 ...0 .... */ | ||
83 | - int rot = extract32(insn, 20, 2); | ||
84 | - int size = extract32(insn, 23, 1); | ||
85 | - int index; | ||
86 | - | ||
87 | - if (!dc_isar_feature(aa32_vcma, s)) { | ||
88 | - return 1; | ||
89 | - } | ||
90 | - if (size == 0) { | ||
91 | - if (!dc_isar_feature(aa32_fp16_arith, s)) { | ||
92 | - return 1; | ||
93 | - } | ||
94 | - /* For fp16, rm is just Vm, and index is M. */ | ||
95 | - rm = extract32(insn, 0, 4); | ||
96 | - index = extract32(insn, 5, 1); | ||
97 | - } else { | ||
98 | - /* For fp32, rm is the usual M:Vm, and index is 0. */ | ||
99 | - VFP_DREG_M(rm, insn); | ||
100 | - index = 0; | ||
101 | - } | ||
102 | - data = (index << 2) | rot; | ||
103 | - fn_gvec_ptr = (size ? gen_helper_gvec_fcmlas_idx | ||
104 | - : gen_helper_gvec_fcmlah_idx); | ||
105 | - } else if ((insn & 0xffb00f00) == 0xfe200d00) { | ||
106 | + if ((insn & 0xffb00f00) == 0xfe200d00) { | ||
107 | /* V[US]DOT -- 1111 1110 0.10 .... .... 1101 .Q.U .... */ | ||
108 | int u = extract32(insn, 4, 1); | ||
109 | |||
110 | -- | ||
111 | 2.20.1 | ||
112 | |||
113 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the V[US]DOT (scalar) insns in the 2reg-scalar-ext group | ||
2 | to decodetree. | ||
3 | 1 | ||
4 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
5 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
6 | Message-id: 20200430181003.21682-10-peter.maydell@linaro.org | ||
7 | --- | ||
8 | target/arm/neon-shared.decode | 3 +++ | ||
9 | target/arm/translate-neon.inc.c | 35 +++++++++++++++++++++++++++++++++ | ||
10 | target/arm/translate.c | 13 +----------- | ||
11 | 3 files changed, 39 insertions(+), 12 deletions(-) | ||
12 | |||
13 | diff --git a/target/arm/neon-shared.decode b/target/arm/neon-shared.decode | ||
14 | index XXXXXXX..XXXXXXX 100644 | ||
15 | --- a/target/arm/neon-shared.decode | ||
16 | +++ b/target/arm/neon-shared.decode | ||
17 | @@ -XXX,XX +XXX,XX @@ VCMLA_scalar 1111 1110 0 . rot:2 .... .... 1000 . q:1 index:1 0 vm:4 \ | ||
18 | vn=%vn_dp vd=%vd_dp size=0 | ||
19 | VCMLA_scalar 1111 1110 1 . rot:2 .... .... 1000 . q:1 . 0 .... \ | ||
20 | vm=%vm_dp vn=%vn_dp vd=%vd_dp size=1 index=0 | ||
21 | + | ||
22 | +VDOT_scalar 1111 1110 0 . 10 .... .... 1101 . q:1 index:1 u:1 rm:4 \ | ||
23 | + vm=%vm_dp vn=%vn_dp vd=%vd_dp | ||
24 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
25 | index XXXXXXX..XXXXXXX 100644 | ||
26 | --- a/target/arm/translate-neon.inc.c | ||
27 | +++ b/target/arm/translate-neon.inc.c | ||
28 | @@ -XXX,XX +XXX,XX @@ static bool trans_VCMLA_scalar(DisasContext *s, arg_VCMLA_scalar *a) | ||
29 | tcg_temp_free_ptr(fpst); | ||
30 | return true; | ||
31 | } | ||
32 | + | ||
33 | +static bool trans_VDOT_scalar(DisasContext *s, arg_VDOT_scalar *a) | ||
34 | +{ | ||
35 | + gen_helper_gvec_3 *fn_gvec; | ||
36 | + int opr_sz; | ||
37 | + TCGv_ptr fpst; | ||
38 | + | ||
39 | + if (!dc_isar_feature(aa32_dp, s)) { | ||
40 | + return false; | ||
41 | + } | ||
42 | + | ||
43 | + /* UNDEF accesses to D16-D31 if they don't exist. */ | ||
44 | + if (!dc_isar_feature(aa32_simd_r32, s) && | ||
45 | + ((a->vd | a->vn) & 0x10)) { | ||
46 | + return false; | ||
47 | + } | ||
48 | + | ||
49 | + if ((a->vd | a->vn) & a->q) { | ||
50 | + return false; | ||
51 | + } | ||
52 | + | ||
53 | + if (!vfp_access_check(s)) { | ||
54 | + return true; | ||
55 | + } | ||
56 | + | ||
57 | + fn_gvec = a->u ? gen_helper_gvec_udot_idx_b : gen_helper_gvec_sdot_idx_b; | ||
58 | + opr_sz = (1 + a->q) * 8; | ||
59 | + fpst = get_fpstatus_ptr(1); | ||
60 | + tcg_gen_gvec_3_ool(vfp_reg_offset(1, a->vd), | ||
61 | + vfp_reg_offset(1, a->vn), | ||
62 | + vfp_reg_offset(1, a->rm), | ||
63 | + opr_sz, opr_sz, a->index, fn_gvec); | ||
64 | + tcg_temp_free_ptr(fpst); | ||
65 | + return true; | ||
66 | +} | ||
67 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
68 | index XXXXXXX..XXXXXXX 100644 | ||
69 | --- a/target/arm/translate.c | ||
70 | +++ b/target/arm/translate.c | ||
71 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_insn_2reg_scalar_ext(DisasContext *s, uint32_t insn) | ||
72 | bool is_long = false, q = extract32(insn, 6, 1); | ||
73 | bool ptr_is_env = false; | ||
74 | |||
75 | - if ((insn & 0xffb00f00) == 0xfe200d00) { | ||
76 | - /* V[US]DOT -- 1111 1110 0.10 .... .... 1101 .Q.U .... */ | ||
77 | - int u = extract32(insn, 4, 1); | ||
78 | - | ||
79 | - if (!dc_isar_feature(aa32_dp, s)) { | ||
80 | - return 1; | ||
81 | - } | ||
82 | - fn_gvec = u ? gen_helper_gvec_udot_idx_b : gen_helper_gvec_sdot_idx_b; | ||
83 | - /* rm is just Vm, and index is M. */ | ||
84 | - data = extract32(insn, 5, 1); /* index */ | ||
85 | - rm = extract32(insn, 0, 4); | ||
86 | - } else if ((insn & 0xffa00f10) == 0xfe000810) { | ||
87 | + if ((insn & 0xffa00f10) == 0xfe000810) { | ||
88 | /* VFM[AS]L -- 1111 1110 0.0S .... .... 1000 .Q.1 .... */ | ||
89 | int is_s = extract32(insn, 20, 1); | ||
90 | int vm20 = extract32(insn, 0, 3); | ||
91 | -- | ||
92 | 2.20.1 | ||
93 | |||
94 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the Neon "load single structure to all lanes" insns to | ||
2 | decodetree. | ||
3 | 1 | ||
4 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
5 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
6 | Message-id: 20200430181003.21682-13-peter.maydell@linaro.org | ||
7 | --- | ||
8 | target/arm/neon-ls.decode | 5 +++ | ||
9 | target/arm/translate-neon.inc.c | 73 +++++++++++++++++++++++++++++++++ | ||
10 | target/arm/translate.c | 55 +------------------------ | ||
11 | 3 files changed, 80 insertions(+), 53 deletions(-) | ||
12 | |||
13 | diff --git a/target/arm/neon-ls.decode b/target/arm/neon-ls.decode | ||
14 | index XXXXXXX..XXXXXXX 100644 | ||
15 | --- a/target/arm/neon-ls.decode | ||
16 | +++ b/target/arm/neon-ls.decode | ||
17 | @@ -XXX,XX +XXX,XX @@ | ||
18 | |||
19 | VLDST_multiple 1111 0100 0 . l:1 0 rn:4 .... itype:4 size:2 align:2 rm:4 \ | ||
20 | vd=%vd_dp | ||
21 | + | ||
22 | +# Neon load single element to all lanes | ||
23 | + | ||
24 | +VLD_all_lanes 1111 0100 1 . 1 0 rn:4 .... 11 n:2 size:2 t:1 a:1 rm:4 \ | ||
25 | + vd=%vd_dp | ||
26 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
27 | index XXXXXXX..XXXXXXX 100644 | ||
28 | --- a/target/arm/translate-neon.inc.c | ||
29 | +++ b/target/arm/translate-neon.inc.c | ||
30 | @@ -XXX,XX +XXX,XX @@ static bool trans_VLDST_multiple(DisasContext *s, arg_VLDST_multiple *a) | ||
31 | gen_neon_ldst_base_update(s, a->rm, a->rn, nregs * interleave * 8); | ||
32 | return true; | ||
33 | } | ||
34 | + | ||
35 | +static bool trans_VLD_all_lanes(DisasContext *s, arg_VLD_all_lanes *a) | ||
36 | +{ | ||
37 | + /* Neon load single structure to all lanes */ | ||
38 | + int reg, stride, vec_size; | ||
39 | + int vd = a->vd; | ||
40 | + int size = a->size; | ||
41 | + int nregs = a->n + 1; | ||
42 | + TCGv_i32 addr, tmp; | ||
43 | + | ||
44 | + if (!arm_dc_feature(s, ARM_FEATURE_NEON)) { | ||
45 | + return false; | ||
46 | + } | ||
47 | + | ||
48 | + /* UNDEF accesses to D16-D31 if they don't exist */ | ||
49 | + if (!dc_isar_feature(aa32_simd_r32, s) && (a->vd & 0x10)) { | ||
50 | + return false; | ||
51 | + } | ||
52 | + | ||
53 | + if (size == 3) { | ||
54 | + if (nregs != 4 || a->a == 0) { | ||
55 | + return false; | ||
56 | + } | ||
57 | + /* For VLD4 size == 3 a == 1 means 32 bits at 16 byte alignment */ | ||
58 | + size = 2; | ||
59 | + } | ||
60 | + if (nregs == 1 && a->a == 1 && size == 0) { | ||
61 | + return false; | ||
62 | + } | ||
63 | + if (nregs == 3 && a->a == 1) { | ||
64 | + return false; | ||
65 | + } | ||
66 | + | ||
67 | + if (!vfp_access_check(s)) { | ||
68 | + return true; | ||
69 | + } | ||
70 | + | ||
71 | + /* | ||
72 | + * VLD1 to all lanes: T bit indicates how many Dregs to write. | ||
73 | + * VLD2/3/4 to all lanes: T bit indicates register stride. | ||
74 | + */ | ||
75 | + stride = a->t ? 2 : 1; | ||
76 | + vec_size = nregs == 1 ? stride * 8 : 8; | ||
77 | + | ||
78 | + tmp = tcg_temp_new_i32(); | ||
79 | + addr = tcg_temp_new_i32(); | ||
80 | + load_reg_var(s, addr, a->rn); | ||
81 | + for (reg = 0; reg < nregs; reg++) { | ||
82 | + gen_aa32_ld_i32(s, tmp, addr, get_mem_index(s), | ||
83 | + s->be_data | size); | ||
84 | + if ((vd & 1) && vec_size == 16) { | ||
85 | + /* | ||
86 | + * We cannot write 16 bytes at once because the | ||
87 | + * destination is unaligned. | ||
88 | + */ | ||
89 | + tcg_gen_gvec_dup_i32(size, neon_reg_offset(vd, 0), | ||
90 | + 8, 8, tmp); | ||
91 | + tcg_gen_gvec_mov(0, neon_reg_offset(vd + 1, 0), | ||
92 | + neon_reg_offset(vd, 0), 8, 8); | ||
93 | + } else { | ||
94 | + tcg_gen_gvec_dup_i32(size, neon_reg_offset(vd, 0), | ||
95 | + vec_size, vec_size, tmp); | ||
96 | + } | ||
97 | + tcg_gen_addi_i32(addr, addr, 1 << size); | ||
98 | + vd += stride; | ||
99 | + } | ||
100 | + tcg_temp_free_i32(tmp); | ||
101 | + tcg_temp_free_i32(addr); | ||
102 | + | ||
103 | + gen_neon_ldst_base_update(s, a->rm, a->rn, (1 << size) * nregs); | ||
104 | + | ||
105 | + return true; | ||
106 | +} | ||
107 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
108 | index XXXXXXX..XXXXXXX 100644 | ||
109 | --- a/target/arm/translate.c | ||
110 | +++ b/target/arm/translate.c | ||
111 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_ls_insn(DisasContext *s, uint32_t insn) | ||
112 | int size; | ||
113 | int reg; | ||
114 | int load; | ||
115 | - int vec_size; | ||
116 | TCGv_i32 addr; | ||
117 | TCGv_i32 tmp; | ||
118 | |||
119 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_ls_insn(DisasContext *s, uint32_t insn) | ||
120 | } else { | ||
121 | size = (insn >> 10) & 3; | ||
122 | if (size == 3) { | ||
123 | - /* Load single element to all lanes. */ | ||
124 | - int a = (insn >> 4) & 1; | ||
125 | - if (!load) { | ||
126 | - return 1; | ||
127 | - } | ||
128 | - size = (insn >> 6) & 3; | ||
129 | - nregs = ((insn >> 8) & 3) + 1; | ||
130 | - | ||
131 | - if (size == 3) { | ||
132 | - if (nregs != 4 || a == 0) { | ||
133 | - return 1; | ||
134 | - } | ||
135 | - /* For VLD4 size==3 a == 1 means 32 bits at 16 byte alignment */ | ||
136 | - size = 2; | ||
137 | - } | ||
138 | - if (nregs == 1 && a == 1 && size == 0) { | ||
139 | - return 1; | ||
140 | - } | ||
141 | - if (nregs == 3 && a == 1) { | ||
142 | - return 1; | ||
143 | - } | ||
144 | - addr = tcg_temp_new_i32(); | ||
145 | - load_reg_var(s, addr, rn); | ||
146 | - | ||
147 | - /* VLD1 to all lanes: bit 5 indicates how many Dregs to write. | ||
148 | - * VLD2/3/4 to all lanes: bit 5 indicates register stride. | ||
149 | - */ | ||
150 | - stride = (insn & (1 << 5)) ? 2 : 1; | ||
151 | - vec_size = nregs == 1 ? stride * 8 : 8; | ||
152 | - | ||
153 | - tmp = tcg_temp_new_i32(); | ||
154 | - for (reg = 0; reg < nregs; reg++) { | ||
155 | - gen_aa32_ld_i32(s, tmp, addr, get_mem_index(s), | ||
156 | - s->be_data | size); | ||
157 | - if ((rd & 1) && vec_size == 16) { | ||
158 | - /* We cannot write 16 bytes at once because the | ||
159 | - * destination is unaligned. | ||
160 | - */ | ||
161 | - tcg_gen_gvec_dup_i32(size, neon_reg_offset(rd, 0), | ||
162 | - 8, 8, tmp); | ||
163 | - tcg_gen_gvec_mov(0, neon_reg_offset(rd + 1, 0), | ||
164 | - neon_reg_offset(rd, 0), 8, 8); | ||
165 | - } else { | ||
166 | - tcg_gen_gvec_dup_i32(size, neon_reg_offset(rd, 0), | ||
167 | - vec_size, vec_size, tmp); | ||
168 | - } | ||
169 | - tcg_gen_addi_i32(addr, addr, 1 << size); | ||
170 | - rd += stride; | ||
171 | - } | ||
172 | - tcg_temp_free_i32(tmp); | ||
173 | - tcg_temp_free_i32(addr); | ||
174 | - stride = (1 << size) * nregs; | ||
175 | + /* Load single element to all lanes -- handled by decodetree */ | ||
176 | + return 1; | ||
177 | } else { | ||
178 | /* Single element. */ | ||
179 | int idx = (insn >> 4) & 0xf; | ||
180 | -- | ||
181 | 2.20.1 | ||
182 | |||
183 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the Neon 3-reg-same VADD and VSUB insns to decodetree. | ||
2 | 1 | ||
3 | Note that we don't need the neon_3r_sizes[op] check here because all | ||
4 | size values are OK for VADD and VSUB; we'll add this when we convert | ||
5 | the first insn that has size restrictions. | ||
6 | |||
7 | For this we need one of the GVecGen*Fn typedefs currently in | ||
8 | translate-a64.h; move them all to translate.h as a block so they | ||
9 | are visible to the 32-bit decoder. | ||
10 | |||
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
12 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
13 | Message-id: 20200430181003.21682-15-peter.maydell@linaro.org | ||
14 | --- | ||
15 | target/arm/translate-a64.h | 9 -------- | ||
16 | target/arm/translate.h | 9 ++++++++ | ||
17 | target/arm/neon-dp.decode | 17 +++++++++++++++ | ||
18 | target/arm/translate-neon.inc.c | 38 +++++++++++++++++++++++++++++++++ | ||
19 | target/arm/translate.c | 14 ++++-------- | ||
20 | 5 files changed, 68 insertions(+), 19 deletions(-) | ||
21 | |||
22 | diff --git a/target/arm/translate-a64.h b/target/arm/translate-a64.h | ||
23 | index XXXXXXX..XXXXXXX 100644 | ||
24 | --- a/target/arm/translate-a64.h | ||
25 | +++ b/target/arm/translate-a64.h | ||
26 | @@ -XXX,XX +XXX,XX @@ static inline int vec_full_reg_size(DisasContext *s) | ||
27 | |||
28 | bool disas_sve(DisasContext *, uint32_t); | ||
29 | |||
30 | -/* Note that the gvec expanders operate on offsets + sizes. */ | ||
31 | -typedef void GVecGen2Fn(unsigned, uint32_t, uint32_t, uint32_t, uint32_t); | ||
32 | -typedef void GVecGen2iFn(unsigned, uint32_t, uint32_t, int64_t, | ||
33 | - uint32_t, uint32_t); | ||
34 | -typedef void GVecGen3Fn(unsigned, uint32_t, uint32_t, | ||
35 | - uint32_t, uint32_t, uint32_t); | ||
36 | -typedef void GVecGen4Fn(unsigned, uint32_t, uint32_t, uint32_t, | ||
37 | - uint32_t, uint32_t, uint32_t); | ||
38 | - | ||
39 | #endif /* TARGET_ARM_TRANSLATE_A64_H */ | ||
40 | diff --git a/target/arm/translate.h b/target/arm/translate.h | ||
41 | index XXXXXXX..XXXXXXX 100644 | ||
42 | --- a/target/arm/translate.h | ||
43 | +++ b/target/arm/translate.h | ||
44 | @@ -XXX,XX +XXX,XX @@ void gen_sshl_i64(TCGv_i64 d, TCGv_i64 a, TCGv_i64 b); | ||
45 | #define dc_isar_feature(name, ctx) \ | ||
46 | ({ DisasContext *ctx_ = (ctx); isar_feature_##name(ctx_->isar); }) | ||
47 | |||
48 | +/* Note that the gvec expanders operate on offsets + sizes. */ | ||
49 | +typedef void GVecGen2Fn(unsigned, uint32_t, uint32_t, uint32_t, uint32_t); | ||
50 | +typedef void GVecGen2iFn(unsigned, uint32_t, uint32_t, int64_t, | ||
51 | + uint32_t, uint32_t); | ||
52 | +typedef void GVecGen3Fn(unsigned, uint32_t, uint32_t, | ||
53 | + uint32_t, uint32_t, uint32_t); | ||
54 | +typedef void GVecGen4Fn(unsigned, uint32_t, uint32_t, uint32_t, | ||
55 | + uint32_t, uint32_t, uint32_t); | ||
56 | + | ||
57 | #endif /* TARGET_ARM_TRANSLATE_H */ | ||
58 | diff --git a/target/arm/neon-dp.decode b/target/arm/neon-dp.decode | ||
59 | index XXXXXXX..XXXXXXX 100644 | ||
60 | --- a/target/arm/neon-dp.decode | ||
61 | +++ b/target/arm/neon-dp.decode | ||
62 | @@ -XXX,XX +XXX,XX @@ | ||
63 | # | ||
64 | # This file is processed by scripts/decodetree.py | ||
65 | # | ||
66 | +# VFP/Neon register fields; same as vfp.decode | ||
67 | +%vm_dp 5:1 0:4 | ||
68 | +%vn_dp 7:1 16:4 | ||
69 | +%vd_dp 22:1 12:4 | ||
70 | |||
71 | # Encodings for Neon data processing instructions where the T32 encoding | ||
72 | # is a simple transformation of the A32 encoding. | ||
73 | @@ -XXX,XX +XXX,XX @@ | ||
74 | # 0b111p_1111_qqqq_qqqq_qqqq_qqqq_qqqq_qqqq | ||
75 | # This file works on the A32 encoding only; calling code for T32 has to | ||
76 | # transform the insn into the A32 version first. | ||
77 | + | ||
78 | +###################################################################### | ||
79 | +# 3-reg-same grouping: | ||
80 | +# 1111 001 U 0 D sz:2 Vn:4 Vd:4 opc:4 N Q M op Vm:4 | ||
81 | +###################################################################### | ||
82 | + | ||
83 | +&3same vm vn vd q size | ||
84 | + | ||
85 | +@3same .... ... . . . size:2 .... .... .... . q:1 . . .... \ | ||
86 | + &3same vm=%vm_dp vn=%vn_dp vd=%vd_dp | ||
87 | + | ||
88 | +VADD_3s 1111 001 0 0 . .. .... .... 1000 . . . 0 .... @3same | ||
89 | +VSUB_3s 1111 001 1 0 . .. .... .... 1000 . . . 0 .... @3same | ||
90 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
91 | index XXXXXXX..XXXXXXX 100644 | ||
92 | --- a/target/arm/translate-neon.inc.c | ||
93 | +++ b/target/arm/translate-neon.inc.c | ||
94 | @@ -XXX,XX +XXX,XX @@ static bool trans_VLDST_single(DisasContext *s, arg_VLDST_single *a) | ||
95 | |||
96 | return true; | ||
97 | } | ||
98 | + | ||
99 | +static bool do_3same(DisasContext *s, arg_3same *a, GVecGen3Fn fn) | ||
100 | +{ | ||
101 | + int vec_size = a->q ? 16 : 8; | ||
102 | + int rd_ofs = neon_reg_offset(a->vd, 0); | ||
103 | + int rn_ofs = neon_reg_offset(a->vn, 0); | ||
104 | + int rm_ofs = neon_reg_offset(a->vm, 0); | ||
105 | + | ||
106 | + if (!arm_dc_feature(s, ARM_FEATURE_NEON)) { | ||
107 | + return false; | ||
108 | + } | ||
109 | + | ||
110 | + /* UNDEF accesses to D16-D31 if they don't exist. */ | ||
111 | + if (!dc_isar_feature(aa32_simd_r32, s) && | ||
112 | + ((a->vd | a->vn | a->vm) & 0x10)) { | ||
113 | + return false; | ||
114 | + } | ||
115 | + | ||
116 | + if ((a->vn | a->vm | a->vd) & a->q) { | ||
117 | + return false; | ||
118 | + } | ||
119 | + | ||
120 | + if (!vfp_access_check(s)) { | ||
121 | + return true; | ||
122 | + } | ||
123 | + | ||
124 | + fn(a->size, rd_ofs, rn_ofs, rm_ofs, vec_size, vec_size); | ||
125 | + return true; | ||
126 | +} | ||
127 | + | ||
128 | +#define DO_3SAME(INSN, FUNC) \ | ||
129 | + static bool trans_##INSN##_3s(DisasContext *s, arg_3same *a) \ | ||
130 | + { \ | ||
131 | + return do_3same(s, a, FUNC); \ | ||
132 | + } | ||
133 | + | ||
134 | +DO_3SAME(VADD, tcg_gen_gvec_add) | ||
135 | +DO_3SAME(VSUB, tcg_gen_gvec_sub) | ||
136 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
137 | index XXXXXXX..XXXXXXX 100644 | ||
138 | --- a/target/arm/translate.c | ||
139 | +++ b/target/arm/translate.c | ||
140 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
141 | } | ||
142 | return 0; | ||
143 | |||
144 | - case NEON_3R_VADD_VSUB: | ||
145 | - if (u) { | ||
146 | - tcg_gen_gvec_sub(size, rd_ofs, rn_ofs, rm_ofs, | ||
147 | - vec_size, vec_size); | ||
148 | - } else { | ||
149 | - tcg_gen_gvec_add(size, rd_ofs, rn_ofs, rm_ofs, | ||
150 | - vec_size, vec_size); | ||
151 | - } | ||
152 | - return 0; | ||
153 | - | ||
154 | case NEON_3R_VQADD: | ||
155 | tcg_gen_gvec_4(rd_ofs, offsetof(CPUARMState, vfp.qc), | ||
156 | rn_ofs, rm_ofs, vec_size, vec_size, | ||
157 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
158 | tcg_gen_gvec_3(rd_ofs, rm_ofs, rn_ofs, vec_size, vec_size, | ||
159 | u ? &ushl_op[size] : &sshl_op[size]); | ||
160 | return 0; | ||
161 | + | ||
162 | + case NEON_3R_VADD_VSUB: | ||
163 | + /* Already handled by decodetree */ | ||
164 | + return 1; | ||
165 | } | ||
166 | |||
167 | if (size == 3) { | ||
168 | -- | ||
169 | 2.20.1 | ||
170 | |||
171 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the Neon logic ops in the 3-reg-same grouping to decodetree. | ||
2 | Note that for the logic ops the 'size' field forms part of their | ||
3 | decode and the actual operations are always bitwise. | ||
4 | 1 | ||
5 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
6 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
7 | Message-id: 20200430181003.21682-16-peter.maydell@linaro.org | ||
8 | --- | ||
9 | target/arm/neon-dp.decode | 12 +++++++++++ | ||
10 | target/arm/translate-neon.inc.c | 19 +++++++++++++++++ | ||
11 | target/arm/translate.c | 38 +-------------------------------- | ||
12 | 3 files changed, 32 insertions(+), 37 deletions(-) | ||
13 | |||
14 | diff --git a/target/arm/neon-dp.decode b/target/arm/neon-dp.decode | ||
15 | index XXXXXXX..XXXXXXX 100644 | ||
16 | --- a/target/arm/neon-dp.decode | ||
17 | +++ b/target/arm/neon-dp.decode | ||
18 | @@ -XXX,XX +XXX,XX @@ | ||
19 | @3same .... ... . . . size:2 .... .... .... . q:1 . . .... \ | ||
20 | &3same vm=%vm_dp vn=%vn_dp vd=%vd_dp | ||
21 | |||
22 | +@3same_logic .... ... . . . .. .... .... .... . q:1 .. .... \ | ||
23 | + &3same vm=%vm_dp vn=%vn_dp vd=%vd_dp size=0 | ||
24 | + | ||
25 | +VAND_3s 1111 001 0 0 . 00 .... .... 0001 ... 1 .... @3same_logic | ||
26 | +VBIC_3s 1111 001 0 0 . 01 .... .... 0001 ... 1 .... @3same_logic | ||
27 | +VORR_3s 1111 001 0 0 . 10 .... .... 0001 ... 1 .... @3same_logic | ||
28 | +VORN_3s 1111 001 0 0 . 11 .... .... 0001 ... 1 .... @3same_logic | ||
29 | +VEOR_3s 1111 001 1 0 . 00 .... .... 0001 ... 1 .... @3same_logic | ||
30 | +VBSL_3s 1111 001 1 0 . 01 .... .... 0001 ... 1 .... @3same_logic | ||
31 | +VBIT_3s 1111 001 1 0 . 10 .... .... 0001 ... 1 .... @3same_logic | ||
32 | +VBIF_3s 1111 001 1 0 . 11 .... .... 0001 ... 1 .... @3same_logic | ||
33 | + | ||
34 | VADD_3s 1111 001 0 0 . .. .... .... 1000 . . . 0 .... @3same | ||
35 | VSUB_3s 1111 001 1 0 . .. .... .... 1000 . . . 0 .... @3same | ||
36 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
37 | index XXXXXXX..XXXXXXX 100644 | ||
38 | --- a/target/arm/translate-neon.inc.c | ||
39 | +++ b/target/arm/translate-neon.inc.c | ||
40 | @@ -XXX,XX +XXX,XX @@ static bool do_3same(DisasContext *s, arg_3same *a, GVecGen3Fn fn) | ||
41 | |||
42 | DO_3SAME(VADD, tcg_gen_gvec_add) | ||
43 | DO_3SAME(VSUB, tcg_gen_gvec_sub) | ||
44 | +DO_3SAME(VAND, tcg_gen_gvec_and) | ||
45 | +DO_3SAME(VBIC, tcg_gen_gvec_andc) | ||
46 | +DO_3SAME(VORR, tcg_gen_gvec_or) | ||
47 | +DO_3SAME(VORN, tcg_gen_gvec_orc) | ||
48 | +DO_3SAME(VEOR, tcg_gen_gvec_xor) | ||
49 | + | ||
50 | +/* These insns are all gvec_bitsel but with the inputs in various orders. */ | ||
51 | +#define DO_3SAME_BITSEL(INSN, O1, O2, O3) \ | ||
52 | + static void gen_##INSN##_3s(unsigned vece, uint32_t rd_ofs, \ | ||
53 | + uint32_t rn_ofs, uint32_t rm_ofs, \ | ||
54 | + uint32_t oprsz, uint32_t maxsz) \ | ||
55 | + { \ | ||
56 | + tcg_gen_gvec_bitsel(vece, rd_ofs, O1, O2, O3, oprsz, maxsz); \ | ||
57 | + } \ | ||
58 | + DO_3SAME(INSN, gen_##INSN##_3s) | ||
59 | + | ||
60 | +DO_3SAME_BITSEL(VBSL, rd_ofs, rn_ofs, rm_ofs) | ||
61 | +DO_3SAME_BITSEL(VBIT, rm_ofs, rn_ofs, rd_ofs) | ||
62 | +DO_3SAME_BITSEL(VBIF, rm_ofs, rd_ofs, rn_ofs) | ||
63 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
64 | index XXXXXXX..XXXXXXX 100644 | ||
65 | --- a/target/arm/translate.c | ||
66 | +++ b/target/arm/translate.c | ||
67 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
68 | } | ||
69 | return 1; | ||
70 | |||
71 | - case NEON_3R_LOGIC: /* Logic ops. */ | ||
72 | - switch ((u << 2) | size) { | ||
73 | - case 0: /* VAND */ | ||
74 | - tcg_gen_gvec_and(0, rd_ofs, rn_ofs, rm_ofs, | ||
75 | - vec_size, vec_size); | ||
76 | - break; | ||
77 | - case 1: /* VBIC */ | ||
78 | - tcg_gen_gvec_andc(0, rd_ofs, rn_ofs, rm_ofs, | ||
79 | - vec_size, vec_size); | ||
80 | - break; | ||
81 | - case 2: /* VORR */ | ||
82 | - tcg_gen_gvec_or(0, rd_ofs, rn_ofs, rm_ofs, | ||
83 | - vec_size, vec_size); | ||
84 | - break; | ||
85 | - case 3: /* VORN */ | ||
86 | - tcg_gen_gvec_orc(0, rd_ofs, rn_ofs, rm_ofs, | ||
87 | - vec_size, vec_size); | ||
88 | - break; | ||
89 | - case 4: /* VEOR */ | ||
90 | - tcg_gen_gvec_xor(0, rd_ofs, rn_ofs, rm_ofs, | ||
91 | - vec_size, vec_size); | ||
92 | - break; | ||
93 | - case 5: /* VBSL */ | ||
94 | - tcg_gen_gvec_bitsel(MO_8, rd_ofs, rd_ofs, rn_ofs, rm_ofs, | ||
95 | - vec_size, vec_size); | ||
96 | - break; | ||
97 | - case 6: /* VBIT */ | ||
98 | - tcg_gen_gvec_bitsel(MO_8, rd_ofs, rm_ofs, rn_ofs, rd_ofs, | ||
99 | - vec_size, vec_size); | ||
100 | - break; | ||
101 | - case 7: /* VBIF */ | ||
102 | - tcg_gen_gvec_bitsel(MO_8, rd_ofs, rm_ofs, rd_ofs, rn_ofs, | ||
103 | - vec_size, vec_size); | ||
104 | - break; | ||
105 | - } | ||
106 | - return 0; | ||
107 | - | ||
108 | case NEON_3R_VQADD: | ||
109 | tcg_gen_gvec_4(rd_ofs, offsetof(CPUARMState, vfp.qc), | ||
110 | rn_ofs, rm_ofs, vec_size, vec_size, | ||
111 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
112 | return 0; | ||
113 | |||
114 | case NEON_3R_VADD_VSUB: | ||
115 | + case NEON_3R_LOGIC: | ||
116 | /* Already handled by decodetree */ | ||
117 | return 1; | ||
118 | } | ||
119 | -- | ||
120 | 2.20.1 | ||
121 | |||
122 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the Neon 3-reg-same VMAX and VMIN insns to decodetree. | ||
2 | 1 | ||
3 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
4 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
5 | Message-id: 20200430181003.21682-17-peter.maydell@linaro.org | ||
6 | --- | ||
7 | target/arm/neon-dp.decode | 5 +++++ | ||
8 | target/arm/translate-neon.inc.c | 14 ++++++++++++++ | ||
9 | target/arm/translate.c | 21 ++------------------- | ||
10 | 3 files changed, 21 insertions(+), 19 deletions(-) | ||
11 | |||
12 | diff --git a/target/arm/neon-dp.decode b/target/arm/neon-dp.decode | ||
13 | index XXXXXXX..XXXXXXX 100644 | ||
14 | --- a/target/arm/neon-dp.decode | ||
15 | +++ b/target/arm/neon-dp.decode | ||
16 | @@ -XXX,XX +XXX,XX @@ VBSL_3s 1111 001 1 0 . 01 .... .... 0001 ... 1 .... @3same_logic | ||
17 | VBIT_3s 1111 001 1 0 . 10 .... .... 0001 ... 1 .... @3same_logic | ||
18 | VBIF_3s 1111 001 1 0 . 11 .... .... 0001 ... 1 .... @3same_logic | ||
19 | |||
20 | +VMAX_S_3s 1111 001 0 0 . .. .... .... 0110 . . . 0 .... @3same | ||
21 | +VMAX_U_3s 1111 001 1 0 . .. .... .... 0110 . . . 0 .... @3same | ||
22 | +VMIN_S_3s 1111 001 0 0 . .. .... .... 0110 . . . 1 .... @3same | ||
23 | +VMIN_U_3s 1111 001 1 0 . .. .... .... 0110 . . . 1 .... @3same | ||
24 | + | ||
25 | VADD_3s 1111 001 0 0 . .. .... .... 1000 . . . 0 .... @3same | ||
26 | VSUB_3s 1111 001 1 0 . .. .... .... 1000 . . . 0 .... @3same | ||
27 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
28 | index XXXXXXX..XXXXXXX 100644 | ||
29 | --- a/target/arm/translate-neon.inc.c | ||
30 | +++ b/target/arm/translate-neon.inc.c | ||
31 | @@ -XXX,XX +XXX,XX @@ DO_3SAME(VEOR, tcg_gen_gvec_xor) | ||
32 | DO_3SAME_BITSEL(VBSL, rd_ofs, rn_ofs, rm_ofs) | ||
33 | DO_3SAME_BITSEL(VBIT, rm_ofs, rn_ofs, rd_ofs) | ||
34 | DO_3SAME_BITSEL(VBIF, rm_ofs, rd_ofs, rn_ofs) | ||
35 | + | ||
36 | +#define DO_3SAME_NO_SZ_3(INSN, FUNC) \ | ||
37 | + static bool trans_##INSN##_3s(DisasContext *s, arg_3same *a) \ | ||
38 | + { \ | ||
39 | + if (a->size == 3) { \ | ||
40 | + return false; \ | ||
41 | + } \ | ||
42 | + return do_3same(s, a, FUNC); \ | ||
43 | + } | ||
44 | + | ||
45 | +DO_3SAME_NO_SZ_3(VMAX_S, tcg_gen_gvec_smax) | ||
46 | +DO_3SAME_NO_SZ_3(VMAX_U, tcg_gen_gvec_umax) | ||
47 | +DO_3SAME_NO_SZ_3(VMIN_S, tcg_gen_gvec_smin) | ||
48 | +DO_3SAME_NO_SZ_3(VMIN_U, tcg_gen_gvec_umin) | ||
49 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
50 | index XXXXXXX..XXXXXXX 100644 | ||
51 | --- a/target/arm/translate.c | ||
52 | +++ b/target/arm/translate.c | ||
53 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
54 | rd_ofs, rn_ofs, rm_ofs, vec_size, vec_size); | ||
55 | return 0; | ||
56 | |||
57 | - case NEON_3R_VMAX: | ||
58 | - if (u) { | ||
59 | - tcg_gen_gvec_umax(size, rd_ofs, rn_ofs, rm_ofs, | ||
60 | - vec_size, vec_size); | ||
61 | - } else { | ||
62 | - tcg_gen_gvec_smax(size, rd_ofs, rn_ofs, rm_ofs, | ||
63 | - vec_size, vec_size); | ||
64 | - } | ||
65 | - return 0; | ||
66 | - case NEON_3R_VMIN: | ||
67 | - if (u) { | ||
68 | - tcg_gen_gvec_umin(size, rd_ofs, rn_ofs, rm_ofs, | ||
69 | - vec_size, vec_size); | ||
70 | - } else { | ||
71 | - tcg_gen_gvec_smin(size, rd_ofs, rn_ofs, rm_ofs, | ||
72 | - vec_size, vec_size); | ||
73 | - } | ||
74 | - return 0; | ||
75 | - | ||
76 | case NEON_3R_VSHL: | ||
77 | /* Note the operation is vshl vd,vm,vn */ | ||
78 | tcg_gen_gvec_3(rd_ofs, rm_ofs, rn_ofs, vec_size, vec_size, | ||
79 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
80 | |||
81 | case NEON_3R_VADD_VSUB: | ||
82 | case NEON_3R_LOGIC: | ||
83 | + case NEON_3R_VMAX: | ||
84 | + case NEON_3R_VMIN: | ||
85 | /* Already handled by decodetree */ | ||
86 | return 1; | ||
87 | } | ||
88 | -- | ||
89 | 2.20.1 | ||
90 | |||
91 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the Neon comparison ops in the 3-reg-same grouping | ||
2 | to decodetree. | ||
3 | 1 | ||
4 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
5 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
6 | Message-id: 20200430181003.21682-18-peter.maydell@linaro.org | ||
7 | --- | ||
8 | target/arm/neon-dp.decode | 8 ++++++++ | ||
9 | target/arm/translate-neon.inc.c | 22 ++++++++++++++++++++++ | ||
10 | target/arm/translate.c | 23 +++-------------------- | ||
11 | 3 files changed, 33 insertions(+), 20 deletions(-) | ||
12 | |||
13 | diff --git a/target/arm/neon-dp.decode b/target/arm/neon-dp.decode | ||
14 | index XXXXXXX..XXXXXXX 100644 | ||
15 | --- a/target/arm/neon-dp.decode | ||
16 | +++ b/target/arm/neon-dp.decode | ||
17 | @@ -XXX,XX +XXX,XX @@ VBSL_3s 1111 001 1 0 . 01 .... .... 0001 ... 1 .... @3same_logic | ||
18 | VBIT_3s 1111 001 1 0 . 10 .... .... 0001 ... 1 .... @3same_logic | ||
19 | VBIF_3s 1111 001 1 0 . 11 .... .... 0001 ... 1 .... @3same_logic | ||
20 | |||
21 | +VCGT_S_3s 1111 001 0 0 . .. .... .... 0011 . . . 0 .... @3same | ||
22 | +VCGT_U_3s 1111 001 1 0 . .. .... .... 0011 . . . 0 .... @3same | ||
23 | +VCGE_S_3s 1111 001 0 0 . .. .... .... 0011 . . . 1 .... @3same | ||
24 | +VCGE_U_3s 1111 001 1 0 . .. .... .... 0011 . . . 1 .... @3same | ||
25 | + | ||
26 | VMAX_S_3s 1111 001 0 0 . .. .... .... 0110 . . . 0 .... @3same | ||
27 | VMAX_U_3s 1111 001 1 0 . .. .... .... 0110 . . . 0 .... @3same | ||
28 | VMIN_S_3s 1111 001 0 0 . .. .... .... 0110 . . . 1 .... @3same | ||
29 | @@ -XXX,XX +XXX,XX @@ VMIN_U_3s 1111 001 1 0 . .. .... .... 0110 . . . 1 .... @3same | ||
30 | |||
31 | VADD_3s 1111 001 0 0 . .. .... .... 1000 . . . 0 .... @3same | ||
32 | VSUB_3s 1111 001 1 0 . .. .... .... 1000 . . . 0 .... @3same | ||
33 | + | ||
34 | +VTST_3s 1111 001 0 0 . .. .... .... 1000 . . . 1 .... @3same | ||
35 | +VCEQ_3s 1111 001 1 0 . .. .... .... 1000 . . . 1 .... @3same | ||
36 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
37 | index XXXXXXX..XXXXXXX 100644 | ||
38 | --- a/target/arm/translate-neon.inc.c | ||
39 | +++ b/target/arm/translate-neon.inc.c | ||
40 | @@ -XXX,XX +XXX,XX @@ DO_3SAME_NO_SZ_3(VMAX_S, tcg_gen_gvec_smax) | ||
41 | DO_3SAME_NO_SZ_3(VMAX_U, tcg_gen_gvec_umax) | ||
42 | DO_3SAME_NO_SZ_3(VMIN_S, tcg_gen_gvec_smin) | ||
43 | DO_3SAME_NO_SZ_3(VMIN_U, tcg_gen_gvec_umin) | ||
44 | + | ||
45 | +#define DO_3SAME_CMP(INSN, COND) \ | ||
46 | + static void gen_##INSN##_3s(unsigned vece, uint32_t rd_ofs, \ | ||
47 | + uint32_t rn_ofs, uint32_t rm_ofs, \ | ||
48 | + uint32_t oprsz, uint32_t maxsz) \ | ||
49 | + { \ | ||
50 | + tcg_gen_gvec_cmp(COND, vece, rd_ofs, rn_ofs, rm_ofs, oprsz, maxsz); \ | ||
51 | + } \ | ||
52 | + DO_3SAME_NO_SZ_3(INSN, gen_##INSN##_3s) | ||
53 | + | ||
54 | +DO_3SAME_CMP(VCGT_S, TCG_COND_GT) | ||
55 | +DO_3SAME_CMP(VCGT_U, TCG_COND_GTU) | ||
56 | +DO_3SAME_CMP(VCGE_S, TCG_COND_GE) | ||
57 | +DO_3SAME_CMP(VCGE_U, TCG_COND_GEU) | ||
58 | +DO_3SAME_CMP(VCEQ, TCG_COND_EQ) | ||
59 | + | ||
60 | +static void gen_VTST_3s(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs, | ||
61 | + uint32_t rm_ofs, uint32_t oprsz, uint32_t maxsz) | ||
62 | +{ | ||
63 | + tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, oprsz, maxsz, &cmtst_op[vece]); | ||
64 | +} | ||
65 | +DO_3SAME_NO_SZ_3(VTST, gen_VTST_3s) | ||
66 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
67 | index XXXXXXX..XXXXXXX 100644 | ||
68 | --- a/target/arm/translate.c | ||
69 | +++ b/target/arm/translate.c | ||
70 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
71 | u ? &mls_op[size] : &mla_op[size]); | ||
72 | return 0; | ||
73 | |||
74 | - case NEON_3R_VTST_VCEQ: | ||
75 | - if (u) { /* VCEQ */ | ||
76 | - tcg_gen_gvec_cmp(TCG_COND_EQ, size, rd_ofs, rn_ofs, rm_ofs, | ||
77 | - vec_size, vec_size); | ||
78 | - } else { /* VTST */ | ||
79 | - tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, | ||
80 | - vec_size, vec_size, &cmtst_op[size]); | ||
81 | - } | ||
82 | - return 0; | ||
83 | - | ||
84 | - case NEON_3R_VCGT: | ||
85 | - tcg_gen_gvec_cmp(u ? TCG_COND_GTU : TCG_COND_GT, size, | ||
86 | - rd_ofs, rn_ofs, rm_ofs, vec_size, vec_size); | ||
87 | - return 0; | ||
88 | - | ||
89 | - case NEON_3R_VCGE: | ||
90 | - tcg_gen_gvec_cmp(u ? TCG_COND_GEU : TCG_COND_GE, size, | ||
91 | - rd_ofs, rn_ofs, rm_ofs, vec_size, vec_size); | ||
92 | - return 0; | ||
93 | - | ||
94 | case NEON_3R_VSHL: | ||
95 | /* Note the operation is vshl vd,vm,vn */ | ||
96 | tcg_gen_gvec_3(rd_ofs, rm_ofs, rn_ofs, vec_size, vec_size, | ||
97 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
98 | case NEON_3R_LOGIC: | ||
99 | case NEON_3R_VMAX: | ||
100 | case NEON_3R_VMIN: | ||
101 | + case NEON_3R_VTST_VCEQ: | ||
102 | + case NEON_3R_VCGT: | ||
103 | + case NEON_3R_VCGE: | ||
104 | /* Already handled by decodetree */ | ||
105 | return 1; | ||
106 | } | ||
107 | -- | ||
108 | 2.20.1 | ||
109 | |||
110 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Convert the Neon VQADD/VQSUB insns in the 3-reg-same grouping | ||
2 | to decodetree. | ||
3 | 1 | ||
4 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
5 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
6 | Message-id: 20200430181003.21682-19-peter.maydell@linaro.org | ||
7 | --- | ||
8 | target/arm/neon-dp.decode | 6 ++++++ | ||
9 | target/arm/translate-neon.inc.c | 15 +++++++++++++++ | ||
10 | target/arm/translate.c | 14 ++------------ | ||
11 | 3 files changed, 23 insertions(+), 12 deletions(-) | ||
12 | |||
13 | diff --git a/target/arm/neon-dp.decode b/target/arm/neon-dp.decode | ||
14 | index XXXXXXX..XXXXXXX 100644 | ||
15 | --- a/target/arm/neon-dp.decode | ||
16 | +++ b/target/arm/neon-dp.decode | ||
17 | @@ -XXX,XX +XXX,XX @@ | ||
18 | @3same .... ... . . . size:2 .... .... .... . q:1 . . .... \ | ||
19 | &3same vm=%vm_dp vn=%vn_dp vd=%vd_dp | ||
20 | |||
21 | +VQADD_S_3s 1111 001 0 0 . .. .... .... 0000 . . . 1 .... @3same | ||
22 | +VQADD_U_3s 1111 001 1 0 . .. .... .... 0000 . . . 1 .... @3same | ||
23 | + | ||
24 | @3same_logic .... ... . . . .. .... .... .... . q:1 .. .... \ | ||
25 | &3same vm=%vm_dp vn=%vn_dp vd=%vd_dp size=0 | ||
26 | |||
27 | @@ -XXX,XX +XXX,XX @@ VBSL_3s 1111 001 1 0 . 01 .... .... 0001 ... 1 .... @3same_logic | ||
28 | VBIT_3s 1111 001 1 0 . 10 .... .... 0001 ... 1 .... @3same_logic | ||
29 | VBIF_3s 1111 001 1 0 . 11 .... .... 0001 ... 1 .... @3same_logic | ||
30 | |||
31 | +VQSUB_S_3s 1111 001 0 0 . .. .... .... 0010 . . . 1 .... @3same | ||
32 | +VQSUB_U_3s 1111 001 1 0 . .. .... .... 0010 . . . 1 .... @3same | ||
33 | + | ||
34 | VCGT_S_3s 1111 001 0 0 . .. .... .... 0011 . . . 0 .... @3same | ||
35 | VCGT_U_3s 1111 001 1 0 . .. .... .... 0011 . . . 0 .... @3same | ||
36 | VCGE_S_3s 1111 001 0 0 . .. .... .... 0011 . . . 1 .... @3same | ||
37 | diff --git a/target/arm/translate-neon.inc.c b/target/arm/translate-neon.inc.c | ||
38 | index XXXXXXX..XXXXXXX 100644 | ||
39 | --- a/target/arm/translate-neon.inc.c | ||
40 | +++ b/target/arm/translate-neon.inc.c | ||
41 | @@ -XXX,XX +XXX,XX @@ static void gen_VTST_3s(unsigned vece, uint32_t rd_ofs, uint32_t rn_ofs, | ||
42 | tcg_gen_gvec_3(rd_ofs, rn_ofs, rm_ofs, oprsz, maxsz, &cmtst_op[vece]); | ||
43 | } | ||
44 | DO_3SAME_NO_SZ_3(VTST, gen_VTST_3s) | ||
45 | + | ||
46 | +#define DO_3SAME_GVEC4(INSN, OPARRAY) \ | ||
47 | + static void gen_##INSN##_3s(unsigned vece, uint32_t rd_ofs, \ | ||
48 | + uint32_t rn_ofs, uint32_t rm_ofs, \ | ||
49 | + uint32_t oprsz, uint32_t maxsz) \ | ||
50 | + { \ | ||
51 | + tcg_gen_gvec_4(rd_ofs, offsetof(CPUARMState, vfp.qc), \ | ||
52 | + rn_ofs, rm_ofs, oprsz, maxsz, &OPARRAY[vece]); \ | ||
53 | + } \ | ||
54 | + DO_3SAME(INSN, gen_##INSN##_3s) | ||
55 | + | ||
56 | +DO_3SAME_GVEC4(VQADD_S, sqadd_op) | ||
57 | +DO_3SAME_GVEC4(VQADD_U, uqadd_op) | ||
58 | +DO_3SAME_GVEC4(VQSUB_S, sqsub_op) | ||
59 | +DO_3SAME_GVEC4(VQSUB_U, uqsub_op) | ||
60 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
61 | index XXXXXXX..XXXXXXX 100644 | ||
62 | --- a/target/arm/translate.c | ||
63 | +++ b/target/arm/translate.c | ||
64 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
65 | } | ||
66 | return 1; | ||
67 | |||
68 | - case NEON_3R_VQADD: | ||
69 | - tcg_gen_gvec_4(rd_ofs, offsetof(CPUARMState, vfp.qc), | ||
70 | - rn_ofs, rm_ofs, vec_size, vec_size, | ||
71 | - (u ? uqadd_op : sqadd_op) + size); | ||
72 | - return 0; | ||
73 | - | ||
74 | - case NEON_3R_VQSUB: | ||
75 | - tcg_gen_gvec_4(rd_ofs, offsetof(CPUARMState, vfp.qc), | ||
76 | - rn_ofs, rm_ofs, vec_size, vec_size, | ||
77 | - (u ? uqsub_op : sqsub_op) + size); | ||
78 | - return 0; | ||
79 | - | ||
80 | case NEON_3R_VMUL: /* VMUL */ | ||
81 | if (u) { | ||
82 | /* Polynomial case allows only P8. */ | ||
83 | @@ -XXX,XX +XXX,XX @@ static int disas_neon_data_insn(DisasContext *s, uint32_t insn) | ||
84 | case NEON_3R_VTST_VCEQ: | ||
85 | case NEON_3R_VCGT: | ||
86 | case NEON_3R_VCGE: | ||
87 | + case NEON_3R_VQADD: | ||
88 | + case NEON_3R_VQSUB: | ||
89 | /* Already handled by decodetree */ | ||
90 | return 1; | ||
91 | } | ||
92 | -- | ||
93 | 2.20.1 | ||
94 | |||
95 | diff view generated by jsdifflib |