/* Flattened device tree describing the machine to the guest. */ #include #include #include "machine_internal.h" /* Fixed buffers bound every FDT operation independently of guest input. */ struct fdt_builder { u8 structure[24576]; u8 strings[8192]; u64 reservations[64]; u32 structure_size; u32 strings_size; u32 reservation_count; bool valid; }; static void be32(u8 *out, u32 value) { out[0] = value >> 24; out[1] = value >> 16; out[2] = value >> 8; out[3] = value; } static void be64(u8 *out, u64 value) { be32(out, (u32)(value >> 32)); be32(out + 4, (u32)value); } static void bytes(struct fdt_builder *f, const void *data, u32 size) { u32 padded = (size + 3) & ~3U; if (padded > sizeof(f->structure) - f->structure_size) { f->valid = false; return; } memcpy(f->structure + f->structure_size, data, size); memset(f->structure + f->structure_size + size, 0, padded - size); f->structure_size += padded; } static void word(struct fdt_builder *f, u32 value) { u8 buffer[4]; be32(buffer, value); bytes(f, buffer, 4); } static void begin(struct fdt_builder *f, const char *name) { word(f, 1); bytes(f, name, (u32)strlen(name) + 1); } static void end(struct fdt_builder *f) { word(f, 2); } static void property( struct fdt_builder *f, const char *name, const void *value, u32 size ) { u32 length = (u32)strlen(name) + 1; if (length > sizeof(f->strings) - f->strings_size) { f->valid = false; return; } word(f, 3); word(f, size); word(f, f->strings_size); memcpy(f->strings + f->strings_size, name, length); f->strings_size += length; bytes(f, value, size); } static void string(struct fdt_builder *f, const char *name, const char *value) { property(f, name, value, (u32)strlen(value) + 1); } static void scalar(struct fdt_builder *f, const char *name, u32 value) { u8 buffer[4]; be32(buffer, value); property(f, name, buffer, sizeof(buffer)); } static void region( struct fdt_builder *f, const char *name, u64 base, u64 size ) { u8 buffer[16]; be64(buffer, base); be64(buffer + 8, size); property(f, name, buffer, sizeof(buffer)); } static void reserved( struct fdt_builder *f, const char *kind, u64 base, u64 size ) { if (!size) return; if (f->reservation_count + 2 > sizeof(f->reservations) / sizeof(f->reservations[0])) { f->valid = false; return; } f->reservations[f->reservation_count++] = base; f->reservations[f->reservation_count++] = size; char name[64]; snprintf(name, sizeof(name), "%s@%llx", kind, base); begin(f, name); region(f, "reg", base, size); property(f, "no-map", "", 0); end(f); } bool machine_fdt(struct machine *m) { struct fdt_builder f = { .valid = true }; const struct machine_config *c = m->config; begin(&f, ""); scalar(&f, "#address-cells", 2); scalar(&f, "#size-cells", 2); string(&f, "compatible", "radiance,rv64-machine"); string(&f, "model", "Radiance deterministic RV64IMA machine"); begin(&f, "chosen"); string(&f, "stdout-path", "/soc/uart@10000000"); u8 entry[8]; be64(entry, c->entry); property(&f, "radiance,kernel-entry", entry, sizeof(entry)); region(&f, "radiance,kernel-text", c->text.base, c->text.size); region(&f, "radiance,kernel-rodata", c->rodata.base, c->rodata.size); region(&f, "radiance,kernel-rwdata", c->rwdata.base, c->rwdata.size); region(&f, "radiance,fdt-reservation", MACHINE_FDT_BASE, MACHINE_FDT_SIZE); u8 stacks[MACHINE_MAX_HARTS * 16]; for (u32 id = 0; id < c->hart_count; id++) { be64(stacks + id * 16, m->stack_base[id]); be64(stacks + id * 16 + 8, c->stack_size); } property(&f, "radiance,kernel-stacks", stacks, c->hart_count * 16); end(&f); char memory_name[40]; snprintf(memory_name, sizeof(memory_name), "memory@%llx", MACHINE_RAM_BASE); begin(&f, memory_name); string(&f, "device_type", "memory"); region(&f, "reg", MACHINE_RAM_BASE, c->memory_size); end(&f); begin(&f, "reserved-memory"); scalar(&f, "#address-cells", 2); scalar(&f, "#size-cells", 2); property(&f, "ranges", "", 0); reserved(&f, "kernel-text", c->text.base, c->text.size); reserved(&f, "kernel-rodata", c->rodata.base, c->rodata.size); reserved(&f, "kernel-rwdata", c->rwdata.base, c->rwdata.size); reserved(&f, "fdt", MACHINE_FDT_BASE, MACHINE_FDT_SIZE); for (u32 id = 0; id < c->hart_count; id++) reserved(&f, "kernel-stack", m->stack_base[id], c->stack_size); reserved(&f, "clint-aperture", MACHINE_CLINT_BASE, MACHINE_CLINT_SIZE); reserved(&f, "plic-aperture", MACHINE_PLIC_BASE, MACHINE_PLIC_SIZE); /* The UART and finish pages. */ reserved(&f, "console-aperture", MACHINE_UART_BASE, 2 * MACHINE_UART_SIZE); end(&f); begin(&f, "cpus"); scalar(&f, "#address-cells", 1); scalar(&f, "#size-cells", 0); scalar(&f, "timebase-frequency", MACHINE_TIMEBASE); for (u32 id = 0; id < c->hart_count; id++) { char name[24]; snprintf(name, sizeof(name), "cpu@%x", id); begin(&f, name); string(&f, "device_type", "cpu"); string(&f, "compatible", "riscv"); scalar(&f, "reg", id); string(&f, "status", "okay"); string( &f, "riscv,isa", "rv64ima_zba_zbb_zbs_zicsr_zifencei_zvbb_zve64x_zvl256b" ); begin(&f, "interrupt-controller"); scalar(&f, "#interrupt-cells", 1); property(&f, "interrupt-controller", "", 0); string(&f, "compatible", "riscv,cpu-intc"); scalar(&f, "phandle", id + 1); end(&f); end(&f); } end(&f); begin(&f, "soc"); scalar(&f, "#address-cells", 2); scalar(&f, "#size-cells", 2); string(&f, "compatible", "simple-bus"); property(&f, "ranges", "", 0); begin(&f, "clint@2000000"); string(&f, "compatible", "riscv,clint0"); region(&f, "reg", MACHINE_CLINT_BASE, MACHINE_CLINT_SIZE); u8 local_interrupts[MACHINE_MAX_HARTS * 16]; for (u32 id = 0; id < c->hart_count; id++) { be32(local_interrupts + id * 16, id + 1); be32(local_interrupts + id * 16 + 4, 3); be32(local_interrupts + id * 16 + 8, id + 1); be32(local_interrupts + id * 16 + 12, 7); } property(&f, "interrupts-extended", local_interrupts, c->hart_count * 16); end(&f); begin(&f, "plic@c000000"); string(&f, "compatible", "riscv,plic0"); region(&f, "reg", MACHINE_PLIC_BASE, MACHINE_PLIC_SIZE); scalar(&f, "#interrupt-cells", 1); scalar(&f, "#address-cells", 0); property(&f, "interrupt-controller", "", 0); scalar(&f, "phandle", 0x100); scalar(&f, "riscv,ndev", MACHINE_IRQ_COUNT); scalar(&f, "riscv,max-priority", 7); u8 external_interrupts[MACHINE_MAX_HARTS * 8]; for (u32 id = 0; id < c->hart_count; id++) { be32(external_interrupts + id * 8, id + 1); be32(external_interrupts + id * 8 + 4, 11); } property(&f, "interrupts-extended", external_interrupts, c->hart_count * 8); end(&f); begin(&f, "uart@10000000"); string(&f, "compatible", "ns16550a"); region(&f, "reg", MACHINE_UART_BASE, 0x100); scalar(&f, "clock-frequency", 1843200); scalar(&f, "current-speed", 115200); scalar(&f, "reg-shift", 0); scalar(&f, "reg-io-width", 1); scalar(&f, "interrupt-parent", 0x100); scalar(&f, "interrupts", MACHINE_UART_IRQ); end(&f); begin(&f, "finish@10001000"); string(&f, "compatible", "radiant,finish"); region(&f, "reg", MACHINE_FINISH_BASE, 4); scalar(&f, "radiance,success-value", 0x5555); scalar(&f, "radiance,failure-mask", 0xffff); scalar(&f, "radiance,failure-value", 0x3333); end(&f); end(&f); end(&f); word(&f, 9); u32 reserve_size = (f.reservation_count + 2) * 8; u32 structure_offset = 40 + reserve_size; u32 strings_offset = structure_offset + f.structure_size; u32 total = strings_offset + f.strings_size; if (!f.valid || total > MACHINE_FDT_SIZE) return false; u8 *out = c->ram + (MACHINE_FDT_BASE - MACHINE_RAM_BASE); memset(out, 0, MACHINE_FDT_SIZE); const u32 header[] = { 0xd00dfeed, total, structure_offset, strings_offset, 40, 17, 16, 0, f.strings_size, f.structure_size }; for (u32 i = 0; i < 10; i++) be32(out + i * 4, header[i]); for (u32 i = 0; i < f.reservation_count; i++) be64(out + 40 + i * 8, f.reservations[i]); memcpy(out + structure_offset, f.structure, f.structure_size); memcpy(out + strings_offset, f.strings, f.strings_size); return true; }