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/timer/i8254.h"
32 #include "sysemu/block-backend.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("qemu: 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
) {
116 "qemu: memory too small for initial ram disk '%s'\n",
117 loaderparams
.initrd_filename
);
120 initrd_size
= load_image_targphys(loaderparams
.initrd_filename
,
122 ram_size
- initrd_offset
);
124 if (initrd_size
== (target_ulong
) -1) {
125 fprintf(stderr
, "qemu: could not load initial ram disk '%s'\n",
126 loaderparams
.initrd_filename
);
131 /* Store command line. */
133 params_buf
= g_malloc(params_size
);
135 params_buf
[0] = tswap32(ram_size
);
136 params_buf
[1] = tswap32(0x12345678);
138 if (initrd_size
> 0) {
139 snprintf((char *)params_buf
+ 8, 256, "rd_start=0x%" PRIx64
" rd_size=%li %s",
140 cpu_mips_phys_to_kseg0(NULL
, initrd_offset
),
141 initrd_size
, loaderparams
.kernel_cmdline
);
143 snprintf((char *)params_buf
+ 8, 256, "%s", loaderparams
.kernel_cmdline
);
146 rom_add_blob_fixed("params", params_buf
, params_size
,
153 static void main_cpu_reset(void *opaque
)
155 ResetData
*s
= (ResetData
*)opaque
;
156 CPUMIPSState
*env
= &s
->cpu
->env
;
158 cpu_reset(CPU(s
->cpu
));
159 env
->active_tc
.PC
= s
->vector
;
162 static const int sector_len
= 32 * 1024;
164 void mips_r4k_init(MachineState
*machine
)
166 ram_addr_t ram_size
= machine
->ram_size
;
167 const char *kernel_filename
= machine
->kernel_filename
;
168 const char *kernel_cmdline
= machine
->kernel_cmdline
;
169 const char *initrd_filename
= machine
->initrd_filename
;
171 MemoryRegion
*address_space_mem
= get_system_memory();
172 MemoryRegion
*ram
= g_new(MemoryRegion
, 1);
174 MemoryRegion
*iomem
= g_new(MemoryRegion
, 1);
175 MemoryRegion
*isa_io
= g_new(MemoryRegion
, 1);
176 MemoryRegion
*isa_mem
= g_new(MemoryRegion
, 1);
180 ResetData
*reset_info
;
184 DriveInfo
*hd
[MAX_IDE_BUS
* MAX_IDE_DEVS
];
189 cpu
= MIPS_CPU(cpu_create(machine
->cpu_type
));
192 reset_info
= g_malloc0(sizeof(ResetData
));
193 reset_info
->cpu
= cpu
;
194 reset_info
->vector
= env
->active_tc
.PC
;
195 qemu_register_reset(main_cpu_reset
, reset_info
);
198 if (ram_size
> (256 << 20)) {
200 "qemu: Too much memory for this machine: %d MB, maximum 256 MB\n",
201 ((unsigned int)ram_size
/ (1 << 20)));
204 memory_region_allocate_system_memory(ram
, NULL
, "mips_r4k.ram", ram_size
);
206 memory_region_add_subregion(address_space_mem
, 0, ram
);
208 memory_region_init_io(iomem
, NULL
, &mips_qemu_ops
, NULL
, "mips-qemu", 0x10000);
209 memory_region_add_subregion(address_space_mem
, 0x1fbf0000, iomem
);
211 /* Try to load a BIOS image. If this fails, we continue regardless,
212 but initialize the hardware ourselves. When a kernel gets
213 preloaded we also initialize the hardware, since the BIOS wasn't
215 if (bios_name
== NULL
)
216 bios_name
= BIOS_FILENAME
;
217 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, bios_name
);
219 bios_size
= get_image_size(filename
);
223 #ifdef TARGET_WORDS_BIGENDIAN
228 if ((bios_size
> 0) && (bios_size
<= BIOS_SIZE
)) {
229 bios
= g_new(MemoryRegion
, 1);
230 memory_region_init_ram(bios
, NULL
, "mips_r4k.bios", BIOS_SIZE
,
232 memory_region_set_readonly(bios
, true);
233 memory_region_add_subregion(get_system_memory(), 0x1fc00000, bios
);
235 load_image_targphys(filename
, 0x1fc00000, BIOS_SIZE
);
236 } else if ((dinfo
= drive_get(IF_PFLASH
, 0, 0)) != NULL
) {
237 uint32_t mips_rom
= 0x00400000;
238 if (!pflash_cfi01_register(0x1fc00000, NULL
, "mips_r4k.bios", mips_rom
,
239 blk_by_legacy_dinfo(dinfo
),
240 sector_len
, mips_rom
/ sector_len
,
241 4, 0, 0, 0, 0, be
)) {
242 fprintf(stderr
, "qemu: Error registering flash memory.\n");
244 } else if (!qtest_enabled()) {
246 warn_report("could not load MIPS bios '%s'", bios_name
);
250 if (kernel_filename
) {
251 loaderparams
.ram_size
= ram_size
;
252 loaderparams
.kernel_filename
= kernel_filename
;
253 loaderparams
.kernel_cmdline
= kernel_cmdline
;
254 loaderparams
.initrd_filename
= initrd_filename
;
255 reset_info
->vector
= load_kernel();
258 /* Init CPU internal devices */
259 cpu_mips_irq_init_cpu(cpu
);
260 cpu_mips_clock_init(cpu
);
262 /* ISA bus: IO space at 0x14000000, mem space at 0x10000000 */
263 memory_region_init_alias(isa_io
, NULL
, "isa-io",
264 get_system_io(), 0, 0x00010000);
265 memory_region_init(isa_mem
, NULL
, "isa-mem", 0x01000000);
266 memory_region_add_subregion(get_system_memory(), 0x14000000, isa_io
);
267 memory_region_add_subregion(get_system_memory(), 0x10000000, isa_mem
);
268 isa_bus
= isa_bus_new(NULL
, isa_mem
, get_system_io(), &error_abort
);
270 /* The PIC is attached to the MIPS CPU INT0 pin */
271 i8259
= i8259_init(isa_bus
, env
->irq
[2]);
272 isa_bus_irqs(isa_bus
, i8259
);
274 mc146818_rtc_init(isa_bus
, 2000, NULL
);
276 pit
= i8254_pit_init(isa_bus
, 0x40, 0, NULL
);
278 serial_hds_isa_init(isa_bus
, 0, MAX_SERIAL_PORTS
);
280 isa_vga_init(isa_bus
);
282 if (nd_table
[0].used
)
283 isa_ne2000_init(isa_bus
, 0x300, 9, &nd_table
[0]);
285 ide_drive_get(hd
, ARRAY_SIZE(hd
));
286 for(i
= 0; i
< MAX_IDE_BUS
; i
++)
287 isa_ide_init(isa_bus
, ide_iobase
[i
], ide_iobase2
[i
], ide_irq
[i
],
288 hd
[MAX_IDE_DEVS
* i
],
289 hd
[MAX_IDE_DEVS
* i
+ 1]);
291 isa_create_simple(isa_bus
, "i8042");
294 static void mips_machine_init(MachineClass
*mc
)
296 mc
->desc
= "mips r4k platform";
297 mc
->init
= mips_r4k_init
;
298 mc
->block_default_type
= IF_IDE
;
300 mc
->default_cpu_type
= MIPS_CPU_TYPE_NAME("R4000");
302 mc
->default_cpu_type
= MIPS_CPU_TYPE_NAME("24Kf");
307 DEFINE_MACHINE("mips", mips_machine_init
)