2 * QEMU HPPA hardware system emulator.
3 * Copyright 2018 Helge Deller <deller@gmx.de>
6 #include "qemu/osdep.h"
7 #include "qemu-common.h"
10 #include "hw/loader.h"
11 #include "hw/boards.h"
12 #include "qemu/error-report.h"
13 #include "sysemu/reset.h"
14 #include "sysemu/sysemu.h"
15 #include "hw/rtc/mc146818rtc.h"
17 #include "hw/timer/i8254.h"
18 #include "hw/char/serial.h"
20 #include "qemu/units.h"
21 #include "qapi/error.h"
26 static ISABus
*hppa_isa_bus(void)
30 MemoryRegion
*isa_region
;
32 isa_region
= g_new(MemoryRegion
, 1);
33 memory_region_init_io(isa_region
, NULL
, &hppa_pci_ignore_ops
,
34 NULL
, "isa-io", 0x800);
35 memory_region_add_subregion(get_system_memory(), IDE_HPA
,
38 isa_bus
= isa_bus_new(NULL
, get_system_memory(), isa_region
,
40 isa_irqs
= i8259_init(isa_bus
,
41 /* qemu_allocate_irq(dino_set_isa_irq, s, 0)); */
43 isa_bus_irqs(isa_bus
, isa_irqs
);
48 static uint64_t cpu_hppa_to_phys(void *opaque
, uint64_t addr
)
50 addr
&= (0x10000000 - 1);
54 static HPPACPU
*cpu
[HPPA_MAX_CPUS
];
55 static uint64_t firmware_entry
;
57 static void machine_hppa_init(MachineState
*machine
)
59 const char *kernel_filename
= machine
->kernel_filename
;
60 const char *kernel_cmdline
= machine
->kernel_cmdline
;
61 const char *initrd_filename
= machine
->initrd_filename
;
65 qemu_irq rtc_irq
, serial_irq
;
66 char *firmware_filename
;
67 uint64_t firmware_low
, firmware_high
;
69 uint64_t kernel_entry
= 0, kernel_low
, kernel_high
;
70 MemoryRegion
*addr_space
= get_system_memory();
71 MemoryRegion
*rom_region
;
72 MemoryRegion
*ram_region
;
73 MemoryRegion
*cpu_region
;
75 unsigned int smp_cpus
= machine
->smp
.cpus
;
77 ram_size
= machine
->ram_size
;
80 for (i
= 0; i
< smp_cpus
; i
++) {
81 char *name
= g_strdup_printf("cpu%ld-io-eir", i
);
82 cpu
[i
] = HPPA_CPU(cpu_create(machine
->cpu_type
));
84 cpu_region
= g_new(MemoryRegion
, 1);
85 memory_region_init_io(cpu_region
, OBJECT(cpu
[i
]), &hppa_io_eir_ops
,
87 memory_region_add_subregion(addr_space
, CPU_HPA
+ i
* 0x1000,
92 /* Limit main memory. */
93 if (ram_size
> FIRMWARE_START
) {
94 machine
->ram_size
= ram_size
= FIRMWARE_START
;
97 /* Main memory region. */
98 ram_region
= g_new(MemoryRegion
, 1);
99 memory_region_allocate_system_memory(ram_region
, OBJECT(machine
),
101 memory_region_add_subregion(addr_space
, 0, ram_region
);
103 /* Init Dino (PCI host bus chip). */
104 pci_bus
= dino_init(addr_space
, &rtc_irq
, &serial_irq
);
107 /* Create ISA bus. */
108 isa_bus
= hppa_isa_bus();
111 /* Realtime clock, used by firmware for PDC_TOD call. */
112 mc146818_rtc_init(isa_bus
, 2000, rtc_irq
);
114 /* Serial code setup. */
116 uint32_t addr
= DINO_UART_HPA
+ 0x800;
117 serial_mm_init(addr_space
, addr
, 0, serial_irq
,
118 115200, serial_hd(0), DEVICE_BIG_ENDIAN
);
121 /* SCSI disk setup. */
122 dev
= DEVICE(pci_create_simple(pci_bus
, -1, "lsi53c895a"));
123 lsi53c8xx_handle_legacy_cmdline(dev
);
125 /* Network setup. e1000 is good enough, failing Tulip support. */
126 for (i
= 0; i
< nb_nics
; i
++) {
127 pci_nic_init_nofail(&nd_table
[i
], pci_bus
, "e1000", NULL
);
130 /* Load firmware. Given that this is not "real" firmware,
131 but one explicitly written for the emulation, we might as
132 well load it directly from an ELF image. */
133 firmware_filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
,
134 bios_name
? bios_name
:
135 "hppa-firmware.img");
136 if (firmware_filename
== NULL
) {
137 error_report("no firmware provided");
141 size
= load_elf(firmware_filename
, NULL
, NULL
, NULL
,
142 &firmware_entry
, &firmware_low
, &firmware_high
,
143 true, EM_PARISC
, 0, 0);
145 /* Unfortunately, load_elf sign-extends reading elf32. */
146 firmware_entry
= (target_ureg
)firmware_entry
;
147 firmware_low
= (target_ureg
)firmware_low
;
148 firmware_high
= (target_ureg
)firmware_high
;
151 error_report("could not load firmware '%s'", firmware_filename
);
154 qemu_log_mask(CPU_LOG_PAGE
, "Firmware loaded at 0x%08" PRIx64
155 "-0x%08" PRIx64
", entry at 0x%08" PRIx64
".\n",
156 firmware_low
, firmware_high
, firmware_entry
);
157 if (firmware_low
< ram_size
|| firmware_high
>= FIRMWARE_END
) {
158 error_report("Firmware overlaps with memory or IO space");
161 g_free(firmware_filename
);
163 rom_region
= g_new(MemoryRegion
, 1);
164 memory_region_init_ram(rom_region
, NULL
, "firmware",
165 (FIRMWARE_END
- FIRMWARE_START
), &error_fatal
);
166 memory_region_add_subregion(addr_space
, FIRMWARE_START
, rom_region
);
169 if (kernel_filename
) {
170 size
= load_elf(kernel_filename
, NULL
, &cpu_hppa_to_phys
,
171 NULL
, &kernel_entry
, &kernel_low
, &kernel_high
,
172 true, EM_PARISC
, 0, 0);
174 /* Unfortunately, load_elf sign-extends reading elf32. */
175 kernel_entry
= (target_ureg
) cpu_hppa_to_phys(NULL
, kernel_entry
);
176 kernel_low
= (target_ureg
)kernel_low
;
177 kernel_high
= (target_ureg
)kernel_high
;
180 error_report("could not load kernel '%s'", kernel_filename
);
183 qemu_log_mask(CPU_LOG_PAGE
, "Kernel loaded at 0x%08" PRIx64
184 "-0x%08" PRIx64
", entry at 0x%08" PRIx64
185 ", size %" PRIu64
" kB\n",
186 kernel_low
, kernel_high
, kernel_entry
, size
/ KiB
);
188 if (kernel_cmdline
) {
189 cpu
[0]->env
.gr
[24] = 0x4000;
190 pstrcpy_targphys("cmdline", cpu
[0]->env
.gr
[24],
191 TARGET_PAGE_SIZE
, kernel_cmdline
);
194 if (initrd_filename
) {
195 ram_addr_t initrd_base
;
198 initrd_size
= get_image_size(initrd_filename
);
199 if (initrd_size
< 0) {
200 error_report("could not load initial ram disk '%s'",
205 /* Load the initrd image high in memory.
206 Mirror the algorithm used by palo:
207 (1) Due to sign-extension problems and PDC,
208 put the initrd no higher than 1G.
209 (2) Reserve 64k for stack. */
210 initrd_base
= MIN(ram_size
, 1 * GiB
);
211 initrd_base
= initrd_base
- 64 * KiB
;
212 initrd_base
= (initrd_base
- initrd_size
) & TARGET_PAGE_MASK
;
214 if (initrd_base
< kernel_high
) {
215 error_report("kernel and initial ram disk too large!");
219 load_image_targphys(initrd_filename
, initrd_base
, initrd_size
);
220 cpu
[0]->env
.gr
[23] = initrd_base
;
221 cpu
[0]->env
.gr
[22] = initrd_base
+ initrd_size
;
226 /* When booting via firmware, tell firmware if we want interactive
227 * mode (kernel_entry=1), and to boot from CD (gr[24]='d')
228 * or hard disc * (gr[24]='c').
230 kernel_entry
= boot_menu
? 1 : 0;
231 cpu
[0]->env
.gr
[24] = machine
->boot_order
[0];
234 /* We jump to the firmware entry routine and pass the
235 * various parameters in registers. After firmware initialization,
236 * firmware will start the Linux kernel with ramdisk and cmdline.
238 cpu
[0]->env
.gr
[26] = ram_size
;
239 cpu
[0]->env
.gr
[25] = kernel_entry
;
241 /* tell firmware how many SMP CPUs to present in inventory table */
242 cpu
[0]->env
.gr
[21] = smp_cpus
;
245 static void hppa_machine_reset(MachineState
*ms
)
247 unsigned int smp_cpus
= ms
->smp
.cpus
;
250 qemu_devices_reset();
252 /* Start all CPUs at the firmware entry point.
253 * Monarch CPU will initialize firmware, secondary CPUs
254 * will enter a small idle look and wait for rendevouz. */
255 for (i
= 0; i
< smp_cpus
; i
++) {
256 cpu_set_pc(CPU(cpu
[i
]), firmware_entry
);
257 cpu
[i
]->env
.gr
[5] = CPU_HPA
+ i
* 0x1000;
260 /* already initialized by machine_hppa_init()? */
261 if (cpu
[0]->env
.gr
[26] == ram_size
) {
265 cpu
[0]->env
.gr
[26] = ram_size
;
266 cpu
[0]->env
.gr
[25] = 0; /* no firmware boot menu */
267 cpu
[0]->env
.gr
[24] = 'c';
268 /* gr22/gr23 unused, no initrd while reboot. */
269 cpu
[0]->env
.gr
[21] = smp_cpus
;
273 static void machine_hppa_machine_init(MachineClass
*mc
)
275 mc
->desc
= "HPPA generic machine";
276 mc
->default_cpu_type
= TYPE_HPPA_CPU
;
277 mc
->init
= machine_hppa_init
;
278 mc
->reset
= hppa_machine_reset
;
279 mc
->block_default_type
= IF_SCSI
;
280 mc
->max_cpus
= HPPA_MAX_CPUS
;
281 mc
->default_cpus
= 1;
283 mc
->default_ram_size
= 512 * MiB
;
284 mc
->default_boot_order
= "cd";
287 DEFINE_MACHINE("hppa", machine_hppa_machine_init
)