1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include "qemu/osdep.h"
29#include "qemu/units.h"
30#include "qapi/error.h"
31#include "cpu.h"
32#include "sysemu/sysemu.h"
33#include "hw/boards.h"
34#include "hw/loader.h"
35#include "elf.h"
36#include "exec/memory.h"
37#include "exec/address-spaces.h"
38#include "hw/char/serial.h"
39#include "net/net.h"
40#include "hw/sysbus.h"
41#include "hw/block/flash.h"
42#include "chardev/char.h"
43#include "sysemu/device_tree.h"
44#include "qemu/error-report.h"
45#include "qemu/option.h"
46#include "bootparam.h"
47#include "xtensa_memory.h"
48
49typedef struct XtfpgaFlashDesc {
50 hwaddr base;
51 size_t size;
52 size_t boot_base;
53 size_t sector_size;
54} XtfpgaFlashDesc;
55
56typedef struct XtfpgaBoardDesc {
57 const XtfpgaFlashDesc *flash;
58 size_t sram_size;
59 const hwaddr *io;
60} XtfpgaBoardDesc;
61
62typedef struct XtfpgaFpgaState {
63 MemoryRegion iomem;
64 uint32_t leds;
65 uint32_t switches;
66} XtfpgaFpgaState;
67
68static void xtfpga_fpga_reset(void *opaque)
69{
70 XtfpgaFpgaState *s = opaque;
71
72 s->leds = 0;
73 s->switches = 0;
74}
75
76static uint64_t xtfpga_fpga_read(void *opaque, hwaddr addr,
77 unsigned size)
78{
79 XtfpgaFpgaState *s = opaque;
80
81 switch (addr) {
82 case 0x0:
83 return 0x09272011;
84
85 case 0x4:
86 return 10000000;
87
88 case 0x8:
89 return s->leds;
90
91 case 0xc:
92 return s->switches;
93 }
94 return 0;
95}
96
97static void xtfpga_fpga_write(void *opaque, hwaddr addr,
98 uint64_t val, unsigned size)
99{
100 XtfpgaFpgaState *s = opaque;
101
102 switch (addr) {
103 case 0x8:
104 s->leds = val;
105 break;
106
107 case 0x10:
108 if (val == 0xdead) {
109 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET);
110 }
111 break;
112 }
113}
114
115static const MemoryRegionOps xtfpga_fpga_ops = {
116 .read = xtfpga_fpga_read,
117 .write = xtfpga_fpga_write,
118 .endianness = DEVICE_NATIVE_ENDIAN,
119};
120
121static XtfpgaFpgaState *xtfpga_fpga_init(MemoryRegion *address_space,
122 hwaddr base)
123{
124 XtfpgaFpgaState *s = g_malloc(sizeof(XtfpgaFpgaState));
125
126 memory_region_init_io(&s->iomem, NULL, &xtfpga_fpga_ops, s,
127 "xtfpga.fpga", 0x10000);
128 memory_region_add_subregion(address_space, base, &s->iomem);
129 xtfpga_fpga_reset(s);
130 qemu_register_reset(xtfpga_fpga_reset, s);
131 return s;
132}
133
134static void xtfpga_net_init(MemoryRegion *address_space,
135 hwaddr base,
136 hwaddr descriptors,
137 hwaddr buffers,
138 qemu_irq irq, NICInfo *nd)
139{
140 DeviceState *dev;
141 SysBusDevice *s;
142 MemoryRegion *ram;
143
144 dev = qdev_create(NULL, "open_eth");
145 qdev_set_nic_properties(dev, nd);
146 qdev_init_nofail(dev);
147
148 s = SYS_BUS_DEVICE(dev);
149 sysbus_connect_irq(s, 0, irq);
150 memory_region_add_subregion(address_space, base,
151 sysbus_mmio_get_region(s, 0));
152 memory_region_add_subregion(address_space, descriptors,
153 sysbus_mmio_get_region(s, 1));
154
155 ram = g_malloc(sizeof(*ram));
156 memory_region_init_ram_nomigrate(ram, OBJECT(s), "open_eth.ram", 16 * KiB,
157 &error_fatal);
158 vmstate_register_ram_global(ram);
159 memory_region_add_subregion(address_space, buffers, ram);
160}
161
162static PFlashCFI01 *xtfpga_flash_init(MemoryRegion *address_space,
163 const XtfpgaBoardDesc *board,
164 DriveInfo *dinfo, int be)
165{
166 SysBusDevice *s;
167 DeviceState *dev = qdev_create(NULL, TYPE_PFLASH_CFI01);
168
169 qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo),
170 &error_abort);
171 qdev_prop_set_uint32(dev, "num-blocks",
172 board->flash->size / board->flash->sector_size);
173 qdev_prop_set_uint64(dev, "sector-length", board->flash->sector_size);
174 qdev_prop_set_uint8(dev, "width", 2);
175 qdev_prop_set_bit(dev, "big-endian", be);
176 qdev_prop_set_string(dev, "name", "xtfpga.io.flash");
177 qdev_init_nofail(dev);
178 s = SYS_BUS_DEVICE(dev);
179 memory_region_add_subregion(address_space, board->flash->base,
180 sysbus_mmio_get_region(s, 0));
181 return PFLASH_CFI01(dev);
182}
183
184static uint64_t translate_phys_addr(void *opaque, uint64_t addr)
185{
186 XtensaCPU *cpu = opaque;
187
188 return cpu_get_phys_page_debug(CPU(cpu), addr);
189}
190
191static void xtfpga_reset(void *opaque)
192{
193 XtensaCPU *cpu = opaque;
194
195 cpu_reset(CPU(cpu));
196}
197
198static uint64_t xtfpga_io_read(void *opaque, hwaddr addr,
199 unsigned size)
200{
201 return 0;
202}
203
204static void xtfpga_io_write(void *opaque, hwaddr addr,
205 uint64_t val, unsigned size)
206{
207}
208
209static const MemoryRegionOps xtfpga_io_ops = {
210 .read = xtfpga_io_read,
211 .write = xtfpga_io_write,
212 .endianness = DEVICE_NATIVE_ENDIAN,
213};
214
215static void xtfpga_init(const XtfpgaBoardDesc *board, MachineState *machine)
216{
217#ifdef TARGET_WORDS_BIGENDIAN
218 int be = 1;
219#else
220 int be = 0;
221#endif
222 MemoryRegion *system_memory = get_system_memory();
223 XtensaCPU *cpu = NULL;
224 CPUXtensaState *env = NULL;
225 MemoryRegion *system_io;
226 DriveInfo *dinfo;
227 PFlashCFI01 *flash = NULL;
228 QemuOpts *machine_opts = qemu_get_machine_opts();
229 const char *kernel_filename = qemu_opt_get(machine_opts, "kernel");
230 const char *kernel_cmdline = qemu_opt_get(machine_opts, "append");
231 const char *dtb_filename = qemu_opt_get(machine_opts, "dtb");
232 const char *initrd_filename = qemu_opt_get(machine_opts, "initrd");
233 const unsigned system_io_size = 224 * MiB;
234 int n;
235
236 for (n = 0; n < smp_cpus; n++) {
237 cpu = XTENSA_CPU(cpu_create(machine->cpu_type));
238 env = &cpu->env;
239
240 env->sregs[PRID] = n;
241 qemu_register_reset(xtfpga_reset, cpu);
242
243
244
245 cpu_reset(CPU(cpu));
246 }
247
248 if (env) {
249 XtensaMemory sysram = env->config->sysram;
250
251 sysram.location[0].size = machine->ram_size;
252 xtensa_create_memory_regions(&env->config->instrom, "xtensa.instrom",
253 system_memory);
254 xtensa_create_memory_regions(&env->config->instram, "xtensa.instram",
255 system_memory);
256 xtensa_create_memory_regions(&env->config->datarom, "xtensa.datarom",
257 system_memory);
258 xtensa_create_memory_regions(&env->config->dataram, "xtensa.dataram",
259 system_memory);
260 xtensa_create_memory_regions(&sysram, "xtensa.sysram",
261 system_memory);
262 }
263
264 system_io = g_malloc(sizeof(*system_io));
265 memory_region_init_io(system_io, NULL, &xtfpga_io_ops, NULL, "xtfpga.io",
266 system_io_size);
267 memory_region_add_subregion(system_memory, board->io[0], system_io);
268 if (board->io[1]) {
269 MemoryRegion *io = g_malloc(sizeof(*io));
270
271 memory_region_init_alias(io, NULL, "xtfpga.io.cached",
272 system_io, 0, system_io_size);
273 memory_region_add_subregion(system_memory, board->io[1], io);
274 }
275 xtfpga_fpga_init(system_io, 0x0d020000);
276 if (nd_table[0].used) {
277 xtfpga_net_init(system_io, 0x0d030000, 0x0d030400, 0x0d800000,
278 xtensa_get_extint(env, 1), nd_table);
279 }
280
281 serial_mm_init(system_io, 0x0d050020, 2, xtensa_get_extint(env, 0),
282 115200, serial_hd(0), DEVICE_NATIVE_ENDIAN);
283
284 dinfo = drive_get(IF_PFLASH, 0, 0);
285 if (dinfo) {
286 flash = xtfpga_flash_init(system_io, board, dinfo, be);
287 }
288
289
290 if (kernel_filename) {
291 uint32_t entry_point = env->pc;
292 size_t bp_size = 3 * get_tag_size(0);
293 uint32_t tagptr = env->config->sysrom.location[0].addr +
294 board->sram_size;
295 uint32_t cur_tagptr;
296 BpMemInfo memory_location = {
297 .type = tswap32(MEMORY_TYPE_CONVENTIONAL),
298 .start = tswap32(env->config->sysram.location[0].addr),
299 .end = tswap32(env->config->sysram.location[0].addr +
300 machine->ram_size),
301 };
302 uint32_t lowmem_end = machine->ram_size < 0x08000000 ?
303 machine->ram_size : 0x08000000;
304 uint32_t cur_lowmem = QEMU_ALIGN_UP(lowmem_end / 2, 4096);
305
306 lowmem_end += env->config->sysram.location[0].addr;
307 cur_lowmem += env->config->sysram.location[0].addr;
308
309 xtensa_create_memory_regions(&env->config->sysrom, "xtensa.sysrom",
310 system_memory);
311
312 if (kernel_cmdline) {
313 bp_size += get_tag_size(strlen(kernel_cmdline) + 1);
314 }
315 if (dtb_filename) {
316 bp_size += get_tag_size(sizeof(uint32_t));
317 }
318 if (initrd_filename) {
319 bp_size += get_tag_size(sizeof(BpMemInfo));
320 }
321
322
323 tagptr = (tagptr - bp_size) & ~0xff;
324 cur_tagptr = put_tag(tagptr, BP_TAG_FIRST, 0, NULL);
325 cur_tagptr = put_tag(cur_tagptr, BP_TAG_MEMORY,
326 sizeof(memory_location), &memory_location);
327
328 if (kernel_cmdline) {
329 cur_tagptr = put_tag(cur_tagptr, BP_TAG_COMMAND_LINE,
330 strlen(kernel_cmdline) + 1, kernel_cmdline);
331 }
332#ifdef CONFIG_FDT
333 if (dtb_filename) {
334 int fdt_size;
335 void *fdt = load_device_tree(dtb_filename, &fdt_size);
336 uint32_t dtb_addr = tswap32(cur_lowmem);
337
338 if (!fdt) {
339 error_report("could not load DTB '%s'", dtb_filename);
340 exit(EXIT_FAILURE);
341 }
342
343 cpu_physical_memory_write(cur_lowmem, fdt, fdt_size);
344 cur_tagptr = put_tag(cur_tagptr, BP_TAG_FDT,
345 sizeof(dtb_addr), &dtb_addr);
346 cur_lowmem = QEMU_ALIGN_UP(cur_lowmem + fdt_size, 4 * KiB);
347 }
348#else
349 if (dtb_filename) {
350 error_report("could not load DTB '%s': "
351 "FDT support is not configured in QEMU",
352 dtb_filename);
353 exit(EXIT_FAILURE);
354 }
355#endif
356 if (initrd_filename) {
357 BpMemInfo initrd_location = { 0 };
358 int initrd_size = load_ramdisk(initrd_filename, cur_lowmem,
359 lowmem_end - cur_lowmem);
360
361 if (initrd_size < 0) {
362 initrd_size = load_image_targphys(initrd_filename,
363 cur_lowmem,
364 lowmem_end - cur_lowmem);
365 }
366 if (initrd_size < 0) {
367 error_report("could not load initrd '%s'", initrd_filename);
368 exit(EXIT_FAILURE);
369 }
370 initrd_location.start = tswap32(cur_lowmem);
371 initrd_location.end = tswap32(cur_lowmem + initrd_size);
372 cur_tagptr = put_tag(cur_tagptr, BP_TAG_INITRD,
373 sizeof(initrd_location), &initrd_location);
374 cur_lowmem = QEMU_ALIGN_UP(cur_lowmem + initrd_size, 4 * KiB);
375 }
376 cur_tagptr = put_tag(cur_tagptr, BP_TAG_LAST, 0, NULL);
377 env->regs[2] = tagptr;
378
379 uint64_t elf_entry;
380 uint64_t elf_lowaddr;
381 int success = load_elf(kernel_filename, translate_phys_addr, cpu,
382 &elf_entry, &elf_lowaddr, NULL, be, EM_XTENSA, 0, 0);
383 if (success > 0) {
384 entry_point = elf_entry;
385 } else {
386 hwaddr ep;
387 int is_linux;
388 success = load_uimage(kernel_filename, &ep, NULL, &is_linux,
389 translate_phys_addr, cpu);
390 if (success > 0 && is_linux) {
391 entry_point = ep;
392 } else {
393 error_report("could not load kernel '%s'",
394 kernel_filename);
395 exit(EXIT_FAILURE);
396 }
397 }
398 if (entry_point != env->pc) {
399 uint8_t boot[] = {
400#ifdef TARGET_WORDS_BIGENDIAN
401 0x60, 0x00, 0x08,
402 0x00,
403 0x00, 0x00, 0x00, 0x00,
404 0x00, 0x00, 0x00, 0x00,
405
406 0x10, 0xff, 0xfe,
407 0x12, 0xff, 0xfe,
408 0x0a, 0x00, 0x00,
409#else
410 0x06, 0x02, 0x00,
411 0x00,
412 0x00, 0x00, 0x00, 0x00,
413 0x00, 0x00, 0x00, 0x00,
414
415 0x01, 0xfe, 0xff,
416 0x21, 0xfe, 0xff,
417 0xa0, 0x00, 0x00,
418#endif
419 };
420 uint32_t entry_pc = tswap32(entry_point);
421 uint32_t entry_a2 = tswap32(tagptr);
422
423 memcpy(boot + 4, &entry_pc, sizeof(entry_pc));
424 memcpy(boot + 8, &entry_a2, sizeof(entry_a2));
425 cpu_physical_memory_write(env->pc, boot, sizeof(boot));
426 }
427 } else {
428 if (flash) {
429 MemoryRegion *flash_mr = pflash_cfi01_get_memory(flash);
430 MemoryRegion *flash_io = g_malloc(sizeof(*flash_io));
431 uint32_t size = env->config->sysrom.location[0].size;
432
433 if (board->flash->size - board->flash->boot_base < size) {
434 size = board->flash->size - board->flash->boot_base;
435 }
436
437 memory_region_init_alias(flash_io, NULL, "xtfpga.flash",
438 flash_mr, board->flash->boot_base, size);
439 memory_region_add_subregion(system_memory,
440 env->config->sysrom.location[0].addr,
441 flash_io);
442 } else {
443 xtensa_create_memory_regions(&env->config->sysrom, "xtensa.sysrom",
444 system_memory);
445 }
446 }
447}
448
449#define XTFPGA_MMU_RESERVED_MEMORY_SIZE (128 * MiB)
450
451static const hwaddr xtfpga_mmu_io[2] = {
452 0xf0000000,
453};
454
455static const hwaddr xtfpga_nommu_io[2] = {
456 0x90000000,
457 0x70000000,
458};
459
460static const XtfpgaFlashDesc lx60_flash = {
461 .base = 0x08000000,
462 .size = 0x00400000,
463 .sector_size = 0x10000,
464};
465
466static void xtfpga_lx60_init(MachineState *machine)
467{
468 static const XtfpgaBoardDesc lx60_board = {
469 .flash = &lx60_flash,
470 .sram_size = 0x20000,
471 .io = xtfpga_mmu_io,
472 };
473 xtfpga_init(&lx60_board, machine);
474}
475
476static void xtfpga_lx60_nommu_init(MachineState *machine)
477{
478 static const XtfpgaBoardDesc lx60_board = {
479 .flash = &lx60_flash,
480 .sram_size = 0x20000,
481 .io = xtfpga_nommu_io,
482 };
483 xtfpga_init(&lx60_board, machine);
484}
485
486static const XtfpgaFlashDesc lx200_flash = {
487 .base = 0x08000000,
488 .size = 0x01000000,
489 .sector_size = 0x20000,
490};
491
492static void xtfpga_lx200_init(MachineState *machine)
493{
494 static const XtfpgaBoardDesc lx200_board = {
495 .flash = &lx200_flash,
496 .sram_size = 0x2000000,
497 .io = xtfpga_mmu_io,
498 };
499 xtfpga_init(&lx200_board, machine);
500}
501
502static void xtfpga_lx200_nommu_init(MachineState *machine)
503{
504 static const XtfpgaBoardDesc lx200_board = {
505 .flash = &lx200_flash,
506 .sram_size = 0x2000000,
507 .io = xtfpga_nommu_io,
508 };
509 xtfpga_init(&lx200_board, machine);
510}
511
512static const XtfpgaFlashDesc ml605_flash = {
513 .base = 0x08000000,
514 .size = 0x01000000,
515 .sector_size = 0x20000,
516};
517
518static void xtfpga_ml605_init(MachineState *machine)
519{
520 static const XtfpgaBoardDesc ml605_board = {
521 .flash = &ml605_flash,
522 .sram_size = 0x2000000,
523 .io = xtfpga_mmu_io,
524 };
525 xtfpga_init(&ml605_board, machine);
526}
527
528static void xtfpga_ml605_nommu_init(MachineState *machine)
529{
530 static const XtfpgaBoardDesc ml605_board = {
531 .flash = &ml605_flash,
532 .sram_size = 0x2000000,
533 .io = xtfpga_nommu_io,
534 };
535 xtfpga_init(&ml605_board, machine);
536}
537
538static const XtfpgaFlashDesc kc705_flash = {
539 .base = 0x00000000,
540 .size = 0x08000000,
541 .boot_base = 0x06000000,
542 .sector_size = 0x20000,
543};
544
545static void xtfpga_kc705_init(MachineState *machine)
546{
547 static const XtfpgaBoardDesc kc705_board = {
548 .flash = &kc705_flash,
549 .sram_size = 0x2000000,
550 .io = xtfpga_mmu_io,
551 };
552 xtfpga_init(&kc705_board, machine);
553}
554
555static void xtfpga_kc705_nommu_init(MachineState *machine)
556{
557 static const XtfpgaBoardDesc kc705_board = {
558 .flash = &kc705_flash,
559 .sram_size = 0x2000000,
560 .io = xtfpga_nommu_io,
561 };
562 xtfpga_init(&kc705_board, machine);
563}
564
565static void xtfpga_lx60_class_init(ObjectClass *oc, void *data)
566{
567 MachineClass *mc = MACHINE_CLASS(oc);
568
569 mc->desc = "lx60 EVB (" XTENSA_DEFAULT_CPU_MODEL ")";
570 mc->init = xtfpga_lx60_init;
571 mc->max_cpus = 4;
572 mc->default_cpu_type = XTENSA_DEFAULT_CPU_TYPE;
573 mc->default_ram_size = 64 * MiB;
574}
575
576static const TypeInfo xtfpga_lx60_type = {
577 .name = MACHINE_TYPE_NAME("lx60"),
578 .parent = TYPE_MACHINE,
579 .class_init = xtfpga_lx60_class_init,
580};
581
582static void xtfpga_lx60_nommu_class_init(ObjectClass *oc, void *data)
583{
584 MachineClass *mc = MACHINE_CLASS(oc);
585
586 mc->desc = "lx60 noMMU EVB (" XTENSA_DEFAULT_CPU_NOMMU_MODEL ")";
587 mc->init = xtfpga_lx60_nommu_init;
588 mc->max_cpus = 4;
589 mc->default_cpu_type = XTENSA_DEFAULT_CPU_NOMMU_TYPE;
590 mc->default_ram_size = 64 * MiB;
591}
592
593static const TypeInfo xtfpga_lx60_nommu_type = {
594 .name = MACHINE_TYPE_NAME("lx60-nommu"),
595 .parent = TYPE_MACHINE,
596 .class_init = xtfpga_lx60_nommu_class_init,
597};
598
599static void xtfpga_lx200_class_init(ObjectClass *oc, void *data)
600{
601 MachineClass *mc = MACHINE_CLASS(oc);
602
603 mc->desc = "lx200 EVB (" XTENSA_DEFAULT_CPU_MODEL ")";
604 mc->init = xtfpga_lx200_init;
605 mc->max_cpus = 4;
606 mc->default_cpu_type = XTENSA_DEFAULT_CPU_TYPE;
607 mc->default_ram_size = 96 * MiB;
608}
609
610static const TypeInfo xtfpga_lx200_type = {
611 .name = MACHINE_TYPE_NAME("lx200"),
612 .parent = TYPE_MACHINE,
613 .class_init = xtfpga_lx200_class_init,
614};
615
616static void xtfpga_lx200_nommu_class_init(ObjectClass *oc, void *data)
617{
618 MachineClass *mc = MACHINE_CLASS(oc);
619
620 mc->desc = "lx200 noMMU EVB (" XTENSA_DEFAULT_CPU_NOMMU_MODEL ")";
621 mc->init = xtfpga_lx200_nommu_init;
622 mc->max_cpus = 4;
623 mc->default_cpu_type = XTENSA_DEFAULT_CPU_NOMMU_TYPE;
624 mc->default_ram_size = 96 * MiB;
625}
626
627static const TypeInfo xtfpga_lx200_nommu_type = {
628 .name = MACHINE_TYPE_NAME("lx200-nommu"),
629 .parent = TYPE_MACHINE,
630 .class_init = xtfpga_lx200_nommu_class_init,
631};
632
633static void xtfpga_ml605_class_init(ObjectClass *oc, void *data)
634{
635 MachineClass *mc = MACHINE_CLASS(oc);
636
637 mc->desc = "ml605 EVB (" XTENSA_DEFAULT_CPU_MODEL ")";
638 mc->init = xtfpga_ml605_init;
639 mc->max_cpus = 4;
640 mc->default_cpu_type = XTENSA_DEFAULT_CPU_TYPE;
641 mc->default_ram_size = 512 * MiB - XTFPGA_MMU_RESERVED_MEMORY_SIZE;
642}
643
644static const TypeInfo xtfpga_ml605_type = {
645 .name = MACHINE_TYPE_NAME("ml605"),
646 .parent = TYPE_MACHINE,
647 .class_init = xtfpga_ml605_class_init,
648};
649
650static void xtfpga_ml605_nommu_class_init(ObjectClass *oc, void *data)
651{
652 MachineClass *mc = MACHINE_CLASS(oc);
653
654 mc->desc = "ml605 noMMU EVB (" XTENSA_DEFAULT_CPU_NOMMU_MODEL ")";
655 mc->init = xtfpga_ml605_nommu_init;
656 mc->max_cpus = 4;
657 mc->default_cpu_type = XTENSA_DEFAULT_CPU_NOMMU_TYPE;
658 mc->default_ram_size = 256 * MiB;
659}
660
661static const TypeInfo xtfpga_ml605_nommu_type = {
662 .name = MACHINE_TYPE_NAME("ml605-nommu"),
663 .parent = TYPE_MACHINE,
664 .class_init = xtfpga_ml605_nommu_class_init,
665};
666
667static void xtfpga_kc705_class_init(ObjectClass *oc, void *data)
668{
669 MachineClass *mc = MACHINE_CLASS(oc);
670
671 mc->desc = "kc705 EVB (" XTENSA_DEFAULT_CPU_MODEL ")";
672 mc->init = xtfpga_kc705_init;
673 mc->max_cpus = 4;
674 mc->default_cpu_type = XTENSA_DEFAULT_CPU_TYPE;
675 mc->default_ram_size = 1 * GiB - XTFPGA_MMU_RESERVED_MEMORY_SIZE;
676}
677
678static const TypeInfo xtfpga_kc705_type = {
679 .name = MACHINE_TYPE_NAME("kc705"),
680 .parent = TYPE_MACHINE,
681 .class_init = xtfpga_kc705_class_init,
682};
683
684static void xtfpga_kc705_nommu_class_init(ObjectClass *oc, void *data)
685{
686 MachineClass *mc = MACHINE_CLASS(oc);
687
688 mc->desc = "kc705 noMMU EVB (" XTENSA_DEFAULT_CPU_NOMMU_MODEL ")";
689 mc->init = xtfpga_kc705_nommu_init;
690 mc->max_cpus = 4;
691 mc->default_cpu_type = XTENSA_DEFAULT_CPU_NOMMU_TYPE;
692 mc->default_ram_size = 256 * MiB;
693}
694
695static const TypeInfo xtfpga_kc705_nommu_type = {
696 .name = MACHINE_TYPE_NAME("kc705-nommu"),
697 .parent = TYPE_MACHINE,
698 .class_init = xtfpga_kc705_nommu_class_init,
699};
700
701static void xtfpga_machines_init(void)
702{
703 type_register_static(&xtfpga_lx60_type);
704 type_register_static(&xtfpga_lx200_type);
705 type_register_static(&xtfpga_ml605_type);
706 type_register_static(&xtfpga_kc705_type);
707 type_register_static(&xtfpga_lx60_nommu_type);
708 type_register_static(&xtfpga_lx200_nommu_type);
709 type_register_static(&xtfpga_ml605_nommu_type);
710 type_register_static(&xtfpga_kc705_nommu_type);
711}
712
713type_init(xtfpga_machines_init)
714