Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 1 | /* |
Cédric Le Goater | ff90606 | 2016-09-22 18:13:05 +0100 | [diff] [blame] | 2 | * ASPEED SoC family |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 3 | * |
| 4 | * Andrew Jeffery <andrew@aj.id.au> |
| 5 | * Jeremy Kerr <jk@ozlabs.org> |
| 6 | * |
| 7 | * Copyright 2016 IBM Corp. |
| 8 | * |
| 9 | * This code is licensed under the GPL version 2 or later. See |
| 10 | * the COPYING file in the top-level directory. |
| 11 | */ |
| 12 | |
| 13 | #include "qemu/osdep.h" |
Cédric Le Goater | 346160c | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 14 | #include "qemu/units.h" |
Markus Armbruster | da34e65 | 2016-03-14 09:01:28 +0100 | [diff] [blame] | 15 | #include "qapi/error.h" |
Philippe Mathieu-Daudé | c7c3c9f | 2018-02-15 18:29:36 +0000 | [diff] [blame] | 16 | #include "hw/misc/unimp.h" |
Cédric Le Goater | 0044240 | 2016-09-22 18:13:05 +0100 | [diff] [blame] | 17 | #include "hw/arm/aspeed_soc.h" |
Bernhard Beschow | 7e6b549 | 2024-09-05 09:38:32 +0200 | [diff] [blame] | 18 | #include "hw/char/serial-mm.h" |
Markus Armbruster | 0b8fa32 | 2019-05-23 16:35:07 +0200 | [diff] [blame] | 19 | #include "qemu/module.h" |
Cédric Le Goater | ece09be | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 20 | #include "qemu/error-report.h" |
Cédric Le Goater | 1602001 | 2016-06-06 16:59:29 +0100 | [diff] [blame] | 21 | #include "hw/i2c/aspeed_i2c.h" |
Cédric Le Goater | ea337c6 | 2017-04-14 10:35:02 +0200 | [diff] [blame] | 22 | #include "net/net.h" |
Markus Armbruster | 46517dd | 2019-08-12 07:23:57 +0200 | [diff] [blame] | 23 | #include "sysemu/sysemu.h" |
Philippe Mathieu-Daudé | d780d05 | 2024-01-18 21:06:38 +0100 | [diff] [blame] | 24 | #include "target/arm/cpu-qom.h" |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 25 | |
Cédric Le Goater | ff90606 | 2016-09-22 18:13:05 +0100 | [diff] [blame] | 26 | #define ASPEED_SOC_IOMEM_SIZE 0x00200000 |
Cédric Le Goater | d783d1f | 2019-07-01 17:26:15 +0100 | [diff] [blame] | 27 | |
| 28 | static const hwaddr aspeed_soc_ast2400_memmap[] = { |
Jamin Lin | db052d0 | 2024-02-15 15:53:31 +0800 | [diff] [blame] | 29 | [ASPEED_DEV_SPI_BOOT] = 0x00000000, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 30 | [ASPEED_DEV_IOMEM] = 0x1E600000, |
| 31 | [ASPEED_DEV_FMC] = 0x1E620000, |
| 32 | [ASPEED_DEV_SPI1] = 0x1E630000, |
| 33 | [ASPEED_DEV_EHCI1] = 0x1E6A1000, |
| 34 | [ASPEED_DEV_VIC] = 0x1E6C0000, |
| 35 | [ASPEED_DEV_SDMC] = 0x1E6E0000, |
| 36 | [ASPEED_DEV_SCU] = 0x1E6E2000, |
Joel Stanley | a3888d7 | 2021-05-01 10:03:51 +0200 | [diff] [blame] | 37 | [ASPEED_DEV_HACE] = 0x1E6E3000, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 38 | [ASPEED_DEV_XDMA] = 0x1E6E7000, |
| 39 | [ASPEED_DEV_VIDEO] = 0x1E700000, |
| 40 | [ASPEED_DEV_ADC] = 0x1E6E9000, |
| 41 | [ASPEED_DEV_SRAM] = 0x1E720000, |
| 42 | [ASPEED_DEV_SDHCI] = 0x1E740000, |
| 43 | [ASPEED_DEV_GPIO] = 0x1E780000, |
| 44 | [ASPEED_DEV_RTC] = 0x1E781000, |
| 45 | [ASPEED_DEV_TIMER1] = 0x1E782000, |
| 46 | [ASPEED_DEV_WDT] = 0x1E785000, |
| 47 | [ASPEED_DEV_PWM] = 0x1E786000, |
| 48 | [ASPEED_DEV_LPC] = 0x1E789000, |
| 49 | [ASPEED_DEV_IBT] = 0x1E789140, |
| 50 | [ASPEED_DEV_I2C] = 0x1E78A000, |
Peter Delevoryas | 55c5702 | 2022-06-30 09:21:14 +0200 | [diff] [blame] | 51 | [ASPEED_DEV_PECI] = 0x1E78B000, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 52 | [ASPEED_DEV_ETH1] = 0x1E660000, |
| 53 | [ASPEED_DEV_ETH2] = 0x1E680000, |
| 54 | [ASPEED_DEV_UART1] = 0x1E783000, |
Peter Delevoryas | ab5e860 | 2022-05-25 10:31:33 +0200 | [diff] [blame] | 55 | [ASPEED_DEV_UART2] = 0x1E78D000, |
| 56 | [ASPEED_DEV_UART3] = 0x1E78E000, |
| 57 | [ASPEED_DEV_UART4] = 0x1E78F000, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 58 | [ASPEED_DEV_UART5] = 0x1E784000, |
| 59 | [ASPEED_DEV_VUART] = 0x1E787000, |
| 60 | [ASPEED_DEV_SDRAM] = 0x40000000, |
Cédric Le Goater | d783d1f | 2019-07-01 17:26:15 +0100 | [diff] [blame] | 61 | }; |
| 62 | |
| 63 | static const hwaddr aspeed_soc_ast2500_memmap[] = { |
Jamin Lin | db052d0 | 2024-02-15 15:53:31 +0800 | [diff] [blame] | 64 | [ASPEED_DEV_SPI_BOOT] = 0x00000000, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 65 | [ASPEED_DEV_IOMEM] = 0x1E600000, |
| 66 | [ASPEED_DEV_FMC] = 0x1E620000, |
| 67 | [ASPEED_DEV_SPI1] = 0x1E630000, |
| 68 | [ASPEED_DEV_SPI2] = 0x1E631000, |
| 69 | [ASPEED_DEV_EHCI1] = 0x1E6A1000, |
| 70 | [ASPEED_DEV_EHCI2] = 0x1E6A3000, |
| 71 | [ASPEED_DEV_VIC] = 0x1E6C0000, |
| 72 | [ASPEED_DEV_SDMC] = 0x1E6E0000, |
| 73 | [ASPEED_DEV_SCU] = 0x1E6E2000, |
Joel Stanley | a3888d7 | 2021-05-01 10:03:51 +0200 | [diff] [blame] | 74 | [ASPEED_DEV_HACE] = 0x1E6E3000, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 75 | [ASPEED_DEV_XDMA] = 0x1E6E7000, |
| 76 | [ASPEED_DEV_ADC] = 0x1E6E9000, |
| 77 | [ASPEED_DEV_VIDEO] = 0x1E700000, |
| 78 | [ASPEED_DEV_SRAM] = 0x1E720000, |
| 79 | [ASPEED_DEV_SDHCI] = 0x1E740000, |
| 80 | [ASPEED_DEV_GPIO] = 0x1E780000, |
| 81 | [ASPEED_DEV_RTC] = 0x1E781000, |
| 82 | [ASPEED_DEV_TIMER1] = 0x1E782000, |
| 83 | [ASPEED_DEV_WDT] = 0x1E785000, |
| 84 | [ASPEED_DEV_PWM] = 0x1E786000, |
| 85 | [ASPEED_DEV_LPC] = 0x1E789000, |
| 86 | [ASPEED_DEV_IBT] = 0x1E789140, |
| 87 | [ASPEED_DEV_I2C] = 0x1E78A000, |
Peter Delevoryas | 55c5702 | 2022-06-30 09:21:14 +0200 | [diff] [blame] | 88 | [ASPEED_DEV_PECI] = 0x1E78B000, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 89 | [ASPEED_DEV_ETH1] = 0x1E660000, |
| 90 | [ASPEED_DEV_ETH2] = 0x1E680000, |
| 91 | [ASPEED_DEV_UART1] = 0x1E783000, |
Peter Delevoryas | ab5e860 | 2022-05-25 10:31:33 +0200 | [diff] [blame] | 92 | [ASPEED_DEV_UART2] = 0x1E78D000, |
| 93 | [ASPEED_DEV_UART3] = 0x1E78E000, |
| 94 | [ASPEED_DEV_UART4] = 0x1E78F000, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 95 | [ASPEED_DEV_UART5] = 0x1E784000, |
| 96 | [ASPEED_DEV_VUART] = 0x1E787000, |
| 97 | [ASPEED_DEV_SDRAM] = 0x80000000, |
Cédric Le Goater | d783d1f | 2019-07-01 17:26:15 +0100 | [diff] [blame] | 98 | }; |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 99 | |
Cédric Le Goater | b456b11 | 2019-07-01 17:26:15 +0100 | [diff] [blame] | 100 | static const int aspeed_soc_ast2400_irqmap[] = { |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 101 | [ASPEED_DEV_UART1] = 9, |
| 102 | [ASPEED_DEV_UART2] = 32, |
| 103 | [ASPEED_DEV_UART3] = 33, |
| 104 | [ASPEED_DEV_UART4] = 34, |
| 105 | [ASPEED_DEV_UART5] = 10, |
| 106 | [ASPEED_DEV_VUART] = 8, |
| 107 | [ASPEED_DEV_FMC] = 19, |
| 108 | [ASPEED_DEV_EHCI1] = 5, |
| 109 | [ASPEED_DEV_EHCI2] = 13, |
| 110 | [ASPEED_DEV_SDMC] = 0, |
| 111 | [ASPEED_DEV_SCU] = 21, |
| 112 | [ASPEED_DEV_ADC] = 31, |
| 113 | [ASPEED_DEV_GPIO] = 20, |
| 114 | [ASPEED_DEV_RTC] = 22, |
| 115 | [ASPEED_DEV_TIMER1] = 16, |
| 116 | [ASPEED_DEV_TIMER2] = 17, |
| 117 | [ASPEED_DEV_TIMER3] = 18, |
| 118 | [ASPEED_DEV_TIMER4] = 35, |
| 119 | [ASPEED_DEV_TIMER5] = 36, |
| 120 | [ASPEED_DEV_TIMER6] = 37, |
| 121 | [ASPEED_DEV_TIMER7] = 38, |
| 122 | [ASPEED_DEV_TIMER8] = 39, |
| 123 | [ASPEED_DEV_WDT] = 27, |
| 124 | [ASPEED_DEV_PWM] = 28, |
| 125 | [ASPEED_DEV_LPC] = 8, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 126 | [ASPEED_DEV_I2C] = 12, |
Peter Delevoryas | 55c5702 | 2022-06-30 09:21:14 +0200 | [diff] [blame] | 127 | [ASPEED_DEV_PECI] = 15, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 128 | [ASPEED_DEV_ETH1] = 2, |
| 129 | [ASPEED_DEV_ETH2] = 3, |
| 130 | [ASPEED_DEV_XDMA] = 6, |
| 131 | [ASPEED_DEV_SDHCI] = 26, |
Joel Stanley | a3888d7 | 2021-05-01 10:03:51 +0200 | [diff] [blame] | 132 | [ASPEED_DEV_HACE] = 4, |
Cédric Le Goater | b456b11 | 2019-07-01 17:26:15 +0100 | [diff] [blame] | 133 | }; |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 134 | |
Cédric Le Goater | b456b11 | 2019-07-01 17:26:15 +0100 | [diff] [blame] | 135 | #define aspeed_soc_ast2500_irqmap aspeed_soc_ast2400_irqmap |
| 136 | |
Cédric Le Goater | 699db71 | 2022-05-25 10:31:33 +0200 | [diff] [blame] | 137 | static qemu_irq aspeed_soc_ast2400_get_irq(AspeedSoCState *s, int dev) |
Cédric Le Goater | b456b11 | 2019-07-01 17:26:15 +0100 | [diff] [blame] | 138 | { |
Philippe Mathieu-Daudé | dd41ce7 | 2023-10-24 18:24:22 +0200 | [diff] [blame] | 139 | Aspeed2400SoCState *a = ASPEED2400_SOC(s); |
Cédric Le Goater | b456b11 | 2019-07-01 17:26:15 +0100 | [diff] [blame] | 140 | AspeedSoCClass *sc = ASPEED_SOC_GET_CLASS(s); |
| 141 | |
Philippe Mathieu-Daudé | dd41ce7 | 2023-10-24 18:24:22 +0200 | [diff] [blame] | 142 | return qdev_get_gpio_in(DEVICE(&a->vic), sc->irqmap[dev]); |
Cédric Le Goater | b456b11 | 2019-07-01 17:26:15 +0100 | [diff] [blame] | 143 | } |
| 144 | |
Philippe Mathieu-Daudé | a150836 | 2023-10-24 18:24:13 +0200 | [diff] [blame] | 145 | static void aspeed_ast2400_soc_init(Object *obj) |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 146 | { |
Philippe Mathieu-Daudé | dd41ce7 | 2023-10-24 18:24:22 +0200 | [diff] [blame] | 147 | Aspeed2400SoCState *a = ASPEED2400_SOC(obj); |
Cédric Le Goater | ff90606 | 2016-09-22 18:13:05 +0100 | [diff] [blame] | 148 | AspeedSoCState *s = ASPEED_SOC(obj); |
Cédric Le Goater | b033271 | 2016-09-22 18:13:05 +0100 | [diff] [blame] | 149 | AspeedSoCClass *sc = ASPEED_SOC_GET_CLASS(s); |
Cédric Le Goater | dbcabee | 2016-10-17 19:22:16 +0100 | [diff] [blame] | 150 | int i; |
Cédric Le Goater | 811a5b1 | 2019-09-04 09:05:00 +0200 | [diff] [blame] | 151 | char socname[8]; |
| 152 | char typename[64]; |
| 153 | |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 154 | if (sscanf(sc->name, "%7s", socname) != 1) { |
Cédric Le Goater | 811a5b1 | 2019-09-04 09:05:00 +0200 | [diff] [blame] | 155 | g_assert_not_reached(); |
| 156 | } |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 157 | |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 158 | for (i = 0; i < sc->num_cpus; i++) { |
Philippe Mathieu-Daudé | d815649 | 2024-01-25 06:55:43 +0100 | [diff] [blame] | 159 | object_initialize_child(obj, "cpu[*]", &a->cpu[i], |
| 160 | aspeed_soc_cpu_type(sc)); |
Cédric Le Goater | ece09be | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 161 | } |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 162 | |
Cédric Le Goater | 9a937f6 | 2019-09-04 09:05:05 +0200 | [diff] [blame] | 163 | snprintf(typename, sizeof(typename), "aspeed.scu-%s", socname); |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 164 | object_initialize_child(obj, "scu", &s->scu, typename); |
Andrew Jeffery | 334973b | 2016-06-27 15:37:33 +0100 | [diff] [blame] | 165 | qdev_prop_set_uint32(DEVICE(&s->scu), "silicon-rev", |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 166 | sc->silicon_rev); |
Andrew Jeffery | 334973b | 2016-06-27 15:37:33 +0100 | [diff] [blame] | 167 | object_property_add_alias(obj, "hw-strap1", OBJECT(&s->scu), |
Markus Armbruster | d262312 | 2020-05-05 17:29:22 +0200 | [diff] [blame] | 168 | "hw-strap1"); |
Andrew Jeffery | 334973b | 2016-06-27 15:37:33 +0100 | [diff] [blame] | 169 | object_property_add_alias(obj, "hw-strap2", OBJECT(&s->scu), |
Markus Armbruster | d262312 | 2020-05-05 17:29:22 +0200 | [diff] [blame] | 170 | "hw-strap2"); |
Joel Stanley | b6e70d1 | 2017-11-14 22:50:18 +1030 | [diff] [blame] | 171 | object_property_add_alias(obj, "hw-prot-key", OBJECT(&s->scu), |
Markus Armbruster | d262312 | 2020-05-05 17:29:22 +0200 | [diff] [blame] | 172 | "hw-prot-key"); |
Cédric Le Goater | 7c1c69b | 2016-07-04 13:06:37 +0100 | [diff] [blame] | 173 | |
Philippe Mathieu-Daudé | dd41ce7 | 2023-10-24 18:24:22 +0200 | [diff] [blame] | 174 | object_initialize_child(obj, "vic", &a->vic, TYPE_ASPEED_VIC); |
Cédric Le Goater | e2a11ca | 2018-06-26 17:50:42 +0100 | [diff] [blame] | 175 | |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 176 | object_initialize_child(obj, "rtc", &s->rtc, TYPE_ASPEED_RTC); |
Joel Stanley | 75fb457 | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 177 | |
Cédric Le Goater | 72d96f8 | 2019-09-25 16:32:29 +0200 | [diff] [blame] | 178 | snprintf(typename, sizeof(typename), "aspeed.timer-%s", socname); |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 179 | object_initialize_child(obj, "timerctrl", &s->timerctrl, typename); |
Cédric Le Goater | e2a11ca | 2018-06-26 17:50:42 +0100 | [diff] [blame] | 180 | |
Andrew Jeffery | 199fd62 | 2021-10-12 08:20:08 +0200 | [diff] [blame] | 181 | snprintf(typename, sizeof(typename), "aspeed.adc-%s", socname); |
| 182 | object_initialize_child(obj, "adc", &s->adc, typename); |
| 183 | |
Cédric Le Goater | f7da1aa | 2019-09-25 16:32:40 +0200 | [diff] [blame] | 184 | snprintf(typename, sizeof(typename), "aspeed.i2c-%s", socname); |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 185 | object_initialize_child(obj, "i2c", &s->i2c, typename); |
Cédric Le Goater | e2a11ca | 2018-06-26 17:50:42 +0100 | [diff] [blame] | 186 | |
Peter Delevoryas | 55c5702 | 2022-06-30 09:21:14 +0200 | [diff] [blame] | 187 | object_initialize_child(obj, "peci", &s->peci, TYPE_ASPEED_PECI); |
| 188 | |
Cédric Le Goater | 811a5b1 | 2019-09-04 09:05:00 +0200 | [diff] [blame] | 189 | snprintf(typename, sizeof(typename), "aspeed.fmc-%s", socname); |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 190 | object_initialize_child(obj, "fmc", &s->fmc, typename); |
Cédric Le Goater | 7c1c69b | 2016-07-04 13:06:37 +0100 | [diff] [blame] | 191 | |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 192 | for (i = 0; i < sc->spis_num; i++) { |
Cédric Le Goater | 811a5b1 | 2019-09-04 09:05:00 +0200 | [diff] [blame] | 193 | snprintf(typename, sizeof(typename), "aspeed.spi%d-%s", i + 1, socname); |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 194 | object_initialize_child(obj, "spi[*]", &s->spi[i], typename); |
Cédric Le Goater | dbcabee | 2016-10-17 19:22:16 +0100 | [diff] [blame] | 195 | } |
Cédric Le Goater | c2da8a8 | 2016-09-06 19:52:17 +0100 | [diff] [blame] | 196 | |
Guenter Roeck | bfdd34f | 2020-02-06 10:34:37 -0800 | [diff] [blame] | 197 | for (i = 0; i < sc->ehcis_num; i++) { |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 198 | object_initialize_child(obj, "ehci[*]", &s->ehci[i], |
| 199 | TYPE_PLATFORM_EHCI); |
Guenter Roeck | bfdd34f | 2020-02-06 10:34:37 -0800 | [diff] [blame] | 200 | } |
| 201 | |
Cédric Le Goater | 8e00d1a | 2019-09-25 16:32:33 +0200 | [diff] [blame] | 202 | snprintf(typename, sizeof(typename), "aspeed.sdmc-%s", socname); |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 203 | object_initialize_child(obj, "sdmc", &s->sdmc, typename); |
Cédric Le Goater | c6c7cfb | 2016-09-22 18:13:06 +0100 | [diff] [blame] | 204 | object_property_add_alias(obj, "ram-size", OBJECT(&s->sdmc), |
Markus Armbruster | d262312 | 2020-05-05 17:29:22 +0200 | [diff] [blame] | 205 | "ram-size"); |
Cédric Le Goater | 013befe | 2017-02-07 18:29:59 +0000 | [diff] [blame] | 206 | |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 207 | for (i = 0; i < sc->wdts_num; i++) { |
Cédric Le Goater | 6112bd6 | 2019-09-25 16:32:35 +0200 | [diff] [blame] | 208 | snprintf(typename, sizeof(typename), "aspeed.wdt-%s", socname); |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 209 | object_initialize_child(obj, "wdt[*]", &s->wdt[i], typename); |
Joel Stanley | f986ee1 | 2017-07-11 11:21:26 +0100 | [diff] [blame] | 210 | } |
Cédric Le Goater | ea337c6 | 2017-04-14 10:35:02 +0200 | [diff] [blame] | 211 | |
Joel Stanley | d300db0 | 2019-09-25 16:32:46 +0200 | [diff] [blame] | 212 | for (i = 0; i < sc->macs_num; i++) { |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 213 | object_initialize_child(obj, "ftgmac100[*]", &s->ftgmac100[i], |
| 214 | TYPE_FTGMAC100); |
Cédric Le Goater | 6734099 | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 215 | } |
Eddie James | 118c82e | 2019-07-01 17:26:18 +0100 | [diff] [blame] | 216 | |
Peter Delevoryas | d2b3eae | 2022-07-14 16:24:38 +0200 | [diff] [blame] | 217 | for (i = 0; i < sc->uarts_num; i++) { |
| 218 | object_initialize_child(obj, "uart[*]", &s->uart[i], TYPE_SERIAL_MM); |
| 219 | } |
| 220 | |
Cédric Le Goater | 8efbee2 | 2021-05-01 10:03:52 +0200 | [diff] [blame] | 221 | snprintf(typename, sizeof(typename), TYPE_ASPEED_XDMA "-%s", socname); |
| 222 | object_initialize_child(obj, "xdma", &s->xdma, typename); |
Rashmica Gupta | fdcc7c0 | 2019-09-04 09:04:58 +0200 | [diff] [blame] | 223 | |
Cédric Le Goater | 811a5b1 | 2019-09-04 09:05:00 +0200 | [diff] [blame] | 224 | snprintf(typename, sizeof(typename), "aspeed.gpio-%s", socname); |
Markus Armbruster | db873cc | 2020-06-10 07:32:37 +0200 | [diff] [blame] | 225 | object_initialize_child(obj, "gpio", &s->gpio, typename); |
Eddie James | 2bea128 | 2019-09-25 16:32:27 +0200 | [diff] [blame] | 226 | |
Jamin Lin | 6a0238a | 2024-12-04 16:44:50 +0800 | [diff] [blame] | 227 | snprintf(typename, sizeof(typename), "aspeed.sdhci-%s", socname); |
| 228 | object_initialize_child(obj, "sdc", &s->sdhci, typename); |
Eddie James | 2bea128 | 2019-09-25 16:32:27 +0200 | [diff] [blame] | 229 | |
Markus Armbruster | 5325cc3 | 2020-07-07 18:05:54 +0200 | [diff] [blame] | 230 | object_property_set_int(OBJECT(&s->sdhci), "num-slots", 2, &error_abort); |
Andrew Jeffery | 0e2c24c | 2020-01-30 16:02:02 +0000 | [diff] [blame] | 231 | |
Eddie James | 2bea128 | 2019-09-25 16:32:27 +0200 | [diff] [blame] | 232 | /* Init sd card slot class here so that they're under the correct parent */ |
| 233 | for (i = 0; i < ASPEED_SDHCI_NUM_SLOTS; ++i) { |
Markus Armbruster | 7089e0c | 2020-06-10 07:32:39 +0200 | [diff] [blame] | 234 | object_initialize_child(obj, "sdhci[*]", &s->sdhci.slots[i], |
| 235 | TYPE_SYSBUS_SDHCI); |
Eddie James | 2bea128 | 2019-09-25 16:32:27 +0200 | [diff] [blame] | 236 | } |
Cédric Le Goater | 2ecf172 | 2021-03-09 12:01:28 +0100 | [diff] [blame] | 237 | |
| 238 | object_initialize_child(obj, "lpc", &s->lpc, TYPE_ASPEED_LPC); |
Joel Stanley | a3888d7 | 2021-05-01 10:03:51 +0200 | [diff] [blame] | 239 | |
| 240 | snprintf(typename, sizeof(typename), "aspeed.hace-%s", socname); |
| 241 | object_initialize_child(obj, "hace", &s->hace, typename); |
Peter Delevoryas | 80beb08 | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 242 | |
| 243 | object_initialize_child(obj, "iomem", &s->iomem, TYPE_UNIMPLEMENTED_DEVICE); |
| 244 | object_initialize_child(obj, "video", &s->video, TYPE_UNIMPLEMENTED_DEVICE); |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 245 | } |
| 246 | |
Philippe Mathieu-Daudé | aa6c669 | 2023-10-24 18:24:14 +0200 | [diff] [blame] | 247 | static void aspeed_ast2400_soc_realize(DeviceState *dev, Error **errp) |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 248 | { |
| 249 | int i; |
Philippe Mathieu-Daudé | dd41ce7 | 2023-10-24 18:24:22 +0200 | [diff] [blame] | 250 | Aspeed2400SoCState *a = ASPEED2400_SOC(dev); |
Cédric Le Goater | ff90606 | 2016-09-22 18:13:05 +0100 | [diff] [blame] | 251 | AspeedSoCState *s = ASPEED_SOC(dev); |
Cédric Le Goater | dbcabee | 2016-10-17 19:22:16 +0100 | [diff] [blame] | 252 | AspeedSoCClass *sc = ASPEED_SOC_GET_CLASS(s); |
Peter Delevoryas | 72a7c47 | 2022-07-14 16:24:38 +0200 | [diff] [blame] | 253 | g_autofree char *sram_name = NULL; |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 254 | |
Cédric Le Goater | 5aa281d | 2023-03-02 13:57:50 +0100 | [diff] [blame] | 255 | /* Default boot region (SPI memory or ROMs) */ |
| 256 | memory_region_init(&s->spi_boot_container, OBJECT(s), |
| 257 | "aspeed.spi_boot_container", 0x10000000); |
| 258 | memory_region_add_subregion(s->memory, sc->memmap[ASPEED_DEV_SPI_BOOT], |
| 259 | &s->spi_boot_container); |
| 260 | |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 261 | /* IO space */ |
Peter Delevoryas | 80beb08 | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 262 | aspeed_mmio_map_unimplemented(s, SYS_BUS_DEVICE(&s->iomem), "aspeed.io", |
| 263 | sc->memmap[ASPEED_DEV_IOMEM], |
| 264 | ASPEED_SOC_IOMEM_SIZE); |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 265 | |
Joel Stanley | 514bcf6 | 2019-09-25 16:32:48 +0200 | [diff] [blame] | 266 | /* Video engine stub */ |
Peter Delevoryas | 80beb08 | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 267 | aspeed_mmio_map_unimplemented(s, SYS_BUS_DEVICE(&s->video), "aspeed.video", |
| 268 | sc->memmap[ASPEED_DEV_VIDEO], 0x1000); |
Joel Stanley | 514bcf6 | 2019-09-25 16:32:48 +0200 | [diff] [blame] | 269 | |
Cédric Le Goater | 2d105bd | 2016-12-27 14:59:26 +0000 | [diff] [blame] | 270 | /* CPU */ |
Cédric Le Goater | b7f1a0c | 2020-06-09 14:23:19 +0200 | [diff] [blame] | 271 | for (i = 0; i < sc->num_cpus; i++) { |
Philippe Mathieu-Daudé | dd41ce7 | 2023-10-24 18:24:22 +0200 | [diff] [blame] | 272 | object_property_set_link(OBJECT(&a->cpu[i]), "memory", |
Peter Delevoryas | 4dd9d55 | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 273 | OBJECT(s->memory), &error_abort); |
Philippe Mathieu-Daudé | dd41ce7 | 2023-10-24 18:24:22 +0200 | [diff] [blame] | 274 | if (!qdev_realize(DEVICE(&a->cpu[i]), NULL, errp)) { |
Cédric Le Goater | ece09be | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 275 | return; |
| 276 | } |
Cédric Le Goater | 2d105bd | 2016-12-27 14:59:26 +0000 | [diff] [blame] | 277 | } |
| 278 | |
Cédric Le Goater | 74af4ee | 2016-12-27 14:59:27 +0000 | [diff] [blame] | 279 | /* SRAM */ |
Philippe Mathieu-Daudé | dd41ce7 | 2023-10-24 18:24:22 +0200 | [diff] [blame] | 280 | sram_name = g_strdup_printf("aspeed.sram.%d", CPU(&a->cpu[0])->cpu_index); |
Philippe Mathieu-Daudé | 2198f5f | 2023-11-20 13:36:35 +0100 | [diff] [blame] | 281 | if (!memory_region_init_ram(&s->sram, OBJECT(s), sram_name, sc->sram_size, |
| 282 | errp)) { |
Cédric Le Goater | 74af4ee | 2016-12-27 14:59:27 +0000 | [diff] [blame] | 283 | return; |
| 284 | } |
Peter Delevoryas | 4dd9d55 | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 285 | memory_region_add_subregion(s->memory, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 286 | sc->memmap[ASPEED_DEV_SRAM], &s->sram); |
Cédric Le Goater | 74af4ee | 2016-12-27 14:59:27 +0000 | [diff] [blame] | 287 | |
Cédric Le Goater | e2a11ca | 2018-06-26 17:50:42 +0100 | [diff] [blame] | 288 | /* SCU */ |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 289 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->scu), errp)) { |
Cédric Le Goater | e2a11ca | 2018-06-26 17:50:42 +0100 | [diff] [blame] | 290 | return; |
| 291 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 292 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->scu), 0, sc->memmap[ASPEED_DEV_SCU]); |
Cédric Le Goater | e2a11ca | 2018-06-26 17:50:42 +0100 | [diff] [blame] | 293 | |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 294 | /* VIC */ |
Philippe Mathieu-Daudé | dd41ce7 | 2023-10-24 18:24:22 +0200 | [diff] [blame] | 295 | if (!sysbus_realize(SYS_BUS_DEVICE(&a->vic), errp)) { |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 296 | return; |
| 297 | } |
Philippe Mathieu-Daudé | dd41ce7 | 2023-10-24 18:24:22 +0200 | [diff] [blame] | 298 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&a->vic), 0, sc->memmap[ASPEED_DEV_VIC]); |
| 299 | sysbus_connect_irq(SYS_BUS_DEVICE(&a->vic), 0, |
| 300 | qdev_get_gpio_in(DEVICE(&a->cpu), ARM_CPU_IRQ)); |
| 301 | sysbus_connect_irq(SYS_BUS_DEVICE(&a->vic), 1, |
| 302 | qdev_get_gpio_in(DEVICE(&a->cpu), ARM_CPU_FIQ)); |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 303 | |
Joel Stanley | 75fb457 | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 304 | /* RTC */ |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 305 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->rtc), errp)) { |
Joel Stanley | 75fb457 | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 306 | return; |
| 307 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 308 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->rtc), 0, sc->memmap[ASPEED_DEV_RTC]); |
Joel Stanley | 75fb457 | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 309 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->rtc), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 310 | aspeed_soc_get_irq(s, ASPEED_DEV_RTC)); |
Joel Stanley | 75fb457 | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 311 | |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 312 | /* Timer */ |
Markus Armbruster | 5325cc3 | 2020-07-07 18:05:54 +0200 | [diff] [blame] | 313 | object_property_set_link(OBJECT(&s->timerctrl), "scu", OBJECT(&s->scu), |
| 314 | &error_abort); |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 315 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->timerctrl), errp)) { |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 316 | return; |
| 317 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 318 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->timerctrl), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 319 | sc->memmap[ASPEED_DEV_TIMER1]); |
Cédric Le Goater | b456b11 | 2019-07-01 17:26:15 +0100 | [diff] [blame] | 320 | for (i = 0; i < ASPEED_TIMER_NR_TIMERS; i++) { |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 321 | qemu_irq irq = aspeed_soc_get_irq(s, ASPEED_DEV_TIMER1 + i); |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 322 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->timerctrl), i, irq); |
| 323 | } |
| 324 | |
Andrew Jeffery | 199fd62 | 2021-10-12 08:20:08 +0200 | [diff] [blame] | 325 | /* ADC */ |
| 326 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->adc), errp)) { |
| 327 | return; |
| 328 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 329 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->adc), 0, sc->memmap[ASPEED_DEV_ADC]); |
Andrew Jeffery | 199fd62 | 2021-10-12 08:20:08 +0200 | [diff] [blame] | 330 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->adc), 0, |
| 331 | aspeed_soc_get_irq(s, ASPEED_DEV_ADC)); |
| 332 | |
Peter Delevoryas | 470253b | 2022-05-25 10:31:33 +0200 | [diff] [blame] | 333 | /* UART */ |
Peter Delevoryas | d2b3eae | 2022-07-14 16:24:38 +0200 | [diff] [blame] | 334 | if (!aspeed_soc_uart_realize(s, errp)) { |
| 335 | return; |
| 336 | } |
Cédric Le Goater | 1602001 | 2016-06-06 16:59:29 +0100 | [diff] [blame] | 337 | |
| 338 | /* I2C */ |
Markus Armbruster | 5325cc3 | 2020-07-07 18:05:54 +0200 | [diff] [blame] | 339 | object_property_set_link(OBJECT(&s->i2c), "dram", OBJECT(s->dram_mr), |
Markus Armbruster | c24d9716 | 2020-06-30 11:03:41 +0200 | [diff] [blame] | 340 | &error_abort); |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 341 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->i2c), errp)) { |
Cédric Le Goater | 1602001 | 2016-06-06 16:59:29 +0100 | [diff] [blame] | 342 | return; |
| 343 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 344 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->i2c), 0, sc->memmap[ASPEED_DEV_I2C]); |
Cédric Le Goater | 1602001 | 2016-06-06 16:59:29 +0100 | [diff] [blame] | 345 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->i2c), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 346 | aspeed_soc_get_irq(s, ASPEED_DEV_I2C)); |
Cédric Le Goater | 7c1c69b | 2016-07-04 13:06:37 +0100 | [diff] [blame] | 347 | |
Peter Delevoryas | 55c5702 | 2022-06-30 09:21:14 +0200 | [diff] [blame] | 348 | /* PECI */ |
| 349 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->peci), errp)) { |
| 350 | return; |
| 351 | } |
| 352 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->peci), 0, |
| 353 | sc->memmap[ASPEED_DEV_PECI]); |
| 354 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->peci), 0, |
| 355 | aspeed_soc_get_irq(s, ASPEED_DEV_PECI)); |
| 356 | |
Cédric Le Goater | 26d5df9 | 2016-12-27 14:59:29 +0000 | [diff] [blame] | 357 | /* FMC, The number of CS is set at the board level */ |
Markus Armbruster | 5325cc3 | 2020-07-07 18:05:54 +0200 | [diff] [blame] | 358 | object_property_set_link(OBJECT(&s->fmc), "dram", OBJECT(s->dram_mr), |
Markus Armbruster | c24d9716 | 2020-06-30 11:03:41 +0200 | [diff] [blame] | 359 | &error_abort); |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 360 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->fmc), errp)) { |
Cédric Le Goater | 7c1c69b | 2016-07-04 13:06:37 +0100 | [diff] [blame] | 361 | return; |
| 362 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 363 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->fmc), 0, sc->memmap[ASPEED_DEV_FMC]); |
| 364 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->fmc), 1, |
Cédric Le Goater | 30b6852 | 2021-10-12 08:20:08 +0200 | [diff] [blame] | 365 | ASPEED_SMC_GET_CLASS(&s->fmc)->flash_window_base); |
Cédric Le Goater | 0e5803d | 2016-10-17 19:22:16 +0100 | [diff] [blame] | 366 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->fmc), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 367 | aspeed_soc_get_irq(s, ASPEED_DEV_FMC)); |
Cédric Le Goater | 7c1c69b | 2016-07-04 13:06:37 +0100 | [diff] [blame] | 368 | |
Cédric Le Goater | 5aa281d | 2023-03-02 13:57:50 +0100 | [diff] [blame] | 369 | /* Set up an alias on the FMC CE0 region (boot default) */ |
| 370 | MemoryRegion *fmc0_mmio = &s->fmc.flashes[0].mmio; |
| 371 | memory_region_init_alias(&s->spi_boot, OBJECT(s), "aspeed.spi_boot", |
| 372 | fmc0_mmio, 0, memory_region_size(fmc0_mmio)); |
| 373 | memory_region_add_subregion(&s->spi_boot_container, 0x0, &s->spi_boot); |
| 374 | |
Cédric Le Goater | 7c1c69b | 2016-07-04 13:06:37 +0100 | [diff] [blame] | 375 | /* SPI */ |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 376 | for (i = 0; i < sc->spis_num; i++) { |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 377 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->spi[i]), errp)) { |
Cédric Le Goater | dbcabee | 2016-10-17 19:22:16 +0100 | [diff] [blame] | 378 | return; |
| 379 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 380 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->spi[i]), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 381 | sc->memmap[ASPEED_DEV_SPI1 + i]); |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 382 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->spi[i]), 1, |
Cédric Le Goater | 30b6852 | 2021-10-12 08:20:08 +0200 | [diff] [blame] | 383 | ASPEED_SMC_GET_CLASS(&s->spi[i])->flash_window_base); |
Cédric Le Goater | 7c1c69b | 2016-07-04 13:06:37 +0100 | [diff] [blame] | 384 | } |
Cédric Le Goater | c2da8a8 | 2016-09-06 19:52:17 +0100 | [diff] [blame] | 385 | |
Guenter Roeck | bfdd34f | 2020-02-06 10:34:37 -0800 | [diff] [blame] | 386 | /* EHCI */ |
| 387 | for (i = 0; i < sc->ehcis_num; i++) { |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 388 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->ehci[i]), errp)) { |
Guenter Roeck | bfdd34f | 2020-02-06 10:34:37 -0800 | [diff] [blame] | 389 | return; |
| 390 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 391 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->ehci[i]), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 392 | sc->memmap[ASPEED_DEV_EHCI1 + i]); |
Guenter Roeck | bfdd34f | 2020-02-06 10:34:37 -0800 | [diff] [blame] | 393 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->ehci[i]), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 394 | aspeed_soc_get_irq(s, ASPEED_DEV_EHCI1 + i)); |
Guenter Roeck | bfdd34f | 2020-02-06 10:34:37 -0800 | [diff] [blame] | 395 | } |
| 396 | |
Cédric Le Goater | c2da8a8 | 2016-09-06 19:52:17 +0100 | [diff] [blame] | 397 | /* SDMC - SDRAM Memory Controller */ |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 398 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdmc), errp)) { |
Cédric Le Goater | c2da8a8 | 2016-09-06 19:52:17 +0100 | [diff] [blame] | 399 | return; |
| 400 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 401 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->sdmc), 0, |
| 402 | sc->memmap[ASPEED_DEV_SDMC]); |
Cédric Le Goater | 013befe | 2017-02-07 18:29:59 +0000 | [diff] [blame] | 403 | |
| 404 | /* Watch dog */ |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 405 | for (i = 0; i < sc->wdts_num; i++) { |
Cédric Le Goater | 6112bd6 | 2019-09-25 16:32:35 +0200 | [diff] [blame] | 406 | AspeedWDTClass *awc = ASPEED_WDT_GET_CLASS(&s->wdt[i]); |
Philippe Mathieu-Daudé | 6fdb438 | 2023-02-07 09:02:05 +0100 | [diff] [blame] | 407 | hwaddr wdt_offset = sc->memmap[ASPEED_DEV_WDT] + i * awc->iosize; |
Cédric Le Goater | 6112bd6 | 2019-09-25 16:32:35 +0200 | [diff] [blame] | 408 | |
Markus Armbruster | 5325cc3 | 2020-07-07 18:05:54 +0200 | [diff] [blame] | 409 | object_property_set_link(OBJECT(&s->wdt[i]), "scu", OBJECT(&s->scu), |
| 410 | &error_abort); |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 411 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->wdt[i]), errp)) { |
Joel Stanley | f986ee1 | 2017-07-11 11:21:26 +0100 | [diff] [blame] | 412 | return; |
| 413 | } |
Philippe Mathieu-Daudé | 6fdb438 | 2023-02-07 09:02:05 +0100 | [diff] [blame] | 414 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->wdt[i]), 0, wdt_offset); |
Cédric Le Goater | 013befe | 2017-02-07 18:29:59 +0000 | [diff] [blame] | 415 | } |
Cédric Le Goater | ea337c6 | 2017-04-14 10:35:02 +0200 | [diff] [blame] | 416 | |
Cédric Le Goater | 346160c | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 417 | /* RAM */ |
| 418 | if (!aspeed_soc_dram_init(s, errp)) { |
| 419 | return; |
| 420 | } |
| 421 | |
Cédric Le Goater | ea337c6 | 2017-04-14 10:35:02 +0200 | [diff] [blame] | 422 | /* Net */ |
Cédric Le Goater | d3bad7e | 2020-06-09 14:23:20 +0200 | [diff] [blame] | 423 | for (i = 0; i < sc->macs_num; i++) { |
Markus Armbruster | 5325cc3 | 2020-07-07 18:05:54 +0200 | [diff] [blame] | 424 | object_property_set_bool(OBJECT(&s->ftgmac100[i]), "aspeed", true, |
Markus Armbruster | 2255f6b | 2020-06-30 11:03:48 +0200 | [diff] [blame] | 425 | &error_abort); |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 426 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->ftgmac100[i]), errp)) { |
Markus Armbruster | 123327d | 2020-06-30 11:03:37 +0200 | [diff] [blame] | 427 | return; |
Cédric Le Goater | 6734099 | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 428 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 429 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->ftgmac100[i]), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 430 | sc->memmap[ASPEED_DEV_ETH1 + i]); |
Cédric Le Goater | 6734099 | 2019-07-01 17:26:16 +0100 | [diff] [blame] | 431 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->ftgmac100[i]), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 432 | aspeed_soc_get_irq(s, ASPEED_DEV_ETH1 + i)); |
Cédric Le Goater | ea337c6 | 2017-04-14 10:35:02 +0200 | [diff] [blame] | 433 | } |
Eddie James | 118c82e | 2019-07-01 17:26:18 +0100 | [diff] [blame] | 434 | |
| 435 | /* XDMA */ |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 436 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->xdma), errp)) { |
Eddie James | 118c82e | 2019-07-01 17:26:18 +0100 | [diff] [blame] | 437 | return; |
| 438 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 439 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->xdma), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 440 | sc->memmap[ASPEED_DEV_XDMA]); |
Eddie James | 118c82e | 2019-07-01 17:26:18 +0100 | [diff] [blame] | 441 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->xdma), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 442 | aspeed_soc_get_irq(s, ASPEED_DEV_XDMA)); |
Rashmica Gupta | fdcc7c0 | 2019-09-04 09:04:58 +0200 | [diff] [blame] | 443 | |
| 444 | /* GPIO */ |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 445 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), errp)) { |
Rashmica Gupta | fdcc7c0 | 2019-09-04 09:04:58 +0200 | [diff] [blame] | 446 | return; |
| 447 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 448 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->gpio), 0, |
| 449 | sc->memmap[ASPEED_DEV_GPIO]); |
Rashmica Gupta | fdcc7c0 | 2019-09-04 09:04:58 +0200 | [diff] [blame] | 450 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->gpio), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 451 | aspeed_soc_get_irq(s, ASPEED_DEV_GPIO)); |
Eddie James | 2bea128 | 2019-09-25 16:32:27 +0200 | [diff] [blame] | 452 | |
| 453 | /* SDHCI */ |
Markus Armbruster | 668f62e | 2020-07-07 18:06:02 +0200 | [diff] [blame] | 454 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhci), errp)) { |
Eddie James | 2bea128 | 2019-09-25 16:32:27 +0200 | [diff] [blame] | 455 | return; |
| 456 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 457 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->sdhci), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 458 | sc->memmap[ASPEED_DEV_SDHCI]); |
Eddie James | 2bea128 | 2019-09-25 16:32:27 +0200 | [diff] [blame] | 459 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->sdhci), 0, |
Eduardo Habkost | 347df6f | 2020-08-25 15:20:02 -0400 | [diff] [blame] | 460 | aspeed_soc_get_irq(s, ASPEED_DEV_SDHCI)); |
Cédric Le Goater | 2ecf172 | 2021-03-09 12:01:28 +0100 | [diff] [blame] | 461 | |
| 462 | /* LPC */ |
| 463 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->lpc), errp)) { |
| 464 | return; |
| 465 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 466 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->lpc), 0, sc->memmap[ASPEED_DEV_LPC]); |
Andrew Jeffery | c59f781 | 2021-03-09 12:01:28 +0100 | [diff] [blame] | 467 | |
| 468 | /* Connect the LPC IRQ to the VIC */ |
Cédric Le Goater | 2ecf172 | 2021-03-09 12:01:28 +0100 | [diff] [blame] | 469 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->lpc), 0, |
| 470 | aspeed_soc_get_irq(s, ASPEED_DEV_LPC)); |
Andrew Jeffery | c59f781 | 2021-03-09 12:01:28 +0100 | [diff] [blame] | 471 | |
| 472 | /* |
| 473 | * On the AST2400 and AST2500 the one LPC IRQ is shared between all of the |
| 474 | * subdevices. Connect the LPC subdevice IRQs to the LPC controller IRQ (by |
| 475 | * contrast, on the AST2600, the subdevice IRQs are connected straight to |
| 476 | * the GIC). |
| 477 | * |
| 478 | * LPC subdevice IRQ sources are offset from 1 because the shared IRQ output |
| 479 | * to the VIC is at offset 0. |
| 480 | */ |
| 481 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->lpc), 1 + aspeed_lpc_kcs_1, |
| 482 | qdev_get_gpio_in(DEVICE(&s->lpc), aspeed_lpc_kcs_1)); |
| 483 | |
| 484 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->lpc), 1 + aspeed_lpc_kcs_2, |
| 485 | qdev_get_gpio_in(DEVICE(&s->lpc), aspeed_lpc_kcs_2)); |
| 486 | |
| 487 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->lpc), 1 + aspeed_lpc_kcs_3, |
| 488 | qdev_get_gpio_in(DEVICE(&s->lpc), aspeed_lpc_kcs_3)); |
| 489 | |
| 490 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->lpc), 1 + aspeed_lpc_kcs_4, |
| 491 | qdev_get_gpio_in(DEVICE(&s->lpc), aspeed_lpc_kcs_4)); |
Joel Stanley | a3888d7 | 2021-05-01 10:03:51 +0200 | [diff] [blame] | 492 | |
| 493 | /* HACE */ |
| 494 | object_property_set_link(OBJECT(&s->hace), "dram", OBJECT(s->dram_mr), |
| 495 | &error_abort); |
| 496 | if (!sysbus_realize(SYS_BUS_DEVICE(&s->hace), errp)) { |
| 497 | return; |
| 498 | } |
Peter Delevoryas | 5bfcbda | 2022-06-30 09:21:13 +0200 | [diff] [blame] | 499 | aspeed_mmio_map(s, SYS_BUS_DEVICE(&s->hace), 0, |
| 500 | sc->memmap[ASPEED_DEV_HACE]); |
Joel Stanley | a3888d7 | 2021-05-01 10:03:51 +0200 | [diff] [blame] | 501 | sysbus_connect_irq(SYS_BUS_DEVICE(&s->hace), 0, |
| 502 | aspeed_soc_get_irq(s, ASPEED_DEV_HACE)); |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 503 | } |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 504 | |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 505 | static void aspeed_soc_ast2400_class_init(ObjectClass *oc, void *data) |
| 506 | { |
Philippe Mathieu-Daudé | dc13909 | 2024-01-25 06:55:44 +0100 | [diff] [blame] | 507 | static const char * const valid_cpu_types[] = { |
| 508 | ARM_CPU_TYPE_NAME("arm926"), |
| 509 | NULL |
| 510 | }; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 511 | AspeedSoCClass *sc = ASPEED_SOC_CLASS(oc); |
Philippe Mathieu-Daudé | aa6c669 | 2023-10-24 18:24:14 +0200 | [diff] [blame] | 512 | DeviceClass *dc = DEVICE_CLASS(oc); |
| 513 | |
| 514 | dc->realize = aspeed_ast2400_soc_realize; |
| 515 | /* Reason: Uses serial_hds and nd_table in realize() directly */ |
| 516 | dc->user_creatable = false; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 517 | |
| 518 | sc->name = "ast2400-a1"; |
Philippe Mathieu-Daudé | dc13909 | 2024-01-25 06:55:44 +0100 | [diff] [blame] | 519 | sc->valid_cpu_types = valid_cpu_types; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 520 | sc->silicon_rev = AST2400_A1_SILICON_REV; |
| 521 | sc->sram_size = 0x8000; |
| 522 | sc->spis_num = 1; |
Guenter Roeck | bfdd34f | 2020-02-06 10:34:37 -0800 | [diff] [blame] | 523 | sc->ehcis_num = 1; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 524 | sc->wdts_num = 2; |
Joel Stanley | d300db0 | 2019-09-25 16:32:46 +0200 | [diff] [blame] | 525 | sc->macs_num = 2; |
Peter Delevoryas | c5e1bdb | 2022-05-25 10:31:33 +0200 | [diff] [blame] | 526 | sc->uarts_num = 5; |
Jamin Lin | 944128e | 2024-02-15 15:53:30 +0800 | [diff] [blame] | 527 | sc->uarts_base = ASPEED_DEV_UART1; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 528 | sc->irqmap = aspeed_soc_ast2400_irqmap; |
| 529 | sc->memmap = aspeed_soc_ast2400_memmap; |
| 530 | sc->num_cpus = 1; |
Cédric Le Goater | 699db71 | 2022-05-25 10:31:33 +0200 | [diff] [blame] | 531 | sc->get_irq = aspeed_soc_ast2400_get_irq; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 532 | } |
| 533 | |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 534 | static void aspeed_soc_ast2500_class_init(ObjectClass *oc, void *data) |
| 535 | { |
Philippe Mathieu-Daudé | dc13909 | 2024-01-25 06:55:44 +0100 | [diff] [blame] | 536 | static const char * const valid_cpu_types[] = { |
| 537 | ARM_CPU_TYPE_NAME("arm1176"), |
| 538 | NULL |
| 539 | }; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 540 | AspeedSoCClass *sc = ASPEED_SOC_CLASS(oc); |
Philippe Mathieu-Daudé | aa6c669 | 2023-10-24 18:24:14 +0200 | [diff] [blame] | 541 | DeviceClass *dc = DEVICE_CLASS(oc); |
| 542 | |
| 543 | dc->realize = aspeed_ast2400_soc_realize; |
| 544 | /* Reason: Uses serial_hds and nd_table in realize() directly */ |
| 545 | dc->user_creatable = false; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 546 | |
| 547 | sc->name = "ast2500-a1"; |
Philippe Mathieu-Daudé | dc13909 | 2024-01-25 06:55:44 +0100 | [diff] [blame] | 548 | sc->valid_cpu_types = valid_cpu_types; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 549 | sc->silicon_rev = AST2500_A1_SILICON_REV; |
| 550 | sc->sram_size = 0x9000; |
| 551 | sc->spis_num = 2; |
Guenter Roeck | bfdd34f | 2020-02-06 10:34:37 -0800 | [diff] [blame] | 552 | sc->ehcis_num = 2; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 553 | sc->wdts_num = 3; |
Joel Stanley | d300db0 | 2019-09-25 16:32:46 +0200 | [diff] [blame] | 554 | sc->macs_num = 2; |
Peter Delevoryas | c5e1bdb | 2022-05-25 10:31:33 +0200 | [diff] [blame] | 555 | sc->uarts_num = 5; |
Jamin Lin | 944128e | 2024-02-15 15:53:30 +0800 | [diff] [blame] | 556 | sc->uarts_base = ASPEED_DEV_UART1; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 557 | sc->irqmap = aspeed_soc_ast2500_irqmap; |
| 558 | sc->memmap = aspeed_soc_ast2500_memmap; |
| 559 | sc->num_cpus = 1; |
Cédric Le Goater | 699db71 | 2022-05-25 10:31:33 +0200 | [diff] [blame] | 560 | sc->get_irq = aspeed_soc_ast2400_get_irq; |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 561 | } |
| 562 | |
Philippe Mathieu-Daudé | 1a94fae | 2023-10-24 18:24:18 +0200 | [diff] [blame] | 563 | static const TypeInfo aspeed_soc_ast2400_types[] = { |
| 564 | { |
| 565 | .name = TYPE_ASPEED2400_SOC, |
| 566 | .parent = TYPE_ASPEED_SOC, |
| 567 | .instance_init = aspeed_ast2400_soc_init, |
| 568 | .instance_size = sizeof(Aspeed2400SoCState), |
| 569 | .abstract = true, |
| 570 | }, { |
| 571 | .name = "ast2400-a1", |
| 572 | .parent = TYPE_ASPEED2400_SOC, |
| 573 | .class_init = aspeed_soc_ast2400_class_init, |
| 574 | }, { |
| 575 | .name = "ast2500-a1", |
| 576 | .parent = TYPE_ASPEED2400_SOC, |
| 577 | .class_init = aspeed_soc_ast2500_class_init, |
| 578 | }, |
Cédric Le Goater | 54ecafb | 2019-09-25 16:32:42 +0200 | [diff] [blame] | 579 | }; |
Andrew Jeffery | 43e3346 | 2016-03-16 17:06:00 +0000 | [diff] [blame] | 580 | |
Philippe Mathieu-Daudé | 1a94fae | 2023-10-24 18:24:18 +0200 | [diff] [blame] | 581 | DEFINE_TYPES(aspeed_soc_ast2400_types) |