?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s390x/pci: bypass vfio DMA counting when using cdev
[qemu/kevin.git] / hw / arm / armsse.c
blob31acbf73471df862a9310f88158983020ea507a4
1 /*
2 * Arm SSE (Subsystems for Embedded): IoTKit
3 *
4 * Copyright (c) 2018 Linaro Limited
5 * Written by Peter Maydell
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 or
9 * (at your option) any later version.
10 */
11
12 #include "qemu/osdep.h"
13 #include "qemu/log.h"
14 #include "qemu/module.h"
15 #include "qemu/bitops.h"
16 #include "qemu/units.h"
17 #include "qapi/error.h"
18 #include "trace.h"
19 #include "hw/sysbus.h"
20 #include "migration/vmstate.h"
21 #include "hw/registerfields.h"
22 #include "hw/arm/armsse.h"
23 #include "hw/arm/armsse-version.h"
24 #include "hw/arm/boot.h"
25 #include "hw/irq.h"
26 #include "hw/qdev-clock.h"
27
28 /*
29 * The SSE-300 puts some devices in different places to the
30 * SSE-200 (and original IoTKit). We use an array of these structs
31 * to define how each variant lays out these devices. (Parts of the
32 * SoC that are the same for all variants aren't handled via these
33 * data structures.)
34 */
35
36 #define NO_IRQ -1
37 #define NO_PPC -1
38 /*
39 * Special values for ARMSSEDeviceInfo::irq to indicate that this
40 * device uses one of the inputs to the OR gate that feeds into the
41 * CPU NMI input.
42 */
43 #define NMI_0 10000
44 #define NMI_1 10001
45
46 typedef struct ARMSSEDeviceInfo {
47 const char *name; /* name to use for the QOM object; NULL terminates list */
48 const char *type; /* QOM type name */
49 unsigned int index; /* Which of the N devices of this type is this ? */
50 hwaddr addr;
51 hwaddr size; /* only needed for TYPE_UNIMPLEMENTED_DEVICE */
52 int ppc; /* Index of APB PPC this device is wired up to, or NO_PPC */
53 int ppc_port; /* Port number of this device on the PPC */
54 int irq; /* NO_IRQ, or 0..NUM_SSE_IRQS-1, or NMI_0 or NMI_1 */
55 bool slowclk; /* true if device uses the slow 32KHz clock */
56 } ARMSSEDeviceInfo;
57
58 struct ARMSSEInfo {
59 const char *name;
60 const char *cpu_type;
61 uint32_t sse_version;
62 int sram_banks;
63 uint32_t sram_bank_base;
64 int num_cpus;
65 uint32_t sys_version;
66 uint32_t iidr;
67 uint32_t cpuwait_rst;
68 bool has_mhus;
69 bool has_cachectrl;
70 bool has_cpusecctrl;
71 bool has_cpuid;
72 bool has_cpu_pwrctrl;
73 bool has_sse_counter;
74 bool has_tcms;
75 Property *props;
76 const ARMSSEDeviceInfo *devinfo;
77 const bool *irq_is_common;
78 };
79
80 static Property iotkit_properties[] = {
81 DEFINE_PROP_LINK("memory", ARMSSE, board_memory, TYPE_MEMORY_REGION,
82 MemoryRegion *),
83 DEFINE_PROP_UINT32("EXP_NUMIRQ", ARMSSE, exp_numirq, 64),
84 DEFINE_PROP_UINT32("SRAM_ADDR_WIDTH", ARMSSE, sram_addr_width, 15),
85 DEFINE_PROP_UINT32("init-svtor", ARMSSE, init_svtor, 0x10000000),
86 DEFINE_PROP_BOOL("CPU0_FPU", ARMSSE, cpu_fpu[0], true),
87 DEFINE_PROP_BOOL("CPU0_DSP", ARMSSE, cpu_dsp[0], true),
88 DEFINE_PROP_UINT32("CPU0_MPU_NS", ARMSSE, cpu_mpu_ns[0], 8),
89 DEFINE_PROP_UINT32("CPU0_MPU_S", ARMSSE, cpu_mpu_s[0], 8),
90 DEFINE_PROP_END_OF_LIST()
91 };
92
93 static Property sse200_properties[] = {
94 DEFINE_PROP_LINK("memory", ARMSSE, board_memory, TYPE_MEMORY_REGION,
95 MemoryRegion *),
96 DEFINE_PROP_UINT32("EXP_NUMIRQ", ARMSSE, exp_numirq, 64),
97 DEFINE_PROP_UINT32("SRAM_ADDR_WIDTH", ARMSSE, sram_addr_width, 15),
98 DEFINE_PROP_UINT32("init-svtor", ARMSSE, init_svtor, 0x10000000),
99 DEFINE_PROP_BOOL("CPU0_FPU", ARMSSE, cpu_fpu[0], false),
100 DEFINE_PROP_BOOL("CPU0_DSP", ARMSSE, cpu_dsp[0], false),
101 DEFINE_PROP_BOOL("CPU1_FPU", ARMSSE, cpu_fpu[1], true),
102 DEFINE_PROP_BOOL("CPU1_DSP", ARMSSE, cpu_dsp[1], true),
103 DEFINE_PROP_UINT32("CPU0_MPU_NS", ARMSSE, cpu_mpu_ns[0], 8),
104 DEFINE_PROP_UINT32("CPU0_MPU_S", ARMSSE, cpu_mpu_s[0], 8),
105 DEFINE_PROP_UINT32("CPU1_MPU_NS", ARMSSE, cpu_mpu_ns[1], 8),
106 DEFINE_PROP_UINT32("CPU1_MPU_S", ARMSSE, cpu_mpu_s[1], 8),
107 DEFINE_PROP_END_OF_LIST()
108 };
109
110 static Property sse300_properties[] = {
111 DEFINE_PROP_LINK("memory", ARMSSE, board_memory, TYPE_MEMORY_REGION,
112 MemoryRegion *),
113 DEFINE_PROP_UINT32("EXP_NUMIRQ", ARMSSE, exp_numirq, 64),
114 DEFINE_PROP_UINT32("SRAM_ADDR_WIDTH", ARMSSE, sram_addr_width, 18),
115 DEFINE_PROP_UINT32("init-svtor", ARMSSE, init_svtor, 0x10000000),
116 DEFINE_PROP_BOOL("CPU0_FPU", ARMSSE, cpu_fpu[0], true),
117 DEFINE_PROP_BOOL("CPU0_DSP", ARMSSE, cpu_dsp[0], true),
118 DEFINE_PROP_UINT32("CPU0_MPU_NS", ARMSSE, cpu_mpu_ns[0], 8),
119 DEFINE_PROP_UINT32("CPU0_MPU_S", ARMSSE, cpu_mpu_s[0], 8),
120 DEFINE_PROP_END_OF_LIST()
121 };
122
123 static const ARMSSEDeviceInfo iotkit_devices[] = {
124 {
125 .name = "timer0",
126 .type = TYPE_CMSDK_APB_TIMER,
127 .index = 0,
128 .addr = 0x40000000,
129 .ppc = 0,
130 .ppc_port = 0,
131 .irq = 3,
132 },
133 {
134 .name = "timer1",
135 .type = TYPE_CMSDK_APB_TIMER,
136 .index = 1,
137 .addr = 0x40001000,
138 .ppc = 0,
139 .ppc_port = 1,
140 .irq = 4,
141 },
142 {
143 .name = "s32ktimer",
144 .type = TYPE_CMSDK_APB_TIMER,
145 .index = 2,
146 .addr = 0x4002f000,
147 .ppc = 1,
148 .ppc_port = 0,
149 .irq = 2,
150 .slowclk = true,
151 },
152 {
153 .name = "dualtimer",
154 .type = TYPE_CMSDK_APB_DUALTIMER,
155 .index = 0,
156 .addr = 0x40002000,
157 .ppc = 0,
158 .ppc_port = 2,
159 .irq = 5,
160 },
161 {
162 .name = "s32kwatchdog",
163 .type = TYPE_CMSDK_APB_WATCHDOG,
164 .index = 0,
165 .addr = 0x5002e000,
166 .ppc = NO_PPC,
167 .irq = NMI_0,
168 .slowclk = true,
169 },
170 {
171 .name = "nswatchdog",
172 .type = TYPE_CMSDK_APB_WATCHDOG,
173 .index = 1,
174 .addr = 0x40081000,
175 .ppc = NO_PPC,
176 .irq = 1,
177 },
178 {
179 .name = "swatchdog",
180 .type = TYPE_CMSDK_APB_WATCHDOG,
181 .index = 2,
182 .addr = 0x50081000,
183 .ppc = NO_PPC,
184 .irq = NMI_1,
185 },
186 {
187 .name = "armsse-sysinfo",
188 .type = TYPE_IOTKIT_SYSINFO,
189 .index = 0,
190 .addr = 0x40020000,
191 .ppc = NO_PPC,
192 .irq = NO_IRQ,
193 },
194 {
195 .name = "armsse-sysctl",
196 .type = TYPE_IOTKIT_SYSCTL,
197 .index = 0,
198 .addr = 0x50021000,
199 .ppc = NO_PPC,
200 .irq = NO_IRQ,
201 },
202 {
203 .name = NULL,
204 }
205 };
206
207 static const ARMSSEDeviceInfo sse200_devices[] = {
208 {
209 .name = "timer0",
210 .type = TYPE_CMSDK_APB_TIMER,
211 .index = 0,
212 .addr = 0x40000000,
213 .ppc = 0,
214 .ppc_port = 0,
215 .irq = 3,
216 },
217 {
218 .name = "timer1",
219 .type = TYPE_CMSDK_APB_TIMER,
220 .index = 1,
221 .addr = 0x40001000,
222 .ppc = 0,
223 .ppc_port = 1,
224 .irq = 4,
225 },
226 {
227 .name = "s32ktimer",
228 .type = TYPE_CMSDK_APB_TIMER,
229 .index = 2,
230 .addr = 0x4002f000,
231 .ppc = 1,
232 .ppc_port = 0,
233 .irq = 2,
234 .slowclk = true,
235 },
236 {
237 .name = "dualtimer",
238 .type = TYPE_CMSDK_APB_DUALTIMER,
239 .index = 0,
240 .addr = 0x40002000,
241 .ppc = 0,
242 .ppc_port = 2,
243 .irq = 5,
244 },
245 {
246 .name = "s32kwatchdog",
247 .type = TYPE_CMSDK_APB_WATCHDOG,
248 .index = 0,
249 .addr = 0x5002e000,
250 .ppc = NO_PPC,
251 .irq = NMI_0,
252 .slowclk = true,
253 },
254 {
255 .name = "nswatchdog",
256 .type = TYPE_CMSDK_APB_WATCHDOG,
257 .index = 1,
258 .addr = 0x40081000,
259 .ppc = NO_PPC,
260 .irq = 1,
261 },
262 {
263 .name = "swatchdog",
264 .type = TYPE_CMSDK_APB_WATCHDOG,
265 .index = 2,
266 .addr = 0x50081000,
267 .ppc = NO_PPC,
268 .irq = NMI_1,
269 },
270 {
271 .name = "armsse-sysinfo",
272 .type = TYPE_IOTKIT_SYSINFO,
273 .index = 0,
274 .addr = 0x40020000,
275 .ppc = NO_PPC,
276 .irq = NO_IRQ,
277 },
278 {
279 .name = "armsse-sysctl",
280 .type = TYPE_IOTKIT_SYSCTL,
281 .index = 0,
282 .addr = 0x50021000,
283 .ppc = NO_PPC,
284 .irq = NO_IRQ,
285 },
286 {
287 .name = "CPU0CORE_PPU",
288 .type = TYPE_UNIMPLEMENTED_DEVICE,
289 .index = 0,
290 .addr = 0x50023000,
291 .size = 0x1000,
292 .ppc = NO_PPC,
293 .irq = NO_IRQ,
294 },
295 {
296 .name = "CPU1CORE_PPU",
297 .type = TYPE_UNIMPLEMENTED_DEVICE,
298 .index = 1,
299 .addr = 0x50025000,
300 .size = 0x1000,
301 .ppc = NO_PPC,
302 .irq = NO_IRQ,
303 },
304 {
305 .name = "DBG_PPU",
306 .type = TYPE_UNIMPLEMENTED_DEVICE,
307 .index = 2,
308 .addr = 0x50029000,
309 .size = 0x1000,
310 .ppc = NO_PPC,
311 .irq = NO_IRQ,
312 },
313 {
314 .name = "RAM0_PPU",
315 .type = TYPE_UNIMPLEMENTED_DEVICE,
316 .index = 3,
317 .addr = 0x5002a000,
318 .size = 0x1000,
319 .ppc = NO_PPC,
320 .irq = NO_IRQ,
321 },
322 {
323 .name = "RAM1_PPU",
324 .type = TYPE_UNIMPLEMENTED_DEVICE,
325 .index = 4,
326 .addr = 0x5002b000,
327 .size = 0x1000,
328 .ppc = NO_PPC,
329 .irq = NO_IRQ,
330 },
331 {
332 .name = "RAM2_PPU",
333 .type = TYPE_UNIMPLEMENTED_DEVICE,
334 .index = 5,
335 .addr = 0x5002c000,
336 .size = 0x1000,
337 .ppc = NO_PPC,
338 .irq = NO_IRQ,
339 },
340 {
341 .name = "RAM3_PPU",
342 .type = TYPE_UNIMPLEMENTED_DEVICE,
343 .index = 6,
344 .addr = 0x5002d000,
345 .size = 0x1000,
346 .ppc = NO_PPC,
347 .irq = NO_IRQ,
348 },
349 {
350 .name = "SYS_PPU",
351 .type = TYPE_UNIMPLEMENTED_DEVICE,
352 .index = 7,
353 .addr = 0x50022000,
354 .size = 0x1000,
355 .ppc = NO_PPC,
356 .irq = NO_IRQ,
357 },
358 {
359 .name = NULL,
360 }
361 };
362
363 static const ARMSSEDeviceInfo sse300_devices[] = {
364 {
365 .name = "timer0",
366 .type = TYPE_SSE_TIMER,
367 .index = 0,
368 .addr = 0x48000000,
369 .ppc = 0,
370 .ppc_port = 0,
371 .irq = 3,
372 },
373 {
374 .name = "timer1",
375 .type = TYPE_SSE_TIMER,
376 .index = 1,
377 .addr = 0x48001000,
378 .ppc = 0,
379 .ppc_port = 1,
380 .irq = 4,
381 },
382 {
383 .name = "timer2",
384 .type = TYPE_SSE_TIMER,
385 .index = 2,
386 .addr = 0x48002000,
387 .ppc = 0,
388 .ppc_port = 2,
389 .irq = 5,
390 },
391 {
392 .name = "timer3",
393 .type = TYPE_SSE_TIMER,
394 .index = 3,
395 .addr = 0x48003000,
396 .ppc = 0,
397 .ppc_port = 5,
398 .irq = 27,
399 },
400 {
401 .name = "s32ktimer",
402 .type = TYPE_CMSDK_APB_TIMER,
403 .index = 0,
404 .addr = 0x4802f000,
405 .ppc = 1,
406 .ppc_port = 0,
407 .irq = 2,
408 .slowclk = true,
409 },
410 {
411 .name = "s32kwatchdog",
412 .type = TYPE_CMSDK_APB_WATCHDOG,
413 .index = 0,
414 .addr = 0x4802e000,
415 .ppc = NO_PPC,
416 .irq = NMI_0,
417 .slowclk = true,
418 },
419 {
420 .name = "watchdog",
421 .type = TYPE_UNIMPLEMENTED_DEVICE,
422 .index = 0,
423 .addr = 0x48040000,
424 .size = 0x2000,
425 .ppc = NO_PPC,
426 .irq = NO_IRQ,
427 },
428 {
429 .name = "armsse-sysinfo",
430 .type = TYPE_IOTKIT_SYSINFO,
431 .index = 0,
432 .addr = 0x48020000,
433 .ppc = NO_PPC,
434 .irq = NO_IRQ,
435 },
436 {
437 .name = "armsse-sysctl",
438 .type = TYPE_IOTKIT_SYSCTL,
439 .index = 0,
440 .addr = 0x58021000,
441 .ppc = NO_PPC,
442 .irq = NO_IRQ,
443 },
444 {
445 .name = "SYS_PPU",
446 .type = TYPE_UNIMPLEMENTED_DEVICE,
447 .index = 1,
448 .addr = 0x58022000,
449 .size = 0x1000,
450 .ppc = NO_PPC,
451 .irq = NO_IRQ,
452 },
453 {
454 .name = "CPU0CORE_PPU",
455 .type = TYPE_UNIMPLEMENTED_DEVICE,
456 .index = 2,
457 .addr = 0x50023000,
458 .size = 0x1000,
459 .ppc = NO_PPC,
460 .irq = NO_IRQ,
461 },
462 {
463 .name = "MGMT_PPU",
464 .type = TYPE_UNIMPLEMENTED_DEVICE,
465 .index = 3,
466 .addr = 0x50028000,
467 .size = 0x1000,
468 .ppc = NO_PPC,
469 .irq = NO_IRQ,
470 },
471 {
472 .name = "DEBUG_PPU",
473 .type = TYPE_UNIMPLEMENTED_DEVICE,
474 .index = 4,
475 .addr = 0x50029000,
476 .size = 0x1000,
477 .ppc = NO_PPC,
478 .irq = NO_IRQ,
479 },
480 {
481 .name = NULL,
482 }
483 };
484
485 /* Is internal IRQ n shared between CPUs in a multi-core SSE ? */
486 static const bool sse200_irq_is_common[32] = {
487 [0 ... 5] = true,
488 /* 6, 7: per-CPU MHU interrupts */
489 [8 ... 12] = true,
490 /* 13: per-CPU icache interrupt */
491 /* 14: reserved */
492 [15 ... 20] = true,
493 /* 21: reserved */
494 [22 ... 26] = true,
495 /* 27: reserved */
496 /* 28, 29: per-CPU CTI interrupts */
497 /* 30, 31: reserved */
498 };
499
500 static const bool sse300_irq_is_common[32] = {
501 [0 ... 5] = true,
502 /* 6, 7: per-CPU MHU interrupts */
503 [8 ... 12] = true,
504 /* 13: reserved */
505 [14 ... 16] = true,
506 /* 17-25: reserved */
507 [26 ... 27] = true,
508 /* 28, 29: per-CPU CTI interrupts */
509 /* 30, 31: reserved */
510 };
511
512 static const ARMSSEInfo armsse_variants[] = {
513 {
514 .name = TYPE_IOTKIT,
515 .sse_version = ARMSSE_IOTKIT,
516 .cpu_type = ARM_CPU_TYPE_NAME("cortex-m33"),
517 .sram_banks = 1,
518 .sram_bank_base = 0x20000000,
519 .num_cpus = 1,
520 .sys_version = 0x41743,
521 .iidr = 0,
522 .cpuwait_rst = 0,
523 .has_mhus = false,
524 .has_cachectrl = false,
525 .has_cpusecctrl = false,
526 .has_cpuid = false,
527 .has_cpu_pwrctrl = false,
528 .has_sse_counter = false,
529 .has_tcms = false,
530 .props = iotkit_properties,
531 .devinfo = iotkit_devices,
532 .irq_is_common = sse200_irq_is_common,
533 },
534 {
535 .name = TYPE_SSE200,
536 .sse_version = ARMSSE_SSE200,
537 .cpu_type = ARM_CPU_TYPE_NAME("cortex-m33"),
538 .sram_banks = 4,
539 .sram_bank_base = 0x20000000,
540 .num_cpus = 2,
541 .sys_version = 0x22041743,
542 .iidr = 0,
543 .cpuwait_rst = 2,
544 .has_mhus = true,
545 .has_cachectrl = true,
546 .has_cpusecctrl = true,
547 .has_cpuid = true,
548 .has_cpu_pwrctrl = false,
549 .has_sse_counter = false,
550 .has_tcms = false,
551 .props = sse200_properties,
552 .devinfo = sse200_devices,
553 .irq_is_common = sse200_irq_is_common,
554 },
555 {
556 .name = TYPE_SSE300,
557 .sse_version = ARMSSE_SSE300,
558 .cpu_type = ARM_CPU_TYPE_NAME("cortex-m55"),
559 .sram_banks = 2,
560 .sram_bank_base = 0x21000000,
561 .num_cpus = 1,
562 .sys_version = 0x7e00043b,
563 .iidr = 0x74a0043b,
564 .cpuwait_rst = 0,
565 .has_mhus = false,
566 .has_cachectrl = false,
567 .has_cpusecctrl = true,
568 .has_cpuid = true,
569 .has_cpu_pwrctrl = true,
570 .has_sse_counter = true,
571 .has_tcms = true,
572 .props = sse300_properties,
573 .devinfo = sse300_devices,
574 .irq_is_common = sse300_irq_is_common,
575 },
576 };
577
578 static uint32_t armsse_sys_config_value(ARMSSE *s, const ARMSSEInfo *info)
579 {
580 /* Return the SYS_CONFIG value for this SSE */
581 uint32_t sys_config;
582
583 switch (info->sse_version) {
584 case ARMSSE_IOTKIT:
585 sys_config = 0;
586 sys_config = deposit32(sys_config, 0, 4, info->sram_banks);
587 sys_config = deposit32(sys_config, 4, 4, s->sram_addr_width - 12);
588 break;
589 case ARMSSE_SSE200:
590 sys_config = 0;
591 sys_config = deposit32(sys_config, 0, 4, info->sram_banks);
592 sys_config = deposit32(sys_config, 4, 5, s->sram_addr_width);
593 sys_config = deposit32(sys_config, 24, 4, 2);
594 if (info->num_cpus > 1) {
595 sys_config = deposit32(sys_config, 10, 1, 1);
596 sys_config = deposit32(sys_config, 20, 4, info->sram_banks - 1);
597 sys_config = deposit32(sys_config, 28, 4, 2);
598 }
599 break;
600 case ARMSSE_SSE300:
601 sys_config = 0;
602 sys_config = deposit32(sys_config, 0, 4, info->sram_banks);
603 sys_config = deposit32(sys_config, 4, 5, s->sram_addr_width);
604 sys_config = deposit32(sys_config, 16, 3, 3); /* CPU0 = Cortex-M55 */
605 break;
606 default:
607 g_assert_not_reached();
608 }
609 return sys_config;
610 }
611
612 /* Clock frequency in HZ of the 32KHz "slow clock" */
613 #define S32KCLK (32 * 1000)
614
615 /*
616 * Create an alias region in @container of @size bytes starting at @base
617 * which mirrors the memory starting at @orig.
618 */
619 static void make_alias(ARMSSE *s, MemoryRegion *mr, MemoryRegion *container,
620 const char *name, hwaddr base, hwaddr size, hwaddr orig)
621 {
622 memory_region_init_alias(mr, NULL, name, container, orig, size);
623 /* The alias is even lower priority than unimplemented_device regions */
624 memory_region_add_subregion_overlap(container, base, mr, -1500);
625 }
626
627 static void irq_status_forwarder(void *opaque, int n, int level)
628 {
629 qemu_irq destirq = opaque;
630
631 qemu_set_irq(destirq, level);
632 }
633
634 static void nsccfg_handler(void *opaque, int n, int level)
635 {
636 ARMSSE *s = ARM_SSE(opaque);
637
638 s->nsccfg = level;
639 }
640
641 static void armsse_forward_ppc(ARMSSE *s, const char *ppcname, int ppcnum)
642 {
643 /* Each of the 4 AHB and 4 APB PPCs that might be present in a
644 * system using the ARMSSE has a collection of control lines which
645 * are provided by the security controller and which we want to
646 * expose as control lines on the ARMSSE device itself, so the
647 * code using the ARMSSE can wire them up to the PPCs.
648 */
649 SplitIRQ *splitter = &s->ppc_irq_splitter[ppcnum];
650 DeviceState *armssedev = DEVICE(s);
651 DeviceState *dev_secctl = DEVICE(&s->secctl);
652 DeviceState *dev_splitter = DEVICE(splitter);
653 char *name;
654
655 name = g_strdup_printf("%s_nonsec", ppcname);
656 qdev_pass_gpios(dev_secctl, armssedev, name);
657 g_free(name);
658 name = g_strdup_printf("%s_ap", ppcname);
659 qdev_pass_gpios(dev_secctl, armssedev, name);
660 g_free(name);
661 name = g_strdup_printf("%s_irq_enable", ppcname);
662 qdev_pass_gpios(dev_secctl, armssedev, name);
663 g_free(name);
664 name = g_strdup_printf("%s_irq_clear", ppcname);
665 qdev_pass_gpios(dev_secctl, armssedev, name);
666 g_free(name);
667
668 /* irq_status is a little more tricky, because we need to
669 * split it so we can send it both to the security controller
670 * and to our OR gate for the NVIC interrupt line.
671 * Connect up the splitter's outputs, and create a GPIO input
672 * which will pass the line state to the input splitter.
673 */
674 name = g_strdup_printf("%s_irq_status", ppcname);
675 qdev_connect_gpio_out(dev_splitter, 0,
676 qdev_get_gpio_in_named(dev_secctl,
677 name, 0));
678 qdev_connect_gpio_out(dev_splitter, 1,
679 qdev_get_gpio_in(DEVICE(&s->ppc_irq_orgate), ppcnum));
680 s->irq_status_in[ppcnum] = qdev_get_gpio_in(dev_splitter, 0);
681 qdev_init_gpio_in_named_with_opaque(armssedev, irq_status_forwarder,
682 s->irq_status_in[ppcnum], name, 1);
683 g_free(name);
684 }
685
686 static void armsse_forward_sec_resp_cfg(ARMSSE *s)
687 {
688 /* Forward the 3rd output from the splitter device as a
689 * named GPIO output of the armsse object.
690 */
691 DeviceState *dev = DEVICE(s);
692 DeviceState *dev_splitter = DEVICE(&s->sec_resp_splitter);
693
694 qdev_init_gpio_out_named(dev, &s->sec_resp_cfg, "sec_resp_cfg", 1);
695 s->sec_resp_cfg_in = qemu_allocate_irq(irq_status_forwarder,
696 s->sec_resp_cfg, 1);
697 qdev_connect_gpio_out(dev_splitter, 2, s->sec_resp_cfg_in);
698 }
699
700 static void armsse_init(Object *obj)
701 {
702 ARMSSE *s = ARM_SSE(obj);
703 ARMSSEClass *asc = ARM_SSE_GET_CLASS(obj);
704 const ARMSSEInfo *info = asc->info;
705 const ARMSSEDeviceInfo *devinfo;
706 int i;
707
708 assert(info->sram_banks <= MAX_SRAM_BANKS);
709 assert(info->num_cpus <= SSE_MAX_CPUS);
710
711 s->mainclk = qdev_init_clock_in(DEVICE(s), "MAINCLK", NULL, NULL, 0);
712 s->s32kclk = qdev_init_clock_in(DEVICE(s), "S32KCLK", NULL, NULL, 0);
713
714 memory_region_init(&s->container, obj, "armsse-container", UINT64_MAX);
715
716 for (i = 0; i < info->num_cpus; i++) {
717 /*
718 * We put each CPU in its own cluster as they are logically
719 * distinct and may be configured differently.
720 */
721 char *name;
722
723 name = g_strdup_printf("cluster%d", i);
724 object_initialize_child(obj, name, &s->cluster[i], TYPE_CPU_CLUSTER);
725 qdev_prop_set_uint32(DEVICE(&s->cluster[i]), "cluster-id", i);
726 g_free(name);
727
728 name = g_strdup_printf("armv7m%d", i);
729 object_initialize_child(OBJECT(&s->cluster[i]), name, &s->armv7m[i],
730 TYPE_ARMV7M);
731 qdev_prop_set_string(DEVICE(&s->armv7m[i]), "cpu-type", info->cpu_type);
732 g_free(name);
733 name = g_strdup_printf("arm-sse-cpu-container%d", i);
734 memory_region_init(&s->cpu_container[i], obj, name, UINT64_MAX);
735 g_free(name);
736 if (i > 0) {
737 name = g_strdup_printf("arm-sse-container-alias%d", i);
738 memory_region_init_alias(&s->container_alias[i - 1], obj,
739 name, &s->container, 0, UINT64_MAX);
740 g_free(name);
741 }
742 }
743
744 for (devinfo = info->devinfo; devinfo->name; devinfo++) {
745 assert(devinfo->ppc == NO_PPC || devinfo->ppc < ARRAY_SIZE(s->apb_ppc));
746 if (!strcmp(devinfo->type, TYPE_CMSDK_APB_TIMER)) {
747 assert(devinfo->index < ARRAY_SIZE(s->timer));
748 object_initialize_child(obj, devinfo->name,
749 &s->timer[devinfo->index],
750 TYPE_CMSDK_APB_TIMER);
751 } else if (!strcmp(devinfo->type, TYPE_CMSDK_APB_DUALTIMER)) {
752 assert(devinfo->index == 0);
753 object_initialize_child(obj, devinfo->name, &s->dualtimer,
754 TYPE_CMSDK_APB_DUALTIMER);
755 } else if (!strcmp(devinfo->type, TYPE_SSE_TIMER)) {
756 assert(devinfo->index < ARRAY_SIZE(s->sse_timer));
757 object_initialize_child(obj, devinfo->name,
758 &s->sse_timer[devinfo->index],
759 TYPE_SSE_TIMER);
760 } else if (!strcmp(devinfo->type, TYPE_CMSDK_APB_WATCHDOG)) {
761 assert(devinfo->index < ARRAY_SIZE(s->cmsdk_watchdog));
762 object_initialize_child(obj, devinfo->name,
763 &s->cmsdk_watchdog[devinfo->index],
764 TYPE_CMSDK_APB_WATCHDOG);
765 } else if (!strcmp(devinfo->type, TYPE_IOTKIT_SYSINFO)) {
766 assert(devinfo->index == 0);
767 object_initialize_child(obj, devinfo->name, &s->sysinfo,
768 TYPE_IOTKIT_SYSINFO);
769 } else if (!strcmp(devinfo->type, TYPE_IOTKIT_SYSCTL)) {
770 assert(devinfo->index == 0);
771 object_initialize_child(obj, devinfo->name, &s->sysctl,
772 TYPE_IOTKIT_SYSCTL);
773 } else if (!strcmp(devinfo->type, TYPE_UNIMPLEMENTED_DEVICE)) {
774 assert(devinfo->index < ARRAY_SIZE(s->unimp));
775 object_initialize_child(obj, devinfo->name,
776 &s->unimp[devinfo->index],
777 TYPE_UNIMPLEMENTED_DEVICE);
778 } else {
779 g_assert_not_reached();
780 }
781 }
782
783 object_initialize_child(obj, "secctl", &s->secctl, TYPE_IOTKIT_SECCTL);
784
785 for (i = 0; i < ARRAY_SIZE(s->apb_ppc); i++) {
786 g_autofree char *name = g_strdup_printf("apb-ppc%d", i);
787 object_initialize_child(obj, name, &s->apb_ppc[i], TYPE_TZ_PPC);
788 }
789
790 for (i = 0; i < info->sram_banks; i++) {
791 char *name = g_strdup_printf("mpc%d", i);
792 object_initialize_child(obj, name, &s->mpc[i], TYPE_TZ_MPC);
793 g_free(name);
794 }
795 object_initialize_child(obj, "mpc-irq-orgate", &s->mpc_irq_orgate,
796 TYPE_OR_IRQ);
797
798 for (i = 0; i < IOTS_NUM_EXP_MPC + info->sram_banks; i++) {
799 char *name = g_strdup_printf("mpc-irq-splitter-%d", i);
800 SplitIRQ *splitter = &s->mpc_irq_splitter[i];
801
802 object_initialize_child(obj, name, splitter, TYPE_SPLIT_IRQ);
803 g_free(name);
804 }
805
806 if (info->has_mhus) {
807 object_initialize_child(obj, "mhu0", &s->mhu[0], TYPE_ARMSSE_MHU);
808 object_initialize_child(obj, "mhu1", &s->mhu[1], TYPE_ARMSSE_MHU);
809 }
810 if (info->has_cachectrl) {
811 for (i = 0; i < info->num_cpus; i++) {
812 char *name = g_strdup_printf("cachectrl%d", i);
813
814 object_initialize_child(obj, name, &s->cachectrl[i],
815 TYPE_UNIMPLEMENTED_DEVICE);
816 g_free(name);
817 }
818 }
819 if (info->has_cpusecctrl) {
820 for (i = 0; i < info->num_cpus; i++) {
821 char *name = g_strdup_printf("cpusecctrl%d", i);
822
823 object_initialize_child(obj, name, &s->cpusecctrl[i],
824 TYPE_UNIMPLEMENTED_DEVICE);
825 g_free(name);
826 }
827 }
828 if (info->has_cpuid) {
829 for (i = 0; i < info->num_cpus; i++) {
830 char *name = g_strdup_printf("cpuid%d", i);
831
832 object_initialize_child(obj, name, &s->cpuid[i],
833 TYPE_ARMSSE_CPUID);
834 g_free(name);
835 }
836 }
837 if (info->has_cpu_pwrctrl) {
838 for (i = 0; i < info->num_cpus; i++) {
839 char *name = g_strdup_printf("cpu_pwrctrl%d", i);
840
841 object_initialize_child(obj, name, &s->cpu_pwrctrl[i],
842 TYPE_ARMSSE_CPU_PWRCTRL);
843 g_free(name);
844 }
845 }
846 if (info->has_sse_counter) {
847 object_initialize_child(obj, "sse-counter", &s->sse_counter,
848 TYPE_SSE_COUNTER);
849 }
850
851 object_initialize_child(obj, "nmi-orgate", &s->nmi_orgate, TYPE_OR_IRQ);
852 object_initialize_child(obj, "ppc-irq-orgate", &s->ppc_irq_orgate,
853 TYPE_OR_IRQ);
854 object_initialize_child(obj, "sec-resp-splitter", &s->sec_resp_splitter,
855 TYPE_SPLIT_IRQ);
856 for (i = 0; i < ARRAY_SIZE(s->ppc_irq_splitter); i++) {
857 char *name = g_strdup_printf("ppc-irq-splitter-%d", i);
858 SplitIRQ *splitter = &s->ppc_irq_splitter[i];
859
860 object_initialize_child(obj, name, splitter, TYPE_SPLIT_IRQ);
861 g_free(name);
862 }
863 if (info->num_cpus > 1) {
864 for (i = 0; i < ARRAY_SIZE(s->cpu_irq_splitter); i++) {
865 if (info->irq_is_common[i]) {
866 char *name = g_strdup_printf("cpu-irq-splitter%d", i);
867 SplitIRQ *splitter = &s->cpu_irq_splitter[i];
868
869 object_initialize_child(obj, name, splitter, TYPE_SPLIT_IRQ);
870 g_free(name);
871 }
872 }
873 }
874 }
875
876 static void armsse_exp_irq(void *opaque, int n, int level)
877 {
878 qemu_irq *irqarray = opaque;
879
880 qemu_set_irq(irqarray[n], level);
881 }
882
883 static void armsse_mpcexp_status(void *opaque, int n, int level)
884 {
885 ARMSSE *s = ARM_SSE(opaque);
886 qemu_set_irq(s->mpcexp_status_in[n], level);
887 }
888
889 static qemu_irq armsse_get_common_irq_in(ARMSSE *s, int irqno)
890 {
891 /*
892 * Return a qemu_irq which can be used to signal IRQ n to
893 * all CPUs in the SSE.
894 */
895 ARMSSEClass *asc = ARM_SSE_GET_CLASS(s);
896 const ARMSSEInfo *info = asc->info;
897
898 assert(info->irq_is_common[irqno]);
899
900 if (info->num_cpus == 1) {
901 /* Only one CPU -- just connect directly to it */
902 return qdev_get_gpio_in(DEVICE(&s->armv7m[0]), irqno);
903 } else {
904 /* Connect to the splitter which feeds all CPUs */
905 return qdev_get_gpio_in(DEVICE(&s->cpu_irq_splitter[irqno]), 0);
906 }
907 }
908
909 static void armsse_realize(DeviceState *dev, Error **errp)
910 {
911 ERRP_GUARD();
912 ARMSSE *s = ARM_SSE(dev);
913 ARMSSEClass *asc = ARM_SSE_GET_CLASS(dev);
914 const ARMSSEInfo *info = asc->info;
915 const ARMSSEDeviceInfo *devinfo;
916 int i;
917 MemoryRegion *mr;
918 SysBusDevice *sbd_apb_ppc0;
919 SysBusDevice *sbd_secctl;
920 DeviceState *dev_apb_ppc0;
921 DeviceState *dev_apb_ppc1;
922 DeviceState *dev_secctl;
923 DeviceState *dev_splitter;
924 uint32_t addr_width_max;
925
926 if (!s->board_memory) {
927 error_setg(errp, "memory property was not set");
928 return;
929 }
930
931 if (!clock_has_source(s->mainclk)) {
932 error_setg(errp, "MAINCLK clock was not connected");
933 }
934 if (!clock_has_source(s->s32kclk)) {
935 error_setg(errp, "S32KCLK clock was not connected");
936 }
937
938 assert(info->num_cpus <= SSE_MAX_CPUS);
939
940 /* max SRAM_ADDR_WIDTH: 24 - log2(SRAM_NUM_BANK) */
941 assert(is_power_of_2(info->sram_banks));
942 addr_width_max = 24 - ctz32(info->sram_banks);
943 if (s->sram_addr_width < 1 || s->sram_addr_width > addr_width_max) {
944 error_setg(errp, "SRAM_ADDR_WIDTH must be between 1 and %d",
945 addr_width_max);
946 return;
947 }
948
949 /* Handling of which devices should be available only to secure
950 * code is usually done differently for M profile than for A profile.
951 * Instead of putting some devices only into the secure address space,
952 * devices exist in both address spaces but with hard-wired security
953 * permissions that will cause the CPU to fault for non-secure accesses.
954 *
955 * The ARMSSE has an IDAU (Implementation Defined Access Unit),
956 * which specifies hard-wired security permissions for different
957 * areas of the physical address space. For the ARMSSE IDAU, the
958 * top 4 bits of the physical address are the IDAU region ID, and
959 * if bit 28 (ie the lowest bit of the ID) is 0 then this is an NS
960 * region, otherwise it is an S region.
961 *
962 * The various devices and RAMs are generally all mapped twice,
963 * once into a region that the IDAU defines as secure and once
964 * into a non-secure region. They sit behind either a Memory
965 * Protection Controller (for RAM) or a Peripheral Protection
966 * Controller (for devices), which allow a more fine grained
967 * configuration of whether non-secure accesses are permitted.
968 *
969 * (The other place that guest software can configure security
970 * permissions is in the architected SAU (Security Attribution
971 * Unit), which is entirely inside the CPU. The IDAU can upgrade
972 * the security attributes for a region to more restrictive than
973 * the SAU specifies, but cannot downgrade them.)
974 *
975 * 0x10000000..0x1fffffff alias of 0x00000000..0x0fffffff
976 * 0x20000000..0x2007ffff 32KB FPGA block RAM
977 * 0x30000000..0x3fffffff alias of 0x20000000..0x2fffffff
978 * 0x40000000..0x4000ffff base peripheral region 1
979 * 0x40010000..0x4001ffff CPU peripherals (none for ARMSSE)
980 * 0x40020000..0x4002ffff system control element peripherals
981 * 0x40080000..0x400fffff base peripheral region 2
982 * 0x50000000..0x5fffffff alias of 0x40000000..0x4fffffff
983 */
984
985 memory_region_add_subregion_overlap(&s->container, 0, s->board_memory, -2);
986
987 for (i = 0; i < info->num_cpus; i++) {
988 DeviceState *cpudev = DEVICE(&s->armv7m[i]);
989 Object *cpuobj = OBJECT(&s->armv7m[i]);
990 int j;
991 char *gpioname;
992
993 qdev_connect_clock_in(cpudev, "cpuclk", s->mainclk);
994 /* The SSE subsystems do not wire up a systick refclk */
995
996 qdev_prop_set_uint32(cpudev, "num-irq", s->exp_numirq + NUM_SSE_IRQS);
997 /*
998 * In real hardware the initial Secure VTOR is set from the INITSVTOR*
999 * registers in the IoT Kit System Control Register block. In QEMU
1000 * we set the initial value here, and also the reset value of the
1001 * sysctl register, from this object's QOM init-svtor property.
1002 * If the guest changes the INITSVTOR* registers at runtime then the
1003 * code in iotkit-sysctl.c will update the CPU init-svtor property
1004 * (which will then take effect on the next CPU warm-reset).
1005 *
1006 * Note that typically a board using the SSE-200 will have a system
1007 * control processor whose boot firmware initializes the INITSVTOR*
1008 * registers before powering up the CPUs. QEMU doesn't emulate
1009 * the control processor, so instead we behave in the way that the
1010 * firmware does: the initial value should be set by the board code
1011 * (using the init-svtor property on the ARMSSE object) to match
1012 * whatever its firmware does.
1013 */
1014 qdev_prop_set_uint32(cpudev, "init-svtor", s->init_svtor);
1015 /*
1016 * CPUs start powered down if the corresponding bit in the CPUWAIT
1017 * register is 1. In real hardware the CPUWAIT register reset value is
1018 * a configurable property of the SSE-200 (via the CPUWAIT0_RST and
1019 * CPUWAIT1_RST parameters), but since all the boards we care about
1020 * start CPU0 and leave CPU1 powered off, we hard-code that in
1021 * info->cpuwait_rst for now. We can add QOM properties for this
1022 * later if necessary.
1023 */
1024 if (extract32(info->cpuwait_rst, i, 1)) {
1025 if (!object_property_set_bool(cpuobj, "start-powered-off", true,
1026 errp)) {
1027 return;
1028 }
1029 }
1030 if (!s->cpu_fpu[i]) {
1031 if (!object_property_set_bool(cpuobj, "vfp", false, errp)) {
1032 return;
1033 }
1034 }
1035 if (!s->cpu_dsp[i]) {
1036 if (!object_property_set_bool(cpuobj, "dsp", false, errp)) {
1037 return;
1038 }
1039 }
1040 if (!object_property_set_uint(cpuobj, "mpu-ns-regions",
1041 s->cpu_mpu_ns[i], errp)) {
1042 return;
1043 }
1044 if (!object_property_set_uint(cpuobj, "mpu-s-regions",
1045 s->cpu_mpu_s[i], errp)) {
1046 return;
1047 }
1048
1049 if (i > 0) {
1050 memory_region_add_subregion_overlap(&s->cpu_container[i], 0,
1051 &s->container_alias[i - 1], -1);
1052 } else {
1053 memory_region_add_subregion_overlap(&s->cpu_container[i], 0,
1054 &s->container, -1);
1055 }
1056 object_property_set_link(cpuobj, "memory",
1057 OBJECT(&s->cpu_container[i]), &error_abort);
1058 object_property_set_link(cpuobj, "idau", OBJECT(s), &error_abort);
1059 if (!sysbus_realize(SYS_BUS_DEVICE(cpuobj), errp)) {
1060 return;
1061 }
1062 /*
1063 * The cluster must be realized after the armv7m container, as
1064 * the container's CPU object is only created on realize, and the
1065 * CPU must exist and have been parented into the cluster before
1066 * the cluster is realized.
1067 */
1068 if (!qdev_realize(DEVICE(&s->cluster[i]), NULL, errp)) {
1069 return;
1070 }
1071
1072 /* Connect EXP_IRQ/EXP_CPUn_IRQ GPIOs to the NVIC's lines 32 and up */
1073 s->exp_irqs[i] = g_new(qemu_irq, s->exp_numirq);
1074 for (j = 0; j < s->exp_numirq; j++) {
1075 s->exp_irqs[i][j] = qdev_get_gpio_in(cpudev, j + NUM_SSE_IRQS);
1076 }
1077 if (i == 0) {
1078 gpioname = g_strdup("EXP_IRQ");
1079 } else {
1080 gpioname = g_strdup_printf("EXP_CPU%d_IRQ", i);
1081 }
1082 qdev_init_gpio_in_named_with_opaque(dev, armsse_exp_irq,
1083 s->exp_irqs[i],
1084 gpioname, s->exp_numirq);
1085 g_free(gpioname);
1086 }
1087
1088 /* Wire up the splitters that connect common IRQs to all CPUs */
1089 if (info->num_cpus > 1) {
1090 for (i = 0; i < ARRAY_SIZE(s->cpu_irq_splitter); i++) {
1091 if (info->irq_is_common[i]) {
1092 Object *splitter = OBJECT(&s->cpu_irq_splitter[i]);
1093 DeviceState *devs = DEVICE(splitter);
1094 int cpunum;
1095
1096 if (!object_property_set_int(splitter, "num-lines",
1097 info->num_cpus, errp)) {
1098 return;
1099 }
1100 if (!qdev_realize(DEVICE(splitter), NULL, errp)) {
1101 return;
1102 }
1103 for (cpunum = 0; cpunum < info->num_cpus; cpunum++) {
1104 DeviceState *cpudev = DEVICE(&s->armv7m[cpunum]);
1105
1106 qdev_connect_gpio_out(devs, cpunum,
1107 qdev_get_gpio_in(cpudev, i));
1108 }
1109 }
1110 }
1111 }
1112
1113 /* Set up the big aliases first */
1114 make_alias(s, &s->alias1, &s->container, "alias 1",
1115 0x10000000, 0x10000000, 0x00000000);
1116 make_alias(s, &s->alias2, &s->container,
1117 "alias 2", 0x30000000, 0x10000000, 0x20000000);
1118 /* The 0x50000000..0x5fffffff region is not a pure alias: it has
1119 * a few extra devices that only appear there (generally the
1120 * control interfaces for the protection controllers).
1121 * We implement this by mapping those devices over the top of this
1122 * alias MR at a higher priority. Some of the devices in this range
1123 * are per-CPU, so we must put this alias in the per-cpu containers.
1124 */
1125 for (i = 0; i < info->num_cpus; i++) {
1126 make_alias(s, &s->alias3[i], &s->cpu_container[i],
1127 "alias 3", 0x50000000, 0x10000000, 0x40000000);
1128 }
1129
1130 /* Security controller */
1131 object_property_set_int(OBJECT(&s->secctl), "sse-version",
1132 info->sse_version, &error_abort);
1133 if (!sysbus_realize(SYS_BUS_DEVICE(&s->secctl), errp)) {
1134 return;
1135 }
1136 sbd_secctl = SYS_BUS_DEVICE(&s->secctl);
1137 dev_secctl = DEVICE(&s->secctl);
1138 sysbus_mmio_map(sbd_secctl, 0, 0x50080000);
1139 sysbus_mmio_map(sbd_secctl, 1, 0x40080000);
1140
1141 s->nsc_cfg_in = qemu_allocate_irq(nsccfg_handler, s, 1);
1142 qdev_connect_gpio_out_named(dev_secctl, "nsc_cfg", 0, s->nsc_cfg_in);
1143
1144 /* The sec_resp_cfg output from the security controller must be split into
1145 * multiple lines, one for each of the PPCs within the ARMSSE and one
1146 * that will be an output from the ARMSSE to the system.
1147 */
1148 if (!object_property_set_int(OBJECT(&s->sec_resp_splitter),
1149 "num-lines", 3, errp)) {
1150 return;
1151 }
1152 if (!qdev_realize(DEVICE(&s->sec_resp_splitter), NULL, errp)) {
1153 return;
1154 }
1155 dev_splitter = DEVICE(&s->sec_resp_splitter);
1156 qdev_connect_gpio_out_named(dev_secctl, "sec_resp_cfg", 0,
1157 qdev_get_gpio_in(dev_splitter, 0));
1158
1159 /* Each SRAM bank lives behind its own Memory Protection Controller */
1160 for (i = 0; i < info->sram_banks; i++) {
1161 char *ramname = g_strdup_printf("armsse.sram%d", i);
1162 SysBusDevice *sbd_mpc;
1163 uint32_t sram_bank_size = 1 << s->sram_addr_width;
1164
1165 memory_region_init_ram(&s->sram[i], NULL, ramname,
1166 sram_bank_size, errp);
1167 g_free(ramname);
1168 if (*errp) {
1169 return;
1170 }
1171 object_property_set_link(OBJECT(&s->mpc[i]), "downstream",
1172 OBJECT(&s->sram[i]), &error_abort);
1173 if (!sysbus_realize(SYS_BUS_DEVICE(&s->mpc[i]), errp)) {
1174 return;
1175 }
1176 /* Map the upstream end of the MPC into the right place... */
1177 sbd_mpc = SYS_BUS_DEVICE(&s->mpc[i]);
1178 memory_region_add_subregion(&s->container,
1179 info->sram_bank_base + i * sram_bank_size,
1180 sysbus_mmio_get_region(sbd_mpc, 1));
1181 /* ...and its register interface */
1182 memory_region_add_subregion(&s->container, 0x50083000 + i * 0x1000,
1183 sysbus_mmio_get_region(sbd_mpc, 0));
1184 }
1185
1186 /* We must OR together lines from the MPC splitters to go to the NVIC */
1187 if (!object_property_set_int(OBJECT(&s->mpc_irq_orgate), "num-lines",
1188 IOTS_NUM_EXP_MPC + info->sram_banks,
1189 errp)) {
1190 return;
1191 }
1192 if (!qdev_realize(DEVICE(&s->mpc_irq_orgate), NULL, errp)) {
1193 return;
1194 }
1195 qdev_connect_gpio_out(DEVICE(&s->mpc_irq_orgate), 0,
1196 armsse_get_common_irq_in(s, 9));
1197
1198 /* This OR gate wires together outputs from the secure watchdogs to NMI */
1199 if (!object_property_set_int(OBJECT(&s->nmi_orgate), "num-lines", 2,
1200 errp)) {
1201 return;
1202 }
1203 if (!qdev_realize(DEVICE(&s->nmi_orgate), NULL, errp)) {
1204 return;
1205 }
1206 qdev_connect_gpio_out(DEVICE(&s->nmi_orgate), 0,
1207 qdev_get_gpio_in_named(DEVICE(&s->armv7m), "NMI", 0));
1208
1209 /* The SSE-300 has a System Counter / System Timestamp Generator */
1210 if (info->has_sse_counter) {
1211 SysBusDevice *sbd = SYS_BUS_DEVICE(&s->sse_counter);
1212
1213 qdev_connect_clock_in(DEVICE(sbd), "CLK", s->mainclk);
1214 if (!sysbus_realize(sbd, errp)) {
1215 return;
1216 }
1217 /*
1218 * The control frame is only in the Secure region;
1219 * the status frame is in the NS region (and visible in the
1220 * S region via the alias mapping).
1221 */
1222 memory_region_add_subregion(&s->container, 0x58100000,
1223 sysbus_mmio_get_region(sbd, 0));
1224 memory_region_add_subregion(&s->container, 0x48101000,
1225 sysbus_mmio_get_region(sbd, 1));
1226 }
1227
1228 if (info->has_tcms) {
1229 /* The SSE-300 has an ITCM at 0x0000_0000 and a DTCM at 0x2000_0000 */
1230 memory_region_init_ram(&s->itcm, NULL, "sse300-itcm", 512 * KiB, errp);
1231 if (*errp) {
1232 return;
1233 }
1234 memory_region_init_ram(&s->dtcm, NULL, "sse300-dtcm", 512 * KiB, errp);
1235 if (*errp) {
1236 return;
1237 }
1238 memory_region_add_subregion(&s->container, 0x00000000, &s->itcm);
1239 memory_region_add_subregion(&s->container, 0x20000000, &s->dtcm);
1240 }
1241
1242 /* Devices behind APB PPC0:
1243 * 0x40000000: timer0
1244 * 0x40001000: timer1
1245 * 0x40002000: dual timer
1246 * 0x40003000: MHU0 (SSE-200 only)
1247 * 0x40004000: MHU1 (SSE-200 only)
1248 * We must configure and realize each downstream device and connect
1249 * it to the appropriate PPC port; then we can realize the PPC and
1250 * map its upstream ends to the right place in the container.
1251 */
1252 for (devinfo = info->devinfo; devinfo->name; devinfo++) {
1253 SysBusDevice *sbd;
1254 qemu_irq irq;
1255
1256 if (!strcmp(devinfo->type, TYPE_CMSDK_APB_TIMER)) {
1257 sbd = SYS_BUS_DEVICE(&s->timer[devinfo->index]);
1258
1259 qdev_connect_clock_in(DEVICE(sbd), "pclk",
1260 devinfo->slowclk ? s->s32kclk : s->mainclk);
1261 if (!sysbus_realize(sbd, errp)) {
1262 return;
1263 }
1264 mr = sysbus_mmio_get_region(sbd, 0);
1265 } else if (!strcmp(devinfo->type, TYPE_CMSDK_APB_DUALTIMER)) {
1266 sbd = SYS_BUS_DEVICE(&s->dualtimer);
1267
1268 qdev_connect_clock_in(DEVICE(sbd), "TIMCLK", s->mainclk);
1269 if (!sysbus_realize(sbd, errp)) {
1270 return;
1271 }
1272 mr = sysbus_mmio_get_region(sbd, 0);
1273 } else if (!strcmp(devinfo->type, TYPE_SSE_TIMER)) {
1274 sbd = SYS_BUS_DEVICE(&s->sse_timer[devinfo->index]);
1275
1276 assert(info->has_sse_counter);
1277 object_property_set_link(OBJECT(sbd), "counter",
1278 OBJECT(&s->sse_counter), &error_abort);
1279 if (!sysbus_realize(sbd, errp)) {
1280 return;
1281 }
1282 mr = sysbus_mmio_get_region(sbd, 0);
1283 } else if (!strcmp(devinfo->type, TYPE_CMSDK_APB_WATCHDOG)) {
1284 sbd = SYS_BUS_DEVICE(&s->cmsdk_watchdog[devinfo->index]);
1285
1286 qdev_connect_clock_in(DEVICE(sbd), "WDOGCLK",
1287 devinfo->slowclk ? s->s32kclk : s->mainclk);
1288 if (!sysbus_realize(sbd, errp)) {
1289 return;
1290 }
1291 mr = sysbus_mmio_get_region(sbd, 0);
1292 } else if (!strcmp(devinfo->type, TYPE_IOTKIT_SYSINFO)) {
1293 sbd = SYS_BUS_DEVICE(&s->sysinfo);
1294
1295 object_property_set_int(OBJECT(&s->sysinfo), "SYS_VERSION",
1296 info->sys_version, &error_abort);
1297 object_property_set_int(OBJECT(&s->sysinfo), "SYS_CONFIG",
1298 armsse_sys_config_value(s, info),
1299 &error_abort);
1300 object_property_set_int(OBJECT(&s->sysinfo), "sse-version",
1301 info->sse_version, &error_abort);
1302 object_property_set_int(OBJECT(&s->sysinfo), "IIDR",
1303 info->iidr, &error_abort);
1304 if (!sysbus_realize(sbd, errp)) {
1305 return;
1306 }
1307 mr = sysbus_mmio_get_region(sbd, 0);
1308 } else if (!strcmp(devinfo->type, TYPE_IOTKIT_SYSCTL)) {
1309 /* System control registers */
1310 sbd = SYS_BUS_DEVICE(&s->sysctl);
1311
1312 object_property_set_int(OBJECT(&s->sysctl), "sse-version",
1313 info->sse_version, &error_abort);
1314 object_property_set_int(OBJECT(&s->sysctl), "CPUWAIT_RST",
1315 info->cpuwait_rst, &error_abort);
1316 object_property_set_int(OBJECT(&s->sysctl), "INITSVTOR0_RST",
1317 s->init_svtor, &error_abort);
1318 object_property_set_int(OBJECT(&s->sysctl), "INITSVTOR1_RST",
1319 s->init_svtor, &error_abort);
1320 if (!sysbus_realize(sbd, errp)) {
1321 return;
1322 }
1323 mr = sysbus_mmio_get_region(sbd, 0);
1324 } else if (!strcmp(devinfo->type, TYPE_UNIMPLEMENTED_DEVICE)) {
1325 sbd = SYS_BUS_DEVICE(&s->unimp[devinfo->index]);
1326
1327 qdev_prop_set_string(DEVICE(sbd), "name", devinfo->name);
1328 qdev_prop_set_uint64(DEVICE(sbd), "size", devinfo->size);
1329 if (!sysbus_realize(sbd, errp)) {
1330 return;
1331 }
1332 mr = sysbus_mmio_get_region(sbd, 0);
1333 } else {
1334 g_assert_not_reached();
1335 }
1336
1337 switch (devinfo->irq) {
1338 case NO_IRQ:
1339 irq = NULL;
1340 break;
1341 case 0 ... NUM_SSE_IRQS - 1:
1342 irq = armsse_get_common_irq_in(s, devinfo->irq);
1343 break;
1344 case NMI_0:
1345 case NMI_1:
1346 irq = qdev_get_gpio_in(DEVICE(&s->nmi_orgate),
1347 devinfo->irq - NMI_0);
1348 break;
1349 default:
1350 g_assert_not_reached();
1351 }
1352
1353 if (irq) {
1354 sysbus_connect_irq(sbd, 0, irq);
1355 }
1356
1357 /*
1358 * Devices connected to a PPC are connected to the port here;
1359 * we will map the upstream end of that port to the right address
1360 * in the container later after the PPC has been realized.
1361 * Devices not connected to a PPC can be mapped immediately.
1362 */
1363 if (devinfo->ppc != NO_PPC) {
1364 TZPPC *ppc = &s->apb_ppc[devinfo->ppc];
1365 g_autofree char *portname = g_strdup_printf("port[%d]",
1366 devinfo->ppc_port);
1367 object_property_set_link(OBJECT(ppc), portname, OBJECT(mr),
1368 &error_abort);
1369 } else {
1370 memory_region_add_subregion(&s->container, devinfo->addr, mr);
1371 }
1372 }
1373
1374 if (info->has_mhus) {
1375 /*
1376 * An SSE-200 with only one CPU should have only one MHU created,
1377 * with the region where the second MHU usually is being RAZ/WI.
1378 * We don't implement that SSE-200 config; if we want to support
1379 * it then this code needs to be enhanced to handle creating the
1380 * RAZ/WI region instead of the second MHU.
1381 */
1382 assert(info->num_cpus == ARRAY_SIZE(s->mhu));
1383
1384 for (i = 0; i < ARRAY_SIZE(s->mhu); i++) {
1385 char *port;
1386 int cpunum;
1387 SysBusDevice *mhu_sbd = SYS_BUS_DEVICE(&s->mhu[i]);
1388
1389 if (!sysbus_realize(SYS_BUS_DEVICE(&s->mhu[i]), errp)) {
1390 return;
1391 }
1392 port = g_strdup_printf("port[%d]", i + 3);
1393 mr = sysbus_mmio_get_region(mhu_sbd, 0);
1394 object_property_set_link(OBJECT(&s->apb_ppc[0]), port, OBJECT(mr),
1395 &error_abort);
1396 g_free(port);
1397
1398 /*
1399 * Each MHU has an irq line for each CPU:
1400 * MHU 0 irq line 0 -> CPU 0 IRQ 6
1401 * MHU 0 irq line 1 -> CPU 1 IRQ 6
1402 * MHU 1 irq line 0 -> CPU 0 IRQ 7
1403 * MHU 1 irq line 1 -> CPU 1 IRQ 7
1404 */
1405 for (cpunum = 0; cpunum < info->num_cpus; cpunum++) {
1406 DeviceState *cpudev = DEVICE(&s->armv7m[cpunum]);
1407
1408 sysbus_connect_irq(mhu_sbd, cpunum,
1409 qdev_get_gpio_in(cpudev, 6 + i));
1410 }
1411 }
1412 }
1413
1414 if (!sysbus_realize(SYS_BUS_DEVICE(&s->apb_ppc[0]), errp)) {
1415 return;
1416 }
1417
1418 sbd_apb_ppc0 = SYS_BUS_DEVICE(&s->apb_ppc[0]);
1419 dev_apb_ppc0 = DEVICE(&s->apb_ppc[0]);
1420
1421 if (info->has_mhus) {
1422 mr = sysbus_mmio_get_region(sbd_apb_ppc0, 3);
1423 memory_region_add_subregion(&s->container, 0x40003000, mr);
1424 mr = sysbus_mmio_get_region(sbd_apb_ppc0, 4);
1425 memory_region_add_subregion(&s->container, 0x40004000, mr);
1426 }
1427 for (i = 0; i < IOTS_APB_PPC0_NUM_PORTS; i++) {
1428 qdev_connect_gpio_out_named(dev_secctl, "apb_ppc0_nonsec", i,
1429 qdev_get_gpio_in_named(dev_apb_ppc0,
1430 "cfg_nonsec", i));
1431 qdev_connect_gpio_out_named(dev_secctl, "apb_ppc0_ap", i,
1432 qdev_get_gpio_in_named(dev_apb_ppc0,
1433 "cfg_ap", i));
1434 }
1435 qdev_connect_gpio_out_named(dev_secctl, "apb_ppc0_irq_enable", 0,
1436 qdev_get_gpio_in_named(dev_apb_ppc0,
1437 "irq_enable", 0));
1438 qdev_connect_gpio_out_named(dev_secctl, "apb_ppc0_irq_clear", 0,
1439 qdev_get_gpio_in_named(dev_apb_ppc0,
1440 "irq_clear", 0));
1441 qdev_connect_gpio_out(dev_splitter, 0,
1442 qdev_get_gpio_in_named(dev_apb_ppc0,
1443 "cfg_sec_resp", 0));
1444
1445 /* All the PPC irq lines (from the 2 internal PPCs and the 8 external
1446 * ones) are sent individually to the security controller, and also
1447 * ORed together to give a single combined PPC interrupt to the NVIC.
1448 */
1449 if (!object_property_set_int(OBJECT(&s->ppc_irq_orgate),
1450 "num-lines", NUM_PPCS, errp)) {
1451 return;
1452 }
1453 if (!qdev_realize(DEVICE(&s->ppc_irq_orgate), NULL, errp)) {
1454 return;
1455 }
1456 qdev_connect_gpio_out(DEVICE(&s->ppc_irq_orgate), 0,
1457 armsse_get_common_irq_in(s, 10));
1458
1459 /*
1460 * 0x40010000 .. 0x4001ffff (and the 0x5001000... secure-only alias):
1461 * private per-CPU region (all these devices are SSE-200 only):
1462 * 0x50010000: L1 icache control registers
1463 * 0x50011000: CPUSECCTRL (CPU local security control registers)
1464 * 0x4001f000 and 0x5001f000: CPU_IDENTITY register block
1465 * The SSE-300 has an extra:
1466 * 0x40012000 and 0x50012000: CPU_PWRCTRL register block
1467 */
1468 if (info->has_cachectrl) {
1469 for (i = 0; i < info->num_cpus; i++) {
1470 char *name = g_strdup_printf("cachectrl%d", i);
1471
1472 qdev_prop_set_string(DEVICE(&s->cachectrl[i]), "name", name);
1473 g_free(name);
1474 qdev_prop_set_uint64(DEVICE(&s->cachectrl[i]), "size", 0x1000);
1475 if (!sysbus_realize(SYS_BUS_DEVICE(&s->cachectrl[i]), errp)) {
1476 return;
1477 }
1478
1479 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->cachectrl[i]), 0);
1480 memory_region_add_subregion(&s->cpu_container[i], 0x50010000, mr);
1481 }
1482 }
1483 if (info->has_cpusecctrl) {
1484 for (i = 0; i < info->num_cpus; i++) {
1485 char *name = g_strdup_printf("CPUSECCTRL%d", i);
1486
1487 qdev_prop_set_string(DEVICE(&s->cpusecctrl[i]), "name", name);
1488 g_free(name);
1489 qdev_prop_set_uint64(DEVICE(&s->cpusecctrl[i]), "size", 0x1000);
1490 if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpusecctrl[i]), errp)) {
1491 return;
1492 }
1493
1494 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->cpusecctrl[i]), 0);
1495 memory_region_add_subregion(&s->cpu_container[i], 0x50011000, mr);
1496 }
1497 }
1498 if (info->has_cpuid) {
1499 for (i = 0; i < info->num_cpus; i++) {
1500
1501 qdev_prop_set_uint32(DEVICE(&s->cpuid[i]), "CPUID", i);
1502 if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpuid[i]), errp)) {
1503 return;
1504 }
1505
1506 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->cpuid[i]), 0);
1507 memory_region_add_subregion(&s->cpu_container[i], 0x4001F000, mr);
1508 }
1509 }
1510 if (info->has_cpu_pwrctrl) {
1511 for (i = 0; i < info->num_cpus; i++) {
1512
1513 if (!sysbus_realize(SYS_BUS_DEVICE(&s->cpu_pwrctrl[i]), errp)) {
1514 return;
1515 }
1516
1517 mr = sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->cpu_pwrctrl[i]), 0);
1518 memory_region_add_subregion(&s->cpu_container[i], 0x40012000, mr);
1519 }
1520 }
1521
1522 if (!sysbus_realize(SYS_BUS_DEVICE(&s->apb_ppc[1]), errp)) {
1523 return;
1524 }
1525
1526 dev_apb_ppc1 = DEVICE(&s->apb_ppc[1]);
1527 qdev_connect_gpio_out_named(dev_secctl, "apb_ppc1_nonsec", 0,
1528 qdev_get_gpio_in_named(dev_apb_ppc1,
1529 "cfg_nonsec", 0));
1530 qdev_connect_gpio_out_named(dev_secctl, "apb_ppc1_ap", 0,
1531 qdev_get_gpio_in_named(dev_apb_ppc1,
1532 "cfg_ap", 0));
1533 qdev_connect_gpio_out_named(dev_secctl, "apb_ppc1_irq_enable", 0,
1534 qdev_get_gpio_in_named(dev_apb_ppc1,
1535 "irq_enable", 0));
1536 qdev_connect_gpio_out_named(dev_secctl, "apb_ppc1_irq_clear", 0,
1537 qdev_get_gpio_in_named(dev_apb_ppc1,
1538 "irq_clear", 0));
1539 qdev_connect_gpio_out(dev_splitter, 1,
1540 qdev_get_gpio_in_named(dev_apb_ppc1,
1541 "cfg_sec_resp", 0));
1542
1543 /*
1544 * Now both PPCs are realized we can map the upstream ends of
1545 * ports which correspond to entries in the devinfo array.
1546 * The ports which are connected to non-devinfo devices have
1547 * already been mapped.
1548 */
1549 for (devinfo = info->devinfo; devinfo->name; devinfo++) {
1550 SysBusDevice *ppc_sbd;
1551
1552 if (devinfo->ppc == NO_PPC) {
1553 continue;
1554 }
1555 ppc_sbd = SYS_BUS_DEVICE(&s->apb_ppc[devinfo->ppc]);
1556 mr = sysbus_mmio_get_region(ppc_sbd, devinfo->ppc_port);
1557 memory_region_add_subregion(&s->container, devinfo->addr, mr);
1558 }
1559
1560 for (i = 0; i < ARRAY_SIZE(s->ppc_irq_splitter); i++) {
1561 Object *splitter = OBJECT(&s->ppc_irq_splitter[i]);
1562
1563 if (!object_property_set_int(splitter, "num-lines", 2, errp)) {
1564 return;
1565 }
1566 if (!qdev_realize(DEVICE(splitter), NULL, errp)) {
1567 return;
1568 }
1569 }
1570
1571 for (i = 0; i < IOTS_NUM_AHB_EXP_PPC; i++) {
1572 char *ppcname = g_strdup_printf("ahb_ppcexp%d", i);
1573
1574 armsse_forward_ppc(s, ppcname, i);
1575 g_free(ppcname);
1576 }
1577
1578 for (i = 0; i < IOTS_NUM_APB_EXP_PPC; i++) {
1579 char *ppcname = g_strdup_printf("apb_ppcexp%d", i);
1580
1581 armsse_forward_ppc(s, ppcname, i + IOTS_NUM_AHB_EXP_PPC);
1582 g_free(ppcname);
1583 }
1584
1585 for (i = NUM_EXTERNAL_PPCS; i < NUM_PPCS; i++) {
1586 /* Wire up IRQ splitter for internal PPCs */
1587 DeviceState *devs = DEVICE(&s->ppc_irq_splitter[i]);
1588 char *gpioname = g_strdup_printf("apb_ppc%d_irq_status",
1589 i - NUM_EXTERNAL_PPCS);
1590 TZPPC *ppc = &s->apb_ppc[i - NUM_EXTERNAL_PPCS];
1591
1592 qdev_connect_gpio_out(devs, 0,
1593 qdev_get_gpio_in_named(dev_secctl, gpioname, 0));
1594 qdev_connect_gpio_out(devs, 1,
1595 qdev_get_gpio_in(DEVICE(&s->ppc_irq_orgate), i));
1596 qdev_connect_gpio_out_named(DEVICE(ppc), "irq", 0,
1597 qdev_get_gpio_in(devs, 0));
1598 g_free(gpioname);
1599 }
1600
1601 /* Wire up the splitters for the MPC IRQs */
1602 for (i = 0; i < IOTS_NUM_EXP_MPC + info->sram_banks; i++) {
1603 SplitIRQ *splitter = &s->mpc_irq_splitter[i];
1604 DeviceState *devs = DEVICE(splitter);
1605
1606 if (!object_property_set_int(OBJECT(splitter), "num-lines", 2,
1607 errp)) {
1608 return;
1609 }
1610 if (!qdev_realize(DEVICE(splitter), NULL, errp)) {
1611 return;
1612 }
1613
1614 if (i < IOTS_NUM_EXP_MPC) {
1615 /* Splitter input is from GPIO input line */
1616 s->mpcexp_status_in[i] = qdev_get_gpio_in(devs, 0);
1617 qdev_connect_gpio_out(devs, 0,
1618 qdev_get_gpio_in_named(dev_secctl,
1619 "mpcexp_status", i));
1620 } else {
1621 /* Splitter input is from our own MPC */
1622 qdev_connect_gpio_out_named(DEVICE(&s->mpc[i - IOTS_NUM_EXP_MPC]),
1623 "irq", 0,
1624 qdev_get_gpio_in(devs, 0));
1625 qdev_connect_gpio_out(devs, 0,
1626 qdev_get_gpio_in_named(dev_secctl,
1627 "mpc_status",
1628 i - IOTS_NUM_EXP_MPC));
1629 }
1630
1631 qdev_connect_gpio_out(devs, 1,
1632 qdev_get_gpio_in(DEVICE(&s->mpc_irq_orgate), i));
1633 }
1634 /* Create GPIO inputs which will pass the line state for our
1635 * mpcexp_irq inputs to the correct splitter devices.
1636 */
1637 qdev_init_gpio_in_named(dev, armsse_mpcexp_status, "mpcexp_status",
1638 IOTS_NUM_EXP_MPC);
1639
1640 armsse_forward_sec_resp_cfg(s);
1641
1642 /* Forward the MSC related signals */
1643 qdev_pass_gpios(dev_secctl, dev, "mscexp_status");
1644 qdev_pass_gpios(dev_secctl, dev, "mscexp_clear");
1645 qdev_pass_gpios(dev_secctl, dev, "mscexp_ns");
1646 qdev_connect_gpio_out_named(dev_secctl, "msc_irq", 0,
1647 armsse_get_common_irq_in(s, 11));
1648
1649 /*
1650 * Expose our container region to the board model; this corresponds
1651 * to the AHB Slave Expansion ports which allow bus master devices
1652 * (eg DMA controllers) in the board model to make transactions into
1653 * devices in the ARMSSE.
1654 */
1655 sysbus_init_mmio(SYS_BUS_DEVICE(s), &s->container);
1656 }
1657
1658 static void armsse_idau_check(IDAUInterface *ii, uint32_t address,
1659 int *iregion, bool *exempt, bool *ns, bool *nsc)
1660 {
1661 /*
1662 * For ARMSSE systems the IDAU responses are simple logical functions
1663 * of the address bits. The NSC attribute is guest-adjustable via the
1664 * NSCCFG register in the security controller.
1665 */
1666 ARMSSE *s = ARM_SSE(ii);
1667 int region = extract32(address, 28, 4);
1668
1669 *ns = !(region & 1);
1670 *nsc = (region == 1 && (s->nsccfg & 1)) || (region == 3 && (s->nsccfg & 2));
1671 /* 0xe0000000..0xe00fffff and 0xf0000000..0xf00fffff are exempt */
1672 *exempt = (address & 0xeff00000) == 0xe0000000;
1673 *iregion = region;
1674 }
1675
1676 static const VMStateDescription armsse_vmstate = {
1677 .name = "iotkit",
1678 .version_id = 2,
1679 .minimum_version_id = 2,
1680 .fields = (VMStateField[]) {
1681 VMSTATE_CLOCK(mainclk, ARMSSE),
1682 VMSTATE_CLOCK(s32kclk, ARMSSE),
1683 VMSTATE_UINT32(nsccfg, ARMSSE),
1684 VMSTATE_END_OF_LIST()
1685 }
1686 };
1687
1688 static void armsse_reset(DeviceState *dev)
1689 {
1690 ARMSSE *s = ARM_SSE(dev);
1691
1692 s->nsccfg = 0;
1693 }
1694
1695 static void armsse_class_init(ObjectClass *klass, void *data)
1696 {
1697 DeviceClass *dc = DEVICE_CLASS(klass);
1698 IDAUInterfaceClass *iic = IDAU_INTERFACE_CLASS(klass);
1699 ARMSSEClass *asc = ARM_SSE_CLASS(klass);
1700 const ARMSSEInfo *info = data;
1701
1702 dc->realize = armsse_realize;
1703 dc->vmsd = &armsse_vmstate;
1704 device_class_set_props(dc, info->props);
1705 dc->reset = armsse_reset;
1706 iic->check = armsse_idau_check;
1707 asc->info = info;
1708 }
1709
1710 static const TypeInfo armsse_info = {
1711 .name = TYPE_ARM_SSE,
1712 .parent = TYPE_SYS_BUS_DEVICE,
1713 .instance_size = sizeof(ARMSSE),
1714 .class_size = sizeof(ARMSSEClass),
1715 .instance_init = armsse_init,
1716 .abstract = true,
1717 .interfaces = (InterfaceInfo[]) {
1718 { TYPE_IDAU_INTERFACE },
1719 { }
1720 }
1721 };
1722
1723 static void armsse_register_types(void)
1724 {
1725 int i;
1726
1727 type_register_static(&armsse_info);
1728
1729 for (i = 0; i < ARRAY_SIZE(armsse_variants); i++) {
1730 TypeInfo ti = {
1731 .name = armsse_variants[i].name,
1732 .parent = TYPE_ARM_SSE,
1733 .class_init = armsse_class_init,
1734 .class_data = (void *)&armsse_variants[i],
1735 };
1736 type_register(&ti);
1737 }
1738 }
1739
1740 type_init(armsse_register_types);
Random patches