/* $NetBSD: efifdt.c,v 1.38 2024/12/07 19:29:04 jmcneill Exp $ */ /*- * Copyright (c) 2019 Jason R. Thorpe * Copyright (c) 2018 Jared McNeill * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "efiboot.h" #include "efifdt.h" #include "efiblock.h" #include "overlay.h" #include "module.h" #ifdef EFIBOOT_ACPI #include "efiacpi.h" #endif #include #define FDT_TABLE_GUID \ { 0xb1b621d5, 0xf19c, 0x41a5, { 0x83, 0x0b, 0xd9, 0x15, 0x2c, 0x69, 0xaa, 0xe0 } } static EFI_GUID FdtTableGuid = FDT_TABLE_GUID; #define FDT_MEMORY_NODE_PATH "/memory" #define FDT_MEMORY_NODE_NAME "memory" #define FDT_CHOSEN_NODE_PATH "/chosen" #define FDT_CHOSEN_NODE_NAME "chosen" #define FDT_MEMORY_USABLE(_md) \ ((_md)->Type == EfiLoaderCode || (_md)->Type == EfiLoaderData || \ (_md)->Type == EfiBootServicesCode || (_md)->Type == EfiBootServicesData || \ (_md)->Type == EfiConventionalMemory) #define FDT_SPACE (4 * 1024 * 1024) #define FDT_ALIGN (2 * 1024 * 1024) #ifdef _LP64 #define PRIdUINTN "ld" #define PRIxUINTN "lx" #else #define PRIdUINTN "d" #define PRIxUINTN "x" #endif static void *fdt_data = NULL; static size_t fdt_data_size = 512*1024; static EFI_PHYSICAL_ADDRESS initrd_addr, dtb_addr, rndseed_addr; static u_long initrd_size = 0, dtb_size = 0, rndseed_size = 0; /* exec.c */ extern EFI_PHYSICAL_ADDRESS efirng_addr; extern u_long efirng_size; #ifdef EFIBOOT_ACPI #define ACPI_FDT_SIZE (128 * 1024) static int efi_fdt_create_acpifdt(void); #endif int efi_fdt_probe(void) { EFI_STATUS status; status = LibGetSystemConfigurationTable(&FdtTableGuid, &fdt_data); if (EFI_ERROR(status)) return EIO; if (fdt_check_header(fdt_data) != 0) { fdt_data = NULL; return EINVAL; } return 0; } int efi_fdt_set_data(void *data) { int err; if (fdt_check_header(data) != 0) return EINVAL; fdt_data = alloc(fdt_data_size); if (fdt_data == NULL) return ENOMEM; memset(fdt_data, 0, fdt_data_size); err = fdt_open_into(data, fdt_data, fdt_data_size); if (err != 0) { dealloc(fdt_data, fdt_data_size); fdt_data = NULL; return ENXIO; } return 0; } void * efi_fdt_data(void) { return fdt_data; } int efi_fdt_size(void) { return fdt_data == NULL ? 0 : fdt_totalsize(fdt_data); } bool efi_fdt_overlay_is_compatible(void *dtbo) { const int system_root = fdt_path_offset(fdt_data, "/"); const int overlay_root = fdt_path_offset(dtbo, "/"); if (system_root < 0 || overlay_root < 0) return false; const int system_ncompat = fdt_stringlist_count(fdt_data, system_root, "compatible"); const int overlay_ncompat = fdt_stringlist_count(dtbo, overlay_root, "compatible"); if (system_ncompat <= 0 || overlay_ncompat <= 0) return false; const char *system_compatible, *overlay_compatible; int si, oi; for (si = 0; si < system_ncompat; si++) { system_compatible = fdt_stringlist_get(fdt_data, system_root, "compatible", si, NULL); if (system_compatible == NULL) continue; for (oi = 0; oi < overlay_ncompat; oi++) { overlay_compatible = fdt_stringlist_get(dtbo, overlay_root, "compatible", oi, NULL); if (overlay_compatible == NULL) continue; if (strcmp(system_compatible, overlay_compatible) == 0) return true; } } return false; } int efi_fdt_overlay_apply(void *dtbo, int *fdterr) { int err = fdt_overlay_apply(fdt_data, dtbo); if (fdterr) *fdterr = err; return err == 0 ? 0 : EIO; } void efi_fdt_init(u_long addr, u_long len) { int error; error = fdt_open_into(fdt_data, (void *)addr, len); if (error < 0) panic("fdt_open_into failed: %d", error); fdt_data = (void *)addr; } void efi_fdt_fini(void) { int error; error = fdt_pack(fdt_data); if (error < 0) panic("fdt_pack failed: %d", error); } void efi_fdt_show(void) { const char *model, *compat; int n, ncompat; if (fdt_data == NULL) { return; } model = fdt_getprop(fdt_data, fdt_path_offset(fdt_data, "/"), "model", NULL); if (model) { command_printtab("FDT", "%s [", model); } ncompat = fdt_stringlist_count(fdt_data, fdt_path_offset(fdt_data, "/"), "compatible"); for (n = 0; n < ncompat; n++) { compat = fdt_stringlist_get(fdt_data, fdt_path_offset(fdt_data, "/"), "compatible", n, NULL); printf("%s%s", n == 0 ? "" : ", ", compat); } printf("]\n"); } static int efi_fdt_chosen(void) { int chosen; chosen = fdt_path_offset(fdt_data, FDT_CHOSEN_NODE_PATH); if (chosen < 0) chosen = fdt_add_subnode(fdt_data, fdt_path_offset(fdt_data, "/"), FDT_CHOSEN_NODE_NAME); if (chosen < 0) panic("FDT: Failed to create " FDT_CHOSEN_NODE_PATH " node"); return chosen; } void efi_fdt_system_table(void) { #ifdef EFIBOOT_RUNTIME_ADDRESS int chosen; chosen = efi_fdt_chosen(); fdt_setprop_u64(fdt_data, chosen, "netbsd,uefi-system-table", (uint64_t)(uintptr_t)ST); #endif } void efi_fdt_memory_map(void) { UINTN nentries = 0, mapkey, descsize; EFI_MEMORY_DESCRIPTOR *md, *memmap; UINT32 descver; UINT64 phys_start, phys_size; int n, memory; memory = fdt_path_offset(fdt_data, FDT_MEMORY_NODE_PATH); if (memory < 0) memory = fdt_add_subnode(fdt_data, fdt_path_offset(fdt_data, "/"), FDT_MEMORY_NODE_NAME); if (memory < 0) panic("FDT: Failed to create " FDT_MEMORY_NODE_PATH " node"); fdt_delprop(fdt_data, memory, "reg"); const int address_cells = fdt_address_cells(fdt_data, fdt_path_offset(fdt_data, "/")); const int size_cells = fdt_size_cells(fdt_data, fdt_path_offset(fdt_data, "/")); memmap = LibMemoryMap(&nentries, &mapkey, &descsize, &descver); for (n = 0, md = memmap; n < nentries; n++, md = NextMemoryDescriptor(md, descsize)) { /* * create / find the chosen node for each iteration as it might have changed * when adding to the memory node */ int chosen = efi_fdt_chosen(); fdt_appendprop_u32(fdt_data, chosen, "netbsd,uefi-memmap", md->Type); fdt_appendprop_u64(fdt_data, chosen, "netbsd,uefi-memmap", md->PhysicalStart); fdt_appendprop_u64(fdt_data, chosen, "netbsd,uefi-memmap", md->NumberOfPages); fdt_appendprop_u64(fdt_data, chosen, "netbsd,uefi-memmap", md->Attribute); if ((md->Attribute & EFI_MEMORY_RUNTIME) != 0) continue; if ((md->Attribute & EFI_MEMORY_WB) == 0) continue; if (!FDT_MEMORY_USABLE(md)) continue; if ((address_cells == 1 || size_cells == 1) && md->PhysicalStart + (md->NumberOfPages * EFI_PAGE_SIZE) > 0xffffffff) continue; if (md->NumberOfPages <= 1) continue; phys_start = md->PhysicalStart; phys_size = md->NumberOfPages * EFI_PAGE_SIZE; if (phys_start & EFI_PAGE_MASK) { /* * UEFI spec says these should be 4KB aligned, but * U-Boot doesn't always, so round up to the next * page. */ phys_start = (phys_start + EFI_PAGE_SIZE) & ~EFI_PAGE_MASK; phys_size -= (EFI_PAGE_SIZE * 2); if (phys_size == 0) continue; } memory = fdt_path_offset(fdt_data, FDT_MEMORY_NODE_PATH); if (address_cells == 1) fdt_appendprop_u32(fdt_data, memory, "reg", (uint32_t)phys_start); else fdt_appendprop_u64(fdt_data, memory, "reg", phys_start); if (size_cells == 1) fdt_appendprop_u32(fdt_data, memory, "reg", (uint32_t)phys_size); else fdt_appendprop_u64(fdt_data, memory, "reg", phys_size); } } void efi_fdt_gop(void) { EFI_STATUS status; EFI_GRAPHICS_OUTPUT_PROTOCOL *gop; EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *mode; EFI_HANDLE *gop_handle; UINTN ngop_handle, n; char buf[48]; int fb, chosen; status = LibLocateHandle(ByProtocol, &GraphicsOutputProtocol, NULL, &ngop_handle, &gop_handle); if (EFI_ERROR(status) || ngop_handle == 0) return; for (n = 0; n < ngop_handle; n++) { status = uefi_call_wrapper(BS->HandleProtocol, 3, gop_handle[n], &GraphicsOutputProtocol, (void **)&gop); if (EFI_ERROR(status)) continue; mode = gop->Mode; if (mode == NULL) continue; #ifdef EFIBOOT_DEBUG printf("GOP: FB @ 0x%" PRIx64 " size 0x%" PRIxUINTN "\n", mode->FrameBufferBase, mode->FrameBufferSize); printf("GOP: Version %d\n", mode->Info->Version); printf("GOP: HRes %d VRes %d\n", mode->Info->HorizontalResolution, mode->Info->VerticalResolution); printf("GOP: PixelFormat %d\n", mode->Info->PixelFormat); printf("GOP: PixelBitmask R 0x%x G 0x%x B 0x%x Res 0x%x\n", mode->Info->PixelInformation.RedMask, mode->Info->PixelInformation.GreenMask, mode->Info->PixelInformation.BlueMask, mode->Info->PixelInformation.ReservedMask); printf("GOP: Pixels per scanline %d\n", mode->Info->PixelsPerScanLine); #endif if (mode->Info->PixelFormat == PixelBltOnly) { printf("GOP: PixelBltOnly pixel format not supported\n"); continue; } chosen = efi_fdt_chosen(); fdt_setprop_u32(fdt_data, chosen, "#address-cells", 2); fdt_setprop_u32(fdt_data, chosen, "#size-cells", 2); fdt_setprop_empty(fdt_data, chosen, "ranges"); snprintf(buf, sizeof(buf), "framebuffer@%" PRIx64, mode->FrameBufferBase); fb = fdt_add_subnode(fdt_data, chosen, buf); if (fb < 0) { /* Framebuffer node already exists. No need to create a new one! */ return; } fdt_appendprop_string(fdt_data, fb, "compatible", "simple-framebuffer"); fdt_appendprop_string(fdt_data, fb, "status", "okay"); fdt_appendprop_u64(fdt_data, fb, "reg", mode->FrameBufferBase); fdt_appendprop_u64(fdt_data, fb, "reg", mode->FrameBufferSize); fdt_appendprop_u32(fdt_data, fb, "width", mode->Info->HorizontalResolution); fdt_appendprop_u32(fdt_data, fb, "height", mode->Info->VerticalResolution); fdt_appendprop_u32(fdt_data, fb, "stride", mode->Info->PixelsPerScanLine * 4); /* XXX */ fdt_appendprop_string(fdt_data, fb, "format", "a8b8g8r8"); #ifdef EFIBOOT_ACPI /* * In ACPI mode, use GOP as console. */ if (efi_acpi_available()) { snprintf(buf, sizeof(buf), "/chosen/framebuffer@%" PRIx64, mode->FrameBufferBase); fdt_setprop_string(fdt_data, chosen, "stdout-path", buf); } #endif return; } } void efi_fdt_bootargs(const char *bootargs) { struct efi_block_part *bpart = efi_block_boot_part(); uint8_t macaddr[6]; int chosen; chosen = efi_fdt_chosen(); if (*bootargs) fdt_setprop_string(fdt_data, chosen, "bootargs", bootargs); if (bpart) { switch (bpart->type) { case EFI_BLOCK_PART_DISKLABEL: fdt_setprop(fdt_data, chosen, "netbsd,mbr", bpart->hash, sizeof(bpart->hash)); fdt_setprop_u32(fdt_data, chosen, "netbsd,partition", bpart->index); break; case EFI_BLOCK_PART_GPT: if (bpart->gpt.ent.ent_name[0] == 0x0000) { fdt_setprop(fdt_data, chosen, "netbsd,gpt-guid", bpart->hash, sizeof(bpart->hash)); } else { char *label = NULL; int rv = ucs2_to_utf8(bpart->gpt.ent.ent_name, &label); if (rv == 0) { fdt_setprop_string(fdt_data, chosen, "netbsd,gpt-label", label); FreePool(label); } } break; default: break; } } else if (efi_net_get_booted_macaddr(macaddr) == 0) { fdt_setprop(fdt_data, chosen, "netbsd,booted-mac-address", macaddr, sizeof(macaddr)); } } static void efi_fdt_userconf_addprop(const char *cmd) { const int chosen = efi_fdt_chosen(); fdt_appendprop_string(fdt_data, chosen, "netbsd,userconf", cmd); } void efi_fdt_userconf(void) { userconf_foreach(efi_fdt_userconf_addprop); } void efi_fdt_initrd(u_long initrd_addr, u_long initrd_size) { int chosen; if (initrd_size == 0) return; chosen = efi_fdt_chosen(); fdt_setprop_u64(fdt_data, chosen, "linux,initrd-start", initrd_addr); fdt_setprop_u64(fdt_data, chosen, "linux,initrd-end", initrd_addr + initrd_size); } /* pass in the NetBSD on-disk random seed */ void efi_fdt_rndseed(u_long addr, u_long size) { int chosen; if (size == 0) return; chosen = efi_fdt_chosen(); fdt_setprop_u64(fdt_data, chosen, "netbsd,rndseed-start", addr); fdt_setprop_u64(fdt_data, chosen, "netbsd,rndseed-end", addr + size); } /* pass in output from the EFI firmware's RNG from some unknown source */ void efi_fdt_efirng(u_long efirng_addr, u_long efirng_size) { int chosen; if (efirng_size == 0) return; chosen = efi_fdt_chosen(); fdt_setprop_u64(fdt_data, chosen, "netbsd,efirng-start", efirng_addr); fdt_setprop_u64(fdt_data, chosen, "netbsd,efirng-end", efirng_addr + efirng_size); } /* pass in module information */ void efi_fdt_module(const char *module_name, u_long module_addr, u_long module_size) { int chosen; if (module_size == 0) return; chosen = efi_fdt_chosen(); fdt_appendprop_string(fdt_data, chosen, "netbsd,module-names", module_name); fdt_appendprop_u64(fdt_data, chosen, "netbsd,modules", module_addr); fdt_appendprop_u64(fdt_data, chosen, "netbsd,modules", module_size); } static void apply_overlay(const char *path, void *dtbo) { if (!efi_fdt_overlay_is_compatible(dtbo)) { printf("boot: %s: incompatible overlay\n", path); return; } int fdterr; if (efi_fdt_overlay_apply(dtbo, &fdterr) != 0) { printf("boot: %s: error %d applying overlay\n", path, fdterr); } } static void apply_overlay_file(const char *path) { EFI_PHYSICAL_ADDRESS dtbo_addr; u_long dtbo_size; if (strlen(path) == 0) return; if (load_file(path, 0, false, &dtbo_addr, &dtbo_size) != 0 || dtbo_addr == 0) { /* Error messages have already been displayed. */ goto out; } apply_overlay(path, (void *)(uintptr_t)dtbo_addr); out: if (dtbo_addr) { uefi_call_wrapper(BS->FreePages, 2, dtbo_addr, EFI_SIZE_TO_PAGES(dtbo_size)); } } static void load_fdt_overlays(void) { if (!dtoverlay_enabled) return; dtoverlay_foreach(apply_overlay_file); } static void load_module(const char *module_name) { EFI_PHYSICAL_ADDRESS addr; u_long size; char path[PATH_MAX]; snprintf(path, sizeof(path), "%s/%s/%s.kmod", module_prefix, module_name, module_name); if (load_file(path, 0, false, &addr, &size) != 0 || addr == 0 || size == 0) return; efi_fdt_module(module_name, (u_long)addr, size); } static void load_modules(const char *kernel_name) { if (!module_enabled) return; module_init(kernel_name); module_foreach(load_module); } /* * Prepare kernel arguments and shutdown boot services. */ int efi_fdt_prepare_boot(const char *fname, const char *args, u_long *marks) { int error; load_file(get_initrd_path(), 0, false, &initrd_addr, &initrd_size); load_file(get_dtb_path(), 0, false, &dtb_addr, &dtb_size); error = efi_md_prepare_boot(fname, args, marks); if (error) { return error; } #ifdef EFIBOOT_ACPI /* ACPI support only works for little endian kernels */ if (efi_acpi_available() && netbsd_elf_data == ELFDATA2LSB) { error = efi_fdt_create_acpifdt(); if (error != 0) { return error; } } else #endif if (dtb_addr && efi_fdt_set_data((void *)(uintptr_t)dtb_addr) != 0) { return EINVAL; } if (efi_fdt_size() > 0) { /* * Load the rndseed as late as possible -- after we * have committed to using fdt and executing this * kernel -- so that it doesn't hang around in memory * if we have to bail or the kernel won't use it. */ load_file(get_rndseed_path(), 0, false, &rndseed_addr, &rndseed_size); efi_fdt_init((marks[MARK_END] + FDT_ALIGN - 1) & -FDT_ALIGN, FDT_ALIGN); load_modules(fname); load_fdt_overlays(); efi_fdt_initrd(initrd_addr, initrd_size); efi_fdt_rndseed(rndseed_addr, rndseed_size); efi_fdt_efirng(efirng_addr, efirng_size); efi_fdt_bootargs(args); efi_fdt_userconf(); efi_fdt_system_table(); efi_fdt_gop(); efi_fdt_memory_map(); } efi_cleanup(); if (efi_fdt_size() > 0) { efi_fdt_fini(); } return 0; } /* * Free memory after a failed boot. */ void efi_fdt_cleanup_boot(void) { if (rndseed_addr) { uefi_call_wrapper(BS->FreePages, 2, rndseed_addr, EFI_SIZE_TO_PAGES(rndseed_size)); rndseed_addr = 0; rndseed_size = 0; } if (initrd_addr) { uefi_call_wrapper(BS->FreePages, 2, initrd_addr, EFI_SIZE_TO_PAGES(initrd_size)); initrd_addr = 0; initrd_size = 0; } if (dtb_addr) { uefi_call_wrapper(BS->FreePages, 2, dtb_addr, EFI_SIZE_TO_PAGES(dtb_size)); dtb_addr = 0; dtb_size = 0; } } size_t efi_fdt_alloc_size(void) { return FDT_SPACE; } #ifdef EFIBOOT_ACPI int efi_fdt_create_acpifdt(void) { void *acpi_root = efi_acpi_root(); void *smbios_table = efi_acpi_smbios(); void *fdt; int error; if (acpi_root == NULL) return EINVAL; fdt = AllocatePool(ACPI_FDT_SIZE); if (fdt == NULL) return ENOMEM; error = fdt_create_empty_tree(fdt, ACPI_FDT_SIZE); if (error) return EIO; const char *model = efi_acpi_get_model(); fdt_setprop_string(fdt, fdt_path_offset(fdt, "/"), "compatible", "netbsd,generic-acpi"); fdt_setprop_string(fdt, fdt_path_offset(fdt, "/"), "model", model); fdt_setprop_cell(fdt, fdt_path_offset(fdt, "/"), "#address-cells", 2); fdt_setprop_cell(fdt, fdt_path_offset(fdt, "/"), "#size-cells", 2); fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), "chosen"); fdt_setprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,acpi-root-table", (uint64_t)(uintptr_t)acpi_root); if (smbios_table) fdt_setprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,smbios-table", (uint64_t)(uintptr_t)smbios_table); fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"), "acpi"); fdt_setprop_string(fdt, fdt_path_offset(fdt, "/acpi"), "compatible", "netbsd,acpi"); return efi_fdt_set_data(fdt); } #endif #ifdef EFIBOOT_RUNTIME_ADDRESS static uint64_t efi_fdt_runtime_alloc_va(uint64_t pa, uint64_t npages) { #if EFIBOOT_RUNTIME_ADDRESS != 0 static uint64_t va = EFIBOOT_RUNTIME_ADDRESS; static uint64_t sz = EFIBOOT_RUNTIME_SIZE; uint64_t nva; if (sz < (npages * EFI_PAGE_SIZE)) { panic("efi_acpi_alloc_va: couldn't allocate %" PRIu64 " pages", npages); } nva = va; va += (npages * EFI_PAGE_SIZE); sz -= (npages * EFI_PAGE_SIZE); return nva; #else return pa; #endif } void efi_fdt_set_virtual_address_map(EFI_MEMORY_DESCRIPTOR *memmap, UINTN nentries, UINTN mapkey, UINTN descsize, UINT32 descver) { EFI_MEMORY_DESCRIPTOR *md, *vmd, *vmemmap; EFI_STATUS status; int n, nrt; void *fdt; fdt = efi_fdt_data(); vmemmap = alloc(nentries * descsize); if (vmemmap == NULL) panic("FATAL: couldn't allocate virtual memory map"); for (n = 0, nrt = 0, vmd = vmemmap, md = memmap; n < nentries; n++, md = NextMemoryDescriptor(md, descsize)) { if ((md->Attribute & EFI_MEMORY_RUNTIME) == 0) { continue; } md->VirtualStart = efi_fdt_runtime_alloc_va(md->PhysicalStart, md->NumberOfPages); switch (md->Type) { case EfiRuntimeServicesCode: fdt_appendprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,uefi-runtime-code", md->PhysicalStart); fdt_appendprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,uefi-runtime-code", md->VirtualStart); fdt_appendprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,uefi-runtime-code", md->NumberOfPages * EFI_PAGE_SIZE); break; case EfiRuntimeServicesData: fdt_appendprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,uefi-runtime-data", md->PhysicalStart); fdt_appendprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,uefi-runtime-data", md->VirtualStart); fdt_appendprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,uefi-runtime-data", md->NumberOfPages * EFI_PAGE_SIZE); break; case EfiMemoryMappedIO: fdt_appendprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,uefi-runtime-mmio", md->PhysicalStart); fdt_appendprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,uefi-runtime-mmio", md->VirtualStart); fdt_appendprop_u64(fdt, fdt_path_offset(fdt, "/chosen"), "netbsd,uefi-runtime-mmio", md->NumberOfPages * EFI_PAGE_SIZE); break; default: break; } *vmd = *md; vmd = NextMemoryDescriptor(vmd, descsize); ++nrt; } status = uefi_call_wrapper(RT->SetVirtualAddressMap, 4, nrt * descsize, descsize, descver, vmemmap); if (EFI_ERROR(status)) { printf("WARNING: SetVirtualAddressMap failed\n"); return; } } #endif