2 * Copyright (c) 2011, Max Filippov, Open Source and Linux Lab.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * * Neither the name of the Open Source and Linux Lab nor the
13 * names of its contributors may be used to endorse or promote products
14 * derived from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 #include "qemu/osdep.h"
29 #include "qapi/error.h"
30 #include "sysemu/sysemu.h"
31 #include "hw/boards.h"
32 #include "hw/loader.h"
34 #include "exec/memory.h"
35 #include "exec/address-spaces.h"
36 #include "hw/char/serial.h"
38 #include "hw/sysbus.h"
39 #include "hw/block/flash.h"
40 #include "sysemu/block-backend.h"
41 #include "sysemu/char.h"
42 #include "sysemu/device_tree.h"
43 #include "qemu/error-report.h"
44 #include "bootparam.h"
46 typedef struct LxBoardDesc
{
49 size_t flash_boot_base
;
50 size_t flash_sector_size
;
54 typedef struct Lx60FpgaState
{
60 static void lx60_fpga_reset(void *opaque
)
62 Lx60FpgaState
*s
= opaque
;
68 static uint64_t lx60_fpga_read(void *opaque
, hwaddr addr
,
71 Lx60FpgaState
*s
= opaque
;
74 case 0x0: /*build date code*/
77 case 0x4: /*processor clock frequency, Hz*/
80 case 0x8: /*LEDs (off = 0, on = 1)*/
83 case 0xc: /*DIP switches (off = 0, on = 1)*/
89 static void lx60_fpga_write(void *opaque
, hwaddr addr
,
90 uint64_t val
, unsigned size
)
92 Lx60FpgaState
*s
= opaque
;
95 case 0x8: /*LEDs (off = 0, on = 1)*/
99 case 0x10: /*board reset*/
101 qemu_system_reset_request();
107 static const MemoryRegionOps lx60_fpga_ops
= {
108 .read
= lx60_fpga_read
,
109 .write
= lx60_fpga_write
,
110 .endianness
= DEVICE_NATIVE_ENDIAN
,
113 static Lx60FpgaState
*lx60_fpga_init(MemoryRegion
*address_space
,
116 Lx60FpgaState
*s
= g_malloc(sizeof(Lx60FpgaState
));
118 memory_region_init_io(&s
->iomem
, NULL
, &lx60_fpga_ops
, s
,
119 "lx60.fpga", 0x10000);
120 memory_region_add_subregion(address_space
, base
, &s
->iomem
);
122 qemu_register_reset(lx60_fpga_reset
, s
);
126 static void lx60_net_init(MemoryRegion
*address_space
,
130 qemu_irq irq
, NICInfo
*nd
)
136 dev
= qdev_create(NULL
, "open_eth");
137 qdev_set_nic_properties(dev
, nd
);
138 qdev_init_nofail(dev
);
140 s
= SYS_BUS_DEVICE(dev
);
141 sysbus_connect_irq(s
, 0, irq
);
142 memory_region_add_subregion(address_space
, base
,
143 sysbus_mmio_get_region(s
, 0));
144 memory_region_add_subregion(address_space
, descriptors
,
145 sysbus_mmio_get_region(s
, 1));
147 ram
= g_malloc(sizeof(*ram
));
148 memory_region_init_ram(ram
, OBJECT(s
), "open_eth.ram", 16384,
150 vmstate_register_ram_global(ram
);
151 memory_region_add_subregion(address_space
, buffers
, ram
);
154 static pflash_t
*xtfpga_flash_init(MemoryRegion
*address_space
,
155 const LxBoardDesc
*board
,
156 DriveInfo
*dinfo
, int be
)
159 DeviceState
*dev
= qdev_create(NULL
, "cfi.pflash01");
161 qdev_prop_set_drive(dev
, "drive", blk_by_legacy_dinfo(dinfo
),
163 qdev_prop_set_uint32(dev
, "num-blocks",
164 board
->flash_size
/ board
->flash_sector_size
);
165 qdev_prop_set_uint64(dev
, "sector-length", board
->flash_sector_size
);
166 qdev_prop_set_uint8(dev
, "width", 4);
167 qdev_prop_set_bit(dev
, "big-endian", be
);
168 qdev_prop_set_string(dev
, "name", "lx60.io.flash");
169 qdev_init_nofail(dev
);
170 s
= SYS_BUS_DEVICE(dev
);
171 memory_region_add_subregion(address_space
, board
->flash_base
,
172 sysbus_mmio_get_region(s
, 0));
173 return OBJECT_CHECK(pflash_t
, (dev
), "cfi.pflash01");
176 static uint64_t translate_phys_addr(void *opaque
, uint64_t addr
)
178 XtensaCPU
*cpu
= opaque
;
180 return cpu_get_phys_page_debug(CPU(cpu
), addr
);
183 static void lx60_reset(void *opaque
)
185 XtensaCPU
*cpu
= opaque
;
190 static uint64_t lx60_io_read(void *opaque
, hwaddr addr
,
196 static void lx60_io_write(void *opaque
, hwaddr addr
,
197 uint64_t val
, unsigned size
)
201 static const MemoryRegionOps lx60_io_ops
= {
202 .read
= lx60_io_read
,
203 .write
= lx60_io_write
,
204 .endianness
= DEVICE_NATIVE_ENDIAN
,
207 static void lx_init(const LxBoardDesc
*board
, MachineState
*machine
)
209 #ifdef TARGET_WORDS_BIGENDIAN
214 MemoryRegion
*system_memory
= get_system_memory();
215 XtensaCPU
*cpu
= NULL
;
216 CPUXtensaState
*env
= NULL
;
217 MemoryRegion
*ram
, *rom
, *system_io
;
219 pflash_t
*flash
= NULL
;
220 QemuOpts
*machine_opts
= qemu_get_machine_opts();
221 const char *cpu_model
= machine
->cpu_model
;
222 const char *kernel_filename
= qemu_opt_get(machine_opts
, "kernel");
223 const char *kernel_cmdline
= qemu_opt_get(machine_opts
, "append");
224 const char *dtb_filename
= qemu_opt_get(machine_opts
, "dtb");
225 const char *initrd_filename
= qemu_opt_get(machine_opts
, "initrd");
229 cpu_model
= XTENSA_DEFAULT_CPU_MODEL
;
232 for (n
= 0; n
< smp_cpus
; n
++) {
233 cpu
= cpu_xtensa_init(cpu_model
);
235 error_report("unable to find CPU definition '%s'",
241 env
->sregs
[PRID
] = n
;
242 qemu_register_reset(lx60_reset
, cpu
);
243 /* Need MMU initialized prior to ELF loading,
244 * so that ELF gets loaded into virtual addresses
249 ram
= g_malloc(sizeof(*ram
));
250 memory_region_init_ram(ram
, NULL
, "lx60.dram", machine
->ram_size
,
252 vmstate_register_ram_global(ram
);
253 memory_region_add_subregion(system_memory
, 0, ram
);
255 system_io
= g_malloc(sizeof(*system_io
));
256 memory_region_init_io(system_io
, NULL
, &lx60_io_ops
, NULL
, "lx60.io",
258 memory_region_add_subregion(system_memory
, 0xf0000000, system_io
);
259 lx60_fpga_init(system_io
, 0x0d020000);
260 if (nd_table
[0].used
) {
261 lx60_net_init(system_io
, 0x0d030000, 0x0d030400, 0x0d800000,
262 xtensa_get_extint(env
, 1), nd_table
);
265 if (!serial_hds
[0]) {
266 serial_hds
[0] = qemu_chr_new("serial0", "null", NULL
);
269 serial_mm_init(system_io
, 0x0d050020, 2, xtensa_get_extint(env
, 0),
270 115200, serial_hds
[0], DEVICE_NATIVE_ENDIAN
);
272 dinfo
= drive_get(IF_PFLASH
, 0, 0);
274 flash
= xtfpga_flash_init(system_io
, board
, dinfo
, be
);
277 /* Use presence of kernel file name as 'boot from SRAM' switch. */
278 if (kernel_filename
) {
279 uint32_t entry_point
= env
->pc
;
280 size_t bp_size
= 3 * get_tag_size(0); /* first/last and memory tags */
281 uint32_t tagptr
= 0xfe000000 + board
->sram_size
;
283 BpMemInfo memory_location
= {
284 .type
= tswap32(MEMORY_TYPE_CONVENTIONAL
),
286 .end
= tswap32(machine
->ram_size
),
288 uint32_t lowmem_end
= machine
->ram_size
< 0x08000000 ?
289 machine
->ram_size
: 0x08000000;
290 uint32_t cur_lowmem
= QEMU_ALIGN_UP(lowmem_end
/ 2, 4096);
292 rom
= g_malloc(sizeof(*rom
));
293 memory_region_init_ram(rom
, NULL
, "lx60.sram", board
->sram_size
,
295 vmstate_register_ram_global(rom
);
296 memory_region_add_subregion(system_memory
, 0xfe000000, rom
);
298 if (kernel_cmdline
) {
299 bp_size
+= get_tag_size(strlen(kernel_cmdline
) + 1);
302 bp_size
+= get_tag_size(sizeof(uint32_t));
304 if (initrd_filename
) {
305 bp_size
+= get_tag_size(sizeof(BpMemInfo
));
308 /* Put kernel bootparameters to the end of that SRAM */
309 tagptr
= (tagptr
- bp_size
) & ~0xff;
310 cur_tagptr
= put_tag(tagptr
, BP_TAG_FIRST
, 0, NULL
);
311 cur_tagptr
= put_tag(cur_tagptr
, BP_TAG_MEMORY
,
312 sizeof(memory_location
), &memory_location
);
314 if (kernel_cmdline
) {
315 cur_tagptr
= put_tag(cur_tagptr
, BP_TAG_COMMAND_LINE
,
316 strlen(kernel_cmdline
) + 1, kernel_cmdline
);
320 void *fdt
= load_device_tree(dtb_filename
, &fdt_size
);
321 uint32_t dtb_addr
= tswap32(cur_lowmem
);
324 error_report("could not load DTB '%s'", dtb_filename
);
328 cpu_physical_memory_write(cur_lowmem
, fdt
, fdt_size
);
329 cur_tagptr
= put_tag(cur_tagptr
, BP_TAG_FDT
,
330 sizeof(dtb_addr
), &dtb_addr
);
331 cur_lowmem
= QEMU_ALIGN_UP(cur_lowmem
+ fdt_size
, 4096);
333 if (initrd_filename
) {
334 BpMemInfo initrd_location
= { 0 };
335 int initrd_size
= load_ramdisk(initrd_filename
, cur_lowmem
,
336 lowmem_end
- cur_lowmem
);
338 if (initrd_size
< 0) {
339 initrd_size
= load_image_targphys(initrd_filename
,
341 lowmem_end
- cur_lowmem
);
343 if (initrd_size
< 0) {
344 error_report("could not load initrd '%s'", initrd_filename
);
347 initrd_location
.start
= tswap32(cur_lowmem
);
348 initrd_location
.end
= tswap32(cur_lowmem
+ initrd_size
);
349 cur_tagptr
= put_tag(cur_tagptr
, BP_TAG_INITRD
,
350 sizeof(initrd_location
), &initrd_location
);
351 cur_lowmem
= QEMU_ALIGN_UP(cur_lowmem
+ initrd_size
, 4096);
353 cur_tagptr
= put_tag(cur_tagptr
, BP_TAG_LAST
, 0, NULL
);
354 env
->regs
[2] = tagptr
;
357 uint64_t elf_lowaddr
;
358 int success
= load_elf(kernel_filename
, translate_phys_addr
, cpu
,
359 &elf_entry
, &elf_lowaddr
, NULL
, be
, EM_XTENSA
, 0, 0);
361 entry_point
= elf_entry
;
365 success
= load_uimage(kernel_filename
, &ep
, NULL
, &is_linux
,
366 translate_phys_addr
, cpu
);
367 if (success
> 0 && is_linux
) {
370 error_report("could not load kernel '%s'",
375 if (entry_point
!= env
->pc
) {
376 static const uint8_t jx_a0
[] = {
377 #ifdef TARGET_WORDS_BIGENDIAN
383 env
->regs
[0] = entry_point
;
384 cpu_physical_memory_write(env
->pc
, jx_a0
, sizeof(jx_a0
));
388 MemoryRegion
*flash_mr
= pflash_cfi01_get_memory(flash
);
389 MemoryRegion
*flash_io
= g_malloc(sizeof(*flash_io
));
391 memory_region_init_alias(flash_io
, NULL
, "lx60.flash",
392 flash_mr
, board
->flash_boot_base
,
393 board
->flash_size
- board
->flash_boot_base
< 0x02000000 ?
394 board
->flash_size
- board
->flash_boot_base
: 0x02000000);
395 memory_region_add_subregion(system_memory
, 0xfe000000,
401 static void xtensa_lx60_init(MachineState
*machine
)
403 static const LxBoardDesc lx60_board
= {
404 .flash_base
= 0x08000000,
405 .flash_size
= 0x00400000,
406 .flash_sector_size
= 0x10000,
407 .sram_size
= 0x20000,
409 lx_init(&lx60_board
, machine
);
412 static void xtensa_lx200_init(MachineState
*machine
)
414 static const LxBoardDesc lx200_board
= {
415 .flash_base
= 0x08000000,
416 .flash_size
= 0x01000000,
417 .flash_sector_size
= 0x20000,
418 .sram_size
= 0x2000000,
420 lx_init(&lx200_board
, machine
);
423 static void xtensa_ml605_init(MachineState
*machine
)
425 static const LxBoardDesc ml605_board
= {
426 .flash_base
= 0x08000000,
427 .flash_size
= 0x01000000,
428 .flash_sector_size
= 0x20000,
429 .sram_size
= 0x2000000,
431 lx_init(&ml605_board
, machine
);
434 static void xtensa_kc705_init(MachineState
*machine
)
436 static const LxBoardDesc kc705_board
= {
437 .flash_base
= 0x00000000,
438 .flash_size
= 0x08000000,
439 .flash_boot_base
= 0x06000000,
440 .flash_sector_size
= 0x20000,
441 .sram_size
= 0x2000000,
443 lx_init(&kc705_board
, machine
);
446 static void xtensa_lx60_class_init(ObjectClass
*oc
, void *data
)
448 MachineClass
*mc
= MACHINE_CLASS(oc
);
450 mc
->desc
= "lx60 EVB (" XTENSA_DEFAULT_CPU_MODEL
")";
451 mc
->init
= xtensa_lx60_init
;
455 static const TypeInfo xtensa_lx60_type
= {
456 .name
= MACHINE_TYPE_NAME("lx60"),
457 .parent
= TYPE_MACHINE
,
458 .class_init
= xtensa_lx60_class_init
,
461 static void xtensa_lx200_class_init(ObjectClass
*oc
, void *data
)
463 MachineClass
*mc
= MACHINE_CLASS(oc
);
465 mc
->desc
= "lx200 EVB (" XTENSA_DEFAULT_CPU_MODEL
")";
466 mc
->init
= xtensa_lx200_init
;
470 static const TypeInfo xtensa_lx200_type
= {
471 .name
= MACHINE_TYPE_NAME("lx200"),
472 .parent
= TYPE_MACHINE
,
473 .class_init
= xtensa_lx200_class_init
,
476 static void xtensa_ml605_class_init(ObjectClass
*oc
, void *data
)
478 MachineClass
*mc
= MACHINE_CLASS(oc
);
480 mc
->desc
= "ml605 EVB (" XTENSA_DEFAULT_CPU_MODEL
")";
481 mc
->init
= xtensa_ml605_init
;
485 static const TypeInfo xtensa_ml605_type
= {
486 .name
= MACHINE_TYPE_NAME("ml605"),
487 .parent
= TYPE_MACHINE
,
488 .class_init
= xtensa_ml605_class_init
,
491 static void xtensa_kc705_class_init(ObjectClass
*oc
, void *data
)
493 MachineClass
*mc
= MACHINE_CLASS(oc
);
495 mc
->desc
= "kc705 EVB (" XTENSA_DEFAULT_CPU_MODEL
")";
496 mc
->init
= xtensa_kc705_init
;
500 static const TypeInfo xtensa_kc705_type
= {
501 .name
= MACHINE_TYPE_NAME("kc705"),
502 .parent
= TYPE_MACHINE
,
503 .class_init
= xtensa_kc705_class_init
,
506 static void xtensa_lx_machines_init(void)
508 type_register_static(&xtensa_lx60_type
);
509 type_register_static(&xtensa_lx200_type
);
510 type_register_static(&xtensa_ml605_type
);
511 type_register_static(&xtensa_kc705_type
);
514 type_init(xtensa_lx_machines_init
)