1
2
3
4
5
6
7
8
9
10
11
12#include "qemu/osdep.h"
13#include "qemu/units.h"
14#include "qapi/error.h"
15#include "qemu/module.h"
16#include "hw/sysbus.h"
17#include "net/net.h"
18#include "sysemu/sysemu.h"
19#include "sysemu/kvm.h"
20#include "hw/arm/boot.h"
21#include "kvm_arm.h"
22#include "hw/misc/unimp.h"
23#include "hw/arm/xlnx-versal.h"
24
25#define XLNX_VERSAL_ACPU_TYPE ARM_CPU_TYPE_NAME("cortex-a72")
26#define GEM_REVISION 0x40070106
27
28static void versal_create_apu_cpus(Versal *s)
29{
30 int i;
31
32 for (i = 0; i < ARRAY_SIZE(s->fpd.apu.cpu); i++) {
33 Object *obj;
34
35 object_initialize_child(OBJECT(s), "apu-cpu[*]", &s->fpd.apu.cpu[i],
36 XLNX_VERSAL_ACPU_TYPE);
37 obj = OBJECT(&s->fpd.apu.cpu[i]);
38 object_property_set_int(obj, "psci-conduit", s->cfg.psci_conduit,
39 &error_abort);
40 if (i) {
41
42 object_property_set_bool(obj, "start-powered-off", true,
43 &error_abort);
44 }
45
46 object_property_set_int(obj, "core-count", ARRAY_SIZE(s->fpd.apu.cpu),
47 &error_abort);
48 object_property_set_link(obj, "memory", OBJECT(&s->fpd.apu.mr),
49 &error_abort);
50 qdev_realize(DEVICE(obj), NULL, &error_fatal);
51 }
52}
53
54static void versal_create_apu_gic(Versal *s, qemu_irq *pic)
55{
56 static const uint64_t addrs[] = {
57 MM_GIC_APU_DIST_MAIN,
58 MM_GIC_APU_REDIST_0
59 };
60 SysBusDevice *gicbusdev;
61 DeviceState *gicdev;
62 int nr_apu_cpus = ARRAY_SIZE(s->fpd.apu.cpu);
63 int i;
64
65 object_initialize_child(OBJECT(s), "apu-gic", &s->fpd.apu.gic,
66 gicv3_class_name());
67 gicbusdev = SYS_BUS_DEVICE(&s->fpd.apu.gic);
68 gicdev = DEVICE(&s->fpd.apu.gic);
69 qdev_prop_set_uint32(gicdev, "revision", 3);
70 qdev_prop_set_uint32(gicdev, "num-cpu", nr_apu_cpus);
71 qdev_prop_set_uint32(gicdev, "num-irq", XLNX_VERSAL_NR_IRQS + 32);
72 qdev_prop_set_uint32(gicdev, "len-redist-region-count", 1);
73 qdev_prop_set_uint32(gicdev, "redist-region-count[0]", nr_apu_cpus);
74 qdev_prop_set_bit(gicdev, "has-security-extensions", true);
75
76 sysbus_realize(SYS_BUS_DEVICE(&s->fpd.apu.gic), &error_fatal);
77
78 for (i = 0; i < ARRAY_SIZE(addrs); i++) {
79 MemoryRegion *mr;
80
81 mr = sysbus_mmio_get_region(gicbusdev, i);
82 memory_region_add_subregion(&s->fpd.apu.mr, addrs[i], mr);
83 }
84
85 for (i = 0; i < nr_apu_cpus; i++) {
86 DeviceState *cpudev = DEVICE(&s->fpd.apu.cpu[i]);
87 int ppibase = XLNX_VERSAL_NR_IRQS + i * GIC_INTERNAL + GIC_NR_SGIS;
88 qemu_irq maint_irq;
89 int ti;
90
91
92
93 const int timer_irq[] = {
94 [GTIMER_PHYS] = VERSAL_TIMER_NS_EL1_IRQ,
95 [GTIMER_VIRT] = VERSAL_TIMER_VIRT_IRQ,
96 [GTIMER_HYP] = VERSAL_TIMER_NS_EL2_IRQ,
97 [GTIMER_SEC] = VERSAL_TIMER_S_EL1_IRQ,
98 };
99
100 for (ti = 0; ti < ARRAY_SIZE(timer_irq); ti++) {
101 qdev_connect_gpio_out(cpudev, ti,
102 qdev_get_gpio_in(gicdev,
103 ppibase + timer_irq[ti]));
104 }
105 maint_irq = qdev_get_gpio_in(gicdev,
106 ppibase + VERSAL_GIC_MAINT_IRQ);
107 qdev_connect_gpio_out_named(cpudev, "gicv3-maintenance-interrupt",
108 0, maint_irq);
109 sysbus_connect_irq(gicbusdev, i, qdev_get_gpio_in(cpudev, ARM_CPU_IRQ));
110 sysbus_connect_irq(gicbusdev, i + nr_apu_cpus,
111 qdev_get_gpio_in(cpudev, ARM_CPU_FIQ));
112 sysbus_connect_irq(gicbusdev, i + 2 * nr_apu_cpus,
113 qdev_get_gpio_in(cpudev, ARM_CPU_VIRQ));
114 sysbus_connect_irq(gicbusdev, i + 3 * nr_apu_cpus,
115 qdev_get_gpio_in(cpudev, ARM_CPU_VFIQ));
116 }
117
118 for (i = 0; i < XLNX_VERSAL_NR_IRQS; i++) {
119 pic[i] = qdev_get_gpio_in(gicdev, i);
120 }
121}
122
123static void versal_create_uarts(Versal *s, qemu_irq *pic)
124{
125 int i;
126
127 for (i = 0; i < ARRAY_SIZE(s->lpd.iou.uart); i++) {
128 static const int irqs[] = { VERSAL_UART0_IRQ_0, VERSAL_UART1_IRQ_0};
129 static const uint64_t addrs[] = { MM_UART0, MM_UART1 };
130 char *name = g_strdup_printf("uart%d", i);
131 DeviceState *dev;
132 MemoryRegion *mr;
133
134 object_initialize_child(OBJECT(s), name, &s->lpd.iou.uart[i],
135 TYPE_PL011);
136 dev = DEVICE(&s->lpd.iou.uart[i]);
137 qdev_prop_set_chr(dev, "chardev", serial_hd(i));
138 sysbus_realize(SYS_BUS_DEVICE(dev), &error_fatal);
139
140 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0);
141 memory_region_add_subregion(&s->mr_ps, addrs[i], mr);
142
143 sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[irqs[i]]);
144 g_free(name);
145 }
146}
147
148static void versal_create_usbs(Versal *s, qemu_irq *pic)
149{
150 DeviceState *dev;
151 MemoryRegion *mr;
152
153 object_initialize_child(OBJECT(s), "usb2", &s->lpd.iou.usb,
154 TYPE_XILINX_VERSAL_USB2);
155 dev = DEVICE(&s->lpd.iou.usb);
156
157 object_property_set_link(OBJECT(dev), "dma", OBJECT(&s->mr_ps),
158 &error_abort);
159 qdev_prop_set_uint32(dev, "intrs", 1);
160 qdev_prop_set_uint32(dev, "slots", 2);
161
162 sysbus_realize(SYS_BUS_DEVICE(dev), &error_fatal);
163
164 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0);
165 memory_region_add_subregion(&s->mr_ps, MM_USB_0, mr);
166
167 sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[VERSAL_USB0_IRQ_0]);
168
169 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 1);
170 memory_region_add_subregion(&s->mr_ps, MM_USB2_CTRL_REGS, mr);
171}
172
173static void versal_create_gems(Versal *s, qemu_irq *pic)
174{
175 int i;
176
177 for (i = 0; i < ARRAY_SIZE(s->lpd.iou.gem); i++) {
178 static const int irqs[] = { VERSAL_GEM0_IRQ_0, VERSAL_GEM1_IRQ_0};
179 static const uint64_t addrs[] = { MM_GEM0, MM_GEM1 };
180 char *name = g_strdup_printf("gem%d", i);
181 NICInfo *nd = &nd_table[i];
182 DeviceState *dev;
183 MemoryRegion *mr;
184
185 object_initialize_child(OBJECT(s), name, &s->lpd.iou.gem[i],
186 TYPE_CADENCE_GEM);
187 dev = DEVICE(&s->lpd.iou.gem[i]);
188
189 if (nd->used) {
190 qemu_check_nic_model(nd, "cadence_gem");
191 qdev_set_nic_properties(dev, nd);
192 }
193 object_property_set_int(OBJECT(dev), "phy-addr", 23, &error_abort);
194 object_property_set_int(OBJECT(dev), "num-priority-queues", 2,
195 &error_abort);
196 object_property_set_link(OBJECT(dev), "dma", OBJECT(&s->mr_ps),
197 &error_abort);
198 sysbus_realize(SYS_BUS_DEVICE(dev), &error_fatal);
199
200 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0);
201 memory_region_add_subregion(&s->mr_ps, addrs[i], mr);
202
203 sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[irqs[i]]);
204 g_free(name);
205 }
206}
207
208static void versal_create_admas(Versal *s, qemu_irq *pic)
209{
210 int i;
211
212 for (i = 0; i < ARRAY_SIZE(s->lpd.iou.adma); i++) {
213 char *name = g_strdup_printf("adma%d", i);
214 DeviceState *dev;
215 MemoryRegion *mr;
216
217 object_initialize_child(OBJECT(s), name, &s->lpd.iou.adma[i],
218 TYPE_XLNX_ZDMA);
219 dev = DEVICE(&s->lpd.iou.adma[i]);
220 object_property_set_int(OBJECT(dev), "bus-width", 128, &error_abort);
221 object_property_set_link(OBJECT(dev), "dma",
222 OBJECT(get_system_memory()), &error_fatal);
223 sysbus_realize(SYS_BUS_DEVICE(dev), &error_fatal);
224
225 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0);
226 memory_region_add_subregion(&s->mr_ps,
227 MM_ADMA_CH0 + i * MM_ADMA_CH0_SIZE, mr);
228
229 sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, pic[VERSAL_ADMA_IRQ_0 + i]);
230 g_free(name);
231 }
232}
233
234#define SDHCI_CAPABILITIES 0x280737ec6481
235static void versal_create_sds(Versal *s, qemu_irq *pic)
236{
237 int i;
238
239 for (i = 0; i < ARRAY_SIZE(s->pmc.iou.sd); i++) {
240 DeviceState *dev;
241 MemoryRegion *mr;
242
243 object_initialize_child(OBJECT(s), "sd[*]", &s->pmc.iou.sd[i],
244 TYPE_SYSBUS_SDHCI);
245 dev = DEVICE(&s->pmc.iou.sd[i]);
246
247 object_property_set_uint(OBJECT(dev), "sd-spec-version", 3,
248 &error_fatal);
249 object_property_set_uint(OBJECT(dev), "capareg", SDHCI_CAPABILITIES,
250 &error_fatal);
251 object_property_set_uint(OBJECT(dev), "uhs", UHS_I, &error_fatal);
252 sysbus_realize(SYS_BUS_DEVICE(dev), &error_fatal);
253
254 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0);
255 memory_region_add_subregion(&s->mr_ps,
256 MM_PMC_SD0 + i * MM_PMC_SD0_SIZE, mr);
257
258 sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0,
259 pic[VERSAL_SD0_IRQ_0 + i * 2]);
260 }
261}
262
263static void versal_create_rtc(Versal *s, qemu_irq *pic)
264{
265 SysBusDevice *sbd;
266 MemoryRegion *mr;
267
268 object_initialize_child(OBJECT(s), "rtc", &s->pmc.rtc,
269 TYPE_XLNX_ZYNQMP_RTC);
270 sbd = SYS_BUS_DEVICE(&s->pmc.rtc);
271 sysbus_realize(SYS_BUS_DEVICE(sbd), &error_fatal);
272
273 mr = sysbus_mmio_get_region(sbd, 0);
274 memory_region_add_subregion(&s->mr_ps, MM_PMC_RTC, mr);
275
276
277
278
279
280 sysbus_connect_irq(sbd, 1, pic[VERSAL_RTC_APB_ERR_IRQ]);
281}
282
283static void versal_create_xrams(Versal *s, qemu_irq *pic)
284{
285 int nr_xrams = ARRAY_SIZE(s->lpd.xram.ctrl);
286 DeviceState *orgate;
287 int i;
288
289
290 object_initialize_child(OBJECT(s), "xram-irq-orgate",
291 &s->lpd.xram.irq_orgate, TYPE_OR_IRQ);
292 orgate = DEVICE(&s->lpd.xram.irq_orgate);
293 object_property_set_int(OBJECT(orgate),
294 "num-lines", nr_xrams, &error_fatal);
295 qdev_realize(orgate, NULL, &error_fatal);
296 qdev_connect_gpio_out(orgate, 0, pic[VERSAL_XRAM_IRQ_0]);
297
298 for (i = 0; i < ARRAY_SIZE(s->lpd.xram.ctrl); i++) {
299 SysBusDevice *sbd;
300 MemoryRegion *mr;
301
302 object_initialize_child(OBJECT(s), "xram[*]", &s->lpd.xram.ctrl[i],
303 TYPE_XLNX_XRAM_CTRL);
304 sbd = SYS_BUS_DEVICE(&s->lpd.xram.ctrl[i]);
305 sysbus_realize(sbd, &error_fatal);
306
307 mr = sysbus_mmio_get_region(sbd, 0);
308 memory_region_add_subregion(&s->mr_ps,
309 MM_XRAMC + i * MM_XRAMC_SIZE, mr);
310 mr = sysbus_mmio_get_region(sbd, 1);
311 memory_region_add_subregion(&s->mr_ps, MM_XRAM + i * MiB, mr);
312
313 sysbus_connect_irq(sbd, 0, qdev_get_gpio_in(orgate, i));
314 }
315}
316
317static void versal_create_bbram(Versal *s, qemu_irq *pic)
318{
319 SysBusDevice *sbd;
320
321 object_initialize_child_with_props(OBJECT(s), "bbram", &s->pmc.bbram,
322 sizeof(s->pmc.bbram), TYPE_XLNX_BBRAM,
323 &error_fatal,
324 "crc-zpads", "0",
325 NULL);
326 sbd = SYS_BUS_DEVICE(&s->pmc.bbram);
327
328 sysbus_realize(sbd, &error_fatal);
329 memory_region_add_subregion(&s->mr_ps, MM_PMC_BBRAM_CTRL,
330 sysbus_mmio_get_region(sbd, 0));
331 sysbus_connect_irq(sbd, 0, pic[VERSAL_BBRAM_APB_IRQ_0]);
332}
333
334static void versal_realize_efuse_part(Versal *s, Object *dev, hwaddr base)
335{
336 SysBusDevice *part = SYS_BUS_DEVICE(dev);
337
338 object_property_set_link(OBJECT(part), "efuse",
339 OBJECT(&s->pmc.efuse), &error_abort);
340
341 sysbus_realize(part, &error_abort);
342 memory_region_add_subregion(&s->mr_ps, base,
343 sysbus_mmio_get_region(part, 0));
344}
345
346static void versal_create_efuse(Versal *s, qemu_irq *pic)
347{
348 Object *bits = OBJECT(&s->pmc.efuse);
349 Object *ctrl = OBJECT(&s->pmc.efuse_ctrl);
350 Object *cache = OBJECT(&s->pmc.efuse_cache);
351
352 object_initialize_child(OBJECT(s), "efuse-ctrl", &s->pmc.efuse_ctrl,
353 TYPE_XLNX_VERSAL_EFUSE_CTRL);
354
355 object_initialize_child(OBJECT(s), "efuse-cache", &s->pmc.efuse_cache,
356 TYPE_XLNX_VERSAL_EFUSE_CACHE);
357
358 object_initialize_child_with_props(ctrl, "xlnx-efuse@0", bits,
359 sizeof(s->pmc.efuse),
360 TYPE_XLNX_EFUSE, &error_abort,
361 "efuse-nr", "3",
362 "efuse-size", "8192",
363 NULL);
364
365 qdev_realize(DEVICE(bits), NULL, &error_abort);
366 versal_realize_efuse_part(s, ctrl, MM_PMC_EFUSE_CTRL);
367 versal_realize_efuse_part(s, cache, MM_PMC_EFUSE_CACHE);
368
369 sysbus_connect_irq(SYS_BUS_DEVICE(ctrl), 0, pic[VERSAL_EFUSE_IRQ]);
370}
371
372
373
374
375static void versal_map_ddr(Versal *s)
376{
377 uint64_t size = memory_region_size(s->cfg.mr_ddr);
378
379 static const struct {
380 uint64_t base;
381 uint64_t size;
382 } addr_ranges[] = {
383 { MM_TOP_DDR, MM_TOP_DDR_SIZE },
384 { MM_TOP_DDR_2, MM_TOP_DDR_2_SIZE },
385 { MM_TOP_DDR_3, MM_TOP_DDR_3_SIZE },
386 { MM_TOP_DDR_4, MM_TOP_DDR_4_SIZE }
387 };
388 uint64_t offset = 0;
389 int i;
390
391 assert(ARRAY_SIZE(addr_ranges) == ARRAY_SIZE(s->noc.mr_ddr_ranges));
392 for (i = 0; i < ARRAY_SIZE(addr_ranges) && size; i++) {
393 char *name;
394 uint64_t mapsize;
395
396 mapsize = size < addr_ranges[i].size ? size : addr_ranges[i].size;
397 name = g_strdup_printf("noc-ddr-range%d", i);
398
399 memory_region_init_alias(&s->noc.mr_ddr_ranges[i], OBJECT(s),
400 name, s->cfg.mr_ddr,
401 offset, mapsize);
402
403
404 memory_region_add_subregion(&s->mr_ps, addr_ranges[i].base,
405 &s->noc.mr_ddr_ranges[i]);
406 offset += mapsize;
407 size -= mapsize;
408 g_free(name);
409 }
410}
411
412static void versal_unimp_area(Versal *s, const char *name,
413 MemoryRegion *mr,
414 hwaddr base, hwaddr size)
415{
416 DeviceState *dev = qdev_new(TYPE_UNIMPLEMENTED_DEVICE);
417 MemoryRegion *mr_dev;
418
419 qdev_prop_set_string(dev, "name", name);
420 qdev_prop_set_uint64(dev, "size", size);
421 object_property_add_child(OBJECT(s), name, OBJECT(dev));
422 sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal);
423
424 mr_dev = sysbus_mmio_get_region(SYS_BUS_DEVICE(dev), 0);
425 memory_region_add_subregion(mr, base, mr_dev);
426}
427
428static void versal_unimp(Versal *s)
429{
430 versal_unimp_area(s, "psm", &s->mr_ps,
431 MM_PSM_START, MM_PSM_END - MM_PSM_START);
432 versal_unimp_area(s, "crl", &s->mr_ps,
433 MM_CRL, MM_CRL_SIZE);
434 versal_unimp_area(s, "crf", &s->mr_ps,
435 MM_FPD_CRF, MM_FPD_CRF_SIZE);
436 versal_unimp_area(s, "apu", &s->mr_ps,
437 MM_FPD_FPD_APU, MM_FPD_FPD_APU_SIZE);
438 versal_unimp_area(s, "crp", &s->mr_ps,
439 MM_PMC_CRP, MM_PMC_CRP_SIZE);
440 versal_unimp_area(s, "iou-scntr", &s->mr_ps,
441 MM_IOU_SCNTR, MM_IOU_SCNTR_SIZE);
442 versal_unimp_area(s, "iou-scntr-seucre", &s->mr_ps,
443 MM_IOU_SCNTRS, MM_IOU_SCNTRS_SIZE);
444}
445
446static void versal_realize(DeviceState *dev, Error **errp)
447{
448 Versal *s = XLNX_VERSAL(dev);
449 qemu_irq pic[XLNX_VERSAL_NR_IRQS];
450
451 versal_create_apu_cpus(s);
452 versal_create_apu_gic(s, pic);
453 versal_create_uarts(s, pic);
454 versal_create_usbs(s, pic);
455 versal_create_gems(s, pic);
456 versal_create_admas(s, pic);
457 versal_create_sds(s, pic);
458 versal_create_rtc(s, pic);
459 versal_create_xrams(s, pic);
460 versal_create_bbram(s, pic);
461 versal_create_efuse(s, pic);
462 versal_map_ddr(s);
463 versal_unimp(s);
464
465
466 memory_region_init_ram(&s->lpd.mr_ocm, OBJECT(s), "ocm",
467 MM_OCM_SIZE, &error_fatal);
468
469 memory_region_add_subregion_overlap(&s->mr_ps, MM_OCM, &s->lpd.mr_ocm, 0);
470 memory_region_add_subregion_overlap(&s->fpd.apu.mr, 0, &s->mr_ps, 0);
471}
472
473static void versal_init(Object *obj)
474{
475 Versal *s = XLNX_VERSAL(obj);
476
477 memory_region_init(&s->fpd.apu.mr, obj, "mr-apu", UINT64_MAX);
478 memory_region_init(&s->mr_ps, obj, "mr-ps-switch", UINT64_MAX);
479}
480
481static Property versal_properties[] = {
482 DEFINE_PROP_LINK("ddr", Versal, cfg.mr_ddr, TYPE_MEMORY_REGION,
483 MemoryRegion *),
484 DEFINE_PROP_UINT32("psci-conduit", Versal, cfg.psci_conduit, 0),
485 DEFINE_PROP_END_OF_LIST()
486};
487
488static void versal_class_init(ObjectClass *klass, void *data)
489{
490 DeviceClass *dc = DEVICE_CLASS(klass);
491
492 dc->realize = versal_realize;
493 device_class_set_props(dc, versal_properties);
494
495}
496
497static const TypeInfo versal_info = {
498 .name = TYPE_XLNX_VERSAL,
499 .parent = TYPE_SYS_BUS_DEVICE,
500 .instance_size = sizeof(Versal),
501 .instance_init = versal_init,
502 .class_init = versal_class_init,
503};
504
505static void versal_register_types(void)
506{
507 type_register_static(&versal_info);
508}
509
510type_init(versal_register_types);
511
