2 * QEMU/MIPS pseudo-board
4 * emulates a simple machine with ISA-like bus.
5 * ISA IO space mapped to the 0x14000000 (PHYS) and
6 * ISA memory at the 0x10000000 (PHYS, 16Mb in size).
7 * All peripherial devices are attached to this "bus" with
8 * the standard PC ISA addresses.
10 #include "qemu/osdep.h"
11 #include "qapi/error.h"
12 #include "qemu-common.h"
15 #include "hw/mips/mips.h"
16 #include "hw/mips/cpudevs.h"
17 #include "hw/i386/pc.h"
18 #include "hw/char/serial.h"
19 #include "hw/isa/isa.h"
21 #include "hw/net/ne2000-isa.h"
22 #include "sysemu/sysemu.h"
23 #include "hw/boards.h"
24 #include "hw/block/flash.h"
26 #include "hw/mips/bios.h"
28 #include "hw/loader.h"
30 #include "hw/timer/mc146818rtc.h"
31 #include "hw/input/i8042.h"
32 #include "hw/timer/i8254.h"
33 #include "exec/address-spaces.h"
34 #include "sysemu/qtest.h"
35 #include "qemu/error-report.h"
39 static const int ide_iobase
[2] = { 0x1f0, 0x170 };
40 static const int ide_iobase2
[2] = { 0x3f6, 0x376 };
41 static const int ide_irq
[2] = { 14, 15 };
43 static ISADevice
*pit
; /* PIT i8254 */
45 /* i8254 PIT is attached to the IRQ0 at PIC i8259 */
47 static struct _loaderparams
{
49 const char *kernel_filename
;
50 const char *kernel_cmdline
;
51 const char *initrd_filename
;
54 static void mips_qemu_write (void *opaque
, hwaddr addr
,
55 uint64_t val
, unsigned size
)
57 if ((addr
& 0xffff) == 0 && val
== 42)
58 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET
);
59 else if ((addr
& 0xffff) == 4 && val
== 42)
60 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN
);
63 static uint64_t mips_qemu_read (void *opaque
, hwaddr addr
,
69 static const MemoryRegionOps mips_qemu_ops
= {
70 .read
= mips_qemu_read
,
71 .write
= mips_qemu_write
,
72 .endianness
= DEVICE_NATIVE_ENDIAN
,
75 typedef struct ResetData
{
80 static int64_t load_kernel(void)
82 int64_t entry
, kernel_high
;
83 long kernel_size
, initrd_size
, params_size
;
84 ram_addr_t initrd_offset
;
88 #ifdef TARGET_WORDS_BIGENDIAN
93 kernel_size
= load_elf(loaderparams
.kernel_filename
, cpu_mips_kseg0_to_phys
,
94 NULL
, (uint64_t *)&entry
, NULL
,
95 (uint64_t *)&kernel_high
, big_endian
,
97 if (kernel_size
>= 0) {
98 if ((entry
& ~0x7fffffffULL
) == 0x80000000)
99 entry
= (int32_t)entry
;
101 error_report("could not load kernel '%s': %s",
102 loaderparams
.kernel_filename
,
103 load_elf_strerror(kernel_size
));
110 if (loaderparams
.initrd_filename
) {
111 initrd_size
= get_image_size (loaderparams
.initrd_filename
);
112 if (initrd_size
> 0) {
113 initrd_offset
= (kernel_high
+ ~INITRD_PAGE_MASK
) & INITRD_PAGE_MASK
;
114 if (initrd_offset
+ initrd_size
> ram_size
) {
115 error_report("memory too small for initial ram disk '%s'",
116 loaderparams
.initrd_filename
);
119 initrd_size
= load_image_targphys(loaderparams
.initrd_filename
,
121 ram_size
- initrd_offset
);
123 if (initrd_size
== (target_ulong
) -1) {
124 error_report("could not load initial ram disk '%s'",
125 loaderparams
.initrd_filename
);
130 /* Store command line. */
132 params_buf
= g_malloc(params_size
);
134 params_buf
[0] = tswap32(ram_size
);
135 params_buf
[1] = tswap32(0x12345678);
137 if (initrd_size
> 0) {
138 snprintf((char *)params_buf
+ 8, 256, "rd_start=0x%" PRIx64
" rd_size=%li %s",
139 cpu_mips_phys_to_kseg0(NULL
, initrd_offset
),
140 initrd_size
, loaderparams
.kernel_cmdline
);
142 snprintf((char *)params_buf
+ 8, 256, "%s", loaderparams
.kernel_cmdline
);
145 rom_add_blob_fixed("params", params_buf
, params_size
,
152 static void main_cpu_reset(void *opaque
)
154 ResetData
*s
= (ResetData
*)opaque
;
155 CPUMIPSState
*env
= &s
->cpu
->env
;
157 cpu_reset(CPU(s
->cpu
));
158 env
->active_tc
.PC
= s
->vector
;
161 static const int sector_len
= 32 * 1024;
163 void mips_r4k_init(MachineState
*machine
)
165 ram_addr_t ram_size
= machine
->ram_size
;
166 const char *kernel_filename
= machine
->kernel_filename
;
167 const char *kernel_cmdline
= machine
->kernel_cmdline
;
168 const char *initrd_filename
= machine
->initrd_filename
;
170 MemoryRegion
*address_space_mem
= get_system_memory();
171 MemoryRegion
*ram
= g_new(MemoryRegion
, 1);
173 MemoryRegion
*iomem
= g_new(MemoryRegion
, 1);
174 MemoryRegion
*isa_io
= g_new(MemoryRegion
, 1);
175 MemoryRegion
*isa_mem
= g_new(MemoryRegion
, 1);
179 ResetData
*reset_info
;
183 DriveInfo
*hd
[MAX_IDE_BUS
* MAX_IDE_DEVS
];
188 cpu
= MIPS_CPU(cpu_create(machine
->cpu_type
));
191 reset_info
= g_malloc0(sizeof(ResetData
));
192 reset_info
->cpu
= cpu
;
193 reset_info
->vector
= env
->active_tc
.PC
;
194 qemu_register_reset(main_cpu_reset
, reset_info
);
197 if (ram_size
> (256 << 20)) {
198 error_report("Too much memory for this machine: %dMB, maximum 256MB",
199 ((unsigned int)ram_size
/ (1 << 20)));
202 memory_region_allocate_system_memory(ram
, NULL
, "mips_r4k.ram", ram_size
);
204 memory_region_add_subregion(address_space_mem
, 0, ram
);
206 memory_region_init_io(iomem
, NULL
, &mips_qemu_ops
, NULL
, "mips-qemu", 0x10000);
207 memory_region_add_subregion(address_space_mem
, 0x1fbf0000, iomem
);
209 /* Try to load a BIOS image. If this fails, we continue regardless,
210 but initialize the hardware ourselves. When a kernel gets
211 preloaded we also initialize the hardware, since the BIOS wasn't
213 if (bios_name
== NULL
)
214 bios_name
= BIOS_FILENAME
;
215 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, bios_name
);
217 bios_size
= get_image_size(filename
);
221 #ifdef TARGET_WORDS_BIGENDIAN
226 if ((bios_size
> 0) && (bios_size
<= BIOS_SIZE
)) {
227 bios
= g_new(MemoryRegion
, 1);
228 memory_region_init_ram(bios
, NULL
, "mips_r4k.bios", BIOS_SIZE
,
230 memory_region_set_readonly(bios
, true);
231 memory_region_add_subregion(get_system_memory(), 0x1fc00000, bios
);
233 load_image_targphys(filename
, 0x1fc00000, BIOS_SIZE
);
234 } else if ((dinfo
= drive_get(IF_PFLASH
, 0, 0)) != NULL
) {
235 uint32_t mips_rom
= 0x00400000;
236 if (!pflash_cfi01_register(0x1fc00000, NULL
, "mips_r4k.bios", mips_rom
,
237 blk_by_legacy_dinfo(dinfo
),
238 sector_len
, mips_rom
/ sector_len
,
239 4, 0, 0, 0, 0, be
)) {
240 fprintf(stderr
, "qemu: Error registering flash memory.\n");
242 } else if (!qtest_enabled()) {
244 warn_report("could not load MIPS bios '%s'", bios_name
);
248 if (kernel_filename
) {
249 loaderparams
.ram_size
= ram_size
;
250 loaderparams
.kernel_filename
= kernel_filename
;
251 loaderparams
.kernel_cmdline
= kernel_cmdline
;
252 loaderparams
.initrd_filename
= initrd_filename
;
253 reset_info
->vector
= load_kernel();
256 /* Init CPU internal devices */
257 cpu_mips_irq_init_cpu(cpu
);
258 cpu_mips_clock_init(cpu
);
260 /* ISA bus: IO space at 0x14000000, mem space at 0x10000000 */
261 memory_region_init_alias(isa_io
, NULL
, "isa-io",
262 get_system_io(), 0, 0x00010000);
263 memory_region_init(isa_mem
, NULL
, "isa-mem", 0x01000000);
264 memory_region_add_subregion(get_system_memory(), 0x14000000, isa_io
);
265 memory_region_add_subregion(get_system_memory(), 0x10000000, isa_mem
);
266 isa_bus
= isa_bus_new(NULL
, isa_mem
, get_system_io(), &error_abort
);
268 /* The PIC is attached to the MIPS CPU INT0 pin */
269 i8259
= i8259_init(isa_bus
, env
->irq
[2]);
270 isa_bus_irqs(isa_bus
, i8259
);
272 mc146818_rtc_init(isa_bus
, 2000, NULL
);
274 pit
= i8254_pit_init(isa_bus
, 0x40, 0, NULL
);
276 serial_hds_isa_init(isa_bus
, 0, MAX_ISA_SERIAL_PORTS
);
278 isa_vga_init(isa_bus
);
280 if (nd_table
[0].used
)
281 isa_ne2000_init(isa_bus
, 0x300, 9, &nd_table
[0]);
283 ide_drive_get(hd
, ARRAY_SIZE(hd
));
284 for(i
= 0; i
< MAX_IDE_BUS
; i
++)
285 isa_ide_init(isa_bus
, ide_iobase
[i
], ide_iobase2
[i
], ide_irq
[i
],
286 hd
[MAX_IDE_DEVS
* i
],
287 hd
[MAX_IDE_DEVS
* i
+ 1]);
289 isa_create_simple(isa_bus
, TYPE_I8042
);
292 static void mips_machine_init(MachineClass
*mc
)
294 mc
->desc
= "mips r4k platform";
295 mc
->init
= mips_r4k_init
;
296 mc
->block_default_type
= IF_IDE
;
298 mc
->default_cpu_type
= MIPS_CPU_TYPE_NAME("R4000");
300 mc
->default_cpu_type
= MIPS_CPU_TYPE_NAME("24Kf");
305 DEFINE_MACHINE("mips", mips_machine_init
)