1 | target-arm queue: the big stuff here is the final part of | 1 | The following changes since commit 3db29dcac23da85486704ef9e7a8e7217f7829cd: |
---|---|---|---|
2 | rth's patches for Cortex-A76 and Neoverse-N1 support; | ||
3 | also present are Gavin's NUMA series and a few other things. | ||
4 | 2 | ||
5 | thanks | 3 | Merge tag 'for-upstream' of https://gitlab.com/bonzini/qemu into staging (2023-01-12 13:51:36 +0000) |
6 | -- PMM | ||
7 | |||
8 | The following changes since commit 554623226f800acf48a2ed568900c1c968ec9a8b: | ||
9 | |||
10 | Merge tag 'qemu-sparc-20220508' of https://github.com/mcayland/qemu into staging (2022-05-08 17:03:26 -0500) | ||
11 | 4 | ||
12 | are available in the Git repository at: | 5 | are available in the Git repository at: |
13 | 6 | ||
14 | https://git.linaro.org/people/pmaydell/qemu-arm.git tags/pull-target-arm-20220509 | 7 | https://git.linaro.org/people/pmaydell/qemu-arm.git tags/pull-target-arm-20230113 |
15 | 8 | ||
16 | for you to fetch changes up to ae9141d4a3265553503bf07d3574b40f84615a34: | 9 | for you to fetch changes up to 08899b5c68a55a3780d707e2464073c8f2670d31: |
17 | 10 | ||
18 | hw/acpi/aml-build: Use existing CPU topology to build PPTT table (2022-05-09 11:47:55 +0100) | 11 | target/arm: allow writes to SCR_EL3.HXEn bit when FEAT_HCX is enabled (2023-01-13 13:19:36 +0000) |
19 | 12 | ||
20 | ---------------------------------------------------------------- | 13 | ---------------------------------------------------------------- |
21 | target-arm queue: | 14 | target-arm queue: |
22 | * MAINTAINERS/.mailmap: update email for Leif Lindholm | 15 | hw/arm/stm32f405: correctly describe the memory layout |
23 | * hw/arm: add version information to sbsa-ref machine DT | 16 | hw/arm: Add Olimex H405 board |
24 | * Enable new features for -cpu max: | 17 | cubieboard: Support booting from an SD card image with u-boot on it |
25 | FEAT_Debugv8p2, FEAT_Debugv8p4, FEAT_RAS (minimal version only), | 18 | target/arm: Fix sve_probe_page |
26 | FEAT_IESB, FEAT_CSV2, FEAT_CSV2_2, FEAT_CSV3, FEAT_DGH | 19 | target/arm: allow writes to SCR_EL3.HXEn bit when FEAT_HCX is enabled |
27 | * Emulate Cortex-A76 | 20 | various code cleanups |
28 | * Emulate Neoverse-N1 | ||
29 | * Fix the virt board default NUMA topology | ||
30 | 21 | ||
31 | ---------------------------------------------------------------- | 22 | ---------------------------------------------------------------- |
32 | Gavin Shan (6): | 23 | Evgeny Iakovlev (1): |
33 | qapi/machine.json: Add cluster-id | 24 | target/arm: allow writes to SCR_EL3.HXEn bit when FEAT_HCX is enabled |
34 | qtest/numa-test: Specify CPU topology in aarch64_numa_cpu() | ||
35 | hw/arm/virt: Consider SMP configuration in CPU topology | ||
36 | qtest/numa-test: Correct CPU and NUMA association in aarch64_numa_cpu() | ||
37 | hw/arm/virt: Fix CPU's default NUMA node ID | ||
38 | hw/acpi/aml-build: Use existing CPU topology to build PPTT table | ||
39 | 25 | ||
40 | Leif Lindholm (2): | 26 | Felipe Balbi (2): |
41 | MAINTAINERS/.mailmap: update email for Leif Lindholm | 27 | hw/arm/stm32f405: correctly describe the memory layout |
42 | hw/arm: add versioning to sbsa-ref machine DT | 28 | hw/arm: Add Olimex H405 |
43 | 29 | ||
44 | Richard Henderson (24): | 30 | Philippe Mathieu-Daudé (27): |
45 | target/arm: Handle cpreg registration for missing EL | 31 | hw/arm/pxa2xx: Simplify pxa255_init() |
46 | target/arm: Drop EL3 no EL2 fallbacks | 32 | hw/arm/pxa2xx: Simplify pxa270_init() |
47 | target/arm: Merge zcr reginfo | 33 | hw/arm/collie: Use the IEC binary prefix definitions |
48 | target/arm: Adjust definition of CONTEXTIDR_EL2 | 34 | hw/arm/collie: Simplify flash creation using for() loop |
49 | target/arm: Move cortex impdef sysregs to cpu_tcg.c | 35 | hw/arm/gumstix: Improve documentation |
50 | target/arm: Update qemu-system-arm -cpu max to cortex-a57 | 36 | hw/arm/gumstix: Use the IEC binary prefix definitions |
51 | target/arm: Set ID_DFR0.PerfMon for qemu-system-arm -cpu max | 37 | hw/arm/mainstone: Use the IEC binary prefix definitions |
52 | target/arm: Split out aa32_max_features | 38 | hw/arm/musicpal: Use the IEC binary prefix definitions |
53 | target/arm: Annotate arm_max_initfn with FEAT identifiers | 39 | hw/arm/omap_sx1: Remove unused 'total_ram' definitions |
54 | target/arm: Use field names for manipulating EL2 and EL3 modes | 40 | hw/arm/omap_sx1: Use the IEC binary prefix definitions |
55 | target/arm: Enable FEAT_Debugv8p2 for -cpu max | 41 | hw/arm/z2: Use the IEC binary prefix definitions |
56 | target/arm: Enable FEAT_Debugv8p4 for -cpu max | 42 | hw/arm/vexpress: Remove dead code in vexpress_common_init() |
57 | target/arm: Add minimal RAS registers | 43 | hw/arm: Remove unreachable code calling pflash_cfi01_register() |
58 | target/arm: Enable SCR and HCR bits for RAS | 44 | hw/arm/pxa: Avoid forward-declaring PXA2xxI2CState |
59 | target/arm: Implement virtual SError exceptions | 45 | hw/gpio/omap_gpio: Add local variable to avoid embedded cast |
60 | target/arm: Implement ESB instruction | 46 | hw/arm/omap: Drop useless casts from void * to pointer |
61 | target/arm: Enable FEAT_RAS for -cpu max | 47 | hw/gpio/omap_gpio: Use CamelCase for TYPE_OMAP1_GPIO type name |
62 | target/arm: Enable FEAT_IESB for -cpu max | 48 | hw/gpio/omap_gpio: Use CamelCase for TYPE_OMAP2_GPIO type name |
63 | target/arm: Enable FEAT_CSV2 for -cpu max | 49 | hw/intc/omap_intc: Use CamelCase for TYPE_OMAP_INTC type name |
64 | target/arm: Enable FEAT_CSV2_2 for -cpu max | 50 | hw/arm/stellaris: Drop useless casts from void * to pointer |
65 | target/arm: Enable FEAT_CSV3 for -cpu max | 51 | hw/arm/stellaris: Use CamelCase for STELLARIS_ADC type name |
66 | target/arm: Enable FEAT_DGH for -cpu max | 52 | hw/arm/bcm2836: Remove definitions generated by OBJECT_DECLARE_TYPE() |
67 | target/arm: Define cortex-a76 | 53 | hw/arm/npcm7xx: Declare QOM macros using OBJECT_DECLARE_SIMPLE_TYPE() |
68 | target/arm: Define neoverse-n1 | 54 | hw/misc/sbsa_ec: Rename TYPE_SBSA_EC -> TYPE_SBSA_SECURE_EC |
55 | hw/misc/sbsa_ec: Declare QOM macros using OBJECT_DECLARE_SIMPLE_TYPE() | ||
56 | hw/intc/xilinx_intc: Use 'XpsIntc' typedef instead of 'struct xlx_pic' | ||
57 | hw/timer/xilinx_timer: Use XpsTimerState instead of 'struct timerblock' | ||
69 | 58 | ||
70 | docs/system/arm/emulation.rst | 10 + | 59 | Richard Henderson (1): |
71 | docs/system/arm/virt.rst | 2 + | 60 | target/arm: Fix sve_probe_page |
72 | qapi/machine.json | 6 +- | 61 | |
73 | target/arm/cpregs.h | 11 + | 62 | Strahinja Jankovic (7): |
74 | target/arm/cpu.h | 23 ++ | 63 | hw/misc: Allwinner-A10 Clock Controller Module Emulation |
75 | target/arm/helper.h | 1 + | 64 | hw/misc: Allwinner A10 DRAM Controller Emulation |
76 | target/arm/internals.h | 16 ++ | 65 | {hw/i2c,docs/system/arm}: Allwinner TWI/I2C Emulation |
77 | target/arm/syndrome.h | 5 + | 66 | hw/misc: AXP209 PMU Emulation |
78 | target/arm/a32.decode | 16 +- | 67 | hw/arm: Add AXP209 to Cubieboard |
79 | target/arm/t32.decode | 18 +- | 68 | hw/arm: Allwinner A10 enable SPL load from MMC |
80 | hw/acpi/aml-build.c | 111 ++++---- | 69 | tests/avocado: Add SD boot test to Cubieboard |
81 | hw/arm/sbsa-ref.c | 16 ++ | 70 | |
82 | hw/arm/virt.c | 21 +- | 71 | docs/system/arm/cubieboard.rst | 1 + |
83 | hw/core/machine-hmp-cmds.c | 4 + | 72 | docs/system/arm/orangepi.rst | 1 + |
84 | hw/core/machine.c | 16 ++ | 73 | docs/system/arm/stm32.rst | 1 + |
85 | target/arm/cpu.c | 66 ++++- | 74 | configs/devices/arm-softmmu/default.mak | 1 + |
86 | target/arm/cpu64.c | 353 ++++++++++++++----------- | 75 | include/hw/adc/npcm7xx_adc.h | 7 +- |
87 | target/arm/cpu_tcg.c | 227 +++++++++++----- | 76 | include/hw/arm/allwinner-a10.h | 27 ++ |
88 | target/arm/helper.c | 600 +++++++++++++++++++++++++----------------- | 77 | include/hw/arm/allwinner-h3.h | 3 + |
89 | target/arm/op_helper.c | 43 +++ | 78 | include/hw/arm/npcm7xx.h | 18 +- |
90 | target/arm/translate-a64.c | 18 ++ | 79 | include/hw/arm/omap.h | 24 +- |
91 | target/arm/translate.c | 23 ++ | 80 | include/hw/arm/pxa.h | 11 +- |
92 | tests/qtest/numa-test.c | 19 +- | 81 | include/hw/arm/stm32f405_soc.h | 5 +- |
93 | .mailmap | 3 +- | 82 | include/hw/i2c/allwinner-i2c.h | 55 ++++ |
94 | MAINTAINERS | 2 +- | 83 | include/hw/i2c/npcm7xx_smbus.h | 7 +- |
95 | 25 files changed, 1068 insertions(+), 562 deletions(-) | 84 | include/hw/misc/allwinner-a10-ccm.h | 67 +++++ |
85 | include/hw/misc/allwinner-a10-dramc.h | 68 +++++ | ||
86 | include/hw/misc/npcm7xx_clk.h | 2 +- | ||
87 | include/hw/misc/npcm7xx_gcr.h | 6 +- | ||
88 | include/hw/misc/npcm7xx_mft.h | 7 +- | ||
89 | include/hw/misc/npcm7xx_pwm.h | 3 +- | ||
90 | include/hw/misc/npcm7xx_rng.h | 6 +- | ||
91 | include/hw/net/npcm7xx_emc.h | 5 +- | ||
92 | include/hw/sd/npcm7xx_sdhci.h | 4 +- | ||
93 | hw/arm/allwinner-a10.c | 40 +++ | ||
94 | hw/arm/allwinner-h3.c | 11 +- | ||
95 | hw/arm/bcm2836.c | 9 +- | ||
96 | hw/arm/collie.c | 25 +- | ||
97 | hw/arm/cubieboard.c | 11 + | ||
98 | hw/arm/gumstix.c | 45 ++-- | ||
99 | hw/arm/mainstone.c | 37 ++- | ||
100 | hw/arm/musicpal.c | 9 +- | ||
101 | hw/arm/olimex-stm32-h405.c | 69 +++++ | ||
102 | hw/arm/omap1.c | 115 ++++---- | ||
103 | hw/arm/omap2.c | 40 ++- | ||
104 | hw/arm/omap_sx1.c | 53 ++-- | ||
105 | hw/arm/palm.c | 2 +- | ||
106 | hw/arm/pxa2xx.c | 8 +- | ||
107 | hw/arm/spitz.c | 6 +- | ||
108 | hw/arm/stellaris.c | 73 +++-- | ||
109 | hw/arm/stm32f405_soc.c | 8 + | ||
110 | hw/arm/tosa.c | 2 +- | ||
111 | hw/arm/versatilepb.c | 6 +- | ||
112 | hw/arm/vexpress.c | 10 +- | ||
113 | hw/arm/z2.c | 16 +- | ||
114 | hw/char/omap_uart.c | 7 +- | ||
115 | hw/display/omap_dss.c | 15 +- | ||
116 | hw/display/omap_lcdc.c | 9 +- | ||
117 | hw/dma/omap_dma.c | 15 +- | ||
118 | hw/gpio/omap_gpio.c | 48 ++-- | ||
119 | hw/i2c/allwinner-i2c.c | 459 ++++++++++++++++++++++++++++++++ | ||
120 | hw/intc/omap_intc.c | 38 +-- | ||
121 | hw/intc/xilinx_intc.c | 28 +- | ||
122 | hw/misc/allwinner-a10-ccm.c | 224 ++++++++++++++++ | ||
123 | hw/misc/allwinner-a10-dramc.c | 179 +++++++++++++ | ||
124 | hw/misc/axp209.c | 238 +++++++++++++++++ | ||
125 | hw/misc/omap_gpmc.c | 12 +- | ||
126 | hw/misc/omap_l4.c | 7 +- | ||
127 | hw/misc/omap_sdrc.c | 7 +- | ||
128 | hw/misc/omap_tap.c | 5 +- | ||
129 | hw/misc/sbsa_ec.c | 12 +- | ||
130 | hw/sd/omap_mmc.c | 9 +- | ||
131 | hw/ssi/omap_spi.c | 7 +- | ||
132 | hw/timer/omap_gptimer.c | 22 +- | ||
133 | hw/timer/omap_synctimer.c | 4 +- | ||
134 | hw/timer/xilinx_timer.c | 27 +- | ||
135 | target/arm/helper.c | 3 + | ||
136 | target/arm/sve_helper.c | 14 +- | ||
137 | MAINTAINERS | 8 + | ||
138 | hw/arm/Kconfig | 9 + | ||
139 | hw/arm/meson.build | 1 + | ||
140 | hw/i2c/Kconfig | 4 + | ||
141 | hw/i2c/meson.build | 1 + | ||
142 | hw/i2c/trace-events | 5 + | ||
143 | hw/misc/Kconfig | 10 + | ||
144 | hw/misc/meson.build | 3 + | ||
145 | hw/misc/trace-events | 5 + | ||
146 | tests/avocado/boot_linux_console.py | 47 ++++ | ||
147 | 76 files changed, 1951 insertions(+), 455 deletions(-) | ||
148 | create mode 100644 include/hw/i2c/allwinner-i2c.h | ||
149 | create mode 100644 include/hw/misc/allwinner-a10-ccm.h | ||
150 | create mode 100644 include/hw/misc/allwinner-a10-dramc.h | ||
151 | create mode 100644 hw/arm/olimex-stm32-h405.c | ||
152 | create mode 100644 hw/i2c/allwinner-i2c.c | ||
153 | create mode 100644 hw/misc/allwinner-a10-ccm.c | ||
154 | create mode 100644 hw/misc/allwinner-a10-dramc.c | ||
155 | create mode 100644 hw/misc/axp209.c | ||
156 | diff view generated by jsdifflib |
New patch | |||
---|---|---|---|
1 | From: Felipe Balbi <balbi@kernel.org> | ||
1 | 2 | ||
3 | STM32F405 has 128K of SRAM and another 64K of CCM (Core-coupled | ||
4 | Memory) at a different base address. Correctly describe the memory | ||
5 | layout to give existing FW images a chance to run unmodified. | ||
6 | |||
7 | Reviewed-by: Alistair Francis <alistair@alistair23.me> | ||
8 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> | ||
9 | Signed-off-by: Felipe Balbi <balbi@kernel.org> | ||
10 | Message-id: 20221230145733.200496-2-balbi@kernel.org | ||
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
12 | --- | ||
13 | include/hw/arm/stm32f405_soc.h | 5 ++++- | ||
14 | hw/arm/stm32f405_soc.c | 8 ++++++++ | ||
15 | 2 files changed, 12 insertions(+), 1 deletion(-) | ||
16 | |||
17 | diff --git a/include/hw/arm/stm32f405_soc.h b/include/hw/arm/stm32f405_soc.h | ||
18 | index XXXXXXX..XXXXXXX 100644 | ||
19 | --- a/include/hw/arm/stm32f405_soc.h | ||
20 | +++ b/include/hw/arm/stm32f405_soc.h | ||
21 | @@ -XXX,XX +XXX,XX @@ OBJECT_DECLARE_SIMPLE_TYPE(STM32F405State, STM32F405_SOC) | ||
22 | #define FLASH_BASE_ADDRESS 0x08000000 | ||
23 | #define FLASH_SIZE (1024 * 1024) | ||
24 | #define SRAM_BASE_ADDRESS 0x20000000 | ||
25 | -#define SRAM_SIZE (192 * 1024) | ||
26 | +#define SRAM_SIZE (128 * 1024) | ||
27 | +#define CCM_BASE_ADDRESS 0x10000000 | ||
28 | +#define CCM_SIZE (64 * 1024) | ||
29 | |||
30 | struct STM32F405State { | ||
31 | /*< private >*/ | ||
32 | @@ -XXX,XX +XXX,XX @@ struct STM32F405State { | ||
33 | STM32F2XXADCState adc[STM_NUM_ADCS]; | ||
34 | STM32F2XXSPIState spi[STM_NUM_SPIS]; | ||
35 | |||
36 | + MemoryRegion ccm; | ||
37 | MemoryRegion sram; | ||
38 | MemoryRegion flash; | ||
39 | MemoryRegion flash_alias; | ||
40 | diff --git a/hw/arm/stm32f405_soc.c b/hw/arm/stm32f405_soc.c | ||
41 | index XXXXXXX..XXXXXXX 100644 | ||
42 | --- a/hw/arm/stm32f405_soc.c | ||
43 | +++ b/hw/arm/stm32f405_soc.c | ||
44 | @@ -XXX,XX +XXX,XX @@ static void stm32f405_soc_realize(DeviceState *dev_soc, Error **errp) | ||
45 | } | ||
46 | memory_region_add_subregion(system_memory, SRAM_BASE_ADDRESS, &s->sram); | ||
47 | |||
48 | + memory_region_init_ram(&s->ccm, NULL, "STM32F405.ccm", CCM_SIZE, | ||
49 | + &err); | ||
50 | + if (err != NULL) { | ||
51 | + error_propagate(errp, err); | ||
52 | + return; | ||
53 | + } | ||
54 | + memory_region_add_subregion(system_memory, CCM_BASE_ADDRESS, &s->ccm); | ||
55 | + | ||
56 | armv7m = DEVICE(&s->armv7m); | ||
57 | qdev_prop_set_uint32(armv7m, "num-irq", 96); | ||
58 | qdev_prop_set_string(armv7m, "cpu-type", s->cpu_type); | ||
59 | -- | ||
60 | 2.34.1 | ||
61 | |||
62 | diff view generated by jsdifflib |
1 | From: Leif Lindholm <quic_llindhol@quicinc.com> | 1 | From: Felipe Balbi <balbi@kernel.org> |
---|---|---|---|
2 | 2 | ||
3 | NUVIA was acquired by Qualcomm in March 2021, but kept functioning on | 3 | Olimex makes a series of low-cost STM32 boards. This commit introduces |
4 | separate infrastructure for a transitional period. We've now switched | 4 | the minimum setup to support SMT32-H405. See [1] for details |
5 | over to contributing as Qualcomm Innovation Center (quicinc), so update | ||
6 | my email address to reflect this. | ||
7 | 5 | ||
8 | Signed-off-by: Leif Lindholm <quic_llindhol@quicinc.com> | 6 | [1] https://www.olimex.com/Products/ARM/ST/STM32-H405/ |
9 | Message-id: 20220505113740.75565-1-quic_llindhol@quicinc.com | 7 | |
10 | Cc: Leif Lindholm <leif@nuviainc.com> | 8 | Signed-off-by: Felipe Balbi <balbi@kernel.org> |
11 | Cc: Peter Maydell <peter.maydell@linaro.org> | 9 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
12 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | 10 | Reviewed-by: Alistair Francis <alistair.francis@wdc.com> |
13 | [Fixed commit message typo] | 11 | Message-id: 20221230145733.200496-3-balbi@kernel.org |
14 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 12 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
15 | --- | 13 | --- |
16 | .mailmap | 3 ++- | 14 | docs/system/arm/stm32.rst | 1 + |
17 | MAINTAINERS | 2 +- | 15 | configs/devices/arm-softmmu/default.mak | 1 + |
18 | 2 files changed, 3 insertions(+), 2 deletions(-) | 16 | hw/arm/olimex-stm32-h405.c | 69 +++++++++++++++++++++++++ |
17 | MAINTAINERS | 6 +++ | ||
18 | hw/arm/Kconfig | 4 ++ | ||
19 | hw/arm/meson.build | 1 + | ||
20 | 6 files changed, 82 insertions(+) | ||
21 | create mode 100644 hw/arm/olimex-stm32-h405.c | ||
19 | 22 | ||
20 | diff --git a/.mailmap b/.mailmap | 23 | diff --git a/docs/system/arm/stm32.rst b/docs/system/arm/stm32.rst |
21 | index XXXXXXX..XXXXXXX 100644 | 24 | index XXXXXXX..XXXXXXX 100644 |
22 | --- a/.mailmap | 25 | --- a/docs/system/arm/stm32.rst |
23 | +++ b/.mailmap | 26 | +++ b/docs/system/arm/stm32.rst |
24 | @@ -XXX,XX +XXX,XX @@ Greg Kurz <groug@kaod.org> <gkurz@linux.vnet.ibm.com> | 27 | @@ -XXX,XX +XXX,XX @@ The STM32F4 series is based on ARM Cortex-M4F core. This series is pin-to-pin |
25 | Huacai Chen <chenhuacai@kernel.org> <chenhc@lemote.com> | 28 | compatible with STM32F2 series. The following machines are based on this chip : |
26 | Huacai Chen <chenhuacai@kernel.org> <chenhuacai@loongson.cn> | 29 | |
27 | James Hogan <jhogan@kernel.org> <james.hogan@imgtec.com> | 30 | - ``netduinoplus2`` Netduino Plus 2 board with STM32F405RGT6 microcontroller |
28 | -Leif Lindholm <leif@nuviainc.com> <leif.lindholm@linaro.org> | 31 | +- ``olimex-stm32-h405`` Olimex STM32 H405 board with STM32F405RGT6 microcontroller |
29 | +Leif Lindholm <quic_llindhol@quicinc.com> <leif.lindholm@linaro.org> | 32 | |
30 | +Leif Lindholm <quic_llindhol@quicinc.com> <leif@nuviainc.com> | 33 | There are many other STM32 series that are currently not supported by QEMU. |
31 | Radoslaw Biernacki <rad@semihalf.com> <radoslaw.biernacki@linaro.org> | 34 | |
32 | Paul Burton <paulburton@kernel.org> <paul.burton@mips.com> | 35 | diff --git a/configs/devices/arm-softmmu/default.mak b/configs/devices/arm-softmmu/default.mak |
33 | Paul Burton <paulburton@kernel.org> <paul.burton@imgtec.com> | 36 | index XXXXXXX..XXXXXXX 100644 |
37 | --- a/configs/devices/arm-softmmu/default.mak | ||
38 | +++ b/configs/devices/arm-softmmu/default.mak | ||
39 | @@ -XXX,XX +XXX,XX @@ CONFIG_COLLIE=y | ||
40 | CONFIG_ASPEED_SOC=y | ||
41 | CONFIG_NETDUINO2=y | ||
42 | CONFIG_NETDUINOPLUS2=y | ||
43 | +CONFIG_OLIMEX_STM32_H405=y | ||
44 | CONFIG_MPS2=y | ||
45 | CONFIG_RASPI=y | ||
46 | CONFIG_DIGIC=y | ||
47 | diff --git a/hw/arm/olimex-stm32-h405.c b/hw/arm/olimex-stm32-h405.c | ||
48 | new file mode 100644 | ||
49 | index XXXXXXX..XXXXXXX | ||
50 | --- /dev/null | ||
51 | +++ b/hw/arm/olimex-stm32-h405.c | ||
52 | @@ -XXX,XX +XXX,XX @@ | ||
53 | +/* | ||
54 | + * ST STM32VLDISCOVERY machine | ||
55 | + * Olimex STM32-H405 machine | ||
56 | + * | ||
57 | + * Copyright (c) 2022 Felipe Balbi <balbi@kernel.org> | ||
58 | + * | ||
59 | + * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
60 | + * of this software and associated documentation files (the "Software"), to deal | ||
61 | + * in the Software without restriction, including without limitation the rights | ||
62 | + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
63 | + * copies of the Software, and to permit persons to whom the Software is | ||
64 | + * furnished to do so, subject to the following conditions: | ||
65 | + * | ||
66 | + * The above copyright notice and this permission notice shall be included in | ||
67 | + * all copies or substantial portions of the Software. | ||
68 | + * | ||
69 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
70 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
71 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
72 | + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
73 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
74 | + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
75 | + * THE SOFTWARE. | ||
76 | + */ | ||
77 | + | ||
78 | +#include "qemu/osdep.h" | ||
79 | +#include "qapi/error.h" | ||
80 | +#include "hw/boards.h" | ||
81 | +#include "hw/qdev-properties.h" | ||
82 | +#include "hw/qdev-clock.h" | ||
83 | +#include "qemu/error-report.h" | ||
84 | +#include "hw/arm/stm32f405_soc.h" | ||
85 | +#include "hw/arm/boot.h" | ||
86 | + | ||
87 | +/* olimex-stm32-h405 implementation is derived from netduinoplus2 */ | ||
88 | + | ||
89 | +/* Main SYSCLK frequency in Hz (168MHz) */ | ||
90 | +#define SYSCLK_FRQ 168000000ULL | ||
91 | + | ||
92 | +static void olimex_stm32_h405_init(MachineState *machine) | ||
93 | +{ | ||
94 | + DeviceState *dev; | ||
95 | + Clock *sysclk; | ||
96 | + | ||
97 | + /* This clock doesn't need migration because it is fixed-frequency */ | ||
98 | + sysclk = clock_new(OBJECT(machine), "SYSCLK"); | ||
99 | + clock_set_hz(sysclk, SYSCLK_FRQ); | ||
100 | + | ||
101 | + dev = qdev_new(TYPE_STM32F405_SOC); | ||
102 | + qdev_prop_set_string(dev, "cpu-type", ARM_CPU_TYPE_NAME("cortex-m4")); | ||
103 | + qdev_connect_clock_in(dev, "sysclk", sysclk); | ||
104 | + sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal); | ||
105 | + | ||
106 | + armv7m_load_kernel(ARM_CPU(first_cpu), | ||
107 | + machine->kernel_filename, | ||
108 | + 0, FLASH_SIZE); | ||
109 | +} | ||
110 | + | ||
111 | +static void olimex_stm32_h405_machine_init(MachineClass *mc) | ||
112 | +{ | ||
113 | + mc->desc = "Olimex STM32-H405 (Cortex-M4)"; | ||
114 | + mc->init = olimex_stm32_h405_init; | ||
115 | + mc->default_cpu_type = ARM_CPU_TYPE_NAME("cortex-m4"); | ||
116 | + | ||
117 | + /* SRAM pre-allocated as part of the SoC instantiation */ | ||
118 | + mc->default_ram_size = 0; | ||
119 | +} | ||
120 | + | ||
121 | +DEFINE_MACHINE("olimex-stm32-h405", olimex_stm32_h405_machine_init) | ||
34 | diff --git a/MAINTAINERS b/MAINTAINERS | 122 | diff --git a/MAINTAINERS b/MAINTAINERS |
35 | index XXXXXXX..XXXXXXX 100644 | 123 | index XXXXXXX..XXXXXXX 100644 |
36 | --- a/MAINTAINERS | 124 | --- a/MAINTAINERS |
37 | +++ b/MAINTAINERS | 125 | +++ b/MAINTAINERS |
38 | @@ -XXX,XX +XXX,XX @@ F: include/hw/ssi/imx_spi.h | 126 | @@ -XXX,XX +XXX,XX @@ L: qemu-arm@nongnu.org |
39 | SBSA-REF | 127 | S: Maintained |
40 | M: Radoslaw Biernacki <rad@semihalf.com> | 128 | F: hw/arm/netduinoplus2.c |
129 | |||
130 | +Olimex STM32 H405 | ||
131 | +M: Felipe Balbi <balbi@kernel.org> | ||
132 | +L: qemu-arm@nongnu.org | ||
133 | +S: Maintained | ||
134 | +F: hw/arm/olimex-stm32-h405.c | ||
135 | + | ||
136 | SmartFusion2 | ||
137 | M: Subbaraya Sundeep <sundeep.lkml@gmail.com> | ||
41 | M: Peter Maydell <peter.maydell@linaro.org> | 138 | M: Peter Maydell <peter.maydell@linaro.org> |
42 | -R: Leif Lindholm <leif@nuviainc.com> | 139 | diff --git a/hw/arm/Kconfig b/hw/arm/Kconfig |
43 | +R: Leif Lindholm <quic_llindhol@quicinc.com> | 140 | index XXXXXXX..XXXXXXX 100644 |
44 | L: qemu-arm@nongnu.org | 141 | --- a/hw/arm/Kconfig |
45 | S: Maintained | 142 | +++ b/hw/arm/Kconfig |
46 | F: hw/arm/sbsa-ref.c | 143 | @@ -XXX,XX +XXX,XX @@ config NETDUINOPLUS2 |
144 | bool | ||
145 | select STM32F405_SOC | ||
146 | |||
147 | +config OLIMEX_STM32_H405 | ||
148 | + bool | ||
149 | + select STM32F405_SOC | ||
150 | + | ||
151 | config NSERIES | ||
152 | bool | ||
153 | select OMAP | ||
154 | diff --git a/hw/arm/meson.build b/hw/arm/meson.build | ||
155 | index XXXXXXX..XXXXXXX 100644 | ||
156 | --- a/hw/arm/meson.build | ||
157 | +++ b/hw/arm/meson.build | ||
158 | @@ -XXX,XX +XXX,XX @@ arm_ss.add(when: 'CONFIG_MICROBIT', if_true: files('microbit.c')) | ||
159 | arm_ss.add(when: 'CONFIG_MUSICPAL', if_true: files('musicpal.c')) | ||
160 | arm_ss.add(when: 'CONFIG_NETDUINO2', if_true: files('netduino2.c')) | ||
161 | arm_ss.add(when: 'CONFIG_NETDUINOPLUS2', if_true: files('netduinoplus2.c')) | ||
162 | +arm_ss.add(when: 'CONFIG_OLIMEX_STM32_H405', if_true: files('olimex-stm32-h405.c')) | ||
163 | arm_ss.add(when: 'CONFIG_NPCM7XX', if_true: files('npcm7xx.c', 'npcm7xx_boards.c')) | ||
164 | arm_ss.add(when: 'CONFIG_NSERIES', if_true: files('nseries.c')) | ||
165 | arm_ss.add(when: 'CONFIG_SX1', if_true: files('omap_sx1.c')) | ||
47 | -- | 166 | -- |
48 | 2.25.1 | 167 | 2.34.1 |
49 | 168 | ||
50 | 169 | diff view generated by jsdifflib |
New patch | |||
---|---|---|---|
1 | From: Strahinja Jankovic <strahinjapjankovic@gmail.com> | ||
1 | 2 | ||
3 | During SPL boot several Clock Controller Module (CCM) registers are | ||
4 | read, most important are PLL and Tuning, as well as divisor registers. | ||
5 | |||
6 | This patch adds these registers and initializes reset values from user's | ||
7 | guide. | ||
8 | |||
9 | Signed-off-by: Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
10 | |||
11 | Reviewed-by: Niek Linnenbank <nieklinnenbank@gmail.com> | ||
12 | Message-id: 20221226220303.14420-2-strahinja.p.jankovic@gmail.com | ||
13 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
14 | --- | ||
15 | include/hw/arm/allwinner-a10.h | 2 + | ||
16 | include/hw/misc/allwinner-a10-ccm.h | 67 +++++++++ | ||
17 | hw/arm/allwinner-a10.c | 7 + | ||
18 | hw/misc/allwinner-a10-ccm.c | 224 ++++++++++++++++++++++++++++ | ||
19 | hw/arm/Kconfig | 1 + | ||
20 | hw/misc/Kconfig | 3 + | ||
21 | hw/misc/meson.build | 1 + | ||
22 | 7 files changed, 305 insertions(+) | ||
23 | create mode 100644 include/hw/misc/allwinner-a10-ccm.h | ||
24 | create mode 100644 hw/misc/allwinner-a10-ccm.c | ||
25 | |||
26 | diff --git a/include/hw/arm/allwinner-a10.h b/include/hw/arm/allwinner-a10.h | ||
27 | index XXXXXXX..XXXXXXX 100644 | ||
28 | --- a/include/hw/arm/allwinner-a10.h | ||
29 | +++ b/include/hw/arm/allwinner-a10.h | ||
30 | @@ -XXX,XX +XXX,XX @@ | ||
31 | #include "hw/usb/hcd-ohci.h" | ||
32 | #include "hw/usb/hcd-ehci.h" | ||
33 | #include "hw/rtc/allwinner-rtc.h" | ||
34 | +#include "hw/misc/allwinner-a10-ccm.h" | ||
35 | |||
36 | #include "target/arm/cpu.h" | ||
37 | #include "qom/object.h" | ||
38 | @@ -XXX,XX +XXX,XX @@ struct AwA10State { | ||
39 | /*< public >*/ | ||
40 | |||
41 | ARMCPU cpu; | ||
42 | + AwA10ClockCtlState ccm; | ||
43 | AwA10PITState timer; | ||
44 | AwA10PICState intc; | ||
45 | AwEmacState emac; | ||
46 | diff --git a/include/hw/misc/allwinner-a10-ccm.h b/include/hw/misc/allwinner-a10-ccm.h | ||
47 | new file mode 100644 | ||
48 | index XXXXXXX..XXXXXXX | ||
49 | --- /dev/null | ||
50 | +++ b/include/hw/misc/allwinner-a10-ccm.h | ||
51 | @@ -XXX,XX +XXX,XX @@ | ||
52 | +/* | ||
53 | + * Allwinner A10 Clock Control Module emulation | ||
54 | + * | ||
55 | + * Copyright (C) 2022 Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
56 | + * | ||
57 | + * This file is derived from Allwinner H3 CCU, | ||
58 | + * by Niek Linnenbank. | ||
59 | + * | ||
60 | + * This program is free software: you can redistribute it and/or modify | ||
61 | + * it under the terms of the GNU General Public License as published by | ||
62 | + * the Free Software Foundation, either version 2 of the License, or | ||
63 | + * (at your option) any later version. | ||
64 | + * | ||
65 | + * This program is distributed in the hope that it will be useful, | ||
66 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
67 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
68 | + * GNU General Public License for more details. | ||
69 | + * | ||
70 | + * You should have received a copy of the GNU General Public License | ||
71 | + * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
72 | + */ | ||
73 | + | ||
74 | +#ifndef HW_MISC_ALLWINNER_A10_CCM_H | ||
75 | +#define HW_MISC_ALLWINNER_A10_CCM_H | ||
76 | + | ||
77 | +#include "qom/object.h" | ||
78 | +#include "hw/sysbus.h" | ||
79 | + | ||
80 | +/** | ||
81 | + * @name Constants | ||
82 | + * @{ | ||
83 | + */ | ||
84 | + | ||
85 | +/** Size of register I/O address space used by CCM device */ | ||
86 | +#define AW_A10_CCM_IOSIZE (0x400) | ||
87 | + | ||
88 | +/** Total number of known registers */ | ||
89 | +#define AW_A10_CCM_REGS_NUM (AW_A10_CCM_IOSIZE / sizeof(uint32_t)) | ||
90 | + | ||
91 | +/** @} */ | ||
92 | + | ||
93 | +/** | ||
94 | + * @name Object model | ||
95 | + * @{ | ||
96 | + */ | ||
97 | + | ||
98 | +#define TYPE_AW_A10_CCM "allwinner-a10-ccm" | ||
99 | +OBJECT_DECLARE_SIMPLE_TYPE(AwA10ClockCtlState, AW_A10_CCM) | ||
100 | + | ||
101 | +/** @} */ | ||
102 | + | ||
103 | +/** | ||
104 | + * Allwinner A10 CCM object instance state. | ||
105 | + */ | ||
106 | +struct AwA10ClockCtlState { | ||
107 | + /*< private >*/ | ||
108 | + SysBusDevice parent_obj; | ||
109 | + /*< public >*/ | ||
110 | + | ||
111 | + /** Maps I/O registers in physical memory */ | ||
112 | + MemoryRegion iomem; | ||
113 | + | ||
114 | + /** Array of hardware registers */ | ||
115 | + uint32_t regs[AW_A10_CCM_REGS_NUM]; | ||
116 | +}; | ||
117 | + | ||
118 | +#endif /* HW_MISC_ALLWINNER_H3_CCU_H */ | ||
119 | diff --git a/hw/arm/allwinner-a10.c b/hw/arm/allwinner-a10.c | ||
120 | index XXXXXXX..XXXXXXX 100644 | ||
121 | --- a/hw/arm/allwinner-a10.c | ||
122 | +++ b/hw/arm/allwinner-a10.c | ||
123 | @@ -XXX,XX +XXX,XX @@ | ||
124 | #include "hw/usb/hcd-ohci.h" | ||
125 | |||
126 | #define AW_A10_MMC0_BASE 0x01c0f000 | ||
127 | +#define AW_A10_CCM_BASE 0x01c20000 | ||
128 | #define AW_A10_PIC_REG_BASE 0x01c20400 | ||
129 | #define AW_A10_PIT_REG_BASE 0x01c20c00 | ||
130 | #define AW_A10_UART0_REG_BASE 0x01c28000 | ||
131 | @@ -XXX,XX +XXX,XX @@ static void aw_a10_init(Object *obj) | ||
132 | |||
133 | object_initialize_child(obj, "timer", &s->timer, TYPE_AW_A10_PIT); | ||
134 | |||
135 | + object_initialize_child(obj, "ccm", &s->ccm, TYPE_AW_A10_CCM); | ||
136 | + | ||
137 | object_initialize_child(obj, "emac", &s->emac, TYPE_AW_EMAC); | ||
138 | |||
139 | object_initialize_child(obj, "sata", &s->sata, TYPE_ALLWINNER_AHCI); | ||
140 | @@ -XXX,XX +XXX,XX @@ static void aw_a10_realize(DeviceState *dev, Error **errp) | ||
141 | memory_region_add_subregion(get_system_memory(), 0x00000000, &s->sram_a); | ||
142 | create_unimplemented_device("a10-sram-ctrl", 0x01c00000, 4 * KiB); | ||
143 | |||
144 | + /* Clock Control Module */ | ||
145 | + sysbus_realize(SYS_BUS_DEVICE(&s->ccm), &error_fatal); | ||
146 | + sysbus_mmio_map(SYS_BUS_DEVICE(&s->ccm), 0, AW_A10_CCM_BASE); | ||
147 | + | ||
148 | /* FIXME use qdev NIC properties instead of nd_table[] */ | ||
149 | if (nd_table[0].used) { | ||
150 | qemu_check_nic_model(&nd_table[0], TYPE_AW_EMAC); | ||
151 | diff --git a/hw/misc/allwinner-a10-ccm.c b/hw/misc/allwinner-a10-ccm.c | ||
152 | new file mode 100644 | ||
153 | index XXXXXXX..XXXXXXX | ||
154 | --- /dev/null | ||
155 | +++ b/hw/misc/allwinner-a10-ccm.c | ||
156 | @@ -XXX,XX +XXX,XX @@ | ||
157 | +/* | ||
158 | + * Allwinner A10 Clock Control Module emulation | ||
159 | + * | ||
160 | + * Copyright (C) 2022 Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
161 | + * | ||
162 | + * This file is derived from Allwinner H3 CCU, | ||
163 | + * by Niek Linnenbank. | ||
164 | + * | ||
165 | + * This program is free software: you can redistribute it and/or modify | ||
166 | + * it under the terms of the GNU General Public License as published by | ||
167 | + * the Free Software Foundation, either version 2 of the License, or | ||
168 | + * (at your option) any later version. | ||
169 | + * | ||
170 | + * This program is distributed in the hope that it will be useful, | ||
171 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
172 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
173 | + * GNU General Public License for more details. | ||
174 | + * | ||
175 | + * You should have received a copy of the GNU General Public License | ||
176 | + * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
177 | + */ | ||
178 | + | ||
179 | +#include "qemu/osdep.h" | ||
180 | +#include "qemu/units.h" | ||
181 | +#include "hw/sysbus.h" | ||
182 | +#include "migration/vmstate.h" | ||
183 | +#include "qemu/log.h" | ||
184 | +#include "qemu/module.h" | ||
185 | +#include "hw/misc/allwinner-a10-ccm.h" | ||
186 | + | ||
187 | +/* CCM register offsets */ | ||
188 | +enum { | ||
189 | + REG_PLL1_CFG = 0x0000, /* PLL1 Control */ | ||
190 | + REG_PLL1_TUN = 0x0004, /* PLL1 Tuning */ | ||
191 | + REG_PLL2_CFG = 0x0008, /* PLL2 Control */ | ||
192 | + REG_PLL2_TUN = 0x000C, /* PLL2 Tuning */ | ||
193 | + REG_PLL3_CFG = 0x0010, /* PLL3 Control */ | ||
194 | + REG_PLL4_CFG = 0x0018, /* PLL4 Control */ | ||
195 | + REG_PLL5_CFG = 0x0020, /* PLL5 Control */ | ||
196 | + REG_PLL5_TUN = 0x0024, /* PLL5 Tuning */ | ||
197 | + REG_PLL6_CFG = 0x0028, /* PLL6 Control */ | ||
198 | + REG_PLL6_TUN = 0x002C, /* PLL6 Tuning */ | ||
199 | + REG_PLL7_CFG = 0x0030, /* PLL7 Control */ | ||
200 | + REG_PLL1_TUN2 = 0x0038, /* PLL1 Tuning2 */ | ||
201 | + REG_PLL5_TUN2 = 0x003C, /* PLL5 Tuning2 */ | ||
202 | + REG_PLL8_CFG = 0x0040, /* PLL8 Control */ | ||
203 | + REG_OSC24M_CFG = 0x0050, /* OSC24M Control */ | ||
204 | + REG_CPU_AHB_APB0_CFG = 0x0054, /* CPU, AHB and APB0 Divide Ratio */ | ||
205 | +}; | ||
206 | + | ||
207 | +#define REG_INDEX(offset) (offset / sizeof(uint32_t)) | ||
208 | + | ||
209 | +/* CCM register reset values */ | ||
210 | +enum { | ||
211 | + REG_PLL1_CFG_RST = 0x21005000, | ||
212 | + REG_PLL1_TUN_RST = 0x0A101000, | ||
213 | + REG_PLL2_CFG_RST = 0x08100010, | ||
214 | + REG_PLL2_TUN_RST = 0x00000000, | ||
215 | + REG_PLL3_CFG_RST = 0x0010D063, | ||
216 | + REG_PLL4_CFG_RST = 0x21009911, | ||
217 | + REG_PLL5_CFG_RST = 0x11049280, | ||
218 | + REG_PLL5_TUN_RST = 0x14888000, | ||
219 | + REG_PLL6_CFG_RST = 0x21009911, | ||
220 | + REG_PLL6_TUN_RST = 0x00000000, | ||
221 | + REG_PLL7_CFG_RST = 0x0010D063, | ||
222 | + REG_PLL1_TUN2_RST = 0x00000000, | ||
223 | + REG_PLL5_TUN2_RST = 0x00000000, | ||
224 | + REG_PLL8_CFG_RST = 0x21009911, | ||
225 | + REG_OSC24M_CFG_RST = 0x00138013, | ||
226 | + REG_CPU_AHB_APB0_CFG_RST = 0x00010010, | ||
227 | +}; | ||
228 | + | ||
229 | +static uint64_t allwinner_a10_ccm_read(void *opaque, hwaddr offset, | ||
230 | + unsigned size) | ||
231 | +{ | ||
232 | + const AwA10ClockCtlState *s = AW_A10_CCM(opaque); | ||
233 | + const uint32_t idx = REG_INDEX(offset); | ||
234 | + | ||
235 | + switch (offset) { | ||
236 | + case REG_PLL1_CFG: | ||
237 | + case REG_PLL1_TUN: | ||
238 | + case REG_PLL2_CFG: | ||
239 | + case REG_PLL2_TUN: | ||
240 | + case REG_PLL3_CFG: | ||
241 | + case REG_PLL4_CFG: | ||
242 | + case REG_PLL5_CFG: | ||
243 | + case REG_PLL5_TUN: | ||
244 | + case REG_PLL6_CFG: | ||
245 | + case REG_PLL6_TUN: | ||
246 | + case REG_PLL7_CFG: | ||
247 | + case REG_PLL1_TUN2: | ||
248 | + case REG_PLL5_TUN2: | ||
249 | + case REG_PLL8_CFG: | ||
250 | + case REG_OSC24M_CFG: | ||
251 | + case REG_CPU_AHB_APB0_CFG: | ||
252 | + break; | ||
253 | + case 0x158 ... AW_A10_CCM_IOSIZE: | ||
254 | + qemu_log_mask(LOG_GUEST_ERROR, "%s: out-of-bounds offset 0x%04x\n", | ||
255 | + __func__, (uint32_t)offset); | ||
256 | + return 0; | ||
257 | + default: | ||
258 | + qemu_log_mask(LOG_UNIMP, "%s: unimplemented read offset 0x%04x\n", | ||
259 | + __func__, (uint32_t)offset); | ||
260 | + return 0; | ||
261 | + } | ||
262 | + | ||
263 | + return s->regs[idx]; | ||
264 | +} | ||
265 | + | ||
266 | +static void allwinner_a10_ccm_write(void *opaque, hwaddr offset, | ||
267 | + uint64_t val, unsigned size) | ||
268 | +{ | ||
269 | + AwA10ClockCtlState *s = AW_A10_CCM(opaque); | ||
270 | + const uint32_t idx = REG_INDEX(offset); | ||
271 | + | ||
272 | + switch (offset) { | ||
273 | + case REG_PLL1_CFG: | ||
274 | + case REG_PLL1_TUN: | ||
275 | + case REG_PLL2_CFG: | ||
276 | + case REG_PLL2_TUN: | ||
277 | + case REG_PLL3_CFG: | ||
278 | + case REG_PLL4_CFG: | ||
279 | + case REG_PLL5_CFG: | ||
280 | + case REG_PLL5_TUN: | ||
281 | + case REG_PLL6_CFG: | ||
282 | + case REG_PLL6_TUN: | ||
283 | + case REG_PLL7_CFG: | ||
284 | + case REG_PLL1_TUN2: | ||
285 | + case REG_PLL5_TUN2: | ||
286 | + case REG_PLL8_CFG: | ||
287 | + case REG_OSC24M_CFG: | ||
288 | + case REG_CPU_AHB_APB0_CFG: | ||
289 | + break; | ||
290 | + case 0x158 ... AW_A10_CCM_IOSIZE: | ||
291 | + qemu_log_mask(LOG_GUEST_ERROR, "%s: out-of-bounds offset 0x%04x\n", | ||
292 | + __func__, (uint32_t)offset); | ||
293 | + break; | ||
294 | + default: | ||
295 | + qemu_log_mask(LOG_UNIMP, "%s: unimplemented write offset 0x%04x\n", | ||
296 | + __func__, (uint32_t)offset); | ||
297 | + break; | ||
298 | + } | ||
299 | + | ||
300 | + s->regs[idx] = (uint32_t) val; | ||
301 | +} | ||
302 | + | ||
303 | +static const MemoryRegionOps allwinner_a10_ccm_ops = { | ||
304 | + .read = allwinner_a10_ccm_read, | ||
305 | + .write = allwinner_a10_ccm_write, | ||
306 | + .endianness = DEVICE_NATIVE_ENDIAN, | ||
307 | + .valid = { | ||
308 | + .min_access_size = 4, | ||
309 | + .max_access_size = 4, | ||
310 | + }, | ||
311 | + .impl.min_access_size = 4, | ||
312 | +}; | ||
313 | + | ||
314 | +static void allwinner_a10_ccm_reset_enter(Object *obj, ResetType type) | ||
315 | +{ | ||
316 | + AwA10ClockCtlState *s = AW_A10_CCM(obj); | ||
317 | + | ||
318 | + /* Set default values for registers */ | ||
319 | + s->regs[REG_INDEX(REG_PLL1_CFG)] = REG_PLL1_CFG_RST; | ||
320 | + s->regs[REG_INDEX(REG_PLL1_TUN)] = REG_PLL1_TUN_RST; | ||
321 | + s->regs[REG_INDEX(REG_PLL2_CFG)] = REG_PLL2_CFG_RST; | ||
322 | + s->regs[REG_INDEX(REG_PLL2_TUN)] = REG_PLL2_TUN_RST; | ||
323 | + s->regs[REG_INDEX(REG_PLL3_CFG)] = REG_PLL3_CFG_RST; | ||
324 | + s->regs[REG_INDEX(REG_PLL4_CFG)] = REG_PLL4_CFG_RST; | ||
325 | + s->regs[REG_INDEX(REG_PLL5_CFG)] = REG_PLL5_CFG_RST; | ||
326 | + s->regs[REG_INDEX(REG_PLL5_TUN)] = REG_PLL5_TUN_RST; | ||
327 | + s->regs[REG_INDEX(REG_PLL6_CFG)] = REG_PLL6_CFG_RST; | ||
328 | + s->regs[REG_INDEX(REG_PLL6_TUN)] = REG_PLL6_TUN_RST; | ||
329 | + s->regs[REG_INDEX(REG_PLL7_CFG)] = REG_PLL7_CFG_RST; | ||
330 | + s->regs[REG_INDEX(REG_PLL1_TUN2)] = REG_PLL1_TUN2_RST; | ||
331 | + s->regs[REG_INDEX(REG_PLL5_TUN2)] = REG_PLL5_TUN2_RST; | ||
332 | + s->regs[REG_INDEX(REG_PLL8_CFG)] = REG_PLL8_CFG_RST; | ||
333 | + s->regs[REG_INDEX(REG_OSC24M_CFG)] = REG_OSC24M_CFG_RST; | ||
334 | + s->regs[REG_INDEX(REG_CPU_AHB_APB0_CFG)] = REG_CPU_AHB_APB0_CFG_RST; | ||
335 | +} | ||
336 | + | ||
337 | +static void allwinner_a10_ccm_init(Object *obj) | ||
338 | +{ | ||
339 | + SysBusDevice *sbd = SYS_BUS_DEVICE(obj); | ||
340 | + AwA10ClockCtlState *s = AW_A10_CCM(obj); | ||
341 | + | ||
342 | + /* Memory mapping */ | ||
343 | + memory_region_init_io(&s->iomem, OBJECT(s), &allwinner_a10_ccm_ops, s, | ||
344 | + TYPE_AW_A10_CCM, AW_A10_CCM_IOSIZE); | ||
345 | + sysbus_init_mmio(sbd, &s->iomem); | ||
346 | +} | ||
347 | + | ||
348 | +static const VMStateDescription allwinner_a10_ccm_vmstate = { | ||
349 | + .name = "allwinner-a10-ccm", | ||
350 | + .version_id = 1, | ||
351 | + .minimum_version_id = 1, | ||
352 | + .fields = (VMStateField[]) { | ||
353 | + VMSTATE_UINT32_ARRAY(regs, AwA10ClockCtlState, AW_A10_CCM_REGS_NUM), | ||
354 | + VMSTATE_END_OF_LIST() | ||
355 | + } | ||
356 | +}; | ||
357 | + | ||
358 | +static void allwinner_a10_ccm_class_init(ObjectClass *klass, void *data) | ||
359 | +{ | ||
360 | + DeviceClass *dc = DEVICE_CLASS(klass); | ||
361 | + ResettableClass *rc = RESETTABLE_CLASS(klass); | ||
362 | + | ||
363 | + rc->phases.enter = allwinner_a10_ccm_reset_enter; | ||
364 | + dc->vmsd = &allwinner_a10_ccm_vmstate; | ||
365 | +} | ||
366 | + | ||
367 | +static const TypeInfo allwinner_a10_ccm_info = { | ||
368 | + .name = TYPE_AW_A10_CCM, | ||
369 | + .parent = TYPE_SYS_BUS_DEVICE, | ||
370 | + .instance_init = allwinner_a10_ccm_init, | ||
371 | + .instance_size = sizeof(AwA10ClockCtlState), | ||
372 | + .class_init = allwinner_a10_ccm_class_init, | ||
373 | +}; | ||
374 | + | ||
375 | +static void allwinner_a10_ccm_register(void) | ||
376 | +{ | ||
377 | + type_register_static(&allwinner_a10_ccm_info); | ||
378 | +} | ||
379 | + | ||
380 | +type_init(allwinner_a10_ccm_register) | ||
381 | diff --git a/hw/arm/Kconfig b/hw/arm/Kconfig | ||
382 | index XXXXXXX..XXXXXXX 100644 | ||
383 | --- a/hw/arm/Kconfig | ||
384 | +++ b/hw/arm/Kconfig | ||
385 | @@ -XXX,XX +XXX,XX @@ config ALLWINNER_A10 | ||
386 | select AHCI | ||
387 | select ALLWINNER_A10_PIT | ||
388 | select ALLWINNER_A10_PIC | ||
389 | + select ALLWINNER_A10_CCM | ||
390 | select ALLWINNER_EMAC | ||
391 | select SERIAL | ||
392 | select UNIMP | ||
393 | diff --git a/hw/misc/Kconfig b/hw/misc/Kconfig | ||
394 | index XXXXXXX..XXXXXXX 100644 | ||
395 | --- a/hw/misc/Kconfig | ||
396 | +++ b/hw/misc/Kconfig | ||
397 | @@ -XXX,XX +XXX,XX @@ config VIRT_CTRL | ||
398 | config LASI | ||
399 | bool | ||
400 | |||
401 | +config ALLWINNER_A10_CCM | ||
402 | + bool | ||
403 | + | ||
404 | source macio/Kconfig | ||
405 | diff --git a/hw/misc/meson.build b/hw/misc/meson.build | ||
406 | index XXXXXXX..XXXXXXX 100644 | ||
407 | --- a/hw/misc/meson.build | ||
408 | +++ b/hw/misc/meson.build | ||
409 | @@ -XXX,XX +XXX,XX @@ subdir('macio') | ||
410 | |||
411 | softmmu_ss.add(when: 'CONFIG_IVSHMEM_DEVICE', if_true: files('ivshmem.c')) | ||
412 | |||
413 | +softmmu_ss.add(when: 'CONFIG_ALLWINNER_A10_CCM', if_true: files('allwinner-a10-ccm.c')) | ||
414 | softmmu_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-h3-ccu.c')) | ||
415 | specific_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-cpucfg.c')) | ||
416 | softmmu_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-h3-dramc.c')) | ||
417 | -- | ||
418 | 2.34.1 | diff view generated by jsdifflib |
New patch | |||
---|---|---|---|
1 | 1 | From: Strahinja Jankovic <strahinjapjankovic@gmail.com> | |
2 | |||
3 | During SPL boot several DRAM Controller registers are used. Most | ||
4 | important registers are those related to DRAM initialization and | ||
5 | calibration, where SPL initiates process and waits until certain bit is | ||
6 | set/cleared. | ||
7 | |||
8 | This patch adds these registers, initializes reset values from user's | ||
9 | guide and updates state of registers as SPL expects it. | ||
10 | |||
11 | Signed-off-by: Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
12 | |||
13 | Reviewed-by: Niek Linnenbank <nieklinnenbank@gmail.com> | ||
14 | Message-id: 20221226220303.14420-3-strahinja.p.jankovic@gmail.com | ||
15 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
16 | --- | ||
17 | include/hw/arm/allwinner-a10.h | 2 + | ||
18 | include/hw/misc/allwinner-a10-dramc.h | 68 ++++++++++ | ||
19 | hw/arm/allwinner-a10.c | 7 + | ||
20 | hw/misc/allwinner-a10-dramc.c | 179 ++++++++++++++++++++++++++ | ||
21 | hw/arm/Kconfig | 1 + | ||
22 | hw/misc/Kconfig | 3 + | ||
23 | hw/misc/meson.build | 1 + | ||
24 | 7 files changed, 261 insertions(+) | ||
25 | create mode 100644 include/hw/misc/allwinner-a10-dramc.h | ||
26 | create mode 100644 hw/misc/allwinner-a10-dramc.c | ||
27 | |||
28 | diff --git a/include/hw/arm/allwinner-a10.h b/include/hw/arm/allwinner-a10.h | ||
29 | index XXXXXXX..XXXXXXX 100644 | ||
30 | --- a/include/hw/arm/allwinner-a10.h | ||
31 | +++ b/include/hw/arm/allwinner-a10.h | ||
32 | @@ -XXX,XX +XXX,XX @@ | ||
33 | #include "hw/usb/hcd-ehci.h" | ||
34 | #include "hw/rtc/allwinner-rtc.h" | ||
35 | #include "hw/misc/allwinner-a10-ccm.h" | ||
36 | +#include "hw/misc/allwinner-a10-dramc.h" | ||
37 | |||
38 | #include "target/arm/cpu.h" | ||
39 | #include "qom/object.h" | ||
40 | @@ -XXX,XX +XXX,XX @@ struct AwA10State { | ||
41 | |||
42 | ARMCPU cpu; | ||
43 | AwA10ClockCtlState ccm; | ||
44 | + AwA10DramControllerState dramc; | ||
45 | AwA10PITState timer; | ||
46 | AwA10PICState intc; | ||
47 | AwEmacState emac; | ||
48 | diff --git a/include/hw/misc/allwinner-a10-dramc.h b/include/hw/misc/allwinner-a10-dramc.h | ||
49 | new file mode 100644 | ||
50 | index XXXXXXX..XXXXXXX | ||
51 | --- /dev/null | ||
52 | +++ b/include/hw/misc/allwinner-a10-dramc.h | ||
53 | @@ -XXX,XX +XXX,XX @@ | ||
54 | +/* | ||
55 | + * Allwinner A10 DRAM Controller emulation | ||
56 | + * | ||
57 | + * Copyright (C) 2022 Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
58 | + * | ||
59 | + * This file is derived from Allwinner H3 DRAMC, | ||
60 | + * by Niek Linnenbank. | ||
61 | + * | ||
62 | + * This program is free software: you can redistribute it and/or modify | ||
63 | + * it under the terms of the GNU General Public License as published by | ||
64 | + * the Free Software Foundation, either version 2 of the License, or | ||
65 | + * (at your option) any later version. | ||
66 | + * | ||
67 | + * This program is distributed in the hope that it will be useful, | ||
68 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
69 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
70 | + * GNU General Public License for more details. | ||
71 | + * | ||
72 | + * You should have received a copy of the GNU General Public License | ||
73 | + * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
74 | + */ | ||
75 | + | ||
76 | +#ifndef HW_MISC_ALLWINNER_A10_DRAMC_H | ||
77 | +#define HW_MISC_ALLWINNER_A10_DRAMC_H | ||
78 | + | ||
79 | +#include "qom/object.h" | ||
80 | +#include "hw/sysbus.h" | ||
81 | +#include "hw/register.h" | ||
82 | + | ||
83 | +/** | ||
84 | + * @name Constants | ||
85 | + * @{ | ||
86 | + */ | ||
87 | + | ||
88 | +/** Size of register I/O address space used by DRAMC device */ | ||
89 | +#define AW_A10_DRAMC_IOSIZE (0x1000) | ||
90 | + | ||
91 | +/** Total number of known registers */ | ||
92 | +#define AW_A10_DRAMC_REGS_NUM (AW_A10_DRAMC_IOSIZE / sizeof(uint32_t)) | ||
93 | + | ||
94 | +/** @} */ | ||
95 | + | ||
96 | +/** | ||
97 | + * @name Object model | ||
98 | + * @{ | ||
99 | + */ | ||
100 | + | ||
101 | +#define TYPE_AW_A10_DRAMC "allwinner-a10-dramc" | ||
102 | +OBJECT_DECLARE_SIMPLE_TYPE(AwA10DramControllerState, AW_A10_DRAMC) | ||
103 | + | ||
104 | +/** @} */ | ||
105 | + | ||
106 | +/** | ||
107 | + * Allwinner A10 DRAMC object instance state. | ||
108 | + */ | ||
109 | +struct AwA10DramControllerState { | ||
110 | + /*< private >*/ | ||
111 | + SysBusDevice parent_obj; | ||
112 | + /*< public >*/ | ||
113 | + | ||
114 | + /** Maps I/O registers in physical memory */ | ||
115 | + MemoryRegion iomem; | ||
116 | + | ||
117 | + /** Array of hardware registers */ | ||
118 | + uint32_t regs[AW_A10_DRAMC_REGS_NUM]; | ||
119 | +}; | ||
120 | + | ||
121 | +#endif /* HW_MISC_ALLWINNER_A10_DRAMC_H */ | ||
122 | diff --git a/hw/arm/allwinner-a10.c b/hw/arm/allwinner-a10.c | ||
123 | index XXXXXXX..XXXXXXX 100644 | ||
124 | --- a/hw/arm/allwinner-a10.c | ||
125 | +++ b/hw/arm/allwinner-a10.c | ||
126 | @@ -XXX,XX +XXX,XX @@ | ||
127 | #include "hw/boards.h" | ||
128 | #include "hw/usb/hcd-ohci.h" | ||
129 | |||
130 | +#define AW_A10_DRAMC_BASE 0x01c01000 | ||
131 | #define AW_A10_MMC0_BASE 0x01c0f000 | ||
132 | #define AW_A10_CCM_BASE 0x01c20000 | ||
133 | #define AW_A10_PIC_REG_BASE 0x01c20400 | ||
134 | @@ -XXX,XX +XXX,XX @@ static void aw_a10_init(Object *obj) | ||
135 | |||
136 | object_initialize_child(obj, "ccm", &s->ccm, TYPE_AW_A10_CCM); | ||
137 | |||
138 | + object_initialize_child(obj, "dramc", &s->dramc, TYPE_AW_A10_DRAMC); | ||
139 | + | ||
140 | object_initialize_child(obj, "emac", &s->emac, TYPE_AW_EMAC); | ||
141 | |||
142 | object_initialize_child(obj, "sata", &s->sata, TYPE_ALLWINNER_AHCI); | ||
143 | @@ -XXX,XX +XXX,XX @@ static void aw_a10_realize(DeviceState *dev, Error **errp) | ||
144 | sysbus_realize(SYS_BUS_DEVICE(&s->ccm), &error_fatal); | ||
145 | sysbus_mmio_map(SYS_BUS_DEVICE(&s->ccm), 0, AW_A10_CCM_BASE); | ||
146 | |||
147 | + /* DRAM Control Module */ | ||
148 | + sysbus_realize(SYS_BUS_DEVICE(&s->dramc), &error_fatal); | ||
149 | + sysbus_mmio_map(SYS_BUS_DEVICE(&s->dramc), 0, AW_A10_DRAMC_BASE); | ||
150 | + | ||
151 | /* FIXME use qdev NIC properties instead of nd_table[] */ | ||
152 | if (nd_table[0].used) { | ||
153 | qemu_check_nic_model(&nd_table[0], TYPE_AW_EMAC); | ||
154 | diff --git a/hw/misc/allwinner-a10-dramc.c b/hw/misc/allwinner-a10-dramc.c | ||
155 | new file mode 100644 | ||
156 | index XXXXXXX..XXXXXXX | ||
157 | --- /dev/null | ||
158 | +++ b/hw/misc/allwinner-a10-dramc.c | ||
159 | @@ -XXX,XX +XXX,XX @@ | ||
160 | +/* | ||
161 | + * Allwinner A10 DRAM Controller emulation | ||
162 | + * | ||
163 | + * Copyright (C) 2022 Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
164 | + * | ||
165 | + * This file is derived from Allwinner H3 DRAMC, | ||
166 | + * by Niek Linnenbank. | ||
167 | + * | ||
168 | + * This program is free software: you can redistribute it and/or modify | ||
169 | + * it under the terms of the GNU General Public License as published by | ||
170 | + * the Free Software Foundation, either version 2 of the License, or | ||
171 | + * (at your option) any later version. | ||
172 | + * | ||
173 | + * This program is distributed in the hope that it will be useful, | ||
174 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
175 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
176 | + * GNU General Public License for more details. | ||
177 | + * | ||
178 | + * You should have received a copy of the GNU General Public License | ||
179 | + * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
180 | + */ | ||
181 | + | ||
182 | +#include "qemu/osdep.h" | ||
183 | +#include "qemu/units.h" | ||
184 | +#include "hw/sysbus.h" | ||
185 | +#include "migration/vmstate.h" | ||
186 | +#include "qemu/log.h" | ||
187 | +#include "qemu/module.h" | ||
188 | +#include "hw/misc/allwinner-a10-dramc.h" | ||
189 | + | ||
190 | +/* DRAMC register offsets */ | ||
191 | +enum { | ||
192 | + REG_SDR_CCR = 0x0000, | ||
193 | + REG_SDR_ZQCR0 = 0x00a8, | ||
194 | + REG_SDR_ZQSR = 0x00b0 | ||
195 | +}; | ||
196 | + | ||
197 | +#define REG_INDEX(offset) (offset / sizeof(uint32_t)) | ||
198 | + | ||
199 | +/* DRAMC register flags */ | ||
200 | +enum { | ||
201 | + REG_SDR_CCR_DATA_TRAINING = (1 << 30), | ||
202 | + REG_SDR_CCR_DRAM_INIT = (1 << 31), | ||
203 | +}; | ||
204 | +enum { | ||
205 | + REG_SDR_ZQSR_ZCAL = (1 << 31), | ||
206 | +}; | ||
207 | + | ||
208 | +/* DRAMC register reset values */ | ||
209 | +enum { | ||
210 | + REG_SDR_CCR_RESET = 0x80020000, | ||
211 | + REG_SDR_ZQCR0_RESET = 0x07b00000, | ||
212 | + REG_SDR_ZQSR_RESET = 0x80000000 | ||
213 | +}; | ||
214 | + | ||
215 | +static uint64_t allwinner_a10_dramc_read(void *opaque, hwaddr offset, | ||
216 | + unsigned size) | ||
217 | +{ | ||
218 | + const AwA10DramControllerState *s = AW_A10_DRAMC(opaque); | ||
219 | + const uint32_t idx = REG_INDEX(offset); | ||
220 | + | ||
221 | + switch (offset) { | ||
222 | + case REG_SDR_CCR: | ||
223 | + case REG_SDR_ZQCR0: | ||
224 | + case REG_SDR_ZQSR: | ||
225 | + break; | ||
226 | + case 0x2e4 ... AW_A10_DRAMC_IOSIZE: | ||
227 | + qemu_log_mask(LOG_GUEST_ERROR, "%s: out-of-bounds offset 0x%04x\n", | ||
228 | + __func__, (uint32_t)offset); | ||
229 | + return 0; | ||
230 | + default: | ||
231 | + qemu_log_mask(LOG_UNIMP, "%s: unimplemented read offset 0x%04x\n", | ||
232 | + __func__, (uint32_t)offset); | ||
233 | + return 0; | ||
234 | + } | ||
235 | + | ||
236 | + return s->regs[idx]; | ||
237 | +} | ||
238 | + | ||
239 | +static void allwinner_a10_dramc_write(void *opaque, hwaddr offset, | ||
240 | + uint64_t val, unsigned size) | ||
241 | +{ | ||
242 | + AwA10DramControllerState *s = AW_A10_DRAMC(opaque); | ||
243 | + const uint32_t idx = REG_INDEX(offset); | ||
244 | + | ||
245 | + switch (offset) { | ||
246 | + case REG_SDR_CCR: | ||
247 | + if (val & REG_SDR_CCR_DRAM_INIT) { | ||
248 | + /* Clear DRAM_INIT to indicate process is done. */ | ||
249 | + val &= ~REG_SDR_CCR_DRAM_INIT; | ||
250 | + } | ||
251 | + if (val & REG_SDR_CCR_DATA_TRAINING) { | ||
252 | + /* Clear DATA_TRAINING to indicate process is done. */ | ||
253 | + val &= ~REG_SDR_CCR_DATA_TRAINING; | ||
254 | + } | ||
255 | + break; | ||
256 | + case REG_SDR_ZQCR0: | ||
257 | + /* Set ZCAL in ZQSR to indicate calibration is done. */ | ||
258 | + s->regs[REG_INDEX(REG_SDR_ZQSR)] |= REG_SDR_ZQSR_ZCAL; | ||
259 | + break; | ||
260 | + case 0x2e4 ... AW_A10_DRAMC_IOSIZE: | ||
261 | + qemu_log_mask(LOG_GUEST_ERROR, "%s: out-of-bounds offset 0x%04x\n", | ||
262 | + __func__, (uint32_t)offset); | ||
263 | + break; | ||
264 | + default: | ||
265 | + qemu_log_mask(LOG_UNIMP, "%s: unimplemented write offset 0x%04x\n", | ||
266 | + __func__, (uint32_t)offset); | ||
267 | + break; | ||
268 | + } | ||
269 | + | ||
270 | + s->regs[idx] = (uint32_t) val; | ||
271 | +} | ||
272 | + | ||
273 | +static const MemoryRegionOps allwinner_a10_dramc_ops = { | ||
274 | + .read = allwinner_a10_dramc_read, | ||
275 | + .write = allwinner_a10_dramc_write, | ||
276 | + .endianness = DEVICE_NATIVE_ENDIAN, | ||
277 | + .valid = { | ||
278 | + .min_access_size = 4, | ||
279 | + .max_access_size = 4, | ||
280 | + }, | ||
281 | + .impl.min_access_size = 4, | ||
282 | +}; | ||
283 | + | ||
284 | +static void allwinner_a10_dramc_reset_enter(Object *obj, ResetType type) | ||
285 | +{ | ||
286 | + AwA10DramControllerState *s = AW_A10_DRAMC(obj); | ||
287 | + | ||
288 | + /* Set default values for registers */ | ||
289 | + s->regs[REG_INDEX(REG_SDR_CCR)] = REG_SDR_CCR_RESET; | ||
290 | + s->regs[REG_INDEX(REG_SDR_ZQCR0)] = REG_SDR_ZQCR0_RESET; | ||
291 | + s->regs[REG_INDEX(REG_SDR_ZQSR)] = REG_SDR_ZQSR_RESET; | ||
292 | +} | ||
293 | + | ||
294 | +static void allwinner_a10_dramc_init(Object *obj) | ||
295 | +{ | ||
296 | + SysBusDevice *sbd = SYS_BUS_DEVICE(obj); | ||
297 | + AwA10DramControllerState *s = AW_A10_DRAMC(obj); | ||
298 | + | ||
299 | + /* Memory mapping */ | ||
300 | + memory_region_init_io(&s->iomem, OBJECT(s), &allwinner_a10_dramc_ops, s, | ||
301 | + TYPE_AW_A10_DRAMC, AW_A10_DRAMC_IOSIZE); | ||
302 | + sysbus_init_mmio(sbd, &s->iomem); | ||
303 | +} | ||
304 | + | ||
305 | +static const VMStateDescription allwinner_a10_dramc_vmstate = { | ||
306 | + .name = "allwinner-a10-dramc", | ||
307 | + .version_id = 1, | ||
308 | + .minimum_version_id = 1, | ||
309 | + .fields = (VMStateField[]) { | ||
310 | + VMSTATE_UINT32_ARRAY(regs, AwA10DramControllerState, | ||
311 | + AW_A10_DRAMC_REGS_NUM), | ||
312 | + VMSTATE_END_OF_LIST() | ||
313 | + } | ||
314 | +}; | ||
315 | + | ||
316 | +static void allwinner_a10_dramc_class_init(ObjectClass *klass, void *data) | ||
317 | +{ | ||
318 | + DeviceClass *dc = DEVICE_CLASS(klass); | ||
319 | + ResettableClass *rc = RESETTABLE_CLASS(klass); | ||
320 | + | ||
321 | + rc->phases.enter = allwinner_a10_dramc_reset_enter; | ||
322 | + dc->vmsd = &allwinner_a10_dramc_vmstate; | ||
323 | +} | ||
324 | + | ||
325 | +static const TypeInfo allwinner_a10_dramc_info = { | ||
326 | + .name = TYPE_AW_A10_DRAMC, | ||
327 | + .parent = TYPE_SYS_BUS_DEVICE, | ||
328 | + .instance_init = allwinner_a10_dramc_init, | ||
329 | + .instance_size = sizeof(AwA10DramControllerState), | ||
330 | + .class_init = allwinner_a10_dramc_class_init, | ||
331 | +}; | ||
332 | + | ||
333 | +static void allwinner_a10_dramc_register(void) | ||
334 | +{ | ||
335 | + type_register_static(&allwinner_a10_dramc_info); | ||
336 | +} | ||
337 | + | ||
338 | +type_init(allwinner_a10_dramc_register) | ||
339 | diff --git a/hw/arm/Kconfig b/hw/arm/Kconfig | ||
340 | index XXXXXXX..XXXXXXX 100644 | ||
341 | --- a/hw/arm/Kconfig | ||
342 | +++ b/hw/arm/Kconfig | ||
343 | @@ -XXX,XX +XXX,XX @@ config ALLWINNER_A10 | ||
344 | select ALLWINNER_A10_PIT | ||
345 | select ALLWINNER_A10_PIC | ||
346 | select ALLWINNER_A10_CCM | ||
347 | + select ALLWINNER_A10_DRAMC | ||
348 | select ALLWINNER_EMAC | ||
349 | select SERIAL | ||
350 | select UNIMP | ||
351 | diff --git a/hw/misc/Kconfig b/hw/misc/Kconfig | ||
352 | index XXXXXXX..XXXXXXX 100644 | ||
353 | --- a/hw/misc/Kconfig | ||
354 | +++ b/hw/misc/Kconfig | ||
355 | @@ -XXX,XX +XXX,XX @@ config LASI | ||
356 | config ALLWINNER_A10_CCM | ||
357 | bool | ||
358 | |||
359 | +config ALLWINNER_A10_DRAMC | ||
360 | + bool | ||
361 | + | ||
362 | source macio/Kconfig | ||
363 | diff --git a/hw/misc/meson.build b/hw/misc/meson.build | ||
364 | index XXXXXXX..XXXXXXX 100644 | ||
365 | --- a/hw/misc/meson.build | ||
366 | +++ b/hw/misc/meson.build | ||
367 | @@ -XXX,XX +XXX,XX @@ subdir('macio') | ||
368 | softmmu_ss.add(when: 'CONFIG_IVSHMEM_DEVICE', if_true: files('ivshmem.c')) | ||
369 | |||
370 | softmmu_ss.add(when: 'CONFIG_ALLWINNER_A10_CCM', if_true: files('allwinner-a10-ccm.c')) | ||
371 | +softmmu_ss.add(when: 'CONFIG_ALLWINNER_A10_DRAMC', if_true: files('allwinner-a10-dramc.c')) | ||
372 | softmmu_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-h3-ccu.c')) | ||
373 | specific_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-cpucfg.c')) | ||
374 | softmmu_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-h3-dramc.c')) | ||
375 | -- | ||
376 | 2.34.1 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Strahinja Jankovic <strahinjapjankovic@gmail.com> |
---|---|---|---|
2 | 2 | ||
3 | Previously we were defining some of these in user-only mode, | 3 | This patch implements Allwinner TWI/I2C controller emulation. Only |
4 | but none of them are accessible from user-only, therefore | 4 | master-mode functionality is implemented. |
5 | define them only in system mode. | ||
6 | 5 | ||
7 | This will shortly be used from cpu_tcg.c also. | 6 | The SPL boot for Cubieboard expects AXP209 PMIC on TWI0/I2C0 bus, so this is |
7 | first part enabling the TWI/I2C bus operation. | ||
8 | 8 | ||
9 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 9 | Since both Allwinner A10 and H3 use the same module, it is added for |
10 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 10 | both boards. |
11 | Message-id: 20220506180242.216785-6-richard.henderson@linaro.org | 11 | |
12 | Docs are also updated for Cubieboard and Orangepi-PC board to indicate | ||
13 | I2C availability. | ||
14 | |||
15 | Signed-off-by: Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
16 | Reviewed-by: Niek Linnenbank <nieklinnenbank@gmail.com> | ||
17 | Message-id: 20221226220303.14420-4-strahinja.p.jankovic@gmail.com | ||
12 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 18 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
13 | --- | 19 | --- |
14 | target/arm/internals.h | 6 ++++ | 20 | docs/system/arm/cubieboard.rst | 1 + |
15 | target/arm/cpu64.c | 64 +++--------------------------------------- | 21 | docs/system/arm/orangepi.rst | 1 + |
16 | target/arm/cpu_tcg.c | 59 ++++++++++++++++++++++++++++++++++++++ | 22 | include/hw/arm/allwinner-a10.h | 2 + |
17 | 3 files changed, 69 insertions(+), 60 deletions(-) | 23 | include/hw/arm/allwinner-h3.h | 3 + |
24 | include/hw/i2c/allwinner-i2c.h | 55 ++++ | ||
25 | hw/arm/allwinner-a10.c | 8 + | ||
26 | hw/arm/allwinner-h3.c | 11 +- | ||
27 | hw/i2c/allwinner-i2c.c | 459 +++++++++++++++++++++++++++++++++ | ||
28 | hw/arm/Kconfig | 2 + | ||
29 | hw/i2c/Kconfig | 4 + | ||
30 | hw/i2c/meson.build | 1 + | ||
31 | hw/i2c/trace-events | 5 + | ||
32 | 12 files changed, 551 insertions(+), 1 deletion(-) | ||
33 | create mode 100644 include/hw/i2c/allwinner-i2c.h | ||
34 | create mode 100644 hw/i2c/allwinner-i2c.c | ||
18 | 35 | ||
19 | diff --git a/target/arm/internals.h b/target/arm/internals.h | 36 | diff --git a/docs/system/arm/cubieboard.rst b/docs/system/arm/cubieboard.rst |
20 | index XXXXXXX..XXXXXXX 100644 | 37 | index XXXXXXX..XXXXXXX 100644 |
21 | --- a/target/arm/internals.h | 38 | --- a/docs/system/arm/cubieboard.rst |
22 | +++ b/target/arm/internals.h | 39 | +++ b/docs/system/arm/cubieboard.rst |
23 | @@ -XXX,XX +XXX,XX @@ int aarch64_fpu_gdb_get_reg(CPUARMState *env, GByteArray *buf, int reg); | 40 | @@ -XXX,XX +XXX,XX @@ Emulated devices: |
24 | int aarch64_fpu_gdb_set_reg(CPUARMState *env, uint8_t *buf, int reg); | 41 | - SDHCI |
25 | #endif | 42 | - USB controller |
26 | 43 | - SATA controller | |
27 | +#ifdef CONFIG_USER_ONLY | 44 | +- TWI (I2C) controller |
28 | +static inline void define_cortex_a72_a57_a53_cp_reginfo(ARMCPU *cpu) { } | 45 | diff --git a/docs/system/arm/orangepi.rst b/docs/system/arm/orangepi.rst |
29 | +#else | 46 | index XXXXXXX..XXXXXXX 100644 |
30 | +void define_cortex_a72_a57_a53_cp_reginfo(ARMCPU *cpu); | 47 | --- a/docs/system/arm/orangepi.rst |
31 | +#endif | 48 | +++ b/docs/system/arm/orangepi.rst |
32 | + | 49 | @@ -XXX,XX +XXX,XX @@ The Orange Pi PC machine supports the following devices: |
33 | #endif | 50 | * Clock Control Unit |
34 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 51 | * System Control module |
35 | index XXXXXXX..XXXXXXX 100644 | 52 | * Security Identifier device |
36 | --- a/target/arm/cpu64.c | 53 | + * TWI (I2C) |
37 | +++ b/target/arm/cpu64.c | 54 | |
55 | Limitations | ||
56 | """"""""""" | ||
57 | diff --git a/include/hw/arm/allwinner-a10.h b/include/hw/arm/allwinner-a10.h | ||
58 | index XXXXXXX..XXXXXXX 100644 | ||
59 | --- a/include/hw/arm/allwinner-a10.h | ||
60 | +++ b/include/hw/arm/allwinner-a10.h | ||
38 | @@ -XXX,XX +XXX,XX @@ | 61 | @@ -XXX,XX +XXX,XX @@ |
39 | #include "hvf_arm.h" | 62 | #include "hw/rtc/allwinner-rtc.h" |
40 | #include "qapi/visitor.h" | 63 | #include "hw/misc/allwinner-a10-ccm.h" |
41 | #include "hw/qdev-properties.h" | 64 | #include "hw/misc/allwinner-a10-dramc.h" |
42 | -#include "cpregs.h" | 65 | +#include "hw/i2c/allwinner-i2c.h" |
43 | +#include "internals.h" | 66 | |
44 | 67 | #include "target/arm/cpu.h" | |
45 | 68 | #include "qom/object.h" | |
46 | -#ifndef CONFIG_USER_ONLY | 69 | @@ -XXX,XX +XXX,XX @@ struct AwA10State { |
47 | -static uint64_t a57_a53_l2ctlr_read(CPUARMState *env, const ARMCPRegInfo *ri) | 70 | AwEmacState emac; |
48 | -{ | 71 | AllwinnerAHCIState sata; |
49 | - ARMCPU *cpu = env_archcpu(env); | 72 | AwSdHostState mmc0; |
50 | - | 73 | + AWI2CState i2c0; |
51 | - /* Number of cores is in [25:24]; otherwise we RAZ */ | 74 | AwRtcState rtc; |
52 | - return (cpu->core_count - 1) << 24; | 75 | MemoryRegion sram_a; |
53 | -} | 76 | EHCISysBusState ehci[AW_A10_NUM_USB]; |
54 | -#endif | 77 | diff --git a/include/hw/arm/allwinner-h3.h b/include/hw/arm/allwinner-h3.h |
55 | - | 78 | index XXXXXXX..XXXXXXX 100644 |
56 | -static const ARMCPRegInfo cortex_a72_a57_a53_cp_reginfo[] = { | 79 | --- a/include/hw/arm/allwinner-h3.h |
57 | -#ifndef CONFIG_USER_ONLY | 80 | +++ b/include/hw/arm/allwinner-h3.h |
58 | - { .name = "L2CTLR_EL1", .state = ARM_CP_STATE_AA64, | 81 | @@ -XXX,XX +XXX,XX @@ |
59 | - .opc0 = 3, .opc1 = 1, .crn = 11, .crm = 0, .opc2 = 2, | 82 | #include "hw/sd/allwinner-sdhost.h" |
60 | - .access = PL1_RW, .readfn = a57_a53_l2ctlr_read, | 83 | #include "hw/net/allwinner-sun8i-emac.h" |
61 | - .writefn = arm_cp_write_ignore }, | 84 | #include "hw/rtc/allwinner-rtc.h" |
62 | - { .name = "L2CTLR", | 85 | +#include "hw/i2c/allwinner-i2c.h" |
63 | - .cp = 15, .opc1 = 1, .crn = 9, .crm = 0, .opc2 = 2, | 86 | #include "target/arm/cpu.h" |
64 | - .access = PL1_RW, .readfn = a57_a53_l2ctlr_read, | 87 | #include "sysemu/block-backend.h" |
65 | - .writefn = arm_cp_write_ignore }, | 88 | |
66 | -#endif | 89 | @@ -XXX,XX +XXX,XX @@ enum { |
67 | - { .name = "L2ECTLR_EL1", .state = ARM_CP_STATE_AA64, | 90 | AW_H3_DEV_UART2, |
68 | - .opc0 = 3, .opc1 = 1, .crn = 11, .crm = 0, .opc2 = 3, | 91 | AW_H3_DEV_UART3, |
69 | - .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 92 | AW_H3_DEV_EMAC, |
70 | - { .name = "L2ECTLR", | 93 | + AW_H3_DEV_TWI0, |
71 | - .cp = 15, .opc1 = 1, .crn = 9, .crm = 0, .opc2 = 3, | 94 | AW_H3_DEV_DRAMCOM, |
72 | - .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 95 | AW_H3_DEV_DRAMCTL, |
73 | - { .name = "L2ACTLR", .state = ARM_CP_STATE_BOTH, | 96 | AW_H3_DEV_DRAMPHY, |
74 | - .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 0, .opc2 = 0, | 97 | @@ -XXX,XX +XXX,XX @@ struct AwH3State { |
75 | - .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 98 | AwH3SysCtrlState sysctrl; |
76 | - { .name = "CPUACTLR_EL1", .state = ARM_CP_STATE_AA64, | 99 | AwSidState sid; |
77 | - .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 2, .opc2 = 0, | 100 | AwSdHostState mmc0; |
78 | - .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 101 | + AWI2CState i2c0; |
79 | - { .name = "CPUACTLR", | 102 | AwSun8iEmacState emac; |
80 | - .cp = 15, .opc1 = 0, .crm = 15, | 103 | AwRtcState rtc; |
81 | - .access = PL1_RW, .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, | 104 | GICState gic; |
82 | - { .name = "CPUECTLR_EL1", .state = ARM_CP_STATE_AA64, | 105 | diff --git a/include/hw/i2c/allwinner-i2c.h b/include/hw/i2c/allwinner-i2c.h |
83 | - .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 2, .opc2 = 1, | 106 | new file mode 100644 |
84 | - .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 107 | index XXXXXXX..XXXXXXX |
85 | - { .name = "CPUECTLR", | 108 | --- /dev/null |
86 | - .cp = 15, .opc1 = 1, .crm = 15, | 109 | +++ b/include/hw/i2c/allwinner-i2c.h |
87 | - .access = PL1_RW, .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, | 110 | @@ -XXX,XX +XXX,XX @@ |
88 | - { .name = "CPUMERRSR_EL1", .state = ARM_CP_STATE_AA64, | 111 | +/* |
89 | - .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 2, .opc2 = 2, | 112 | + * Allwinner I2C Bus Serial Interface registers definition |
90 | - .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 113 | + * |
91 | - { .name = "CPUMERRSR", | 114 | + * Copyright (C) 2022 Strahinja Jankovic. <strahinja.p.jankovic@gmail.com> |
92 | - .cp = 15, .opc1 = 2, .crm = 15, | 115 | + * |
93 | - .access = PL1_RW, .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, | 116 | + * This file is derived from IMX I2C controller, |
94 | - { .name = "L2MERRSR_EL1", .state = ARM_CP_STATE_AA64, | 117 | + * by Jean-Christophe DUBOIS . |
95 | - .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 2, .opc2 = 3, | 118 | + * |
96 | - .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 119 | + * This program is free software; you can redistribute it and/or modify it |
97 | - { .name = "L2MERRSR", | 120 | + * under the terms of the GNU General Public License as published by the |
98 | - .cp = 15, .opc1 = 3, .crm = 15, | 121 | + * Free Software Foundation; either version 2 of the License, or |
99 | - .access = PL1_RW, .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, | 122 | + * (at your option) any later version. |
100 | -}; | 123 | + * |
101 | - | 124 | + * This program is distributed in the hope that it will be useful, but WITHOUT |
102 | static void aarch64_a57_initfn(Object *obj) | 125 | + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
126 | + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
127 | + * for more details. | ||
128 | + * | ||
129 | + * You should have received a copy of the GNU General Public License along | ||
130 | + * with this program; if not, see <http://www.gnu.org/licenses/>. | ||
131 | + * | ||
132 | + */ | ||
133 | + | ||
134 | +#ifndef ALLWINNER_I2C_H | ||
135 | +#define ALLWINNER_I2C_H | ||
136 | + | ||
137 | +#include "hw/sysbus.h" | ||
138 | +#include "qom/object.h" | ||
139 | + | ||
140 | +#define TYPE_AW_I2C "allwinner.i2c" | ||
141 | +OBJECT_DECLARE_SIMPLE_TYPE(AWI2CState, AW_I2C) | ||
142 | + | ||
143 | +#define AW_I2C_MEM_SIZE 0x24 | ||
144 | + | ||
145 | +struct AWI2CState { | ||
146 | + /*< private >*/ | ||
147 | + SysBusDevice parent_obj; | ||
148 | + | ||
149 | + /*< public >*/ | ||
150 | + MemoryRegion iomem; | ||
151 | + I2CBus *bus; | ||
152 | + qemu_irq irq; | ||
153 | + | ||
154 | + uint8_t addr; | ||
155 | + uint8_t xaddr; | ||
156 | + uint8_t data; | ||
157 | + uint8_t cntr; | ||
158 | + uint8_t stat; | ||
159 | + uint8_t ccr; | ||
160 | + uint8_t srst; | ||
161 | + uint8_t efr; | ||
162 | + uint8_t lcr; | ||
163 | +}; | ||
164 | + | ||
165 | +#endif /* ALLWINNER_I2C_H */ | ||
166 | diff --git a/hw/arm/allwinner-a10.c b/hw/arm/allwinner-a10.c | ||
167 | index XXXXXXX..XXXXXXX 100644 | ||
168 | --- a/hw/arm/allwinner-a10.c | ||
169 | +++ b/hw/arm/allwinner-a10.c | ||
170 | @@ -XXX,XX +XXX,XX @@ | ||
171 | #define AW_A10_OHCI_BASE 0x01c14400 | ||
172 | #define AW_A10_SATA_BASE 0x01c18000 | ||
173 | #define AW_A10_RTC_BASE 0x01c20d00 | ||
174 | +#define AW_A10_I2C0_BASE 0x01c2ac00 | ||
175 | |||
176 | static void aw_a10_init(Object *obj) | ||
103 | { | 177 | { |
104 | ARMCPU *cpu = ARM_CPU(obj); | 178 | @@ -XXX,XX +XXX,XX @@ static void aw_a10_init(Object *obj) |
105 | @@ -XXX,XX +XXX,XX @@ static void aarch64_a57_initfn(Object *obj) | 179 | |
106 | cpu->gic_num_lrs = 4; | 180 | object_initialize_child(obj, "sata", &s->sata, TYPE_ALLWINNER_AHCI); |
107 | cpu->gic_vpribits = 5; | 181 | |
108 | cpu->gic_vprebits = 5; | 182 | + object_initialize_child(obj, "i2c0", &s->i2c0, TYPE_AW_I2C); |
109 | - define_arm_cp_regs(cpu, cortex_a72_a57_a53_cp_reginfo); | 183 | + |
110 | + define_cortex_a72_a57_a53_cp_reginfo(cpu); | 184 | if (machine_usb(current_machine)) { |
185 | int i; | ||
186 | |||
187 | @@ -XXX,XX +XXX,XX @@ static void aw_a10_realize(DeviceState *dev, Error **errp) | ||
188 | /* RTC */ | ||
189 | sysbus_realize(SYS_BUS_DEVICE(&s->rtc), &error_fatal); | ||
190 | sysbus_mmio_map_overlap(SYS_BUS_DEVICE(&s->rtc), 0, AW_A10_RTC_BASE, 10); | ||
191 | + | ||
192 | + /* I2C */ | ||
193 | + sysbus_realize(SYS_BUS_DEVICE(&s->i2c0), &error_fatal); | ||
194 | + sysbus_mmio_map(SYS_BUS_DEVICE(&s->i2c0), 0, AW_A10_I2C0_BASE); | ||
195 | + sysbus_connect_irq(SYS_BUS_DEVICE(&s->i2c0), 0, qdev_get_gpio_in(dev, 7)); | ||
111 | } | 196 | } |
112 | 197 | ||
113 | static void aarch64_a53_initfn(Object *obj) | 198 | static void aw_a10_class_init(ObjectClass *oc, void *data) |
114 | @@ -XXX,XX +XXX,XX @@ static void aarch64_a53_initfn(Object *obj) | 199 | diff --git a/hw/arm/allwinner-h3.c b/hw/arm/allwinner-h3.c |
115 | cpu->gic_num_lrs = 4; | 200 | index XXXXXXX..XXXXXXX 100644 |
116 | cpu->gic_vpribits = 5; | 201 | --- a/hw/arm/allwinner-h3.c |
117 | cpu->gic_vprebits = 5; | 202 | +++ b/hw/arm/allwinner-h3.c |
118 | - define_arm_cp_regs(cpu, cortex_a72_a57_a53_cp_reginfo); | 203 | @@ -XXX,XX +XXX,XX @@ const hwaddr allwinner_h3_memmap[] = { |
119 | + define_cortex_a72_a57_a53_cp_reginfo(cpu); | 204 | [AW_H3_DEV_UART1] = 0x01c28400, |
205 | [AW_H3_DEV_UART2] = 0x01c28800, | ||
206 | [AW_H3_DEV_UART3] = 0x01c28c00, | ||
207 | + [AW_H3_DEV_TWI0] = 0x01c2ac00, | ||
208 | [AW_H3_DEV_EMAC] = 0x01c30000, | ||
209 | [AW_H3_DEV_DRAMCOM] = 0x01c62000, | ||
210 | [AW_H3_DEV_DRAMCTL] = 0x01c63000, | ||
211 | @@ -XXX,XX +XXX,XX @@ struct AwH3Unimplemented { | ||
212 | { "uart1", 0x01c28400, 1 * KiB }, | ||
213 | { "uart2", 0x01c28800, 1 * KiB }, | ||
214 | { "uart3", 0x01c28c00, 1 * KiB }, | ||
215 | - { "twi0", 0x01c2ac00, 1 * KiB }, | ||
216 | { "twi1", 0x01c2b000, 1 * KiB }, | ||
217 | { "twi2", 0x01c2b400, 1 * KiB }, | ||
218 | { "scr", 0x01c2c400, 1 * KiB }, | ||
219 | @@ -XXX,XX +XXX,XX @@ enum { | ||
220 | AW_H3_GIC_SPI_UART1 = 1, | ||
221 | AW_H3_GIC_SPI_UART2 = 2, | ||
222 | AW_H3_GIC_SPI_UART3 = 3, | ||
223 | + AW_H3_GIC_SPI_TWI0 = 6, | ||
224 | AW_H3_GIC_SPI_TIMER0 = 18, | ||
225 | AW_H3_GIC_SPI_TIMER1 = 19, | ||
226 | AW_H3_GIC_SPI_MMC0 = 60, | ||
227 | @@ -XXX,XX +XXX,XX @@ static void allwinner_h3_init(Object *obj) | ||
228 | "ram-size"); | ||
229 | |||
230 | object_initialize_child(obj, "rtc", &s->rtc, TYPE_AW_RTC_SUN6I); | ||
231 | + | ||
232 | + object_initialize_child(obj, "twi0", &s->i2c0, TYPE_AW_I2C); | ||
120 | } | 233 | } |
121 | 234 | ||
122 | static void aarch64_a72_initfn(Object *obj) | 235 | static void allwinner_h3_realize(DeviceState *dev, Error **errp) |
123 | @@ -XXX,XX +XXX,XX @@ static void aarch64_a72_initfn(Object *obj) | 236 | @@ -XXX,XX +XXX,XX @@ static void allwinner_h3_realize(DeviceState *dev, Error **errp) |
124 | cpu->gic_num_lrs = 4; | 237 | sysbus_realize(SYS_BUS_DEVICE(&s->rtc), &error_fatal); |
125 | cpu->gic_vpribits = 5; | 238 | sysbus_mmio_map(SYS_BUS_DEVICE(&s->rtc), 0, s->memmap[AW_H3_DEV_RTC]); |
126 | cpu->gic_vprebits = 5; | 239 | |
127 | - define_arm_cp_regs(cpu, cortex_a72_a57_a53_cp_reginfo); | 240 | + /* I2C */ |
128 | + define_cortex_a72_a57_a53_cp_reginfo(cpu); | 241 | + sysbus_realize(SYS_BUS_DEVICE(&s->i2c0), &error_fatal); |
129 | } | 242 | + sysbus_mmio_map(SYS_BUS_DEVICE(&s->i2c0), 0, s->memmap[AW_H3_DEV_TWI0]); |
130 | 243 | + sysbus_connect_irq(SYS_BUS_DEVICE(&s->i2c0), 0, | |
131 | void arm_cpu_sve_finalize(ARMCPU *cpu, Error **errp) | 244 | + qdev_get_gpio_in(DEVICE(&s->gic), AW_H3_GIC_SPI_TWI0)); |
132 | diff --git a/target/arm/cpu_tcg.c b/target/arm/cpu_tcg.c | 245 | + |
133 | index XXXXXXX..XXXXXXX 100644 | 246 | /* Unimplemented devices */ |
134 | --- a/target/arm/cpu_tcg.c | 247 | for (i = 0; i < ARRAY_SIZE(unimplemented); i++) { |
135 | +++ b/target/arm/cpu_tcg.c | 248 | create_unimplemented_device(unimplemented[i].device_name, |
249 | diff --git a/hw/i2c/allwinner-i2c.c b/hw/i2c/allwinner-i2c.c | ||
250 | new file mode 100644 | ||
251 | index XXXXXXX..XXXXXXX | ||
252 | --- /dev/null | ||
253 | +++ b/hw/i2c/allwinner-i2c.c | ||
136 | @@ -XXX,XX +XXX,XX @@ | 254 | @@ -XXX,XX +XXX,XX @@ |
137 | #endif | 255 | +/* |
138 | #include "cpregs.h" | 256 | + * Allwinner I2C Bus Serial Interface Emulation |
139 | 257 | + * | |
140 | +#ifndef CONFIG_USER_ONLY | 258 | + * Copyright (C) 2022 Strahinja Jankovic <strahinja.p.jankovic@gmail.com> |
141 | +static uint64_t l2ctlr_read(CPUARMState *env, const ARMCPRegInfo *ri) | 259 | + * |
142 | +{ | 260 | + * This file is derived from IMX I2C controller, |
143 | + ARMCPU *cpu = env_archcpu(env); | 261 | + * by Jean-Christophe DUBOIS . |
144 | + | 262 | + * |
145 | + /* Number of cores is in [25:24]; otherwise we RAZ */ | 263 | + * This program is free software; you can redistribute it and/or modify it |
146 | + return (cpu->core_count - 1) << 24; | 264 | + * under the terms of the GNU General Public License as published by the |
147 | +} | 265 | + * Free Software Foundation; either version 2 of the License, or |
148 | + | 266 | + * (at your option) any later version. |
149 | +static const ARMCPRegInfo cortex_a72_a57_a53_cp_reginfo[] = { | 267 | + * |
150 | + { .name = "L2CTLR_EL1", .state = ARM_CP_STATE_AA64, | 268 | + * This program is distributed in the hope that it will be useful, but WITHOUT |
151 | + .opc0 = 3, .opc1 = 1, .crn = 11, .crm = 0, .opc2 = 2, | 269 | + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
152 | + .access = PL1_RW, .readfn = l2ctlr_read, | 270 | + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
153 | + .writefn = arm_cp_write_ignore }, | 271 | + * for more details. |
154 | + { .name = "L2CTLR", | 272 | + * |
155 | + .cp = 15, .opc1 = 1, .crn = 9, .crm = 0, .opc2 = 2, | 273 | + * You should have received a copy of the GNU General Public License along |
156 | + .access = PL1_RW, .readfn = l2ctlr_read, | 274 | + * with this program; if not, see <http://www.gnu.org/licenses/>. |
157 | + .writefn = arm_cp_write_ignore }, | 275 | + * |
158 | + { .name = "L2ECTLR_EL1", .state = ARM_CP_STATE_AA64, | 276 | + * SPDX-License-Identifier: MIT |
159 | + .opc0 = 3, .opc1 = 1, .crn = 11, .crm = 0, .opc2 = 3, | 277 | + */ |
160 | + .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 278 | + |
161 | + { .name = "L2ECTLR", | 279 | +#include "qemu/osdep.h" |
162 | + .cp = 15, .opc1 = 1, .crn = 9, .crm = 0, .opc2 = 3, | 280 | +#include "hw/i2c/allwinner-i2c.h" |
163 | + .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 281 | +#include "hw/irq.h" |
164 | + { .name = "L2ACTLR", .state = ARM_CP_STATE_BOTH, | 282 | +#include "migration/vmstate.h" |
165 | + .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 0, .opc2 = 0, | 283 | +#include "hw/i2c/i2c.h" |
166 | + .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 284 | +#include "qemu/log.h" |
167 | + { .name = "CPUACTLR_EL1", .state = ARM_CP_STATE_AA64, | 285 | +#include "trace.h" |
168 | + .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 2, .opc2 = 0, | 286 | +#include "qemu/module.h" |
169 | + .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 287 | + |
170 | + { .name = "CPUACTLR", | 288 | +/* Allwinner I2C memory map */ |
171 | + .cp = 15, .opc1 = 0, .crm = 15, | 289 | +#define TWI_ADDR_REG 0x00 /* slave address register */ |
172 | + .access = PL1_RW, .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, | 290 | +#define TWI_XADDR_REG 0x04 /* extended slave address register */ |
173 | + { .name = "CPUECTLR_EL1", .state = ARM_CP_STATE_AA64, | 291 | +#define TWI_DATA_REG 0x08 /* data register */ |
174 | + .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 2, .opc2 = 1, | 292 | +#define TWI_CNTR_REG 0x0c /* control register */ |
175 | + .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 293 | +#define TWI_STAT_REG 0x10 /* status register */ |
176 | + { .name = "CPUECTLR", | 294 | +#define TWI_CCR_REG 0x14 /* clock control register */ |
177 | + .cp = 15, .opc1 = 1, .crm = 15, | 295 | +#define TWI_SRST_REG 0x18 /* software reset register */ |
178 | + .access = PL1_RW, .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, | 296 | +#define TWI_EFR_REG 0x1c /* enhance feature register */ |
179 | + { .name = "CPUMERRSR_EL1", .state = ARM_CP_STATE_AA64, | 297 | +#define TWI_LCR_REG 0x20 /* line control register */ |
180 | + .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 2, .opc2 = 2, | 298 | + |
181 | + .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 299 | +/* Used only in slave mode, do not set */ |
182 | + { .name = "CPUMERRSR", | 300 | +#define TWI_ADDR_RESET 0 |
183 | + .cp = 15, .opc1 = 2, .crm = 15, | 301 | +#define TWI_XADDR_RESET 0 |
184 | + .access = PL1_RW, .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, | 302 | + |
185 | + { .name = "L2MERRSR_EL1", .state = ARM_CP_STATE_AA64, | 303 | +/* Data register */ |
186 | + .opc0 = 3, .opc1 = 1, .crn = 15, .crm = 2, .opc2 = 3, | 304 | +#define TWI_DATA_MASK 0xFF |
187 | + .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 305 | +#define TWI_DATA_RESET 0 |
188 | + { .name = "L2MERRSR", | 306 | + |
189 | + .cp = 15, .opc1 = 3, .crm = 15, | 307 | +/* Control register */ |
190 | + .access = PL1_RW, .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, | 308 | +#define TWI_CNTR_INT_EN (1 << 7) |
309 | +#define TWI_CNTR_BUS_EN (1 << 6) | ||
310 | +#define TWI_CNTR_M_STA (1 << 5) | ||
311 | +#define TWI_CNTR_M_STP (1 << 4) | ||
312 | +#define TWI_CNTR_INT_FLAG (1 << 3) | ||
313 | +#define TWI_CNTR_A_ACK (1 << 2) | ||
314 | +#define TWI_CNTR_MASK 0xFC | ||
315 | +#define TWI_CNTR_RESET 0 | ||
316 | + | ||
317 | +/* Status register */ | ||
318 | +#define TWI_STAT_MASK 0xF8 | ||
319 | +#define TWI_STAT_RESET 0xF8 | ||
320 | + | ||
321 | +/* Clock register */ | ||
322 | +#define TWI_CCR_CLK_M_MASK 0x78 | ||
323 | +#define TWI_CCR_CLK_N_MASK 0x07 | ||
324 | +#define TWI_CCR_MASK 0x7F | ||
325 | +#define TWI_CCR_RESET 0 | ||
326 | + | ||
327 | +/* Soft reset */ | ||
328 | +#define TWI_SRST_MASK 0x01 | ||
329 | +#define TWI_SRST_RESET 0 | ||
330 | + | ||
331 | +/* Enhance feature */ | ||
332 | +#define TWI_EFR_MASK 0x03 | ||
333 | +#define TWI_EFR_RESET 0 | ||
334 | + | ||
335 | +/* Line control */ | ||
336 | +#define TWI_LCR_SCL_STATE (1 << 5) | ||
337 | +#define TWI_LCR_SDA_STATE (1 << 4) | ||
338 | +#define TWI_LCR_SCL_CTL (1 << 3) | ||
339 | +#define TWI_LCR_SCL_CTL_EN (1 << 2) | ||
340 | +#define TWI_LCR_SDA_CTL (1 << 1) | ||
341 | +#define TWI_LCR_SDA_CTL_EN (1 << 0) | ||
342 | +#define TWI_LCR_MASK 0x3F | ||
343 | +#define TWI_LCR_RESET 0x3A | ||
344 | + | ||
345 | +/* Status value in STAT register is shifted by 3 bits */ | ||
346 | +#define TWI_STAT_SHIFT 3 | ||
347 | +#define STAT_FROM_STA(x) ((x) << TWI_STAT_SHIFT) | ||
348 | +#define STAT_TO_STA(x) ((x) >> TWI_STAT_SHIFT) | ||
349 | + | ||
350 | +enum { | ||
351 | + STAT_BUS_ERROR = 0, | ||
352 | + /* Master mode */ | ||
353 | + STAT_M_STA_TX, | ||
354 | + STAT_M_RSTA_TX, | ||
355 | + STAT_M_ADDR_WR_ACK, | ||
356 | + STAT_M_ADDR_WR_NACK, | ||
357 | + STAT_M_DATA_TX_ACK, | ||
358 | + STAT_M_DATA_TX_NACK, | ||
359 | + STAT_M_ARB_LOST, | ||
360 | + STAT_M_ADDR_RD_ACK, | ||
361 | + STAT_M_ADDR_RD_NACK, | ||
362 | + STAT_M_DATA_RX_ACK, | ||
363 | + STAT_M_DATA_RX_NACK, | ||
364 | + /* Slave mode */ | ||
365 | + STAT_S_ADDR_WR_ACK, | ||
366 | + STAT_S_ARB_LOST_AW_ACK, | ||
367 | + STAT_S_GCA_ACK, | ||
368 | + STAT_S_ARB_LOST_GCA_ACK, | ||
369 | + STAT_S_DATA_RX_SA_ACK, | ||
370 | + STAT_S_DATA_RX_SA_NACK, | ||
371 | + STAT_S_DATA_RX_GCA_ACK, | ||
372 | + STAT_S_DATA_RX_GCA_NACK, | ||
373 | + STAT_S_STP_RSTA, | ||
374 | + STAT_S_ADDR_RD_ACK, | ||
375 | + STAT_S_ARB_LOST_AR_ACK, | ||
376 | + STAT_S_DATA_TX_ACK, | ||
377 | + STAT_S_DATA_TX_NACK, | ||
378 | + STAT_S_LB_TX_ACK, | ||
379 | + /* Master mode, 10-bit */ | ||
380 | + STAT_M_2ND_ADDR_WR_ACK, | ||
381 | + STAT_M_2ND_ADDR_WR_NACK, | ||
382 | + /* Idle */ | ||
383 | + STAT_IDLE = 0x1f | ||
384 | +} TWI_STAT_STA; | ||
385 | + | ||
386 | +static const char *allwinner_i2c_get_regname(unsigned offset) | ||
387 | +{ | ||
388 | + switch (offset) { | ||
389 | + case TWI_ADDR_REG: | ||
390 | + return "ADDR"; | ||
391 | + case TWI_XADDR_REG: | ||
392 | + return "XADDR"; | ||
393 | + case TWI_DATA_REG: | ||
394 | + return "DATA"; | ||
395 | + case TWI_CNTR_REG: | ||
396 | + return "CNTR"; | ||
397 | + case TWI_STAT_REG: | ||
398 | + return "STAT"; | ||
399 | + case TWI_CCR_REG: | ||
400 | + return "CCR"; | ||
401 | + case TWI_SRST_REG: | ||
402 | + return "SRST"; | ||
403 | + case TWI_EFR_REG: | ||
404 | + return "EFR"; | ||
405 | + case TWI_LCR_REG: | ||
406 | + return "LCR"; | ||
407 | + default: | ||
408 | + return "[?]"; | ||
409 | + } | ||
410 | +} | ||
411 | + | ||
412 | +static inline bool allwinner_i2c_is_reset(AWI2CState *s) | ||
413 | +{ | ||
414 | + return s->srst & TWI_SRST_MASK; | ||
415 | +} | ||
416 | + | ||
417 | +static inline bool allwinner_i2c_bus_is_enabled(AWI2CState *s) | ||
418 | +{ | ||
419 | + return s->cntr & TWI_CNTR_BUS_EN; | ||
420 | +} | ||
421 | + | ||
422 | +static inline bool allwinner_i2c_interrupt_is_enabled(AWI2CState *s) | ||
423 | +{ | ||
424 | + return s->cntr & TWI_CNTR_INT_EN; | ||
425 | +} | ||
426 | + | ||
427 | +static void allwinner_i2c_reset_hold(Object *obj) | ||
428 | +{ | ||
429 | + AWI2CState *s = AW_I2C(obj); | ||
430 | + | ||
431 | + if (STAT_TO_STA(s->stat) != STAT_IDLE) { | ||
432 | + i2c_end_transfer(s->bus); | ||
433 | + } | ||
434 | + | ||
435 | + s->addr = TWI_ADDR_RESET; | ||
436 | + s->xaddr = TWI_XADDR_RESET; | ||
437 | + s->data = TWI_DATA_RESET; | ||
438 | + s->cntr = TWI_CNTR_RESET; | ||
439 | + s->stat = TWI_STAT_RESET; | ||
440 | + s->ccr = TWI_CCR_RESET; | ||
441 | + s->srst = TWI_SRST_RESET; | ||
442 | + s->efr = TWI_EFR_RESET; | ||
443 | + s->lcr = TWI_LCR_RESET; | ||
444 | +} | ||
445 | + | ||
446 | +static inline void allwinner_i2c_raise_interrupt(AWI2CState *s) | ||
447 | +{ | ||
448 | + /* | ||
449 | + * Raise an interrupt if the device is not reset and it is configured | ||
450 | + * to generate some interrupts. | ||
451 | + */ | ||
452 | + if (!allwinner_i2c_is_reset(s) && allwinner_i2c_bus_is_enabled(s)) { | ||
453 | + if (STAT_TO_STA(s->stat) != STAT_IDLE) { | ||
454 | + s->cntr |= TWI_CNTR_INT_FLAG; | ||
455 | + if (allwinner_i2c_interrupt_is_enabled(s)) { | ||
456 | + qemu_irq_raise(s->irq); | ||
457 | + } | ||
458 | + } | ||
459 | + } | ||
460 | +} | ||
461 | + | ||
462 | +static uint64_t allwinner_i2c_read(void *opaque, hwaddr offset, | ||
463 | + unsigned size) | ||
464 | +{ | ||
465 | + uint16_t value; | ||
466 | + AWI2CState *s = AW_I2C(opaque); | ||
467 | + | ||
468 | + switch (offset) { | ||
469 | + case TWI_ADDR_REG: | ||
470 | + value = s->addr; | ||
471 | + break; | ||
472 | + case TWI_XADDR_REG: | ||
473 | + value = s->xaddr; | ||
474 | + break; | ||
475 | + case TWI_DATA_REG: | ||
476 | + if ((STAT_TO_STA(s->stat) == STAT_M_ADDR_RD_ACK) || | ||
477 | + (STAT_TO_STA(s->stat) == STAT_M_DATA_RX_ACK) || | ||
478 | + (STAT_TO_STA(s->stat) == STAT_M_DATA_RX_NACK)) { | ||
479 | + /* Get the next byte */ | ||
480 | + s->data = i2c_recv(s->bus); | ||
481 | + | ||
482 | + if (s->cntr & TWI_CNTR_A_ACK) { | ||
483 | + s->stat = STAT_FROM_STA(STAT_M_DATA_RX_ACK); | ||
484 | + } else { | ||
485 | + s->stat = STAT_FROM_STA(STAT_M_DATA_RX_NACK); | ||
486 | + } | ||
487 | + allwinner_i2c_raise_interrupt(s); | ||
488 | + } | ||
489 | + value = s->data; | ||
490 | + break; | ||
491 | + case TWI_CNTR_REG: | ||
492 | + value = s->cntr; | ||
493 | + break; | ||
494 | + case TWI_STAT_REG: | ||
495 | + value = s->stat; | ||
496 | + /* | ||
497 | + * If polling when reading then change state to indicate data | ||
498 | + * is available | ||
499 | + */ | ||
500 | + if (STAT_TO_STA(s->stat) == STAT_M_ADDR_RD_ACK) { | ||
501 | + if (s->cntr & TWI_CNTR_A_ACK) { | ||
502 | + s->stat = STAT_FROM_STA(STAT_M_DATA_RX_ACK); | ||
503 | + } else { | ||
504 | + s->stat = STAT_FROM_STA(STAT_M_DATA_RX_NACK); | ||
505 | + } | ||
506 | + allwinner_i2c_raise_interrupt(s); | ||
507 | + } | ||
508 | + break; | ||
509 | + case TWI_CCR_REG: | ||
510 | + value = s->ccr; | ||
511 | + break; | ||
512 | + case TWI_SRST_REG: | ||
513 | + value = s->srst; | ||
514 | + break; | ||
515 | + case TWI_EFR_REG: | ||
516 | + value = s->efr; | ||
517 | + break; | ||
518 | + case TWI_LCR_REG: | ||
519 | + value = s->lcr; | ||
520 | + break; | ||
521 | + default: | ||
522 | + qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Bad address at offset 0x%" | ||
523 | + HWADDR_PRIx "\n", TYPE_AW_I2C, __func__, offset); | ||
524 | + value = 0; | ||
525 | + break; | ||
526 | + } | ||
527 | + | ||
528 | + trace_allwinner_i2c_read(allwinner_i2c_get_regname(offset), offset, value); | ||
529 | + | ||
530 | + return (uint64_t)value; | ||
531 | +} | ||
532 | + | ||
533 | +static void allwinner_i2c_write(void *opaque, hwaddr offset, | ||
534 | + uint64_t value, unsigned size) | ||
535 | +{ | ||
536 | + AWI2CState *s = AW_I2C(opaque); | ||
537 | + | ||
538 | + value &= 0xff; | ||
539 | + | ||
540 | + trace_allwinner_i2c_write(allwinner_i2c_get_regname(offset), offset, value); | ||
541 | + | ||
542 | + switch (offset) { | ||
543 | + case TWI_ADDR_REG: | ||
544 | + s->addr = (uint8_t)value; | ||
545 | + break; | ||
546 | + case TWI_XADDR_REG: | ||
547 | + s->xaddr = (uint8_t)value; | ||
548 | + break; | ||
549 | + case TWI_DATA_REG: | ||
550 | + /* If the device is in reset or not enabled, nothing to do */ | ||
551 | + if (allwinner_i2c_is_reset(s) || (!allwinner_i2c_bus_is_enabled(s))) { | ||
552 | + break; | ||
553 | + } | ||
554 | + | ||
555 | + s->data = value & TWI_DATA_MASK; | ||
556 | + | ||
557 | + switch (STAT_TO_STA(s->stat)) { | ||
558 | + case STAT_M_STA_TX: | ||
559 | + case STAT_M_RSTA_TX: | ||
560 | + /* Send address */ | ||
561 | + if (i2c_start_transfer(s->bus, extract32(s->data, 1, 7), | ||
562 | + extract32(s->data, 0, 1))) { | ||
563 | + /* If non zero is returned, the address is not valid */ | ||
564 | + s->stat = STAT_FROM_STA(STAT_M_ADDR_WR_NACK); | ||
565 | + } else { | ||
566 | + /* Determine if read of write */ | ||
567 | + if (extract32(s->data, 0, 1)) { | ||
568 | + s->stat = STAT_FROM_STA(STAT_M_ADDR_RD_ACK); | ||
569 | + } else { | ||
570 | + s->stat = STAT_FROM_STA(STAT_M_ADDR_WR_ACK); | ||
571 | + } | ||
572 | + allwinner_i2c_raise_interrupt(s); | ||
573 | + } | ||
574 | + break; | ||
575 | + case STAT_M_ADDR_WR_ACK: | ||
576 | + case STAT_M_DATA_TX_ACK: | ||
577 | + if (i2c_send(s->bus, s->data)) { | ||
578 | + /* If the target return non zero then end the transfer */ | ||
579 | + s->stat = STAT_FROM_STA(STAT_M_DATA_TX_NACK); | ||
580 | + i2c_end_transfer(s->bus); | ||
581 | + } else { | ||
582 | + s->stat = STAT_FROM_STA(STAT_M_DATA_TX_ACK); | ||
583 | + allwinner_i2c_raise_interrupt(s); | ||
584 | + } | ||
585 | + break; | ||
586 | + default: | ||
587 | + break; | ||
588 | + } | ||
589 | + break; | ||
590 | + case TWI_CNTR_REG: | ||
591 | + if (!allwinner_i2c_is_reset(s)) { | ||
592 | + /* Do something only if not in software reset */ | ||
593 | + s->cntr = value & TWI_CNTR_MASK; | ||
594 | + | ||
595 | + /* Check if start condition should be sent */ | ||
596 | + if (s->cntr & TWI_CNTR_M_STA) { | ||
597 | + /* Update status */ | ||
598 | + if (STAT_TO_STA(s->stat) == STAT_IDLE) { | ||
599 | + /* Send start condition */ | ||
600 | + s->stat = STAT_FROM_STA(STAT_M_STA_TX); | ||
601 | + } else { | ||
602 | + /* Send repeated start condition */ | ||
603 | + s->stat = STAT_FROM_STA(STAT_M_RSTA_TX); | ||
604 | + } | ||
605 | + /* Clear start condition */ | ||
606 | + s->cntr &= ~TWI_CNTR_M_STA; | ||
607 | + } | ||
608 | + if (s->cntr & TWI_CNTR_M_STP) { | ||
609 | + /* Update status */ | ||
610 | + i2c_end_transfer(s->bus); | ||
611 | + s->stat = STAT_FROM_STA(STAT_IDLE); | ||
612 | + s->cntr &= ~TWI_CNTR_M_STP; | ||
613 | + } | ||
614 | + if ((s->cntr & TWI_CNTR_INT_FLAG) == 0) { | ||
615 | + /* Interrupt flag cleared */ | ||
616 | + qemu_irq_lower(s->irq); | ||
617 | + } | ||
618 | + if ((s->cntr & TWI_CNTR_A_ACK) == 0) { | ||
619 | + if (STAT_TO_STA(s->stat) == STAT_M_DATA_RX_ACK) { | ||
620 | + s->stat = STAT_FROM_STA(STAT_M_DATA_RX_NACK); | ||
621 | + } | ||
622 | + } else { | ||
623 | + if (STAT_TO_STA(s->stat) == STAT_M_DATA_RX_NACK) { | ||
624 | + s->stat = STAT_FROM_STA(STAT_M_DATA_RX_ACK); | ||
625 | + } | ||
626 | + } | ||
627 | + allwinner_i2c_raise_interrupt(s); | ||
628 | + | ||
629 | + } | ||
630 | + break; | ||
631 | + case TWI_CCR_REG: | ||
632 | + s->ccr = value & TWI_CCR_MASK; | ||
633 | + break; | ||
634 | + case TWI_SRST_REG: | ||
635 | + if (((value & TWI_SRST_MASK) == 0) && (s->srst & TWI_SRST_MASK)) { | ||
636 | + /* Perform reset */ | ||
637 | + allwinner_i2c_reset_hold(OBJECT(s)); | ||
638 | + } | ||
639 | + s->srst = value & TWI_SRST_MASK; | ||
640 | + break; | ||
641 | + case TWI_EFR_REG: | ||
642 | + s->efr = value & TWI_EFR_MASK; | ||
643 | + break; | ||
644 | + case TWI_LCR_REG: | ||
645 | + s->lcr = value & TWI_LCR_MASK; | ||
646 | + break; | ||
647 | + default: | ||
648 | + qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Bad address at offset 0x%" | ||
649 | + HWADDR_PRIx "\n", TYPE_AW_I2C, __func__, offset); | ||
650 | + break; | ||
651 | + } | ||
652 | +} | ||
653 | + | ||
654 | +static const MemoryRegionOps allwinner_i2c_ops = { | ||
655 | + .read = allwinner_i2c_read, | ||
656 | + .write = allwinner_i2c_write, | ||
657 | + .valid.min_access_size = 1, | ||
658 | + .valid.max_access_size = 4, | ||
659 | + .endianness = DEVICE_NATIVE_ENDIAN, | ||
191 | +}; | 660 | +}; |
192 | + | 661 | + |
193 | +void define_cortex_a72_a57_a53_cp_reginfo(ARMCPU *cpu) | 662 | +static const VMStateDescription allwinner_i2c_vmstate = { |
194 | +{ | 663 | + .name = TYPE_AW_I2C, |
195 | + define_arm_cp_regs(cpu, cortex_a72_a57_a53_cp_reginfo); | 664 | + .version_id = 1, |
196 | +} | 665 | + .minimum_version_id = 1, |
197 | +#endif /* !CONFIG_USER_ONLY */ | 666 | + .fields = (VMStateField[]) { |
198 | + | 667 | + VMSTATE_UINT8(addr, AWI2CState), |
199 | /* CPU models. These are not needed for the AArch64 linux-user build. */ | 668 | + VMSTATE_UINT8(xaddr, AWI2CState), |
200 | #if !defined(CONFIG_USER_ONLY) || !defined(TARGET_AARCH64) | 669 | + VMSTATE_UINT8(data, AWI2CState), |
201 | 670 | + VMSTATE_UINT8(cntr, AWI2CState), | |
671 | + VMSTATE_UINT8(ccr, AWI2CState), | ||
672 | + VMSTATE_UINT8(srst, AWI2CState), | ||
673 | + VMSTATE_UINT8(efr, AWI2CState), | ||
674 | + VMSTATE_UINT8(lcr, AWI2CState), | ||
675 | + VMSTATE_END_OF_LIST() | ||
676 | + } | ||
677 | +}; | ||
678 | + | ||
679 | +static void allwinner_i2c_realize(DeviceState *dev, Error **errp) | ||
680 | +{ | ||
681 | + AWI2CState *s = AW_I2C(dev); | ||
682 | + | ||
683 | + memory_region_init_io(&s->iomem, OBJECT(s), &allwinner_i2c_ops, s, | ||
684 | + TYPE_AW_I2C, AW_I2C_MEM_SIZE); | ||
685 | + sysbus_init_mmio(SYS_BUS_DEVICE(dev), &s->iomem); | ||
686 | + sysbus_init_irq(SYS_BUS_DEVICE(dev), &s->irq); | ||
687 | + s->bus = i2c_init_bus(dev, "i2c"); | ||
688 | +} | ||
689 | + | ||
690 | +static void allwinner_i2c_class_init(ObjectClass *klass, void *data) | ||
691 | +{ | ||
692 | + DeviceClass *dc = DEVICE_CLASS(klass); | ||
693 | + ResettableClass *rc = RESETTABLE_CLASS(klass); | ||
694 | + | ||
695 | + rc->phases.hold = allwinner_i2c_reset_hold; | ||
696 | + dc->vmsd = &allwinner_i2c_vmstate; | ||
697 | + dc->realize = allwinner_i2c_realize; | ||
698 | + dc->desc = "Allwinner I2C Controller"; | ||
699 | +} | ||
700 | + | ||
701 | +static const TypeInfo allwinner_i2c_type_info = { | ||
702 | + .name = TYPE_AW_I2C, | ||
703 | + .parent = TYPE_SYS_BUS_DEVICE, | ||
704 | + .instance_size = sizeof(AWI2CState), | ||
705 | + .class_init = allwinner_i2c_class_init, | ||
706 | +}; | ||
707 | + | ||
708 | +static void allwinner_i2c_register_types(void) | ||
709 | +{ | ||
710 | + type_register_static(&allwinner_i2c_type_info); | ||
711 | +} | ||
712 | + | ||
713 | +type_init(allwinner_i2c_register_types) | ||
714 | diff --git a/hw/arm/Kconfig b/hw/arm/Kconfig | ||
715 | index XXXXXXX..XXXXXXX 100644 | ||
716 | --- a/hw/arm/Kconfig | ||
717 | +++ b/hw/arm/Kconfig | ||
718 | @@ -XXX,XX +XXX,XX @@ config ALLWINNER_A10 | ||
719 | select ALLWINNER_A10_CCM | ||
720 | select ALLWINNER_A10_DRAMC | ||
721 | select ALLWINNER_EMAC | ||
722 | + select ALLWINNER_I2C | ||
723 | select SERIAL | ||
724 | select UNIMP | ||
725 | |||
726 | @@ -XXX,XX +XXX,XX @@ config ALLWINNER_H3 | ||
727 | bool | ||
728 | select ALLWINNER_A10_PIT | ||
729 | select ALLWINNER_SUN8I_EMAC | ||
730 | + select ALLWINNER_I2C | ||
731 | select SERIAL | ||
732 | select ARM_TIMER | ||
733 | select ARM_GIC | ||
734 | diff --git a/hw/i2c/Kconfig b/hw/i2c/Kconfig | ||
735 | index XXXXXXX..XXXXXXX 100644 | ||
736 | --- a/hw/i2c/Kconfig | ||
737 | +++ b/hw/i2c/Kconfig | ||
738 | @@ -XXX,XX +XXX,XX @@ config MPC_I2C | ||
739 | bool | ||
740 | select I2C | ||
741 | |||
742 | +config ALLWINNER_I2C | ||
743 | + bool | ||
744 | + select I2C | ||
745 | + | ||
746 | config PCA954X | ||
747 | bool | ||
748 | select I2C | ||
749 | diff --git a/hw/i2c/meson.build b/hw/i2c/meson.build | ||
750 | index XXXXXXX..XXXXXXX 100644 | ||
751 | --- a/hw/i2c/meson.build | ||
752 | +++ b/hw/i2c/meson.build | ||
753 | @@ -XXX,XX +XXX,XX @@ i2c_ss.add(when: 'CONFIG_BITBANG_I2C', if_true: files('bitbang_i2c.c')) | ||
754 | i2c_ss.add(when: 'CONFIG_EXYNOS4', if_true: files('exynos4210_i2c.c')) | ||
755 | i2c_ss.add(when: 'CONFIG_IMX_I2C', if_true: files('imx_i2c.c')) | ||
756 | i2c_ss.add(when: 'CONFIG_MPC_I2C', if_true: files('mpc_i2c.c')) | ||
757 | +i2c_ss.add(when: 'CONFIG_ALLWINNER_I2C', if_true: files('allwinner-i2c.c')) | ||
758 | i2c_ss.add(when: 'CONFIG_NRF51_SOC', if_true: files('microbit_i2c.c')) | ||
759 | i2c_ss.add(when: 'CONFIG_NPCM7XX', if_true: files('npcm7xx_smbus.c')) | ||
760 | i2c_ss.add(when: 'CONFIG_SMBUS_EEPROM', if_true: files('smbus_eeprom.c')) | ||
761 | diff --git a/hw/i2c/trace-events b/hw/i2c/trace-events | ||
762 | index XXXXXXX..XXXXXXX 100644 | ||
763 | --- a/hw/i2c/trace-events | ||
764 | +++ b/hw/i2c/trace-events | ||
765 | @@ -XXX,XX +XXX,XX @@ i2c_send_async(uint8_t address, uint8_t data) "send_async(addr:0x%02x) data:0x%0 | ||
766 | i2c_recv(uint8_t address, uint8_t data) "recv(addr:0x%02x) data:0x%02x" | ||
767 | i2c_ack(void) "" | ||
768 | |||
769 | +# allwinner_i2c.c | ||
770 | + | ||
771 | +allwinner_i2c_read(const char* reg_name, uint64_t offset, uint64_t value) "read %s [0x%" PRIx64 "]: -> 0x%" PRIx64 | ||
772 | +allwinner_i2c_write(const char* reg_name, uint64_t offset, uint64_t value) "write %s [0x%" PRIx64 "]: <- 0x%" PRIx64 | ||
773 | + | ||
774 | # aspeed_i2c.c | ||
775 | |||
776 | aspeed_i2c_bus_cmd(uint32_t cmd, const char *cmd_flags, uint32_t count, uint32_t intr_status) "handling cmd=0x%x %s count=%d intr=0x%x" | ||
202 | -- | 777 | -- |
203 | 2.25.1 | 778 | 2.34.1 | diff view generated by jsdifflib |
New patch | |||
---|---|---|---|
1 | From: Strahinja Jankovic <strahinjapjankovic@gmail.com> | ||
1 | 2 | ||
3 | This patch adds minimal support for AXP-209 PMU. | ||
4 | Most important is chip ID since U-Boot SPL expects version 0x1. Besides | ||
5 | the chip ID register, reset values for two more registers used by A10 | ||
6 | U-Boot SPL are covered. | ||
7 | |||
8 | Signed-off-by: Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
9 | Message-id: 20221226220303.14420-5-strahinja.p.jankovic@gmail.com | ||
10 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
12 | --- | ||
13 | hw/misc/axp209.c | 238 +++++++++++++++++++++++++++++++++++++++++++ | ||
14 | MAINTAINERS | 2 + | ||
15 | hw/misc/Kconfig | 4 + | ||
16 | hw/misc/meson.build | 1 + | ||
17 | hw/misc/trace-events | 5 + | ||
18 | 5 files changed, 250 insertions(+) | ||
19 | create mode 100644 hw/misc/axp209.c | ||
20 | |||
21 | diff --git a/hw/misc/axp209.c b/hw/misc/axp209.c | ||
22 | new file mode 100644 | ||
23 | index XXXXXXX..XXXXXXX | ||
24 | --- /dev/null | ||
25 | +++ b/hw/misc/axp209.c | ||
26 | @@ -XXX,XX +XXX,XX @@ | ||
27 | +/* | ||
28 | + * AXP-209 PMU Emulation | ||
29 | + * | ||
30 | + * Copyright (C) 2022 Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
31 | + * | ||
32 | + * Permission is hereby granted, free of charge, to any person obtaining a | ||
33 | + * copy of this software and associated documentation files (the "Software"), | ||
34 | + * to deal in the Software without restriction, including without limitation | ||
35 | + * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
36 | + * and/or sell copies of the Software, and to permit persons to whom the | ||
37 | + * Software is furnished to do so, subject to the following conditions: | ||
38 | + * | ||
39 | + * The above copyright notice and this permission notice shall be included in | ||
40 | + * all copies or substantial portions of the Software. | ||
41 | + * | ||
42 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
43 | + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
44 | + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
45 | + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
46 | + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | ||
47 | + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER | ||
48 | + * DEALINGS IN THE SOFTWARE. | ||
49 | + * | ||
50 | + * SPDX-License-Identifier: MIT | ||
51 | + */ | ||
52 | + | ||
53 | +#include "qemu/osdep.h" | ||
54 | +#include "qemu/log.h" | ||
55 | +#include "trace.h" | ||
56 | +#include "hw/i2c/i2c.h" | ||
57 | +#include "migration/vmstate.h" | ||
58 | + | ||
59 | +#define TYPE_AXP209_PMU "axp209_pmu" | ||
60 | + | ||
61 | +#define AXP209(obj) \ | ||
62 | + OBJECT_CHECK(AXP209I2CState, (obj), TYPE_AXP209_PMU) | ||
63 | + | ||
64 | +/* registers */ | ||
65 | +enum { | ||
66 | + REG_POWER_STATUS = 0x0u, | ||
67 | + REG_OPERATING_MODE, | ||
68 | + REG_OTG_VBUS_STATUS, | ||
69 | + REG_CHIP_VERSION, | ||
70 | + REG_DATA_CACHE_0, | ||
71 | + REG_DATA_CACHE_1, | ||
72 | + REG_DATA_CACHE_2, | ||
73 | + REG_DATA_CACHE_3, | ||
74 | + REG_DATA_CACHE_4, | ||
75 | + REG_DATA_CACHE_5, | ||
76 | + REG_DATA_CACHE_6, | ||
77 | + REG_DATA_CACHE_7, | ||
78 | + REG_DATA_CACHE_8, | ||
79 | + REG_DATA_CACHE_9, | ||
80 | + REG_DATA_CACHE_A, | ||
81 | + REG_DATA_CACHE_B, | ||
82 | + REG_POWER_OUTPUT_CTRL = 0x12u, | ||
83 | + REG_DC_DC2_OUT_V_CTRL = 0x23u, | ||
84 | + REG_DC_DC2_DVS_CTRL = 0x25u, | ||
85 | + REG_DC_DC3_OUT_V_CTRL = 0x27u, | ||
86 | + REG_LDO2_4_OUT_V_CTRL, | ||
87 | + REG_LDO3_OUT_V_CTRL, | ||
88 | + REG_VBUS_CH_MGMT = 0x30u, | ||
89 | + REG_SHUTDOWN_V_CTRL, | ||
90 | + REG_SHUTDOWN_CTRL, | ||
91 | + REG_CHARGE_CTRL_1, | ||
92 | + REG_CHARGE_CTRL_2, | ||
93 | + REG_SPARE_CHARGE_CTRL, | ||
94 | + REG_PEK_KEY_CTRL, | ||
95 | + REG_DC_DC_FREQ_SET, | ||
96 | + REG_CHR_TEMP_TH_SET, | ||
97 | + REG_CHR_HIGH_TEMP_TH_CTRL, | ||
98 | + REG_IPSOUT_WARN_L1, | ||
99 | + REG_IPSOUT_WARN_L2, | ||
100 | + REG_DISCHR_TEMP_TH_SET, | ||
101 | + REG_DISCHR_HIGH_TEMP_TH_CTRL, | ||
102 | + REG_IRQ_BANK_1_CTRL = 0x40u, | ||
103 | + REG_IRQ_BANK_2_CTRL, | ||
104 | + REG_IRQ_BANK_3_CTRL, | ||
105 | + REG_IRQ_BANK_4_CTRL, | ||
106 | + REG_IRQ_BANK_5_CTRL, | ||
107 | + REG_IRQ_BANK_1_STAT = 0x48u, | ||
108 | + REG_IRQ_BANK_2_STAT, | ||
109 | + REG_IRQ_BANK_3_STAT, | ||
110 | + REG_IRQ_BANK_4_STAT, | ||
111 | + REG_IRQ_BANK_5_STAT, | ||
112 | + REG_ADC_ACIN_V_H = 0x56u, | ||
113 | + REG_ADC_ACIN_V_L, | ||
114 | + REG_ADC_ACIN_CURR_H, | ||
115 | + REG_ADC_ACIN_CURR_L, | ||
116 | + REG_ADC_VBUS_V_H, | ||
117 | + REG_ADC_VBUS_V_L, | ||
118 | + REG_ADC_VBUS_CURR_H, | ||
119 | + REG_ADC_VBUS_CURR_L, | ||
120 | + REG_ADC_INT_TEMP_H, | ||
121 | + REG_ADC_INT_TEMP_L, | ||
122 | + REG_ADC_TEMP_SENS_V_H = 0x62u, | ||
123 | + REG_ADC_TEMP_SENS_V_L, | ||
124 | + REG_ADC_BAT_V_H = 0x78u, | ||
125 | + REG_ADC_BAT_V_L, | ||
126 | + REG_ADC_BAT_DISCHR_CURR_H, | ||
127 | + REG_ADC_BAT_DISCHR_CURR_L, | ||
128 | + REG_ADC_BAT_CHR_CURR_H, | ||
129 | + REG_ADC_BAT_CHR_CURR_L, | ||
130 | + REG_ADC_IPSOUT_V_H, | ||
131 | + REG_ADC_IPSOUT_V_L, | ||
132 | + REG_DC_DC_MOD_SEL = 0x80u, | ||
133 | + REG_ADC_EN_1, | ||
134 | + REG_ADC_EN_2, | ||
135 | + REG_ADC_SR_CTRL, | ||
136 | + REG_ADC_IN_RANGE, | ||
137 | + REG_GPIO1_ADC_IRQ_RISING_TH, | ||
138 | + REG_GPIO1_ADC_IRQ_FALLING_TH, | ||
139 | + REG_TIMER_CTRL = 0x8au, | ||
140 | + REG_VBUS_CTRL_MON_SRP, | ||
141 | + REG_OVER_TEMP_SHUTDOWN = 0x8fu, | ||
142 | + REG_GPIO0_FEAT_SET, | ||
143 | + REG_GPIO_OUT_HIGH_SET, | ||
144 | + REG_GPIO1_FEAT_SET, | ||
145 | + REG_GPIO2_FEAT_SET, | ||
146 | + REG_GPIO_SIG_STATE_SET_MON, | ||
147 | + REG_GPIO3_SET, | ||
148 | + REG_COULOMB_CNTR_CTRL = 0xb8u, | ||
149 | + REG_POWER_MEAS_RES, | ||
150 | + NR_REGS | ||
151 | +}; | ||
152 | + | ||
153 | +#define AXP209_CHIP_VERSION_ID (0x01) | ||
154 | +#define AXP209_DC_DC2_OUT_V_CTRL_RESET (0x16) | ||
155 | +#define AXP209_IRQ_BANK_1_CTRL_RESET (0xd8) | ||
156 | + | ||
157 | +/* A simple I2C slave which returns values of ID or CNT register. */ | ||
158 | +typedef struct AXP209I2CState { | ||
159 | + /*< private >*/ | ||
160 | + I2CSlave i2c; | ||
161 | + /*< public >*/ | ||
162 | + uint8_t regs[NR_REGS]; /* peripheral registers */ | ||
163 | + uint8_t ptr; /* current register index */ | ||
164 | + uint8_t count; /* counter used for tx/rx */ | ||
165 | +} AXP209I2CState; | ||
166 | + | ||
167 | +/* Reset all counters and load ID register */ | ||
168 | +static void axp209_reset_enter(Object *obj, ResetType type) | ||
169 | +{ | ||
170 | + AXP209I2CState *s = AXP209(obj); | ||
171 | + | ||
172 | + memset(s->regs, 0, NR_REGS); | ||
173 | + s->ptr = 0; | ||
174 | + s->count = 0; | ||
175 | + s->regs[REG_CHIP_VERSION] = AXP209_CHIP_VERSION_ID; | ||
176 | + s->regs[REG_DC_DC2_OUT_V_CTRL] = AXP209_DC_DC2_OUT_V_CTRL_RESET; | ||
177 | + s->regs[REG_IRQ_BANK_1_CTRL] = AXP209_IRQ_BANK_1_CTRL_RESET; | ||
178 | +} | ||
179 | + | ||
180 | +/* Handle events from master. */ | ||
181 | +static int axp209_event(I2CSlave *i2c, enum i2c_event event) | ||
182 | +{ | ||
183 | + AXP209I2CState *s = AXP209(i2c); | ||
184 | + | ||
185 | + s->count = 0; | ||
186 | + | ||
187 | + return 0; | ||
188 | +} | ||
189 | + | ||
190 | +/* Called when master requests read */ | ||
191 | +static uint8_t axp209_rx(I2CSlave *i2c) | ||
192 | +{ | ||
193 | + AXP209I2CState *s = AXP209(i2c); | ||
194 | + uint8_t ret = 0xff; | ||
195 | + | ||
196 | + if (s->ptr < NR_REGS) { | ||
197 | + ret = s->regs[s->ptr++]; | ||
198 | + } | ||
199 | + | ||
200 | + trace_axp209_rx(s->ptr - 1, ret); | ||
201 | + | ||
202 | + return ret; | ||
203 | +} | ||
204 | + | ||
205 | +/* | ||
206 | + * Called when master sends write. | ||
207 | + * Update ptr with byte 0, then perform write with second byte. | ||
208 | + */ | ||
209 | +static int axp209_tx(I2CSlave *i2c, uint8_t data) | ||
210 | +{ | ||
211 | + AXP209I2CState *s = AXP209(i2c); | ||
212 | + | ||
213 | + if (s->count == 0) { | ||
214 | + /* Store register address */ | ||
215 | + s->ptr = data; | ||
216 | + s->count++; | ||
217 | + trace_axp209_select(data); | ||
218 | + } else { | ||
219 | + trace_axp209_tx(s->ptr, data); | ||
220 | + if (s->ptr == REG_DC_DC2_OUT_V_CTRL) { | ||
221 | + s->regs[s->ptr++] = data; | ||
222 | + } | ||
223 | + } | ||
224 | + | ||
225 | + return 0; | ||
226 | +} | ||
227 | + | ||
228 | +static const VMStateDescription vmstate_axp209 = { | ||
229 | + .name = TYPE_AXP209_PMU, | ||
230 | + .version_id = 1, | ||
231 | + .fields = (VMStateField[]) { | ||
232 | + VMSTATE_UINT8_ARRAY(regs, AXP209I2CState, NR_REGS), | ||
233 | + VMSTATE_UINT8(count, AXP209I2CState), | ||
234 | + VMSTATE_UINT8(ptr, AXP209I2CState), | ||
235 | + VMSTATE_END_OF_LIST() | ||
236 | + } | ||
237 | +}; | ||
238 | + | ||
239 | +static void axp209_class_init(ObjectClass *oc, void *data) | ||
240 | +{ | ||
241 | + DeviceClass *dc = DEVICE_CLASS(oc); | ||
242 | + I2CSlaveClass *isc = I2C_SLAVE_CLASS(oc); | ||
243 | + ResettableClass *rc = RESETTABLE_CLASS(oc); | ||
244 | + | ||
245 | + rc->phases.enter = axp209_reset_enter; | ||
246 | + dc->vmsd = &vmstate_axp209; | ||
247 | + isc->event = axp209_event; | ||
248 | + isc->recv = axp209_rx; | ||
249 | + isc->send = axp209_tx; | ||
250 | +} | ||
251 | + | ||
252 | +static const TypeInfo axp209_info = { | ||
253 | + .name = TYPE_AXP209_PMU, | ||
254 | + .parent = TYPE_I2C_SLAVE, | ||
255 | + .instance_size = sizeof(AXP209I2CState), | ||
256 | + .class_init = axp209_class_init | ||
257 | +}; | ||
258 | + | ||
259 | +static void axp209_register_devices(void) | ||
260 | +{ | ||
261 | + type_register_static(&axp209_info); | ||
262 | +} | ||
263 | + | ||
264 | +type_init(axp209_register_devices); | ||
265 | diff --git a/MAINTAINERS b/MAINTAINERS | ||
266 | index XXXXXXX..XXXXXXX 100644 | ||
267 | --- a/MAINTAINERS | ||
268 | +++ b/MAINTAINERS | ||
269 | @@ -XXX,XX +XXX,XX @@ ARM Machines | ||
270 | Allwinner-a10 | ||
271 | M: Beniamino Galvani <b.galvani@gmail.com> | ||
272 | M: Peter Maydell <peter.maydell@linaro.org> | ||
273 | +R: Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
274 | L: qemu-arm@nongnu.org | ||
275 | S: Odd Fixes | ||
276 | F: hw/*/allwinner* | ||
277 | F: include/hw/*/allwinner* | ||
278 | F: hw/arm/cubieboard.c | ||
279 | F: docs/system/arm/cubieboard.rst | ||
280 | +F: hw/misc/axp209.c | ||
281 | |||
282 | Allwinner-h3 | ||
283 | M: Niek Linnenbank <nieklinnenbank@gmail.com> | ||
284 | diff --git a/hw/misc/Kconfig b/hw/misc/Kconfig | ||
285 | index XXXXXXX..XXXXXXX 100644 | ||
286 | --- a/hw/misc/Kconfig | ||
287 | +++ b/hw/misc/Kconfig | ||
288 | @@ -XXX,XX +XXX,XX @@ config ALLWINNER_A10_CCM | ||
289 | config ALLWINNER_A10_DRAMC | ||
290 | bool | ||
291 | |||
292 | +config AXP209_PMU | ||
293 | + bool | ||
294 | + depends on I2C | ||
295 | + | ||
296 | source macio/Kconfig | ||
297 | diff --git a/hw/misc/meson.build b/hw/misc/meson.build | ||
298 | index XXXXXXX..XXXXXXX 100644 | ||
299 | --- a/hw/misc/meson.build | ||
300 | +++ b/hw/misc/meson.build | ||
301 | @@ -XXX,XX +XXX,XX @@ specific_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-cpucfg.c' | ||
302 | softmmu_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-h3-dramc.c')) | ||
303 | softmmu_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-h3-sysctrl.c')) | ||
304 | softmmu_ss.add(when: 'CONFIG_ALLWINNER_H3', if_true: files('allwinner-sid.c')) | ||
305 | +softmmu_ss.add(when: 'CONFIG_AXP209_PMU', if_true: files('axp209.c')) | ||
306 | softmmu_ss.add(when: 'CONFIG_REALVIEW', if_true: files('arm_sysctl.c')) | ||
307 | softmmu_ss.add(when: 'CONFIG_NSERIES', if_true: files('cbus.c')) | ||
308 | softmmu_ss.add(when: 'CONFIG_ECCMEMCTL', if_true: files('eccmemctl.c')) | ||
309 | diff --git a/hw/misc/trace-events b/hw/misc/trace-events | ||
310 | index XXXXXXX..XXXXXXX 100644 | ||
311 | --- a/hw/misc/trace-events | ||
312 | +++ b/hw/misc/trace-events | ||
313 | @@ -XXX,XX +XXX,XX @@ allwinner_sid_write(uint64_t offset, uint64_t data, unsigned size) "offset 0x%" | ||
314 | avr_power_read(uint8_t value) "power_reduc read value:%u" | ||
315 | avr_power_write(uint8_t value) "power_reduc write value:%u" | ||
316 | |||
317 | +# axp209.c | ||
318 | +axp209_rx(uint8_t reg, uint8_t data) "Read reg 0x%" PRIx8 " : 0x%" PRIx8 | ||
319 | +axp209_select(uint8_t reg) "Accessing reg 0x%" PRIx8 | ||
320 | +axp209_tx(uint8_t reg, uint8_t data) "Write reg 0x%" PRIx8 " : 0x%" PRIx8 | ||
321 | + | ||
322 | # eccmemctl.c | ||
323 | ecc_mem_writel_mer(uint32_t val) "Write memory enable 0x%08x" | ||
324 | ecc_mem_writel_mdr(uint32_t val) "Write memory delay 0x%08x" | ||
325 | -- | ||
326 | 2.34.1 | diff view generated by jsdifflib |
1 | From: Gavin Shan <gshan@redhat.com> | 1 | From: Strahinja Jankovic <strahinjapjankovic@gmail.com> |
---|---|---|---|
2 | 2 | ||
3 | When the PPTT table is built, the CPU topology is re-calculated, but | 3 | SPL Boot for Cubieboard expects AXP209 connected to I2C0 bus. |
4 | it's unecessary because the CPU topology has been populated in | ||
5 | virt_possible_cpu_arch_ids() on arm/virt machine. | ||
6 | 4 | ||
7 | This reworks build_pptt() to avoid by reusing the existing IDs in | 5 | Signed-off-by: Strahinja Jankovic <strahinja.p.jankovic@gmail.com> |
8 | ms->possible_cpus. Currently, the only user of build_pptt() is | ||
9 | arm/virt machine. | ||
10 | 6 | ||
11 | Signed-off-by: Gavin Shan <gshan@redhat.com> | 7 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
12 | Tested-by: Yanan Wang <wangyanan55@huawei.com> | 8 | Message-id: 20221226220303.14420-6-strahinja.p.jankovic@gmail.com |
13 | Reviewed-by: Yanan Wang <wangyanan55@huawei.com> | ||
14 | Acked-by: Igor Mammedov <imammedo@redhat.com> | ||
15 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
16 | Message-id: 20220503140304.855514-7-gshan@redhat.com | ||
17 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
18 | --- | 10 | --- |
19 | hw/acpi/aml-build.c | 111 +++++++++++++++++++------------------------- | 11 | hw/arm/cubieboard.c | 6 ++++++ |
20 | 1 file changed, 48 insertions(+), 63 deletions(-) | 12 | hw/arm/Kconfig | 1 + |
13 | 2 files changed, 7 insertions(+) | ||
21 | 14 | ||
22 | diff --git a/hw/acpi/aml-build.c b/hw/acpi/aml-build.c | 15 | diff --git a/hw/arm/cubieboard.c b/hw/arm/cubieboard.c |
23 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
24 | --- a/hw/acpi/aml-build.c | 17 | --- a/hw/arm/cubieboard.c |
25 | +++ b/hw/acpi/aml-build.c | 18 | +++ b/hw/arm/cubieboard.c |
26 | @@ -XXX,XX +XXX,XX @@ void build_pptt(GArray *table_data, BIOSLinker *linker, MachineState *ms, | 19 | @@ -XXX,XX +XXX,XX @@ |
27 | const char *oem_id, const char *oem_table_id) | 20 | #include "hw/boards.h" |
28 | { | 21 | #include "hw/qdev-properties.h" |
29 | MachineClass *mc = MACHINE_GET_CLASS(ms); | 22 | #include "hw/arm/allwinner-a10.h" |
30 | - GQueue *list = g_queue_new(); | 23 | +#include "hw/i2c/i2c.h" |
31 | - guint pptt_start = table_data->len; | 24 | |
32 | - guint parent_offset; | 25 | static struct arm_boot_info cubieboard_binfo = { |
33 | - guint length, i; | 26 | .loader_start = AW_A10_SDRAM_BASE, |
34 | - int uid = 0; | 27 | @@ -XXX,XX +XXX,XX @@ static void cubieboard_init(MachineState *machine) |
35 | - int socket; | 28 | BlockBackend *blk; |
36 | + CPUArchIdList *cpus = ms->possible_cpus; | 29 | BusState *bus; |
37 | + int64_t socket_id = -1, cluster_id = -1, core_id = -1; | 30 | DeviceState *carddev; |
38 | + uint32_t socket_offset = 0, cluster_offset = 0, core_offset = 0; | 31 | + I2CBus *i2c; |
39 | + uint32_t pptt_start = table_data->len; | 32 | |
40 | + int n; | 33 | /* BIOS is not supported by this board */ |
41 | AcpiTable table = { .sig = "PPTT", .rev = 2, | 34 | if (machine->firmware) { |
42 | .oem_id = oem_id, .oem_table_id = oem_table_id }; | 35 | @@ -XXX,XX +XXX,XX @@ static void cubieboard_init(MachineState *machine) |
43 | 36 | exit(1); | |
44 | acpi_table_begin(&table, table_data); | ||
45 | |||
46 | - for (socket = 0; socket < ms->smp.sockets; socket++) { | ||
47 | - g_queue_push_tail(list, | ||
48 | - GUINT_TO_POINTER(table_data->len - pptt_start)); | ||
49 | - build_processor_hierarchy_node( | ||
50 | - table_data, | ||
51 | - /* | ||
52 | - * Physical package - represents the boundary | ||
53 | - * of a physical package | ||
54 | - */ | ||
55 | - (1 << 0), | ||
56 | - 0, socket, NULL, 0); | ||
57 | - } | ||
58 | - | ||
59 | - if (mc->smp_props.clusters_supported) { | ||
60 | - length = g_queue_get_length(list); | ||
61 | - for (i = 0; i < length; i++) { | ||
62 | - int cluster; | ||
63 | - | ||
64 | - parent_offset = GPOINTER_TO_UINT(g_queue_pop_head(list)); | ||
65 | - for (cluster = 0; cluster < ms->smp.clusters; cluster++) { | ||
66 | - g_queue_push_tail(list, | ||
67 | - GUINT_TO_POINTER(table_data->len - pptt_start)); | ||
68 | - build_processor_hierarchy_node( | ||
69 | - table_data, | ||
70 | - (0 << 0), /* not a physical package */ | ||
71 | - parent_offset, cluster, NULL, 0); | ||
72 | - } | ||
73 | + /* | ||
74 | + * This works with the assumption that cpus[n].props.*_id has been | ||
75 | + * sorted from top to down levels in mc->possible_cpu_arch_ids(). | ||
76 | + * Otherwise, the unexpected and duplicated containers will be | ||
77 | + * created. | ||
78 | + */ | ||
79 | + for (n = 0; n < cpus->len; n++) { | ||
80 | + if (cpus->cpus[n].props.socket_id != socket_id) { | ||
81 | + assert(cpus->cpus[n].props.socket_id > socket_id); | ||
82 | + socket_id = cpus->cpus[n].props.socket_id; | ||
83 | + cluster_id = -1; | ||
84 | + core_id = -1; | ||
85 | + socket_offset = table_data->len - pptt_start; | ||
86 | + build_processor_hierarchy_node(table_data, | ||
87 | + (1 << 0), /* Physical package */ | ||
88 | + 0, socket_id, NULL, 0); | ||
89 | } | ||
90 | - } | ||
91 | |||
92 | - length = g_queue_get_length(list); | ||
93 | - for (i = 0; i < length; i++) { | ||
94 | - int core; | ||
95 | - | ||
96 | - parent_offset = GPOINTER_TO_UINT(g_queue_pop_head(list)); | ||
97 | - for (core = 0; core < ms->smp.cores; core++) { | ||
98 | - if (ms->smp.threads > 1) { | ||
99 | - g_queue_push_tail(list, | ||
100 | - GUINT_TO_POINTER(table_data->len - pptt_start)); | ||
101 | - build_processor_hierarchy_node( | ||
102 | - table_data, | ||
103 | - (0 << 0), /* not a physical package */ | ||
104 | - parent_offset, core, NULL, 0); | ||
105 | - } else { | ||
106 | - build_processor_hierarchy_node( | ||
107 | - table_data, | ||
108 | - (1 << 1) | /* ACPI Processor ID valid */ | ||
109 | - (1 << 3), /* Node is a Leaf */ | ||
110 | - parent_offset, uid++, NULL, 0); | ||
111 | + if (mc->smp_props.clusters_supported) { | ||
112 | + if (cpus->cpus[n].props.cluster_id != cluster_id) { | ||
113 | + assert(cpus->cpus[n].props.cluster_id > cluster_id); | ||
114 | + cluster_id = cpus->cpus[n].props.cluster_id; | ||
115 | + core_id = -1; | ||
116 | + cluster_offset = table_data->len - pptt_start; | ||
117 | + build_processor_hierarchy_node(table_data, | ||
118 | + (0 << 0), /* Not a physical package */ | ||
119 | + socket_offset, cluster_id, NULL, 0); | ||
120 | } | ||
121 | + } else { | ||
122 | + cluster_offset = socket_offset; | ||
123 | } | ||
124 | - } | ||
125 | |||
126 | - length = g_queue_get_length(list); | ||
127 | - for (i = 0; i < length; i++) { | ||
128 | - int thread; | ||
129 | + if (ms->smp.threads == 1) { | ||
130 | + build_processor_hierarchy_node(table_data, | ||
131 | + (1 << 1) | /* ACPI Processor ID valid */ | ||
132 | + (1 << 3), /* Node is a Leaf */ | ||
133 | + cluster_offset, n, NULL, 0); | ||
134 | + } else { | ||
135 | + if (cpus->cpus[n].props.core_id != core_id) { | ||
136 | + assert(cpus->cpus[n].props.core_id > core_id); | ||
137 | + core_id = cpus->cpus[n].props.core_id; | ||
138 | + core_offset = table_data->len - pptt_start; | ||
139 | + build_processor_hierarchy_node(table_data, | ||
140 | + (0 << 0), /* Not a physical package */ | ||
141 | + cluster_offset, core_id, NULL, 0); | ||
142 | + } | ||
143 | |||
144 | - parent_offset = GPOINTER_TO_UINT(g_queue_pop_head(list)); | ||
145 | - for (thread = 0; thread < ms->smp.threads; thread++) { | ||
146 | - build_processor_hierarchy_node( | ||
147 | - table_data, | ||
148 | + build_processor_hierarchy_node(table_data, | ||
149 | (1 << 1) | /* ACPI Processor ID valid */ | ||
150 | (1 << 2) | /* Processor is a Thread */ | ||
151 | (1 << 3), /* Node is a Leaf */ | ||
152 | - parent_offset, uid++, NULL, 0); | ||
153 | + core_offset, n, NULL, 0); | ||
154 | } | ||
155 | } | 37 | } |
156 | 38 | ||
157 | - g_queue_free(list); | 39 | + /* Connect AXP 209 */ |
158 | acpi_table_end(linker, &table); | 40 | + i2c = I2C_BUS(qdev_get_child_bus(DEVICE(&a10->i2c0), "i2c")); |
159 | } | 41 | + i2c_slave_create_simple(i2c, "axp209_pmu", 0x34); |
42 | + | ||
43 | /* Retrieve SD bus */ | ||
44 | di = drive_get(IF_SD, 0, 0); | ||
45 | blk = di ? blk_by_legacy_dinfo(di) : NULL; | ||
46 | diff --git a/hw/arm/Kconfig b/hw/arm/Kconfig | ||
47 | index XXXXXXX..XXXXXXX 100644 | ||
48 | --- a/hw/arm/Kconfig | ||
49 | +++ b/hw/arm/Kconfig | ||
50 | @@ -XXX,XX +XXX,XX @@ config ALLWINNER_A10 | ||
51 | select ALLWINNER_A10_DRAMC | ||
52 | select ALLWINNER_EMAC | ||
53 | select ALLWINNER_I2C | ||
54 | + select AXP209_PMU | ||
55 | select SERIAL | ||
56 | select UNIMP | ||
160 | 57 | ||
161 | -- | 58 | -- |
162 | 2.25.1 | 59 | 2.34.1 |
60 | |||
61 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Strahinja Jankovic <strahinjapjankovic@gmail.com> |
---|---|---|---|
2 | 2 | ||
3 | Share the code to set AArch32 max features so that we no | 3 | This patch enables copying of SPL from MMC if `-kernel` parameter is not |
4 | longer have code drift between qemu{-system,}-{arm,aarch64}. | 4 | passed when starting QEMU. SPL is copied to SRAM_A. |
5 | 5 | ||
6 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 6 | The approach is reused from Allwinner H3 implementation. |
7 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 7 | |
8 | Message-id: 20220506180242.216785-9-richard.henderson@linaro.org | 8 | Tested with Armbian and custom Yocto image. |
9 | |||
10 | Signed-off-by: Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
11 | |||
12 | Reviewed-by: Niek Linnenbank <nieklinnenbank@gmail.com> | ||
13 | Message-id: 20221226220303.14420-7-strahinja.p.jankovic@gmail.com | ||
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 14 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
10 | --- | 15 | --- |
11 | target/arm/internals.h | 2 + | 16 | include/hw/arm/allwinner-a10.h | 21 +++++++++++++++++++++ |
12 | target/arm/cpu64.c | 50 +----------------- | 17 | hw/arm/allwinner-a10.c | 18 ++++++++++++++++++ |
13 | target/arm/cpu_tcg.c | 114 ++++++++++++++++++++++------------------- | 18 | hw/arm/cubieboard.c | 5 +++++ |
14 | 3 files changed, 65 insertions(+), 101 deletions(-) | 19 | 3 files changed, 44 insertions(+) |
15 | 20 | ||
16 | diff --git a/target/arm/internals.h b/target/arm/internals.h | 21 | diff --git a/include/hw/arm/allwinner-a10.h b/include/hw/arm/allwinner-a10.h |
17 | index XXXXXXX..XXXXXXX 100644 | 22 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/target/arm/internals.h | 23 | --- a/include/hw/arm/allwinner-a10.h |
19 | +++ b/target/arm/internals.h | 24 | +++ b/include/hw/arm/allwinner-a10.h |
20 | @@ -XXX,XX +XXX,XX @@ static inline void define_cortex_a72_a57_a53_cp_reginfo(ARMCPU *cpu) { } | 25 | @@ -XXX,XX +XXX,XX @@ |
21 | void define_cortex_a72_a57_a53_cp_reginfo(ARMCPU *cpu); | 26 | #include "hw/misc/allwinner-a10-ccm.h" |
22 | #endif | 27 | #include "hw/misc/allwinner-a10-dramc.h" |
23 | 28 | #include "hw/i2c/allwinner-i2c.h" | |
24 | +void aa32_max_features(ARMCPU *cpu); | 29 | +#include "sysemu/block-backend.h" |
30 | |||
31 | #include "target/arm/cpu.h" | ||
32 | #include "qom/object.h" | ||
33 | @@ -XXX,XX +XXX,XX @@ struct AwA10State { | ||
34 | OHCISysBusState ohci[AW_A10_NUM_USB]; | ||
35 | }; | ||
36 | |||
37 | +/** | ||
38 | + * Emulate Boot ROM firmware setup functionality. | ||
39 | + * | ||
40 | + * A real Allwinner A10 SoC contains a Boot ROM | ||
41 | + * which is the first code that runs right after | ||
42 | + * the SoC is powered on. The Boot ROM is responsible | ||
43 | + * for loading user code (e.g. a bootloader) from any | ||
44 | + * of the supported external devices and writing the | ||
45 | + * downloaded code to internal SRAM. After loading the SoC | ||
46 | + * begins executing the code written to SRAM. | ||
47 | + * | ||
48 | + * This function emulates the Boot ROM by copying 32 KiB | ||
49 | + * of data at offset 8 KiB from the given block device and writes it to | ||
50 | + * the start of the first internal SRAM memory. | ||
51 | + * | ||
52 | + * @s: Allwinner A10 state object pointer | ||
53 | + * @blk: Block backend device object pointer | ||
54 | + */ | ||
55 | +void allwinner_a10_bootrom_setup(AwA10State *s, BlockBackend *blk); | ||
25 | + | 56 | + |
26 | #endif | 57 | #endif |
27 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 58 | diff --git a/hw/arm/allwinner-a10.c b/hw/arm/allwinner-a10.c |
28 | index XXXXXXX..XXXXXXX 100644 | 59 | index XXXXXXX..XXXXXXX 100644 |
29 | --- a/target/arm/cpu64.c | 60 | --- a/hw/arm/allwinner-a10.c |
30 | +++ b/target/arm/cpu64.c | 61 | +++ b/hw/arm/allwinner-a10.c |
31 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | ||
32 | { | ||
33 | ARMCPU *cpu = ARM_CPU(obj); | ||
34 | uint64_t t; | ||
35 | - uint32_t u; | ||
36 | |||
37 | if (kvm_enabled() || hvf_enabled()) { | ||
38 | /* With KVM or HVF, '-cpu max' is identical to '-cpu host' */ | ||
39 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | ||
40 | t = FIELD_DP64(t, ID_AA64ZFR0, F64MM, 1); | ||
41 | cpu->isar.id_aa64zfr0 = t; | ||
42 | |||
43 | - /* Replicate the same data to the 32-bit id registers. */ | ||
44 | - u = cpu->isar.id_isar5; | ||
45 | - u = FIELD_DP32(u, ID_ISAR5, AES, 2); /* AES + PMULL */ | ||
46 | - u = FIELD_DP32(u, ID_ISAR5, SHA1, 1); | ||
47 | - u = FIELD_DP32(u, ID_ISAR5, SHA2, 1); | ||
48 | - u = FIELD_DP32(u, ID_ISAR5, CRC32, 1); | ||
49 | - u = FIELD_DP32(u, ID_ISAR5, RDM, 1); | ||
50 | - u = FIELD_DP32(u, ID_ISAR5, VCMA, 1); | ||
51 | - cpu->isar.id_isar5 = u; | ||
52 | - | ||
53 | - u = cpu->isar.id_isar6; | ||
54 | - u = FIELD_DP32(u, ID_ISAR6, JSCVT, 1); | ||
55 | - u = FIELD_DP32(u, ID_ISAR6, DP, 1); | ||
56 | - u = FIELD_DP32(u, ID_ISAR6, FHM, 1); | ||
57 | - u = FIELD_DP32(u, ID_ISAR6, SB, 1); | ||
58 | - u = FIELD_DP32(u, ID_ISAR6, SPECRES, 1); | ||
59 | - u = FIELD_DP32(u, ID_ISAR6, BF16, 1); | ||
60 | - u = FIELD_DP32(u, ID_ISAR6, I8MM, 1); | ||
61 | - cpu->isar.id_isar6 = u; | ||
62 | - | ||
63 | - u = cpu->isar.id_pfr0; | ||
64 | - u = FIELD_DP32(u, ID_PFR0, DIT, 1); | ||
65 | - cpu->isar.id_pfr0 = u; | ||
66 | - | ||
67 | - u = cpu->isar.id_pfr2; | ||
68 | - u = FIELD_DP32(u, ID_PFR2, SSBS, 1); | ||
69 | - cpu->isar.id_pfr2 = u; | ||
70 | - | ||
71 | - u = cpu->isar.id_mmfr3; | ||
72 | - u = FIELD_DP32(u, ID_MMFR3, PAN, 2); /* ATS1E1 */ | ||
73 | - cpu->isar.id_mmfr3 = u; | ||
74 | - | ||
75 | - u = cpu->isar.id_mmfr4; | ||
76 | - u = FIELD_DP32(u, ID_MMFR4, HPDS, 1); /* AA32HPD */ | ||
77 | - u = FIELD_DP32(u, ID_MMFR4, AC2, 1); /* ACTLR2, HACTLR2 */ | ||
78 | - u = FIELD_DP32(u, ID_MMFR4, CNP, 1); /* TTCNP */ | ||
79 | - u = FIELD_DP32(u, ID_MMFR4, XNX, 1); /* TTS2UXN */ | ||
80 | - cpu->isar.id_mmfr4 = u; | ||
81 | - | ||
82 | t = cpu->isar.id_aa64dfr0; | ||
83 | t = FIELD_DP64(t, ID_AA64DFR0, PMUVER, 5); /* v8.4-PMU */ | ||
84 | cpu->isar.id_aa64dfr0 = t; | ||
85 | |||
86 | - u = cpu->isar.id_dfr0; | ||
87 | - u = FIELD_DP32(u, ID_DFR0, PERFMON, 5); /* v8.4-PMU */ | ||
88 | - cpu->isar.id_dfr0 = u; | ||
89 | - | ||
90 | - u = cpu->isar.mvfr1; | ||
91 | - u = FIELD_DP32(u, MVFR1, FPHP, 3); /* v8.2-FP16 */ | ||
92 | - u = FIELD_DP32(u, MVFR1, SIMDHP, 2); /* v8.2-FP16 */ | ||
93 | - cpu->isar.mvfr1 = u; | ||
94 | + /* Replicate the same data to the 32-bit id registers. */ | ||
95 | + aa32_max_features(cpu); | ||
96 | |||
97 | #ifdef CONFIG_USER_ONLY | ||
98 | /* | ||
99 | diff --git a/target/arm/cpu_tcg.c b/target/arm/cpu_tcg.c | ||
100 | index XXXXXXX..XXXXXXX 100644 | ||
101 | --- a/target/arm/cpu_tcg.c | ||
102 | +++ b/target/arm/cpu_tcg.c | ||
103 | @@ -XXX,XX +XXX,XX @@ | 62 | @@ -XXX,XX +XXX,XX @@ |
104 | #endif | 63 | #include "sysemu/sysemu.h" |
105 | #include "cpregs.h" | 64 | #include "hw/boards.h" |
106 | 65 | #include "hw/usb/hcd-ohci.h" | |
66 | +#include "hw/loader.h" | ||
67 | |||
68 | +#define AW_A10_SRAM_A_BASE 0x00000000 | ||
69 | #define AW_A10_DRAMC_BASE 0x01c01000 | ||
70 | #define AW_A10_MMC0_BASE 0x01c0f000 | ||
71 | #define AW_A10_CCM_BASE 0x01c20000 | ||
72 | @@ -XXX,XX +XXX,XX @@ | ||
73 | #define AW_A10_RTC_BASE 0x01c20d00 | ||
74 | #define AW_A10_I2C0_BASE 0x01c2ac00 | ||
75 | |||
76 | +void allwinner_a10_bootrom_setup(AwA10State *s, BlockBackend *blk) | ||
77 | +{ | ||
78 | + const int64_t rom_size = 32 * KiB; | ||
79 | + g_autofree uint8_t *buffer = g_new0(uint8_t, rom_size); | ||
107 | + | 80 | + |
108 | +/* Share AArch32 -cpu max features with AArch64. */ | 81 | + if (blk_pread(blk, 8 * KiB, rom_size, buffer, 0) < 0) { |
109 | +void aa32_max_features(ARMCPU *cpu) | 82 | + error_setg(&error_fatal, "%s: failed to read BlockBackend data", |
110 | +{ | 83 | + __func__); |
111 | + uint32_t t; | 84 | + return; |
85 | + } | ||
112 | + | 86 | + |
113 | + /* Add additional features supported by QEMU */ | 87 | + rom_add_blob("allwinner-a10.bootrom", buffer, rom_size, |
114 | + t = cpu->isar.id_isar5; | 88 | + rom_size, AW_A10_SRAM_A_BASE, |
115 | + t = FIELD_DP32(t, ID_ISAR5, AES, 2); | 89 | + NULL, NULL, NULL, NULL, false); |
116 | + t = FIELD_DP32(t, ID_ISAR5, SHA1, 1); | ||
117 | + t = FIELD_DP32(t, ID_ISAR5, SHA2, 1); | ||
118 | + t = FIELD_DP32(t, ID_ISAR5, CRC32, 1); | ||
119 | + t = FIELD_DP32(t, ID_ISAR5, RDM, 1); | ||
120 | + t = FIELD_DP32(t, ID_ISAR5, VCMA, 1); | ||
121 | + cpu->isar.id_isar5 = t; | ||
122 | + | ||
123 | + t = cpu->isar.id_isar6; | ||
124 | + t = FIELD_DP32(t, ID_ISAR6, JSCVT, 1); | ||
125 | + t = FIELD_DP32(t, ID_ISAR6, DP, 1); | ||
126 | + t = FIELD_DP32(t, ID_ISAR6, FHM, 1); | ||
127 | + t = FIELD_DP32(t, ID_ISAR6, SB, 1); | ||
128 | + t = FIELD_DP32(t, ID_ISAR6, SPECRES, 1); | ||
129 | + t = FIELD_DP32(t, ID_ISAR6, BF16, 1); | ||
130 | + t = FIELD_DP32(t, ID_ISAR6, I8MM, 1); | ||
131 | + cpu->isar.id_isar6 = t; | ||
132 | + | ||
133 | + t = cpu->isar.mvfr1; | ||
134 | + t = FIELD_DP32(t, MVFR1, FPHP, 3); /* v8.2-FP16 */ | ||
135 | + t = FIELD_DP32(t, MVFR1, SIMDHP, 2); /* v8.2-FP16 */ | ||
136 | + cpu->isar.mvfr1 = t; | ||
137 | + | ||
138 | + t = cpu->isar.mvfr2; | ||
139 | + t = FIELD_DP32(t, MVFR2, SIMDMISC, 3); /* SIMD MaxNum */ | ||
140 | + t = FIELD_DP32(t, MVFR2, FPMISC, 4); /* FP MaxNum */ | ||
141 | + cpu->isar.mvfr2 = t; | ||
142 | + | ||
143 | + t = cpu->isar.id_mmfr3; | ||
144 | + t = FIELD_DP32(t, ID_MMFR3, PAN, 2); /* ATS1E1 */ | ||
145 | + cpu->isar.id_mmfr3 = t; | ||
146 | + | ||
147 | + t = cpu->isar.id_mmfr4; | ||
148 | + t = FIELD_DP32(t, ID_MMFR4, HPDS, 1); /* AA32HPD */ | ||
149 | + t = FIELD_DP32(t, ID_MMFR4, AC2, 1); /* ACTLR2, HACTLR2 */ | ||
150 | + t = FIELD_DP32(t, ID_MMFR4, CNP, 1); /* TTCNP */ | ||
151 | + t = FIELD_DP32(t, ID_MMFR4, XNX, 1); /* TTS2UXN */ | ||
152 | + cpu->isar.id_mmfr4 = t; | ||
153 | + | ||
154 | + t = cpu->isar.id_pfr0; | ||
155 | + t = FIELD_DP32(t, ID_PFR0, DIT, 1); | ||
156 | + cpu->isar.id_pfr0 = t; | ||
157 | + | ||
158 | + t = cpu->isar.id_pfr2; | ||
159 | + t = FIELD_DP32(t, ID_PFR2, SSBS, 1); | ||
160 | + cpu->isar.id_pfr2 = t; | ||
161 | + | ||
162 | + t = cpu->isar.id_dfr0; | ||
163 | + t = FIELD_DP32(t, ID_DFR0, PERFMON, 5); /* v8.4-PMU */ | ||
164 | + cpu->isar.id_dfr0 = t; | ||
165 | +} | 90 | +} |
166 | + | 91 | + |
167 | #ifndef CONFIG_USER_ONLY | 92 | static void aw_a10_init(Object *obj) |
168 | static uint64_t l2ctlr_read(CPUARMState *env, const ARMCPRegInfo *ri) | ||
169 | { | 93 | { |
170 | @@ -XXX,XX +XXX,XX @@ static void arm_v7m_class_init(ObjectClass *oc, void *data) | 94 | AwA10State *s = AW_A10(obj); |
171 | static void arm_max_initfn(Object *obj) | 95 | diff --git a/hw/arm/cubieboard.c b/hw/arm/cubieboard.c |
172 | { | 96 | index XXXXXXX..XXXXXXX 100644 |
173 | ARMCPU *cpu = ARM_CPU(obj); | 97 | --- a/hw/arm/cubieboard.c |
174 | - uint32_t t; | 98 | +++ b/hw/arm/cubieboard.c |
175 | 99 | @@ -XXX,XX +XXX,XX @@ static void cubieboard_init(MachineState *machine) | |
176 | /* aarch64_a57_initfn, advertising none of the aarch64 features */ | 100 | memory_region_add_subregion(get_system_memory(), AW_A10_SDRAM_BASE, |
177 | cpu->dtb_compatible = "arm,cortex-a57"; | 101 | machine->ram); |
178 | @@ -XXX,XX +XXX,XX @@ static void arm_max_initfn(Object *obj) | 102 | |
179 | cpu->ccsidr[2] = 0x70ffe07a; /* 2048KB L2 cache */ | 103 | + /* Load target kernel or start using BootROM */ |
180 | define_cortex_a72_a57_a53_cp_reginfo(cpu); | 104 | + if (!machine->kernel_filename && blk && blk_is_available(blk)) { |
181 | 105 | + /* Use Boot ROM to copy data from SD card to SRAM */ | |
182 | - /* Add additional features supported by QEMU */ | 106 | + allwinner_a10_bootrom_setup(a10, blk); |
183 | - t = cpu->isar.id_isar5; | 107 | + } |
184 | - t = FIELD_DP32(t, ID_ISAR5, AES, 2); | 108 | /* TODO create and connect IDE devices for ide_drive_get() */ |
185 | - t = FIELD_DP32(t, ID_ISAR5, SHA1, 1); | 109 | |
186 | - t = FIELD_DP32(t, ID_ISAR5, SHA2, 1); | 110 | cubieboard_binfo.ram_size = machine->ram_size; |
187 | - t = FIELD_DP32(t, ID_ISAR5, CRC32, 1); | ||
188 | - t = FIELD_DP32(t, ID_ISAR5, RDM, 1); | ||
189 | - t = FIELD_DP32(t, ID_ISAR5, VCMA, 1); | ||
190 | - cpu->isar.id_isar5 = t; | ||
191 | - | ||
192 | - t = cpu->isar.id_isar6; | ||
193 | - t = FIELD_DP32(t, ID_ISAR6, JSCVT, 1); | ||
194 | - t = FIELD_DP32(t, ID_ISAR6, DP, 1); | ||
195 | - t = FIELD_DP32(t, ID_ISAR6, FHM, 1); | ||
196 | - t = FIELD_DP32(t, ID_ISAR6, SB, 1); | ||
197 | - t = FIELD_DP32(t, ID_ISAR6, SPECRES, 1); | ||
198 | - t = FIELD_DP32(t, ID_ISAR6, BF16, 1); | ||
199 | - t = FIELD_DP32(t, ID_ISAR6, I8MM, 1); | ||
200 | - cpu->isar.id_isar6 = t; | ||
201 | - | ||
202 | - t = cpu->isar.mvfr1; | ||
203 | - t = FIELD_DP32(t, MVFR1, FPHP, 3); /* v8.2-FP16 */ | ||
204 | - t = FIELD_DP32(t, MVFR1, SIMDHP, 2); /* v8.2-FP16 */ | ||
205 | - cpu->isar.mvfr1 = t; | ||
206 | - | ||
207 | - t = cpu->isar.mvfr2; | ||
208 | - t = FIELD_DP32(t, MVFR2, SIMDMISC, 3); /* SIMD MaxNum */ | ||
209 | - t = FIELD_DP32(t, MVFR2, FPMISC, 4); /* FP MaxNum */ | ||
210 | - cpu->isar.mvfr2 = t; | ||
211 | - | ||
212 | - t = cpu->isar.id_mmfr3; | ||
213 | - t = FIELD_DP32(t, ID_MMFR3, PAN, 2); /* ATS1E1 */ | ||
214 | - cpu->isar.id_mmfr3 = t; | ||
215 | - | ||
216 | - t = cpu->isar.id_mmfr4; | ||
217 | - t = FIELD_DP32(t, ID_MMFR4, HPDS, 1); /* AA32HPD */ | ||
218 | - t = FIELD_DP32(t, ID_MMFR4, AC2, 1); /* ACTLR2, HACTLR2 */ | ||
219 | - t = FIELD_DP32(t, ID_MMFR4, CNP, 1); /* TTCNP */ | ||
220 | - t = FIELD_DP32(t, ID_MMFR4, XNX, 1); /* TTS2UXN */ | ||
221 | - cpu->isar.id_mmfr4 = t; | ||
222 | - | ||
223 | - t = cpu->isar.id_pfr0; | ||
224 | - t = FIELD_DP32(t, ID_PFR0, DIT, 1); | ||
225 | - cpu->isar.id_pfr0 = t; | ||
226 | - | ||
227 | - t = cpu->isar.id_pfr2; | ||
228 | - t = FIELD_DP32(t, ID_PFR2, SSBS, 1); | ||
229 | - cpu->isar.id_pfr2 = t; | ||
230 | - | ||
231 | - t = cpu->isar.id_dfr0; | ||
232 | - t = FIELD_DP32(t, ID_DFR0, PERFMON, 5); /* v8.4-PMU */ | ||
233 | - cpu->isar.id_dfr0 = t; | ||
234 | + aa32_max_features(cpu); | ||
235 | |||
236 | #ifdef CONFIG_USER_ONLY | ||
237 | /* | ||
238 | -- | 111 | -- |
239 | 2.25.1 | 112 | 2.34.1 | diff view generated by jsdifflib |
New patch | |||
---|---|---|---|
1 | From: Strahinja Jankovic <strahinjapjankovic@gmail.com> | ||
1 | 2 | ||
3 | Cubieboard now can boot directly from SD card, without the need to pass | ||
4 | `-kernel` parameter. Update Avocado tests to cover this functionality. | ||
5 | |||
6 | Signed-off-by: Strahinja Jankovic <strahinja.p.jankovic@gmail.com> | ||
7 | Reviewed-by: Niek Linnenbank <nieklinnenbank@gmail.com> | ||
8 | Tested-by: Niek Linnenbank <nieklinnenbank@gmail.com> | ||
9 | Message-id: 20221226220303.14420-8-strahinja.p.jankovic@gmail.com | ||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
11 | --- | ||
12 | tests/avocado/boot_linux_console.py | 47 +++++++++++++++++++++++++++++ | ||
13 | 1 file changed, 47 insertions(+) | ||
14 | |||
15 | diff --git a/tests/avocado/boot_linux_console.py b/tests/avocado/boot_linux_console.py | ||
16 | index XXXXXXX..XXXXXXX 100644 | ||
17 | --- a/tests/avocado/boot_linux_console.py | ||
18 | +++ b/tests/avocado/boot_linux_console.py | ||
19 | @@ -XXX,XX +XXX,XX @@ def test_arm_cubieboard_sata(self): | ||
20 | 'sda') | ||
21 | # cubieboard's reboot is not functioning; omit reboot test. | ||
22 | |||
23 | + @skipUnless(os.getenv('AVOCADO_ALLOW_LARGE_STORAGE'), 'storage limited') | ||
24 | + def test_arm_cubieboard_openwrt_22_03_2(self): | ||
25 | + """ | ||
26 | + :avocado: tags=arch:arm | ||
27 | + :avocado: tags=machine:cubieboard | ||
28 | + :avocado: tags=device:sd | ||
29 | + """ | ||
30 | + | ||
31 | + # This test download a 7.5 MiB compressed image and expand it | ||
32 | + # to 126 MiB. | ||
33 | + image_url = ('https://downloads.openwrt.org/releases/22.03.2/targets/' | ||
34 | + 'sunxi/cortexa8/openwrt-22.03.2-sunxi-cortexa8-' | ||
35 | + 'cubietech_a10-cubieboard-ext4-sdcard.img.gz') | ||
36 | + image_hash = ('94b5ecbfbc0b3b56276e5146b899eafa' | ||
37 | + '2ac5dc2d08733d6705af9f144f39f554') | ||
38 | + image_path_gz = self.fetch_asset(image_url, asset_hash=image_hash, | ||
39 | + algorithm='sha256') | ||
40 | + image_path = archive.extract(image_path_gz, self.workdir) | ||
41 | + image_pow2ceil_expand(image_path) | ||
42 | + | ||
43 | + self.vm.set_console() | ||
44 | + self.vm.add_args('-drive', 'file=' + image_path + ',if=sd,format=raw', | ||
45 | + '-nic', 'user', | ||
46 | + '-no-reboot') | ||
47 | + self.vm.launch() | ||
48 | + | ||
49 | + kernel_command_line = (self.KERNEL_COMMON_COMMAND_LINE + | ||
50 | + 'usbcore.nousb ' | ||
51 | + 'noreboot') | ||
52 | + | ||
53 | + self.wait_for_console_pattern('U-Boot SPL') | ||
54 | + | ||
55 | + interrupt_interactive_console_until_pattern( | ||
56 | + self, 'Hit any key to stop autoboot:', '=>') | ||
57 | + exec_command_and_wait_for_pattern(self, "setenv extraargs '" + | ||
58 | + kernel_command_line + "'", '=>') | ||
59 | + exec_command_and_wait_for_pattern(self, 'boot', 'Starting kernel ...'); | ||
60 | + | ||
61 | + self.wait_for_console_pattern( | ||
62 | + 'Please press Enter to activate this console.') | ||
63 | + | ||
64 | + exec_command_and_wait_for_pattern(self, ' ', 'root@') | ||
65 | + | ||
66 | + exec_command_and_wait_for_pattern(self, 'cat /proc/cpuinfo', | ||
67 | + 'Allwinner sun4i/sun5i') | ||
68 | + # cubieboard's reboot is not functioning; omit reboot test. | ||
69 | + | ||
70 | @skipUnless(os.getenv('AVOCADO_TIMEOUT_EXPECTED'), 'Test might timeout') | ||
71 | def test_arm_quanta_gsj(self): | ||
72 | """ | ||
73 | -- | ||
74 | 2.34.1 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Richard Henderson <richard.henderson@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | This extension concerns not merging memory access, which TCG does | 3 | Don't dereference CPUTLBEntryFull until we verify that |
4 | not implement. Thus we can trivially enable this feature. | 4 | the page is valid. Move the other user-only info field |
5 | Add a comment to handle_hint for the DGH instruction, but no code. | 5 | updates after the valid check to match. |
6 | 6 | ||
7 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 7 | Cc: qemu-stable@nongnu.org |
8 | Resolves: https://gitlab.com/qemu-project/qemu/-/issues/1412 | ||
8 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 9 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> |
9 | Message-id: 20220506180242.216785-23-richard.henderson@linaro.org | 10 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
11 | Message-id: 20230104190056.305143-1-richard.henderson@linaro.org | ||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 12 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | --- | 13 | --- |
12 | docs/system/arm/emulation.rst | 1 + | 14 | target/arm/sve_helper.c | 14 +++++++++----- |
13 | target/arm/cpu64.c | 1 + | 15 | 1 file changed, 9 insertions(+), 5 deletions(-) |
14 | target/arm/translate-a64.c | 1 + | ||
15 | 3 files changed, 3 insertions(+) | ||
16 | 16 | ||
17 | diff --git a/docs/system/arm/emulation.rst b/docs/system/arm/emulation.rst | 17 | diff --git a/target/arm/sve_helper.c b/target/arm/sve_helper.c |
18 | index XXXXXXX..XXXXXXX 100644 | 18 | index XXXXXXX..XXXXXXX 100644 |
19 | --- a/docs/system/arm/emulation.rst | 19 | --- a/target/arm/sve_helper.c |
20 | +++ b/docs/system/arm/emulation.rst | 20 | +++ b/target/arm/sve_helper.c |
21 | @@ -XXX,XX +XXX,XX @@ the following architecture extensions: | 21 | @@ -XXX,XX +XXX,XX @@ bool sve_probe_page(SVEHostPage *info, bool nofault, CPUARMState *env, |
22 | - FEAT_CSV2_1p2 (Cache speculation variant 2, version 1.2) | 22 | #ifdef CONFIG_USER_ONLY |
23 | - FEAT_CSV2_2 (Cache speculation variant 2, version 2) | 23 | flags = probe_access_flags(env, addr, access_type, mmu_idx, nofault, |
24 | - FEAT_CSV3 (Cache speculation variant 3) | 24 | &info->host, retaddr); |
25 | +- FEAT_DGH (Data gathering hint) | 25 | - memset(&info->attrs, 0, sizeof(info->attrs)); |
26 | - FEAT_DIT (Data Independent Timing instructions) | 26 | - /* Require both ANON and MTE; see allocation_tag_mem(). */ |
27 | - FEAT_DPB (DC CVAP instruction) | 27 | - info->tagged = (flags & PAGE_ANON) && (flags & PAGE_MTE); |
28 | - FEAT_Debugv8p2 (Debug changes for v8.2) | 28 | #else |
29 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 29 | CPUTLBEntryFull *full; |
30 | index XXXXXXX..XXXXXXX 100644 | 30 | flags = probe_access_full(env, addr, access_type, mmu_idx, nofault, |
31 | --- a/target/arm/cpu64.c | 31 | &info->host, &full, retaddr); |
32 | +++ b/target/arm/cpu64.c | 32 | - info->attrs = full->attrs; |
33 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | 33 | - info->tagged = full->pte_attrs == 0xf0; |
34 | t = FIELD_DP64(t, ID_AA64ISAR1, SB, 1); /* FEAT_SB */ | 34 | #endif |
35 | t = FIELD_DP64(t, ID_AA64ISAR1, SPECRES, 1); /* FEAT_SPECRES */ | 35 | info->flags = flags; |
36 | t = FIELD_DP64(t, ID_AA64ISAR1, BF16, 1); /* FEAT_BF16 */ | 36 | |
37 | + t = FIELD_DP64(t, ID_AA64ISAR1, DGH, 1); /* FEAT_DGH */ | 37 | @@ -XXX,XX +XXX,XX @@ bool sve_probe_page(SVEHostPage *info, bool nofault, CPUARMState *env, |
38 | t = FIELD_DP64(t, ID_AA64ISAR1, I8MM, 1); /* FEAT_I8MM */ | 38 | return false; |
39 | cpu->isar.id_aa64isar1 = t; | 39 | } |
40 | 40 | ||
41 | diff --git a/target/arm/translate-a64.c b/target/arm/translate-a64.c | 41 | +#ifdef CONFIG_USER_ONLY |
42 | index XXXXXXX..XXXXXXX 100644 | 42 | + memset(&info->attrs, 0, sizeof(info->attrs)); |
43 | --- a/target/arm/translate-a64.c | 43 | + /* Require both ANON and MTE; see allocation_tag_mem(). */ |
44 | +++ b/target/arm/translate-a64.c | 44 | + info->tagged = (flags & PAGE_ANON) && (flags & PAGE_MTE); |
45 | @@ -XXX,XX +XXX,XX @@ static void handle_hint(DisasContext *s, uint32_t insn, | 45 | +#else |
46 | break; | 46 | + info->attrs = full->attrs; |
47 | case 0b00100: /* SEV */ | 47 | + info->tagged = full->pte_attrs == 0xf0; |
48 | case 0b00101: /* SEVL */ | 48 | +#endif |
49 | + case 0b00110: /* DGH */ | 49 | + |
50 | /* we treat all as NOP at least for now */ | 50 | /* Ensure that info->host[] is relative to addr, not addr + mem_off. */ |
51 | break; | 51 | info->host -= mem_off; |
52 | case 0b00111: /* XPACLRI */ | 52 | return true; |
53 | -- | 53 | -- |
54 | 2.25.1 | 54 | 2.34.1 |
55 | |||
56 | diff view generated by jsdifflib |
New patch | |||
---|---|---|---|
1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> | ||
1 | 2 | ||
3 | Since pxa255_init() must map the device in the system memory, | ||
4 | there is no point in passing get_system_memory() by argument. | ||
5 | |||
6 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> | ||
7 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
8 | Message-id: 20230109115316.2235-2-philmd@linaro.org | ||
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | ||
10 | --- | ||
11 | include/hw/arm/pxa.h | 2 +- | ||
12 | hw/arm/gumstix.c | 3 +-- | ||
13 | hw/arm/pxa2xx.c | 4 +++- | ||
14 | hw/arm/tosa.c | 2 +- | ||
15 | 4 files changed, 6 insertions(+), 5 deletions(-) | ||
16 | |||
17 | diff --git a/include/hw/arm/pxa.h b/include/hw/arm/pxa.h | ||
18 | index XXXXXXX..XXXXXXX 100644 | ||
19 | --- a/include/hw/arm/pxa.h | ||
20 | +++ b/include/hw/arm/pxa.h | ||
21 | @@ -XXX,XX +XXX,XX @@ struct PXA2xxI2SState { | ||
22 | |||
23 | PXA2xxState *pxa270_init(MemoryRegion *address_space, unsigned int sdram_size, | ||
24 | const char *revision); | ||
25 | -PXA2xxState *pxa255_init(MemoryRegion *address_space, unsigned int sdram_size); | ||
26 | +PXA2xxState *pxa255_init(unsigned int sdram_size); | ||
27 | |||
28 | #endif /* PXA_H */ | ||
29 | diff --git a/hw/arm/gumstix.c b/hw/arm/gumstix.c | ||
30 | index XXXXXXX..XXXXXXX 100644 | ||
31 | --- a/hw/arm/gumstix.c | ||
32 | +++ b/hw/arm/gumstix.c | ||
33 | @@ -XXX,XX +XXX,XX @@ static void connex_init(MachineState *machine) | ||
34 | { | ||
35 | PXA2xxState *cpu; | ||
36 | DriveInfo *dinfo; | ||
37 | - MemoryRegion *address_space_mem = get_system_memory(); | ||
38 | |||
39 | uint32_t connex_rom = 0x01000000; | ||
40 | uint32_t connex_ram = 0x04000000; | ||
41 | |||
42 | - cpu = pxa255_init(address_space_mem, connex_ram); | ||
43 | + cpu = pxa255_init(connex_ram); | ||
44 | |||
45 | dinfo = drive_get(IF_PFLASH, 0, 0); | ||
46 | if (!dinfo && !qtest_enabled()) { | ||
47 | diff --git a/hw/arm/pxa2xx.c b/hw/arm/pxa2xx.c | ||
48 | index XXXXXXX..XXXXXXX 100644 | ||
49 | --- a/hw/arm/pxa2xx.c | ||
50 | +++ b/hw/arm/pxa2xx.c | ||
51 | @@ -XXX,XX +XXX,XX @@ | ||
52 | #include "qemu/error-report.h" | ||
53 | #include "qemu/module.h" | ||
54 | #include "qapi/error.h" | ||
55 | +#include "exec/address-spaces.h" | ||
56 | #include "cpu.h" | ||
57 | #include "hw/sysbus.h" | ||
58 | #include "migration/vmstate.h" | ||
59 | @@ -XXX,XX +XXX,XX @@ PXA2xxState *pxa270_init(MemoryRegion *address_space, | ||
60 | } | ||
61 | |||
62 | /* Initialise a PXA255 integrated chip (ARM based core). */ | ||
63 | -PXA2xxState *pxa255_init(MemoryRegion *address_space, unsigned int sdram_size) | ||
64 | +PXA2xxState *pxa255_init(unsigned int sdram_size) | ||
65 | { | ||
66 | + MemoryRegion *address_space = get_system_memory(); | ||
67 | PXA2xxState *s; | ||
68 | int i; | ||
69 | DriveInfo *dinfo; | ||
70 | diff --git a/hw/arm/tosa.c b/hw/arm/tosa.c | ||
71 | index XXXXXXX..XXXXXXX 100644 | ||
72 | --- a/hw/arm/tosa.c | ||
73 | +++ b/hw/arm/tosa.c | ||
74 | @@ -XXX,XX +XXX,XX @@ static void tosa_init(MachineState *machine) | ||
75 | TC6393xbState *tmio; | ||
76 | DeviceState *scp0, *scp1; | ||
77 | |||
78 | - mpu = pxa255_init(address_space_mem, tosa_binfo.ram_size); | ||
79 | + mpu = pxa255_init(tosa_binfo.ram_size); | ||
80 | |||
81 | memory_region_init_rom(rom, NULL, "tosa.rom", TOSA_ROM, &error_fatal); | ||
82 | memory_region_add_subregion(address_space_mem, 0, rom); | ||
83 | -- | ||
84 | 2.34.1 | ||
85 | |||
86 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Drop el3_no_el2_cp_reginfo, el3_no_el2_v8_cp_reginfo, and the local | 3 | Since pxa270_init() must map the device in the system memory, |
4 | vpidr_regs definition, and rely on the squashing to ARM_CP_CONST | 4 | there is no point in passing get_system_memory() by argument. |
5 | while registering for v8. | ||
6 | 5 | ||
7 | This is a behavior change for v7 cpus with Security Extensions and | 6 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
8 | without Virtualization Extensions, in that the virtualization cpregs | 7 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
9 | are now correctly not present. This would be a migration compatibility | 8 | Message-id: 20230109115316.2235-3-philmd@linaro.org |
10 | break, except that we have an existing bug in which migration of 32-bit | ||
11 | cpus with Security Extensions enabled does not work. | ||
12 | |||
13 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
14 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | ||
15 | Message-id: 20220506180242.216785-3-richard.henderson@linaro.org | ||
16 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
17 | --- | 10 | --- |
18 | target/arm/helper.c | 158 ++++---------------------------------------- | 11 | include/hw/arm/pxa.h | 3 +-- |
19 | 1 file changed, 13 insertions(+), 145 deletions(-) | 12 | hw/arm/gumstix.c | 3 +-- |
13 | hw/arm/mainstone.c | 10 ++++------ | ||
14 | hw/arm/pxa2xx.c | 4 ++-- | ||
15 | hw/arm/spitz.c | 6 ++---- | ||
16 | hw/arm/z2.c | 3 +-- | ||
17 | 6 files changed, 11 insertions(+), 18 deletions(-) | ||
20 | 18 | ||
21 | diff --git a/target/arm/helper.c b/target/arm/helper.c | 19 | diff --git a/include/hw/arm/pxa.h b/include/hw/arm/pxa.h |
22 | index XXXXXXX..XXXXXXX 100644 | 20 | index XXXXXXX..XXXXXXX 100644 |
23 | --- a/target/arm/helper.c | 21 | --- a/include/hw/arm/pxa.h |
24 | +++ b/target/arm/helper.c | 22 | +++ b/include/hw/arm/pxa.h |
25 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo v8_cp_reginfo[] = { | 23 | @@ -XXX,XX +XXX,XX @@ struct PXA2xxI2SState { |
26 | .fieldoffset = offsetoflow32(CPUARMState, cp15.mdcr_el3) }, | 24 | |
25 | # define PA_FMT "0x%08lx" | ||
26 | |||
27 | -PXA2xxState *pxa270_init(MemoryRegion *address_space, unsigned int sdram_size, | ||
28 | - const char *revision); | ||
29 | +PXA2xxState *pxa270_init(unsigned int sdram_size, const char *revision); | ||
30 | PXA2xxState *pxa255_init(unsigned int sdram_size); | ||
31 | |||
32 | #endif /* PXA_H */ | ||
33 | diff --git a/hw/arm/gumstix.c b/hw/arm/gumstix.c | ||
34 | index XXXXXXX..XXXXXXX 100644 | ||
35 | --- a/hw/arm/gumstix.c | ||
36 | +++ b/hw/arm/gumstix.c | ||
37 | @@ -XXX,XX +XXX,XX @@ static void verdex_init(MachineState *machine) | ||
38 | { | ||
39 | PXA2xxState *cpu; | ||
40 | DriveInfo *dinfo; | ||
41 | - MemoryRegion *address_space_mem = get_system_memory(); | ||
42 | |||
43 | uint32_t verdex_rom = 0x02000000; | ||
44 | uint32_t verdex_ram = 0x10000000; | ||
45 | |||
46 | - cpu = pxa270_init(address_space_mem, verdex_ram, machine->cpu_type); | ||
47 | + cpu = pxa270_init(verdex_ram, machine->cpu_type); | ||
48 | |||
49 | dinfo = drive_get(IF_PFLASH, 0, 0); | ||
50 | if (!dinfo && !qtest_enabled()) { | ||
51 | diff --git a/hw/arm/mainstone.c b/hw/arm/mainstone.c | ||
52 | index XXXXXXX..XXXXXXX 100644 | ||
53 | --- a/hw/arm/mainstone.c | ||
54 | +++ b/hw/arm/mainstone.c | ||
55 | @@ -XXX,XX +XXX,XX @@ static struct arm_boot_info mainstone_binfo = { | ||
56 | .ram_size = 0x04000000, | ||
27 | }; | 57 | }; |
28 | 58 | ||
29 | -/* Used to describe the behaviour of EL2 regs when EL2 does not exist. */ | 59 | -static void mainstone_common_init(MemoryRegion *address_space_mem, |
30 | -static const ARMCPRegInfo el3_no_el2_cp_reginfo[] = { | 60 | - MachineState *machine, |
31 | - { .name = "VBAR_EL2", .state = ARM_CP_STATE_BOTH, | 61 | +static void mainstone_common_init(MachineState *machine, |
32 | - .opc0 = 3, .opc1 = 4, .crn = 12, .crm = 0, .opc2 = 0, | 62 | enum mainstone_model_e model, int arm_id) |
33 | - .access = PL2_RW, | ||
34 | - .readfn = arm_cp_read_zero, .writefn = arm_cp_write_ignore }, | ||
35 | - { .name = "HCR_EL2", .state = ARM_CP_STATE_BOTH, | ||
36 | - .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 0, | ||
37 | - .access = PL2_RW, | ||
38 | - .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
39 | - { .name = "HACR_EL2", .state = ARM_CP_STATE_BOTH, | ||
40 | - .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 7, | ||
41 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
42 | - { .name = "ESR_EL2", .state = ARM_CP_STATE_BOTH, | ||
43 | - .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 2, .opc2 = 0, | ||
44 | - .access = PL2_RW, | ||
45 | - .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
46 | - { .name = "CPTR_EL2", .state = ARM_CP_STATE_BOTH, | ||
47 | - .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 2, | ||
48 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
49 | - { .name = "MAIR_EL2", .state = ARM_CP_STATE_BOTH, | ||
50 | - .opc0 = 3, .opc1 = 4, .crn = 10, .crm = 2, .opc2 = 0, | ||
51 | - .access = PL2_RW, .type = ARM_CP_CONST, | ||
52 | - .resetvalue = 0 }, | ||
53 | - { .name = "HMAIR1", .state = ARM_CP_STATE_AA32, | ||
54 | - .cp = 15, .opc1 = 4, .crn = 10, .crm = 2, .opc2 = 1, | ||
55 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
56 | - { .name = "AMAIR_EL2", .state = ARM_CP_STATE_BOTH, | ||
57 | - .opc0 = 3, .opc1 = 4, .crn = 10, .crm = 3, .opc2 = 0, | ||
58 | - .access = PL2_RW, .type = ARM_CP_CONST, | ||
59 | - .resetvalue = 0 }, | ||
60 | - { .name = "HAMAIR1", .state = ARM_CP_STATE_AA32, | ||
61 | - .cp = 15, .opc1 = 4, .crn = 10, .crm = 3, .opc2 = 1, | ||
62 | - .access = PL2_RW, .type = ARM_CP_CONST, | ||
63 | - .resetvalue = 0 }, | ||
64 | - { .name = "AFSR0_EL2", .state = ARM_CP_STATE_BOTH, | ||
65 | - .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 1, .opc2 = 0, | ||
66 | - .access = PL2_RW, .type = ARM_CP_CONST, | ||
67 | - .resetvalue = 0 }, | ||
68 | - { .name = "AFSR1_EL2", .state = ARM_CP_STATE_BOTH, | ||
69 | - .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 1, .opc2 = 1, | ||
70 | - .access = PL2_RW, .type = ARM_CP_CONST, | ||
71 | - .resetvalue = 0 }, | ||
72 | - { .name = "TCR_EL2", .state = ARM_CP_STATE_BOTH, | ||
73 | - .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 0, .opc2 = 2, | ||
74 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
75 | - { .name = "VTCR_EL2", .state = ARM_CP_STATE_BOTH, | ||
76 | - .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 1, .opc2 = 2, | ||
77 | - .access = PL2_RW, .accessfn = access_el3_aa32ns, | ||
78 | - .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
79 | - { .name = "VTTBR", .state = ARM_CP_STATE_AA32, | ||
80 | - .cp = 15, .opc1 = 6, .crm = 2, | ||
81 | - .access = PL2_RW, .accessfn = access_el3_aa32ns, | ||
82 | - .type = ARM_CP_CONST | ARM_CP_64BIT, .resetvalue = 0 }, | ||
83 | - { .name = "VTTBR_EL2", .state = ARM_CP_STATE_AA64, | ||
84 | - .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 1, .opc2 = 0, | ||
85 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
86 | - { .name = "SCTLR_EL2", .state = ARM_CP_STATE_BOTH, | ||
87 | - .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 0, .opc2 = 0, | ||
88 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
89 | - { .name = "TPIDR_EL2", .state = ARM_CP_STATE_BOTH, | ||
90 | - .opc0 = 3, .opc1 = 4, .crn = 13, .crm = 0, .opc2 = 2, | ||
91 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
92 | - { .name = "TTBR0_EL2", .state = ARM_CP_STATE_AA64, | ||
93 | - .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 0, .opc2 = 0, | ||
94 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
95 | - { .name = "HTTBR", .cp = 15, .opc1 = 4, .crm = 2, | ||
96 | - .access = PL2_RW, .type = ARM_CP_64BIT | ARM_CP_CONST, | ||
97 | - .resetvalue = 0 }, | ||
98 | - { .name = "CNTHCTL_EL2", .state = ARM_CP_STATE_BOTH, | ||
99 | - .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 1, .opc2 = 0, | ||
100 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
101 | - { .name = "CNTVOFF_EL2", .state = ARM_CP_STATE_AA64, | ||
102 | - .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 0, .opc2 = 3, | ||
103 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
104 | - { .name = "CNTVOFF", .cp = 15, .opc1 = 4, .crm = 14, | ||
105 | - .access = PL2_RW, .type = ARM_CP_64BIT | ARM_CP_CONST, | ||
106 | - .resetvalue = 0 }, | ||
107 | - { .name = "CNTHP_CVAL_EL2", .state = ARM_CP_STATE_AA64, | ||
108 | - .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 2, .opc2 = 2, | ||
109 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
110 | - { .name = "CNTHP_CVAL", .cp = 15, .opc1 = 6, .crm = 14, | ||
111 | - .access = PL2_RW, .type = ARM_CP_64BIT | ARM_CP_CONST, | ||
112 | - .resetvalue = 0 }, | ||
113 | - { .name = "CNTHP_TVAL_EL2", .state = ARM_CP_STATE_BOTH, | ||
114 | - .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 2, .opc2 = 0, | ||
115 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
116 | - { .name = "CNTHP_CTL_EL2", .state = ARM_CP_STATE_BOTH, | ||
117 | - .opc0 = 3, .opc1 = 4, .crn = 14, .crm = 2, .opc2 = 1, | ||
118 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
119 | - { .name = "MDCR_EL2", .state = ARM_CP_STATE_BOTH, | ||
120 | - .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 1, | ||
121 | - .access = PL2_RW, .accessfn = access_tda, | ||
122 | - .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
123 | - { .name = "HPFAR_EL2", .state = ARM_CP_STATE_BOTH, | ||
124 | - .opc0 = 3, .opc1 = 4, .crn = 6, .crm = 0, .opc2 = 4, | ||
125 | - .access = PL2_RW, .accessfn = access_el3_aa32ns, | ||
126 | - .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
127 | - { .name = "HSTR_EL2", .state = ARM_CP_STATE_BOTH, | ||
128 | - .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 3, | ||
129 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
130 | - { .name = "FAR_EL2", .state = ARM_CP_STATE_BOTH, | ||
131 | - .opc0 = 3, .opc1 = 4, .crn = 6, .crm = 0, .opc2 = 0, | ||
132 | - .access = PL2_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
133 | - { .name = "HIFAR", .state = ARM_CP_STATE_AA32, | ||
134 | - .type = ARM_CP_CONST, | ||
135 | - .cp = 15, .opc1 = 4, .crn = 6, .crm = 0, .opc2 = 2, | ||
136 | - .access = PL2_RW, .resetvalue = 0 }, | ||
137 | -}; | ||
138 | - | ||
139 | -/* Ditto, but for registers which exist in ARMv8 but not v7 */ | ||
140 | -static const ARMCPRegInfo el3_no_el2_v8_cp_reginfo[] = { | ||
141 | - { .name = "HCR2", .state = ARM_CP_STATE_AA32, | ||
142 | - .cp = 15, .opc1 = 4, .crn = 1, .crm = 1, .opc2 = 4, | ||
143 | - .access = PL2_RW, | ||
144 | - .type = ARM_CP_CONST, .resetvalue = 0 }, | ||
145 | -}; | ||
146 | - | ||
147 | static void do_hcr_write(CPUARMState *env, uint64_t value, uint64_t valid_mask) | ||
148 | { | 63 | { |
149 | ARMCPU *cpu = env_archcpu(env); | 64 | uint32_t sector_len = 256 * 1024; |
150 | @@ -XXX,XX +XXX,XX @@ void register_cp_regs_for_features(ARMCPU *cpu) | 65 | @@ -XXX,XX +XXX,XX @@ static void mainstone_common_init(MemoryRegion *address_space_mem, |
151 | define_arm_cp_regs(cpu, v8_idregs); | 66 | MemoryRegion *rom = g_new(MemoryRegion, 1); |
152 | define_arm_cp_regs(cpu, v8_cp_reginfo); | 67 | |
153 | } | 68 | /* Setup CPU & memory */ |
154 | - if (arm_feature(env, ARM_FEATURE_EL2)) { | 69 | - mpu = pxa270_init(address_space_mem, mainstone_binfo.ram_size, |
155 | + | 70 | - machine->cpu_type); |
156 | + /* | 71 | + mpu = pxa270_init(mainstone_binfo.ram_size, machine->cpu_type); |
157 | + * Register the base EL2 cpregs. | 72 | memory_region_init_rom(rom, NULL, "mainstone.rom", MAINSTONE_ROM, |
158 | + * Pre v8, these registers are implemented only as part of the | 73 | &error_fatal); |
159 | + * Virtualization Extensions (EL2 present). Beginning with v8, | 74 | - memory_region_add_subregion(address_space_mem, 0, rom); |
160 | + * if EL2 is missing but EL3 is enabled, mostly these become | 75 | + memory_region_add_subregion(get_system_memory(), 0x00000000, rom); |
161 | + * RES0 from EL3, with some specific exceptions. | 76 | |
162 | + */ | 77 | /* There are two 32MiB flash devices on the board */ |
163 | + if (arm_feature(env, ARM_FEATURE_EL2) | 78 | for (i = 0; i < 2; i ++) { |
164 | + || (arm_feature(env, ARM_FEATURE_EL3) | 79 | @@ -XXX,XX +XXX,XX @@ static void mainstone_common_init(MemoryRegion *address_space_mem, |
165 | + && arm_feature(env, ARM_FEATURE_V8))) { | 80 | |
166 | uint64_t vmpidr_def = mpidr_read_val(env); | 81 | static void mainstone_init(MachineState *machine) |
167 | ARMCPRegInfo vpidr_regs[] = { | 82 | { |
168 | { .name = "VPIDR", .state = ARM_CP_STATE_AA32, | 83 | - mainstone_common_init(get_system_memory(), machine, mainstone, 0x196); |
169 | @@ -XXX,XX +XXX,XX @@ void register_cp_regs_for_features(ARMCPU *cpu) | 84 | + mainstone_common_init(machine, mainstone, 0x196); |
170 | }; | 85 | } |
171 | define_one_arm_cp_reg(cpu, &rvbar); | 86 | |
172 | } | 87 | static void mainstone2_machine_init(MachineClass *mc) |
173 | - } else { | 88 | diff --git a/hw/arm/pxa2xx.c b/hw/arm/pxa2xx.c |
174 | - /* If EL2 is missing but higher ELs are enabled, we need to | 89 | index XXXXXXX..XXXXXXX 100644 |
175 | - * register the no_el2 reginfos. | 90 | --- a/hw/arm/pxa2xx.c |
176 | - */ | 91 | +++ b/hw/arm/pxa2xx.c |
177 | - if (arm_feature(env, ARM_FEATURE_EL3)) { | 92 | @@ -XXX,XX +XXX,XX @@ static void pxa2xx_reset(void *opaque, int line, int level) |
178 | - /* When EL3 exists but not EL2, VPIDR and VMPIDR take the value | 93 | } |
179 | - * of MIDR_EL1 and MPIDR_EL1. | 94 | |
180 | - */ | 95 | /* Initialise a PXA270 integrated chip (ARM based core). */ |
181 | - ARMCPRegInfo vpidr_regs[] = { | 96 | -PXA2xxState *pxa270_init(MemoryRegion *address_space, |
182 | - { .name = "VPIDR_EL2", .state = ARM_CP_STATE_BOTH, | 97 | - unsigned int sdram_size, const char *cpu_type) |
183 | - .opc0 = 3, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 0, | 98 | +PXA2xxState *pxa270_init(unsigned int sdram_size, const char *cpu_type) |
184 | - .access = PL2_RW, .accessfn = access_el3_aa32ns, | 99 | { |
185 | - .type = ARM_CP_CONST, .resetvalue = cpu->midr, | 100 | + MemoryRegion *address_space = get_system_memory(); |
186 | - .fieldoffset = offsetof(CPUARMState, cp15.vpidr_el2) }, | 101 | PXA2xxState *s; |
187 | - { .name = "VMPIDR_EL2", .state = ARM_CP_STATE_BOTH, | 102 | int i; |
188 | - .opc0 = 3, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 5, | 103 | DriveInfo *dinfo; |
189 | - .access = PL2_RW, .accessfn = access_el3_aa32ns, | 104 | diff --git a/hw/arm/spitz.c b/hw/arm/spitz.c |
190 | - .type = ARM_CP_NO_RAW, | 105 | index XXXXXXX..XXXXXXX 100644 |
191 | - .writefn = arm_cp_write_ignore, .readfn = mpidr_read }, | 106 | --- a/hw/arm/spitz.c |
192 | - }; | 107 | +++ b/hw/arm/spitz.c |
193 | - define_arm_cp_regs(cpu, vpidr_regs); | 108 | @@ -XXX,XX +XXX,XX @@ static void spitz_common_init(MachineState *machine) |
194 | - define_arm_cp_regs(cpu, el3_no_el2_cp_reginfo); | 109 | SpitzMachineState *sms = SPITZ_MACHINE(machine); |
195 | - if (arm_feature(env, ARM_FEATURE_V8)) { | 110 | enum spitz_model_e model = smc->model; |
196 | - define_arm_cp_regs(cpu, el3_no_el2_v8_cp_reginfo); | 111 | PXA2xxState *mpu; |
197 | - } | 112 | - MemoryRegion *address_space_mem = get_system_memory(); |
198 | - } | 113 | MemoryRegion *rom = g_new(MemoryRegion, 1); |
199 | } | 114 | |
200 | + | 115 | /* Setup CPU & memory */ |
201 | + /* Register the base EL3 cpregs. */ | 116 | - mpu = pxa270_init(address_space_mem, spitz_binfo.ram_size, |
202 | if (arm_feature(env, ARM_FEATURE_EL3)) { | 117 | - machine->cpu_type); |
203 | define_arm_cp_regs(cpu, el3_cp_reginfo); | 118 | + mpu = pxa270_init(spitz_binfo.ram_size, machine->cpu_type); |
204 | ARMCPRegInfo el3_regs[] = { | 119 | sms->mpu = mpu; |
120 | |||
121 | sl_flash_register(mpu, (model == spitz) ? FLASH_128M : FLASH_1024M); | ||
122 | |||
123 | memory_region_init_rom(rom, NULL, "spitz.rom", SPITZ_ROM, &error_fatal); | ||
124 | - memory_region_add_subregion(address_space_mem, 0, rom); | ||
125 | + memory_region_add_subregion(get_system_memory(), 0, rom); | ||
126 | |||
127 | /* Setup peripherals */ | ||
128 | spitz_keyboard_register(mpu); | ||
129 | diff --git a/hw/arm/z2.c b/hw/arm/z2.c | ||
130 | index XXXXXXX..XXXXXXX 100644 | ||
131 | --- a/hw/arm/z2.c | ||
132 | +++ b/hw/arm/z2.c | ||
133 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo aer915_info = { | ||
134 | |||
135 | static void z2_init(MachineState *machine) | ||
136 | { | ||
137 | - MemoryRegion *address_space_mem = get_system_memory(); | ||
138 | uint32_t sector_len = 0x10000; | ||
139 | PXA2xxState *mpu; | ||
140 | DriveInfo *dinfo; | ||
141 | @@ -XXX,XX +XXX,XX @@ static void z2_init(MachineState *machine) | ||
142 | DeviceState *wm; | ||
143 | |||
144 | /* Setup CPU & memory */ | ||
145 | - mpu = pxa270_init(address_space_mem, z2_binfo.ram_size, machine->cpu_type); | ||
146 | + mpu = pxa270_init(z2_binfo.ram_size, machine->cpu_type); | ||
147 | |||
148 | dinfo = drive_get(IF_PFLASH, 0, 0); | ||
149 | if (!pflash_cfi01_register(Z2_FLASH_BASE, "z2.flash0", Z2_FLASH_SIZE, | ||
205 | -- | 150 | -- |
206 | 2.25.1 | 151 | 2.34.1 |
152 | |||
153 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Update the legacy feature names to the current names. | 3 | IEC binary prefixes ease code review: the unit is explicit. |
4 | Provide feature names for id changes that were not marked. | ||
5 | Sort the field updates into increasing bitfield order. | ||
6 | 4 | ||
7 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 5 | Add definitions for RAM / Flash / Flash blocksize. |
8 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 6 | |
9 | Message-id: 20220506180242.216785-10-richard.henderson@linaro.org | 7 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
9 | Message-id: 20230109115316.2235-4-philmd@linaro.org | ||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | --- | 11 | --- |
12 | target/arm/cpu64.c | 100 +++++++++++++++++++++---------------------- | 12 | hw/arm/collie.c | 16 ++++++++++------ |
13 | target/arm/cpu_tcg.c | 48 ++++++++++----------- | 13 | 1 file changed, 10 insertions(+), 6 deletions(-) |
14 | 2 files changed, 74 insertions(+), 74 deletions(-) | ||
15 | 14 | ||
16 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 15 | diff --git a/hw/arm/collie.c b/hw/arm/collie.c |
17 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/target/arm/cpu64.c | 17 | --- a/hw/arm/collie.c |
19 | +++ b/target/arm/cpu64.c | 18 | +++ b/hw/arm/collie.c |
20 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | 19 | @@ -XXX,XX +XXX,XX @@ |
21 | cpu->midr = t; | 20 | #include "cpu.h" |
22 | 21 | #include "qom/object.h" | |
23 | t = cpu->isar.id_aa64isar0; | 22 | |
24 | - t = FIELD_DP64(t, ID_AA64ISAR0, AES, 2); /* AES + PMULL */ | 23 | +#define RAM_SIZE (512 * MiB) |
25 | - t = FIELD_DP64(t, ID_AA64ISAR0, SHA1, 1); | 24 | +#define FLASH_SIZE (32 * MiB) |
26 | - t = FIELD_DP64(t, ID_AA64ISAR0, SHA2, 2); /* SHA512 */ | 25 | +#define FLASH_SECTOR_SIZE (64 * KiB) |
27 | + t = FIELD_DP64(t, ID_AA64ISAR0, AES, 2); /* FEAT_PMULL */ | 26 | + |
28 | + t = FIELD_DP64(t, ID_AA64ISAR0, SHA1, 1); /* FEAT_SHA1 */ | 27 | struct CollieMachineState { |
29 | + t = FIELD_DP64(t, ID_AA64ISAR0, SHA2, 2); /* FEAT_SHA512 */ | 28 | MachineState parent; |
30 | t = FIELD_DP64(t, ID_AA64ISAR0, CRC32, 1); | 29 | |
31 | - t = FIELD_DP64(t, ID_AA64ISAR0, ATOMIC, 2); | 30 | @@ -XXX,XX +XXX,XX @@ OBJECT_DECLARE_SIMPLE_TYPE(CollieMachineState, COLLIE_MACHINE) |
32 | - t = FIELD_DP64(t, ID_AA64ISAR0, RDM, 1); | 31 | |
33 | - t = FIELD_DP64(t, ID_AA64ISAR0, SHA3, 1); | 32 | static struct arm_boot_info collie_binfo = { |
34 | - t = FIELD_DP64(t, ID_AA64ISAR0, SM3, 1); | 33 | .loader_start = SA_SDCS0, |
35 | - t = FIELD_DP64(t, ID_AA64ISAR0, SM4, 1); | 34 | - .ram_size = 0x20000000, |
36 | - t = FIELD_DP64(t, ID_AA64ISAR0, DP, 1); | 35 | + .ram_size = RAM_SIZE, |
37 | - t = FIELD_DP64(t, ID_AA64ISAR0, FHM, 1); | 36 | }; |
38 | - t = FIELD_DP64(t, ID_AA64ISAR0, TS, 2); /* v8.5-CondM */ | 37 | |
39 | - t = FIELD_DP64(t, ID_AA64ISAR0, TLB, 2); /* FEAT_TLBIRANGE */ | 38 | static void collie_init(MachineState *machine) |
40 | - t = FIELD_DP64(t, ID_AA64ISAR0, RNDR, 1); | 39 | @@ -XXX,XX +XXX,XX @@ static void collie_init(MachineState *machine) |
41 | + t = FIELD_DP64(t, ID_AA64ISAR0, ATOMIC, 2); /* FEAT_LSE */ | 40 | memory_region_add_subregion(get_system_memory(), SA_SDCS0, machine->ram); |
42 | + t = FIELD_DP64(t, ID_AA64ISAR0, RDM, 1); /* FEAT_RDM */ | 41 | |
43 | + t = FIELD_DP64(t, ID_AA64ISAR0, SHA3, 1); /* FEAT_SHA3 */ | 42 | dinfo = drive_get(IF_PFLASH, 0, 0); |
44 | + t = FIELD_DP64(t, ID_AA64ISAR0, SM3, 1); /* FEAT_SM3 */ | 43 | - pflash_cfi01_register(SA_CS0, "collie.fl1", 0x02000000, |
45 | + t = FIELD_DP64(t, ID_AA64ISAR0, SM4, 1); /* FEAT_SM4 */ | 44 | + pflash_cfi01_register(SA_CS0, "collie.fl1", FLASH_SIZE, |
46 | + t = FIELD_DP64(t, ID_AA64ISAR0, DP, 1); /* FEAT_DotProd */ | 45 | dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
47 | + t = FIELD_DP64(t, ID_AA64ISAR0, FHM, 1); /* FEAT_FHM */ | 46 | - 64 * KiB, 4, 0x00, 0x00, 0x00, 0x00, 0); |
48 | + t = FIELD_DP64(t, ID_AA64ISAR0, TS, 2); /* FEAT_FlagM2 */ | 47 | + FLASH_SECTOR_SIZE, 4, 0x00, 0x00, 0x00, 0x00, 0); |
49 | + t = FIELD_DP64(t, ID_AA64ISAR0, TLB, 2); /* FEAT_TLBIRANGE */ | 48 | |
50 | + t = FIELD_DP64(t, ID_AA64ISAR0, RNDR, 1); /* FEAT_RNG */ | 49 | dinfo = drive_get(IF_PFLASH, 0, 1); |
51 | cpu->isar.id_aa64isar0 = t; | 50 | - pflash_cfi01_register(SA_CS1, "collie.fl2", 0x02000000, |
52 | 51 | + pflash_cfi01_register(SA_CS1, "collie.fl2", FLASH_SIZE, | |
53 | t = cpu->isar.id_aa64isar1; | 52 | dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
54 | - t = FIELD_DP64(t, ID_AA64ISAR1, DPB, 2); | 53 | - 64 * KiB, 4, 0x00, 0x00, 0x00, 0x00, 0); |
55 | - t = FIELD_DP64(t, ID_AA64ISAR1, JSCVT, 1); | 54 | + FLASH_SECTOR_SIZE, 4, 0x00, 0x00, 0x00, 0x00, 0); |
56 | - t = FIELD_DP64(t, ID_AA64ISAR1, FCMA, 1); | 55 | |
57 | - t = FIELD_DP64(t, ID_AA64ISAR1, SB, 1); | 56 | sysbus_create_simple("scoop", 0x40800000, NULL); |
58 | - t = FIELD_DP64(t, ID_AA64ISAR1, SPECRES, 1); | 57 | |
59 | - t = FIELD_DP64(t, ID_AA64ISAR1, BF16, 1); | 58 | @@ -XXX,XX +XXX,XX @@ static void collie_machine_class_init(ObjectClass *oc, void *data) |
60 | - t = FIELD_DP64(t, ID_AA64ISAR1, FRINTTS, 1); | 59 | mc->init = collie_init; |
61 | - t = FIELD_DP64(t, ID_AA64ISAR1, LRCPC, 2); /* ARMv8.4-RCPC */ | 60 | mc->ignore_memory_transaction_failures = true; |
62 | - t = FIELD_DP64(t, ID_AA64ISAR1, I8MM, 1); | 61 | mc->default_cpu_type = ARM_CPU_TYPE_NAME("sa1110"); |
63 | + t = FIELD_DP64(t, ID_AA64ISAR1, DPB, 2); /* FEAT_DPB2 */ | 62 | - mc->default_ram_size = 0x20000000; |
64 | + t = FIELD_DP64(t, ID_AA64ISAR1, JSCVT, 1); /* FEAT_JSCVT */ | 63 | + mc->default_ram_size = RAM_SIZE; |
65 | + t = FIELD_DP64(t, ID_AA64ISAR1, FCMA, 1); /* FEAT_FCMA */ | 64 | mc->default_ram_id = "strongarm.sdram"; |
66 | + t = FIELD_DP64(t, ID_AA64ISAR1, LRCPC, 2); /* FEAT_LRCPC2 */ | ||
67 | + t = FIELD_DP64(t, ID_AA64ISAR1, FRINTTS, 1); /* FEAT_FRINTTS */ | ||
68 | + t = FIELD_DP64(t, ID_AA64ISAR1, SB, 1); /* FEAT_SB */ | ||
69 | + t = FIELD_DP64(t, ID_AA64ISAR1, SPECRES, 1); /* FEAT_SPECRES */ | ||
70 | + t = FIELD_DP64(t, ID_AA64ISAR1, BF16, 1); /* FEAT_BF16 */ | ||
71 | + t = FIELD_DP64(t, ID_AA64ISAR1, I8MM, 1); /* FEAT_I8MM */ | ||
72 | cpu->isar.id_aa64isar1 = t; | ||
73 | |||
74 | t = cpu->isar.id_aa64pfr0; | ||
75 | + t = FIELD_DP64(t, ID_AA64PFR0, FP, 1); /* FEAT_FP16 */ | ||
76 | + t = FIELD_DP64(t, ID_AA64PFR0, ADVSIMD, 1); /* FEAT_FP16 */ | ||
77 | t = FIELD_DP64(t, ID_AA64PFR0, SVE, 1); | ||
78 | - t = FIELD_DP64(t, ID_AA64PFR0, FP, 1); | ||
79 | - t = FIELD_DP64(t, ID_AA64PFR0, ADVSIMD, 1); | ||
80 | - t = FIELD_DP64(t, ID_AA64PFR0, SEL2, 1); | ||
81 | - t = FIELD_DP64(t, ID_AA64PFR0, DIT, 1); | ||
82 | + t = FIELD_DP64(t, ID_AA64PFR0, SEL2, 1); /* FEAT_SEL2 */ | ||
83 | + t = FIELD_DP64(t, ID_AA64PFR0, DIT, 1); /* FEAT_DIT */ | ||
84 | cpu->isar.id_aa64pfr0 = t; | ||
85 | |||
86 | t = cpu->isar.id_aa64pfr1; | ||
87 | - t = FIELD_DP64(t, ID_AA64PFR1, BT, 1); | ||
88 | - t = FIELD_DP64(t, ID_AA64PFR1, SSBS, 2); | ||
89 | + t = FIELD_DP64(t, ID_AA64PFR1, BT, 1); /* FEAT_BTI */ | ||
90 | + t = FIELD_DP64(t, ID_AA64PFR1, SSBS, 2); /* FEAT_SSBS2 */ | ||
91 | /* | ||
92 | * Begin with full support for MTE. This will be downgraded to MTE=0 | ||
93 | * during realize if the board provides no tag memory, much like | ||
94 | * we do for EL2 with the virtualization=on property. | ||
95 | */ | ||
96 | - t = FIELD_DP64(t, ID_AA64PFR1, MTE, 3); | ||
97 | + t = FIELD_DP64(t, ID_AA64PFR1, MTE, 3); /* FEAT_MTE3 */ | ||
98 | cpu->isar.id_aa64pfr1 = t; | ||
99 | |||
100 | t = cpu->isar.id_aa64mmfr0; | ||
101 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | ||
102 | cpu->isar.id_aa64mmfr0 = t; | ||
103 | |||
104 | t = cpu->isar.id_aa64mmfr1; | ||
105 | - t = FIELD_DP64(t, ID_AA64MMFR1, HPDS, 1); /* HPD */ | ||
106 | - t = FIELD_DP64(t, ID_AA64MMFR1, LO, 1); | ||
107 | - t = FIELD_DP64(t, ID_AA64MMFR1, VH, 1); | ||
108 | - t = FIELD_DP64(t, ID_AA64MMFR1, PAN, 2); /* ATS1E1 */ | ||
109 | - t = FIELD_DP64(t, ID_AA64MMFR1, VMIDBITS, 2); /* VMID16 */ | ||
110 | - t = FIELD_DP64(t, ID_AA64MMFR1, XNX, 1); /* TTS2UXN */ | ||
111 | + t = FIELD_DP64(t, ID_AA64MMFR1, VMIDBITS, 2); /* FEAT_VMID16 */ | ||
112 | + t = FIELD_DP64(t, ID_AA64MMFR1, VH, 1); /* FEAT_VHE */ | ||
113 | + t = FIELD_DP64(t, ID_AA64MMFR1, HPDS, 1); /* FEAT_HPDS */ | ||
114 | + t = FIELD_DP64(t, ID_AA64MMFR1, LO, 1); /* FEAT_LOR */ | ||
115 | + t = FIELD_DP64(t, ID_AA64MMFR1, PAN, 2); /* FEAT_PAN2 */ | ||
116 | + t = FIELD_DP64(t, ID_AA64MMFR1, XNX, 1); /* FEAT_XNX */ | ||
117 | cpu->isar.id_aa64mmfr1 = t; | ||
118 | |||
119 | t = cpu->isar.id_aa64mmfr2; | ||
120 | - t = FIELD_DP64(t, ID_AA64MMFR2, UAO, 1); | ||
121 | - t = FIELD_DP64(t, ID_AA64MMFR2, CNP, 1); /* TTCNP */ | ||
122 | - t = FIELD_DP64(t, ID_AA64MMFR2, ST, 1); /* TTST */ | ||
123 | - t = FIELD_DP64(t, ID_AA64MMFR2, VARANGE, 1); /* FEAT_LVA */ | ||
124 | - t = FIELD_DP64(t, ID_AA64MMFR2, TTL, 1); /* FEAT_TTL */ | ||
125 | - t = FIELD_DP64(t, ID_AA64MMFR2, BBM, 2); /* FEAT_BBM at level 2 */ | ||
126 | + t = FIELD_DP64(t, ID_AA64MMFR2, CNP, 1); /* FEAT_TTCNP */ | ||
127 | + t = FIELD_DP64(t, ID_AA64MMFR2, UAO, 1); /* FEAT_UAO */ | ||
128 | + t = FIELD_DP64(t, ID_AA64MMFR2, VARANGE, 1); /* FEAT_LVA */ | ||
129 | + t = FIELD_DP64(t, ID_AA64MMFR2, ST, 1); /* FEAT_TTST */ | ||
130 | + t = FIELD_DP64(t, ID_AA64MMFR2, TTL, 1); /* FEAT_TTL */ | ||
131 | + t = FIELD_DP64(t, ID_AA64MMFR2, BBM, 2); /* FEAT_BBM at level 2 */ | ||
132 | cpu->isar.id_aa64mmfr2 = t; | ||
133 | |||
134 | t = cpu->isar.id_aa64zfr0; | ||
135 | t = FIELD_DP64(t, ID_AA64ZFR0, SVEVER, 1); | ||
136 | - t = FIELD_DP64(t, ID_AA64ZFR0, AES, 2); /* PMULL */ | ||
137 | - t = FIELD_DP64(t, ID_AA64ZFR0, BITPERM, 1); | ||
138 | - t = FIELD_DP64(t, ID_AA64ZFR0, BFLOAT16, 1); | ||
139 | - t = FIELD_DP64(t, ID_AA64ZFR0, SHA3, 1); | ||
140 | - t = FIELD_DP64(t, ID_AA64ZFR0, SM4, 1); | ||
141 | - t = FIELD_DP64(t, ID_AA64ZFR0, I8MM, 1); | ||
142 | - t = FIELD_DP64(t, ID_AA64ZFR0, F32MM, 1); | ||
143 | - t = FIELD_DP64(t, ID_AA64ZFR0, F64MM, 1); | ||
144 | + t = FIELD_DP64(t, ID_AA64ZFR0, AES, 2); /* FEAT_SVE_PMULL128 */ | ||
145 | + t = FIELD_DP64(t, ID_AA64ZFR0, BITPERM, 1); /* FEAT_SVE_BitPerm */ | ||
146 | + t = FIELD_DP64(t, ID_AA64ZFR0, BFLOAT16, 1); /* FEAT_BF16 */ | ||
147 | + t = FIELD_DP64(t, ID_AA64ZFR0, SHA3, 1); /* FEAT_SVE_SHA3 */ | ||
148 | + t = FIELD_DP64(t, ID_AA64ZFR0, SM4, 1); /* FEAT_SVE_SM4 */ | ||
149 | + t = FIELD_DP64(t, ID_AA64ZFR0, I8MM, 1); /* FEAT_I8MM */ | ||
150 | + t = FIELD_DP64(t, ID_AA64ZFR0, F32MM, 1); /* FEAT_F32MM */ | ||
151 | + t = FIELD_DP64(t, ID_AA64ZFR0, F64MM, 1); /* FEAT_F64MM */ | ||
152 | cpu->isar.id_aa64zfr0 = t; | ||
153 | |||
154 | t = cpu->isar.id_aa64dfr0; | ||
155 | - t = FIELD_DP64(t, ID_AA64DFR0, PMUVER, 5); /* v8.4-PMU */ | ||
156 | + t = FIELD_DP64(t, ID_AA64DFR0, PMUVER, 5); /* FEAT_PMUv3p4 */ | ||
157 | cpu->isar.id_aa64dfr0 = t; | ||
158 | |||
159 | /* Replicate the same data to the 32-bit id registers. */ | ||
160 | diff --git a/target/arm/cpu_tcg.c b/target/arm/cpu_tcg.c | ||
161 | index XXXXXXX..XXXXXXX 100644 | ||
162 | --- a/target/arm/cpu_tcg.c | ||
163 | +++ b/target/arm/cpu_tcg.c | ||
164 | @@ -XXX,XX +XXX,XX @@ void aa32_max_features(ARMCPU *cpu) | ||
165 | |||
166 | /* Add additional features supported by QEMU */ | ||
167 | t = cpu->isar.id_isar5; | ||
168 | - t = FIELD_DP32(t, ID_ISAR5, AES, 2); | ||
169 | - t = FIELD_DP32(t, ID_ISAR5, SHA1, 1); | ||
170 | - t = FIELD_DP32(t, ID_ISAR5, SHA2, 1); | ||
171 | + t = FIELD_DP32(t, ID_ISAR5, AES, 2); /* FEAT_PMULL */ | ||
172 | + t = FIELD_DP32(t, ID_ISAR5, SHA1, 1); /* FEAT_SHA1 */ | ||
173 | + t = FIELD_DP32(t, ID_ISAR5, SHA2, 1); /* FEAT_SHA256 */ | ||
174 | t = FIELD_DP32(t, ID_ISAR5, CRC32, 1); | ||
175 | - t = FIELD_DP32(t, ID_ISAR5, RDM, 1); | ||
176 | - t = FIELD_DP32(t, ID_ISAR5, VCMA, 1); | ||
177 | + t = FIELD_DP32(t, ID_ISAR5, RDM, 1); /* FEAT_RDM */ | ||
178 | + t = FIELD_DP32(t, ID_ISAR5, VCMA, 1); /* FEAT_FCMA */ | ||
179 | cpu->isar.id_isar5 = t; | ||
180 | |||
181 | t = cpu->isar.id_isar6; | ||
182 | - t = FIELD_DP32(t, ID_ISAR6, JSCVT, 1); | ||
183 | - t = FIELD_DP32(t, ID_ISAR6, DP, 1); | ||
184 | - t = FIELD_DP32(t, ID_ISAR6, FHM, 1); | ||
185 | - t = FIELD_DP32(t, ID_ISAR6, SB, 1); | ||
186 | - t = FIELD_DP32(t, ID_ISAR6, SPECRES, 1); | ||
187 | - t = FIELD_DP32(t, ID_ISAR6, BF16, 1); | ||
188 | - t = FIELD_DP32(t, ID_ISAR6, I8MM, 1); | ||
189 | + t = FIELD_DP32(t, ID_ISAR6, JSCVT, 1); /* FEAT_JSCVT */ | ||
190 | + t = FIELD_DP32(t, ID_ISAR6, DP, 1); /* Feat_DotProd */ | ||
191 | + t = FIELD_DP32(t, ID_ISAR6, FHM, 1); /* FEAT_FHM */ | ||
192 | + t = FIELD_DP32(t, ID_ISAR6, SB, 1); /* FEAT_SB */ | ||
193 | + t = FIELD_DP32(t, ID_ISAR6, SPECRES, 1); /* FEAT_SPECRES */ | ||
194 | + t = FIELD_DP32(t, ID_ISAR6, BF16, 1); /* FEAT_AA32BF16 */ | ||
195 | + t = FIELD_DP32(t, ID_ISAR6, I8MM, 1); /* FEAT_AA32I8MM */ | ||
196 | cpu->isar.id_isar6 = t; | ||
197 | |||
198 | t = cpu->isar.mvfr1; | ||
199 | - t = FIELD_DP32(t, MVFR1, FPHP, 3); /* v8.2-FP16 */ | ||
200 | - t = FIELD_DP32(t, MVFR1, SIMDHP, 2); /* v8.2-FP16 */ | ||
201 | + t = FIELD_DP32(t, MVFR1, FPHP, 3); /* FEAT_FP16 */ | ||
202 | + t = FIELD_DP32(t, MVFR1, SIMDHP, 2); /* FEAT_FP16 */ | ||
203 | cpu->isar.mvfr1 = t; | ||
204 | |||
205 | t = cpu->isar.mvfr2; | ||
206 | - t = FIELD_DP32(t, MVFR2, SIMDMISC, 3); /* SIMD MaxNum */ | ||
207 | - t = FIELD_DP32(t, MVFR2, FPMISC, 4); /* FP MaxNum */ | ||
208 | + t = FIELD_DP32(t, MVFR2, SIMDMISC, 3); /* SIMD MaxNum */ | ||
209 | + t = FIELD_DP32(t, MVFR2, FPMISC, 4); /* FP MaxNum */ | ||
210 | cpu->isar.mvfr2 = t; | ||
211 | |||
212 | t = cpu->isar.id_mmfr3; | ||
213 | - t = FIELD_DP32(t, ID_MMFR3, PAN, 2); /* ATS1E1 */ | ||
214 | + t = FIELD_DP32(t, ID_MMFR3, PAN, 2); /* FEAT_PAN2 */ | ||
215 | cpu->isar.id_mmfr3 = t; | ||
216 | |||
217 | t = cpu->isar.id_mmfr4; | ||
218 | - t = FIELD_DP32(t, ID_MMFR4, HPDS, 1); /* AA32HPD */ | ||
219 | - t = FIELD_DP32(t, ID_MMFR4, AC2, 1); /* ACTLR2, HACTLR2 */ | ||
220 | - t = FIELD_DP32(t, ID_MMFR4, CNP, 1); /* TTCNP */ | ||
221 | - t = FIELD_DP32(t, ID_MMFR4, XNX, 1); /* TTS2UXN */ | ||
222 | + t = FIELD_DP32(t, ID_MMFR4, HPDS, 1); /* FEAT_AA32HPD */ | ||
223 | + t = FIELD_DP32(t, ID_MMFR4, AC2, 1); /* ACTLR2, HACTLR2 */ | ||
224 | + t = FIELD_DP32(t, ID_MMFR4, CNP, 1); /* FEAT_TTCNP */ | ||
225 | + t = FIELD_DP32(t, ID_MMFR4, XNX, 1); /* FEAT_XNX*/ | ||
226 | cpu->isar.id_mmfr4 = t; | ||
227 | |||
228 | t = cpu->isar.id_pfr0; | ||
229 | - t = FIELD_DP32(t, ID_PFR0, DIT, 1); | ||
230 | + t = FIELD_DP32(t, ID_PFR0, DIT, 1); /* FEAT_DIT */ | ||
231 | cpu->isar.id_pfr0 = t; | ||
232 | |||
233 | t = cpu->isar.id_pfr2; | ||
234 | - t = FIELD_DP32(t, ID_PFR2, SSBS, 1); | ||
235 | + t = FIELD_DP32(t, ID_PFR2, SSBS, 1); /* FEAT_SSBS */ | ||
236 | cpu->isar.id_pfr2 = t; | ||
237 | |||
238 | t = cpu->isar.id_dfr0; | ||
239 | - t = FIELD_DP32(t, ID_DFR0, PERFMON, 5); /* v8.4-PMU */ | ||
240 | + t = FIELD_DP32(t, ID_DFR0, PERFMON, 5); /* FEAT_PMUv3p4 */ | ||
241 | cpu->isar.id_dfr0 = t; | ||
242 | } | 65 | } |
243 | 66 | ||
244 | -- | 67 | -- |
245 | 2.25.1 | 68 | 2.34.1 |
69 | |||
70 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | This extension concerns cache speculation, which TCG does | 3 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
4 | not implement. Thus we can trivially enable this feature. | 4 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
5 | 5 | Message-id: 20230109115316.2235-5-philmd@linaro.org | |
6 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
7 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | ||
8 | Message-id: 20220506180242.216785-22-richard.henderson@linaro.org | ||
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 6 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
10 | --- | 7 | --- |
11 | docs/system/arm/emulation.rst | 1 + | 8 | hw/arm/collie.c | 17 +++++++---------- |
12 | target/arm/cpu64.c | 1 + | 9 | 1 file changed, 7 insertions(+), 10 deletions(-) |
13 | target/arm/cpu_tcg.c | 1 + | ||
14 | 3 files changed, 3 insertions(+) | ||
15 | 10 | ||
16 | diff --git a/docs/system/arm/emulation.rst b/docs/system/arm/emulation.rst | 11 | diff --git a/hw/arm/collie.c b/hw/arm/collie.c |
17 | index XXXXXXX..XXXXXXX 100644 | 12 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/docs/system/arm/emulation.rst | 13 | --- a/hw/arm/collie.c |
19 | +++ b/docs/system/arm/emulation.rst | 14 | +++ b/hw/arm/collie.c |
20 | @@ -XXX,XX +XXX,XX @@ the following architecture extensions: | 15 | @@ -XXX,XX +XXX,XX @@ static struct arm_boot_info collie_binfo = { |
21 | - FEAT_CSV2_1p1 (Cache speculation variant 2, version 1.1) | 16 | |
22 | - FEAT_CSV2_1p2 (Cache speculation variant 2, version 1.2) | 17 | static void collie_init(MachineState *machine) |
23 | - FEAT_CSV2_2 (Cache speculation variant 2, version 2) | 18 | { |
24 | +- FEAT_CSV3 (Cache speculation variant 3) | 19 | - DriveInfo *dinfo; |
25 | - FEAT_DIT (Data Independent Timing instructions) | 20 | MachineClass *mc = MACHINE_GET_CLASS(machine); |
26 | - FEAT_DPB (DC CVAP instruction) | 21 | CollieMachineState *cms = COLLIE_MACHINE(machine); |
27 | - FEAT_Debugv8p2 (Debug changes for v8.2) | 22 | |
28 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 23 | @@ -XXX,XX +XXX,XX @@ static void collie_init(MachineState *machine) |
29 | index XXXXXXX..XXXXXXX 100644 | 24 | |
30 | --- a/target/arm/cpu64.c | 25 | memory_region_add_subregion(get_system_memory(), SA_SDCS0, machine->ram); |
31 | +++ b/target/arm/cpu64.c | 26 | |
32 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | 27 | - dinfo = drive_get(IF_PFLASH, 0, 0); |
33 | t = FIELD_DP64(t, ID_AA64PFR0, SEL2, 1); /* FEAT_SEL2 */ | 28 | - pflash_cfi01_register(SA_CS0, "collie.fl1", FLASH_SIZE, |
34 | t = FIELD_DP64(t, ID_AA64PFR0, DIT, 1); /* FEAT_DIT */ | 29 | - dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
35 | t = FIELD_DP64(t, ID_AA64PFR0, CSV2, 2); /* FEAT_CSV2_2 */ | 30 | - FLASH_SECTOR_SIZE, 4, 0x00, 0x00, 0x00, 0x00, 0); |
36 | + t = FIELD_DP64(t, ID_AA64PFR0, CSV3, 1); /* FEAT_CSV3 */ | 31 | - |
37 | cpu->isar.id_aa64pfr0 = t; | 32 | - dinfo = drive_get(IF_PFLASH, 0, 1); |
38 | 33 | - pflash_cfi01_register(SA_CS1, "collie.fl2", FLASH_SIZE, | |
39 | t = cpu->isar.id_aa64pfr1; | 34 | - dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
40 | diff --git a/target/arm/cpu_tcg.c b/target/arm/cpu_tcg.c | 35 | - FLASH_SECTOR_SIZE, 4, 0x00, 0x00, 0x00, 0x00, 0); |
41 | index XXXXXXX..XXXXXXX 100644 | 36 | + for (unsigned i = 0; i < 2; i++) { |
42 | --- a/target/arm/cpu_tcg.c | 37 | + DriveInfo *dinfo = drive_get(IF_PFLASH, 0, i); |
43 | +++ b/target/arm/cpu_tcg.c | 38 | + pflash_cfi01_register(i ? SA_CS1 : SA_CS0, |
44 | @@ -XXX,XX +XXX,XX @@ void aa32_max_features(ARMCPU *cpu) | 39 | + i ? "collie.fl2" : "collie.fl1", FLASH_SIZE, |
45 | cpu->isar.id_pfr0 = t; | 40 | + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
46 | 41 | + FLASH_SECTOR_SIZE, 4, 0x00, 0x00, 0x00, 0x00, 0); | |
47 | t = cpu->isar.id_pfr2; | 42 | + } |
48 | + t = FIELD_DP32(t, ID_PFR2, CSV3, 1); /* FEAT_CSV3 */ | 43 | |
49 | t = FIELD_DP32(t, ID_PFR2, SSBS, 1); /* FEAT_SSBS */ | 44 | sysbus_create_simple("scoop", 0x40800000, NULL); |
50 | cpu->isar.id_pfr2 = t; | ||
51 | 45 | ||
52 | -- | 46 | -- |
53 | 2.25.1 | 47 | 2.34.1 |
48 | |||
49 | diff view generated by jsdifflib |
1 | From: Gavin Shan <gshan@redhat.com> | 1 | From: Philippe Mathieu-Daudé <f4bug@amsat.org> |
---|---|---|---|
2 | 2 | ||
3 | In aarch64_numa_cpu(), the CPU and NUMA association is something | 3 | Add a comment describing the Connex uses a Numonyx RC28F128J3F75 |
4 | like below. Two threads in the same core/cluster/socket are | 4 | flash, and the Verdex uses a Micron RC28F256P30TFA. |
5 | associated with two individual NUMA nodes, which is unreal as | ||
6 | Igor Mammedov mentioned. We don't expect the association to break | ||
7 | NUMA-to-socket boundary, which matches with the real world. | ||
8 | 5 | ||
9 | NUMA-node socket cluster core thread | 6 | Correct the Verdex machine description (we model the 'Pro' board). |
10 | ------------------------------------------ | ||
11 | 0 0 0 0 0 | ||
12 | 1 0 0 0 1 | ||
13 | 7 | ||
14 | This corrects the topology for CPUs and their association with | 8 | Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org> |
15 | NUMA nodes. After this patch is applied, the CPU and NUMA | 9 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
16 | association becomes something like below, which looks real. | 10 | Message-id: 20230109115316.2235-6-philmd@linaro.org |
17 | Besides, socket/cluster/core/thread IDs are all checked when | 11 | Message-Id: <20200223231044.8003-3-philmd@redhat.com> |
18 | the NUMA node IDs are verified. It helps to check if the CPU | ||
19 | topology is properly populated or not. | ||
20 | |||
21 | NUMA-node socket cluster core thread | ||
22 | ------------------------------------------ | ||
23 | 0 1 0 0 0 | ||
24 | 1 0 0 0 0 | ||
25 | |||
26 | Suggested-by: Igor Mammedov <imammedo@redhat.com> | ||
27 | Signed-off-by: Gavin Shan <gshan@redhat.com> | ||
28 | Acked-by: Igor Mammedov <imammedo@redhat.com> | ||
29 | Message-id: 20220503140304.855514-5-gshan@redhat.com | ||
30 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 12 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
31 | --- | 13 | --- |
32 | tests/qtest/numa-test.c | 18 ++++++++++++------ | 14 | hw/arm/gumstix.c | 6 ++++-- |
33 | 1 file changed, 12 insertions(+), 6 deletions(-) | 15 | 1 file changed, 4 insertions(+), 2 deletions(-) |
34 | 16 | ||
35 | diff --git a/tests/qtest/numa-test.c b/tests/qtest/numa-test.c | 17 | diff --git a/hw/arm/gumstix.c b/hw/arm/gumstix.c |
36 | index XXXXXXX..XXXXXXX 100644 | 18 | index XXXXXXX..XXXXXXX 100644 |
37 | --- a/tests/qtest/numa-test.c | 19 | --- a/hw/arm/gumstix.c |
38 | +++ b/tests/qtest/numa-test.c | 20 | +++ b/hw/arm/gumstix.c |
39 | @@ -XXX,XX +XXX,XX @@ static void aarch64_numa_cpu(const void *data) | 21 | @@ -XXX,XX +XXX,XX @@ |
40 | g_autofree char *cli = NULL; | 22 | * Contributions after 2012-01-13 are licensed under the terms of the |
41 | 23 | * GNU GPL, version 2 or (at your option) any later version. | |
42 | cli = make_cli(data, "-machine " | 24 | */ |
43 | - "smp.cpus=2,smp.sockets=1,smp.clusters=1,smp.cores=1,smp.threads=2 " | 25 | - |
44 | + "smp.cpus=2,smp.sockets=2,smp.clusters=1,smp.cores=1,smp.threads=1 " | 26 | + |
45 | "-numa node,nodeid=0,memdev=ram -numa node,nodeid=1 " | 27 | /* |
46 | - "-numa cpu,node-id=1,thread-id=0 " | 28 | * Example usage: |
47 | - "-numa cpu,node-id=0,thread-id=1"); | 29 | * |
48 | + "-numa cpu,node-id=0,socket-id=1,cluster-id=0,core-id=0,thread-id=0 " | 30 | @@ -XXX,XX +XXX,XX @@ static void connex_init(MachineState *machine) |
49 | + "-numa cpu,node-id=1,socket-id=0,cluster-id=0,core-id=0,thread-id=0"); | 31 | exit(1); |
50 | qts = qtest_init(cli); | 32 | } |
51 | cpus = get_cpus(qts, &resp); | 33 | |
52 | g_assert(cpus); | 34 | + /* Numonyx RC28F128J3F75 */ |
53 | 35 | if (!pflash_cfi01_register(0x00000000, "connext.rom", connex_rom, | |
54 | while ((e = qlist_pop(cpus))) { | 36 | dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
55 | QDict *cpu, *props; | 37 | sector_len, 2, 0, 0, 0, 0, 0)) { |
56 | - int64_t thread, node; | 38 | @@ -XXX,XX +XXX,XX @@ static void verdex_init(MachineState *machine) |
57 | + int64_t socket, cluster, core, thread, node; | 39 | exit(1); |
58 | 40 | } | |
59 | cpu = qobject_to(QDict, e); | 41 | |
60 | g_assert(qdict_haskey(cpu, "props")); | 42 | + /* Micron RC28F256P30TFA */ |
61 | @@ -XXX,XX +XXX,XX @@ static void aarch64_numa_cpu(const void *data) | 43 | if (!pflash_cfi01_register(0x00000000, "verdex.rom", verdex_rom, |
62 | 44 | dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, | |
63 | g_assert(qdict_haskey(props, "node-id")); | 45 | sector_len, 2, 0, 0, 0, 0, 0)) { |
64 | node = qdict_get_int(props, "node-id"); | 46 | @@ -XXX,XX +XXX,XX @@ static void verdex_class_init(ObjectClass *oc, void *data) |
65 | + g_assert(qdict_haskey(props, "socket-id")); | 47 | { |
66 | + socket = qdict_get_int(props, "socket-id"); | 48 | MachineClass *mc = MACHINE_CLASS(oc); |
67 | + g_assert(qdict_haskey(props, "cluster-id")); | 49 | |
68 | + cluster = qdict_get_int(props, "cluster-id"); | 50 | - mc->desc = "Gumstix Verdex (PXA270)"; |
69 | + g_assert(qdict_haskey(props, "core-id")); | 51 | + mc->desc = "Gumstix Verdex Pro XL6P COMs (PXA270)"; |
70 | + core = qdict_get_int(props, "core-id"); | 52 | mc->init = verdex_init; |
71 | g_assert(qdict_haskey(props, "thread-id")); | 53 | mc->ignore_memory_transaction_failures = true; |
72 | thread = qdict_get_int(props, "thread-id"); | 54 | mc->default_cpu_type = ARM_CPU_TYPE_NAME("pxa270-c0"); |
73 | |||
74 | - if (thread == 0) { | ||
75 | + if (socket == 0 && cluster == 0 && core == 0 && thread == 0) { | ||
76 | g_assert_cmpint(node, ==, 1); | ||
77 | - } else if (thread == 1) { | ||
78 | + } else if (socket == 1 && cluster == 0 && core == 0 && thread == 0) { | ||
79 | g_assert_cmpint(node, ==, 0); | ||
80 | } else { | ||
81 | g_assert(false); | ||
82 | -- | 55 | -- |
83 | 2.25.1 | 56 | 2.34.1 |
57 | |||
58 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <f4bug@amsat.org> |
---|---|---|---|
2 | 2 | ||
3 | More gracefully handle cpregs when EL2 and/or EL3 are missing. | 3 | IEC binary prefixes ease code review: the unit is explicit. |
4 | If the reg is entirely inaccessible, do not register it at all. | ||
5 | If the reg is for EL2, and EL3 is present but EL2 is not, | ||
6 | either discard, squash to res0, const, or keep unchanged. | ||
7 | 4 | ||
8 | Per rule RJFFP, mark the 4 aarch32 hypervisor access registers | 5 | Add definitions for RAM / Flash / Flash blocksize. |
9 | with ARM_CP_EL3_NO_EL2_KEEP, and mark all of the EL2 address | ||
10 | translation and tlb invalidation "regs" ARM_CP_EL3_NO_EL2_UNDEF. | ||
11 | Mark the 2 virtualization processor id regs ARM_CP_EL3_NO_EL2_C_NZ. | ||
12 | 6 | ||
13 | This will simplify cpreg registration for conditional arm features. | 7 | Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org> |
14 | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | |
15 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 9 | Message-id: 20230109115316.2235-7-philmd@linaro.org |
16 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 10 | Message-Id: <20200223231044.8003-3-philmd@redhat.com> |
17 | Message-id: 20220506180242.216785-2-richard.henderson@linaro.org | ||
18 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
19 | --- | 12 | --- |
20 | target/arm/cpregs.h | 11 +++ | 13 | hw/arm/gumstix.c | 27 ++++++++++++++------------- |
21 | target/arm/helper.c | 178 ++++++++++++++++++++++++++++++-------------- | 14 | 1 file changed, 14 insertions(+), 13 deletions(-) |
22 | 2 files changed, 133 insertions(+), 56 deletions(-) | ||
23 | 15 | ||
24 | diff --git a/target/arm/cpregs.h b/target/arm/cpregs.h | 16 | diff --git a/hw/arm/gumstix.c b/hw/arm/gumstix.c |
25 | index XXXXXXX..XXXXXXX 100644 | 17 | index XXXXXXX..XXXXXXX 100644 |
26 | --- a/target/arm/cpregs.h | 18 | --- a/hw/arm/gumstix.c |
27 | +++ b/target/arm/cpregs.h | 19 | +++ b/hw/arm/gumstix.c |
28 | @@ -XXX,XX +XXX,XX @@ enum { | 20 | @@ -XXX,XX +XXX,XX @@ |
29 | ARM_CP_SVE = 1 << 14, | 21 | */ |
30 | /* Flag: Do not expose in gdb sysreg xml. */ | 22 | |
31 | ARM_CP_NO_GDB = 1 << 15, | 23 | #include "qemu/osdep.h" |
32 | + /* | 24 | +#include "qemu/units.h" |
33 | + * Flags: If EL3 but not EL2... | 25 | #include "qemu/error-report.h" |
34 | + * - UNDEF: discard the cpreg, | 26 | #include "hw/arm/pxa.h" |
35 | + * - KEEP: retain the cpreg as is, | 27 | #include "net/net.h" |
36 | + * - C_NZ: set const on the cpreg, but retain resetvalue, | 28 | @@ -XXX,XX +XXX,XX @@ |
37 | + * - else: set const on the cpreg, zero resetvalue, aka RES0. | 29 | #include "sysemu/qtest.h" |
38 | + * See rule RJFFP in section D1.1.3 of DDI0487H.a. | 30 | #include "cpu.h" |
39 | + */ | 31 | |
40 | + ARM_CP_EL3_NO_EL2_UNDEF = 1 << 16, | 32 | -static const int sector_len = 128 * 1024; |
41 | + ARM_CP_EL3_NO_EL2_KEEP = 1 << 17, | 33 | +#define CONNEX_FLASH_SIZE (16 * MiB) |
42 | + ARM_CP_EL3_NO_EL2_C_NZ = 1 << 18, | 34 | +#define CONNEX_RAM_SIZE (64 * MiB) |
43 | }; | 35 | + |
44 | 36 | +#define VERDEX_FLASH_SIZE (32 * MiB) | |
45 | /* | 37 | +#define VERDEX_RAM_SIZE (256 * MiB) |
46 | diff --git a/target/arm/helper.c b/target/arm/helper.c | 38 | + |
47 | index XXXXXXX..XXXXXXX 100644 | 39 | +#define FLASH_SECTOR_SIZE (128 * KiB) |
48 | --- a/target/arm/helper.c | 40 | |
49 | +++ b/target/arm/helper.c | 41 | static void connex_init(MachineState *machine) |
50 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo v8_cp_reginfo[] = { | ||
51 | .access = PL1_RW, .readfn = spsel_read, .writefn = spsel_write }, | ||
52 | { .name = "FPEXC32_EL2", .state = ARM_CP_STATE_AA64, | ||
53 | .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 3, .opc2 = 0, | ||
54 | - .access = PL2_RW, .type = ARM_CP_ALIAS | ARM_CP_FPU, | ||
55 | + .access = PL2_RW, | ||
56 | + .type = ARM_CP_ALIAS | ARM_CP_FPU | ARM_CP_EL3_NO_EL2_KEEP, | ||
57 | .fieldoffset = offsetof(CPUARMState, vfp.xregs[ARM_VFP_FPEXC]) }, | ||
58 | { .name = "DACR32_EL2", .state = ARM_CP_STATE_AA64, | ||
59 | .opc0 = 3, .opc1 = 4, .crn = 3, .crm = 0, .opc2 = 0, | ||
60 | - .access = PL2_RW, .resetvalue = 0, | ||
61 | + .access = PL2_RW, .resetvalue = 0, .type = ARM_CP_EL3_NO_EL2_KEEP, | ||
62 | .writefn = dacr_write, .raw_writefn = raw_write, | ||
63 | .fieldoffset = offsetof(CPUARMState, cp15.dacr32_el2) }, | ||
64 | { .name = "IFSR32_EL2", .state = ARM_CP_STATE_AA64, | ||
65 | .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 0, .opc2 = 1, | ||
66 | - .access = PL2_RW, .resetvalue = 0, | ||
67 | + .access = PL2_RW, .resetvalue = 0, .type = ARM_CP_EL3_NO_EL2_KEEP, | ||
68 | .fieldoffset = offsetof(CPUARMState, cp15.ifsr32_el2) }, | ||
69 | { .name = "SPSR_IRQ", .state = ARM_CP_STATE_AA64, | ||
70 | .type = ARM_CP_ALIAS, | ||
71 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo el2_cp_reginfo[] = { | ||
72 | .writefn = tlbimva_hyp_is_write }, | ||
73 | { .name = "TLBI_ALLE2", .state = ARM_CP_STATE_AA64, | ||
74 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 0, | ||
75 | - .type = ARM_CP_NO_RAW, .access = PL2_W, | ||
76 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
77 | .writefn = tlbi_aa64_alle2_write }, | ||
78 | { .name = "TLBI_VAE2", .state = ARM_CP_STATE_AA64, | ||
79 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 1, | ||
80 | - .type = ARM_CP_NO_RAW, .access = PL2_W, | ||
81 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
82 | .writefn = tlbi_aa64_vae2_write }, | ||
83 | { .name = "TLBI_VALE2", .state = ARM_CP_STATE_AA64, | ||
84 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 7, .opc2 = 5, | ||
85 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
86 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
87 | .writefn = tlbi_aa64_vae2_write }, | ||
88 | { .name = "TLBI_ALLE2IS", .state = ARM_CP_STATE_AA64, | ||
89 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 0, | ||
90 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
91 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
92 | .writefn = tlbi_aa64_alle2is_write }, | ||
93 | { .name = "TLBI_VAE2IS", .state = ARM_CP_STATE_AA64, | ||
94 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 1, | ||
95 | - .type = ARM_CP_NO_RAW, .access = PL2_W, | ||
96 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
97 | .writefn = tlbi_aa64_vae2is_write }, | ||
98 | { .name = "TLBI_VALE2IS", .state = ARM_CP_STATE_AA64, | ||
99 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 3, .opc2 = 5, | ||
100 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
101 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
102 | .writefn = tlbi_aa64_vae2is_write }, | ||
103 | #ifndef CONFIG_USER_ONLY | ||
104 | /* Unlike the other EL2-related AT operations, these must | ||
105 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo el2_cp_reginfo[] = { | ||
106 | { .name = "AT_S1E2R", .state = ARM_CP_STATE_AA64, | ||
107 | .opc0 = 1, .opc1 = 4, .crn = 7, .crm = 8, .opc2 = 0, | ||
108 | .access = PL2_W, .accessfn = at_s1e2_access, | ||
109 | - .type = ARM_CP_NO_RAW | ARM_CP_RAISES_EXC, .writefn = ats_write64 }, | ||
110 | + .type = ARM_CP_NO_RAW | ARM_CP_RAISES_EXC | ARM_CP_EL3_NO_EL2_UNDEF, | ||
111 | + .writefn = ats_write64 }, | ||
112 | { .name = "AT_S1E2W", .state = ARM_CP_STATE_AA64, | ||
113 | .opc0 = 1, .opc1 = 4, .crn = 7, .crm = 8, .opc2 = 1, | ||
114 | .access = PL2_W, .accessfn = at_s1e2_access, | ||
115 | - .type = ARM_CP_NO_RAW | ARM_CP_RAISES_EXC, .writefn = ats_write64 }, | ||
116 | + .type = ARM_CP_NO_RAW | ARM_CP_RAISES_EXC | ARM_CP_EL3_NO_EL2_UNDEF, | ||
117 | + .writefn = ats_write64 }, | ||
118 | /* The AArch32 ATS1H* operations are CONSTRAINED UNPREDICTABLE | ||
119 | * if EL2 is not implemented; we choose to UNDEF. Behaviour at EL3 | ||
120 | * with SCR.NS == 0 outside Monitor mode is UNPREDICTABLE; we choose | ||
121 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo debug_cp_reginfo[] = { | ||
122 | { .name = "DBGVCR32_EL2", .state = ARM_CP_STATE_AA64, | ||
123 | .opc0 = 2, .opc1 = 4, .crn = 0, .crm = 7, .opc2 = 0, | ||
124 | .access = PL2_RW, .accessfn = access_tda, | ||
125 | - .type = ARM_CP_NOP }, | ||
126 | + .type = ARM_CP_NOP | ARM_CP_EL3_NO_EL2_KEEP }, | ||
127 | /* Dummy MDCCINT_EL1, since we don't implement the Debug Communications | ||
128 | * Channel but Linux may try to access this register. The 32-bit | ||
129 | * alias is DBGDCCINT. | ||
130 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo tlbirange_reginfo[] = { | ||
131 | .access = PL2_W, .type = ARM_CP_NOP }, | ||
132 | { .name = "TLBI_RVAE2IS", .state = ARM_CP_STATE_AA64, | ||
133 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 2, .opc2 = 1, | ||
134 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
135 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
136 | .writefn = tlbi_aa64_rvae2is_write }, | ||
137 | { .name = "TLBI_RVALE2IS", .state = ARM_CP_STATE_AA64, | ||
138 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 2, .opc2 = 5, | ||
139 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
140 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
141 | .writefn = tlbi_aa64_rvae2is_write }, | ||
142 | { .name = "TLBI_RIPAS2E1", .state = ARM_CP_STATE_AA64, | ||
143 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 4, .opc2 = 2, | ||
144 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo tlbirange_reginfo[] = { | ||
145 | .access = PL2_W, .type = ARM_CP_NOP }, | ||
146 | { .name = "TLBI_RVAE2OS", .state = ARM_CP_STATE_AA64, | ||
147 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 5, .opc2 = 1, | ||
148 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
149 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
150 | .writefn = tlbi_aa64_rvae2is_write }, | ||
151 | { .name = "TLBI_RVALE2OS", .state = ARM_CP_STATE_AA64, | ||
152 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 5, .opc2 = 5, | ||
153 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
154 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
155 | .writefn = tlbi_aa64_rvae2is_write }, | ||
156 | { .name = "TLBI_RVAE2", .state = ARM_CP_STATE_AA64, | ||
157 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 6, .opc2 = 1, | ||
158 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
159 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
160 | .writefn = tlbi_aa64_rvae2_write }, | ||
161 | { .name = "TLBI_RVALE2", .state = ARM_CP_STATE_AA64, | ||
162 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 6, .opc2 = 5, | ||
163 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
164 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
165 | .writefn = tlbi_aa64_rvae2_write }, | ||
166 | { .name = "TLBI_RVAE3IS", .state = ARM_CP_STATE_AA64, | ||
167 | .opc0 = 1, .opc1 = 6, .crn = 8, .crm = 2, .opc2 = 1, | ||
168 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo tlbios_reginfo[] = { | ||
169 | .writefn = tlbi_aa64_vae1is_write }, | ||
170 | { .name = "TLBI_ALLE2OS", .state = ARM_CP_STATE_AA64, | ||
171 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 1, .opc2 = 0, | ||
172 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
173 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
174 | .writefn = tlbi_aa64_alle2is_write }, | ||
175 | { .name = "TLBI_VAE2OS", .state = ARM_CP_STATE_AA64, | ||
176 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 1, .opc2 = 1, | ||
177 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
178 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
179 | .writefn = tlbi_aa64_vae2is_write }, | ||
180 | { .name = "TLBI_ALLE1OS", .state = ARM_CP_STATE_AA64, | ||
181 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 1, .opc2 = 4, | ||
182 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo tlbios_reginfo[] = { | ||
183 | .writefn = tlbi_aa64_alle1is_write }, | ||
184 | { .name = "TLBI_VALE2OS", .state = ARM_CP_STATE_AA64, | ||
185 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 1, .opc2 = 5, | ||
186 | - .access = PL2_W, .type = ARM_CP_NO_RAW, | ||
187 | + .access = PL2_W, .type = ARM_CP_NO_RAW | ARM_CP_EL3_NO_EL2_UNDEF, | ||
188 | .writefn = tlbi_aa64_vae2is_write }, | ||
189 | { .name = "TLBI_VMALLS12E1OS", .state = ARM_CP_STATE_AA64, | ||
190 | .opc0 = 1, .opc1 = 4, .crn = 8, .crm = 1, .opc2 = 6, | ||
191 | @@ -XXX,XX +XXX,XX @@ void register_cp_regs_for_features(ARMCPU *cpu) | ||
192 | { .name = "VPIDR", .state = ARM_CP_STATE_AA32, | ||
193 | .cp = 15, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 0, | ||
194 | .access = PL2_RW, .accessfn = access_el3_aa32ns, | ||
195 | - .resetvalue = cpu->midr, .type = ARM_CP_ALIAS, | ||
196 | + .resetvalue = cpu->midr, | ||
197 | + .type = ARM_CP_ALIAS | ARM_CP_EL3_NO_EL2_C_NZ, | ||
198 | .fieldoffset = offsetoflow32(CPUARMState, cp15.vpidr_el2) }, | ||
199 | { .name = "VPIDR_EL2", .state = ARM_CP_STATE_AA64, | ||
200 | .opc0 = 3, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 0, | ||
201 | .access = PL2_RW, .resetvalue = cpu->midr, | ||
202 | + .type = ARM_CP_EL3_NO_EL2_C_NZ, | ||
203 | .fieldoffset = offsetof(CPUARMState, cp15.vpidr_el2) }, | ||
204 | { .name = "VMPIDR", .state = ARM_CP_STATE_AA32, | ||
205 | .cp = 15, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 5, | ||
206 | .access = PL2_RW, .accessfn = access_el3_aa32ns, | ||
207 | - .resetvalue = vmpidr_def, .type = ARM_CP_ALIAS, | ||
208 | + .resetvalue = vmpidr_def, | ||
209 | + .type = ARM_CP_ALIAS | ARM_CP_EL3_NO_EL2_C_NZ, | ||
210 | .fieldoffset = offsetoflow32(CPUARMState, cp15.vmpidr_el2) }, | ||
211 | { .name = "VMPIDR_EL2", .state = ARM_CP_STATE_AA64, | ||
212 | .opc0 = 3, .opc1 = 4, .crn = 0, .crm = 0, .opc2 = 5, | ||
213 | - .access = PL2_RW, | ||
214 | - .resetvalue = vmpidr_def, | ||
215 | + .access = PL2_RW, .resetvalue = vmpidr_def, | ||
216 | + .type = ARM_CP_EL3_NO_EL2_C_NZ, | ||
217 | .fieldoffset = offsetof(CPUARMState, cp15.vmpidr_el2) }, | ||
218 | }; | ||
219 | define_arm_cp_regs(cpu, vpidr_regs); | ||
220 | @@ -XXX,XX +XXX,XX @@ static void add_cpreg_to_hashtable(ARMCPU *cpu, const ARMCPRegInfo *r, | ||
221 | int crm, int opc1, int opc2, | ||
222 | const char *name) | ||
223 | { | 42 | { |
224 | + CPUARMState *env = &cpu->env; | 43 | PXA2xxState *cpu; |
225 | uint32_t key; | 44 | DriveInfo *dinfo; |
226 | ARMCPRegInfo *r2; | 45 | |
227 | bool is64 = r->type & ARM_CP_64BIT; | 46 | - uint32_t connex_rom = 0x01000000; |
228 | bool ns = secstate & ARM_CP_SECSTATE_NS; | 47 | - uint32_t connex_ram = 0x04000000; |
229 | int cp = r->cp; | 48 | - |
230 | - bool isbanked; | 49 | - cpu = pxa255_init(connex_ram); |
231 | size_t name_len; | 50 | + cpu = pxa255_init(CONNEX_RAM_SIZE); |
232 | + bool make_const; | 51 | |
233 | 52 | dinfo = drive_get(IF_PFLASH, 0, 0); | |
234 | switch (state) { | 53 | if (!dinfo && !qtest_enabled()) { |
235 | case ARM_CP_STATE_AA32: | 54 | @@ -XXX,XX +XXX,XX @@ static void connex_init(MachineState *machine) |
236 | @@ -XXX,XX +XXX,XX @@ static void add_cpreg_to_hashtable(ARMCPU *cpu, const ARMCPRegInfo *r, | ||
237 | } | ||
238 | } | 55 | } |
239 | 56 | ||
240 | + /* | 57 | /* Numonyx RC28F128J3F75 */ |
241 | + * Eliminate registers that are not present because the EL is missing. | 58 | - if (!pflash_cfi01_register(0x00000000, "connext.rom", connex_rom, |
242 | + * Doing this here makes it easier to put all registers for a given | 59 | + if (!pflash_cfi01_register(0x00000000, "connext.rom", CONNEX_FLASH_SIZE, |
243 | + * feature into the same ARMCPRegInfo array and define them all at once. | 60 | dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
244 | + */ | 61 | - sector_len, 2, 0, 0, 0, 0, 0)) { |
245 | + make_const = false; | 62 | + FLASH_SECTOR_SIZE, 2, 0, 0, 0, 0, 0)) { |
246 | + if (arm_feature(env, ARM_FEATURE_EL3)) { | 63 | error_report("Error registering flash memory"); |
247 | + /* | 64 | exit(1); |
248 | + * An EL2 register without EL2 but with EL3 is (usually) RES0. | ||
249 | + * See rule RJFFP in section D1.1.3 of DDI0487H.a. | ||
250 | + */ | ||
251 | + int min_el = ctz32(r->access) / 2; | ||
252 | + if (min_el == 2 && !arm_feature(env, ARM_FEATURE_EL2)) { | ||
253 | + if (r->type & ARM_CP_EL3_NO_EL2_UNDEF) { | ||
254 | + return; | ||
255 | + } | ||
256 | + make_const = !(r->type & ARM_CP_EL3_NO_EL2_KEEP); | ||
257 | + } | ||
258 | + } else { | ||
259 | + CPAccessRights max_el = (arm_feature(env, ARM_FEATURE_EL2) | ||
260 | + ? PL2_RW : PL1_RW); | ||
261 | + if ((r->access & max_el) == 0) { | ||
262 | + return; | ||
263 | + } | ||
264 | + } | ||
265 | + | ||
266 | /* Combine cpreg and name into one allocation. */ | ||
267 | name_len = strlen(name) + 1; | ||
268 | r2 = g_malloc(sizeof(*r2) + name_len); | ||
269 | @@ -XXX,XX +XXX,XX @@ static void add_cpreg_to_hashtable(ARMCPU *cpu, const ARMCPRegInfo *r, | ||
270 | r2->opaque = opaque; | ||
271 | } | 65 | } |
272 | 66 | @@ -XXX,XX +XXX,XX @@ static void verdex_init(MachineState *machine) | |
273 | - isbanked = r->bank_fieldoffsets[0] && r->bank_fieldoffsets[1]; | 67 | PXA2xxState *cpu; |
274 | - if (isbanked) { | 68 | DriveInfo *dinfo; |
275 | + if (make_const) { | 69 | |
276 | + /* This should not have been a very special register to begin. */ | 70 | - uint32_t verdex_rom = 0x02000000; |
277 | + int old_special = r2->type & ARM_CP_SPECIAL_MASK; | 71 | - uint32_t verdex_ram = 0x10000000; |
278 | + assert(old_special == 0 || old_special == ARM_CP_NOP); | 72 | - |
279 | /* | 73 | - cpu = pxa270_init(verdex_ram, machine->cpu_type); |
280 | - * Register is banked (using both entries in array). | 74 | + cpu = pxa270_init(VERDEX_RAM_SIZE, machine->cpu_type); |
281 | - * Overwriting fieldoffset as the array is only used to define | 75 | |
282 | - * banked registers but later only fieldoffset is used. | 76 | dinfo = drive_get(IF_PFLASH, 0, 0); |
283 | + * Set the special function to CONST, retaining the other flags. | 77 | if (!dinfo && !qtest_enabled()) { |
284 | + * This is important for e.g. ARM_CP_SVE so that we still | 78 | @@ -XXX,XX +XXX,XX @@ static void verdex_init(MachineState *machine) |
285 | + * take the SVE trap if CPTR_EL3.EZ == 0. | ||
286 | */ | ||
287 | - r2->fieldoffset = r->bank_fieldoffsets[ns]; | ||
288 | - } | ||
289 | + r2->type = (r2->type & ~ARM_CP_SPECIAL_MASK) | ARM_CP_CONST; | ||
290 | + /* | ||
291 | + * Usually, these registers become RES0, but there are a few | ||
292 | + * special cases like VPIDR_EL2 which have a constant non-zero | ||
293 | + * value with writes ignored. | ||
294 | + */ | ||
295 | + if (!(r->type & ARM_CP_EL3_NO_EL2_C_NZ)) { | ||
296 | + r2->resetvalue = 0; | ||
297 | + } | ||
298 | + /* | ||
299 | + * ARM_CP_CONST has precedence, so removing the callbacks and | ||
300 | + * offsets are not strictly necessary, but it is potentially | ||
301 | + * less confusing to debug later. | ||
302 | + */ | ||
303 | + r2->readfn = NULL; | ||
304 | + r2->writefn = NULL; | ||
305 | + r2->raw_readfn = NULL; | ||
306 | + r2->raw_writefn = NULL; | ||
307 | + r2->resetfn = NULL; | ||
308 | + r2->fieldoffset = 0; | ||
309 | + r2->bank_fieldoffsets[0] = 0; | ||
310 | + r2->bank_fieldoffsets[1] = 0; | ||
311 | + } else { | ||
312 | + bool isbanked = r->bank_fieldoffsets[0] && r->bank_fieldoffsets[1]; | ||
313 | |||
314 | - if (state == ARM_CP_STATE_AA32) { | ||
315 | if (isbanked) { | ||
316 | /* | ||
317 | - * If the register is banked then we don't need to migrate or | ||
318 | - * reset the 32-bit instance in certain cases: | ||
319 | - * | ||
320 | - * 1) If the register has both 32-bit and 64-bit instances then we | ||
321 | - * can count on the 64-bit instance taking care of the | ||
322 | - * non-secure bank. | ||
323 | - * 2) If ARMv8 is enabled then we can count on a 64-bit version | ||
324 | - * taking care of the secure bank. This requires that separate | ||
325 | - * 32 and 64-bit definitions are provided. | ||
326 | + * Register is banked (using both entries in array). | ||
327 | + * Overwriting fieldoffset as the array is only used to define | ||
328 | + * banked registers but later only fieldoffset is used. | ||
329 | */ | ||
330 | - if ((r->state == ARM_CP_STATE_BOTH && ns) || | ||
331 | - (arm_feature(&cpu->env, ARM_FEATURE_V8) && !ns)) { | ||
332 | + r2->fieldoffset = r->bank_fieldoffsets[ns]; | ||
333 | + } | ||
334 | + if (state == ARM_CP_STATE_AA32) { | ||
335 | + if (isbanked) { | ||
336 | + /* | ||
337 | + * If the register is banked then we don't need to migrate or | ||
338 | + * reset the 32-bit instance in certain cases: | ||
339 | + * | ||
340 | + * 1) If the register has both 32-bit and 64-bit instances | ||
341 | + * then we can count on the 64-bit instance taking care | ||
342 | + * of the non-secure bank. | ||
343 | + * 2) If ARMv8 is enabled then we can count on a 64-bit | ||
344 | + * version taking care of the secure bank. This requires | ||
345 | + * that separate 32 and 64-bit definitions are provided. | ||
346 | + */ | ||
347 | + if ((r->state == ARM_CP_STATE_BOTH && ns) || | ||
348 | + (arm_feature(env, ARM_FEATURE_V8) && !ns)) { | ||
349 | + r2->type |= ARM_CP_ALIAS; | ||
350 | + } | ||
351 | + } else if ((secstate != r->secure) && !ns) { | ||
352 | + /* | ||
353 | + * The register is not banked so we only want to allow | ||
354 | + * migration of the non-secure instance. | ||
355 | + */ | ||
356 | r2->type |= ARM_CP_ALIAS; | ||
357 | } | ||
358 | - } else if ((secstate != r->secure) && !ns) { | ||
359 | - /* | ||
360 | - * The register is not banked so we only want to allow migration | ||
361 | - * of the non-secure instance. | ||
362 | - */ | ||
363 | - r2->type |= ARM_CP_ALIAS; | ||
364 | - } | ||
365 | |||
366 | - if (HOST_BIG_ENDIAN && | ||
367 | - r->state == ARM_CP_STATE_BOTH && r2->fieldoffset) { | ||
368 | - r2->fieldoffset += sizeof(uint32_t); | ||
369 | + if (HOST_BIG_ENDIAN && | ||
370 | + r->state == ARM_CP_STATE_BOTH && r2->fieldoffset) { | ||
371 | + r2->fieldoffset += sizeof(uint32_t); | ||
372 | + } | ||
373 | } | ||
374 | } | 79 | } |
375 | 80 | ||
376 | @@ -XXX,XX +XXX,XX @@ static void add_cpreg_to_hashtable(ARMCPU *cpu, const ARMCPRegInfo *r, | 81 | /* Micron RC28F256P30TFA */ |
377 | * multiple times. Special registers (ie NOP/WFI) are | 82 | - if (!pflash_cfi01_register(0x00000000, "verdex.rom", verdex_rom, |
378 | * never migratable and not even raw-accessible. | 83 | + if (!pflash_cfi01_register(0x00000000, "verdex.rom", VERDEX_FLASH_SIZE, |
379 | */ | 84 | dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
380 | - if (r->type & ARM_CP_SPECIAL_MASK) { | 85 | - sector_len, 2, 0, 0, 0, 0, 0)) { |
381 | + if (r2->type & ARM_CP_SPECIAL_MASK) { | 86 | + FLASH_SECTOR_SIZE, 2, 0, 0, 0, 0, 0)) { |
382 | r2->type |= ARM_CP_NO_RAW; | 87 | error_report("Error registering flash memory"); |
88 | exit(1); | ||
383 | } | 89 | } |
384 | if (((r->crm == CP_ANY) && crm != 0) || | ||
385 | -- | 90 | -- |
386 | 2.25.1 | 91 | 2.34.1 |
92 | |||
93 | diff view generated by jsdifflib |
1 | From: Gavin Shan <gshan@redhat.com> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Currently, the SMP configuration isn't considered when the CPU | 3 | IEC binary prefixes ease code review: the unit is explicit. |
4 | topology is populated. In this case, it's impossible to provide | ||
5 | the default CPU-to-NUMA mapping or association based on the socket | ||
6 | ID of the given CPU. | ||
7 | 4 | ||
8 | This takes account of SMP configuration when the CPU topology | 5 | Add the FLASH_SECTOR_SIZE definition. |
9 | is populated. The die ID for the given CPU isn't assigned since | ||
10 | it's not supported on arm/virt machine. Besides, the used SMP | ||
11 | configuration in qtest/numa-test/aarch64_numa_cpu() is corrcted | ||
12 | to avoid testing failure | ||
13 | 6 | ||
14 | Signed-off-by: Gavin Shan <gshan@redhat.com> | 7 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
15 | Reviewed-by: Yanan Wang <wangyanan55@huawei.com> | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
16 | Acked-by: Igor Mammedov <imammedo@redhat.com> | 9 | Message-id: 20230109115316.2235-8-philmd@linaro.org |
17 | Message-id: 20220503140304.855514-4-gshan@redhat.com | ||
18 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
19 | --- | 11 | --- |
20 | hw/arm/virt.c | 15 ++++++++++++++- | 12 | hw/arm/mainstone.c | 18 ++++++++++-------- |
21 | 1 file changed, 14 insertions(+), 1 deletion(-) | 13 | 1 file changed, 10 insertions(+), 8 deletions(-) |
22 | 14 | ||
23 | diff --git a/hw/arm/virt.c b/hw/arm/virt.c | 15 | diff --git a/hw/arm/mainstone.c b/hw/arm/mainstone.c |
24 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
25 | --- a/hw/arm/virt.c | 17 | --- a/hw/arm/mainstone.c |
26 | +++ b/hw/arm/virt.c | 18 | +++ b/hw/arm/mainstone.c |
27 | @@ -XXX,XX +XXX,XX @@ static const CPUArchIdList *virt_possible_cpu_arch_ids(MachineState *ms) | 19 | @@ -XXX,XX +XXX,XX @@ |
28 | int n; | 20 | * GNU GPL, version 2 or (at your option) any later version. |
29 | unsigned int max_cpus = ms->smp.max_cpus; | 21 | */ |
30 | VirtMachineState *vms = VIRT_MACHINE(ms); | 22 | #include "qemu/osdep.h" |
31 | + MachineClass *mc = MACHINE_GET_CLASS(vms); | 23 | +#include "qemu/units.h" |
32 | 24 | #include "qemu/error-report.h" | |
33 | if (ms->possible_cpus) { | 25 | #include "qapi/error.h" |
34 | assert(ms->possible_cpus->len == max_cpus); | 26 | #include "hw/arm/pxa.h" |
35 | @@ -XXX,XX +XXX,XX @@ static const CPUArchIdList *virt_possible_cpu_arch_ids(MachineState *ms) | 27 | @@ -XXX,XX +XXX,XX @@ static const struct keymap map[0xE0] = { |
36 | ms->possible_cpus->cpus[n].type = ms->cpu_type; | 28 | |
37 | ms->possible_cpus->cpus[n].arch_id = | 29 | enum mainstone_model_e { mainstone }; |
38 | virt_cpu_mp_affinity(vms, n); | 30 | |
31 | -#define MAINSTONE_RAM 0x04000000 | ||
32 | -#define MAINSTONE_ROM 0x00800000 | ||
33 | -#define MAINSTONE_FLASH 0x02000000 | ||
34 | +#define MAINSTONE_RAM_SIZE (64 * MiB) | ||
35 | +#define MAINSTONE_ROM_SIZE (8 * MiB) | ||
36 | +#define MAINSTONE_FLASH_SIZE (32 * MiB) | ||
37 | |||
38 | static struct arm_boot_info mainstone_binfo = { | ||
39 | .loader_start = PXA2XX_SDRAM_BASE, | ||
40 | - .ram_size = 0x04000000, | ||
41 | + .ram_size = MAINSTONE_RAM_SIZE, | ||
42 | }; | ||
43 | |||
44 | +#define FLASH_SECTOR_SIZE (256 * KiB) | ||
39 | + | 45 | + |
40 | + assert(!mc->smp_props.dies_supported); | 46 | static void mainstone_common_init(MachineState *machine, |
41 | + ms->possible_cpus->cpus[n].props.has_socket_id = true; | 47 | enum mainstone_model_e model, int arm_id) |
42 | + ms->possible_cpus->cpus[n].props.socket_id = | 48 | { |
43 | + n / (ms->smp.clusters * ms->smp.cores * ms->smp.threads); | 49 | - uint32_t sector_len = 256 * 1024; |
44 | + ms->possible_cpus->cpus[n].props.has_cluster_id = true; | 50 | hwaddr mainstone_flash_base[] = { MST_FLASH_0, MST_FLASH_1 }; |
45 | + ms->possible_cpus->cpus[n].props.cluster_id = | 51 | PXA2xxState *mpu; |
46 | + (n / (ms->smp.cores * ms->smp.threads)) % ms->smp.clusters; | 52 | DeviceState *mst_irq; |
47 | + ms->possible_cpus->cpus[n].props.has_core_id = true; | 53 | @@ -XXX,XX +XXX,XX @@ static void mainstone_common_init(MachineState *machine, |
48 | + ms->possible_cpus->cpus[n].props.core_id = | 54 | |
49 | + (n / ms->smp.threads) % ms->smp.cores; | 55 | /* Setup CPU & memory */ |
50 | ms->possible_cpus->cpus[n].props.has_thread_id = true; | 56 | mpu = pxa270_init(mainstone_binfo.ram_size, machine->cpu_type); |
51 | - ms->possible_cpus->cpus[n].props.thread_id = n; | 57 | - memory_region_init_rom(rom, NULL, "mainstone.rom", MAINSTONE_ROM, |
52 | + ms->possible_cpus->cpus[n].props.thread_id = | 58 | + memory_region_init_rom(rom, NULL, "mainstone.rom", MAINSTONE_ROM_SIZE, |
53 | + n % ms->smp.threads; | 59 | &error_fatal); |
54 | } | 60 | memory_region_add_subregion(get_system_memory(), 0x00000000, rom); |
55 | return ms->possible_cpus; | 61 | |
56 | } | 62 | @@ -XXX,XX +XXX,XX @@ static void mainstone_common_init(MachineState *machine, |
63 | dinfo = drive_get(IF_PFLASH, 0, i); | ||
64 | if (!pflash_cfi01_register(mainstone_flash_base[i], | ||
65 | i ? "mainstone.flash1" : "mainstone.flash0", | ||
66 | - MAINSTONE_FLASH, | ||
67 | + MAINSTONE_FLASH_SIZE, | ||
68 | dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, | ||
69 | - sector_len, 4, 0, 0, 0, 0, 0)) { | ||
70 | + FLASH_SECTOR_SIZE, 4, 0, 0, 0, 0, 0)) { | ||
71 | error_report("Error registering flash memory"); | ||
72 | exit(1); | ||
73 | } | ||
57 | -- | 74 | -- |
58 | 2.25.1 | 75 | 2.34.1 |
76 | |||
77 | diff view generated by jsdifflib |
1 | From: Gavin Shan <gshan@redhat.com> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | This adds cluster-id in CPU instance properties, which will be used | 3 | IEC binary prefixes ease code review: the unit is explicit. |
4 | by arm/virt machine. Besides, the cluster-id is also verified or | ||
5 | dumped in various spots: | ||
6 | 4 | ||
7 | * hw/core/machine.c::machine_set_cpu_numa_node() to associate | 5 | Add the FLASH_SECTOR_SIZE definition. |
8 | CPU with its NUMA node. | ||
9 | 6 | ||
10 | * hw/core/machine.c::machine_numa_finish_cpu_init() to record | 7 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
11 | CPU slots with no NUMA mapping set. | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
12 | 9 | Message-id: 20230109115316.2235-9-philmd@linaro.org | |
13 | * hw/core/machine-hmp-cmds.c::hmp_hotpluggable_cpus() to dump | ||
14 | cluster-id. | ||
15 | |||
16 | Signed-off-by: Gavin Shan <gshan@redhat.com> | ||
17 | Reviewed-by: Yanan Wang <wangyanan55@huawei.com> | ||
18 | Acked-by: Igor Mammedov <imammedo@redhat.com> | ||
19 | Message-id: 20220503140304.855514-2-gshan@redhat.com | ||
20 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
21 | --- | 11 | --- |
22 | qapi/machine.json | 6 ++++-- | 12 | hw/arm/musicpal.c | 9 ++++++--- |
23 | hw/core/machine-hmp-cmds.c | 4 ++++ | 13 | 1 file changed, 6 insertions(+), 3 deletions(-) |
24 | hw/core/machine.c | 16 ++++++++++++++++ | ||
25 | 3 files changed, 24 insertions(+), 2 deletions(-) | ||
26 | 14 | ||
27 | diff --git a/qapi/machine.json b/qapi/machine.json | 15 | diff --git a/hw/arm/musicpal.c b/hw/arm/musicpal.c |
28 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
29 | --- a/qapi/machine.json | 17 | --- a/hw/arm/musicpal.c |
30 | +++ b/qapi/machine.json | 18 | +++ b/hw/arm/musicpal.c |
31 | @@ -XXX,XX +XXX,XX @@ | 19 | @@ -XXX,XX +XXX,XX @@ |
32 | # @node-id: NUMA node ID the CPU belongs to | 20 | */ |
33 | # @socket-id: socket number within node/board the CPU belongs to | 21 | |
34 | # @die-id: die number within socket the CPU belongs to (since 4.1) | 22 | #include "qemu/osdep.h" |
35 | -# @core-id: core number within die the CPU belongs to | 23 | +#include "qemu/units.h" |
36 | +# @cluster-id: cluster number within die the CPU belongs to (since 7.1) | 24 | #include "qapi/error.h" |
37 | +# @core-id: core number within cluster the CPU belongs to | 25 | #include "cpu.h" |
38 | # @thread-id: thread number within core the CPU belongs to | 26 | #include "hw/sysbus.h" |
39 | # | 27 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo musicpal_key_info = { |
40 | -# Note: currently there are 5 properties that could be present | 28 | .class_init = musicpal_key_class_init, |
41 | +# Note: currently there are 6 properties that could be present | 29 | }; |
42 | # but management should be prepared to pass through other | 30 | |
43 | # properties with device_add command to allow for future | 31 | +#define FLASH_SECTOR_SIZE (64 * KiB) |
44 | # interface extension. This also requires the filed names to be kept in | 32 | + |
45 | @@ -XXX,XX +XXX,XX @@ | 33 | static struct arm_boot_info musicpal_binfo = { |
46 | 'data': { '*node-id': 'int', | 34 | .loader_start = 0x0, |
47 | '*socket-id': 'int', | 35 | .board_id = 0x20e, |
48 | '*die-id': 'int', | 36 | @@ -XXX,XX +XXX,XX @@ static void musicpal_init(MachineState *machine) |
49 | + '*cluster-id': 'int', | 37 | BlockBackend *blk = blk_by_legacy_dinfo(dinfo); |
50 | '*core-id': 'int', | 38 | |
51 | '*thread-id': 'int' | 39 | flash_size = blk_getlength(blk); |
52 | } | 40 | - if (flash_size != 8*1024*1024 && flash_size != 16*1024*1024 && |
53 | diff --git a/hw/core/machine-hmp-cmds.c b/hw/core/machine-hmp-cmds.c | 41 | - flash_size != 32*1024*1024) { |
54 | index XXXXXXX..XXXXXXX 100644 | 42 | + if (flash_size != 8 * MiB && flash_size != 16 * MiB && |
55 | --- a/hw/core/machine-hmp-cmds.c | 43 | + flash_size != 32 * MiB) { |
56 | +++ b/hw/core/machine-hmp-cmds.c | 44 | error_report("Invalid flash image size"); |
57 | @@ -XXX,XX +XXX,XX @@ void hmp_hotpluggable_cpus(Monitor *mon, const QDict *qdict) | 45 | exit(1); |
58 | if (c->has_die_id) { | ||
59 | monitor_printf(mon, " die-id: \"%" PRIu64 "\"\n", c->die_id); | ||
60 | } | 46 | } |
61 | + if (c->has_cluster_id) { | 47 | @@ -XXX,XX +XXX,XX @@ static void musicpal_init(MachineState *machine) |
62 | + monitor_printf(mon, " cluster-id: \"%" PRIu64 "\"\n", | 48 | */ |
63 | + c->cluster_id); | 49 | pflash_cfi02_register(0x100000000ULL - MP_FLASH_SIZE_MAX, |
64 | + } | 50 | "musicpal.flash", flash_size, |
65 | if (c->has_core_id) { | 51 | - blk, 0x10000, |
66 | monitor_printf(mon, " core-id: \"%" PRIu64 "\"\n", c->core_id); | 52 | + blk, FLASH_SECTOR_SIZE, |
67 | } | 53 | MP_FLASH_SIZE_MAX / flash_size, |
68 | diff --git a/hw/core/machine.c b/hw/core/machine.c | 54 | 2, 0x00BF, 0x236D, 0x0000, 0x0000, |
69 | index XXXXXXX..XXXXXXX 100644 | 55 | 0x5555, 0x2AAA, 0); |
70 | --- a/hw/core/machine.c | ||
71 | +++ b/hw/core/machine.c | ||
72 | @@ -XXX,XX +XXX,XX @@ void machine_set_cpu_numa_node(MachineState *machine, | ||
73 | return; | ||
74 | } | ||
75 | |||
76 | + if (props->has_cluster_id && !slot->props.has_cluster_id) { | ||
77 | + error_setg(errp, "cluster-id is not supported"); | ||
78 | + return; | ||
79 | + } | ||
80 | + | ||
81 | if (props->has_socket_id && !slot->props.has_socket_id) { | ||
82 | error_setg(errp, "socket-id is not supported"); | ||
83 | return; | ||
84 | @@ -XXX,XX +XXX,XX @@ void machine_set_cpu_numa_node(MachineState *machine, | ||
85 | continue; | ||
86 | } | ||
87 | |||
88 | + if (props->has_cluster_id && | ||
89 | + props->cluster_id != slot->props.cluster_id) { | ||
90 | + continue; | ||
91 | + } | ||
92 | + | ||
93 | if (props->has_die_id && props->die_id != slot->props.die_id) { | ||
94 | continue; | ||
95 | } | ||
96 | @@ -XXX,XX +XXX,XX @@ static char *cpu_slot_to_string(const CPUArchId *cpu) | ||
97 | } | ||
98 | g_string_append_printf(s, "die-id: %"PRId64, cpu->props.die_id); | ||
99 | } | ||
100 | + if (cpu->props.has_cluster_id) { | ||
101 | + if (s->len) { | ||
102 | + g_string_append_printf(s, ", "); | ||
103 | + } | ||
104 | + g_string_append_printf(s, "cluster-id: %"PRId64, cpu->props.cluster_id); | ||
105 | + } | ||
106 | if (cpu->props.has_core_id) { | ||
107 | if (s->len) { | ||
108 | g_string_append_printf(s, ", "); | ||
109 | -- | 56 | -- |
110 | 2.25.1 | 57 | 2.34.1 |
58 | |||
59 | diff view generated by jsdifflib |
1 | From: Leif Lindholm <quic_llindhol@quicinc.com> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | The sbsa-ref machine is continuously evolving. Some of the changes we | 3 | The total_ram_v1/total_ram_v2 definitions were never used. |
4 | want to make in the near future, to align with real components (e.g. | ||
5 | the GIC-700), will break compatibility for existing firmware. | ||
6 | 4 | ||
7 | Introduce two new properties to the DT generated on machine generation: | 5 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
8 | - machine-version-major | 6 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
9 | To be incremented when a platform change makes the machine | 7 | Message-id: 20230109115316.2235-10-philmd@linaro.org |
10 | incompatible with existing firmware. | ||
11 | - machine-version-minor | ||
12 | To be incremented when functionality is added to the machine | ||
13 | without causing incompatibility with existing firmware. | ||
14 | to be reset to 0 when machine-version-major is incremented. | ||
15 | |||
16 | This versioning scheme is *neither*: | ||
17 | - A QEMU versioned machine type; a given version of QEMU will emulate | ||
18 | a given version of the platform. | ||
19 | - A reflection of level of SBSA (now SystemReady SR) support provided. | ||
20 | |||
21 | The version will increment on guest-visible functional changes only, | ||
22 | akin to a revision ID register found on a physical platform. | ||
23 | |||
24 | These properties are both introduced with the value 0. | ||
25 | (Hence, a machine where the DT is lacking these nodes is equivalent | ||
26 | to version 0.0.) | ||
27 | |||
28 | Signed-off-by: Leif Lindholm <quic_llindhol@quicinc.com> | ||
29 | Message-id: 20220505113947.75714-1-quic_llindhol@quicinc.com | ||
30 | Cc: Peter Maydell <peter.maydell@linaro.org> | ||
31 | Cc: Radoslaw Biernacki <rad@semihalf.com> | ||
32 | Cc: Cédric Le Goater <clg@kaod.org> | ||
33 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
34 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 8 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
35 | --- | 9 | --- |
36 | hw/arm/sbsa-ref.c | 14 ++++++++++++++ | 10 | hw/arm/omap_sx1.c | 2 -- |
37 | 1 file changed, 14 insertions(+) | 11 | 1 file changed, 2 deletions(-) |
38 | 12 | ||
39 | diff --git a/hw/arm/sbsa-ref.c b/hw/arm/sbsa-ref.c | 13 | diff --git a/hw/arm/omap_sx1.c b/hw/arm/omap_sx1.c |
40 | index XXXXXXX..XXXXXXX 100644 | 14 | index XXXXXXX..XXXXXXX 100644 |
41 | --- a/hw/arm/sbsa-ref.c | 15 | --- a/hw/arm/omap_sx1.c |
42 | +++ b/hw/arm/sbsa-ref.c | 16 | +++ b/hw/arm/omap_sx1.c |
43 | @@ -XXX,XX +XXX,XX @@ static void create_fdt(SBSAMachineState *sms) | 17 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps static_ops = { |
44 | qemu_fdt_setprop_cell(fdt, "/", "#address-cells", 0x2); | 18 | #define flash0_size (16 * 1024 * 1024) |
45 | qemu_fdt_setprop_cell(fdt, "/", "#size-cells", 0x2); | 19 | #define flash1_size ( 8 * 1024 * 1024) |
46 | 20 | #define flash2_size (32 * 1024 * 1024) | |
47 | + /* | 21 | -#define total_ram_v1 (sdram_size + flash0_size + flash1_size + OMAP15XX_SRAM_SIZE) |
48 | + * This versioning scheme is for informing platform fw only. It is neither: | 22 | -#define total_ram_v2 (sdram_size + flash2_size + OMAP15XX_SRAM_SIZE) |
49 | + * - A QEMU versioned machine type; a given version of QEMU will emulate | 23 | |
50 | + * a given version of the platform. | 24 | static struct arm_boot_info sx1_binfo = { |
51 | + * - A reflection of level of SBSA (now SystemReady SR) support provided. | 25 | .loader_start = OMAP_EMIFF_BASE, |
52 | + * | ||
53 | + * machine-version-major: updated when changes breaking fw compatibility | ||
54 | + * are introduced. | ||
55 | + * machine-version-minor: updated when features are added that don't break | ||
56 | + * fw compatibility. | ||
57 | + */ | ||
58 | + qemu_fdt_setprop_cell(fdt, "/", "machine-version-major", 0); | ||
59 | + qemu_fdt_setprop_cell(fdt, "/", "machine-version-minor", 0); | ||
60 | + | ||
61 | if (ms->numa_state->have_numa_distance) { | ||
62 | int size = nb_numa_nodes * nb_numa_nodes * 3 * sizeof(uint32_t); | ||
63 | uint32_t *matrix = g_malloc0(size); | ||
64 | -- | 26 | -- |
65 | 2.25.1 | 27 | 2.34.1 |
66 | 28 | ||
67 | 29 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Enable the n1 for virt and sbsa board use. | 3 | IEC binary prefixes ease code review: the unit is explicit. |
4 | 4 | ||
5 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 5 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
6 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 6 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
7 | Message-id: 20220506180242.216785-25-richard.henderson@linaro.org | 7 | Message-id: 20230109115316.2235-11-philmd@linaro.org |
8 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 8 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
9 | --- | 9 | --- |
10 | docs/system/arm/virt.rst | 1 + | 10 | hw/arm/omap_sx1.c | 33 +++++++++++++++++---------------- |
11 | hw/arm/sbsa-ref.c | 1 + | 11 | 1 file changed, 17 insertions(+), 16 deletions(-) |
12 | hw/arm/virt.c | 1 + | ||
13 | target/arm/cpu64.c | 66 ++++++++++++++++++++++++++++++++++++++++ | ||
14 | 4 files changed, 69 insertions(+) | ||
15 | 12 | ||
16 | diff --git a/docs/system/arm/virt.rst b/docs/system/arm/virt.rst | 13 | diff --git a/hw/arm/omap_sx1.c b/hw/arm/omap_sx1.c |
17 | index XXXXXXX..XXXXXXX 100644 | 14 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/docs/system/arm/virt.rst | 15 | --- a/hw/arm/omap_sx1.c |
19 | +++ b/docs/system/arm/virt.rst | 16 | +++ b/hw/arm/omap_sx1.c |
20 | @@ -XXX,XX +XXX,XX @@ Supported guest CPU types: | 17 | @@ -XXX,XX +XXX,XX @@ |
21 | - ``cortex-a76`` (64-bit) | 18 | * with this program; if not, see <http://www.gnu.org/licenses/>. |
22 | - ``a64fx`` (64-bit) | 19 | */ |
23 | - ``host`` (with KVM only) | 20 | #include "qemu/osdep.h" |
24 | +- ``neoverse-n1`` (64-bit) | 21 | +#include "qemu/units.h" |
25 | - ``max`` (same as ``host`` for KVM; best possible emulation with TCG) | 22 | #include "qapi/error.h" |
26 | 23 | #include "ui/console.h" | |
27 | Note that the default is ``cortex-a15``, so for an AArch64 guest you must | 24 | #include "hw/arm/omap.h" |
28 | diff --git a/hw/arm/sbsa-ref.c b/hw/arm/sbsa-ref.c | 25 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps static_ops = { |
29 | index XXXXXXX..XXXXXXX 100644 | 26 | .endianness = DEVICE_NATIVE_ENDIAN, |
30 | --- a/hw/arm/sbsa-ref.c | ||
31 | +++ b/hw/arm/sbsa-ref.c | ||
32 | @@ -XXX,XX +XXX,XX @@ static const char * const valid_cpus[] = { | ||
33 | ARM_CPU_TYPE_NAME("cortex-a57"), | ||
34 | ARM_CPU_TYPE_NAME("cortex-a72"), | ||
35 | ARM_CPU_TYPE_NAME("cortex-a76"), | ||
36 | + ARM_CPU_TYPE_NAME("neoverse-n1"), | ||
37 | ARM_CPU_TYPE_NAME("max"), | ||
38 | }; | 27 | }; |
39 | 28 | ||
40 | diff --git a/hw/arm/virt.c b/hw/arm/virt.c | 29 | -#define sdram_size 0x02000000 |
41 | index XXXXXXX..XXXXXXX 100644 | 30 | -#define sector_size (128 * 1024) |
42 | --- a/hw/arm/virt.c | 31 | -#define flash0_size (16 * 1024 * 1024) |
43 | +++ b/hw/arm/virt.c | 32 | -#define flash1_size ( 8 * 1024 * 1024) |
44 | @@ -XXX,XX +XXX,XX @@ static const char *valid_cpus[] = { | 33 | -#define flash2_size (32 * 1024 * 1024) |
45 | ARM_CPU_TYPE_NAME("cortex-a72"), | 34 | +#define SDRAM_SIZE (32 * MiB) |
46 | ARM_CPU_TYPE_NAME("cortex-a76"), | 35 | +#define SECTOR_SIZE (128 * KiB) |
47 | ARM_CPU_TYPE_NAME("a64fx"), | 36 | +#define FLASH0_SIZE (16 * MiB) |
48 | + ARM_CPU_TYPE_NAME("neoverse-n1"), | 37 | +#define FLASH1_SIZE (8 * MiB) |
49 | ARM_CPU_TYPE_NAME("host"), | 38 | +#define FLASH2_SIZE (32 * MiB) |
50 | ARM_CPU_TYPE_NAME("max"), | 39 | |
40 | static struct arm_boot_info sx1_binfo = { | ||
41 | .loader_start = OMAP_EMIFF_BASE, | ||
42 | - .ram_size = sdram_size, | ||
43 | + .ram_size = SDRAM_SIZE, | ||
44 | .board_id = 0x265, | ||
51 | }; | 45 | }; |
52 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 46 | |
53 | index XXXXXXX..XXXXXXX 100644 | 47 | @@ -XXX,XX +XXX,XX @@ static void sx1_init(MachineState *machine, const int version) |
54 | --- a/target/arm/cpu64.c | 48 | static uint32_t cs3val = 0x00001139; |
55 | +++ b/target/arm/cpu64.c | 49 | DriveInfo *dinfo; |
56 | @@ -XXX,XX +XXX,XX @@ static void aarch64_a76_initfn(Object *obj) | 50 | int fl_idx; |
57 | cpu->isar.mvfr2 = 0x00000043; | 51 | - uint32_t flash_size = flash0_size; |
52 | + uint32_t flash_size = FLASH0_SIZE; | ||
53 | |||
54 | if (machine->ram_size != mc->default_ram_size) { | ||
55 | char *sz = size_to_str(mc->default_ram_size); | ||
56 | @@ -XXX,XX +XXX,XX @@ static void sx1_init(MachineState *machine, const int version) | ||
57 | } | ||
58 | |||
59 | if (version == 2) { | ||
60 | - flash_size = flash2_size; | ||
61 | + flash_size = FLASH2_SIZE; | ||
62 | } | ||
63 | |||
64 | memory_region_add_subregion(address_space, OMAP_EMIFF_BASE, machine->ram); | ||
65 | @@ -XXX,XX +XXX,XX @@ static void sx1_init(MachineState *machine, const int version) | ||
66 | if (!pflash_cfi01_register(OMAP_CS0_BASE, | ||
67 | "omap_sx1.flash0-1", flash_size, | ||
68 | blk_by_legacy_dinfo(dinfo), | ||
69 | - sector_size, 4, 0, 0, 0, 0, 0)) { | ||
70 | + SECTOR_SIZE, 4, 0, 0, 0, 0, 0)) { | ||
71 | fprintf(stderr, "qemu: Error registering flash memory %d.\n", | ||
72 | fl_idx); | ||
73 | } | ||
74 | @@ -XXX,XX +XXX,XX @@ static void sx1_init(MachineState *machine, const int version) | ||
75 | (dinfo = drive_get(IF_PFLASH, 0, fl_idx)) != NULL) { | ||
76 | MemoryRegion *flash_1 = g_new(MemoryRegion, 1); | ||
77 | memory_region_init_rom(flash_1, NULL, "omap_sx1.flash1-0", | ||
78 | - flash1_size, &error_fatal); | ||
79 | + FLASH1_SIZE, &error_fatal); | ||
80 | memory_region_add_subregion(address_space, OMAP_CS1_BASE, flash_1); | ||
81 | |||
82 | memory_region_init_io(&cs[1], NULL, &static_ops, &cs1val, | ||
83 | - "sx1.cs1", OMAP_CS1_SIZE - flash1_size); | ||
84 | + "sx1.cs1", OMAP_CS1_SIZE - FLASH1_SIZE); | ||
85 | memory_region_add_subregion(address_space, | ||
86 | - OMAP_CS1_BASE + flash1_size, &cs[1]); | ||
87 | + OMAP_CS1_BASE + FLASH1_SIZE, &cs[1]); | ||
88 | |||
89 | if (!pflash_cfi01_register(OMAP_CS1_BASE, | ||
90 | - "omap_sx1.flash1-1", flash1_size, | ||
91 | + "omap_sx1.flash1-1", FLASH1_SIZE, | ||
92 | blk_by_legacy_dinfo(dinfo), | ||
93 | - sector_size, 4, 0, 0, 0, 0, 0)) { | ||
94 | + SECTOR_SIZE, 4, 0, 0, 0, 0, 0)) { | ||
95 | fprintf(stderr, "qemu: Error registering flash memory %d.\n", | ||
96 | fl_idx); | ||
97 | } | ||
98 | @@ -XXX,XX +XXX,XX @@ static void sx1_machine_v2_class_init(ObjectClass *oc, void *data) | ||
99 | mc->init = sx1_init_v2; | ||
100 | mc->ignore_memory_transaction_failures = true; | ||
101 | mc->default_cpu_type = ARM_CPU_TYPE_NAME("ti925t"); | ||
102 | - mc->default_ram_size = sdram_size; | ||
103 | + mc->default_ram_size = SDRAM_SIZE; | ||
104 | mc->default_ram_id = "omap1.dram"; | ||
58 | } | 105 | } |
59 | 106 | ||
60 | +static void aarch64_neoverse_n1_initfn(Object *obj) | 107 | @@ -XXX,XX +XXX,XX @@ static void sx1_machine_v1_class_init(ObjectClass *oc, void *data) |
61 | +{ | 108 | mc->init = sx1_init_v1; |
62 | + ARMCPU *cpu = ARM_CPU(obj); | 109 | mc->ignore_memory_transaction_failures = true; |
63 | + | 110 | mc->default_cpu_type = ARM_CPU_TYPE_NAME("ti925t"); |
64 | + cpu->dtb_compatible = "arm,neoverse-n1"; | 111 | - mc->default_ram_size = sdram_size; |
65 | + set_feature(&cpu->env, ARM_FEATURE_V8); | 112 | + mc->default_ram_size = SDRAM_SIZE; |
66 | + set_feature(&cpu->env, ARM_FEATURE_NEON); | 113 | mc->default_ram_id = "omap1.dram"; |
67 | + set_feature(&cpu->env, ARM_FEATURE_GENERIC_TIMER); | 114 | } |
68 | + set_feature(&cpu->env, ARM_FEATURE_AARCH64); | 115 | |
69 | + set_feature(&cpu->env, ARM_FEATURE_CBAR_RO); | ||
70 | + set_feature(&cpu->env, ARM_FEATURE_EL2); | ||
71 | + set_feature(&cpu->env, ARM_FEATURE_EL3); | ||
72 | + set_feature(&cpu->env, ARM_FEATURE_PMU); | ||
73 | + | ||
74 | + /* Ordered by B2.4 AArch64 registers by functional group */ | ||
75 | + cpu->clidr = 0x82000023; | ||
76 | + cpu->ctr = 0x8444c004; | ||
77 | + cpu->dcz_blocksize = 4; | ||
78 | + cpu->isar.id_aa64dfr0 = 0x0000000110305408ull; | ||
79 | + cpu->isar.id_aa64isar0 = 0x0000100010211120ull; | ||
80 | + cpu->isar.id_aa64isar1 = 0x0000000000100001ull; | ||
81 | + cpu->isar.id_aa64mmfr0 = 0x0000000000101125ull; | ||
82 | + cpu->isar.id_aa64mmfr1 = 0x0000000010212122ull; | ||
83 | + cpu->isar.id_aa64mmfr2 = 0x0000000000001011ull; | ||
84 | + cpu->isar.id_aa64pfr0 = 0x1100000010111112ull; /* GIC filled in later */ | ||
85 | + cpu->isar.id_aa64pfr1 = 0x0000000000000020ull; | ||
86 | + cpu->id_afr0 = 0x00000000; | ||
87 | + cpu->isar.id_dfr0 = 0x04010088; | ||
88 | + cpu->isar.id_isar0 = 0x02101110; | ||
89 | + cpu->isar.id_isar1 = 0x13112111; | ||
90 | + cpu->isar.id_isar2 = 0x21232042; | ||
91 | + cpu->isar.id_isar3 = 0x01112131; | ||
92 | + cpu->isar.id_isar4 = 0x00010142; | ||
93 | + cpu->isar.id_isar5 = 0x01011121; | ||
94 | + cpu->isar.id_isar6 = 0x00000010; | ||
95 | + cpu->isar.id_mmfr0 = 0x10201105; | ||
96 | + cpu->isar.id_mmfr1 = 0x40000000; | ||
97 | + cpu->isar.id_mmfr2 = 0x01260000; | ||
98 | + cpu->isar.id_mmfr3 = 0x02122211; | ||
99 | + cpu->isar.id_mmfr4 = 0x00021110; | ||
100 | + cpu->isar.id_pfr0 = 0x10010131; | ||
101 | + cpu->isar.id_pfr1 = 0x00010000; /* GIC filled in later */ | ||
102 | + cpu->isar.id_pfr2 = 0x00000011; | ||
103 | + cpu->midr = 0x414fd0c1; /* r4p1 */ | ||
104 | + cpu->revidr = 0; | ||
105 | + | ||
106 | + /* From B2.23 CCSIDR_EL1 */ | ||
107 | + cpu->ccsidr[0] = 0x701fe01a; /* 64KB L1 dcache */ | ||
108 | + cpu->ccsidr[1] = 0x201fe01a; /* 64KB L1 icache */ | ||
109 | + cpu->ccsidr[2] = 0x70ffe03a; /* 1MB L2 cache */ | ||
110 | + | ||
111 | + /* From B2.98 SCTLR_EL3 */ | ||
112 | + cpu->reset_sctlr = 0x30c50838; | ||
113 | + | ||
114 | + /* From B4.23 ICH_VTR_EL2 */ | ||
115 | + cpu->gic_num_lrs = 4; | ||
116 | + cpu->gic_vpribits = 5; | ||
117 | + cpu->gic_vprebits = 5; | ||
118 | + | ||
119 | + /* From B5.1 AdvSIMD AArch64 register summary */ | ||
120 | + cpu->isar.mvfr0 = 0x10110222; | ||
121 | + cpu->isar.mvfr1 = 0x13211111; | ||
122 | + cpu->isar.mvfr2 = 0x00000043; | ||
123 | +} | ||
124 | + | ||
125 | void arm_cpu_sve_finalize(ARMCPU *cpu, Error **errp) | ||
126 | { | ||
127 | /* | ||
128 | @@ -XXX,XX +XXX,XX @@ static const ARMCPUInfo aarch64_cpus[] = { | ||
129 | { .name = "cortex-a72", .initfn = aarch64_a72_initfn }, | ||
130 | { .name = "cortex-a76", .initfn = aarch64_a76_initfn }, | ||
131 | { .name = "a64fx", .initfn = aarch64_a64fx_initfn }, | ||
132 | + { .name = "neoverse-n1", .initfn = aarch64_neoverse_n1_initfn }, | ||
133 | { .name = "max", .initfn = aarch64_max_initfn }, | ||
134 | #if defined(CONFIG_KVM) || defined(CONFIG_HVF) | ||
135 | { .name = "host", .initfn = aarch64_host_initfn }, | ||
136 | -- | 116 | -- |
137 | 2.25.1 | 117 | 2.34.1 |
118 | |||
119 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | This register is present for either VHE or Debugv8p2. | 3 | IEC binary prefixes ease code review: the unit is explicit. |
4 | 4 | ||
5 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 5 | Add the FLASH_SECTOR_SIZE definition. |
6 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 6 | |
7 | Message-id: 20220506180242.216785-5-richard.henderson@linaro.org | 7 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
9 | Message-id: 20230109115316.2235-12-philmd@linaro.org | ||
8 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
9 | --- | 11 | --- |
10 | target/arm/helper.c | 15 +++++++++++---- | 12 | hw/arm/z2.c | 6 ++++-- |
11 | 1 file changed, 11 insertions(+), 4 deletions(-) | 13 | 1 file changed, 4 insertions(+), 2 deletions(-) |
12 | 14 | ||
13 | diff --git a/target/arm/helper.c b/target/arm/helper.c | 15 | diff --git a/hw/arm/z2.c b/hw/arm/z2.c |
14 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
15 | --- a/target/arm/helper.c | 17 | --- a/hw/arm/z2.c |
16 | +++ b/target/arm/helper.c | 18 | +++ b/hw/arm/z2.c |
17 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo jazelle_regs[] = { | 19 | @@ -XXX,XX +XXX,XX @@ |
18 | .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 }, | 20 | */ |
21 | |||
22 | #include "qemu/osdep.h" | ||
23 | +#include "qemu/units.h" | ||
24 | #include "hw/arm/pxa.h" | ||
25 | #include "hw/arm/boot.h" | ||
26 | #include "hw/i2c/i2c.h" | ||
27 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo aer915_info = { | ||
28 | .class_init = aer915_class_init, | ||
19 | }; | 29 | }; |
20 | 30 | ||
21 | +static const ARMCPRegInfo contextidr_el2 = { | 31 | +#define FLASH_SECTOR_SIZE (64 * KiB) |
22 | + .name = "CONTEXTIDR_EL2", .state = ARM_CP_STATE_AA64, | ||
23 | + .opc0 = 3, .opc1 = 4, .crn = 13, .crm = 0, .opc2 = 1, | ||
24 | + .access = PL2_RW, | ||
25 | + .fieldoffset = offsetof(CPUARMState, cp15.contextidr_el[2]) | ||
26 | +}; | ||
27 | + | 32 | + |
28 | static const ARMCPRegInfo vhe_reginfo[] = { | 33 | static void z2_init(MachineState *machine) |
29 | - { .name = "CONTEXTIDR_EL2", .state = ARM_CP_STATE_AA64, | 34 | { |
30 | - .opc0 = 3, .opc1 = 4, .crn = 13, .crm = 0, .opc2 = 1, | 35 | - uint32_t sector_len = 0x10000; |
31 | - .access = PL2_RW, | 36 | PXA2xxState *mpu; |
32 | - .fieldoffset = offsetof(CPUARMState, cp15.contextidr_el[2]) }, | 37 | DriveInfo *dinfo; |
33 | { .name = "TTBR1_EL2", .state = ARM_CP_STATE_AA64, | 38 | void *z2_lcd; |
34 | .opc0 = 3, .opc1 = 4, .crn = 2, .crm = 0, .opc2 = 1, | 39 | @@ -XXX,XX +XXX,XX @@ static void z2_init(MachineState *machine) |
35 | .access = PL2_RW, .writefn = vmsa_tcr_ttbr_el2_write, | 40 | dinfo = drive_get(IF_PFLASH, 0, 0); |
36 | @@ -XXX,XX +XXX,XX @@ void register_cp_regs_for_features(ARMCPU *cpu) | 41 | if (!pflash_cfi01_register(Z2_FLASH_BASE, "z2.flash0", Z2_FLASH_SIZE, |
37 | define_one_arm_cp_reg(cpu, &ssbs_reginfo); | 42 | dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
38 | } | 43 | - sector_len, 4, 0, 0, 0, 0, 0)) { |
39 | 44 | + FLASH_SECTOR_SIZE, 4, 0, 0, 0, 0, 0)) { | |
40 | + if (cpu_isar_feature(aa64_vh, cpu) || | 45 | error_report("Error registering flash memory"); |
41 | + cpu_isar_feature(aa64_debugv8p2, cpu)) { | 46 | exit(1); |
42 | + define_one_arm_cp_reg(cpu, &contextidr_el2); | ||
43 | + } | ||
44 | if (arm_feature(env, ARM_FEATURE_EL2) && cpu_isar_feature(aa64_vh, cpu)) { | ||
45 | define_arm_cp_regs(cpu, vhe_reginfo); | ||
46 | } | 47 | } |
47 | -- | 48 | -- |
48 | 2.25.1 | 49 | 2.34.1 |
50 | |||
51 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | This extension concerns branch speculation, which TCG does | 3 | Upon introduction in commit b8433303fb ("Set proper device-width |
4 | not implement. Thus we can trivially enable this feature. | 4 | for vexpress flash"), ve_pflash_cfi01_register() was calling |
5 | qdev_init_nofail() which can not fail. This call was later | ||
6 | converted with a script to use &error_fatal, still unable to | ||
7 | fail. Remove the unreachable code. | ||
5 | 8 | ||
6 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 9 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
7 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 10 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
8 | Message-id: 20220506180242.216785-20-richard.henderson@linaro.org | 11 | Message-id: 20230109115316.2235-13-philmd@linaro.org |
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 12 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
10 | --- | 13 | --- |
11 | docs/system/arm/emulation.rst | 1 + | 14 | hw/arm/vexpress.c | 10 +--------- |
12 | target/arm/cpu64.c | 1 + | 15 | 1 file changed, 1 insertion(+), 9 deletions(-) |
13 | target/arm/cpu_tcg.c | 1 + | ||
14 | 3 files changed, 3 insertions(+) | ||
15 | 16 | ||
16 | diff --git a/docs/system/arm/emulation.rst b/docs/system/arm/emulation.rst | 17 | diff --git a/hw/arm/vexpress.c b/hw/arm/vexpress.c |
17 | index XXXXXXX..XXXXXXX 100644 | 18 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/docs/system/arm/emulation.rst | 19 | --- a/hw/arm/vexpress.c |
19 | +++ b/docs/system/arm/emulation.rst | 20 | +++ b/hw/arm/vexpress.c |
20 | @@ -XXX,XX +XXX,XX @@ the following architecture extensions: | 21 | @@ -XXX,XX +XXX,XX @@ static void vexpress_common_init(MachineState *machine) |
21 | - FEAT_BBM at level 2 (Translation table break-before-make levels) | 22 | dinfo = drive_get(IF_PFLASH, 0, 0); |
22 | - FEAT_BF16 (AArch64 BFloat16 instructions) | 23 | pflash0 = ve_pflash_cfi01_register(map[VE_NORFLASH0], "vexpress.flash0", |
23 | - FEAT_BTI (Branch Target Identification) | 24 | dinfo); |
24 | +- FEAT_CSV2 (Cache speculation variant 2) | 25 | - if (!pflash0) { |
25 | - FEAT_DIT (Data Independent Timing instructions) | 26 | - error_report("vexpress: error registering flash 0"); |
26 | - FEAT_DPB (DC CVAP instruction) | 27 | - exit(1); |
27 | - FEAT_Debugv8p2 (Debug changes for v8.2) | 28 | - } |
28 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 29 | |
29 | index XXXXXXX..XXXXXXX 100644 | 30 | if (map[VE_NORFLASHALIAS] != -1) { |
30 | --- a/target/arm/cpu64.c | 31 | /* Map flash 0 as an alias into low memory */ |
31 | +++ b/target/arm/cpu64.c | 32 | @@ -XXX,XX +XXX,XX @@ static void vexpress_common_init(MachineState *machine) |
32 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | 33 | } |
33 | t = FIELD_DP64(t, ID_AA64PFR0, SVE, 1); | 34 | |
34 | t = FIELD_DP64(t, ID_AA64PFR0, SEL2, 1); /* FEAT_SEL2 */ | 35 | dinfo = drive_get(IF_PFLASH, 0, 1); |
35 | t = FIELD_DP64(t, ID_AA64PFR0, DIT, 1); /* FEAT_DIT */ | 36 | - if (!ve_pflash_cfi01_register(map[VE_NORFLASH1], "vexpress.flash1", |
36 | + t = FIELD_DP64(t, ID_AA64PFR0, CSV2, 1); /* FEAT_CSV2 */ | 37 | - dinfo)) { |
37 | cpu->isar.id_aa64pfr0 = t; | 38 | - error_report("vexpress: error registering flash 1"); |
38 | 39 | - exit(1); | |
39 | t = cpu->isar.id_aa64pfr1; | 40 | - } |
40 | diff --git a/target/arm/cpu_tcg.c b/target/arm/cpu_tcg.c | 41 | + ve_pflash_cfi01_register(map[VE_NORFLASH1], "vexpress.flash1", dinfo); |
41 | index XXXXXXX..XXXXXXX 100644 | 42 | |
42 | --- a/target/arm/cpu_tcg.c | 43 | sram_size = 0x2000000; |
43 | +++ b/target/arm/cpu_tcg.c | 44 | memory_region_init_ram(sram, NULL, "vexpress.sram", sram_size, |
44 | @@ -XXX,XX +XXX,XX @@ void aa32_max_features(ARMCPU *cpu) | ||
45 | cpu->isar.id_mmfr4 = t; | ||
46 | |||
47 | t = cpu->isar.id_pfr0; | ||
48 | + t = FIELD_DP32(t, ID_PFR0, CSV2, 2); /* FEAT_CVS2 */ | ||
49 | t = FIELD_DP32(t, ID_PFR0, DIT, 1); /* FEAT_DIT */ | ||
50 | t = FIELD_DP32(t, ID_PFR0, RAS, 1); /* FEAT_RAS */ | ||
51 | cpu->isar.id_pfr0 = t; | ||
52 | -- | 45 | -- |
53 | 2.25.1 | 46 | 2.34.1 |
47 | |||
48 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Use FIELD_DP{32,64} to manipulate id_pfr1 and id_aa64pfr0 | 3 | Since its QOM'ification in commit 368a354f02 ("pflash_cfi0x: |
4 | during arm_cpu_realizefn. | 4 | QOMified") the pflash_cfi01_register() function does not fail. |
5 | 5 | ||
6 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 6 | This call was later converted with a script to use &error_fatal, |
7 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 7 | still unable to fail. Remove the unreachable code. |
8 | Message-id: 20220506180242.216785-11-richard.henderson@linaro.org | 8 | |
9 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> | ||
10 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
11 | Message-id: 20230109115316.2235-14-philmd@linaro.org | ||
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 12 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
10 | --- | 13 | --- |
11 | target/arm/cpu.c | 22 +++++++++++++--------- | 14 | hw/arm/gumstix.c | 18 ++++++------------ |
12 | 1 file changed, 13 insertions(+), 9 deletions(-) | 15 | hw/arm/mainstone.c | 13 +++++-------- |
16 | hw/arm/omap_sx1.c | 22 ++++++++-------------- | ||
17 | hw/arm/versatilepb.c | 6 ++---- | ||
18 | hw/arm/z2.c | 9 +++------ | ||
19 | 5 files changed, 24 insertions(+), 44 deletions(-) | ||
13 | 20 | ||
14 | diff --git a/target/arm/cpu.c b/target/arm/cpu.c | 21 | diff --git a/hw/arm/gumstix.c b/hw/arm/gumstix.c |
15 | index XXXXXXX..XXXXXXX 100644 | 22 | index XXXXXXX..XXXXXXX 100644 |
16 | --- a/target/arm/cpu.c | 23 | --- a/hw/arm/gumstix.c |
17 | +++ b/target/arm/cpu.c | 24 | +++ b/hw/arm/gumstix.c |
18 | @@ -XXX,XX +XXX,XX @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp) | 25 | @@ -XXX,XX +XXX,XX @@ static void connex_init(MachineState *machine) |
19 | */ | ||
20 | unset_feature(env, ARM_FEATURE_EL3); | ||
21 | |||
22 | - /* Disable the security extension feature bits in the processor feature | ||
23 | - * registers as well. These are id_pfr1[7:4] and id_aa64pfr0[15:12]. | ||
24 | + /* | ||
25 | + * Disable the security extension feature bits in the processor | ||
26 | + * feature registers as well. | ||
27 | */ | ||
28 | - cpu->isar.id_pfr1 &= ~0xf0; | ||
29 | - cpu->isar.id_aa64pfr0 &= ~0xf000; | ||
30 | + cpu->isar.id_pfr1 = FIELD_DP32(cpu->isar.id_pfr1, ID_PFR1, SECURITY, 0); | ||
31 | + cpu->isar.id_aa64pfr0 = FIELD_DP64(cpu->isar.id_aa64pfr0, | ||
32 | + ID_AA64PFR0, EL3, 0); | ||
33 | } | 26 | } |
34 | 27 | ||
35 | if (!cpu->has_el2) { | 28 | /* Numonyx RC28F128J3F75 */ |
36 | @@ -XXX,XX +XXX,XX @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp) | 29 | - if (!pflash_cfi01_register(0x00000000, "connext.rom", CONNEX_FLASH_SIZE, |
30 | - dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, | ||
31 | - FLASH_SECTOR_SIZE, 2, 0, 0, 0, 0, 0)) { | ||
32 | - error_report("Error registering flash memory"); | ||
33 | - exit(1); | ||
34 | - } | ||
35 | + pflash_cfi01_register(0x00000000, "connext.rom", CONNEX_FLASH_SIZE, | ||
36 | + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, | ||
37 | + FLASH_SECTOR_SIZE, 2, 0, 0, 0, 0, 0); | ||
38 | |||
39 | /* Interrupt line of NIC is connected to GPIO line 36 */ | ||
40 | smc91c111_init(&nd_table[0], 0x04000300, | ||
41 | @@ -XXX,XX +XXX,XX @@ static void verdex_init(MachineState *machine) | ||
37 | } | 42 | } |
38 | 43 | ||
39 | if (!arm_feature(env, ARM_FEATURE_EL2)) { | 44 | /* Micron RC28F256P30TFA */ |
40 | - /* Disable the hypervisor feature bits in the processor feature | 45 | - if (!pflash_cfi01_register(0x00000000, "verdex.rom", VERDEX_FLASH_SIZE, |
41 | - * registers if we don't have EL2. These are id_pfr1[15:12] and | 46 | - dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
42 | - * id_aa64pfr0_el1[11:8]. | 47 | - FLASH_SECTOR_SIZE, 2, 0, 0, 0, 0, 0)) { |
43 | + /* | 48 | - error_report("Error registering flash memory"); |
44 | + * Disable the hypervisor feature bits in the processor feature | 49 | - exit(1); |
45 | + * registers if we don't have EL2. | 50 | - } |
46 | */ | 51 | + pflash_cfi01_register(0x00000000, "verdex.rom", VERDEX_FLASH_SIZE, |
47 | - cpu->isar.id_aa64pfr0 &= ~0xf00; | 52 | + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, |
48 | - cpu->isar.id_pfr1 &= ~0xf000; | 53 | + FLASH_SECTOR_SIZE, 2, 0, 0, 0, 0, 0); |
49 | + cpu->isar.id_aa64pfr0 = FIELD_DP64(cpu->isar.id_aa64pfr0, | 54 | |
50 | + ID_AA64PFR0, EL2, 0); | 55 | /* Interrupt line of NIC is connected to GPIO line 99 */ |
51 | + cpu->isar.id_pfr1 = FIELD_DP32(cpu->isar.id_pfr1, | 56 | smc91c111_init(&nd_table[0], 0x04000300, |
52 | + ID_PFR1, VIRTUALIZATION, 0); | 57 | diff --git a/hw/arm/mainstone.c b/hw/arm/mainstone.c |
58 | index XXXXXXX..XXXXXXX 100644 | ||
59 | --- a/hw/arm/mainstone.c | ||
60 | +++ b/hw/arm/mainstone.c | ||
61 | @@ -XXX,XX +XXX,XX @@ static void mainstone_common_init(MachineState *machine, | ||
62 | /* There are two 32MiB flash devices on the board */ | ||
63 | for (i = 0; i < 2; i ++) { | ||
64 | dinfo = drive_get(IF_PFLASH, 0, i); | ||
65 | - if (!pflash_cfi01_register(mainstone_flash_base[i], | ||
66 | - i ? "mainstone.flash1" : "mainstone.flash0", | ||
67 | - MAINSTONE_FLASH_SIZE, | ||
68 | - dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, | ||
69 | - FLASH_SECTOR_SIZE, 4, 0, 0, 0, 0, 0)) { | ||
70 | - error_report("Error registering flash memory"); | ||
71 | - exit(1); | ||
72 | - } | ||
73 | + pflash_cfi01_register(mainstone_flash_base[i], | ||
74 | + i ? "mainstone.flash1" : "mainstone.flash0", | ||
75 | + MAINSTONE_FLASH_SIZE, | ||
76 | + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, | ||
77 | + FLASH_SECTOR_SIZE, 4, 0, 0, 0, 0, 0); | ||
53 | } | 78 | } |
54 | 79 | ||
55 | #ifndef CONFIG_USER_ONLY | 80 | mst_irq = sysbus_create_simple("mainstone-fpga", MST_FPGA_PHYS, |
81 | diff --git a/hw/arm/omap_sx1.c b/hw/arm/omap_sx1.c | ||
82 | index XXXXXXX..XXXXXXX 100644 | ||
83 | --- a/hw/arm/omap_sx1.c | ||
84 | +++ b/hw/arm/omap_sx1.c | ||
85 | @@ -XXX,XX +XXX,XX @@ static void sx1_init(MachineState *machine, const int version) | ||
86 | |||
87 | fl_idx = 0; | ||
88 | if ((dinfo = drive_get(IF_PFLASH, 0, fl_idx)) != NULL) { | ||
89 | - if (!pflash_cfi01_register(OMAP_CS0_BASE, | ||
90 | - "omap_sx1.flash0-1", flash_size, | ||
91 | - blk_by_legacy_dinfo(dinfo), | ||
92 | - SECTOR_SIZE, 4, 0, 0, 0, 0, 0)) { | ||
93 | - fprintf(stderr, "qemu: Error registering flash memory %d.\n", | ||
94 | - fl_idx); | ||
95 | - } | ||
96 | + pflash_cfi01_register(OMAP_CS0_BASE, | ||
97 | + "omap_sx1.flash0-1", flash_size, | ||
98 | + blk_by_legacy_dinfo(dinfo), | ||
99 | + SECTOR_SIZE, 4, 0, 0, 0, 0, 0); | ||
100 | fl_idx++; | ||
101 | } | ||
102 | |||
103 | @@ -XXX,XX +XXX,XX @@ static void sx1_init(MachineState *machine, const int version) | ||
104 | memory_region_add_subregion(address_space, | ||
105 | OMAP_CS1_BASE + FLASH1_SIZE, &cs[1]); | ||
106 | |||
107 | - if (!pflash_cfi01_register(OMAP_CS1_BASE, | ||
108 | - "omap_sx1.flash1-1", FLASH1_SIZE, | ||
109 | - blk_by_legacy_dinfo(dinfo), | ||
110 | - SECTOR_SIZE, 4, 0, 0, 0, 0, 0)) { | ||
111 | - fprintf(stderr, "qemu: Error registering flash memory %d.\n", | ||
112 | - fl_idx); | ||
113 | - } | ||
114 | + pflash_cfi01_register(OMAP_CS1_BASE, | ||
115 | + "omap_sx1.flash1-1", FLASH1_SIZE, | ||
116 | + blk_by_legacy_dinfo(dinfo), | ||
117 | + SECTOR_SIZE, 4, 0, 0, 0, 0, 0); | ||
118 | fl_idx++; | ||
119 | } else { | ||
120 | memory_region_init_io(&cs[1], NULL, &static_ops, &cs1val, | ||
121 | diff --git a/hw/arm/versatilepb.c b/hw/arm/versatilepb.c | ||
122 | index XXXXXXX..XXXXXXX 100644 | ||
123 | --- a/hw/arm/versatilepb.c | ||
124 | +++ b/hw/arm/versatilepb.c | ||
125 | @@ -XXX,XX +XXX,XX @@ static void versatile_init(MachineState *machine, int board_id) | ||
126 | /* 0x34000000 NOR Flash */ | ||
127 | |||
128 | dinfo = drive_get(IF_PFLASH, 0, 0); | ||
129 | - if (!pflash_cfi01_register(VERSATILE_FLASH_ADDR, "versatile.flash", | ||
130 | + pflash_cfi01_register(VERSATILE_FLASH_ADDR, "versatile.flash", | ||
131 | VERSATILE_FLASH_SIZE, | ||
132 | dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, | ||
133 | VERSATILE_FLASH_SECT_SIZE, | ||
134 | - 4, 0x0089, 0x0018, 0x0000, 0x0, 0)) { | ||
135 | - fprintf(stderr, "qemu: Error registering flash memory.\n"); | ||
136 | - } | ||
137 | + 4, 0x0089, 0x0018, 0x0000, 0x0, 0); | ||
138 | |||
139 | versatile_binfo.ram_size = machine->ram_size; | ||
140 | versatile_binfo.board_id = board_id; | ||
141 | diff --git a/hw/arm/z2.c b/hw/arm/z2.c | ||
142 | index XXXXXXX..XXXXXXX 100644 | ||
143 | --- a/hw/arm/z2.c | ||
144 | +++ b/hw/arm/z2.c | ||
145 | @@ -XXX,XX +XXX,XX @@ static void z2_init(MachineState *machine) | ||
146 | mpu = pxa270_init(z2_binfo.ram_size, machine->cpu_type); | ||
147 | |||
148 | dinfo = drive_get(IF_PFLASH, 0, 0); | ||
149 | - if (!pflash_cfi01_register(Z2_FLASH_BASE, "z2.flash0", Z2_FLASH_SIZE, | ||
150 | - dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, | ||
151 | - FLASH_SECTOR_SIZE, 4, 0, 0, 0, 0, 0)) { | ||
152 | - error_report("Error registering flash memory"); | ||
153 | - exit(1); | ||
154 | - } | ||
155 | + pflash_cfi01_register(Z2_FLASH_BASE, "z2.flash0", Z2_FLASH_SIZE, | ||
156 | + dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, | ||
157 | + FLASH_SECTOR_SIZE, 4, 0, 0, 0, 0, 0); | ||
158 | |||
159 | /* setup keypad */ | ||
160 | pxa27x_register_keypad(mpu->kp, map, 0x100); | ||
56 | -- | 161 | -- |
57 | 2.25.1 | 162 | 2.34.1 |
163 | |||
164 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | This feature is AArch64 only, and applies to physical SErrors, | 3 | To avoid forward-declaring PXA2xxI2CState, declare |
4 | which QEMU does not implement, thus the feature is a nop. | 4 | PXA2XX_I2C before its use in pxa2xx_i2c_init() prototype. |
5 | 5 | ||
6 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 6 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
7 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 7 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
8 | Message-id: 20220506180242.216785-19-richard.henderson@linaro.org | 8 | Message-id: 20230109140306.23161-2-philmd@linaro.org |
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
10 | --- | 10 | --- |
11 | docs/system/arm/emulation.rst | 1 + | 11 | include/hw/arm/pxa.h | 6 +++--- |
12 | target/arm/cpu64.c | 1 + | 12 | 1 file changed, 3 insertions(+), 3 deletions(-) |
13 | 2 files changed, 2 insertions(+) | ||
14 | 13 | ||
15 | diff --git a/docs/system/arm/emulation.rst b/docs/system/arm/emulation.rst | 14 | diff --git a/include/hw/arm/pxa.h b/include/hw/arm/pxa.h |
16 | index XXXXXXX..XXXXXXX 100644 | 15 | index XXXXXXX..XXXXXXX 100644 |
17 | --- a/docs/system/arm/emulation.rst | 16 | --- a/include/hw/arm/pxa.h |
18 | +++ b/docs/system/arm/emulation.rst | 17 | +++ b/include/hw/arm/pxa.h |
19 | @@ -XXX,XX +XXX,XX @@ the following architecture extensions: | 18 | @@ -XXX,XX +XXX,XX @@ void pxa27x_register_keypad(PXA2xxKeyPadState *kp, |
20 | - FEAT_FlagM2 (Enhancements to flag manipulation instructions) | 19 | const struct keymap *map, int size); |
21 | - FEAT_HPDS (Hierarchical permission disables) | 20 | |
22 | - FEAT_I8MM (AArch64 Int8 matrix multiplication instructions) | 21 | /* pxa2xx.c */ |
23 | +- FEAT_IESB (Implicit error synchronization event) | 22 | -typedef struct PXA2xxI2CState PXA2xxI2CState; |
24 | - FEAT_JSCVT (JavaScript conversion instructions) | 23 | +#define TYPE_PXA2XX_I2C "pxa2xx_i2c" |
25 | - FEAT_LOR (Limited ordering regions) | 24 | +OBJECT_DECLARE_SIMPLE_TYPE(PXA2xxI2CState, PXA2XX_I2C) |
26 | - FEAT_LPA (Large Physical Address space) | 25 | + |
27 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 26 | PXA2xxI2CState *pxa2xx_i2c_init(hwaddr base, |
28 | index XXXXXXX..XXXXXXX 100644 | 27 | qemu_irq irq, uint32_t page_size); |
29 | --- a/target/arm/cpu64.c | 28 | I2CBus *pxa2xx_i2c_bus(PXA2xxI2CState *s); |
30 | +++ b/target/arm/cpu64.c | 29 | |
31 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | 30 | -#define TYPE_PXA2XX_I2C "pxa2xx_i2c" |
32 | t = cpu->isar.id_aa64mmfr2; | 31 | typedef struct PXA2xxI2SState PXA2xxI2SState; |
33 | t = FIELD_DP64(t, ID_AA64MMFR2, CNP, 1); /* FEAT_TTCNP */ | 32 | -OBJECT_DECLARE_SIMPLE_TYPE(PXA2xxI2CState, PXA2XX_I2C) |
34 | t = FIELD_DP64(t, ID_AA64MMFR2, UAO, 1); /* FEAT_UAO */ | 33 | |
35 | + t = FIELD_DP64(t, ID_AA64MMFR2, IESB, 1); /* FEAT_IESB */ | 34 | #define TYPE_PXA2XX_FIR "pxa2xx-fir" |
36 | t = FIELD_DP64(t, ID_AA64MMFR2, VARANGE, 1); /* FEAT_LVA */ | 35 | OBJECT_DECLARE_SIMPLE_TYPE(PXA2xxFIrState, PXA2XX_FIR) |
37 | t = FIELD_DP64(t, ID_AA64MMFR2, ST, 1); /* FEAT_TTST */ | ||
38 | t = FIELD_DP64(t, ID_AA64MMFR2, TTL, 1); /* FEAT_TTL */ | ||
39 | -- | 36 | -- |
40 | 2.25.1 | 37 | 2.34.1 |
38 | |||
39 | diff view generated by jsdifflib |
1 | From: Gavin Shan <gshan@redhat.com> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | The CPU topology isn't enabled on arm/virt machine yet, but we're | 3 | Add a local 'struct omap_gpif_s *' variable to improve readability. |
4 | going to do it in next patch. After the CPU topology is enabled by | 4 | (This also eases next commit conversion). |
5 | next patch, "thread-id=1" becomes invalid because the CPU core is | ||
6 | preferred on arm/virt machine. It means these two CPUs have 0/1 | ||
7 | as their core IDs, but their thread IDs are all 0. It will trigger | ||
8 | test failure as the following message indicates: | ||
9 | 5 | ||
10 | [14/21 qemu:qtest+qtest-aarch64 / qtest-aarch64/numa-test ERROR | 6 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
11 | 1.48s killed by signal 6 SIGABRT | 7 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
12 | >>> G_TEST_DBUS_DAEMON=/home/gavin/sandbox/qemu.main/tests/dbus-vmstate-daemon.sh \ | 8 | Message-id: 20230109140306.23161-3-philmd@linaro.org |
13 | QTEST_QEMU_STORAGE_DAEMON_BINARY=./storage-daemon/qemu-storage-daemon \ | ||
14 | QTEST_QEMU_BINARY=./qemu-system-aarch64 \ | ||
15 | QTEST_QEMU_IMG=./qemu-img MALLOC_PERTURB_=83 \ | ||
16 | /home/gavin/sandbox/qemu.main/build/tests/qtest/numa-test --tap -k | ||
17 | ―――――――――――――――――――――――――――――――――――――――――――――― | ||
18 | stderr: | ||
19 | qemu-system-aarch64: -numa cpu,node-id=0,thread-id=1: no match found | ||
20 | |||
21 | This fixes the issue by providing comprehensive SMP configurations | ||
22 | in aarch64_numa_cpu(). The SMP configurations aren't used before | ||
23 | the CPU topology is enabled in next patch. | ||
24 | |||
25 | Signed-off-by: Gavin Shan <gshan@redhat.com> | ||
26 | Reviewed-by: Yanan Wang <wangyanan55@huawei.com> | ||
27 | Message-id: 20220503140304.855514-3-gshan@redhat.com | ||
28 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
29 | --- | 10 | --- |
30 | tests/qtest/numa-test.c | 3 ++- | 11 | hw/gpio/omap_gpio.c | 3 ++- |
31 | 1 file changed, 2 insertions(+), 1 deletion(-) | 12 | 1 file changed, 2 insertions(+), 1 deletion(-) |
32 | 13 | ||
33 | diff --git a/tests/qtest/numa-test.c b/tests/qtest/numa-test.c | 14 | diff --git a/hw/gpio/omap_gpio.c b/hw/gpio/omap_gpio.c |
34 | index XXXXXXX..XXXXXXX 100644 | 15 | index XXXXXXX..XXXXXXX 100644 |
35 | --- a/tests/qtest/numa-test.c | 16 | --- a/hw/gpio/omap_gpio.c |
36 | +++ b/tests/qtest/numa-test.c | 17 | +++ b/hw/gpio/omap_gpio.c |
37 | @@ -XXX,XX +XXX,XX @@ static void aarch64_numa_cpu(const void *data) | 18 | @@ -XXX,XX +XXX,XX @@ struct omap_gpif_s { |
38 | QTestState *qts; | 19 | /* General-Purpose I/O of OMAP1 */ |
39 | g_autofree char *cli = NULL; | 20 | static void omap_gpio_set(void *opaque, int line, int level) |
40 | 21 | { | |
41 | - cli = make_cli(data, "-machine smp.cpus=2 " | 22 | - struct omap_gpio_s *s = &((struct omap_gpif_s *) opaque)->omap1; |
42 | + cli = make_cli(data, "-machine " | 23 | + struct omap_gpif_s *p = opaque; |
43 | + "smp.cpus=2,smp.sockets=1,smp.clusters=1,smp.cores=1,smp.threads=2 " | 24 | + struct omap_gpio_s *s = &p->omap1; |
44 | "-numa node,nodeid=0,memdev=ram -numa node,nodeid=1 " | 25 | uint16_t prev = s->inputs; |
45 | "-numa cpu,node-id=1,thread-id=0 " | 26 | |
46 | "-numa cpu,node-id=0,thread-id=1"); | 27 | if (level) |
47 | -- | 28 | -- |
48 | 2.25.1 | 29 | 2.34.1 |
49 | 30 | ||
50 | 31 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Drop zcr_no_el2_reginfo and merge the 3 registers into one array, | 3 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
4 | now that ZCR_EL2 can be squashed to RES0 and ZCR_EL3 dropped | 4 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
5 | while registering. | 5 | Message-id: 20230109140306.23161-4-philmd@linaro.org |
6 | |||
7 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
8 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | ||
9 | Message-id: 20220506180242.216785-4-richard.henderson@linaro.org | ||
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 6 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | --- | 7 | --- |
12 | target/arm/helper.c | 55 ++++++++++++++------------------------------- | 8 | hw/arm/omap1.c | 115 ++++++++++++++++++-------------------- |
13 | 1 file changed, 17 insertions(+), 38 deletions(-) | 9 | hw/arm/omap2.c | 40 ++++++------- |
10 | hw/arm/omap_sx1.c | 2 +- | ||
11 | hw/arm/palm.c | 2 +- | ||
12 | hw/char/omap_uart.c | 7 +-- | ||
13 | hw/display/omap_dss.c | 15 +++-- | ||
14 | hw/display/omap_lcdc.c | 9 ++- | ||
15 | hw/dma/omap_dma.c | 15 +++-- | ||
16 | hw/gpio/omap_gpio.c | 15 +++-- | ||
17 | hw/intc/omap_intc.c | 12 ++-- | ||
18 | hw/misc/omap_gpmc.c | 12 ++-- | ||
19 | hw/misc/omap_l4.c | 7 +-- | ||
20 | hw/misc/omap_sdrc.c | 7 +-- | ||
21 | hw/misc/omap_tap.c | 5 +- | ||
22 | hw/sd/omap_mmc.c | 9 ++- | ||
23 | hw/ssi/omap_spi.c | 7 +-- | ||
24 | hw/timer/omap_gptimer.c | 22 ++++---- | ||
25 | hw/timer/omap_synctimer.c | 4 +- | ||
26 | 18 files changed, 142 insertions(+), 163 deletions(-) | ||
14 | 27 | ||
15 | diff --git a/target/arm/helper.c b/target/arm/helper.c | 28 | diff --git a/hw/arm/omap1.c b/hw/arm/omap1.c |
16 | index XXXXXXX..XXXXXXX 100644 | 29 | index XXXXXXX..XXXXXXX 100644 |
17 | --- a/target/arm/helper.c | 30 | --- a/hw/arm/omap1.c |
18 | +++ b/target/arm/helper.c | 31 | +++ b/hw/arm/omap1.c |
19 | @@ -XXX,XX +XXX,XX @@ static void zcr_write(CPUARMState *env, const ARMCPRegInfo *ri, | 32 | @@ -XXX,XX +XXX,XX @@ static void omap_timer_fire(void *opaque) |
33 | |||
34 | static void omap_timer_tick(void *opaque) | ||
35 | { | ||
36 | - struct omap_mpu_timer_s *timer = (struct omap_mpu_timer_s *) opaque; | ||
37 | + struct omap_mpu_timer_s *timer = opaque; | ||
38 | |||
39 | omap_timer_sync(timer); | ||
40 | omap_timer_fire(timer); | ||
41 | @@ -XXX,XX +XXX,XX @@ static void omap_timer_tick(void *opaque) | ||
42 | |||
43 | static void omap_timer_clk_update(void *opaque, int line, int on) | ||
44 | { | ||
45 | - struct omap_mpu_timer_s *timer = (struct omap_mpu_timer_s *) opaque; | ||
46 | + struct omap_mpu_timer_s *timer = opaque; | ||
47 | |||
48 | omap_timer_sync(timer); | ||
49 | timer->rate = on ? omap_clk_getrate(timer->clk) : 0; | ||
50 | @@ -XXX,XX +XXX,XX @@ static void omap_timer_clk_setup(struct omap_mpu_timer_s *timer) | ||
51 | static uint64_t omap_mpu_timer_read(void *opaque, hwaddr addr, | ||
52 | unsigned size) | ||
53 | { | ||
54 | - struct omap_mpu_timer_s *s = (struct omap_mpu_timer_s *) opaque; | ||
55 | + struct omap_mpu_timer_s *s = opaque; | ||
56 | |||
57 | if (size != 4) { | ||
58 | return omap_badwidth_read32(opaque, addr); | ||
59 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_mpu_timer_read(void *opaque, hwaddr addr, | ||
60 | static void omap_mpu_timer_write(void *opaque, hwaddr addr, | ||
61 | uint64_t value, unsigned size) | ||
62 | { | ||
63 | - struct omap_mpu_timer_s *s = (struct omap_mpu_timer_s *) opaque; | ||
64 | + struct omap_mpu_timer_s *s = opaque; | ||
65 | |||
66 | if (size != 4) { | ||
67 | omap_badwidth_write32(opaque, addr, value); | ||
68 | @@ -XXX,XX +XXX,XX @@ struct omap_watchdog_timer_s { | ||
69 | static uint64_t omap_wd_timer_read(void *opaque, hwaddr addr, | ||
70 | unsigned size) | ||
71 | { | ||
72 | - struct omap_watchdog_timer_s *s = (struct omap_watchdog_timer_s *) opaque; | ||
73 | + struct omap_watchdog_timer_s *s = opaque; | ||
74 | |||
75 | if (size != 2) { | ||
76 | return omap_badwidth_read16(opaque, addr); | ||
77 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_wd_timer_read(void *opaque, hwaddr addr, | ||
78 | static void omap_wd_timer_write(void *opaque, hwaddr addr, | ||
79 | uint64_t value, unsigned size) | ||
80 | { | ||
81 | - struct omap_watchdog_timer_s *s = (struct omap_watchdog_timer_s *) opaque; | ||
82 | + struct omap_watchdog_timer_s *s = opaque; | ||
83 | |||
84 | if (size != 2) { | ||
85 | omap_badwidth_write16(opaque, addr, value); | ||
86 | @@ -XXX,XX +XXX,XX @@ struct omap_32khz_timer_s { | ||
87 | static uint64_t omap_os_timer_read(void *opaque, hwaddr addr, | ||
88 | unsigned size) | ||
89 | { | ||
90 | - struct omap_32khz_timer_s *s = (struct omap_32khz_timer_s *) opaque; | ||
91 | + struct omap_32khz_timer_s *s = opaque; | ||
92 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
93 | |||
94 | if (size != 4) { | ||
95 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_os_timer_read(void *opaque, hwaddr addr, | ||
96 | static void omap_os_timer_write(void *opaque, hwaddr addr, | ||
97 | uint64_t value, unsigned size) | ||
98 | { | ||
99 | - struct omap_32khz_timer_s *s = (struct omap_32khz_timer_s *) opaque; | ||
100 | + struct omap_32khz_timer_s *s = opaque; | ||
101 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
102 | |||
103 | if (size != 4) { | ||
104 | @@ -XXX,XX +XXX,XX @@ static struct omap_32khz_timer_s *omap_os_timer_init(MemoryRegion *memory, | ||
105 | static uint64_t omap_ulpd_pm_read(void *opaque, hwaddr addr, | ||
106 | unsigned size) | ||
107 | { | ||
108 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
109 | + struct omap_mpu_state_s *s = opaque; | ||
110 | uint16_t ret; | ||
111 | |||
112 | if (size != 2) { | ||
113 | @@ -XXX,XX +XXX,XX @@ static inline void omap_ulpd_req_update(struct omap_mpu_state_s *s, | ||
114 | static void omap_ulpd_pm_write(void *opaque, hwaddr addr, | ||
115 | uint64_t value, unsigned size) | ||
116 | { | ||
117 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
118 | + struct omap_mpu_state_s *s = opaque; | ||
119 | int64_t now, ticks; | ||
120 | int div, mult; | ||
121 | static const int bypass_div[4] = { 1, 2, 4, 4 }; | ||
122 | @@ -XXX,XX +XXX,XX @@ static void omap_ulpd_pm_init(MemoryRegion *system_memory, | ||
123 | static uint64_t omap_pin_cfg_read(void *opaque, hwaddr addr, | ||
124 | unsigned size) | ||
125 | { | ||
126 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
127 | + struct omap_mpu_state_s *s = opaque; | ||
128 | |||
129 | if (size != 4) { | ||
130 | return omap_badwidth_read32(opaque, addr); | ||
131 | @@ -XXX,XX +XXX,XX @@ static inline void omap_pin_modconf1_update(struct omap_mpu_state_s *s, | ||
132 | static void omap_pin_cfg_write(void *opaque, hwaddr addr, | ||
133 | uint64_t value, unsigned size) | ||
134 | { | ||
135 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
136 | + struct omap_mpu_state_s *s = opaque; | ||
137 | uint32_t diff; | ||
138 | |||
139 | if (size != 4) { | ||
140 | @@ -XXX,XX +XXX,XX @@ static void omap_pin_cfg_init(MemoryRegion *system_memory, | ||
141 | static uint64_t omap_id_read(void *opaque, hwaddr addr, | ||
142 | unsigned size) | ||
143 | { | ||
144 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
145 | + struct omap_mpu_state_s *s = opaque; | ||
146 | |||
147 | if (size != 4) { | ||
148 | return omap_badwidth_read32(opaque, addr); | ||
149 | @@ -XXX,XX +XXX,XX @@ static void omap_id_init(MemoryRegion *memory, struct omap_mpu_state_s *mpu) | ||
150 | static uint64_t omap_mpui_read(void *opaque, hwaddr addr, | ||
151 | unsigned size) | ||
152 | { | ||
153 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
154 | + struct omap_mpu_state_s *s = opaque; | ||
155 | |||
156 | if (size != 4) { | ||
157 | return omap_badwidth_read32(opaque, addr); | ||
158 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_mpui_read(void *opaque, hwaddr addr, | ||
159 | static void omap_mpui_write(void *opaque, hwaddr addr, | ||
160 | uint64_t value, unsigned size) | ||
161 | { | ||
162 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
163 | + struct omap_mpu_state_s *s = opaque; | ||
164 | |||
165 | if (size != 4) { | ||
166 | omap_badwidth_write32(opaque, addr, value); | ||
167 | @@ -XXX,XX +XXX,XX @@ struct omap_tipb_bridge_s { | ||
168 | static uint64_t omap_tipb_bridge_read(void *opaque, hwaddr addr, | ||
169 | unsigned size) | ||
170 | { | ||
171 | - struct omap_tipb_bridge_s *s = (struct omap_tipb_bridge_s *) opaque; | ||
172 | + struct omap_tipb_bridge_s *s = opaque; | ||
173 | |||
174 | if (size < 2) { | ||
175 | return omap_badwidth_read16(opaque, addr); | ||
176 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_tipb_bridge_read(void *opaque, hwaddr addr, | ||
177 | static void omap_tipb_bridge_write(void *opaque, hwaddr addr, | ||
178 | uint64_t value, unsigned size) | ||
179 | { | ||
180 | - struct omap_tipb_bridge_s *s = (struct omap_tipb_bridge_s *) opaque; | ||
181 | + struct omap_tipb_bridge_s *s = opaque; | ||
182 | |||
183 | if (size < 2) { | ||
184 | omap_badwidth_write16(opaque, addr, value); | ||
185 | @@ -XXX,XX +XXX,XX @@ static struct omap_tipb_bridge_s *omap_tipb_bridge_init( | ||
186 | static uint64_t omap_tcmi_read(void *opaque, hwaddr addr, | ||
187 | unsigned size) | ||
188 | { | ||
189 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
190 | + struct omap_mpu_state_s *s = opaque; | ||
191 | uint32_t ret; | ||
192 | |||
193 | if (size != 4) { | ||
194 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_tcmi_read(void *opaque, hwaddr addr, | ||
195 | static void omap_tcmi_write(void *opaque, hwaddr addr, | ||
196 | uint64_t value, unsigned size) | ||
197 | { | ||
198 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
199 | + struct omap_mpu_state_s *s = opaque; | ||
200 | |||
201 | if (size != 4) { | ||
202 | omap_badwidth_write32(opaque, addr, value); | ||
203 | @@ -XXX,XX +XXX,XX @@ struct dpll_ctl_s { | ||
204 | static uint64_t omap_dpll_read(void *opaque, hwaddr addr, | ||
205 | unsigned size) | ||
206 | { | ||
207 | - struct dpll_ctl_s *s = (struct dpll_ctl_s *) opaque; | ||
208 | + struct dpll_ctl_s *s = opaque; | ||
209 | |||
210 | if (size != 2) { | ||
211 | return omap_badwidth_read16(opaque, addr); | ||
212 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_dpll_read(void *opaque, hwaddr addr, | ||
213 | static void omap_dpll_write(void *opaque, hwaddr addr, | ||
214 | uint64_t value, unsigned size) | ||
215 | { | ||
216 | - struct dpll_ctl_s *s = (struct dpll_ctl_s *) opaque; | ||
217 | + struct dpll_ctl_s *s = opaque; | ||
218 | uint16_t diff; | ||
219 | static const int bypass_div[4] = { 1, 2, 4, 4 }; | ||
220 | int div, mult; | ||
221 | @@ -XXX,XX +XXX,XX @@ static struct dpll_ctl_s *omap_dpll_init(MemoryRegion *memory, | ||
222 | static uint64_t omap_clkm_read(void *opaque, hwaddr addr, | ||
223 | unsigned size) | ||
224 | { | ||
225 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
226 | + struct omap_mpu_state_s *s = opaque; | ||
227 | |||
228 | if (size != 2) { | ||
229 | return omap_badwidth_read16(opaque, addr); | ||
230 | @@ -XXX,XX +XXX,XX @@ static inline void omap_clkm_ckout1_update(struct omap_mpu_state_s *s, | ||
231 | static void omap_clkm_write(void *opaque, hwaddr addr, | ||
232 | uint64_t value, unsigned size) | ||
233 | { | ||
234 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
235 | + struct omap_mpu_state_s *s = opaque; | ||
236 | uint16_t diff; | ||
237 | omap_clk clk; | ||
238 | static const char *clkschemename[8] = { | ||
239 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps omap_clkm_ops = { | ||
240 | static uint64_t omap_clkdsp_read(void *opaque, hwaddr addr, | ||
241 | unsigned size) | ||
242 | { | ||
243 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
244 | + struct omap_mpu_state_s *s = opaque; | ||
245 | CPUState *cpu = CPU(s->cpu); | ||
246 | |||
247 | if (size != 2) { | ||
248 | @@ -XXX,XX +XXX,XX @@ static inline void omap_clkdsp_idlect2_update(struct omap_mpu_state_s *s, | ||
249 | static void omap_clkdsp_write(void *opaque, hwaddr addr, | ||
250 | uint64_t value, unsigned size) | ||
251 | { | ||
252 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
253 | + struct omap_mpu_state_s *s = opaque; | ||
254 | uint16_t diff; | ||
255 | |||
256 | if (size != 2) { | ||
257 | @@ -XXX,XX +XXX,XX @@ struct omap_mpuio_s { | ||
258 | |||
259 | static void omap_mpuio_set(void *opaque, int line, int level) | ||
260 | { | ||
261 | - struct omap_mpuio_s *s = (struct omap_mpuio_s *) opaque; | ||
262 | + struct omap_mpuio_s *s = opaque; | ||
263 | uint16_t prev = s->inputs; | ||
264 | |||
265 | if (level) | ||
266 | @@ -XXX,XX +XXX,XX @@ static void omap_mpuio_kbd_update(struct omap_mpuio_s *s) | ||
267 | static uint64_t omap_mpuio_read(void *opaque, hwaddr addr, | ||
268 | unsigned size) | ||
269 | { | ||
270 | - struct omap_mpuio_s *s = (struct omap_mpuio_s *) opaque; | ||
271 | + struct omap_mpuio_s *s = opaque; | ||
272 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
273 | uint16_t ret; | ||
274 | |||
275 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_mpuio_read(void *opaque, hwaddr addr, | ||
276 | static void omap_mpuio_write(void *opaque, hwaddr addr, | ||
277 | uint64_t value, unsigned size) | ||
278 | { | ||
279 | - struct omap_mpuio_s *s = (struct omap_mpuio_s *) opaque; | ||
280 | + struct omap_mpuio_s *s = opaque; | ||
281 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
282 | uint16_t diff; | ||
283 | int ln; | ||
284 | @@ -XXX,XX +XXX,XX @@ static void omap_mpuio_reset(struct omap_mpuio_s *s) | ||
285 | |||
286 | static void omap_mpuio_onoff(void *opaque, int line, int on) | ||
287 | { | ||
288 | - struct omap_mpuio_s *s = (struct omap_mpuio_s *) opaque; | ||
289 | + struct omap_mpuio_s *s = opaque; | ||
290 | |||
291 | s->clk = on; | ||
292 | if (on) | ||
293 | @@ -XXX,XX +XXX,XX @@ static void omap_uwire_transfer_start(struct omap_uwire_s *s) | ||
20 | } | 294 | } |
21 | } | 295 | } |
22 | 296 | ||
23 | -static const ARMCPRegInfo zcr_el1_reginfo = { | 297 | -static uint64_t omap_uwire_read(void *opaque, hwaddr addr, |
24 | - .name = "ZCR_EL1", .state = ARM_CP_STATE_AA64, | 298 | - unsigned size) |
25 | - .opc0 = 3, .opc1 = 0, .crn = 1, .crm = 2, .opc2 = 0, | 299 | +static uint64_t omap_uwire_read(void *opaque, hwaddr addr, unsigned size) |
26 | - .access = PL1_RW, .type = ARM_CP_SVE, | 300 | { |
27 | - .fieldoffset = offsetof(CPUARMState, vfp.zcr_el[1]), | 301 | - struct omap_uwire_s *s = (struct omap_uwire_s *) opaque; |
28 | - .writefn = zcr_write, .raw_writefn = raw_write | 302 | + struct omap_uwire_s *s = opaque; |
29 | -}; | 303 | int offset = addr & OMAP_MPUI_REG_MASK; |
30 | - | 304 | |
31 | -static const ARMCPRegInfo zcr_el2_reginfo = { | 305 | if (size != 2) { |
32 | - .name = "ZCR_EL2", .state = ARM_CP_STATE_AA64, | 306 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_uwire_read(void *opaque, hwaddr addr, |
33 | - .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 2, .opc2 = 0, | 307 | static void omap_uwire_write(void *opaque, hwaddr addr, |
34 | - .access = PL2_RW, .type = ARM_CP_SVE, | 308 | uint64_t value, unsigned size) |
35 | - .fieldoffset = offsetof(CPUARMState, vfp.zcr_el[2]), | 309 | { |
36 | - .writefn = zcr_write, .raw_writefn = raw_write | 310 | - struct omap_uwire_s *s = (struct omap_uwire_s *) opaque; |
37 | -}; | 311 | + struct omap_uwire_s *s = opaque; |
38 | - | 312 | int offset = addr & OMAP_MPUI_REG_MASK; |
39 | -static const ARMCPRegInfo zcr_no_el2_reginfo = { | 313 | |
40 | - .name = "ZCR_EL2", .state = ARM_CP_STATE_AA64, | 314 | if (size != 2) { |
41 | - .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 2, .opc2 = 0, | 315 | @@ -XXX,XX +XXX,XX @@ static void omap_pwl_update(struct omap_pwl_s *s) |
42 | - .access = PL2_RW, .type = ARM_CP_SVE, | 316 | } |
43 | - .readfn = arm_cp_read_zero, .writefn = arm_cp_write_ignore | 317 | } |
44 | -}; | 318 | |
45 | - | 319 | -static uint64_t omap_pwl_read(void *opaque, hwaddr addr, |
46 | -static const ARMCPRegInfo zcr_el3_reginfo = { | 320 | - unsigned size) |
47 | - .name = "ZCR_EL3", .state = ARM_CP_STATE_AA64, | 321 | +static uint64_t omap_pwl_read(void *opaque, hwaddr addr, unsigned size) |
48 | - .opc0 = 3, .opc1 = 6, .crn = 1, .crm = 2, .opc2 = 0, | 322 | { |
49 | - .access = PL3_RW, .type = ARM_CP_SVE, | 323 | - struct omap_pwl_s *s = (struct omap_pwl_s *) opaque; |
50 | - .fieldoffset = offsetof(CPUARMState, vfp.zcr_el[3]), | 324 | + struct omap_pwl_s *s = opaque; |
51 | - .writefn = zcr_write, .raw_writefn = raw_write | 325 | int offset = addr & OMAP_MPUI_REG_MASK; |
52 | +static const ARMCPRegInfo zcr_reginfo[] = { | 326 | |
53 | + { .name = "ZCR_EL1", .state = ARM_CP_STATE_AA64, | 327 | if (size != 1) { |
54 | + .opc0 = 3, .opc1 = 0, .crn = 1, .crm = 2, .opc2 = 0, | 328 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_pwl_read(void *opaque, hwaddr addr, |
55 | + .access = PL1_RW, .type = ARM_CP_SVE, | 329 | static void omap_pwl_write(void *opaque, hwaddr addr, |
56 | + .fieldoffset = offsetof(CPUARMState, vfp.zcr_el[1]), | 330 | uint64_t value, unsigned size) |
57 | + .writefn = zcr_write, .raw_writefn = raw_write }, | 331 | { |
58 | + { .name = "ZCR_EL2", .state = ARM_CP_STATE_AA64, | 332 | - struct omap_pwl_s *s = (struct omap_pwl_s *) opaque; |
59 | + .opc0 = 3, .opc1 = 4, .crn = 1, .crm = 2, .opc2 = 0, | 333 | + struct omap_pwl_s *s = opaque; |
60 | + .access = PL2_RW, .type = ARM_CP_SVE, | 334 | int offset = addr & OMAP_MPUI_REG_MASK; |
61 | + .fieldoffset = offsetof(CPUARMState, vfp.zcr_el[2]), | 335 | |
62 | + .writefn = zcr_write, .raw_writefn = raw_write }, | 336 | if (size != 1) { |
63 | + { .name = "ZCR_EL3", .state = ARM_CP_STATE_AA64, | 337 | @@ -XXX,XX +XXX,XX @@ static void omap_pwl_reset(struct omap_pwl_s *s) |
64 | + .opc0 = 3, .opc1 = 6, .crn = 1, .crm = 2, .opc2 = 0, | 338 | |
65 | + .access = PL3_RW, .type = ARM_CP_SVE, | 339 | static void omap_pwl_clk_update(void *opaque, int line, int on) |
66 | + .fieldoffset = offsetof(CPUARMState, vfp.zcr_el[3]), | 340 | { |
67 | + .writefn = zcr_write, .raw_writefn = raw_write }, | 341 | - struct omap_pwl_s *s = (struct omap_pwl_s *) opaque; |
342 | + struct omap_pwl_s *s = opaque; | ||
343 | |||
344 | s->clk = on; | ||
345 | omap_pwl_update(s); | ||
346 | @@ -XXX,XX +XXX,XX @@ struct omap_pwt_s { | ||
347 | omap_clk clk; | ||
68 | }; | 348 | }; |
69 | 349 | ||
70 | void hw_watchpoint_update(ARMCPU *cpu, int n) | 350 | -static uint64_t omap_pwt_read(void *opaque, hwaddr addr, |
71 | @@ -XXX,XX +XXX,XX @@ void register_cp_regs_for_features(ARMCPU *cpu) | 351 | - unsigned size) |
352 | +static uint64_t omap_pwt_read(void *opaque, hwaddr addr, unsigned size) | ||
353 | { | ||
354 | - struct omap_pwt_s *s = (struct omap_pwt_s *) opaque; | ||
355 | + struct omap_pwt_s *s = opaque; | ||
356 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
357 | |||
358 | if (size != 1) { | ||
359 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_pwt_read(void *opaque, hwaddr addr, | ||
360 | static void omap_pwt_write(void *opaque, hwaddr addr, | ||
361 | uint64_t value, unsigned size) | ||
362 | { | ||
363 | - struct omap_pwt_s *s = (struct omap_pwt_s *) opaque; | ||
364 | + struct omap_pwt_s *s = opaque; | ||
365 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
366 | |||
367 | if (size != 1) { | ||
368 | @@ -XXX,XX +XXX,XX @@ static void omap_rtc_alarm_update(struct omap_rtc_s *s) | ||
369 | printf("%s: conversion failed\n", __func__); | ||
370 | } | ||
371 | |||
372 | -static uint64_t omap_rtc_read(void *opaque, hwaddr addr, | ||
373 | - unsigned size) | ||
374 | +static uint64_t omap_rtc_read(void *opaque, hwaddr addr, unsigned size) | ||
375 | { | ||
376 | - struct omap_rtc_s *s = (struct omap_rtc_s *) opaque; | ||
377 | + struct omap_rtc_s *s = opaque; | ||
378 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
379 | uint8_t i; | ||
380 | |||
381 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_rtc_read(void *opaque, hwaddr addr, | ||
382 | static void omap_rtc_write(void *opaque, hwaddr addr, | ||
383 | uint64_t value, unsigned size) | ||
384 | { | ||
385 | - struct omap_rtc_s *s = (struct omap_rtc_s *) opaque; | ||
386 | + struct omap_rtc_s *s = opaque; | ||
387 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
388 | struct tm new_tm; | ||
389 | time_t ti[2]; | ||
390 | @@ -XXX,XX +XXX,XX @@ static void omap_mcbsp_rx_newdata(struct omap_mcbsp_s *s) | ||
391 | |||
392 | static void omap_mcbsp_source_tick(void *opaque) | ||
393 | { | ||
394 | - struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque; | ||
395 | + struct omap_mcbsp_s *s = opaque; | ||
396 | static const int bps[8] = { 0, 1, 1, 2, 2, 2, -255, -255 }; | ||
397 | |||
398 | if (!s->rx_rate) | ||
399 | @@ -XXX,XX +XXX,XX @@ static void omap_mcbsp_tx_newdata(struct omap_mcbsp_s *s) | ||
400 | |||
401 | static void omap_mcbsp_sink_tick(void *opaque) | ||
402 | { | ||
403 | - struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque; | ||
404 | + struct omap_mcbsp_s *s = opaque; | ||
405 | static const int bps[8] = { 0, 1, 1, 2, 2, 2, -255, -255 }; | ||
406 | |||
407 | if (!s->tx_rate) | ||
408 | @@ -XXX,XX +XXX,XX @@ static void omap_mcbsp_req_update(struct omap_mcbsp_s *s) | ||
409 | static uint64_t omap_mcbsp_read(void *opaque, hwaddr addr, | ||
410 | unsigned size) | ||
411 | { | ||
412 | - struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque; | ||
413 | + struct omap_mcbsp_s *s = opaque; | ||
414 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
415 | uint16_t ret; | ||
416 | |||
417 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_mcbsp_read(void *opaque, hwaddr addr, | ||
418 | static void omap_mcbsp_writeh(void *opaque, hwaddr addr, | ||
419 | uint32_t value) | ||
420 | { | ||
421 | - struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque; | ||
422 | + struct omap_mcbsp_s *s = opaque; | ||
423 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
424 | |||
425 | switch (offset) { | ||
426 | @@ -XXX,XX +XXX,XX @@ static void omap_mcbsp_writeh(void *opaque, hwaddr addr, | ||
427 | static void omap_mcbsp_writew(void *opaque, hwaddr addr, | ||
428 | uint32_t value) | ||
429 | { | ||
430 | - struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque; | ||
431 | + struct omap_mcbsp_s *s = opaque; | ||
432 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
433 | |||
434 | if (offset == 0x04) { /* DXR */ | ||
435 | @@ -XXX,XX +XXX,XX @@ static struct omap_mcbsp_s *omap_mcbsp_init(MemoryRegion *system_memory, | ||
436 | |||
437 | static void omap_mcbsp_i2s_swallow(void *opaque, int line, int level) | ||
438 | { | ||
439 | - struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque; | ||
440 | + struct omap_mcbsp_s *s = opaque; | ||
441 | |||
442 | if (s->rx_rate) { | ||
443 | s->rx_req = s->codec->in.len; | ||
444 | @@ -XXX,XX +XXX,XX @@ static void omap_mcbsp_i2s_swallow(void *opaque, int line, int level) | ||
445 | |||
446 | static void omap_mcbsp_i2s_start(void *opaque, int line, int level) | ||
447 | { | ||
448 | - struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque; | ||
449 | + struct omap_mcbsp_s *s = opaque; | ||
450 | |||
451 | if (s->tx_rate) { | ||
452 | s->tx_req = s->codec->out.size; | ||
453 | @@ -XXX,XX +XXX,XX @@ static void omap_lpg_reset(struct omap_lpg_s *s) | ||
454 | omap_lpg_update(s); | ||
455 | } | ||
456 | |||
457 | -static uint64_t omap_lpg_read(void *opaque, hwaddr addr, | ||
458 | - unsigned size) | ||
459 | +static uint64_t omap_lpg_read(void *opaque, hwaddr addr, unsigned size) | ||
460 | { | ||
461 | - struct omap_lpg_s *s = (struct omap_lpg_s *) opaque; | ||
462 | + struct omap_lpg_s *s = opaque; | ||
463 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
464 | |||
465 | if (size != 1) { | ||
466 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_lpg_read(void *opaque, hwaddr addr, | ||
467 | static void omap_lpg_write(void *opaque, hwaddr addr, | ||
468 | uint64_t value, unsigned size) | ||
469 | { | ||
470 | - struct omap_lpg_s *s = (struct omap_lpg_s *) opaque; | ||
471 | + struct omap_lpg_s *s = opaque; | ||
472 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
473 | |||
474 | if (size != 1) { | ||
475 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps omap_lpg_ops = { | ||
476 | |||
477 | static void omap_lpg_clk_update(void *opaque, int line, int on) | ||
478 | { | ||
479 | - struct omap_lpg_s *s = (struct omap_lpg_s *) opaque; | ||
480 | + struct omap_lpg_s *s = opaque; | ||
481 | |||
482 | s->clk = on; | ||
483 | omap_lpg_update(s); | ||
484 | @@ -XXX,XX +XXX,XX @@ static void omap_setup_mpui_io(MemoryRegion *system_memory, | ||
485 | /* General chip reset */ | ||
486 | static void omap1_mpu_reset(void *opaque) | ||
487 | { | ||
488 | - struct omap_mpu_state_s *mpu = (struct omap_mpu_state_s *) opaque; | ||
489 | + struct omap_mpu_state_s *mpu = opaque; | ||
490 | |||
491 | omap_dma_reset(mpu->dma); | ||
492 | omap_mpu_timer_reset(mpu->timer[0]); | ||
493 | @@ -XXX,XX +XXX,XX @@ static void omap_setup_dsp_mapping(MemoryRegion *system_memory, | ||
494 | |||
495 | void omap_mpu_wakeup(void *opaque, int irq, int req) | ||
496 | { | ||
497 | - struct omap_mpu_state_s *mpu = (struct omap_mpu_state_s *) opaque; | ||
498 | + struct omap_mpu_state_s *mpu = opaque; | ||
499 | CPUState *cpu = CPU(mpu->cpu); | ||
500 | |||
501 | if (cpu->halted) { | ||
502 | diff --git a/hw/arm/omap2.c b/hw/arm/omap2.c | ||
503 | index XXXXXXX..XXXXXXX 100644 | ||
504 | --- a/hw/arm/omap2.c | ||
505 | +++ b/hw/arm/omap2.c | ||
506 | @@ -XXX,XX +XXX,XX @@ static inline void omap_eac_out_empty(struct omap_eac_s *s) | ||
507 | |||
508 | static void omap_eac_in_cb(void *opaque, int avail_b) | ||
509 | { | ||
510 | - struct omap_eac_s *s = (struct omap_eac_s *) opaque; | ||
511 | + struct omap_eac_s *s = opaque; | ||
512 | |||
513 | s->codec.rxavail = avail_b >> 2; | ||
514 | omap_eac_in_refill(s); | ||
515 | @@ -XXX,XX +XXX,XX @@ static void omap_eac_in_cb(void *opaque, int avail_b) | ||
516 | |||
517 | static void omap_eac_out_cb(void *opaque, int free_b) | ||
518 | { | ||
519 | - struct omap_eac_s *s = (struct omap_eac_s *) opaque; | ||
520 | + struct omap_eac_s *s = opaque; | ||
521 | |||
522 | s->codec.txavail = free_b >> 2; | ||
523 | if (s->codec.txlen) | ||
524 | @@ -XXX,XX +XXX,XX @@ static void omap_eac_reset(struct omap_eac_s *s) | ||
525 | omap_eac_interrupt_update(s); | ||
526 | } | ||
527 | |||
528 | -static uint64_t omap_eac_read(void *opaque, hwaddr addr, | ||
529 | - unsigned size) | ||
530 | +static uint64_t omap_eac_read(void *opaque, hwaddr addr, unsigned size) | ||
531 | { | ||
532 | - struct omap_eac_s *s = (struct omap_eac_s *) opaque; | ||
533 | + struct omap_eac_s *s = opaque; | ||
534 | uint32_t ret; | ||
535 | |||
536 | if (size != 2) { | ||
537 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_eac_read(void *opaque, hwaddr addr, | ||
538 | static void omap_eac_write(void *opaque, hwaddr addr, | ||
539 | uint64_t value, unsigned size) | ||
540 | { | ||
541 | - struct omap_eac_s *s = (struct omap_eac_s *) opaque; | ||
542 | + struct omap_eac_s *s = opaque; | ||
543 | |||
544 | if (size != 2) { | ||
545 | omap_badwidth_write16(opaque, addr, value); | ||
546 | @@ -XXX,XX +XXX,XX @@ static void omap_sti_reset(struct omap_sti_s *s) | ||
547 | static uint64_t omap_sti_read(void *opaque, hwaddr addr, | ||
548 | unsigned size) | ||
549 | { | ||
550 | - struct omap_sti_s *s = (struct omap_sti_s *) opaque; | ||
551 | + struct omap_sti_s *s = opaque; | ||
552 | |||
553 | if (size != 4) { | ||
554 | return omap_badwidth_read32(opaque, addr); | ||
555 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_sti_read(void *opaque, hwaddr addr, | ||
556 | static void omap_sti_write(void *opaque, hwaddr addr, | ||
557 | uint64_t value, unsigned size) | ||
558 | { | ||
559 | - struct omap_sti_s *s = (struct omap_sti_s *) opaque; | ||
560 | + struct omap_sti_s *s = opaque; | ||
561 | |||
562 | if (size != 4) { | ||
563 | omap_badwidth_write32(opaque, addr, value); | ||
564 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps omap_sti_ops = { | ||
565 | .endianness = DEVICE_NATIVE_ENDIAN, | ||
566 | }; | ||
567 | |||
568 | -static uint64_t omap_sti_fifo_read(void *opaque, hwaddr addr, | ||
569 | - unsigned size) | ||
570 | +static uint64_t omap_sti_fifo_read(void *opaque, hwaddr addr, unsigned size) | ||
571 | { | ||
572 | OMAP_BAD_REG(addr); | ||
573 | return 0; | ||
574 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_sti_fifo_read(void *opaque, hwaddr addr, | ||
575 | static void omap_sti_fifo_write(void *opaque, hwaddr addr, | ||
576 | uint64_t value, unsigned size) | ||
577 | { | ||
578 | - struct omap_sti_s *s = (struct omap_sti_s *) opaque; | ||
579 | + struct omap_sti_s *s = opaque; | ||
580 | int ch = addr >> 6; | ||
581 | uint8_t byte = value; | ||
582 | |||
583 | @@ -XXX,XX +XXX,XX @@ static void omap_prcm_int_update(struct omap_prcm_s *s, int dom) | ||
584 | static uint64_t omap_prcm_read(void *opaque, hwaddr addr, | ||
585 | unsigned size) | ||
586 | { | ||
587 | - struct omap_prcm_s *s = (struct omap_prcm_s *) opaque; | ||
588 | + struct omap_prcm_s *s = opaque; | ||
589 | uint32_t ret; | ||
590 | |||
591 | if (size != 4) { | ||
592 | @@ -XXX,XX +XXX,XX @@ static void omap_prcm_dpll_update(struct omap_prcm_s *s) | ||
593 | static void omap_prcm_write(void *opaque, hwaddr addr, | ||
594 | uint64_t value, unsigned size) | ||
595 | { | ||
596 | - struct omap_prcm_s *s = (struct omap_prcm_s *) opaque; | ||
597 | + struct omap_prcm_s *s = opaque; | ||
598 | |||
599 | if (size != 4) { | ||
600 | omap_badwidth_write32(opaque, addr, value); | ||
601 | @@ -XXX,XX +XXX,XX @@ struct omap_sysctl_s { | ||
602 | static uint32_t omap_sysctl_read8(void *opaque, hwaddr addr) | ||
603 | { | ||
604 | |||
605 | - struct omap_sysctl_s *s = (struct omap_sysctl_s *) opaque; | ||
606 | + struct omap_sysctl_s *s = opaque; | ||
607 | int pad_offset, byte_offset; | ||
608 | int value; | ||
609 | |||
610 | @@ -XXX,XX +XXX,XX @@ static uint32_t omap_sysctl_read8(void *opaque, hwaddr addr) | ||
611 | |||
612 | static uint32_t omap_sysctl_read(void *opaque, hwaddr addr) | ||
613 | { | ||
614 | - struct omap_sysctl_s *s = (struct omap_sysctl_s *) opaque; | ||
615 | + struct omap_sysctl_s *s = opaque; | ||
616 | |||
617 | switch (addr) { | ||
618 | case 0x000: /* CONTROL_REVISION */ | ||
619 | @@ -XXX,XX +XXX,XX @@ static uint32_t omap_sysctl_read(void *opaque, hwaddr addr) | ||
620 | return 0; | ||
621 | } | ||
622 | |||
623 | -static void omap_sysctl_write8(void *opaque, hwaddr addr, | ||
624 | - uint32_t value) | ||
625 | +static void omap_sysctl_write8(void *opaque, hwaddr addr, uint32_t value) | ||
626 | { | ||
627 | - struct omap_sysctl_s *s = (struct omap_sysctl_s *) opaque; | ||
628 | + struct omap_sysctl_s *s = opaque; | ||
629 | int pad_offset, byte_offset; | ||
630 | int prev_value; | ||
631 | |||
632 | @@ -XXX,XX +XXX,XX @@ static void omap_sysctl_write8(void *opaque, hwaddr addr, | ||
72 | } | 633 | } |
73 | 634 | } | |
74 | if (cpu_isar_feature(aa64_sve, cpu)) { | 635 | |
75 | - define_one_arm_cp_reg(cpu, &zcr_el1_reginfo); | 636 | -static void omap_sysctl_write(void *opaque, hwaddr addr, |
76 | - if (arm_feature(env, ARM_FEATURE_EL2)) { | 637 | - uint32_t value) |
77 | - define_one_arm_cp_reg(cpu, &zcr_el2_reginfo); | 638 | +static void omap_sysctl_write(void *opaque, hwaddr addr, uint32_t value) |
78 | - } else { | 639 | { |
79 | - define_one_arm_cp_reg(cpu, &zcr_no_el2_reginfo); | 640 | - struct omap_sysctl_s *s = (struct omap_sysctl_s *) opaque; |
80 | - } | 641 | + struct omap_sysctl_s *s = opaque; |
81 | - if (arm_feature(env, ARM_FEATURE_EL3)) { | 642 | |
82 | - define_one_arm_cp_reg(cpu, &zcr_el3_reginfo); | 643 | switch (addr) { |
83 | - } | 644 | case 0x000: /* CONTROL_REVISION */ |
84 | + define_arm_cp_regs(cpu, zcr_reginfo); | 645 | @@ -XXX,XX +XXX,XX @@ static struct omap_sysctl_s *omap_sysctl_init(struct omap_target_agent_s *ta, |
646 | /* General chip reset */ | ||
647 | static void omap2_mpu_reset(void *opaque) | ||
648 | { | ||
649 | - struct omap_mpu_state_s *mpu = (struct omap_mpu_state_s *) opaque; | ||
650 | + struct omap_mpu_state_s *mpu = opaque; | ||
651 | |||
652 | omap_dma_reset(mpu->dma); | ||
653 | omap_prcm_reset(mpu->prcm); | ||
654 | diff --git a/hw/arm/omap_sx1.c b/hw/arm/omap_sx1.c | ||
655 | index XXXXXXX..XXXXXXX 100644 | ||
656 | --- a/hw/arm/omap_sx1.c | ||
657 | +++ b/hw/arm/omap_sx1.c | ||
658 | @@ -XXX,XX +XXX,XX @@ | ||
659 | static uint64_t static_read(void *opaque, hwaddr offset, | ||
660 | unsigned size) | ||
661 | { | ||
662 | - uint32_t *val = (uint32_t *) opaque; | ||
663 | + uint32_t *val = opaque; | ||
664 | uint32_t mask = (4 / size) - 1; | ||
665 | |||
666 | return *val >> ((offset & mask) << 3); | ||
667 | diff --git a/hw/arm/palm.c b/hw/arm/palm.c | ||
668 | index XXXXXXX..XXXXXXX 100644 | ||
669 | --- a/hw/arm/palm.c | ||
670 | +++ b/hw/arm/palm.c | ||
671 | @@ -XXX,XX +XXX,XX @@ static struct { | ||
672 | |||
673 | static void palmte_button_event(void *opaque, int keycode) | ||
674 | { | ||
675 | - struct omap_mpu_state_s *cpu = (struct omap_mpu_state_s *) opaque; | ||
676 | + struct omap_mpu_state_s *cpu = opaque; | ||
677 | |||
678 | if (palmte_keymap[keycode & 0x7f].row != -1) | ||
679 | omap_mpuio_key(cpu->mpuio, | ||
680 | diff --git a/hw/char/omap_uart.c b/hw/char/omap_uart.c | ||
681 | index XXXXXXX..XXXXXXX 100644 | ||
682 | --- a/hw/char/omap_uart.c | ||
683 | +++ b/hw/char/omap_uart.c | ||
684 | @@ -XXX,XX +XXX,XX @@ struct omap_uart_s *omap_uart_init(hwaddr base, | ||
685 | return s; | ||
686 | } | ||
687 | |||
688 | -static uint64_t omap_uart_read(void *opaque, hwaddr addr, | ||
689 | - unsigned size) | ||
690 | +static uint64_t omap_uart_read(void *opaque, hwaddr addr, unsigned size) | ||
691 | { | ||
692 | - struct omap_uart_s *s = (struct omap_uart_s *) opaque; | ||
693 | + struct omap_uart_s *s = opaque; | ||
694 | |||
695 | if (size == 4) { | ||
696 | return omap_badwidth_read8(opaque, addr); | ||
697 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_uart_read(void *opaque, hwaddr addr, | ||
698 | static void omap_uart_write(void *opaque, hwaddr addr, | ||
699 | uint64_t value, unsigned size) | ||
700 | { | ||
701 | - struct omap_uart_s *s = (struct omap_uart_s *) opaque; | ||
702 | + struct omap_uart_s *s = opaque; | ||
703 | |||
704 | if (size == 4) { | ||
705 | omap_badwidth_write8(opaque, addr, value); | ||
706 | diff --git a/hw/display/omap_dss.c b/hw/display/omap_dss.c | ||
707 | index XXXXXXX..XXXXXXX 100644 | ||
708 | --- a/hw/display/omap_dss.c | ||
709 | +++ b/hw/display/omap_dss.c | ||
710 | @@ -XXX,XX +XXX,XX @@ void omap_dss_reset(struct omap_dss_s *s) | ||
711 | static uint64_t omap_diss_read(void *opaque, hwaddr addr, | ||
712 | unsigned size) | ||
713 | { | ||
714 | - struct omap_dss_s *s = (struct omap_dss_s *) opaque; | ||
715 | + struct omap_dss_s *s = opaque; | ||
716 | |||
717 | if (size != 4) { | ||
718 | return omap_badwidth_read32(opaque, addr); | ||
719 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_diss_read(void *opaque, hwaddr addr, | ||
720 | static void omap_diss_write(void *opaque, hwaddr addr, | ||
721 | uint64_t value, unsigned size) | ||
722 | { | ||
723 | - struct omap_dss_s *s = (struct omap_dss_s *) opaque; | ||
724 | + struct omap_dss_s *s = opaque; | ||
725 | |||
726 | if (size != 4) { | ||
727 | omap_badwidth_write32(opaque, addr, value); | ||
728 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps omap_diss_ops = { | ||
729 | static uint64_t omap_disc_read(void *opaque, hwaddr addr, | ||
730 | unsigned size) | ||
731 | { | ||
732 | - struct omap_dss_s *s = (struct omap_dss_s *) opaque; | ||
733 | + struct omap_dss_s *s = opaque; | ||
734 | |||
735 | if (size != 4) { | ||
736 | return omap_badwidth_read32(opaque, addr); | ||
737 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_disc_read(void *opaque, hwaddr addr, | ||
738 | static void omap_disc_write(void *opaque, hwaddr addr, | ||
739 | uint64_t value, unsigned size) | ||
740 | { | ||
741 | - struct omap_dss_s *s = (struct omap_dss_s *) opaque; | ||
742 | + struct omap_dss_s *s = opaque; | ||
743 | |||
744 | if (size != 4) { | ||
745 | omap_badwidth_write32(opaque, addr, value); | ||
746 | @@ -XXX,XX +XXX,XX @@ static void omap_rfbi_transfer_start(struct omap_dss_s *s) | ||
747 | omap_dispc_interrupt_update(s); | ||
748 | } | ||
749 | |||
750 | -static uint64_t omap_rfbi_read(void *opaque, hwaddr addr, | ||
751 | - unsigned size) | ||
752 | +static uint64_t omap_rfbi_read(void *opaque, hwaddr addr, unsigned size) | ||
753 | { | ||
754 | - struct omap_dss_s *s = (struct omap_dss_s *) opaque; | ||
755 | + struct omap_dss_s *s = opaque; | ||
756 | |||
757 | if (size != 4) { | ||
758 | return omap_badwidth_read32(opaque, addr); | ||
759 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_rfbi_read(void *opaque, hwaddr addr, | ||
760 | static void omap_rfbi_write(void *opaque, hwaddr addr, | ||
761 | uint64_t value, unsigned size) | ||
762 | { | ||
763 | - struct omap_dss_s *s = (struct omap_dss_s *) opaque; | ||
764 | + struct omap_dss_s *s = opaque; | ||
765 | |||
766 | if (size != 4) { | ||
767 | omap_badwidth_write32(opaque, addr, value); | ||
768 | diff --git a/hw/display/omap_lcdc.c b/hw/display/omap_lcdc.c | ||
769 | index XXXXXXX..XXXXXXX 100644 | ||
770 | --- a/hw/display/omap_lcdc.c | ||
771 | +++ b/hw/display/omap_lcdc.c | ||
772 | @@ -XXX,XX +XXX,XX @@ static void draw_line16_32(void *opaque, uint8_t *d, const uint8_t *s, | ||
773 | |||
774 | static void omap_update_display(void *opaque) | ||
775 | { | ||
776 | - struct omap_lcd_panel_s *omap_lcd = (struct omap_lcd_panel_s *) opaque; | ||
777 | + struct omap_lcd_panel_s *omap_lcd = opaque; | ||
778 | DisplaySurface *surface; | ||
779 | drawfn draw_line; | ||
780 | int size, height, first, last; | ||
781 | @@ -XXX,XX +XXX,XX @@ static void omap_lcd_update(struct omap_lcd_panel_s *s) { | ||
85 | } | 782 | } |
86 | 783 | } | |
87 | #ifdef TARGET_AARCH64 | 784 | |
785 | -static uint64_t omap_lcdc_read(void *opaque, hwaddr addr, | ||
786 | - unsigned size) | ||
787 | +static uint64_t omap_lcdc_read(void *opaque, hwaddr addr, unsigned size) | ||
788 | { | ||
789 | - struct omap_lcd_panel_s *s = (struct omap_lcd_panel_s *) opaque; | ||
790 | + struct omap_lcd_panel_s *s = opaque; | ||
791 | |||
792 | switch (addr) { | ||
793 | case 0x00: /* LCD_CONTROL */ | ||
794 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_lcdc_read(void *opaque, hwaddr addr, | ||
795 | static void omap_lcdc_write(void *opaque, hwaddr addr, | ||
796 | uint64_t value, unsigned size) | ||
797 | { | ||
798 | - struct omap_lcd_panel_s *s = (struct omap_lcd_panel_s *) opaque; | ||
799 | + struct omap_lcd_panel_s *s = opaque; | ||
800 | |||
801 | switch (addr) { | ||
802 | case 0x00: /* LCD_CONTROL */ | ||
803 | diff --git a/hw/dma/omap_dma.c b/hw/dma/omap_dma.c | ||
804 | index XXXXXXX..XXXXXXX 100644 | ||
805 | --- a/hw/dma/omap_dma.c | ||
806 | +++ b/hw/dma/omap_dma.c | ||
807 | @@ -XXX,XX +XXX,XX @@ static int omap_dma_sys_read(struct omap_dma_s *s, int offset, | ||
808 | return 0; | ||
809 | } | ||
810 | |||
811 | -static uint64_t omap_dma_read(void *opaque, hwaddr addr, | ||
812 | - unsigned size) | ||
813 | +static uint64_t omap_dma_read(void *opaque, hwaddr addr, unsigned size) | ||
814 | { | ||
815 | - struct omap_dma_s *s = (struct omap_dma_s *) opaque; | ||
816 | + struct omap_dma_s *s = opaque; | ||
817 | int reg, ch; | ||
818 | uint16_t ret; | ||
819 | |||
820 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_dma_read(void *opaque, hwaddr addr, | ||
821 | static void omap_dma_write(void *opaque, hwaddr addr, | ||
822 | uint64_t value, unsigned size) | ||
823 | { | ||
824 | - struct omap_dma_s *s = (struct omap_dma_s *) opaque; | ||
825 | + struct omap_dma_s *s = opaque; | ||
826 | int reg, ch; | ||
827 | |||
828 | if (size != 2) { | ||
829 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps omap_dma_ops = { | ||
830 | |||
831 | static void omap_dma_request(void *opaque, int drq, int req) | ||
832 | { | ||
833 | - struct omap_dma_s *s = (struct omap_dma_s *) opaque; | ||
834 | + struct omap_dma_s *s = opaque; | ||
835 | /* The request pins are level triggered in QEMU. */ | ||
836 | if (req) { | ||
837 | if (~s->dma->drqbmp & (1ULL << drq)) { | ||
838 | @@ -XXX,XX +XXX,XX @@ static void omap_dma_request(void *opaque, int drq, int req) | ||
839 | /* XXX: this won't be needed once soc_dma knows about clocks. */ | ||
840 | static void omap_dma_clk_update(void *opaque, int line, int on) | ||
841 | { | ||
842 | - struct omap_dma_s *s = (struct omap_dma_s *) opaque; | ||
843 | + struct omap_dma_s *s = opaque; | ||
844 | int i; | ||
845 | |||
846 | s->dma->freq = omap_clk_getrate(s->clk); | ||
847 | @@ -XXX,XX +XXX,XX @@ static void omap_dma_interrupts_4_update(struct omap_dma_s *s) | ||
848 | static uint64_t omap_dma4_read(void *opaque, hwaddr addr, | ||
849 | unsigned size) | ||
850 | { | ||
851 | - struct omap_dma_s *s = (struct omap_dma_s *) opaque; | ||
852 | + struct omap_dma_s *s = opaque; | ||
853 | int irqn = 0, chnum; | ||
854 | struct omap_dma_channel_s *ch; | ||
855 | |||
856 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_dma4_read(void *opaque, hwaddr addr, | ||
857 | static void omap_dma4_write(void *opaque, hwaddr addr, | ||
858 | uint64_t value, unsigned size) | ||
859 | { | ||
860 | - struct omap_dma_s *s = (struct omap_dma_s *) opaque; | ||
861 | + struct omap_dma_s *s = opaque; | ||
862 | int chnum, irqn = 0; | ||
863 | struct omap_dma_channel_s *ch; | ||
864 | |||
865 | diff --git a/hw/gpio/omap_gpio.c b/hw/gpio/omap_gpio.c | ||
866 | index XXXXXXX..XXXXXXX 100644 | ||
867 | --- a/hw/gpio/omap_gpio.c | ||
868 | +++ b/hw/gpio/omap_gpio.c | ||
869 | @@ -XXX,XX +XXX,XX @@ static void omap_gpio_set(void *opaque, int line, int level) | ||
870 | static uint64_t omap_gpio_read(void *opaque, hwaddr addr, | ||
871 | unsigned size) | ||
872 | { | ||
873 | - struct omap_gpio_s *s = (struct omap_gpio_s *) opaque; | ||
874 | + struct omap_gpio_s *s = opaque; | ||
875 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
876 | |||
877 | if (size != 2) { | ||
878 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_gpio_read(void *opaque, hwaddr addr, | ||
879 | static void omap_gpio_write(void *opaque, hwaddr addr, | ||
880 | uint64_t value, unsigned size) | ||
881 | { | ||
882 | - struct omap_gpio_s *s = (struct omap_gpio_s *) opaque; | ||
883 | + struct omap_gpio_s *s = opaque; | ||
884 | int offset = addr & OMAP_MPUI_REG_MASK; | ||
885 | uint16_t diff; | ||
886 | int ln; | ||
887 | @@ -XXX,XX +XXX,XX @@ static void omap2_gpio_module_reset(struct omap2_gpio_s *s) | ||
888 | |||
889 | static uint32_t omap2_gpio_module_read(void *opaque, hwaddr addr) | ||
890 | { | ||
891 | - struct omap2_gpio_s *s = (struct omap2_gpio_s *) opaque; | ||
892 | + struct omap2_gpio_s *s = opaque; | ||
893 | |||
894 | switch (addr) { | ||
895 | case 0x00: /* GPIO_REVISION */ | ||
896 | @@ -XXX,XX +XXX,XX @@ static uint32_t omap2_gpio_module_read(void *opaque, hwaddr addr) | ||
897 | static void omap2_gpio_module_write(void *opaque, hwaddr addr, | ||
898 | uint32_t value) | ||
899 | { | ||
900 | - struct omap2_gpio_s *s = (struct omap2_gpio_s *) opaque; | ||
901 | + struct omap2_gpio_s *s = opaque; | ||
902 | uint32_t diff; | ||
903 | int ln; | ||
904 | |||
905 | @@ -XXX,XX +XXX,XX @@ static void omap2_gpif_reset(DeviceState *dev) | ||
906 | s->gpo = 0; | ||
907 | } | ||
908 | |||
909 | -static uint64_t omap2_gpif_top_read(void *opaque, hwaddr addr, | ||
910 | - unsigned size) | ||
911 | +static uint64_t omap2_gpif_top_read(void *opaque, hwaddr addr, unsigned size) | ||
912 | { | ||
913 | - struct omap2_gpif_s *s = (struct omap2_gpif_s *) opaque; | ||
914 | + struct omap2_gpif_s *s = opaque; | ||
915 | |||
916 | switch (addr) { | ||
917 | case 0x00: /* IPGENERICOCPSPL_REVISION */ | ||
918 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap2_gpif_top_read(void *opaque, hwaddr addr, | ||
919 | static void omap2_gpif_top_write(void *opaque, hwaddr addr, | ||
920 | uint64_t value, unsigned size) | ||
921 | { | ||
922 | - struct omap2_gpif_s *s = (struct omap2_gpif_s *) opaque; | ||
923 | + struct omap2_gpif_s *s = opaque; | ||
924 | |||
925 | switch (addr) { | ||
926 | case 0x00: /* IPGENERICOCPSPL_REVISION */ | ||
927 | diff --git a/hw/intc/omap_intc.c b/hw/intc/omap_intc.c | ||
928 | index XXXXXXX..XXXXXXX 100644 | ||
929 | --- a/hw/intc/omap_intc.c | ||
930 | +++ b/hw/intc/omap_intc.c | ||
931 | @@ -XXX,XX +XXX,XX @@ static inline void omap_inth_update(struct omap_intr_handler_s *s, int is_fiq) | ||
932 | |||
933 | static void omap_set_intr(void *opaque, int irq, int req) | ||
934 | { | ||
935 | - struct omap_intr_handler_s *ih = (struct omap_intr_handler_s *) opaque; | ||
936 | + struct omap_intr_handler_s *ih = opaque; | ||
937 | uint32_t rise; | ||
938 | |||
939 | struct omap_intr_handler_bank_s *bank = &ih->bank[irq >> 5]; | ||
940 | @@ -XXX,XX +XXX,XX @@ static void omap_set_intr(void *opaque, int irq, int req) | ||
941 | /* Simplified version with no edge detection */ | ||
942 | static void omap_set_intr_noedge(void *opaque, int irq, int req) | ||
943 | { | ||
944 | - struct omap_intr_handler_s *ih = (struct omap_intr_handler_s *) opaque; | ||
945 | + struct omap_intr_handler_s *ih = opaque; | ||
946 | uint32_t rise; | ||
947 | |||
948 | struct omap_intr_handler_bank_s *bank = &ih->bank[irq >> 5]; | ||
949 | @@ -XXX,XX +XXX,XX @@ static void omap_set_intr_noedge(void *opaque, int irq, int req) | ||
950 | static uint64_t omap_inth_read(void *opaque, hwaddr addr, | ||
951 | unsigned size) | ||
952 | { | ||
953 | - struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque; | ||
954 | + struct omap_intr_handler_s *s = opaque; | ||
955 | int i, offset = addr; | ||
956 | int bank_no = offset >> 8; | ||
957 | int line_no; | ||
958 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_inth_read(void *opaque, hwaddr addr, | ||
959 | static void omap_inth_write(void *opaque, hwaddr addr, | ||
960 | uint64_t value, unsigned size) | ||
961 | { | ||
962 | - struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque; | ||
963 | + struct omap_intr_handler_s *s = opaque; | ||
964 | int i, offset = addr; | ||
965 | int bank_no = offset >> 8; | ||
966 | struct omap_intr_handler_bank_s *bank = &s->bank[bank_no]; | ||
967 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo omap_intc_info = { | ||
968 | static uint64_t omap2_inth_read(void *opaque, hwaddr addr, | ||
969 | unsigned size) | ||
970 | { | ||
971 | - struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque; | ||
972 | + struct omap_intr_handler_s *s = opaque; | ||
973 | int offset = addr; | ||
974 | int bank_no, line_no; | ||
975 | struct omap_intr_handler_bank_s *bank = NULL; | ||
976 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap2_inth_read(void *opaque, hwaddr addr, | ||
977 | static void omap2_inth_write(void *opaque, hwaddr addr, | ||
978 | uint64_t value, unsigned size) | ||
979 | { | ||
980 | - struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque; | ||
981 | + struct omap_intr_handler_s *s = opaque; | ||
982 | int offset = addr; | ||
983 | int bank_no, line_no; | ||
984 | struct omap_intr_handler_bank_s *bank = NULL; | ||
985 | diff --git a/hw/misc/omap_gpmc.c b/hw/misc/omap_gpmc.c | ||
986 | index XXXXXXX..XXXXXXX 100644 | ||
987 | --- a/hw/misc/omap_gpmc.c | ||
988 | +++ b/hw/misc/omap_gpmc.c | ||
989 | @@ -XXX,XX +XXX,XX @@ static void omap_gpmc_dma_update(struct omap_gpmc_s *s, int value) | ||
990 | static uint64_t omap_nand_read(void *opaque, hwaddr addr, | ||
991 | unsigned size) | ||
992 | { | ||
993 | - struct omap_gpmc_cs_file_s *f = (struct omap_gpmc_cs_file_s *)opaque; | ||
994 | + struct omap_gpmc_cs_file_s *f = opaque; | ||
995 | uint64_t v; | ||
996 | nand_setpins(f->dev, 0, 0, 0, 1, 0); | ||
997 | switch (omap_gpmc_devsize(f)) { | ||
998 | @@ -XXX,XX +XXX,XX @@ static void omap_nand_setio(DeviceState *dev, uint64_t value, | ||
999 | static void omap_nand_write(void *opaque, hwaddr addr, | ||
1000 | uint64_t value, unsigned size) | ||
1001 | { | ||
1002 | - struct omap_gpmc_cs_file_s *f = (struct omap_gpmc_cs_file_s *)opaque; | ||
1003 | + struct omap_gpmc_cs_file_s *f = opaque; | ||
1004 | nand_setpins(f->dev, 0, 0, 0, 1, 0); | ||
1005 | omap_nand_setio(f->dev, value, omap_gpmc_devsize(f), size); | ||
1006 | } | ||
1007 | @@ -XXX,XX +XXX,XX @@ static void fill_prefetch_fifo(struct omap_gpmc_s *s) | ||
1008 | static uint64_t omap_gpmc_prefetch_read(void *opaque, hwaddr addr, | ||
1009 | unsigned size) | ||
1010 | { | ||
1011 | - struct omap_gpmc_s *s = (struct omap_gpmc_s *) opaque; | ||
1012 | + struct omap_gpmc_s *s = opaque; | ||
1013 | uint32_t data; | ||
1014 | if (s->prefetch.config1 & 1) { | ||
1015 | /* The TRM doesn't define the behaviour if you read from the | ||
1016 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_gpmc_prefetch_read(void *opaque, hwaddr addr, | ||
1017 | static void omap_gpmc_prefetch_write(void *opaque, hwaddr addr, | ||
1018 | uint64_t value, unsigned size) | ||
1019 | { | ||
1020 | - struct omap_gpmc_s *s = (struct omap_gpmc_s *) opaque; | ||
1021 | + struct omap_gpmc_s *s = opaque; | ||
1022 | int cs = prefetch_cs(s->prefetch.config1); | ||
1023 | if ((s->prefetch.config1 & 1) == 0) { | ||
1024 | /* The TRM doesn't define the behaviour of writing to the | ||
1025 | @@ -XXX,XX +XXX,XX @@ static int gpmc_wordaccess_only(hwaddr addr) | ||
1026 | static uint64_t omap_gpmc_read(void *opaque, hwaddr addr, | ||
1027 | unsigned size) | ||
1028 | { | ||
1029 | - struct omap_gpmc_s *s = (struct omap_gpmc_s *) opaque; | ||
1030 | + struct omap_gpmc_s *s = opaque; | ||
1031 | int cs; | ||
1032 | struct omap_gpmc_cs_file_s *f; | ||
1033 | |||
1034 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_gpmc_read(void *opaque, hwaddr addr, | ||
1035 | static void omap_gpmc_write(void *opaque, hwaddr addr, | ||
1036 | uint64_t value, unsigned size) | ||
1037 | { | ||
1038 | - struct omap_gpmc_s *s = (struct omap_gpmc_s *) opaque; | ||
1039 | + struct omap_gpmc_s *s = opaque; | ||
1040 | int cs; | ||
1041 | struct omap_gpmc_cs_file_s *f; | ||
1042 | |||
1043 | diff --git a/hw/misc/omap_l4.c b/hw/misc/omap_l4.c | ||
1044 | index XXXXXXX..XXXXXXX 100644 | ||
1045 | --- a/hw/misc/omap_l4.c | ||
1046 | +++ b/hw/misc/omap_l4.c | ||
1047 | @@ -XXX,XX +XXX,XX @@ hwaddr omap_l4_region_size(struct omap_target_agent_s *ta, | ||
1048 | return ta->start[region].size; | ||
1049 | } | ||
1050 | |||
1051 | -static uint64_t omap_l4ta_read(void *opaque, hwaddr addr, | ||
1052 | - unsigned size) | ||
1053 | +static uint64_t omap_l4ta_read(void *opaque, hwaddr addr, unsigned size) | ||
1054 | { | ||
1055 | - struct omap_target_agent_s *s = (struct omap_target_agent_s *) opaque; | ||
1056 | + struct omap_target_agent_s *s = opaque; | ||
1057 | |||
1058 | if (size != 2) { | ||
1059 | return omap_badwidth_read16(opaque, addr); | ||
1060 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_l4ta_read(void *opaque, hwaddr addr, | ||
1061 | static void omap_l4ta_write(void *opaque, hwaddr addr, | ||
1062 | uint64_t value, unsigned size) | ||
1063 | { | ||
1064 | - struct omap_target_agent_s *s = (struct omap_target_agent_s *) opaque; | ||
1065 | + struct omap_target_agent_s *s = opaque; | ||
1066 | |||
1067 | if (size != 4) { | ||
1068 | omap_badwidth_write32(opaque, addr, value); | ||
1069 | diff --git a/hw/misc/omap_sdrc.c b/hw/misc/omap_sdrc.c | ||
1070 | index XXXXXXX..XXXXXXX 100644 | ||
1071 | --- a/hw/misc/omap_sdrc.c | ||
1072 | +++ b/hw/misc/omap_sdrc.c | ||
1073 | @@ -XXX,XX +XXX,XX @@ void omap_sdrc_reset(struct omap_sdrc_s *s) | ||
1074 | s->config = 0x10; | ||
1075 | } | ||
1076 | |||
1077 | -static uint64_t omap_sdrc_read(void *opaque, hwaddr addr, | ||
1078 | - unsigned size) | ||
1079 | +static uint64_t omap_sdrc_read(void *opaque, hwaddr addr, unsigned size) | ||
1080 | { | ||
1081 | - struct omap_sdrc_s *s = (struct omap_sdrc_s *) opaque; | ||
1082 | + struct omap_sdrc_s *s = opaque; | ||
1083 | |||
1084 | if (size != 4) { | ||
1085 | return omap_badwidth_read32(opaque, addr); | ||
1086 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_sdrc_read(void *opaque, hwaddr addr, | ||
1087 | static void omap_sdrc_write(void *opaque, hwaddr addr, | ||
1088 | uint64_t value, unsigned size) | ||
1089 | { | ||
1090 | - struct omap_sdrc_s *s = (struct omap_sdrc_s *) opaque; | ||
1091 | + struct omap_sdrc_s *s = opaque; | ||
1092 | |||
1093 | if (size != 4) { | ||
1094 | omap_badwidth_write32(opaque, addr, value); | ||
1095 | diff --git a/hw/misc/omap_tap.c b/hw/misc/omap_tap.c | ||
1096 | index XXXXXXX..XXXXXXX 100644 | ||
1097 | --- a/hw/misc/omap_tap.c | ||
1098 | +++ b/hw/misc/omap_tap.c | ||
1099 | @@ -XXX,XX +XXX,XX @@ | ||
1100 | #include "hw/arm/omap.h" | ||
1101 | |||
1102 | /* TEST-Chip-level TAP */ | ||
1103 | -static uint64_t omap_tap_read(void *opaque, hwaddr addr, | ||
1104 | - unsigned size) | ||
1105 | +static uint64_t omap_tap_read(void *opaque, hwaddr addr, unsigned size) | ||
1106 | { | ||
1107 | - struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque; | ||
1108 | + struct omap_mpu_state_s *s = opaque; | ||
1109 | |||
1110 | if (size != 4) { | ||
1111 | return omap_badwidth_read32(opaque, addr); | ||
1112 | diff --git a/hw/sd/omap_mmc.c b/hw/sd/omap_mmc.c | ||
1113 | index XXXXXXX..XXXXXXX 100644 | ||
1114 | --- a/hw/sd/omap_mmc.c | ||
1115 | +++ b/hw/sd/omap_mmc.c | ||
1116 | @@ -XXX,XX +XXX,XX @@ void omap_mmc_reset(struct omap_mmc_s *host) | ||
1117 | device_cold_reset(DEVICE(host->card)); | ||
1118 | } | ||
1119 | |||
1120 | -static uint64_t omap_mmc_read(void *opaque, hwaddr offset, | ||
1121 | - unsigned size) | ||
1122 | +static uint64_t omap_mmc_read(void *opaque, hwaddr offset, unsigned size) | ||
1123 | { | ||
1124 | uint16_t i; | ||
1125 | - struct omap_mmc_s *s = (struct omap_mmc_s *) opaque; | ||
1126 | + struct omap_mmc_s *s = opaque; | ||
1127 | |||
1128 | if (size != 2) { | ||
1129 | return omap_badwidth_read16(opaque, offset); | ||
1130 | @@ -XXX,XX +XXX,XX @@ static void omap_mmc_write(void *opaque, hwaddr offset, | ||
1131 | uint64_t value, unsigned size) | ||
1132 | { | ||
1133 | int i; | ||
1134 | - struct omap_mmc_s *s = (struct omap_mmc_s *) opaque; | ||
1135 | + struct omap_mmc_s *s = opaque; | ||
1136 | |||
1137 | if (size != 2) { | ||
1138 | omap_badwidth_write16(opaque, offset, value); | ||
1139 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps omap_mmc_ops = { | ||
1140 | |||
1141 | static void omap_mmc_cover_cb(void *opaque, int line, int level) | ||
1142 | { | ||
1143 | - struct omap_mmc_s *host = (struct omap_mmc_s *) opaque; | ||
1144 | + struct omap_mmc_s *host = opaque; | ||
1145 | |||
1146 | if (!host->cdet_state && level) { | ||
1147 | host->status |= 0x0002; | ||
1148 | diff --git a/hw/ssi/omap_spi.c b/hw/ssi/omap_spi.c | ||
1149 | index XXXXXXX..XXXXXXX 100644 | ||
1150 | --- a/hw/ssi/omap_spi.c | ||
1151 | +++ b/hw/ssi/omap_spi.c | ||
1152 | @@ -XXX,XX +XXX,XX @@ void omap_mcspi_reset(struct omap_mcspi_s *s) | ||
1153 | omap_mcspi_interrupt_update(s); | ||
1154 | } | ||
1155 | |||
1156 | -static uint64_t omap_mcspi_read(void *opaque, hwaddr addr, | ||
1157 | - unsigned size) | ||
1158 | +static uint64_t omap_mcspi_read(void *opaque, hwaddr addr, unsigned size) | ||
1159 | { | ||
1160 | - struct omap_mcspi_s *s = (struct omap_mcspi_s *) opaque; | ||
1161 | + struct omap_mcspi_s *s = opaque; | ||
1162 | int ch = 0; | ||
1163 | uint32_t ret; | ||
1164 | |||
1165 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_mcspi_read(void *opaque, hwaddr addr, | ||
1166 | static void omap_mcspi_write(void *opaque, hwaddr addr, | ||
1167 | uint64_t value, unsigned size) | ||
1168 | { | ||
1169 | - struct omap_mcspi_s *s = (struct omap_mcspi_s *) opaque; | ||
1170 | + struct omap_mcspi_s *s = opaque; | ||
1171 | int ch = 0; | ||
1172 | |||
1173 | if (size != 4) { | ||
1174 | diff --git a/hw/timer/omap_gptimer.c b/hw/timer/omap_gptimer.c | ||
1175 | index XXXXXXX..XXXXXXX 100644 | ||
1176 | --- a/hw/timer/omap_gptimer.c | ||
1177 | +++ b/hw/timer/omap_gptimer.c | ||
1178 | @@ -XXX,XX +XXX,XX @@ static inline void omap_gp_timer_trigger(struct omap_gp_timer_s *timer) | ||
1179 | |||
1180 | static void omap_gp_timer_tick(void *opaque) | ||
1181 | { | ||
1182 | - struct omap_gp_timer_s *timer = (struct omap_gp_timer_s *) opaque; | ||
1183 | + struct omap_gp_timer_s *timer = opaque; | ||
1184 | |||
1185 | if (!timer->ar) { | ||
1186 | timer->st = 0; | ||
1187 | @@ -XXX,XX +XXX,XX @@ static void omap_gp_timer_tick(void *opaque) | ||
1188 | |||
1189 | static void omap_gp_timer_match(void *opaque) | ||
1190 | { | ||
1191 | - struct omap_gp_timer_s *timer = (struct omap_gp_timer_s *) opaque; | ||
1192 | + struct omap_gp_timer_s *timer = opaque; | ||
1193 | |||
1194 | if (timer->trigger == gpt_trigger_both) | ||
1195 | omap_gp_timer_trigger(timer); | ||
1196 | @@ -XXX,XX +XXX,XX @@ static void omap_gp_timer_match(void *opaque) | ||
1197 | |||
1198 | static void omap_gp_timer_input(void *opaque, int line, int on) | ||
1199 | { | ||
1200 | - struct omap_gp_timer_s *s = (struct omap_gp_timer_s *) opaque; | ||
1201 | + struct omap_gp_timer_s *s = opaque; | ||
1202 | int trigger; | ||
1203 | |||
1204 | switch (s->capture) { | ||
1205 | @@ -XXX,XX +XXX,XX @@ static void omap_gp_timer_input(void *opaque, int line, int on) | ||
1206 | |||
1207 | static void omap_gp_timer_clk_update(void *opaque, int line, int on) | ||
1208 | { | ||
1209 | - struct omap_gp_timer_s *timer = (struct omap_gp_timer_s *) opaque; | ||
1210 | + struct omap_gp_timer_s *timer = opaque; | ||
1211 | |||
1212 | omap_gp_timer_sync(timer); | ||
1213 | timer->rate = on ? omap_clk_getrate(timer->clk) : 0; | ||
1214 | @@ -XXX,XX +XXX,XX @@ void omap_gp_timer_reset(struct omap_gp_timer_s *s) | ||
1215 | |||
1216 | static uint32_t omap_gp_timer_readw(void *opaque, hwaddr addr) | ||
1217 | { | ||
1218 | - struct omap_gp_timer_s *s = (struct omap_gp_timer_s *) opaque; | ||
1219 | + struct omap_gp_timer_s *s = opaque; | ||
1220 | |||
1221 | switch (addr) { | ||
1222 | case 0x00: /* TIDR */ | ||
1223 | @@ -XXX,XX +XXX,XX @@ static uint32_t omap_gp_timer_readw(void *opaque, hwaddr addr) | ||
1224 | |||
1225 | static uint32_t omap_gp_timer_readh(void *opaque, hwaddr addr) | ||
1226 | { | ||
1227 | - struct omap_gp_timer_s *s = (struct omap_gp_timer_s *) opaque; | ||
1228 | + struct omap_gp_timer_s *s = opaque; | ||
1229 | uint32_t ret; | ||
1230 | |||
1231 | if (addr & 2) | ||
1232 | @@ -XXX,XX +XXX,XX @@ static uint32_t omap_gp_timer_readh(void *opaque, hwaddr addr) | ||
1233 | } | ||
1234 | } | ||
1235 | |||
1236 | -static void omap_gp_timer_write(void *opaque, hwaddr addr, | ||
1237 | - uint32_t value) | ||
1238 | +static void omap_gp_timer_write(void *opaque, hwaddr addr, uint32_t value) | ||
1239 | { | ||
1240 | - struct omap_gp_timer_s *s = (struct omap_gp_timer_s *) opaque; | ||
1241 | + struct omap_gp_timer_s *s = opaque; | ||
1242 | |||
1243 | switch (addr) { | ||
1244 | case 0x00: /* TIDR */ | ||
1245 | @@ -XXX,XX +XXX,XX @@ static void omap_gp_timer_write(void *opaque, hwaddr addr, | ||
1246 | } | ||
1247 | } | ||
1248 | |||
1249 | -static void omap_gp_timer_writeh(void *opaque, hwaddr addr, | ||
1250 | - uint32_t value) | ||
1251 | +static void omap_gp_timer_writeh(void *opaque, hwaddr addr, uint32_t value) | ||
1252 | { | ||
1253 | - struct omap_gp_timer_s *s = (struct omap_gp_timer_s *) opaque; | ||
1254 | + struct omap_gp_timer_s *s = opaque; | ||
1255 | |||
1256 | if (addr & 2) | ||
1257 | omap_gp_timer_write(opaque, addr, (value << 16) | s->writeh); | ||
1258 | diff --git a/hw/timer/omap_synctimer.c b/hw/timer/omap_synctimer.c | ||
1259 | index XXXXXXX..XXXXXXX 100644 | ||
1260 | --- a/hw/timer/omap_synctimer.c | ||
1261 | +++ b/hw/timer/omap_synctimer.c | ||
1262 | @@ -XXX,XX +XXX,XX @@ void omap_synctimer_reset(struct omap_synctimer_s *s) | ||
1263 | |||
1264 | static uint32_t omap_synctimer_readw(void *opaque, hwaddr addr) | ||
1265 | { | ||
1266 | - struct omap_synctimer_s *s = (struct omap_synctimer_s *) opaque; | ||
1267 | + struct omap_synctimer_s *s = opaque; | ||
1268 | |||
1269 | switch (addr) { | ||
1270 | case 0x00: /* 32KSYNCNT_REV */ | ||
1271 | @@ -XXX,XX +XXX,XX @@ static uint32_t omap_synctimer_readw(void *opaque, hwaddr addr) | ||
1272 | |||
1273 | static uint32_t omap_synctimer_readh(void *opaque, hwaddr addr) | ||
1274 | { | ||
1275 | - struct omap_synctimer_s *s = (struct omap_synctimer_s *) opaque; | ||
1276 | + struct omap_synctimer_s *s = opaque; | ||
1277 | uint32_t ret; | ||
1278 | |||
1279 | if (addr & 2) | ||
88 | -- | 1280 | -- |
89 | 2.25.1 | 1281 | 2.34.1 |
1282 | |||
1283 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Check for and defer any pending virtual SError. | 3 | Following docs/devel/style.rst guidelines, rename omap_gpif_s -> |
4 | Omap1GpioState. This also remove a use of 'struct' in the | ||
5 | DECLARE_INSTANCE_CHECKER() macro call. | ||
4 | 6 | ||
5 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 7 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
6 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
7 | Message-id: 20220506180242.216785-17-richard.henderson@linaro.org | 9 | Message-id: 20230109140306.23161-5-philmd@linaro.org |
8 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
9 | --- | 11 | --- |
10 | target/arm/helper.h | 1 + | 12 | include/hw/arm/omap.h | 6 +++--- |
11 | target/arm/a32.decode | 16 ++++++++------ | 13 | hw/gpio/omap_gpio.c | 16 ++++++++-------- |
12 | target/arm/t32.decode | 18 ++++++++-------- | 14 | 2 files changed, 11 insertions(+), 11 deletions(-) |
13 | target/arm/op_helper.c | 43 ++++++++++++++++++++++++++++++++++++++ | ||
14 | target/arm/translate-a64.c | 17 +++++++++++++++ | ||
15 | target/arm/translate.c | 23 ++++++++++++++++++++ | ||
16 | 6 files changed, 103 insertions(+), 15 deletions(-) | ||
17 | 15 | ||
18 | diff --git a/target/arm/helper.h b/target/arm/helper.h | 16 | diff --git a/include/hw/arm/omap.h b/include/hw/arm/omap.h |
19 | index XXXXXXX..XXXXXXX 100644 | 17 | index XXXXXXX..XXXXXXX 100644 |
20 | --- a/target/arm/helper.h | 18 | --- a/include/hw/arm/omap.h |
21 | +++ b/target/arm/helper.h | 19 | +++ b/include/hw/arm/omap.h |
22 | @@ -XXX,XX +XXX,XX @@ DEF_HELPER_1(wfe, void, env) | 20 | @@ -XXX,XX +XXX,XX @@ void omap_i2c_set_fclk(OMAPI2CState *i2c, omap_clk clk); |
23 | DEF_HELPER_1(yield, void, env) | 21 | |
24 | DEF_HELPER_1(pre_hvc, void, env) | 22 | /* omap_gpio.c */ |
25 | DEF_HELPER_2(pre_smc, void, env, i32) | 23 | #define TYPE_OMAP1_GPIO "omap-gpio" |
26 | +DEF_HELPER_1(vesb, void, env) | 24 | -DECLARE_INSTANCE_CHECKER(struct omap_gpif_s, OMAP1_GPIO, |
27 | 25 | +typedef struct Omap1GpioState Omap1GpioState; | |
28 | DEF_HELPER_3(cpsr_write, void, env, i32, i32) | 26 | +DECLARE_INSTANCE_CHECKER(Omap1GpioState, OMAP1_GPIO, |
29 | DEF_HELPER_2(cpsr_write_eret, void, env, i32) | 27 | TYPE_OMAP1_GPIO) |
30 | diff --git a/target/arm/a32.decode b/target/arm/a32.decode | 28 | |
29 | #define TYPE_OMAP2_GPIO "omap2-gpio" | ||
30 | DECLARE_INSTANCE_CHECKER(struct omap2_gpif_s, OMAP2_GPIO, | ||
31 | TYPE_OMAP2_GPIO) | ||
32 | |||
33 | -typedef struct omap_gpif_s omap_gpif; | ||
34 | typedef struct omap2_gpif_s omap2_gpif; | ||
35 | |||
36 | /* TODO: clock framework (see above) */ | ||
37 | -void omap_gpio_set_clk(omap_gpif *gpio, omap_clk clk); | ||
38 | +void omap_gpio_set_clk(Omap1GpioState *gpio, omap_clk clk); | ||
39 | |||
40 | void omap2_gpio_set_iclk(omap2_gpif *gpio, omap_clk clk); | ||
41 | void omap2_gpio_set_fclk(omap2_gpif *gpio, uint8_t i, omap_clk clk); | ||
42 | diff --git a/hw/gpio/omap_gpio.c b/hw/gpio/omap_gpio.c | ||
31 | index XXXXXXX..XXXXXXX 100644 | 43 | index XXXXXXX..XXXXXXX 100644 |
32 | --- a/target/arm/a32.decode | 44 | --- a/hw/gpio/omap_gpio.c |
33 | +++ b/target/arm/a32.decode | 45 | +++ b/hw/gpio/omap_gpio.c |
34 | @@ -XXX,XX +XXX,XX @@ SMULTT .... 0001 0110 .... 0000 .... 1110 .... @rd0mn | 46 | @@ -XXX,XX +XXX,XX @@ struct omap_gpio_s { |
35 | 47 | uint16_t pins; | |
48 | }; | ||
49 | |||
50 | -struct omap_gpif_s { | ||
51 | +struct Omap1GpioState { | ||
52 | SysBusDevice parent_obj; | ||
53 | |||
54 | MemoryRegion iomem; | ||
55 | @@ -XXX,XX +XXX,XX @@ struct omap_gpif_s { | ||
56 | /* General-Purpose I/O of OMAP1 */ | ||
57 | static void omap_gpio_set(void *opaque, int line, int level) | ||
36 | { | 58 | { |
37 | { | 59 | - struct omap_gpif_s *p = opaque; |
38 | - YIELD ---- 0011 0010 0000 1111 ---- 0000 0001 | 60 | + Omap1GpioState *p = opaque; |
39 | - WFE ---- 0011 0010 0000 1111 ---- 0000 0010 | 61 | struct omap_gpio_s *s = &p->omap1; |
40 | - WFI ---- 0011 0010 0000 1111 ---- 0000 0011 | 62 | uint16_t prev = s->inputs; |
41 | + [ | 63 | |
42 | + YIELD ---- 0011 0010 0000 1111 ---- 0000 0001 | 64 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps omap2_gpio_module_ops = { |
43 | + WFE ---- 0011 0010 0000 1111 ---- 0000 0010 | 65 | |
44 | + WFI ---- 0011 0010 0000 1111 ---- 0000 0011 | 66 | static void omap_gpif_reset(DeviceState *dev) |
45 | 67 | { | |
46 | - # TODO: Implement SEV, SEVL; may help SMP performance. | 68 | - struct omap_gpif_s *s = OMAP1_GPIO(dev); |
47 | - # SEV ---- 0011 0010 0000 1111 ---- 0000 0100 | 69 | + Omap1GpioState *s = OMAP1_GPIO(dev); |
48 | - # SEVL ---- 0011 0010 0000 1111 ---- 0000 0101 | 70 | |
49 | + # TODO: Implement SEV, SEVL; may help SMP performance. | 71 | omap_gpio_reset(&s->omap1); |
50 | + # SEV ---- 0011 0010 0000 1111 ---- 0000 0100 | 72 | } |
51 | + # SEVL ---- 0011 0010 0000 1111 ---- 0000 0101 | 73 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps omap2_gpif_top_ops = { |
52 | + | 74 | static void omap_gpio_init(Object *obj) |
53 | + ESB ---- 0011 0010 0000 1111 ---- 0001 0000 | 75 | { |
54 | + ] | 76 | DeviceState *dev = DEVICE(obj); |
55 | 77 | - struct omap_gpif_s *s = OMAP1_GPIO(obj); | |
56 | # The canonical nop ends in 00000000, but the whole of the | 78 | + Omap1GpioState *s = OMAP1_GPIO(obj); |
57 | # rest of the space executes as nop if otherwise unsupported. | 79 | SysBusDevice *sbd = SYS_BUS_DEVICE(obj); |
58 | diff --git a/target/arm/t32.decode b/target/arm/t32.decode | 80 | |
59 | index XXXXXXX..XXXXXXX 100644 | 81 | qdev_init_gpio_in(dev, omap_gpio_set, 16); |
60 | --- a/target/arm/t32.decode | 82 | @@ -XXX,XX +XXX,XX @@ static void omap_gpio_init(Object *obj) |
61 | +++ b/target/arm/t32.decode | 83 | |
62 | @@ -XXX,XX +XXX,XX @@ CLZ 1111 1010 1011 ---- 1111 .... 1000 .... @rdm | 84 | static void omap_gpio_realize(DeviceState *dev, Error **errp) |
63 | [ | 85 | { |
64 | # Hints, and CPS | 86 | - struct omap_gpif_s *s = OMAP1_GPIO(dev); |
65 | { | 87 | + Omap1GpioState *s = OMAP1_GPIO(dev); |
66 | - YIELD 1111 0011 1010 1111 1000 0000 0000 0001 | 88 | |
67 | - WFE 1111 0011 1010 1111 1000 0000 0000 0010 | 89 | if (!s->clk) { |
68 | - WFI 1111 0011 1010 1111 1000 0000 0000 0011 | 90 | error_setg(errp, "omap-gpio: clk not connected"); |
69 | + [ | 91 | @@ -XXX,XX +XXX,XX @@ static void omap2_gpio_realize(DeviceState *dev, Error **errp) |
70 | + YIELD 1111 0011 1010 1111 1000 0000 0000 0001 | ||
71 | + WFE 1111 0011 1010 1111 1000 0000 0000 0010 | ||
72 | + WFI 1111 0011 1010 1111 1000 0000 0000 0011 | ||
73 | |||
74 | - # TODO: Implement SEV, SEVL; may help SMP performance. | ||
75 | - # SEV 1111 0011 1010 1111 1000 0000 0000 0100 | ||
76 | - # SEVL 1111 0011 1010 1111 1000 0000 0000 0101 | ||
77 | + # TODO: Implement SEV, SEVL; may help SMP performance. | ||
78 | + # SEV 1111 0011 1010 1111 1000 0000 0000 0100 | ||
79 | + # SEVL 1111 0011 1010 1111 1000 0000 0000 0101 | ||
80 | |||
81 | - # For M-profile minimal-RAS ESB can be a NOP, which is the | ||
82 | - # default behaviour since it is in the hint space. | ||
83 | - # ESB 1111 0011 1010 1111 1000 0000 0001 0000 | ||
84 | + ESB 1111 0011 1010 1111 1000 0000 0001 0000 | ||
85 | + ] | ||
86 | |||
87 | # The canonical nop ends in 0000 0000, but the whole rest | ||
88 | # of the space is "reserved hint, behaves as nop". | ||
89 | diff --git a/target/arm/op_helper.c b/target/arm/op_helper.c | ||
90 | index XXXXXXX..XXXXXXX 100644 | ||
91 | --- a/target/arm/op_helper.c | ||
92 | +++ b/target/arm/op_helper.c | ||
93 | @@ -XXX,XX +XXX,XX @@ void HELPER(probe_access)(CPUARMState *env, target_ulong ptr, | ||
94 | access_type, mmu_idx, ra); | ||
95 | } | 92 | } |
96 | } | 93 | } |
97 | + | 94 | |
98 | +/* | 95 | -void omap_gpio_set_clk(omap_gpif *gpio, omap_clk clk) |
99 | + * This function corresponds to AArch64.vESBOperation(). | 96 | +void omap_gpio_set_clk(Omap1GpioState *gpio, omap_clk clk) |
100 | + * Note that the AArch32 version is not functionally different. | 97 | { |
101 | + */ | 98 | gpio->clk = clk; |
102 | +void HELPER(vesb)(CPUARMState *env) | ||
103 | +{ | ||
104 | + /* | ||
105 | + * The EL2Enabled() check is done inside arm_hcr_el2_eff, | ||
106 | + * and will return HCR_EL2.VSE == 0, so nothing happens. | ||
107 | + */ | ||
108 | + uint64_t hcr = arm_hcr_el2_eff(env); | ||
109 | + bool enabled = !(hcr & HCR_TGE) && (hcr & HCR_AMO); | ||
110 | + bool pending = enabled && (hcr & HCR_VSE); | ||
111 | + bool masked = (env->daif & PSTATE_A); | ||
112 | + | ||
113 | + /* If VSE pending and masked, defer the exception. */ | ||
114 | + if (pending && masked) { | ||
115 | + uint32_t syndrome; | ||
116 | + | ||
117 | + if (arm_el_is_aa64(env, 1)) { | ||
118 | + /* Copy across IDS and ISS from VSESR. */ | ||
119 | + syndrome = env->cp15.vsesr_el2 & 0x1ffffff; | ||
120 | + } else { | ||
121 | + ARMMMUFaultInfo fi = { .type = ARMFault_AsyncExternal }; | ||
122 | + | ||
123 | + if (extended_addresses_enabled(env)) { | ||
124 | + syndrome = arm_fi_to_lfsc(&fi); | ||
125 | + } else { | ||
126 | + syndrome = arm_fi_to_sfsc(&fi); | ||
127 | + } | ||
128 | + /* Copy across AET and ExT from VSESR. */ | ||
129 | + syndrome |= env->cp15.vsesr_el2 & 0xd000; | ||
130 | + } | ||
131 | + | ||
132 | + /* Set VDISR_EL2.A along with the syndrome. */ | ||
133 | + env->cp15.vdisr_el2 = syndrome | (1u << 31); | ||
134 | + | ||
135 | + /* Clear pending virtual SError */ | ||
136 | + env->cp15.hcr_el2 &= ~HCR_VSE; | ||
137 | + cpu_reset_interrupt(env_cpu(env), CPU_INTERRUPT_VSERR); | ||
138 | + } | ||
139 | +} | ||
140 | diff --git a/target/arm/translate-a64.c b/target/arm/translate-a64.c | ||
141 | index XXXXXXX..XXXXXXX 100644 | ||
142 | --- a/target/arm/translate-a64.c | ||
143 | +++ b/target/arm/translate-a64.c | ||
144 | @@ -XXX,XX +XXX,XX @@ static void handle_hint(DisasContext *s, uint32_t insn, | ||
145 | gen_helper_autib(cpu_X[17], cpu_env, cpu_X[17], cpu_X[16]); | ||
146 | } | ||
147 | break; | ||
148 | + case 0b10000: /* ESB */ | ||
149 | + /* Without RAS, we must implement this as NOP. */ | ||
150 | + if (dc_isar_feature(aa64_ras, s)) { | ||
151 | + /* | ||
152 | + * QEMU does not have a source of physical SErrors, | ||
153 | + * so we are only concerned with virtual SErrors. | ||
154 | + * The pseudocode in the ARM for this case is | ||
155 | + * if PSTATE.EL IN {EL0, EL1} && EL2Enabled() then | ||
156 | + * AArch64.vESBOperation(); | ||
157 | + * Most of the condition can be evaluated at translation time. | ||
158 | + * Test for EL2 present, and defer test for SEL2 to runtime. | ||
159 | + */ | ||
160 | + if (s->current_el <= 1 && arm_dc_feature(s, ARM_FEATURE_EL2)) { | ||
161 | + gen_helper_vesb(cpu_env); | ||
162 | + } | ||
163 | + } | ||
164 | + break; | ||
165 | case 0b11000: /* PACIAZ */ | ||
166 | if (s->pauth_active) { | ||
167 | gen_helper_pacia(cpu_X[30], cpu_env, cpu_X[30], | ||
168 | diff --git a/target/arm/translate.c b/target/arm/translate.c | ||
169 | index XXXXXXX..XXXXXXX 100644 | ||
170 | --- a/target/arm/translate.c | ||
171 | +++ b/target/arm/translate.c | ||
172 | @@ -XXX,XX +XXX,XX @@ static bool trans_WFI(DisasContext *s, arg_WFI *a) | ||
173 | return true; | ||
174 | } | 99 | } |
175 | 100 | ||
176 | +static bool trans_ESB(DisasContext *s, arg_ESB *a) | 101 | static Property omap_gpio_properties[] = { |
177 | +{ | 102 | - DEFINE_PROP_INT32("mpu_model", struct omap_gpif_s, mpu_model, 0), |
178 | + /* | 103 | + DEFINE_PROP_INT32("mpu_model", Omap1GpioState, mpu_model, 0), |
179 | + * For M-profile, minimal-RAS ESB can be a NOP. | 104 | DEFINE_PROP_END_OF_LIST(), |
180 | + * Without RAS, we must implement this as NOP. | 105 | }; |
181 | + */ | 106 | |
182 | + if (!arm_dc_feature(s, ARM_FEATURE_M) && dc_isar_feature(aa32_ras, s)) { | 107 | @@ -XXX,XX +XXX,XX @@ static void omap_gpio_class_init(ObjectClass *klass, void *data) |
183 | + /* | 108 | static const TypeInfo omap_gpio_info = { |
184 | + * QEMU does not have a source of physical SErrors, | 109 | .name = TYPE_OMAP1_GPIO, |
185 | + * so we are only concerned with virtual SErrors. | 110 | .parent = TYPE_SYS_BUS_DEVICE, |
186 | + * The pseudocode in the ARM for this case is | 111 | - .instance_size = sizeof(struct omap_gpif_s), |
187 | + * if PSTATE.EL IN {EL0, EL1} && EL2Enabled() then | 112 | + .instance_size = sizeof(Omap1GpioState), |
188 | + * AArch32.vESBOperation(); | 113 | .instance_init = omap_gpio_init, |
189 | + * Most of the condition can be evaluated at translation time. | 114 | .class_init = omap_gpio_class_init, |
190 | + * Test for EL2 present, and defer test for SEL2 to runtime. | 115 | }; |
191 | + */ | ||
192 | + if (s->current_el <= 1 && arm_dc_feature(s, ARM_FEATURE_EL2)) { | ||
193 | + gen_helper_vesb(cpu_env); | ||
194 | + } | ||
195 | + } | ||
196 | + return true; | ||
197 | +} | ||
198 | + | ||
199 | static bool trans_NOP(DisasContext *s, arg_NOP *a) | ||
200 | { | ||
201 | return true; | ||
202 | -- | 116 | -- |
203 | 2.25.1 | 117 | 2.34.1 |
118 | |||
119 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | There is no branch prediction in TCG, therefore there is no | 3 | Following docs/devel/style.rst guidelines, rename omap2_gpif_s -> |
4 | need to actually include the context number into the predictor. | 4 | Omap2GpioState. This also remove a use of 'struct' in the |
5 | Therefore all we need to do is add the state for SCXTNUM_ELx. | 5 | DECLARE_INSTANCE_CHECKER() macro call. |
6 | 6 | ||
7 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 7 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
8 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
9 | Message-id: 20220506180242.216785-21-richard.henderson@linaro.org | 9 | Message-id: 20230109140306.23161-6-philmd@linaro.org |
10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
11 | --- | 11 | --- |
12 | docs/system/arm/emulation.rst | 3 ++ | 12 | include/hw/arm/omap.h | 9 ++++----- |
13 | target/arm/cpu.h | 16 +++++++++ | 13 | hw/gpio/omap_gpio.c | 20 ++++++++++---------- |
14 | target/arm/cpu.c | 5 +++ | 14 | 2 files changed, 14 insertions(+), 15 deletions(-) |
15 | target/arm/cpu64.c | 3 +- | ||
16 | target/arm/helper.c | 61 ++++++++++++++++++++++++++++++++++- | ||
17 | 5 files changed, 86 insertions(+), 2 deletions(-) | ||
18 | 15 | ||
19 | diff --git a/docs/system/arm/emulation.rst b/docs/system/arm/emulation.rst | 16 | diff --git a/include/hw/arm/omap.h b/include/hw/arm/omap.h |
20 | index XXXXXXX..XXXXXXX 100644 | 17 | index XXXXXXX..XXXXXXX 100644 |
21 | --- a/docs/system/arm/emulation.rst | 18 | --- a/include/hw/arm/omap.h |
22 | +++ b/docs/system/arm/emulation.rst | 19 | +++ b/include/hw/arm/omap.h |
23 | @@ -XXX,XX +XXX,XX @@ the following architecture extensions: | 20 | @@ -XXX,XX +XXX,XX @@ DECLARE_INSTANCE_CHECKER(Omap1GpioState, OMAP1_GPIO, |
24 | - FEAT_BF16 (AArch64 BFloat16 instructions) | 21 | TYPE_OMAP1_GPIO) |
25 | - FEAT_BTI (Branch Target Identification) | 22 | |
26 | - FEAT_CSV2 (Cache speculation variant 2) | 23 | #define TYPE_OMAP2_GPIO "omap2-gpio" |
27 | +- FEAT_CSV2_1p1 (Cache speculation variant 2, version 1.1) | 24 | -DECLARE_INSTANCE_CHECKER(struct omap2_gpif_s, OMAP2_GPIO, |
28 | +- FEAT_CSV2_1p2 (Cache speculation variant 2, version 1.2) | 25 | +typedef struct Omap2GpioState Omap2GpioState; |
29 | +- FEAT_CSV2_2 (Cache speculation variant 2, version 2) | 26 | +DECLARE_INSTANCE_CHECKER(Omap2GpioState, OMAP2_GPIO, |
30 | - FEAT_DIT (Data Independent Timing instructions) | 27 | TYPE_OMAP2_GPIO) |
31 | - FEAT_DPB (DC CVAP instruction) | 28 | |
32 | - FEAT_Debugv8p2 (Debug changes for v8.2) | 29 | -typedef struct omap2_gpif_s omap2_gpif; |
33 | diff --git a/target/arm/cpu.h b/target/arm/cpu.h | 30 | - |
31 | /* TODO: clock framework (see above) */ | ||
32 | void omap_gpio_set_clk(Omap1GpioState *gpio, omap_clk clk); | ||
33 | |||
34 | -void omap2_gpio_set_iclk(omap2_gpif *gpio, omap_clk clk); | ||
35 | -void omap2_gpio_set_fclk(omap2_gpif *gpio, uint8_t i, omap_clk clk); | ||
36 | +void omap2_gpio_set_iclk(Omap2GpioState *gpio, omap_clk clk); | ||
37 | +void omap2_gpio_set_fclk(Omap2GpioState *gpio, uint8_t i, omap_clk clk); | ||
38 | |||
39 | /* OMAP2 l4 Interconnect */ | ||
40 | struct omap_l4_s; | ||
41 | diff --git a/hw/gpio/omap_gpio.c b/hw/gpio/omap_gpio.c | ||
34 | index XXXXXXX..XXXXXXX 100644 | 42 | index XXXXXXX..XXXXXXX 100644 |
35 | --- a/target/arm/cpu.h | 43 | --- a/hw/gpio/omap_gpio.c |
36 | +++ b/target/arm/cpu.h | 44 | +++ b/hw/gpio/omap_gpio.c |
37 | @@ -XXX,XX +XXX,XX @@ typedef struct CPUArchState { | 45 | @@ -XXX,XX +XXX,XX @@ struct omap2_gpio_s { |
38 | ARMPACKey apdb; | 46 | uint8_t delay; |
39 | ARMPACKey apga; | 47 | }; |
40 | } keys; | 48 | |
41 | + | 49 | -struct omap2_gpif_s { |
42 | + uint64_t scxtnum_el[4]; | 50 | +struct Omap2GpioState { |
43 | #endif | 51 | SysBusDevice parent_obj; |
44 | 52 | ||
45 | #if defined(CONFIG_USER_ONLY) | 53 | MemoryRegion iomem; |
46 | @@ -XXX,XX +XXX,XX @@ void pmu_init(ARMCPU *cpu); | 54 | @@ -XXX,XX +XXX,XX @@ static inline void omap2_gpio_module_int(struct omap2_gpio_s *s, int line) |
47 | #define SCTLR_WXN (1U << 19) | 55 | |
48 | #define SCTLR_ST (1U << 20) /* up to ??, RAZ in v6 */ | 56 | static void omap2_gpio_set(void *opaque, int line, int level) |
49 | #define SCTLR_UWXN (1U << 20) /* v7 onward, AArch32 only */ | 57 | { |
50 | +#define SCTLR_TSCXT (1U << 20) /* FEAT_CSV2_1p2, AArch64 only */ | 58 | - struct omap2_gpif_s *p = opaque; |
51 | #define SCTLR_FI (1U << 21) /* up to v7, v8 RES0 */ | 59 | + Omap2GpioState *p = opaque; |
52 | #define SCTLR_IESB (1U << 21) /* v8.2-IESB, AArch64 only */ | 60 | struct omap2_gpio_s *s = &p->modules[line >> 5]; |
53 | #define SCTLR_U (1U << 22) /* up to v6, RAO in v7 */ | 61 | |
54 | @@ -XXX,XX +XXX,XX @@ static inline bool isar_feature_aa64_dit(const ARMISARegisters *id) | 62 | line &= 31; |
55 | return FIELD_EX64(id->id_aa64pfr0, ID_AA64PFR0, DIT) != 0; | 63 | @@ -XXX,XX +XXX,XX @@ static void omap_gpif_reset(DeviceState *dev) |
64 | |||
65 | static void omap2_gpif_reset(DeviceState *dev) | ||
66 | { | ||
67 | - struct omap2_gpif_s *s = OMAP2_GPIO(dev); | ||
68 | + Omap2GpioState *s = OMAP2_GPIO(dev); | ||
69 | int i; | ||
70 | |||
71 | for (i = 0; i < s->modulecount; i++) { | ||
72 | @@ -XXX,XX +XXX,XX @@ static void omap2_gpif_reset(DeviceState *dev) | ||
73 | |||
74 | static uint64_t omap2_gpif_top_read(void *opaque, hwaddr addr, unsigned size) | ||
75 | { | ||
76 | - struct omap2_gpif_s *s = opaque; | ||
77 | + Omap2GpioState *s = opaque; | ||
78 | |||
79 | switch (addr) { | ||
80 | case 0x00: /* IPGENERICOCPSPL_REVISION */ | ||
81 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap2_gpif_top_read(void *opaque, hwaddr addr, unsigned size) | ||
82 | static void omap2_gpif_top_write(void *opaque, hwaddr addr, | ||
83 | uint64_t value, unsigned size) | ||
84 | { | ||
85 | - struct omap2_gpif_s *s = opaque; | ||
86 | + Omap2GpioState *s = opaque; | ||
87 | |||
88 | switch (addr) { | ||
89 | case 0x00: /* IPGENERICOCPSPL_REVISION */ | ||
90 | @@ -XXX,XX +XXX,XX @@ static void omap_gpio_realize(DeviceState *dev, Error **errp) | ||
91 | |||
92 | static void omap2_gpio_realize(DeviceState *dev, Error **errp) | ||
93 | { | ||
94 | - struct omap2_gpif_s *s = OMAP2_GPIO(dev); | ||
95 | + Omap2GpioState *s = OMAP2_GPIO(dev); | ||
96 | SysBusDevice *sbd = SYS_BUS_DEVICE(dev); | ||
97 | int i; | ||
98 | |||
99 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo omap_gpio_info = { | ||
100 | .class_init = omap_gpio_class_init, | ||
101 | }; | ||
102 | |||
103 | -void omap2_gpio_set_iclk(omap2_gpif *gpio, omap_clk clk) | ||
104 | +void omap2_gpio_set_iclk(Omap2GpioState *gpio, omap_clk clk) | ||
105 | { | ||
106 | gpio->iclk = clk; | ||
56 | } | 107 | } |
57 | 108 | ||
58 | +static inline bool isar_feature_aa64_scxtnum(const ARMISARegisters *id) | 109 | -void omap2_gpio_set_fclk(omap2_gpif *gpio, uint8_t i, omap_clk clk) |
59 | +{ | 110 | +void omap2_gpio_set_fclk(Omap2GpioState *gpio, uint8_t i, omap_clk clk) |
60 | + int key = FIELD_EX64(id->id_aa64pfr0, ID_AA64PFR0, CSV2); | ||
61 | + if (key >= 2) { | ||
62 | + return true; /* FEAT_CSV2_2 */ | ||
63 | + } | ||
64 | + if (key == 1) { | ||
65 | + key = FIELD_EX64(id->id_aa64pfr1, ID_AA64PFR1, CSV2_FRAC); | ||
66 | + return key >= 2; /* FEAT_CSV2_1p2 */ | ||
67 | + } | ||
68 | + return false; | ||
69 | +} | ||
70 | + | ||
71 | static inline bool isar_feature_aa64_ssbs(const ARMISARegisters *id) | ||
72 | { | 111 | { |
73 | return FIELD_EX64(id->id_aa64pfr1, ID_AA64PFR1, SSBS) != 0; | 112 | assert(i <= 5); |
74 | diff --git a/target/arm/cpu.c b/target/arm/cpu.c | 113 | gpio->fclk[i] = clk; |
75 | index XXXXXXX..XXXXXXX 100644 | 114 | } |
76 | --- a/target/arm/cpu.c | 115 | |
77 | +++ b/target/arm/cpu.c | 116 | static Property omap2_gpio_properties[] = { |
78 | @@ -XXX,XX +XXX,XX @@ static void arm_cpu_reset(DeviceState *dev) | 117 | - DEFINE_PROP_INT32("mpu_model", struct omap2_gpif_s, mpu_model, 0), |
79 | */ | 118 | + DEFINE_PROP_INT32("mpu_model", Omap2GpioState, mpu_model, 0), |
80 | env->cp15.gcr_el1 = 0x1ffff; | 119 | DEFINE_PROP_END_OF_LIST(), |
81 | } | ||
82 | + /* | ||
83 | + * Disable access to SCXTNUM_EL0 from CSV2_1p2. | ||
84 | + * This is not yet exposed from the Linux kernel in any way. | ||
85 | + */ | ||
86 | + env->cp15.sctlr_el[1] |= SCTLR_TSCXT; | ||
87 | #else | ||
88 | /* Reset into the highest available EL */ | ||
89 | if (arm_feature(env, ARM_FEATURE_EL3)) { | ||
90 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | ||
91 | index XXXXXXX..XXXXXXX 100644 | ||
92 | --- a/target/arm/cpu64.c | ||
93 | +++ b/target/arm/cpu64.c | ||
94 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | ||
95 | t = FIELD_DP64(t, ID_AA64PFR0, SVE, 1); | ||
96 | t = FIELD_DP64(t, ID_AA64PFR0, SEL2, 1); /* FEAT_SEL2 */ | ||
97 | t = FIELD_DP64(t, ID_AA64PFR0, DIT, 1); /* FEAT_DIT */ | ||
98 | - t = FIELD_DP64(t, ID_AA64PFR0, CSV2, 1); /* FEAT_CSV2 */ | ||
99 | + t = FIELD_DP64(t, ID_AA64PFR0, CSV2, 2); /* FEAT_CSV2_2 */ | ||
100 | cpu->isar.id_aa64pfr0 = t; | ||
101 | |||
102 | t = cpu->isar.id_aa64pfr1; | ||
103 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | ||
104 | * we do for EL2 with the virtualization=on property. | ||
105 | */ | ||
106 | t = FIELD_DP64(t, ID_AA64PFR1, MTE, 3); /* FEAT_MTE3 */ | ||
107 | + t = FIELD_DP64(t, ID_AA64PFR1, CSV2_FRAC, 0); /* FEAT_CSV2_2 */ | ||
108 | cpu->isar.id_aa64pfr1 = t; | ||
109 | |||
110 | t = cpu->isar.id_aa64mmfr0; | ||
111 | diff --git a/target/arm/helper.c b/target/arm/helper.c | ||
112 | index XXXXXXX..XXXXXXX 100644 | ||
113 | --- a/target/arm/helper.c | ||
114 | +++ b/target/arm/helper.c | ||
115 | @@ -XXX,XX +XXX,XX @@ static void scr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value) | ||
116 | if (cpu_isar_feature(aa64_mte, cpu)) { | ||
117 | valid_mask |= SCR_ATA; | ||
118 | } | ||
119 | + if (cpu_isar_feature(aa64_scxtnum, cpu)) { | ||
120 | + valid_mask |= SCR_ENSCXT; | ||
121 | + } | ||
122 | } else { | ||
123 | valid_mask &= ~(SCR_RW | SCR_ST); | ||
124 | if (cpu_isar_feature(aa32_ras, cpu)) { | ||
125 | @@ -XXX,XX +XXX,XX @@ static void do_hcr_write(CPUARMState *env, uint64_t value, uint64_t valid_mask) | ||
126 | if (cpu_isar_feature(aa64_mte, cpu)) { | ||
127 | valid_mask |= HCR_ATA | HCR_DCT | HCR_TID5; | ||
128 | } | ||
129 | + if (cpu_isar_feature(aa64_scxtnum, cpu)) { | ||
130 | + valid_mask |= HCR_ENSCXT; | ||
131 | + } | ||
132 | } | ||
133 | |||
134 | /* Clear RES0 bits. */ | ||
135 | @@ -XXX,XX +XXX,XX @@ static void define_arm_vh_e2h_redirects_aliases(ARMCPU *cpu) | ||
136 | { K(3, 0, 5, 6, 0), K(3, 4, 5, 6, 0), K(3, 5, 5, 6, 0), | ||
137 | "TFSR_EL1", "TFSR_EL2", "TFSR_EL12", isar_feature_aa64_mte }, | ||
138 | |||
139 | + { K(3, 0, 13, 0, 7), K(3, 4, 13, 0, 7), K(3, 5, 13, 0, 7), | ||
140 | + "SCXTNUM_EL1", "SCXTNUM_EL2", "SCXTNUM_EL12", | ||
141 | + isar_feature_aa64_scxtnum }, | ||
142 | + | ||
143 | /* TODO: ARMv8.2-SPE -- PMSCR_EL2 */ | ||
144 | /* TODO: ARMv8.4-Trace -- TRFCR_EL2 */ | ||
145 | }; | ||
146 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo mte_el0_cacheop_reginfo[] = { | ||
147 | }, | ||
148 | }; | 120 | }; |
149 | 121 | ||
150 | -#endif | 122 | @@ -XXX,XX +XXX,XX @@ static void omap2_gpio_class_init(ObjectClass *klass, void *data) |
151 | +static CPAccessResult access_scxtnum(CPUARMState *env, const ARMCPRegInfo *ri, | 123 | static const TypeInfo omap2_gpio_info = { |
152 | + bool isread) | 124 | .name = TYPE_OMAP2_GPIO, |
153 | +{ | 125 | .parent = TYPE_SYS_BUS_DEVICE, |
154 | + uint64_t hcr = arm_hcr_el2_eff(env); | 126 | - .instance_size = sizeof(struct omap2_gpif_s), |
155 | + int el = arm_current_el(env); | 127 | + .instance_size = sizeof(Omap2GpioState), |
156 | + | 128 | .class_init = omap2_gpio_class_init, |
157 | + if (el == 0 && !((hcr & HCR_E2H) && (hcr & HCR_TGE))) { | 129 | }; |
158 | + if (env->cp15.sctlr_el[1] & SCTLR_TSCXT) { | 130 | |
159 | + if (hcr & HCR_TGE) { | ||
160 | + return CP_ACCESS_TRAP_EL2; | ||
161 | + } | ||
162 | + return CP_ACCESS_TRAP; | ||
163 | + } | ||
164 | + } else if (el < 2 && (env->cp15.sctlr_el[2] & SCTLR_TSCXT)) { | ||
165 | + return CP_ACCESS_TRAP_EL2; | ||
166 | + } | ||
167 | + if (el < 2 && arm_is_el2_enabled(env) && !(hcr & HCR_ENSCXT)) { | ||
168 | + return CP_ACCESS_TRAP_EL2; | ||
169 | + } | ||
170 | + if (el < 3 | ||
171 | + && arm_feature(env, ARM_FEATURE_EL3) | ||
172 | + && !(env->cp15.scr_el3 & SCR_ENSCXT)) { | ||
173 | + return CP_ACCESS_TRAP_EL3; | ||
174 | + } | ||
175 | + return CP_ACCESS_OK; | ||
176 | +} | ||
177 | + | ||
178 | +static const ARMCPRegInfo scxtnum_reginfo[] = { | ||
179 | + { .name = "SCXTNUM_EL0", .state = ARM_CP_STATE_AA64, | ||
180 | + .opc0 = 3, .opc1 = 3, .crn = 13, .crm = 0, .opc2 = 7, | ||
181 | + .access = PL0_RW, .accessfn = access_scxtnum, | ||
182 | + .fieldoffset = offsetof(CPUARMState, scxtnum_el[0]) }, | ||
183 | + { .name = "SCXTNUM_EL1", .state = ARM_CP_STATE_AA64, | ||
184 | + .opc0 = 3, .opc1 = 0, .crn = 13, .crm = 0, .opc2 = 7, | ||
185 | + .access = PL1_RW, .accessfn = access_scxtnum, | ||
186 | + .fieldoffset = offsetof(CPUARMState, scxtnum_el[1]) }, | ||
187 | + { .name = "SCXTNUM_EL2", .state = ARM_CP_STATE_AA64, | ||
188 | + .opc0 = 3, .opc1 = 4, .crn = 13, .crm = 0, .opc2 = 7, | ||
189 | + .access = PL2_RW, .accessfn = access_scxtnum, | ||
190 | + .fieldoffset = offsetof(CPUARMState, scxtnum_el[2]) }, | ||
191 | + { .name = "SCXTNUM_EL3", .state = ARM_CP_STATE_AA64, | ||
192 | + .opc0 = 3, .opc1 = 6, .crn = 13, .crm = 0, .opc2 = 7, | ||
193 | + .access = PL3_RW, | ||
194 | + .fieldoffset = offsetof(CPUARMState, scxtnum_el[3]) }, | ||
195 | +}; | ||
196 | +#endif /* TARGET_AARCH64 */ | ||
197 | |||
198 | static CPAccessResult access_predinv(CPUARMState *env, const ARMCPRegInfo *ri, | ||
199 | bool isread) | ||
200 | @@ -XXX,XX +XXX,XX @@ void register_cp_regs_for_features(ARMCPU *cpu) | ||
201 | define_arm_cp_regs(cpu, mte_tco_ro_reginfo); | ||
202 | define_arm_cp_regs(cpu, mte_el0_cacheop_reginfo); | ||
203 | } | ||
204 | + | ||
205 | + if (cpu_isar_feature(aa64_scxtnum, cpu)) { | ||
206 | + define_arm_cp_regs(cpu, scxtnum_reginfo); | ||
207 | + } | ||
208 | #endif | ||
209 | |||
210 | if (cpu_isar_feature(any_predinv, cpu)) { | ||
211 | -- | 131 | -- |
212 | 2.25.1 | 132 | 2.34.1 |
133 | |||
134 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Instead of starting with cortex-a15 and adding v8 features to | 3 | Following docs/devel/style.rst guidelines, rename |
4 | a v7 cpu, begin with a v8 cpu stripped of its aarch64 features. | 4 | omap_intr_handler_s -> OMAPIntcState. This also remove a |
5 | This fixes the long-standing to-do where we only enabled v8 | 5 | use of 'struct' in the DECLARE_INSTANCE_CHECKER() macro call. |
6 | features for user-only. | 6 | |
7 | 7 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> | |
8 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
9 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 9 | Message-id: 20230109140306.23161-7-philmd@linaro.org |
10 | Message-id: 20220506180242.216785-7-richard.henderson@linaro.org | ||
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
12 | --- | 11 | --- |
13 | target/arm/cpu_tcg.c | 151 ++++++++++++++++++++++++++----------------- | 12 | include/hw/arm/omap.h | 9 ++++----- |
14 | 1 file changed, 92 insertions(+), 59 deletions(-) | 13 | hw/intc/omap_intc.c | 38 +++++++++++++++++++------------------- |
15 | 14 | 2 files changed, 23 insertions(+), 24 deletions(-) | |
16 | diff --git a/target/arm/cpu_tcg.c b/target/arm/cpu_tcg.c | 15 | |
16 | diff --git a/include/hw/arm/omap.h b/include/hw/arm/omap.h | ||
17 | index XXXXXXX..XXXXXXX 100644 | 17 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/target/arm/cpu_tcg.c | 18 | --- a/include/hw/arm/omap.h |
19 | +++ b/target/arm/cpu_tcg.c | 19 | +++ b/include/hw/arm/omap.h |
20 | @@ -XXX,XX +XXX,XX @@ static void arm_v7m_class_init(ObjectClass *oc, void *data) | 20 | @@ -XXX,XX +XXX,XX @@ void omap_clk_reparent(omap_clk clk, omap_clk parent); |
21 | static void arm_max_initfn(Object *obj) | 21 | |
22 | { | 22 | /* omap_intc.c */ |
23 | ARMCPU *cpu = ARM_CPU(obj); | 23 | #define TYPE_OMAP_INTC "common-omap-intc" |
24 | + uint32_t t; | 24 | -typedef struct omap_intr_handler_s omap_intr_handler; |
25 | 25 | -DECLARE_INSTANCE_CHECKER(omap_intr_handler, OMAP_INTC, | |
26 | - cortex_a15_initfn(obj); | 26 | - TYPE_OMAP_INTC) |
27 | + /* aarch64_a57_initfn, advertising none of the aarch64 features */ | 27 | +typedef struct OMAPIntcState OMAPIntcState; |
28 | + cpu->dtb_compatible = "arm,cortex-a57"; | 28 | +DECLARE_INSTANCE_CHECKER(OMAPIntcState, OMAP_INTC, TYPE_OMAP_INTC) |
29 | + set_feature(&cpu->env, ARM_FEATURE_V8); | 29 | |
30 | + set_feature(&cpu->env, ARM_FEATURE_NEON); | 30 | |
31 | + set_feature(&cpu->env, ARM_FEATURE_GENERIC_TIMER); | 31 | /* |
32 | + set_feature(&cpu->env, ARM_FEATURE_CBAR_RO); | 32 | @@ -XXX,XX +XXX,XX @@ DECLARE_INSTANCE_CHECKER(omap_intr_handler, OMAP_INTC, |
33 | + set_feature(&cpu->env, ARM_FEATURE_EL2); | 33 | * (ie the struct omap_mpu_state_s*) to do the clockname to pointer |
34 | + set_feature(&cpu->env, ARM_FEATURE_EL3); | 34 | * translation.) |
35 | + set_feature(&cpu->env, ARM_FEATURE_PMU); | 35 | */ |
36 | + cpu->midr = 0x411fd070; | 36 | -void omap_intc_set_iclk(omap_intr_handler *intc, omap_clk clk); |
37 | + cpu->revidr = 0x00000000; | 37 | -void omap_intc_set_fclk(omap_intr_handler *intc, omap_clk clk); |
38 | + cpu->reset_fpsid = 0x41034070; | 38 | +void omap_intc_set_iclk(OMAPIntcState *intc, omap_clk clk); |
39 | + cpu->isar.mvfr0 = 0x10110222; | 39 | +void omap_intc_set_fclk(OMAPIntcState *intc, omap_clk clk); |
40 | + cpu->isar.mvfr1 = 0x12111111; | 40 | |
41 | + cpu->isar.mvfr2 = 0x00000043; | 41 | /* omap_i2c.c */ |
42 | + cpu->ctr = 0x8444c004; | 42 | #define TYPE_OMAP_I2C "omap_i2c" |
43 | + cpu->reset_sctlr = 0x00c50838; | 43 | diff --git a/hw/intc/omap_intc.c b/hw/intc/omap_intc.c |
44 | + cpu->isar.id_pfr0 = 0x00000131; | 44 | index XXXXXXX..XXXXXXX 100644 |
45 | + cpu->isar.id_pfr1 = 0x00011011; | 45 | --- a/hw/intc/omap_intc.c |
46 | + cpu->isar.id_dfr0 = 0x03010066; | 46 | +++ b/hw/intc/omap_intc.c |
47 | + cpu->id_afr0 = 0x00000000; | 47 | @@ -XXX,XX +XXX,XX @@ struct omap_intr_handler_bank_s { |
48 | + cpu->isar.id_mmfr0 = 0x10101105; | 48 | unsigned char priority[32]; |
49 | + cpu->isar.id_mmfr1 = 0x40000000; | 49 | }; |
50 | + cpu->isar.id_mmfr2 = 0x01260000; | 50 | |
51 | + cpu->isar.id_mmfr3 = 0x02102211; | 51 | -struct omap_intr_handler_s { |
52 | + cpu->isar.id_isar0 = 0x02101110; | 52 | +struct OMAPIntcState { |
53 | + cpu->isar.id_isar1 = 0x13112111; | 53 | SysBusDevice parent_obj; |
54 | + cpu->isar.id_isar2 = 0x21232042; | 54 | |
55 | + cpu->isar.id_isar3 = 0x01112131; | 55 | qemu_irq *pins; |
56 | + cpu->isar.id_isar4 = 0x00011142; | 56 | @@ -XXX,XX +XXX,XX @@ struct omap_intr_handler_s { |
57 | + cpu->isar.id_isar5 = 0x00011121; | 57 | struct omap_intr_handler_bank_s bank[3]; |
58 | + cpu->isar.id_isar6 = 0; | 58 | }; |
59 | + cpu->isar.dbgdidr = 0x3516d000; | 59 | |
60 | + cpu->clidr = 0x0a200023; | 60 | -static void omap_inth_sir_update(struct omap_intr_handler_s *s, int is_fiq) |
61 | + cpu->ccsidr[0] = 0x701fe00a; /* 32KB L1 dcache */ | 61 | +static void omap_inth_sir_update(OMAPIntcState *s, int is_fiq) |
62 | + cpu->ccsidr[1] = 0x201fe012; /* 48KB L1 icache */ | 62 | { |
63 | + cpu->ccsidr[2] = 0x70ffe07a; /* 2048KB L2 cache */ | 63 | int i, j, sir_intr, p_intr, p; |
64 | + define_cortex_a72_a57_a53_cp_reginfo(cpu); | 64 | uint32_t level; |
65 | 65 | @@ -XXX,XX +XXX,XX @@ static void omap_inth_sir_update(struct omap_intr_handler_s *s, int is_fiq) | |
66 | - /* old-style VFP short-vector support */ | 66 | s->sir_intr[is_fiq] = sir_intr; |
67 | - cpu->isar.mvfr0 = FIELD_DP32(cpu->isar.mvfr0, MVFR0, FPSHVEC, 1); | 67 | } |
68 | + /* Add additional features supported by QEMU */ | 68 | |
69 | + t = cpu->isar.id_isar5; | 69 | -static inline void omap_inth_update(struct omap_intr_handler_s *s, int is_fiq) |
70 | + t = FIELD_DP32(t, ID_ISAR5, AES, 2); | 70 | +static inline void omap_inth_update(OMAPIntcState *s, int is_fiq) |
71 | + t = FIELD_DP32(t, ID_ISAR5, SHA1, 1); | 71 | { |
72 | + t = FIELD_DP32(t, ID_ISAR5, SHA2, 1); | 72 | int i; |
73 | + t = FIELD_DP32(t, ID_ISAR5, CRC32, 1); | 73 | uint32_t has_intr = 0; |
74 | + t = FIELD_DP32(t, ID_ISAR5, RDM, 1); | 74 | @@ -XXX,XX +XXX,XX @@ static inline void omap_inth_update(struct omap_intr_handler_s *s, int is_fiq) |
75 | + t = FIELD_DP32(t, ID_ISAR5, VCMA, 1); | 75 | |
76 | + cpu->isar.id_isar5 = t; | 76 | static void omap_set_intr(void *opaque, int irq, int req) |
77 | + | 77 | { |
78 | + t = cpu->isar.id_isar6; | 78 | - struct omap_intr_handler_s *ih = opaque; |
79 | + t = FIELD_DP32(t, ID_ISAR6, JSCVT, 1); | 79 | + OMAPIntcState *ih = opaque; |
80 | + t = FIELD_DP32(t, ID_ISAR6, DP, 1); | 80 | uint32_t rise; |
81 | + t = FIELD_DP32(t, ID_ISAR6, FHM, 1); | 81 | |
82 | + t = FIELD_DP32(t, ID_ISAR6, SB, 1); | 82 | struct omap_intr_handler_bank_s *bank = &ih->bank[irq >> 5]; |
83 | + t = FIELD_DP32(t, ID_ISAR6, SPECRES, 1); | 83 | @@ -XXX,XX +XXX,XX @@ static void omap_set_intr(void *opaque, int irq, int req) |
84 | + t = FIELD_DP32(t, ID_ISAR6, BF16, 1); | 84 | /* Simplified version with no edge detection */ |
85 | + t = FIELD_DP32(t, ID_ISAR6, I8MM, 1); | 85 | static void omap_set_intr_noedge(void *opaque, int irq, int req) |
86 | + cpu->isar.id_isar6 = t; | 86 | { |
87 | + | 87 | - struct omap_intr_handler_s *ih = opaque; |
88 | + t = cpu->isar.mvfr1; | 88 | + OMAPIntcState *ih = opaque; |
89 | + t = FIELD_DP32(t, MVFR1, FPHP, 3); /* v8.2-FP16 */ | 89 | uint32_t rise; |
90 | + t = FIELD_DP32(t, MVFR1, SIMDHP, 2); /* v8.2-FP16 */ | 90 | |
91 | + cpu->isar.mvfr1 = t; | 91 | struct omap_intr_handler_bank_s *bank = &ih->bank[irq >> 5]; |
92 | + | 92 | @@ -XXX,XX +XXX,XX @@ static void omap_set_intr_noedge(void *opaque, int irq, int req) |
93 | + t = cpu->isar.mvfr2; | 93 | static uint64_t omap_inth_read(void *opaque, hwaddr addr, |
94 | + t = FIELD_DP32(t, MVFR2, SIMDMISC, 3); /* SIMD MaxNum */ | 94 | unsigned size) |
95 | + t = FIELD_DP32(t, MVFR2, FPMISC, 4); /* FP MaxNum */ | 95 | { |
96 | + cpu->isar.mvfr2 = t; | 96 | - struct omap_intr_handler_s *s = opaque; |
97 | + | 97 | + OMAPIntcState *s = opaque; |
98 | + t = cpu->isar.id_mmfr3; | 98 | int i, offset = addr; |
99 | + t = FIELD_DP32(t, ID_MMFR3, PAN, 2); /* ATS1E1 */ | 99 | int bank_no = offset >> 8; |
100 | + cpu->isar.id_mmfr3 = t; | 100 | int line_no; |
101 | + | 101 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap_inth_read(void *opaque, hwaddr addr, |
102 | + t = cpu->isar.id_mmfr4; | 102 | static void omap_inth_write(void *opaque, hwaddr addr, |
103 | + t = FIELD_DP32(t, ID_MMFR4, HPDS, 1); /* AA32HPD */ | 103 | uint64_t value, unsigned size) |
104 | + t = FIELD_DP32(t, ID_MMFR4, AC2, 1); /* ACTLR2, HACTLR2 */ | 104 | { |
105 | + t = FIELD_DP32(t, ID_MMFR4, CNP, 1); /* TTCNP */ | 105 | - struct omap_intr_handler_s *s = opaque; |
106 | + t = FIELD_DP32(t, ID_MMFR4, XNX, 1); /* TTS2UXN */ | 106 | + OMAPIntcState *s = opaque; |
107 | + cpu->isar.id_mmfr4 = t; | 107 | int i, offset = addr; |
108 | + | 108 | int bank_no = offset >> 8; |
109 | + t = cpu->isar.id_pfr0; | 109 | struct omap_intr_handler_bank_s *bank = &s->bank[bank_no]; |
110 | + t = FIELD_DP32(t, ID_PFR0, DIT, 1); | 110 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps omap_inth_mem_ops = { |
111 | + cpu->isar.id_pfr0 = t; | 111 | |
112 | + | 112 | static void omap_inth_reset(DeviceState *dev) |
113 | + t = cpu->isar.id_pfr2; | 113 | { |
114 | + t = FIELD_DP32(t, ID_PFR2, SSBS, 1); | 114 | - struct omap_intr_handler_s *s = OMAP_INTC(dev); |
115 | + cpu->isar.id_pfr2 = t; | 115 | + OMAPIntcState *s = OMAP_INTC(dev); |
116 | 116 | int i; | |
117 | #ifdef CONFIG_USER_ONLY | 117 | |
118 | /* | 118 | for (i = 0; i < s->nbanks; ++i){ |
119 | - * We don't set these in system emulation mode for the moment, | 119 | @@ -XXX,XX +XXX,XX @@ static void omap_inth_reset(DeviceState *dev) |
120 | - * since we don't correctly set (all of) the ID registers to | 120 | static void omap_intc_init(Object *obj) |
121 | - * advertise them. | 121 | { |
122 | + * Break with true ARMv8 and add back old-style VFP short-vector support. | 122 | DeviceState *dev = DEVICE(obj); |
123 | + * Only do this for user-mode, where -cpu max is the default, so that | 123 | - struct omap_intr_handler_s *s = OMAP_INTC(obj); |
124 | + * older v6 and v7 programs are more likely to work without adjustment. | 124 | + OMAPIntcState *s = OMAP_INTC(obj); |
125 | */ | 125 | SysBusDevice *sbd = SYS_BUS_DEVICE(obj); |
126 | - set_feature(&cpu->env, ARM_FEATURE_V8); | 126 | |
127 | - { | 127 | s->nbanks = 1; |
128 | - uint32_t t; | 128 | @@ -XXX,XX +XXX,XX @@ static void omap_intc_init(Object *obj) |
129 | - | 129 | |
130 | - t = cpu->isar.id_isar5; | 130 | static void omap_intc_realize(DeviceState *dev, Error **errp) |
131 | - t = FIELD_DP32(t, ID_ISAR5, AES, 2); | 131 | { |
132 | - t = FIELD_DP32(t, ID_ISAR5, SHA1, 1); | 132 | - struct omap_intr_handler_s *s = OMAP_INTC(dev); |
133 | - t = FIELD_DP32(t, ID_ISAR5, SHA2, 1); | 133 | + OMAPIntcState *s = OMAP_INTC(dev); |
134 | - t = FIELD_DP32(t, ID_ISAR5, CRC32, 1); | 134 | |
135 | - t = FIELD_DP32(t, ID_ISAR5, RDM, 1); | 135 | if (!s->iclk) { |
136 | - t = FIELD_DP32(t, ID_ISAR5, VCMA, 1); | 136 | error_setg(errp, "omap-intc: clk not connected"); |
137 | - cpu->isar.id_isar5 = t; | 137 | } |
138 | - | 138 | } |
139 | - t = cpu->isar.id_isar6; | 139 | |
140 | - t = FIELD_DP32(t, ID_ISAR6, JSCVT, 1); | 140 | -void omap_intc_set_iclk(omap_intr_handler *intc, omap_clk clk) |
141 | - t = FIELD_DP32(t, ID_ISAR6, DP, 1); | 141 | +void omap_intc_set_iclk(OMAPIntcState *intc, omap_clk clk) |
142 | - t = FIELD_DP32(t, ID_ISAR6, FHM, 1); | 142 | { |
143 | - t = FIELD_DP32(t, ID_ISAR6, SB, 1); | 143 | intc->iclk = clk; |
144 | - t = FIELD_DP32(t, ID_ISAR6, SPECRES, 1); | 144 | } |
145 | - t = FIELD_DP32(t, ID_ISAR6, BF16, 1); | 145 | |
146 | - t = FIELD_DP32(t, ID_ISAR6, I8MM, 1); | 146 | -void omap_intc_set_fclk(omap_intr_handler *intc, omap_clk clk) |
147 | - cpu->isar.id_isar6 = t; | 147 | +void omap_intc_set_fclk(OMAPIntcState *intc, omap_clk clk) |
148 | - | 148 | { |
149 | - t = cpu->isar.mvfr1; | 149 | intc->fclk = clk; |
150 | - t = FIELD_DP32(t, MVFR1, FPHP, 3); /* v8.2-FP16 */ | 150 | } |
151 | - t = FIELD_DP32(t, MVFR1, SIMDHP, 2); /* v8.2-FP16 */ | 151 | |
152 | - cpu->isar.mvfr1 = t; | 152 | static Property omap_intc_properties[] = { |
153 | - | 153 | - DEFINE_PROP_UINT32("size", struct omap_intr_handler_s, size, 0x100), |
154 | - t = cpu->isar.mvfr2; | 154 | + DEFINE_PROP_UINT32("size", OMAPIntcState, size, 0x100), |
155 | - t = FIELD_DP32(t, MVFR2, SIMDMISC, 3); /* SIMD MaxNum */ | 155 | DEFINE_PROP_END_OF_LIST(), |
156 | - t = FIELD_DP32(t, MVFR2, FPMISC, 4); /* FP MaxNum */ | 156 | }; |
157 | - cpu->isar.mvfr2 = t; | 157 | |
158 | - | 158 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo omap_intc_info = { |
159 | - t = cpu->isar.id_mmfr3; | 159 | static uint64_t omap2_inth_read(void *opaque, hwaddr addr, |
160 | - t = FIELD_DP32(t, ID_MMFR3, PAN, 2); /* ATS1E1 */ | 160 | unsigned size) |
161 | - cpu->isar.id_mmfr3 = t; | 161 | { |
162 | - | 162 | - struct omap_intr_handler_s *s = opaque; |
163 | - t = cpu->isar.id_mmfr4; | 163 | + OMAPIntcState *s = opaque; |
164 | - t = FIELD_DP32(t, ID_MMFR4, HPDS, 1); /* AA32HPD */ | 164 | int offset = addr; |
165 | - t = FIELD_DP32(t, ID_MMFR4, AC2, 1); /* ACTLR2, HACTLR2 */ | 165 | int bank_no, line_no; |
166 | - t = FIELD_DP32(t, ID_MMFR4, CNP, 1); /* TTCNP */ | 166 | struct omap_intr_handler_bank_s *bank = NULL; |
167 | - t = FIELD_DP32(t, ID_MMFR4, XNX, 1); /* TTS2UXN */ | 167 | @@ -XXX,XX +XXX,XX @@ static uint64_t omap2_inth_read(void *opaque, hwaddr addr, |
168 | - cpu->isar.id_mmfr4 = t; | 168 | static void omap2_inth_write(void *opaque, hwaddr addr, |
169 | - | 169 | uint64_t value, unsigned size) |
170 | - t = cpu->isar.id_pfr0; | 170 | { |
171 | - t = FIELD_DP32(t, ID_PFR0, DIT, 1); | 171 | - struct omap_intr_handler_s *s = opaque; |
172 | - cpu->isar.id_pfr0 = t; | 172 | + OMAPIntcState *s = opaque; |
173 | - | 173 | int offset = addr; |
174 | - t = cpu->isar.id_pfr2; | 174 | int bank_no, line_no; |
175 | - t = FIELD_DP32(t, ID_PFR2, SSBS, 1); | 175 | struct omap_intr_handler_bank_s *bank = NULL; |
176 | - cpu->isar.id_pfr2 = t; | 176 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps omap2_inth_mem_ops = { |
177 | - } | 177 | static void omap2_intc_init(Object *obj) |
178 | -#endif /* CONFIG_USER_ONLY */ | 178 | { |
179 | + cpu->isar.mvfr0 = FIELD_DP32(cpu->isar.mvfr0, MVFR0, FPSHVEC, 1); | 179 | DeviceState *dev = DEVICE(obj); |
180 | +#endif | 180 | - struct omap_intr_handler_s *s = OMAP_INTC(obj); |
181 | } | 181 | + OMAPIntcState *s = OMAP_INTC(obj); |
182 | #endif /* !TARGET_AARCH64 */ | 182 | SysBusDevice *sbd = SYS_BUS_DEVICE(obj); |
183 | |||
184 | s->level_only = 1; | ||
185 | @@ -XXX,XX +XXX,XX @@ static void omap2_intc_init(Object *obj) | ||
186 | |||
187 | static void omap2_intc_realize(DeviceState *dev, Error **errp) | ||
188 | { | ||
189 | - struct omap_intr_handler_s *s = OMAP_INTC(dev); | ||
190 | + OMAPIntcState *s = OMAP_INTC(dev); | ||
191 | |||
192 | if (!s->iclk) { | ||
193 | error_setg(errp, "omap2-intc: iclk not connected"); | ||
194 | @@ -XXX,XX +XXX,XX @@ static void omap2_intc_realize(DeviceState *dev, Error **errp) | ||
195 | } | ||
196 | |||
197 | static Property omap2_intc_properties[] = { | ||
198 | - DEFINE_PROP_UINT8("revision", struct omap_intr_handler_s, | ||
199 | + DEFINE_PROP_UINT8("revision", OMAPIntcState, | ||
200 | revision, 0x21), | ||
201 | DEFINE_PROP_END_OF_LIST(), | ||
202 | }; | ||
203 | @@ -XXX,XX +XXX,XX @@ static const TypeInfo omap2_intc_info = { | ||
204 | static const TypeInfo omap_intc_type_info = { | ||
205 | .name = TYPE_OMAP_INTC, | ||
206 | .parent = TYPE_SYS_BUS_DEVICE, | ||
207 | - .instance_size = sizeof(omap_intr_handler), | ||
208 | + .instance_size = sizeof(OMAPIntcState), | ||
209 | .abstract = true, | ||
210 | }; | ||
183 | 211 | ||
184 | -- | 212 | -- |
185 | 2.25.1 | 213 | 2.34.1 |
214 | |||
215 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 3 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
4 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 4 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
5 | Message-id: 20220506180242.216785-18-richard.henderson@linaro.org | 5 | Message-id: 20230109140306.23161-8-philmd@linaro.org |
6 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 6 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
7 | --- | 7 | --- |
8 | docs/system/arm/emulation.rst | 1 + | 8 | hw/arm/stellaris.c | 6 +++--- |
9 | target/arm/cpu64.c | 1 + | 9 | 1 file changed, 3 insertions(+), 3 deletions(-) |
10 | target/arm/cpu_tcg.c | 1 + | ||
11 | 3 files changed, 3 insertions(+) | ||
12 | 10 | ||
13 | diff --git a/docs/system/arm/emulation.rst b/docs/system/arm/emulation.rst | 11 | diff --git a/hw/arm/stellaris.c b/hw/arm/stellaris.c |
14 | index XXXXXXX..XXXXXXX 100644 | 12 | index XXXXXXX..XXXXXXX 100644 |
15 | --- a/docs/system/arm/emulation.rst | 13 | --- a/hw/arm/stellaris.c |
16 | +++ b/docs/system/arm/emulation.rst | 14 | +++ b/hw/arm/stellaris.c |
17 | @@ -XXX,XX +XXX,XX @@ the following architecture extensions: | 15 | @@ -XXX,XX +XXX,XX @@ static void stellaris_adc_update(stellaris_adc_state *s) |
18 | - FEAT_PMULL (PMULL, PMULL2 instructions) | 16 | |
19 | - FEAT_PMUv3p1 (PMU Extensions v3.1) | 17 | static void stellaris_adc_trigger(void *opaque, int irq, int level) |
20 | - FEAT_PMUv3p4 (PMU Extensions v3.4) | 18 | { |
21 | +- FEAT_RAS (Reliability, availability, and serviceability) | 19 | - stellaris_adc_state *s = (stellaris_adc_state *)opaque; |
22 | - FEAT_RDM (Advanced SIMD rounding double multiply accumulate instructions) | 20 | + stellaris_adc_state *s = opaque; |
23 | - FEAT_RNG (Random number generator) | 21 | int n; |
24 | - FEAT_SB (Speculation Barrier) | 22 | |
25 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 23 | for (n = 0; n < 4; n++) { |
26 | index XXXXXXX..XXXXXXX 100644 | 24 | @@ -XXX,XX +XXX,XX @@ static void stellaris_adc_reset(stellaris_adc_state *s) |
27 | --- a/target/arm/cpu64.c | 25 | static uint64_t stellaris_adc_read(void *opaque, hwaddr offset, |
28 | +++ b/target/arm/cpu64.c | 26 | unsigned size) |
29 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | 27 | { |
30 | t = cpu->isar.id_aa64pfr0; | 28 | - stellaris_adc_state *s = (stellaris_adc_state *)opaque; |
31 | t = FIELD_DP64(t, ID_AA64PFR0, FP, 1); /* FEAT_FP16 */ | 29 | + stellaris_adc_state *s = opaque; |
32 | t = FIELD_DP64(t, ID_AA64PFR0, ADVSIMD, 1); /* FEAT_FP16 */ | 30 | |
33 | + t = FIELD_DP64(t, ID_AA64PFR0, RAS, 1); /* FEAT_RAS */ | 31 | /* TODO: Implement this. */ |
34 | t = FIELD_DP64(t, ID_AA64PFR0, SVE, 1); | 32 | if (offset >= 0x40 && offset < 0xc0) { |
35 | t = FIELD_DP64(t, ID_AA64PFR0, SEL2, 1); /* FEAT_SEL2 */ | 33 | @@ -XXX,XX +XXX,XX @@ static uint64_t stellaris_adc_read(void *opaque, hwaddr offset, |
36 | t = FIELD_DP64(t, ID_AA64PFR0, DIT, 1); /* FEAT_DIT */ | 34 | static void stellaris_adc_write(void *opaque, hwaddr offset, |
37 | diff --git a/target/arm/cpu_tcg.c b/target/arm/cpu_tcg.c | 35 | uint64_t value, unsigned size) |
38 | index XXXXXXX..XXXXXXX 100644 | 36 | { |
39 | --- a/target/arm/cpu_tcg.c | 37 | - stellaris_adc_state *s = (stellaris_adc_state *)opaque; |
40 | +++ b/target/arm/cpu_tcg.c | 38 | + stellaris_adc_state *s = opaque; |
41 | @@ -XXX,XX +XXX,XX @@ void aa32_max_features(ARMCPU *cpu) | 39 | |
42 | 40 | /* TODO: Implement this. */ | |
43 | t = cpu->isar.id_pfr0; | 41 | if (offset >= 0x40 && offset < 0xc0) { |
44 | t = FIELD_DP32(t, ID_PFR0, DIT, 1); /* FEAT_DIT */ | ||
45 | + t = FIELD_DP32(t, ID_PFR0, RAS, 1); /* FEAT_RAS */ | ||
46 | cpu->isar.id_pfr0 = t; | ||
47 | |||
48 | t = cpu->isar.id_pfr2; | ||
49 | -- | 42 | -- |
50 | 2.25.1 | 43 | 2.34.1 |
44 | |||
45 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Virtual SError exceptions are raised by setting HCR_EL2.VSE, | 3 | Following docs/devel/style.rst guidelines, rename |
4 | and are routed to EL1 just like other virtual exceptions. | 4 | stellaris_adc_state -> StellarisADCState. This also remove a |
5 | use of 'struct' in the DECLARE_INSTANCE_CHECKER() macro call. | ||
5 | 6 | ||
6 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 7 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
7 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
8 | Message-id: 20220506180242.216785-16-richard.henderson@linaro.org | 9 | Message-id: 20230109140306.23161-9-philmd@linaro.org |
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
10 | --- | 11 | --- |
11 | target/arm/cpu.h | 2 ++ | 12 | hw/arm/stellaris.c | 73 +++++++++++++++++++++++----------------------- |
12 | target/arm/internals.h | 8 ++++++++ | 13 | 1 file changed, 36 insertions(+), 37 deletions(-) |
13 | target/arm/syndrome.h | 5 +++++ | ||
14 | target/arm/cpu.c | 38 +++++++++++++++++++++++++++++++++++++- | ||
15 | target/arm/helper.c | 40 +++++++++++++++++++++++++++++++++++++++- | ||
16 | 5 files changed, 91 insertions(+), 2 deletions(-) | ||
17 | 14 | ||
18 | diff --git a/target/arm/cpu.h b/target/arm/cpu.h | 15 | diff --git a/hw/arm/stellaris.c b/hw/arm/stellaris.c |
19 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
20 | --- a/target/arm/cpu.h | 17 | --- a/hw/arm/stellaris.c |
21 | +++ b/target/arm/cpu.h | 18 | +++ b/hw/arm/stellaris.c |
22 | @@ -XXX,XX +XXX,XX @@ | 19 | @@ -XXX,XX +XXX,XX @@ static void stellaris_i2c_init(Object *obj) |
23 | #define EXCP_LSERR 21 /* v8M LSERR SecureFault */ | 20 | #define STELLARIS_ADC_FIFO_FULL 0x1000 |
24 | #define EXCP_UNALIGNED 22 /* v7M UNALIGNED UsageFault */ | 21 | |
25 | #define EXCP_DIVBYZERO 23 /* v7M DIVBYZERO UsageFault */ | 22 | #define TYPE_STELLARIS_ADC "stellaris-adc" |
26 | +#define EXCP_VSERR 24 | 23 | -typedef struct StellarisADCState stellaris_adc_state; |
27 | /* NB: add new EXCP_ defines to the array in arm_log_exception() too */ | 24 | -DECLARE_INSTANCE_CHECKER(stellaris_adc_state, STELLARIS_ADC, |
28 | 25 | - TYPE_STELLARIS_ADC) | |
29 | #define ARMV7M_EXCP_RESET 1 | 26 | +typedef struct StellarisADCState StellarisADCState; |
30 | @@ -XXX,XX +XXX,XX @@ enum { | 27 | +DECLARE_INSTANCE_CHECKER(StellarisADCState, STELLARIS_ADC, TYPE_STELLARIS_ADC) |
31 | #define CPU_INTERRUPT_FIQ CPU_INTERRUPT_TGT_EXT_1 | 28 | |
32 | #define CPU_INTERRUPT_VIRQ CPU_INTERRUPT_TGT_EXT_2 | 29 | struct StellarisADCState { |
33 | #define CPU_INTERRUPT_VFIQ CPU_INTERRUPT_TGT_EXT_3 | 30 | SysBusDevice parent_obj; |
34 | +#define CPU_INTERRUPT_VSERR CPU_INTERRUPT_TGT_INT_0 | 31 | @@ -XXX,XX +XXX,XX @@ struct StellarisADCState { |
35 | 32 | qemu_irq irq[4]; | |
36 | /* The usual mapping for an AArch64 system register to its AArch32 | 33 | }; |
37 | * counterpart is for the 32 bit world to have access to the lower | 34 | |
38 | diff --git a/target/arm/internals.h b/target/arm/internals.h | 35 | -static uint32_t stellaris_adc_fifo_read(stellaris_adc_state *s, int n) |
39 | index XXXXXXX..XXXXXXX 100644 | 36 | +static uint32_t stellaris_adc_fifo_read(StellarisADCState *s, int n) |
40 | --- a/target/arm/internals.h | 37 | { |
41 | +++ b/target/arm/internals.h | 38 | int tail; |
42 | @@ -XXX,XX +XXX,XX @@ void arm_cpu_update_virq(ARMCPU *cpu); | 39 | |
43 | */ | 40 | @@ -XXX,XX +XXX,XX @@ static uint32_t stellaris_adc_fifo_read(stellaris_adc_state *s, int n) |
44 | void arm_cpu_update_vfiq(ARMCPU *cpu); | 41 | return s->fifo[n].data[tail]; |
45 | |||
46 | +/** | ||
47 | + * arm_cpu_update_vserr: Update CPU_INTERRUPT_VSERR bit | ||
48 | + * | ||
49 | + * Update the CPU_INTERRUPT_VSERR bit in cs->interrupt_request, | ||
50 | + * following a change to the HCR_EL2.VSE bit. | ||
51 | + */ | ||
52 | +void arm_cpu_update_vserr(ARMCPU *cpu); | ||
53 | + | ||
54 | /** | ||
55 | * arm_mmu_idx_el: | ||
56 | * @env: The cpu environment | ||
57 | diff --git a/target/arm/syndrome.h b/target/arm/syndrome.h | ||
58 | index XXXXXXX..XXXXXXX 100644 | ||
59 | --- a/target/arm/syndrome.h | ||
60 | +++ b/target/arm/syndrome.h | ||
61 | @@ -XXX,XX +XXX,XX @@ static inline uint32_t syn_pcalignment(void) | ||
62 | return (EC_PCALIGNMENT << ARM_EL_EC_SHIFT) | ARM_EL_IL; | ||
63 | } | 42 | } |
64 | 43 | ||
65 | +static inline uint32_t syn_serror(uint32_t extra) | 44 | -static void stellaris_adc_fifo_write(stellaris_adc_state *s, int n, |
66 | +{ | 45 | +static void stellaris_adc_fifo_write(StellarisADCState *s, int n, |
67 | + return (EC_SERROR << ARM_EL_EC_SHIFT) | ARM_EL_IL | extra; | 46 | uint32_t value) |
68 | +} | 47 | { |
69 | + | 48 | int head; |
70 | #endif /* TARGET_ARM_SYNDROME_H */ | 49 | @@ -XXX,XX +XXX,XX @@ static void stellaris_adc_fifo_write(stellaris_adc_state *s, int n, |
71 | diff --git a/target/arm/cpu.c b/target/arm/cpu.c | 50 | s->fifo[n].state |= STELLARIS_ADC_FIFO_FULL; |
72 | index XXXXXXX..XXXXXXX 100644 | ||
73 | --- a/target/arm/cpu.c | ||
74 | +++ b/target/arm/cpu.c | ||
75 | @@ -XXX,XX +XXX,XX @@ static bool arm_cpu_has_work(CPUState *cs) | ||
76 | return (cpu->power_state != PSCI_OFF) | ||
77 | && cs->interrupt_request & | ||
78 | (CPU_INTERRUPT_FIQ | CPU_INTERRUPT_HARD | ||
79 | - | CPU_INTERRUPT_VFIQ | CPU_INTERRUPT_VIRQ | ||
80 | + | CPU_INTERRUPT_VFIQ | CPU_INTERRUPT_VIRQ | CPU_INTERRUPT_VSERR | ||
81 | | CPU_INTERRUPT_EXITTB); | ||
82 | } | 51 | } |
83 | 52 | ||
84 | @@ -XXX,XX +XXX,XX @@ static inline bool arm_excp_unmasked(CPUState *cs, unsigned int excp_idx, | 53 | -static void stellaris_adc_update(stellaris_adc_state *s) |
85 | return false; | 54 | +static void stellaris_adc_update(StellarisADCState *s) |
86 | } | 55 | { |
87 | return !(env->daif & PSTATE_I); | 56 | int level; |
88 | + case EXCP_VSERR: | 57 | int n; |
89 | + if (!(hcr_el2 & HCR_AMO) || (hcr_el2 & HCR_TGE)) { | 58 | @@ -XXX,XX +XXX,XX @@ static void stellaris_adc_update(stellaris_adc_state *s) |
90 | + /* VIRQs are only taken when hypervized. */ | 59 | |
91 | + return false; | 60 | static void stellaris_adc_trigger(void *opaque, int irq, int level) |
92 | + } | 61 | { |
93 | + return !(env->daif & PSTATE_A); | 62 | - stellaris_adc_state *s = opaque; |
94 | default: | 63 | + StellarisADCState *s = opaque; |
95 | g_assert_not_reached(); | 64 | int n; |
96 | } | 65 | |
97 | @@ -XXX,XX +XXX,XX @@ static bool arm_cpu_exec_interrupt(CPUState *cs, int interrupt_request) | 66 | for (n = 0; n < 4; n++) { |
98 | goto found; | 67 | @@ -XXX,XX +XXX,XX @@ static void stellaris_adc_trigger(void *opaque, int irq, int level) |
99 | } | ||
100 | } | ||
101 | + if (interrupt_request & CPU_INTERRUPT_VSERR) { | ||
102 | + excp_idx = EXCP_VSERR; | ||
103 | + target_el = 1; | ||
104 | + if (arm_excp_unmasked(cs, excp_idx, target_el, | ||
105 | + cur_el, secure, hcr_el2)) { | ||
106 | + /* Taking a virtual abort clears HCR_EL2.VSE */ | ||
107 | + env->cp15.hcr_el2 &= ~HCR_VSE; | ||
108 | + cpu_reset_interrupt(cs, CPU_INTERRUPT_VSERR); | ||
109 | + goto found; | ||
110 | + } | ||
111 | + } | ||
112 | return false; | ||
113 | |||
114 | found: | ||
115 | @@ -XXX,XX +XXX,XX @@ void arm_cpu_update_vfiq(ARMCPU *cpu) | ||
116 | } | 68 | } |
117 | } | 69 | } |
118 | 70 | ||
119 | +void arm_cpu_update_vserr(ARMCPU *cpu) | 71 | -static void stellaris_adc_reset(stellaris_adc_state *s) |
120 | +{ | 72 | +static void stellaris_adc_reset(StellarisADCState *s) |
121 | + /* | ||
122 | + * Update the interrupt level for VSERR, which is the HCR_EL2.VSE bit. | ||
123 | + */ | ||
124 | + CPUARMState *env = &cpu->env; | ||
125 | + CPUState *cs = CPU(cpu); | ||
126 | + | ||
127 | + bool new_state = env->cp15.hcr_el2 & HCR_VSE; | ||
128 | + | ||
129 | + if (new_state != ((cs->interrupt_request & CPU_INTERRUPT_VSERR) != 0)) { | ||
130 | + if (new_state) { | ||
131 | + cpu_interrupt(cs, CPU_INTERRUPT_VSERR); | ||
132 | + } else { | ||
133 | + cpu_reset_interrupt(cs, CPU_INTERRUPT_VSERR); | ||
134 | + } | ||
135 | + } | ||
136 | +} | ||
137 | + | ||
138 | #ifndef CONFIG_USER_ONLY | ||
139 | static void arm_cpu_set_irq(void *opaque, int irq, int level) | ||
140 | { | 73 | { |
141 | diff --git a/target/arm/helper.c b/target/arm/helper.c | 74 | int n; |
142 | index XXXXXXX..XXXXXXX 100644 | 75 | |
143 | --- a/target/arm/helper.c | 76 | @@ -XXX,XX +XXX,XX @@ static void stellaris_adc_reset(stellaris_adc_state *s) |
144 | +++ b/target/arm/helper.c | 77 | static uint64_t stellaris_adc_read(void *opaque, hwaddr offset, |
145 | @@ -XXX,XX +XXX,XX @@ static uint64_t isr_read(CPUARMState *env, const ARMCPRegInfo *ri) | 78 | unsigned size) |
146 | } | 79 | { |
80 | - stellaris_adc_state *s = opaque; | ||
81 | + StellarisADCState *s = opaque; | ||
82 | |||
83 | /* TODO: Implement this. */ | ||
84 | if (offset >= 0x40 && offset < 0xc0) { | ||
85 | @@ -XXX,XX +XXX,XX @@ static uint64_t stellaris_adc_read(void *opaque, hwaddr offset, | ||
86 | static void stellaris_adc_write(void *opaque, hwaddr offset, | ||
87 | uint64_t value, unsigned size) | ||
88 | { | ||
89 | - stellaris_adc_state *s = opaque; | ||
90 | + StellarisADCState *s = opaque; | ||
91 | |||
92 | /* TODO: Implement this. */ | ||
93 | if (offset >= 0x40 && offset < 0xc0) { | ||
94 | @@ -XXX,XX +XXX,XX @@ static const VMStateDescription vmstate_stellaris_adc = { | ||
95 | .version_id = 1, | ||
96 | .minimum_version_id = 1, | ||
97 | .fields = (VMStateField[]) { | ||
98 | - VMSTATE_UINT32(actss, stellaris_adc_state), | ||
99 | - VMSTATE_UINT32(ris, stellaris_adc_state), | ||
100 | - VMSTATE_UINT32(im, stellaris_adc_state), | ||
101 | - VMSTATE_UINT32(emux, stellaris_adc_state), | ||
102 | - VMSTATE_UINT32(ostat, stellaris_adc_state), | ||
103 | - VMSTATE_UINT32(ustat, stellaris_adc_state), | ||
104 | - VMSTATE_UINT32(sspri, stellaris_adc_state), | ||
105 | - VMSTATE_UINT32(sac, stellaris_adc_state), | ||
106 | - VMSTATE_UINT32(fifo[0].state, stellaris_adc_state), | ||
107 | - VMSTATE_UINT32_ARRAY(fifo[0].data, stellaris_adc_state, 16), | ||
108 | - VMSTATE_UINT32(ssmux[0], stellaris_adc_state), | ||
109 | - VMSTATE_UINT32(ssctl[0], stellaris_adc_state), | ||
110 | - VMSTATE_UINT32(fifo[1].state, stellaris_adc_state), | ||
111 | - VMSTATE_UINT32_ARRAY(fifo[1].data, stellaris_adc_state, 16), | ||
112 | - VMSTATE_UINT32(ssmux[1], stellaris_adc_state), | ||
113 | - VMSTATE_UINT32(ssctl[1], stellaris_adc_state), | ||
114 | - VMSTATE_UINT32(fifo[2].state, stellaris_adc_state), | ||
115 | - VMSTATE_UINT32_ARRAY(fifo[2].data, stellaris_adc_state, 16), | ||
116 | - VMSTATE_UINT32(ssmux[2], stellaris_adc_state), | ||
117 | - VMSTATE_UINT32(ssctl[2], stellaris_adc_state), | ||
118 | - VMSTATE_UINT32(fifo[3].state, stellaris_adc_state), | ||
119 | - VMSTATE_UINT32_ARRAY(fifo[3].data, stellaris_adc_state, 16), | ||
120 | - VMSTATE_UINT32(ssmux[3], stellaris_adc_state), | ||
121 | - VMSTATE_UINT32(ssctl[3], stellaris_adc_state), | ||
122 | - VMSTATE_UINT32(noise, stellaris_adc_state), | ||
123 | + VMSTATE_UINT32(actss, StellarisADCState), | ||
124 | + VMSTATE_UINT32(ris, StellarisADCState), | ||
125 | + VMSTATE_UINT32(im, StellarisADCState), | ||
126 | + VMSTATE_UINT32(emux, StellarisADCState), | ||
127 | + VMSTATE_UINT32(ostat, StellarisADCState), | ||
128 | + VMSTATE_UINT32(ustat, StellarisADCState), | ||
129 | + VMSTATE_UINT32(sspri, StellarisADCState), | ||
130 | + VMSTATE_UINT32(sac, StellarisADCState), | ||
131 | + VMSTATE_UINT32(fifo[0].state, StellarisADCState), | ||
132 | + VMSTATE_UINT32_ARRAY(fifo[0].data, StellarisADCState, 16), | ||
133 | + VMSTATE_UINT32(ssmux[0], StellarisADCState), | ||
134 | + VMSTATE_UINT32(ssctl[0], StellarisADCState), | ||
135 | + VMSTATE_UINT32(fifo[1].state, StellarisADCState), | ||
136 | + VMSTATE_UINT32_ARRAY(fifo[1].data, StellarisADCState, 16), | ||
137 | + VMSTATE_UINT32(ssmux[1], StellarisADCState), | ||
138 | + VMSTATE_UINT32(ssctl[1], StellarisADCState), | ||
139 | + VMSTATE_UINT32(fifo[2].state, StellarisADCState), | ||
140 | + VMSTATE_UINT32_ARRAY(fifo[2].data, StellarisADCState, 16), | ||
141 | + VMSTATE_UINT32(ssmux[2], StellarisADCState), | ||
142 | + VMSTATE_UINT32(ssctl[2], StellarisADCState), | ||
143 | + VMSTATE_UINT32(fifo[3].state, StellarisADCState), | ||
144 | + VMSTATE_UINT32_ARRAY(fifo[3].data, StellarisADCState, 16), | ||
145 | + VMSTATE_UINT32(ssmux[3], StellarisADCState), | ||
146 | + VMSTATE_UINT32(ssctl[3], StellarisADCState), | ||
147 | + VMSTATE_UINT32(noise, StellarisADCState), | ||
148 | VMSTATE_END_OF_LIST() | ||
147 | } | 149 | } |
148 | 150 | }; | |
149 | - /* External aborts are not possible in QEMU so A bit is always clear */ | 151 | @@ -XXX,XX +XXX,XX @@ static const VMStateDescription vmstate_stellaris_adc = { |
150 | + if (hcr_el2 & HCR_AMO) { | 152 | static void stellaris_adc_init(Object *obj) |
151 | + if (cs->interrupt_request & CPU_INTERRUPT_VSERR) { | 153 | { |
152 | + ret |= CPSR_A; | 154 | DeviceState *dev = DEVICE(obj); |
153 | + } | 155 | - stellaris_adc_state *s = STELLARIS_ADC(obj); |
154 | + } | 156 | + StellarisADCState *s = STELLARIS_ADC(obj); |
155 | + | 157 | SysBusDevice *sbd = SYS_BUS_DEVICE(obj); |
156 | return ret; | 158 | int n; |
157 | } | 159 | |
158 | 160 | @@ -XXX,XX +XXX,XX @@ static void stellaris_adc_class_init(ObjectClass *klass, void *data) | |
159 | @@ -XXX,XX +XXX,XX @@ static void do_hcr_write(CPUARMState *env, uint64_t value, uint64_t valid_mask) | 161 | static const TypeInfo stellaris_adc_info = { |
160 | g_assert(qemu_mutex_iothread_locked()); | 162 | .name = TYPE_STELLARIS_ADC, |
161 | arm_cpu_update_virq(cpu); | 163 | .parent = TYPE_SYS_BUS_DEVICE, |
162 | arm_cpu_update_vfiq(cpu); | 164 | - .instance_size = sizeof(stellaris_adc_state), |
163 | + arm_cpu_update_vserr(cpu); | 165 | + .instance_size = sizeof(StellarisADCState), |
164 | } | 166 | .instance_init = stellaris_adc_init, |
165 | 167 | .class_init = stellaris_adc_class_init, | |
166 | static void hcr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value) | 168 | }; |
167 | @@ -XXX,XX +XXX,XX @@ void arm_log_exception(CPUState *cs) | ||
168 | [EXCP_LSERR] = "v8M LSERR UsageFault", | ||
169 | [EXCP_UNALIGNED] = "v7M UNALIGNED UsageFault", | ||
170 | [EXCP_DIVBYZERO] = "v7M DIVBYZERO UsageFault", | ||
171 | + [EXCP_VSERR] = "Virtual SERR", | ||
172 | }; | ||
173 | |||
174 | if (idx >= 0 && idx < ARRAY_SIZE(excnames)) { | ||
175 | @@ -XXX,XX +XXX,XX @@ static void arm_cpu_do_interrupt_aarch32(CPUState *cs) | ||
176 | mask = CPSR_A | CPSR_I | CPSR_F; | ||
177 | offset = 4; | ||
178 | break; | ||
179 | + case EXCP_VSERR: | ||
180 | + { | ||
181 | + /* | ||
182 | + * Note that this is reported as a data abort, but the DFAR | ||
183 | + * has an UNKNOWN value. Construct the SError syndrome from | ||
184 | + * AET and ExT fields. | ||
185 | + */ | ||
186 | + ARMMMUFaultInfo fi = { .type = ARMFault_AsyncExternal, }; | ||
187 | + | ||
188 | + if (extended_addresses_enabled(env)) { | ||
189 | + env->exception.fsr = arm_fi_to_lfsc(&fi); | ||
190 | + } else { | ||
191 | + env->exception.fsr = arm_fi_to_sfsc(&fi); | ||
192 | + } | ||
193 | + env->exception.fsr |= env->cp15.vsesr_el2 & 0xd000; | ||
194 | + A32_BANKED_CURRENT_REG_SET(env, dfsr, env->exception.fsr); | ||
195 | + qemu_log_mask(CPU_LOG_INT, "...with IFSR 0x%x\n", | ||
196 | + env->exception.fsr); | ||
197 | + | ||
198 | + new_mode = ARM_CPU_MODE_ABT; | ||
199 | + addr = 0x10; | ||
200 | + mask = CPSR_A | CPSR_I; | ||
201 | + offset = 8; | ||
202 | + } | ||
203 | + break; | ||
204 | case EXCP_SMC: | ||
205 | new_mode = ARM_CPU_MODE_MON; | ||
206 | addr = 0x08; | ||
207 | @@ -XXX,XX +XXX,XX @@ static void arm_cpu_do_interrupt_aarch64(CPUState *cs) | ||
208 | case EXCP_VFIQ: | ||
209 | addr += 0x100; | ||
210 | break; | ||
211 | + case EXCP_VSERR: | ||
212 | + addr += 0x180; | ||
213 | + /* Construct the SError syndrome from IDS and ISS fields. */ | ||
214 | + env->exception.syndrome = syn_serror(env->cp15.vsesr_el2 & 0x1ffffff); | ||
215 | + env->cp15.esr_el[new_el] = env->exception.syndrome; | ||
216 | + break; | ||
217 | default: | ||
218 | cpu_abort(cs, "Unhandled exception 0x%x\n", cs->exception_index); | ||
219 | } | ||
220 | -- | 169 | -- |
221 | 2.25.1 | 170 | 2.34.1 |
171 | |||
172 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | This extension concerns changes to the External Debug interface, | 3 | The typedef and definitions are generated by the OBJECT_DECLARE_TYPE |
4 | with Secure and Non-secure access to the debug registers, and all | 4 | macro in "hw/arm/bcm2836.h": |
5 | of it is outside the scope of QEMU. Indicating support for this | ||
6 | is mandatory with FEAT_SEL2, which we do implement. | ||
7 | 5 | ||
8 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 6 | 20 #define TYPE_BCM283X "bcm283x" |
9 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 7 | 21 OBJECT_DECLARE_TYPE(BCM283XState, BCM283XClass, BCM283X) |
10 | Message-id: 20220506180242.216785-13-richard.henderson@linaro.org | 8 | |
9 | The script ran in commit a489d1951c ("Use OBJECT_DECLARE_TYPE when | ||
10 | possible") missed them because they are declared in a different | ||
11 | file unit. Remove them. | ||
12 | |||
13 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> | ||
14 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
15 | Message-id: 20230109140306.23161-10-philmd@linaro.org | ||
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 16 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
12 | --- | 17 | --- |
13 | docs/system/arm/emulation.rst | 1 + | 18 | hw/arm/bcm2836.c | 9 ++------- |
14 | target/arm/cpu64.c | 2 +- | 19 | 1 file changed, 2 insertions(+), 7 deletions(-) |
15 | target/arm/cpu_tcg.c | 4 ++-- | ||
16 | 3 files changed, 4 insertions(+), 3 deletions(-) | ||
17 | 20 | ||
18 | diff --git a/docs/system/arm/emulation.rst b/docs/system/arm/emulation.rst | 21 | diff --git a/hw/arm/bcm2836.c b/hw/arm/bcm2836.c |
19 | index XXXXXXX..XXXXXXX 100644 | 22 | index XXXXXXX..XXXXXXX 100644 |
20 | --- a/docs/system/arm/emulation.rst | 23 | --- a/hw/arm/bcm2836.c |
21 | +++ b/docs/system/arm/emulation.rst | 24 | +++ b/hw/arm/bcm2836.c |
22 | @@ -XXX,XX +XXX,XX @@ the following architecture extensions: | 25 | @@ -XXX,XX +XXX,XX @@ |
23 | - FEAT_DIT (Data Independent Timing instructions) | 26 | #include "hw/arm/raspi_platform.h" |
24 | - FEAT_DPB (DC CVAP instruction) | 27 | #include "hw/sysbus.h" |
25 | - FEAT_Debugv8p2 (Debug changes for v8.2) | 28 | |
26 | +- FEAT_Debugv8p4 (Debug changes for v8.4) | 29 | -typedef struct BCM283XClass { |
27 | - FEAT_DotProd (Advanced SIMD dot product instructions) | 30 | +struct BCM283XClass { |
28 | - FEAT_FCMA (Floating-point complex number instructions) | 31 | /*< private >*/ |
29 | - FEAT_FHM (Floating-point half-precision multiplication instructions) | 32 | DeviceClass parent_class; |
30 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | 33 | /*< public >*/ |
31 | index XXXXXXX..XXXXXXX 100644 | 34 | @@ -XXX,XX +XXX,XX @@ typedef struct BCM283XClass { |
32 | --- a/target/arm/cpu64.c | 35 | hwaddr peri_base; /* Peripheral base address seen by the CPU */ |
33 | +++ b/target/arm/cpu64.c | 36 | hwaddr ctrl_base; /* Interrupt controller and mailboxes etc. */ |
34 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | 37 | int clusterid; |
35 | cpu->isar.id_aa64zfr0 = t; | 38 | -} BCM283XClass; |
36 | 39 | - | |
37 | t = cpu->isar.id_aa64dfr0; | 40 | -#define BCM283X_CLASS(klass) \ |
38 | - t = FIELD_DP64(t, ID_AA64DFR0, DEBUGVER, 8); /* FEAT_Debugv8p2 */ | 41 | - OBJECT_CLASS_CHECK(BCM283XClass, (klass), TYPE_BCM283X) |
39 | + t = FIELD_DP64(t, ID_AA64DFR0, DEBUGVER, 9); /* FEAT_Debugv8p4 */ | 42 | -#define BCM283X_GET_CLASS(obj) \ |
40 | t = FIELD_DP64(t, ID_AA64DFR0, PMUVER, 5); /* FEAT_PMUv3p4 */ | 43 | - OBJECT_GET_CLASS(BCM283XClass, (obj), TYPE_BCM283X) |
41 | cpu->isar.id_aa64dfr0 = t; | 44 | +}; |
42 | 45 | ||
43 | diff --git a/target/arm/cpu_tcg.c b/target/arm/cpu_tcg.c | 46 | static Property bcm2836_enabled_cores_property = |
44 | index XXXXXXX..XXXXXXX 100644 | 47 | DEFINE_PROP_UINT32("enabled-cpus", BCM283XState, enabled_cpus, 0); |
45 | --- a/target/arm/cpu_tcg.c | ||
46 | +++ b/target/arm/cpu_tcg.c | ||
47 | @@ -XXX,XX +XXX,XX @@ void aa32_max_features(ARMCPU *cpu) | ||
48 | cpu->isar.id_pfr2 = t; | ||
49 | |||
50 | t = cpu->isar.id_dfr0; | ||
51 | - t = FIELD_DP32(t, ID_DFR0, COPDBG, 8); /* FEAT_Debugv8p2 */ | ||
52 | - t = FIELD_DP32(t, ID_DFR0, COPSDBG, 8); /* FEAT_Debugv8p2 */ | ||
53 | + t = FIELD_DP32(t, ID_DFR0, COPDBG, 9); /* FEAT_Debugv8p4 */ | ||
54 | + t = FIELD_DP32(t, ID_DFR0, COPSDBG, 9); /* FEAT_Debugv8p4 */ | ||
55 | t = FIELD_DP32(t, ID_DFR0, PERFMON, 5); /* FEAT_PMUv3p4 */ | ||
56 | cpu->isar.id_dfr0 = t; | ||
57 | } | ||
58 | -- | 48 | -- |
59 | 2.25.1 | 49 | 2.34.1 |
50 | |||
51 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Add only the system registers required to implement zero error | 3 | NPCM7XX models have been commited after the conversion from |
4 | records. This means that all values for ERRSELR are out of range, | 4 | commit 8063396bf3 ("Use OBJECT_DECLARE_SIMPLE_TYPE when possible"). |
5 | which means that it and all of the indexed error record registers | 5 | Manually convert them. |
6 | need not be implemented. | 6 | |
7 | 7 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> | |
8 | Add the EL2 registers required for injecting virtual SError. | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
9 | 9 | Message-id: 20230109140306.23161-11-philmd@linaro.org | |
10 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
11 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | ||
12 | Message-id: 20220506180242.216785-14-richard.henderson@linaro.org | ||
13 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
14 | --- | 11 | --- |
15 | target/arm/cpu.h | 5 +++ | 12 | include/hw/adc/npcm7xx_adc.h | 7 +++---- |
16 | target/arm/helper.c | 84 +++++++++++++++++++++++++++++++++++++++++++++ | 13 | include/hw/arm/npcm7xx.h | 18 ++++++------------ |
17 | 2 files changed, 89 insertions(+) | 14 | include/hw/i2c/npcm7xx_smbus.h | 7 +++---- |
18 | 15 | include/hw/misc/npcm7xx_clk.h | 2 +- | |
19 | diff --git a/target/arm/cpu.h b/target/arm/cpu.h | 16 | include/hw/misc/npcm7xx_gcr.h | 6 +++--- |
20 | index XXXXXXX..XXXXXXX 100644 | 17 | include/hw/misc/npcm7xx_mft.h | 7 +++---- |
21 | --- a/target/arm/cpu.h | 18 | include/hw/misc/npcm7xx_pwm.h | 3 +-- |
22 | +++ b/target/arm/cpu.h | 19 | include/hw/misc/npcm7xx_rng.h | 6 +++--- |
23 | @@ -XXX,XX +XXX,XX @@ typedef struct CPUArchState { | 20 | include/hw/net/npcm7xx_emc.h | 5 +---- |
24 | uint64_t tfsr_el[4]; /* tfsre0_el1 is index 0. */ | 21 | include/hw/sd/npcm7xx_sdhci.h | 4 ++-- |
25 | uint64_t gcr_el1; | 22 | 10 files changed, 26 insertions(+), 39 deletions(-) |
26 | uint64_t rgsr_el1; | 23 | |
27 | + | 24 | diff --git a/include/hw/adc/npcm7xx_adc.h b/include/hw/adc/npcm7xx_adc.h |
28 | + /* Minimal RAS registers */ | 25 | index XXXXXXX..XXXXXXX 100644 |
29 | + uint64_t disr_el1; | 26 | --- a/include/hw/adc/npcm7xx_adc.h |
30 | + uint64_t vdisr_el2; | 27 | +++ b/include/hw/adc/npcm7xx_adc.h |
31 | + uint64_t vsesr_el2; | 28 | @@ -XXX,XX +XXX,XX @@ |
32 | } cp15; | 29 | * @iref: The internal reference voltage, initialized at launch time. |
33 | 30 | * @rv: The calibrated output values of 0.5V and 1.5V for the ADC. | |
34 | struct { | 31 | */ |
35 | diff --git a/target/arm/helper.c b/target/arm/helper.c | 32 | -typedef struct { |
36 | index XXXXXXX..XXXXXXX 100644 | 33 | +struct NPCM7xxADCState { |
37 | --- a/target/arm/helper.c | 34 | SysBusDevice parent; |
38 | +++ b/target/arm/helper.c | 35 | |
39 | @@ -XXX,XX +XXX,XX @@ static const ARMCPRegInfo debug_lpae_cp_reginfo[] = { | 36 | MemoryRegion iomem; |
40 | .access = PL0_R, .type = ARM_CP_CONST|ARM_CP_64BIT, .resetvalue = 0 }, | 37 | @@ -XXX,XX +XXX,XX @@ typedef struct { |
38 | uint32_t iref; | ||
39 | |||
40 | uint16_t calibration_r_values[NPCM7XX_ADC_NUM_CALIB]; | ||
41 | -} NPCM7xxADCState; | ||
42 | +}; | ||
43 | |||
44 | #define TYPE_NPCM7XX_ADC "npcm7xx-adc" | ||
45 | -#define NPCM7XX_ADC(obj) \ | ||
46 | - OBJECT_CHECK(NPCM7xxADCState, (obj), TYPE_NPCM7XX_ADC) | ||
47 | +OBJECT_DECLARE_SIMPLE_TYPE(NPCM7xxADCState, NPCM7XX_ADC) | ||
48 | |||
49 | #endif /* NPCM7XX_ADC_H */ | ||
50 | diff --git a/include/hw/arm/npcm7xx.h b/include/hw/arm/npcm7xx.h | ||
51 | index XXXXXXX..XXXXXXX 100644 | ||
52 | --- a/include/hw/arm/npcm7xx.h | ||
53 | +++ b/include/hw/arm/npcm7xx.h | ||
54 | @@ -XXX,XX +XXX,XX @@ | ||
55 | |||
56 | #define NPCM7XX_NR_PWM_MODULES 2 | ||
57 | |||
58 | -typedef struct NPCM7xxMachine { | ||
59 | +struct NPCM7xxMachine { | ||
60 | MachineState parent; | ||
61 | /* | ||
62 | * PWM fan splitter. each splitter connects to one PWM output and | ||
63 | @@ -XXX,XX +XXX,XX @@ typedef struct NPCM7xxMachine { | ||
64 | */ | ||
65 | SplitIRQ fan_splitter[NPCM7XX_NR_PWM_MODULES * | ||
66 | NPCM7XX_PWM_PER_MODULE]; | ||
67 | -} NPCM7xxMachine; | ||
68 | +}; | ||
69 | |||
70 | #define TYPE_NPCM7XX_MACHINE MACHINE_TYPE_NAME("npcm7xx") | ||
71 | -#define NPCM7XX_MACHINE(obj) \ | ||
72 | - OBJECT_CHECK(NPCM7xxMachine, (obj), TYPE_NPCM7XX_MACHINE) | ||
73 | +OBJECT_DECLARE_SIMPLE_TYPE(NPCM7xxMachine, NPCM7XX_MACHINE) | ||
74 | |||
75 | typedef struct NPCM7xxMachineClass { | ||
76 | MachineClass parent; | ||
77 | @@ -XXX,XX +XXX,XX @@ typedef struct NPCM7xxMachineClass { | ||
78 | #define NPCM7XX_MACHINE_GET_CLASS(obj) \ | ||
79 | OBJECT_GET_CLASS(NPCM7xxMachineClass, (obj), TYPE_NPCM7XX_MACHINE) | ||
80 | |||
81 | -typedef struct NPCM7xxState { | ||
82 | +struct NPCM7xxState { | ||
83 | DeviceState parent; | ||
84 | |||
85 | ARMCPU cpu[NPCM7XX_MAX_NUM_CPUS]; | ||
86 | @@ -XXX,XX +XXX,XX @@ typedef struct NPCM7xxState { | ||
87 | NPCM7xxFIUState fiu[2]; | ||
88 | NPCM7xxEMCState emc[2]; | ||
89 | NPCM7xxSDHCIState mmc; | ||
90 | -} NPCM7xxState; | ||
91 | +}; | ||
92 | |||
93 | #define TYPE_NPCM7XX "npcm7xx" | ||
94 | -#define NPCM7XX(obj) OBJECT_CHECK(NPCM7xxState, (obj), TYPE_NPCM7XX) | ||
95 | +OBJECT_DECLARE_TYPE(NPCM7xxState, NPCM7xxClass, NPCM7XX) | ||
96 | |||
97 | #define TYPE_NPCM730 "npcm730" | ||
98 | #define TYPE_NPCM750 "npcm750" | ||
99 | @@ -XXX,XX +XXX,XX @@ typedef struct NPCM7xxClass { | ||
100 | uint32_t num_cpus; | ||
101 | } NPCM7xxClass; | ||
102 | |||
103 | -#define NPCM7XX_CLASS(klass) \ | ||
104 | - OBJECT_CLASS_CHECK(NPCM7xxClass, (klass), TYPE_NPCM7XX) | ||
105 | -#define NPCM7XX_GET_CLASS(obj) \ | ||
106 | - OBJECT_GET_CLASS(NPCM7xxClass, (obj), TYPE_NPCM7XX) | ||
107 | - | ||
108 | /** | ||
109 | * npcm7xx_load_kernel - Loads memory with everything needed to boot | ||
110 | * @machine - The machine containing the SoC to be booted. | ||
111 | diff --git a/include/hw/i2c/npcm7xx_smbus.h b/include/hw/i2c/npcm7xx_smbus.h | ||
112 | index XXXXXXX..XXXXXXX 100644 | ||
113 | --- a/include/hw/i2c/npcm7xx_smbus.h | ||
114 | +++ b/include/hw/i2c/npcm7xx_smbus.h | ||
115 | @@ -XXX,XX +XXX,XX @@ typedef enum NPCM7xxSMBusStatus { | ||
116 | * @rx_cur: The current position of rx_fifo. | ||
117 | * @status: The current status of the SMBus. | ||
118 | */ | ||
119 | -typedef struct NPCM7xxSMBusState { | ||
120 | +struct NPCM7xxSMBusState { | ||
121 | SysBusDevice parent; | ||
122 | |||
123 | MemoryRegion iomem; | ||
124 | @@ -XXX,XX +XXX,XX @@ typedef struct NPCM7xxSMBusState { | ||
125 | uint8_t rx_cur; | ||
126 | |||
127 | NPCM7xxSMBusStatus status; | ||
128 | -} NPCM7xxSMBusState; | ||
129 | +}; | ||
130 | |||
131 | #define TYPE_NPCM7XX_SMBUS "npcm7xx-smbus" | ||
132 | -#define NPCM7XX_SMBUS(obj) OBJECT_CHECK(NPCM7xxSMBusState, (obj), \ | ||
133 | - TYPE_NPCM7XX_SMBUS) | ||
134 | +OBJECT_DECLARE_SIMPLE_TYPE(NPCM7xxSMBusState, NPCM7XX_SMBUS) | ||
135 | |||
136 | #endif /* NPCM7XX_SMBUS_H */ | ||
137 | diff --git a/include/hw/misc/npcm7xx_clk.h b/include/hw/misc/npcm7xx_clk.h | ||
138 | index XXXXXXX..XXXXXXX 100644 | ||
139 | --- a/include/hw/misc/npcm7xx_clk.h | ||
140 | +++ b/include/hw/misc/npcm7xx_clk.h | ||
141 | @@ -XXX,XX +XXX,XX @@ struct NPCM7xxCLKState { | ||
41 | }; | 142 | }; |
42 | 143 | ||
43 | +/* | 144 | #define TYPE_NPCM7XX_CLK "npcm7xx-clk" |
44 | + * Check for traps to RAS registers, which are controlled | 145 | -#define NPCM7XX_CLK(obj) OBJECT_CHECK(NPCM7xxCLKState, (obj), TYPE_NPCM7XX_CLK) |
45 | + * by HCR_EL2.TERR and SCR_EL3.TERR. | 146 | +OBJECT_DECLARE_SIMPLE_TYPE(NPCM7xxCLKState, NPCM7XX_CLK) |
46 | + */ | 147 | |
47 | +static CPAccessResult access_terr(CPUARMState *env, const ARMCPRegInfo *ri, | 148 | #endif /* NPCM7XX_CLK_H */ |
48 | + bool isread) | 149 | diff --git a/include/hw/misc/npcm7xx_gcr.h b/include/hw/misc/npcm7xx_gcr.h |
49 | +{ | 150 | index XXXXXXX..XXXXXXX 100644 |
50 | + int el = arm_current_el(env); | 151 | --- a/include/hw/misc/npcm7xx_gcr.h |
51 | + | 152 | +++ b/include/hw/misc/npcm7xx_gcr.h |
52 | + if (el < 2 && (arm_hcr_el2_eff(env) & HCR_TERR)) { | 153 | @@ -XXX,XX +XXX,XX @@ |
53 | + return CP_ACCESS_TRAP_EL2; | 154 | */ |
54 | + } | 155 | #define NPCM7XX_GCR_NR_REGS (0x148 / sizeof(uint32_t)) |
55 | + if (el < 3 && (env->cp15.scr_el3 & SCR_TERR)) { | 156 | |
56 | + return CP_ACCESS_TRAP_EL3; | 157 | -typedef struct NPCM7xxGCRState { |
57 | + } | 158 | +struct NPCM7xxGCRState { |
58 | + return CP_ACCESS_OK; | 159 | SysBusDevice parent; |
59 | +} | 160 | |
60 | + | 161 | MemoryRegion iomem; |
61 | +static uint64_t disr_read(CPUARMState *env, const ARMCPRegInfo *ri) | 162 | @@ -XXX,XX +XXX,XX @@ typedef struct NPCM7xxGCRState { |
62 | +{ | 163 | uint32_t reset_pwron; |
63 | + int el = arm_current_el(env); | 164 | uint32_t reset_mdlr; |
64 | + | 165 | uint32_t reset_intcr3; |
65 | + if (el < 2 && (arm_hcr_el2_eff(env) & HCR_AMO)) { | 166 | -} NPCM7xxGCRState; |
66 | + return env->cp15.vdisr_el2; | 167 | +}; |
67 | + } | 168 | |
68 | + if (el < 3 && (env->cp15.scr_el3 & SCR_EA)) { | 169 | #define TYPE_NPCM7XX_GCR "npcm7xx-gcr" |
69 | + return 0; /* RAZ/WI */ | 170 | -#define NPCM7XX_GCR(obj) OBJECT_CHECK(NPCM7xxGCRState, (obj), TYPE_NPCM7XX_GCR) |
70 | + } | 171 | +OBJECT_DECLARE_SIMPLE_TYPE(NPCM7xxGCRState, NPCM7XX_GCR) |
71 | + return env->cp15.disr_el1; | 172 | |
72 | +} | 173 | #endif /* NPCM7XX_GCR_H */ |
73 | + | 174 | diff --git a/include/hw/misc/npcm7xx_mft.h b/include/hw/misc/npcm7xx_mft.h |
74 | +static void disr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t val) | 175 | index XXXXXXX..XXXXXXX 100644 |
75 | +{ | 176 | --- a/include/hw/misc/npcm7xx_mft.h |
76 | + int el = arm_current_el(env); | 177 | +++ b/include/hw/misc/npcm7xx_mft.h |
77 | + | 178 | @@ -XXX,XX +XXX,XX @@ |
78 | + if (el < 2 && (arm_hcr_el2_eff(env) & HCR_AMO)) { | 179 | * @max_rpm: The maximum rpm for fans. Order: A0, B0, A1, B1. |
79 | + env->cp15.vdisr_el2 = val; | 180 | * @duty: The duty cycles for fans, relative to NPCM7XX_PWM_MAX_DUTY. |
80 | + return; | 181 | */ |
81 | + } | 182 | -typedef struct NPCM7xxMFTState { |
82 | + if (el < 3 && (env->cp15.scr_el3 & SCR_EA)) { | 183 | +struct NPCM7xxMFTState { |
83 | + return; /* RAZ/WI */ | 184 | SysBusDevice parent; |
84 | + } | 185 | |
85 | + env->cp15.disr_el1 = val; | 186 | MemoryRegion iomem; |
86 | +} | 187 | @@ -XXX,XX +XXX,XX @@ typedef struct NPCM7xxMFTState { |
87 | + | 188 | |
88 | +/* | 189 | uint32_t max_rpm[NPCM7XX_MFT_FANIN_COUNT]; |
89 | + * Minimal RAS implementation with no Error Records. | 190 | uint32_t duty[NPCM7XX_MFT_FANIN_COUNT]; |
90 | + * Which means that all of the Error Record registers: | 191 | -} NPCM7xxMFTState; |
91 | + * ERXADDR_EL1 | 192 | +}; |
92 | + * ERXCTLR_EL1 | 193 | |
93 | + * ERXFR_EL1 | 194 | #define TYPE_NPCM7XX_MFT "npcm7xx-mft" |
94 | + * ERXMISC0_EL1 | 195 | -#define NPCM7XX_MFT(obj) \ |
95 | + * ERXMISC1_EL1 | 196 | - OBJECT_CHECK(NPCM7xxMFTState, (obj), TYPE_NPCM7XX_MFT) |
96 | + * ERXMISC2_EL1 | 197 | +OBJECT_DECLARE_SIMPLE_TYPE(NPCM7xxMFTState, NPCM7XX_MFT) |
97 | + * ERXMISC3_EL1 | 198 | |
98 | + * ERXPFGCDN_EL1 (RASv1p1) | 199 | #endif /* NPCM7XX_MFT_H */ |
99 | + * ERXPFGCTL_EL1 (RASv1p1) | 200 | diff --git a/include/hw/misc/npcm7xx_pwm.h b/include/hw/misc/npcm7xx_pwm.h |
100 | + * ERXPFGF_EL1 (RASv1p1) | 201 | index XXXXXXX..XXXXXXX 100644 |
101 | + * ERXSTATUS_EL1 | 202 | --- a/include/hw/misc/npcm7xx_pwm.h |
102 | + * and | 203 | +++ b/include/hw/misc/npcm7xx_pwm.h |
103 | + * ERRSELR_EL1 | 204 | @@ -XXX,XX +XXX,XX @@ struct NPCM7xxPWMState { |
104 | + * may generate UNDEFINED, which is the effect we get by not | 205 | }; |
105 | + * listing them at all. | 206 | |
106 | + */ | 207 | #define TYPE_NPCM7XX_PWM "npcm7xx-pwm" |
107 | +static const ARMCPRegInfo minimal_ras_reginfo[] = { | 208 | -#define NPCM7XX_PWM(obj) \ |
108 | + { .name = "DISR_EL1", .state = ARM_CP_STATE_BOTH, | 209 | - OBJECT_CHECK(NPCM7xxPWMState, (obj), TYPE_NPCM7XX_PWM) |
109 | + .opc0 = 3, .opc1 = 0, .crn = 12, .crm = 1, .opc2 = 1, | 210 | +OBJECT_DECLARE_SIMPLE_TYPE(NPCM7xxPWMState, NPCM7XX_PWM) |
110 | + .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.disr_el1), | 211 | |
111 | + .readfn = disr_read, .writefn = disr_write, .raw_writefn = raw_write }, | 212 | #endif /* NPCM7XX_PWM_H */ |
112 | + { .name = "ERRIDR_EL1", .state = ARM_CP_STATE_BOTH, | 213 | diff --git a/include/hw/misc/npcm7xx_rng.h b/include/hw/misc/npcm7xx_rng.h |
113 | + .opc0 = 3, .opc1 = 0, .crn = 5, .crm = 3, .opc2 = 0, | 214 | index XXXXXXX..XXXXXXX 100644 |
114 | + .access = PL1_R, .accessfn = access_terr, | 215 | --- a/include/hw/misc/npcm7xx_rng.h |
115 | + .type = ARM_CP_CONST, .resetvalue = 0 }, | 216 | +++ b/include/hw/misc/npcm7xx_rng.h |
116 | + { .name = "VDISR_EL2", .state = ARM_CP_STATE_BOTH, | 217 | @@ -XXX,XX +XXX,XX @@ |
117 | + .opc0 = 3, .opc1 = 4, .crn = 12, .crm = 1, .opc2 = 1, | 218 | |
118 | + .access = PL2_RW, .fieldoffset = offsetof(CPUARMState, cp15.vdisr_el2) }, | 219 | #include "hw/sysbus.h" |
119 | + { .name = "VSESR_EL2", .state = ARM_CP_STATE_BOTH, | 220 | |
120 | + .opc0 = 3, .opc1 = 4, .crn = 5, .crm = 2, .opc2 = 3, | 221 | -typedef struct NPCM7xxRNGState { |
121 | + .access = PL2_RW, .fieldoffset = offsetof(CPUARMState, cp15.vsesr_el2) }, | 222 | +struct NPCM7xxRNGState { |
122 | +}; | 223 | SysBusDevice parent; |
123 | + | 224 | |
124 | /* Return the exception level to which exceptions should be taken | 225 | MemoryRegion iomem; |
125 | * via SVEAccessTrap. If an exception should be routed through | 226 | @@ -XXX,XX +XXX,XX @@ typedef struct NPCM7xxRNGState { |
126 | * AArch64.AdvSIMDFPAccessTrap, return 0; fp_exception_el should | 227 | uint8_t rngcs; |
127 | @@ -XXX,XX +XXX,XX @@ void register_cp_regs_for_features(ARMCPU *cpu) | 228 | uint8_t rngd; |
128 | if (cpu_isar_feature(aa64_ssbs, cpu)) { | 229 | uint8_t rngmode; |
129 | define_one_arm_cp_reg(cpu, &ssbs_reginfo); | 230 | -} NPCM7xxRNGState; |
130 | } | 231 | +}; |
131 | + if (cpu_isar_feature(any_ras, cpu)) { | 232 | |
132 | + define_arm_cp_regs(cpu, minimal_ras_reginfo); | 233 | #define TYPE_NPCM7XX_RNG "npcm7xx-rng" |
133 | + } | 234 | -#define NPCM7XX_RNG(obj) OBJECT_CHECK(NPCM7xxRNGState, (obj), TYPE_NPCM7XX_RNG) |
134 | 235 | +OBJECT_DECLARE_SIMPLE_TYPE(NPCM7xxRNGState, NPCM7XX_RNG) | |
135 | if (cpu_isar_feature(aa64_vh, cpu) || | 236 | |
136 | cpu_isar_feature(aa64_debugv8p2, cpu)) { | 237 | #endif /* NPCM7XX_RNG_H */ |
238 | diff --git a/include/hw/net/npcm7xx_emc.h b/include/hw/net/npcm7xx_emc.h | ||
239 | index XXXXXXX..XXXXXXX 100644 | ||
240 | --- a/include/hw/net/npcm7xx_emc.h | ||
241 | +++ b/include/hw/net/npcm7xx_emc.h | ||
242 | @@ -XXX,XX +XXX,XX @@ struct NPCM7xxEMCState { | ||
243 | bool rx_active; | ||
244 | }; | ||
245 | |||
246 | -typedef struct NPCM7xxEMCState NPCM7xxEMCState; | ||
247 | - | ||
248 | #define TYPE_NPCM7XX_EMC "npcm7xx-emc" | ||
249 | -#define NPCM7XX_EMC(obj) \ | ||
250 | - OBJECT_CHECK(NPCM7xxEMCState, (obj), TYPE_NPCM7XX_EMC) | ||
251 | +OBJECT_DECLARE_SIMPLE_TYPE(NPCM7xxEMCState, NPCM7XX_EMC) | ||
252 | |||
253 | #endif /* NPCM7XX_EMC_H */ | ||
254 | diff --git a/include/hw/sd/npcm7xx_sdhci.h b/include/hw/sd/npcm7xx_sdhci.h | ||
255 | index XXXXXXX..XXXXXXX 100644 | ||
256 | --- a/include/hw/sd/npcm7xx_sdhci.h | ||
257 | +++ b/include/hw/sd/npcm7xx_sdhci.h | ||
258 | @@ -XXX,XX +XXX,XX @@ typedef struct NPCM7xxRegs { | ||
259 | uint32_t boottoctrl; | ||
260 | } NPCM7xxRegisters; | ||
261 | |||
262 | -typedef struct NPCM7xxSDHCIState { | ||
263 | +struct NPCM7xxSDHCIState { | ||
264 | SysBusDevice parent; | ||
265 | |||
266 | MemoryRegion container; | ||
267 | @@ -XXX,XX +XXX,XX @@ typedef struct NPCM7xxSDHCIState { | ||
268 | NPCM7xxRegisters regs; | ||
269 | |||
270 | SDHCIState sdhci; | ||
271 | -} NPCM7xxSDHCIState; | ||
272 | +}; | ||
273 | |||
274 | #endif /* NPCM7XX_SDHCI_H */ | ||
137 | -- | 275 | -- |
138 | 2.25.1 | 276 | 2.34.1 |
277 | |||
278 | diff view generated by jsdifflib |
1 | From: Gavin Shan <gshan@redhat.com> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | When CPU-to-NUMA association isn't explicitly provided by users, | 3 | The structure is named SECUREECState. Rename the type accordingly. |
4 | the default one is given by mc->get_default_cpu_node_id(). However, | ||
5 | the CPU topology isn't fully considered in the default association | ||
6 | and this causes CPU topology broken warnings on booting Linux guest. | ||
7 | 4 | ||
8 | For example, the following warning messages are observed when the | 5 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
9 | Linux guest is booted with the following command lines. | 6 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
10 | 7 | Message-id: 20230109140306.23161-12-philmd@linaro.org | |
11 | /home/gavin/sandbox/qemu.main/build/qemu-system-aarch64 \ | ||
12 | -accel kvm -machine virt,gic-version=host \ | ||
13 | -cpu host \ | ||
14 | -smp 6,sockets=2,cores=3,threads=1 \ | ||
15 | -m 1024M,slots=16,maxmem=64G \ | ||
16 | -object memory-backend-ram,id=mem0,size=128M \ | ||
17 | -object memory-backend-ram,id=mem1,size=128M \ | ||
18 | -object memory-backend-ram,id=mem2,size=128M \ | ||
19 | -object memory-backend-ram,id=mem3,size=128M \ | ||
20 | -object memory-backend-ram,id=mem4,size=128M \ | ||
21 | -object memory-backend-ram,id=mem4,size=384M \ | ||
22 | -numa node,nodeid=0,memdev=mem0 \ | ||
23 | -numa node,nodeid=1,memdev=mem1 \ | ||
24 | -numa node,nodeid=2,memdev=mem2 \ | ||
25 | -numa node,nodeid=3,memdev=mem3 \ | ||
26 | -numa node,nodeid=4,memdev=mem4 \ | ||
27 | -numa node,nodeid=5,memdev=mem5 | ||
28 | : | ||
29 | alternatives: patching kernel code | ||
30 | BUG: arch topology borken | ||
31 | the CLS domain not a subset of the MC domain | ||
32 | <the above error log repeats> | ||
33 | BUG: arch topology borken | ||
34 | the DIE domain not a subset of the NODE domain | ||
35 | |||
36 | With current implementation of mc->get_default_cpu_node_id(), | ||
37 | CPU#0 to CPU#5 are associated with NODE#0 to NODE#5 separately. | ||
38 | That's incorrect because CPU#0/1/2 should be associated with same | ||
39 | NUMA node because they're seated in same socket. | ||
40 | |||
41 | This fixes the issue by considering the socket ID when the default | ||
42 | CPU-to-NUMA association is provided in virt_possible_cpu_arch_ids(). | ||
43 | With this applied, no more CPU topology broken warnings are seen | ||
44 | from the Linux guest. The 6 CPUs are associated with NODE#0/1, but | ||
45 | there are no CPUs associated with NODE#2/3/4/5. | ||
46 | |||
47 | Signed-off-by: Gavin Shan <gshan@redhat.com> | ||
48 | Reviewed-by: Igor Mammedov <imammedo@redhat.com> | ||
49 | Reviewed-by: Yanan Wang <wangyanan55@huawei.com> | ||
50 | Message-id: 20220503140304.855514-6-gshan@redhat.com | ||
51 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 8 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
52 | --- | 9 | --- |
53 | hw/arm/virt.c | 4 +++- | 10 | hw/misc/sbsa_ec.c | 13 +++++++------ |
54 | 1 file changed, 3 insertions(+), 1 deletion(-) | 11 | 1 file changed, 7 insertions(+), 6 deletions(-) |
55 | 12 | ||
56 | diff --git a/hw/arm/virt.c b/hw/arm/virt.c | 13 | diff --git a/hw/misc/sbsa_ec.c b/hw/misc/sbsa_ec.c |
57 | index XXXXXXX..XXXXXXX 100644 | 14 | index XXXXXXX..XXXXXXX 100644 |
58 | --- a/hw/arm/virt.c | 15 | --- a/hw/misc/sbsa_ec.c |
59 | +++ b/hw/arm/virt.c | 16 | +++ b/hw/misc/sbsa_ec.c |
60 | @@ -XXX,XX +XXX,XX @@ virt_cpu_index_to_props(MachineState *ms, unsigned cpu_index) | 17 | @@ -XXX,XX +XXX,XX @@ |
61 | 18 | #include "hw/sysbus.h" | |
62 | static int64_t virt_get_default_cpu_node_id(const MachineState *ms, int idx) | 19 | #include "sysemu/runstate.h" |
20 | |||
21 | -typedef struct { | ||
22 | +typedef struct SECUREECState { | ||
23 | SysBusDevice parent_obj; | ||
24 | MemoryRegion iomem; | ||
25 | } SECUREECState; | ||
26 | |||
27 | -#define TYPE_SBSA_EC "sbsa-ec" | ||
28 | -#define SECURE_EC(obj) OBJECT_CHECK(SECUREECState, (obj), TYPE_SBSA_EC) | ||
29 | +#define TYPE_SBSA_SECURE_EC "sbsa-ec" | ||
30 | +#define SBSA_SECURE_EC(obj) \ | ||
31 | + OBJECT_CHECK(SECUREECState, (obj), TYPE_SBSA_SECURE_EC) | ||
32 | |||
33 | enum sbsa_ec_powerstates { | ||
34 | SBSA_EC_CMD_POWEROFF = 0x01, | ||
35 | @@ -XXX,XX +XXX,XX @@ static uint64_t sbsa_ec_read(void *opaque, hwaddr offset, unsigned size) | ||
36 | } | ||
37 | |||
38 | static void sbsa_ec_write(void *opaque, hwaddr offset, | ||
39 | - uint64_t value, unsigned size) | ||
40 | + uint64_t value, unsigned size) | ||
63 | { | 41 | { |
64 | - return idx % ms->numa_state->num_nodes; | 42 | if (offset == 0) { /* PSCI machine power command register */ |
65 | + int64_t socket_id = ms->possible_cpus->cpus[idx].props.socket_id; | 43 | switch (value) { |
66 | + | 44 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps sbsa_ec_ops = { |
67 | + return socket_id % ms->numa_state->num_nodes; | 45 | |
46 | static void sbsa_ec_init(Object *obj) | ||
47 | { | ||
48 | - SECUREECState *s = SECURE_EC(obj); | ||
49 | + SECUREECState *s = SBSA_SECURE_EC(obj); | ||
50 | SysBusDevice *dev = SYS_BUS_DEVICE(obj); | ||
51 | |||
52 | memory_region_init_io(&s->iomem, obj, &sbsa_ec_ops, s, "sbsa-ec", | ||
53 | @@ -XXX,XX +XXX,XX @@ static void sbsa_ec_class_init(ObjectClass *klass, void *data) | ||
68 | } | 54 | } |
69 | 55 | ||
70 | static const CPUArchIdList *virt_possible_cpu_arch_ids(MachineState *ms) | 56 | static const TypeInfo sbsa_ec_info = { |
57 | - .name = TYPE_SBSA_EC, | ||
58 | + .name = TYPE_SBSA_SECURE_EC, | ||
59 | .parent = TYPE_SYS_BUS_DEVICE, | ||
60 | .instance_size = sizeof(SECUREECState), | ||
61 | .instance_init = sbsa_ec_init, | ||
71 | -- | 62 | -- |
72 | 2.25.1 | 63 | 2.34.1 |
64 | |||
65 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | The only portion of FEAT_Debugv8p2 that is relevant to QEMU | 3 | This model was merged few days before the QOM cleanup from |
4 | is CONTEXTIDR_EL2, which is also conditionally implemented | 4 | commit 8063396bf3 ("Use OBJECT_DECLARE_SIMPLE_TYPE when possible") |
5 | with FEAT_VHE. The rest of the debug extension concerns the | 5 | was pulled and merged. Manually adapt. |
6 | External debug interface, which is outside the scope of QEMU. | ||
7 | 6 | ||
8 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 7 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
9 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 8 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> |
10 | Message-id: 20220506180242.216785-12-richard.henderson@linaro.org | 9 | Message-id: 20230109140306.23161-13-philmd@linaro.org |
11 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 10 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
12 | --- | 11 | --- |
13 | docs/system/arm/emulation.rst | 1 + | 12 | hw/misc/sbsa_ec.c | 3 +-- |
14 | target/arm/cpu.c | 1 + | 13 | 1 file changed, 1 insertion(+), 2 deletions(-) |
15 | target/arm/cpu64.c | 1 + | ||
16 | target/arm/cpu_tcg.c | 2 ++ | ||
17 | 4 files changed, 5 insertions(+) | ||
18 | 14 | ||
19 | diff --git a/docs/system/arm/emulation.rst b/docs/system/arm/emulation.rst | 15 | diff --git a/hw/misc/sbsa_ec.c b/hw/misc/sbsa_ec.c |
20 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
21 | --- a/docs/system/arm/emulation.rst | 17 | --- a/hw/misc/sbsa_ec.c |
22 | +++ b/docs/system/arm/emulation.rst | 18 | +++ b/hw/misc/sbsa_ec.c |
23 | @@ -XXX,XX +XXX,XX @@ the following architecture extensions: | 19 | @@ -XXX,XX +XXX,XX @@ typedef struct SECUREECState { |
24 | - FEAT_BTI (Branch Target Identification) | 20 | } SECUREECState; |
25 | - FEAT_DIT (Data Independent Timing instructions) | 21 | |
26 | - FEAT_DPB (DC CVAP instruction) | 22 | #define TYPE_SBSA_SECURE_EC "sbsa-ec" |
27 | +- FEAT_Debugv8p2 (Debug changes for v8.2) | 23 | -#define SBSA_SECURE_EC(obj) \ |
28 | - FEAT_DotProd (Advanced SIMD dot product instructions) | 24 | - OBJECT_CHECK(SECUREECState, (obj), TYPE_SBSA_SECURE_EC) |
29 | - FEAT_FCMA (Floating-point complex number instructions) | 25 | +OBJECT_DECLARE_SIMPLE_TYPE(SECUREECState, SBSA_SECURE_EC) |
30 | - FEAT_FHM (Floating-point half-precision multiplication instructions) | 26 | |
31 | diff --git a/target/arm/cpu.c b/target/arm/cpu.c | 27 | enum sbsa_ec_powerstates { |
32 | index XXXXXXX..XXXXXXX 100644 | 28 | SBSA_EC_CMD_POWEROFF = 0x01, |
33 | --- a/target/arm/cpu.c | ||
34 | +++ b/target/arm/cpu.c | ||
35 | @@ -XXX,XX +XXX,XX @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp) | ||
36 | * feature registers as well. | ||
37 | */ | ||
38 | cpu->isar.id_pfr1 = FIELD_DP32(cpu->isar.id_pfr1, ID_PFR1, SECURITY, 0); | ||
39 | + cpu->isar.id_dfr0 = FIELD_DP32(cpu->isar.id_dfr0, ID_DFR0, COPSDBG, 0); | ||
40 | cpu->isar.id_aa64pfr0 = FIELD_DP64(cpu->isar.id_aa64pfr0, | ||
41 | ID_AA64PFR0, EL3, 0); | ||
42 | } | ||
43 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | ||
44 | index XXXXXXX..XXXXXXX 100644 | ||
45 | --- a/target/arm/cpu64.c | ||
46 | +++ b/target/arm/cpu64.c | ||
47 | @@ -XXX,XX +XXX,XX @@ static void aarch64_max_initfn(Object *obj) | ||
48 | cpu->isar.id_aa64zfr0 = t; | ||
49 | |||
50 | t = cpu->isar.id_aa64dfr0; | ||
51 | + t = FIELD_DP64(t, ID_AA64DFR0, DEBUGVER, 8); /* FEAT_Debugv8p2 */ | ||
52 | t = FIELD_DP64(t, ID_AA64DFR0, PMUVER, 5); /* FEAT_PMUv3p4 */ | ||
53 | cpu->isar.id_aa64dfr0 = t; | ||
54 | |||
55 | diff --git a/target/arm/cpu_tcg.c b/target/arm/cpu_tcg.c | ||
56 | index XXXXXXX..XXXXXXX 100644 | ||
57 | --- a/target/arm/cpu_tcg.c | ||
58 | +++ b/target/arm/cpu_tcg.c | ||
59 | @@ -XXX,XX +XXX,XX @@ void aa32_max_features(ARMCPU *cpu) | ||
60 | cpu->isar.id_pfr2 = t; | ||
61 | |||
62 | t = cpu->isar.id_dfr0; | ||
63 | + t = FIELD_DP32(t, ID_DFR0, COPDBG, 8); /* FEAT_Debugv8p2 */ | ||
64 | + t = FIELD_DP32(t, ID_DFR0, COPSDBG, 8); /* FEAT_Debugv8p2 */ | ||
65 | t = FIELD_DP32(t, ID_DFR0, PERFMON, 5); /* FEAT_PMUv3p4 */ | ||
66 | cpu->isar.id_dfr0 = t; | ||
67 | } | ||
68 | -- | 29 | -- |
69 | 2.25.1 | 30 | 2.34.1 |
31 | |||
32 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | Enable the a76 for virt and sbsa board use. | 3 | This remove a use of 'struct' in the DECLARE_INSTANCE_CHECKER() |
4 | macro call, to avoid after a QOM refactor: | ||
4 | 5 | ||
5 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 6 | hw/intc/xilinx_intc.c:45:1: error: declaration of anonymous struct must be a definition |
6 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 7 | DECLARE_INSTANCE_CHECKER(struct xlx_pic, XILINX_INTC, |
7 | Message-id: 20220506180242.216785-24-richard.henderson@linaro.org | 8 | ^ |
9 | |||
10 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> | ||
11 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
12 | Reviewed-by: Edgar E. Iglesias <edgar@zeroasic.com> | ||
13 | Message-id: 20230109140306.23161-14-philmd@linaro.org | ||
8 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 14 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
9 | --- | 15 | --- |
10 | docs/system/arm/virt.rst | 1 + | 16 | hw/intc/xilinx_intc.c | 28 +++++++++++++--------------- |
11 | hw/arm/sbsa-ref.c | 1 + | 17 | 1 file changed, 13 insertions(+), 15 deletions(-) |
12 | hw/arm/virt.c | 1 + | ||
13 | target/arm/cpu64.c | 66 ++++++++++++++++++++++++++++++++++++++++ | ||
14 | 4 files changed, 69 insertions(+) | ||
15 | 18 | ||
16 | diff --git a/docs/system/arm/virt.rst b/docs/system/arm/virt.rst | 19 | diff --git a/hw/intc/xilinx_intc.c b/hw/intc/xilinx_intc.c |
17 | index XXXXXXX..XXXXXXX 100644 | 20 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/docs/system/arm/virt.rst | 21 | --- a/hw/intc/xilinx_intc.c |
19 | +++ b/docs/system/arm/virt.rst | 22 | +++ b/hw/intc/xilinx_intc.c |
20 | @@ -XXX,XX +XXX,XX @@ Supported guest CPU types: | 23 | @@ -XXX,XX +XXX,XX @@ |
21 | - ``cortex-a53`` (64-bit) | 24 | #define R_MAX 8 |
22 | - ``cortex-a57`` (64-bit) | 25 | |
23 | - ``cortex-a72`` (64-bit) | 26 | #define TYPE_XILINX_INTC "xlnx.xps-intc" |
24 | +- ``cortex-a76`` (64-bit) | 27 | -DECLARE_INSTANCE_CHECKER(struct xlx_pic, XILINX_INTC, |
25 | - ``a64fx`` (64-bit) | 28 | - TYPE_XILINX_INTC) |
26 | - ``host`` (with KVM only) | 29 | +typedef struct XpsIntc XpsIntc; |
27 | - ``max`` (same as ``host`` for KVM; best possible emulation with TCG) | 30 | +DECLARE_INSTANCE_CHECKER(XpsIntc, XILINX_INTC, TYPE_XILINX_INTC) |
28 | diff --git a/hw/arm/sbsa-ref.c b/hw/arm/sbsa-ref.c | 31 | |
29 | index XXXXXXX..XXXXXXX 100644 | 32 | -struct xlx_pic |
30 | --- a/hw/arm/sbsa-ref.c | 33 | +struct XpsIntc |
31 | +++ b/hw/arm/sbsa-ref.c | 34 | { |
32 | @@ -XXX,XX +XXX,XX @@ static const int sbsa_ref_irqmap[] = { | 35 | SysBusDevice parent_obj; |
33 | static const char * const valid_cpus[] = { | 36 | |
34 | ARM_CPU_TYPE_NAME("cortex-a57"), | 37 | @@ -XXX,XX +XXX,XX @@ struct xlx_pic |
35 | ARM_CPU_TYPE_NAME("cortex-a72"), | 38 | uint32_t irq_pin_state; |
36 | + ARM_CPU_TYPE_NAME("cortex-a76"), | ||
37 | ARM_CPU_TYPE_NAME("max"), | ||
38 | }; | 39 | }; |
39 | 40 | ||
40 | diff --git a/hw/arm/virt.c b/hw/arm/virt.c | 41 | -static void update_irq(struct xlx_pic *p) |
41 | index XXXXXXX..XXXXXXX 100644 | 42 | +static void update_irq(XpsIntc *p) |
42 | --- a/hw/arm/virt.c | 43 | { |
43 | +++ b/hw/arm/virt.c | 44 | uint32_t i; |
44 | @@ -XXX,XX +XXX,XX @@ static const char *valid_cpus[] = { | 45 | |
45 | ARM_CPU_TYPE_NAME("cortex-a53"), | 46 | @@ -XXX,XX +XXX,XX @@ static void update_irq(struct xlx_pic *p) |
46 | ARM_CPU_TYPE_NAME("cortex-a57"), | 47 | qemu_set_irq(p->parent_irq, (p->regs[R_MER] & 1) && p->regs[R_IPR]); |
47 | ARM_CPU_TYPE_NAME("cortex-a72"), | ||
48 | + ARM_CPU_TYPE_NAME("cortex-a76"), | ||
49 | ARM_CPU_TYPE_NAME("a64fx"), | ||
50 | ARM_CPU_TYPE_NAME("host"), | ||
51 | ARM_CPU_TYPE_NAME("max"), | ||
52 | diff --git a/target/arm/cpu64.c b/target/arm/cpu64.c | ||
53 | index XXXXXXX..XXXXXXX 100644 | ||
54 | --- a/target/arm/cpu64.c | ||
55 | +++ b/target/arm/cpu64.c | ||
56 | @@ -XXX,XX +XXX,XX @@ static void aarch64_a72_initfn(Object *obj) | ||
57 | define_cortex_a72_a57_a53_cp_reginfo(cpu); | ||
58 | } | 48 | } |
59 | 49 | ||
60 | +static void aarch64_a76_initfn(Object *obj) | 50 | -static uint64_t |
61 | +{ | 51 | -pic_read(void *opaque, hwaddr addr, unsigned int size) |
62 | + ARMCPU *cpu = ARM_CPU(obj); | 52 | +static uint64_t pic_read(void *opaque, hwaddr addr, unsigned int size) |
63 | + | ||
64 | + cpu->dtb_compatible = "arm,cortex-a76"; | ||
65 | + set_feature(&cpu->env, ARM_FEATURE_V8); | ||
66 | + set_feature(&cpu->env, ARM_FEATURE_NEON); | ||
67 | + set_feature(&cpu->env, ARM_FEATURE_GENERIC_TIMER); | ||
68 | + set_feature(&cpu->env, ARM_FEATURE_AARCH64); | ||
69 | + set_feature(&cpu->env, ARM_FEATURE_CBAR_RO); | ||
70 | + set_feature(&cpu->env, ARM_FEATURE_EL2); | ||
71 | + set_feature(&cpu->env, ARM_FEATURE_EL3); | ||
72 | + set_feature(&cpu->env, ARM_FEATURE_PMU); | ||
73 | + | ||
74 | + /* Ordered by B2.4 AArch64 registers by functional group */ | ||
75 | + cpu->clidr = 0x82000023; | ||
76 | + cpu->ctr = 0x8444C004; | ||
77 | + cpu->dcz_blocksize = 4; | ||
78 | + cpu->isar.id_aa64dfr0 = 0x0000000010305408ull; | ||
79 | + cpu->isar.id_aa64isar0 = 0x0000100010211120ull; | ||
80 | + cpu->isar.id_aa64isar1 = 0x0000000000100001ull; | ||
81 | + cpu->isar.id_aa64mmfr0 = 0x0000000000101122ull; | ||
82 | + cpu->isar.id_aa64mmfr1 = 0x0000000010212122ull; | ||
83 | + cpu->isar.id_aa64mmfr2 = 0x0000000000001011ull; | ||
84 | + cpu->isar.id_aa64pfr0 = 0x1100000010111112ull; /* GIC filled in later */ | ||
85 | + cpu->isar.id_aa64pfr1 = 0x0000000000000010ull; | ||
86 | + cpu->id_afr0 = 0x00000000; | ||
87 | + cpu->isar.id_dfr0 = 0x04010088; | ||
88 | + cpu->isar.id_isar0 = 0x02101110; | ||
89 | + cpu->isar.id_isar1 = 0x13112111; | ||
90 | + cpu->isar.id_isar2 = 0x21232042; | ||
91 | + cpu->isar.id_isar3 = 0x01112131; | ||
92 | + cpu->isar.id_isar4 = 0x00010142; | ||
93 | + cpu->isar.id_isar5 = 0x01011121; | ||
94 | + cpu->isar.id_isar6 = 0x00000010; | ||
95 | + cpu->isar.id_mmfr0 = 0x10201105; | ||
96 | + cpu->isar.id_mmfr1 = 0x40000000; | ||
97 | + cpu->isar.id_mmfr2 = 0x01260000; | ||
98 | + cpu->isar.id_mmfr3 = 0x02122211; | ||
99 | + cpu->isar.id_mmfr4 = 0x00021110; | ||
100 | + cpu->isar.id_pfr0 = 0x10010131; | ||
101 | + cpu->isar.id_pfr1 = 0x00010000; /* GIC filled in later */ | ||
102 | + cpu->isar.id_pfr2 = 0x00000011; | ||
103 | + cpu->midr = 0x414fd0b1; /* r4p1 */ | ||
104 | + cpu->revidr = 0; | ||
105 | + | ||
106 | + /* From B2.18 CCSIDR_EL1 */ | ||
107 | + cpu->ccsidr[0] = 0x701fe01a; /* 64KB L1 dcache */ | ||
108 | + cpu->ccsidr[1] = 0x201fe01a; /* 64KB L1 icache */ | ||
109 | + cpu->ccsidr[2] = 0x707fe03a; /* 512KB L2 cache */ | ||
110 | + | ||
111 | + /* From B2.93 SCTLR_EL3 */ | ||
112 | + cpu->reset_sctlr = 0x30c50838; | ||
113 | + | ||
114 | + /* From B4.23 ICH_VTR_EL2 */ | ||
115 | + cpu->gic_num_lrs = 4; | ||
116 | + cpu->gic_vpribits = 5; | ||
117 | + cpu->gic_vprebits = 5; | ||
118 | + | ||
119 | + /* From B5.1 AdvSIMD AArch64 register summary */ | ||
120 | + cpu->isar.mvfr0 = 0x10110222; | ||
121 | + cpu->isar.mvfr1 = 0x13211111; | ||
122 | + cpu->isar.mvfr2 = 0x00000043; | ||
123 | +} | ||
124 | + | ||
125 | void arm_cpu_sve_finalize(ARMCPU *cpu, Error **errp) | ||
126 | { | 53 | { |
127 | /* | 54 | - struct xlx_pic *p = opaque; |
128 | @@ -XXX,XX +XXX,XX @@ static const ARMCPUInfo aarch64_cpus[] = { | 55 | + XpsIntc *p = opaque; |
129 | { .name = "cortex-a57", .initfn = aarch64_a57_initfn }, | 56 | uint32_t r = 0; |
130 | { .name = "cortex-a53", .initfn = aarch64_a53_initfn }, | 57 | |
131 | { .name = "cortex-a72", .initfn = aarch64_a72_initfn }, | 58 | addr >>= 2; |
132 | + { .name = "cortex-a76", .initfn = aarch64_a76_initfn }, | 59 | @@ -XXX,XX +XXX,XX @@ pic_read(void *opaque, hwaddr addr, unsigned int size) |
133 | { .name = "a64fx", .initfn = aarch64_a64fx_initfn }, | 60 | return r; |
134 | { .name = "max", .initfn = aarch64_max_initfn }, | 61 | } |
135 | #if defined(CONFIG_KVM) || defined(CONFIG_HVF) | 62 | |
63 | -static void | ||
64 | -pic_write(void *opaque, hwaddr addr, | ||
65 | - uint64_t val64, unsigned int size) | ||
66 | +static void pic_write(void *opaque, hwaddr addr, | ||
67 | + uint64_t val64, unsigned int size) | ||
68 | { | ||
69 | - struct xlx_pic *p = opaque; | ||
70 | + XpsIntc *p = opaque; | ||
71 | uint32_t value = val64; | ||
72 | |||
73 | addr >>= 2; | ||
74 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps pic_ops = { | ||
75 | |||
76 | static void irq_handler(void *opaque, int irq, int level) | ||
77 | { | ||
78 | - struct xlx_pic *p = opaque; | ||
79 | + XpsIntc *p = opaque; | ||
80 | |||
81 | /* edge triggered interrupt */ | ||
82 | if (p->c_kind_of_intr & (1 << irq) && p->regs[R_MER] & 2) { | ||
83 | @@ -XXX,XX +XXX,XX @@ static void irq_handler(void *opaque, int irq, int level) | ||
84 | |||
85 | static void xilinx_intc_init(Object *obj) | ||
86 | { | ||
87 | - struct xlx_pic *p = XILINX_INTC(obj); | ||
88 | + XpsIntc *p = XILINX_INTC(obj); | ||
89 | |||
90 | qdev_init_gpio_in(DEVICE(obj), irq_handler, 32); | ||
91 | sysbus_init_irq(SYS_BUS_DEVICE(obj), &p->parent_irq); | ||
92 | @@ -XXX,XX +XXX,XX @@ static void xilinx_intc_init(Object *obj) | ||
93 | } | ||
94 | |||
95 | static Property xilinx_intc_properties[] = { | ||
96 | - DEFINE_PROP_UINT32("kind-of-intr", struct xlx_pic, c_kind_of_intr, 0), | ||
97 | + DEFINE_PROP_UINT32("kind-of-intr", XpsIntc, c_kind_of_intr, 0), | ||
98 | DEFINE_PROP_END_OF_LIST(), | ||
99 | }; | ||
100 | |||
101 | @@ -XXX,XX +XXX,XX @@ static void xilinx_intc_class_init(ObjectClass *klass, void *data) | ||
102 | static const TypeInfo xilinx_intc_info = { | ||
103 | .name = TYPE_XILINX_INTC, | ||
104 | .parent = TYPE_SYS_BUS_DEVICE, | ||
105 | - .instance_size = sizeof(struct xlx_pic), | ||
106 | + .instance_size = sizeof(XpsIntc), | ||
107 | .instance_init = xilinx_intc_init, | ||
108 | .class_init = xilinx_intc_class_init, | ||
109 | }; | ||
136 | -- | 110 | -- |
137 | 2.25.1 | 111 | 2.34.1 |
112 | |||
113 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | 2 | ||
3 | We set this for qemu-system-aarch64, but failed to do so | 3 | This remove a use of 'struct' in the DECLARE_INSTANCE_CHECKER() |
4 | for the strictly 32-bit emulation. | 4 | macro call, to avoid after a QOM refactor: |
5 | 5 | ||
6 | Fixes: 3bec78447a9 ("target/arm: Provide ARMv8.4-PMU in '-cpu max'") | 6 | hw/timer/xilinx_timer.c:65:1: error: declaration of anonymous struct must be a definition |
7 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 7 | DECLARE_INSTANCE_CHECKER(struct timerblock, XILINX_TIMER, |
8 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | 8 | ^ |
9 | Message-id: 20220506180242.216785-8-richard.henderson@linaro.org | 9 | |
10 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> | ||
11 | Reviewed-by: Richard Henderson <richard.henderson@linaro.org> | ||
12 | Reviewed-by: Edgar E. Iglesias <edgar@zeroasic.com> | ||
13 | Message-id: 20230109140306.23161-15-philmd@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 | target/arm/cpu_tcg.c | 4 ++++ | 16 | hw/timer/xilinx_timer.c | 27 +++++++++++++-------------- |
13 | 1 file changed, 4 insertions(+) | 17 | 1 file changed, 13 insertions(+), 14 deletions(-) |
14 | 18 | ||
15 | diff --git a/target/arm/cpu_tcg.c b/target/arm/cpu_tcg.c | 19 | diff --git a/hw/timer/xilinx_timer.c b/hw/timer/xilinx_timer.c |
16 | index XXXXXXX..XXXXXXX 100644 | 20 | index XXXXXXX..XXXXXXX 100644 |
17 | --- a/target/arm/cpu_tcg.c | 21 | --- a/hw/timer/xilinx_timer.c |
18 | +++ b/target/arm/cpu_tcg.c | 22 | +++ b/hw/timer/xilinx_timer.c |
19 | @@ -XXX,XX +XXX,XX @@ static void arm_max_initfn(Object *obj) | 23 | @@ -XXX,XX +XXX,XX @@ struct xlx_timer |
20 | t = FIELD_DP32(t, ID_PFR2, SSBS, 1); | 24 | }; |
21 | cpu->isar.id_pfr2 = t; | 25 | |
22 | 26 | #define TYPE_XILINX_TIMER "xlnx.xps-timer" | |
23 | + t = cpu->isar.id_dfr0; | 27 | -DECLARE_INSTANCE_CHECKER(struct timerblock, XILINX_TIMER, |
24 | + t = FIELD_DP32(t, ID_DFR0, PERFMON, 5); /* v8.4-PMU */ | 28 | - TYPE_XILINX_TIMER) |
25 | + cpu->isar.id_dfr0 = t; | 29 | +typedef struct XpsTimerState XpsTimerState; |
26 | + | 30 | +DECLARE_INSTANCE_CHECKER(XpsTimerState, XILINX_TIMER, TYPE_XILINX_TIMER) |
27 | #ifdef CONFIG_USER_ONLY | 31 | |
28 | /* | 32 | -struct timerblock |
29 | * Break with true ARMv8 and add back old-style VFP short-vector support. | 33 | +struct XpsTimerState |
34 | { | ||
35 | SysBusDevice parent_obj; | ||
36 | |||
37 | @@ -XXX,XX +XXX,XX @@ struct timerblock | ||
38 | struct xlx_timer *timers; | ||
39 | }; | ||
40 | |||
41 | -static inline unsigned int num_timers(struct timerblock *t) | ||
42 | +static inline unsigned int num_timers(XpsTimerState *t) | ||
43 | { | ||
44 | return 2 - t->one_timer_only; | ||
45 | } | ||
46 | @@ -XXX,XX +XXX,XX @@ static inline unsigned int timer_from_addr(hwaddr addr) | ||
47 | return addr >> 2; | ||
48 | } | ||
49 | |||
50 | -static void timer_update_irq(struct timerblock *t) | ||
51 | +static void timer_update_irq(XpsTimerState *t) | ||
52 | { | ||
53 | unsigned int i, irq = 0; | ||
54 | uint32_t csr; | ||
55 | @@ -XXX,XX +XXX,XX @@ static void timer_update_irq(struct timerblock *t) | ||
56 | static uint64_t | ||
57 | timer_read(void *opaque, hwaddr addr, unsigned int size) | ||
58 | { | ||
59 | - struct timerblock *t = opaque; | ||
60 | + XpsTimerState *t = opaque; | ||
61 | struct xlx_timer *xt; | ||
62 | uint32_t r = 0; | ||
63 | unsigned int timer; | ||
64 | @@ -XXX,XX +XXX,XX @@ static void | ||
65 | timer_write(void *opaque, hwaddr addr, | ||
66 | uint64_t val64, unsigned int size) | ||
67 | { | ||
68 | - struct timerblock *t = opaque; | ||
69 | + XpsTimerState *t = opaque; | ||
70 | struct xlx_timer *xt; | ||
71 | unsigned int timer; | ||
72 | uint32_t value = val64; | ||
73 | @@ -XXX,XX +XXX,XX @@ static const MemoryRegionOps timer_ops = { | ||
74 | static void timer_hit(void *opaque) | ||
75 | { | ||
76 | struct xlx_timer *xt = opaque; | ||
77 | - struct timerblock *t = xt->parent; | ||
78 | + XpsTimerState *t = xt->parent; | ||
79 | D(fprintf(stderr, "%s %d\n", __func__, xt->nr)); | ||
80 | xt->regs[R_TCSR] |= TCSR_TINT; | ||
81 | |||
82 | @@ -XXX,XX +XXX,XX @@ static void timer_hit(void *opaque) | ||
83 | |||
84 | static void xilinx_timer_realize(DeviceState *dev, Error **errp) | ||
85 | { | ||
86 | - struct timerblock *t = XILINX_TIMER(dev); | ||
87 | + XpsTimerState *t = XILINX_TIMER(dev); | ||
88 | unsigned int i; | ||
89 | |||
90 | /* Init all the ptimers. */ | ||
91 | @@ -XXX,XX +XXX,XX @@ static void xilinx_timer_realize(DeviceState *dev, Error **errp) | ||
92 | |||
93 | static void xilinx_timer_init(Object *obj) | ||
94 | { | ||
95 | - struct timerblock *t = XILINX_TIMER(obj); | ||
96 | + XpsTimerState *t = XILINX_TIMER(obj); | ||
97 | |||
98 | /* All timers share a single irq line. */ | ||
99 | sysbus_init_irq(SYS_BUS_DEVICE(obj), &t->irq); | ||
100 | } | ||
101 | |||
102 | static Property xilinx_timer_properties[] = { | ||
103 | - DEFINE_PROP_UINT32("clock-frequency", struct timerblock, freq_hz, | ||
104 | - 62 * 1000000), | ||
105 | - DEFINE_PROP_UINT8("one-timer-only", struct timerblock, one_timer_only, 0), | ||
106 | + DEFINE_PROP_UINT32("clock-frequency", XpsTimerState, freq_hz, 62 * 1000000), | ||
107 | + DEFINE_PROP_UINT8("one-timer-only", XpsTimerState, one_timer_only, 0), | ||
108 | DEFINE_PROP_END_OF_LIST(), | ||
109 | }; | ||
110 | |||
111 | @@ -XXX,XX +XXX,XX @@ static void xilinx_timer_class_init(ObjectClass *klass, void *data) | ||
112 | static const TypeInfo xilinx_timer_info = { | ||
113 | .name = TYPE_XILINX_TIMER, | ||
114 | .parent = TYPE_SYS_BUS_DEVICE, | ||
115 | - .instance_size = sizeof(struct timerblock), | ||
116 | + .instance_size = sizeof(XpsTimerState), | ||
117 | .instance_init = xilinx_timer_init, | ||
118 | .class_init = xilinx_timer_class_init, | ||
119 | }; | ||
30 | -- | 120 | -- |
31 | 2.25.1 | 121 | 2.34.1 |
122 | |||
123 | diff view generated by jsdifflib |
1 | From: Richard Henderson <richard.henderson@linaro.org> | 1 | From: Evgeny Iakovlev <eiakovlev@linux.microsoft.com> |
---|---|---|---|
2 | 2 | ||
3 | Enable writes to the TERR and TEA bits when RAS is enabled. | 3 | ARM trusted firmware, when built with FEAT_HCX support, sets SCR_EL3.HXEn bit |
4 | These bits are otherwise RES0. | 4 | to allow EL2 to modify HCRX_EL2 register without trapping it in EL3. Qemu |
5 | uses a valid mask to clear unsupported SCR_EL3 bits when emulating SCR_EL3 | ||
6 | write, and that mask doesn't include SCR_EL3.HXEn bit even if FEAT_HCX is | ||
7 | enabled and exposed to the guest. As a result EL3 writes of that bit are | ||
8 | ignored. | ||
5 | 9 | ||
10 | Cc: qemu-stable@nongnu.org | ||
11 | Signed-off-by: Evgeny Iakovlev <eiakovlev@linux.microsoft.com> | ||
12 | Message-id: 20230105221251.17896-4-eiakovlev@linux.microsoft.com | ||
6 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 13 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> |
7 | Signed-off-by: Richard Henderson <richard.henderson@linaro.org> | ||
8 | Message-id: 20220506180242.216785-15-richard.henderson@linaro.org | ||
9 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> | 14 | Signed-off-by: Peter Maydell <peter.maydell@linaro.org> |
10 | --- | 15 | --- |
11 | target/arm/helper.c | 9 +++++++++ | 16 | target/arm/helper.c | 3 +++ |
12 | 1 file changed, 9 insertions(+) | 17 | 1 file changed, 3 insertions(+) |
13 | 18 | ||
14 | diff --git a/target/arm/helper.c b/target/arm/helper.c | 19 | diff --git a/target/arm/helper.c b/target/arm/helper.c |
15 | index XXXXXXX..XXXXXXX 100644 | 20 | index XXXXXXX..XXXXXXX 100644 |
16 | --- a/target/arm/helper.c | 21 | --- a/target/arm/helper.c |
17 | +++ b/target/arm/helper.c | 22 | +++ b/target/arm/helper.c |
18 | @@ -XXX,XX +XXX,XX @@ static void scr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value) | 23 | @@ -XXX,XX +XXX,XX @@ static void scr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value) |
24 | if (cpu_isar_feature(aa64_sme, cpu)) { | ||
25 | valid_mask |= SCR_ENTP2; | ||
19 | } | 26 | } |
20 | valid_mask &= ~SCR_NET; | 27 | + if (cpu_isar_feature(aa64_hcx, cpu)) { |
21 | 28 | + valid_mask |= SCR_HXEN; | |
22 | + if (cpu_isar_feature(aa64_ras, cpu)) { | ||
23 | + valid_mask |= SCR_TERR; | ||
24 | + } | 29 | + } |
25 | if (cpu_isar_feature(aa64_lor, cpu)) { | ||
26 | valid_mask |= SCR_TLOR; | ||
27 | } | ||
28 | @@ -XXX,XX +XXX,XX @@ static void scr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value) | ||
29 | } | ||
30 | } else { | 30 | } else { |
31 | valid_mask &= ~(SCR_RW | SCR_ST); | 31 | valid_mask &= ~(SCR_RW | SCR_ST); |
32 | + if (cpu_isar_feature(aa32_ras, cpu)) { | 32 | if (cpu_isar_feature(aa32_ras, cpu)) { |
33 | + valid_mask |= SCR_TERR; | ||
34 | + } | ||
35 | } | ||
36 | |||
37 | if (!arm_feature(env, ARM_FEATURE_EL2)) { | ||
38 | @@ -XXX,XX +XXX,XX @@ static void do_hcr_write(CPUARMState *env, uint64_t value, uint64_t valid_mask) | ||
39 | if (cpu_isar_feature(aa64_vh, cpu)) { | ||
40 | valid_mask |= HCR_E2H; | ||
41 | } | ||
42 | + if (cpu_isar_feature(aa64_ras, cpu)) { | ||
43 | + valid_mask |= HCR_TERR | HCR_TEA; | ||
44 | + } | ||
45 | if (cpu_isar_feature(aa64_lor, cpu)) { | ||
46 | valid_mask |= HCR_TLOR; | ||
47 | } | ||
48 | -- | 33 | -- |
49 | 2.25.1 | 34 | 2.34.1 | diff view generated by jsdifflib |