/* $NetBSD: fdt_machdep.c,v 1.59 2019/03/16 10:05:40 skrll Exp $ */ /*- * Copyright (c) 2015-2017 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 AUTHOR ``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 AUTHOR 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 __KERNEL_RCSID(0, "$NetBSD: fdt_machdep.c,v 1.59 2019/03/16 10:05:40 skrll Exp $"); #include "opt_machdep.h" #include "opt_bootconfig.h" #include "opt_ddb.h" #include "opt_md.h" #include "opt_arm_debug.h" #include "opt_multiprocessor.h" #include "opt_cpuoptions.h" #include "opt_efi.h" #include "ukbd.h" #include "wsdisplay.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef EFI_RUNTIME #include #endif #if NUKBD > 0 #include #endif #if NWSDISPLAY > 0 #include #endif #ifdef MEMORY_DISK_DYNAMIC #include #endif #ifndef FDT_MAX_BOOT_STRING #define FDT_MAX_BOOT_STRING 1024 #endif BootConfig bootconfig; char bootargs[FDT_MAX_BOOT_STRING] = ""; char *boot_args = NULL; /* filled in before cleaning bss. keep in .data */ u_long uboot_args[4] __attribute__((__section__(".data"))); const uint8_t *fdt_addr_r __attribute__((__section__(".data"))); static uint64_t initrd_start, initrd_end; #include #include #define FDT_BUF_SIZE (512*1024) static uint8_t fdt_data[FDT_BUF_SIZE]; extern char KERNEL_BASE_phys[]; #define KERNEL_BASE_PHYS ((paddr_t)KERNEL_BASE_phys) static void fdt_update_stdout_path(void); static void fdt_device_register(device_t, void *); static void fdt_device_register_post_config(device_t, void *); static void fdt_cpu_rootconf(void); static void fdt_reset(void); static void fdt_powerdown(void); static void earlyconsputc(dev_t dev, int c) { uartputc(c); } static int earlyconsgetc(dev_t dev) { return 0; } static struct consdev earlycons = { .cn_putc = earlyconsputc, .cn_getc = earlyconsgetc, .cn_pollc = nullcnpollc, }; #ifdef VERBOSE_INIT_ARM #define VPRINTF(...) printf(__VA_ARGS__) #else #define VPRINTF(...) __nothing #endif /* * ARM: Get the first physically contiguous region of memory. * ARM64: Get all of physical memory, including holes. */ static void fdt_get_memory(uint64_t *pstart, uint64_t *pend) { const int memory = OF_finddevice("/memory"); uint64_t cur_addr, cur_size; int index; /* Assume the first entry is the start of memory */ if (fdtbus_get_reg64(memory, 0, &cur_addr, &cur_size) != 0) panic("Cannot determine memory size"); *pstart = cur_addr; *pend = cur_addr + cur_size; VPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n", 0, *pstart, *pend - *pstart); for (index = 1; fdtbus_get_reg64(memory, index, &cur_addr, &cur_size) == 0; index++) { VPRINTF("FDT /memory [%d] @ 0x%" PRIx64 " size 0x%" PRIx64 "\n", index, cur_addr, cur_size); #ifdef __aarch64__ if (cur_addr + cur_size > *pend) *pend = cur_addr + cur_size; #else /* If subsequent entries follow the previous, append them. */ if (*pend == cur_addr) *pend = cur_addr + cur_size; #endif } } void fdt_add_reserved_memory_range(uint64_t addr, uint64_t size) { fdt_memory_remove_range(addr, size); } /* * Exclude memory ranges from memory config from the device tree */ static void fdt_add_reserved_memory(uint64_t min_addr, uint64_t max_addr) { uint64_t lstart = 0, lend = 0; uint64_t addr, size; int index, error; const int num = fdt_num_mem_rsv(fdtbus_get_data()); for (index = 0; index <= num; index++) { error = fdt_get_mem_rsv(fdtbus_get_data(), index, &addr, &size); if (error != 0) continue; if (lstart <= addr && addr <= lend) { size -= (lend - addr); addr = lend; } if (size == 0) continue; if (addr + size <= min_addr) continue; if (addr >= max_addr) continue; if (addr < min_addr) { size -= (min_addr - addr); addr = min_addr; } if (addr + size > max_addr) size = max_addr - addr; fdt_add_reserved_memory_range(addr, size); lstart = addr; lend = addr + size; } } static void fdt_add_dram_blocks(const struct fdt_memory *m, void *arg) { BootConfig *bc = arg; VPRINTF(" %" PRIx64 " - %" PRIx64 "\n", m->start, m->end - 1); bc->dram[bc->dramblocks].address = m->start; bc->dram[bc->dramblocks].pages = (m->end - m->start) / PAGE_SIZE; bc->dramblocks++; } #define MAX_PHYSMEM 64 static int nfdt_physmem = 0; static struct boot_physmem fdt_physmem[MAX_PHYSMEM]; static void fdt_add_boot_physmem(const struct fdt_memory *m, void *arg) { struct boot_physmem *bp = &fdt_physmem[nfdt_physmem++]; VPRINTF(" %" PRIx64 " - %" PRIx64 "\n", m->start, m->end - 1); KASSERT(nfdt_physmem <= MAX_PHYSMEM); bp->bp_start = atop(round_page(m->start)); bp->bp_pages = atop(trunc_page(m->end)) - bp->bp_start; bp->bp_freelist = VM_FREELIST_DEFAULT; #ifdef _LP64 if (m->end > 0x100000000) bp->bp_freelist = VM_FREELIST_HIGHMEM; #endif #ifdef PMAP_NEED_ALLOC_POOLPAGE const uint64_t memory_size = *(uint64_t *)arg; if (atop(memory_size) > bp->bp_pages) { arm_poolpage_vmfreelist = VM_FREELIST_DIRECTMAP; bp->bp_freelist = VM_FREELIST_DIRECTMAP; } #endif } /* * Define usable memory regions. */ static void fdt_build_bootconfig(uint64_t mem_start, uint64_t mem_end) { const int memory = OF_finddevice("/memory"); BootConfig *bc = &bootconfig; uint64_t addr, size; int index; for (index = 0; fdtbus_get_reg64(memory, index, &addr, &size) == 0; index++) { if (addr >= mem_end || size == 0) continue; if (addr + size > mem_end) size = mem_end - addr; fdt_memory_add_range(addr, size); } fdt_add_reserved_memory(mem_start, mem_end); const uint64_t initrd_size = initrd_end - initrd_start; if (initrd_size > 0) fdt_memory_remove_range(initrd_start, initrd_size); const int framebuffer = OF_finddevice("/chosen/framebuffer"); if (framebuffer >= 0) { for (index = 0; fdtbus_get_reg64(framebuffer, index, &addr, &size) == 0; index++) { fdt_add_reserved_memory_range(addr, size); } } VPRINTF("Usable memory:\n"); bc->dramblocks = 0; fdt_memory_foreach(fdt_add_dram_blocks, bc); } static void fdt_probe_initrd(uint64_t *pstart, uint64_t *pend) { *pstart = *pend = 0; #ifdef MEMORY_DISK_DYNAMIC const int chosen = OF_finddevice("/chosen"); if (chosen < 0) return; int len; const void *start_data = fdtbus_get_prop(chosen, "linux,initrd-start", &len); const void *end_data = fdtbus_get_prop(chosen, "linux,initrd-end", NULL); if (start_data == NULL || end_data == NULL) return; switch (len) { case 4: *pstart = be32dec(start_data); *pend = be32dec(end_data); break; case 8: *pstart = be64dec(start_data); *pend = be64dec(end_data); break; default: printf("Unsupported len %d for /chosen/initrd-start\n", len); return; } #endif } static void fdt_setup_initrd(void) { #ifdef MEMORY_DISK_DYNAMIC const uint64_t initrd_size = initrd_end - initrd_start; paddr_t startpa = trunc_page(initrd_start); paddr_t endpa = round_page(initrd_end); paddr_t pa; vaddr_t va; void *md_start; if (initrd_size == 0) return; va = uvm_km_alloc(kernel_map, initrd_size, 0, UVM_KMF_VAONLY | UVM_KMF_NOWAIT); if (va == 0) { printf("Failed to allocate VA for initrd\n"); return; } md_start = (void *)va; for (pa = startpa; pa < endpa; pa += PAGE_SIZE, va += PAGE_SIZE) pmap_kenter_pa(va, pa, VM_PROT_READ|VM_PROT_WRITE, 0); pmap_update(pmap_kernel()); md_root_setconf(md_start, initrd_size); #endif } #ifdef EFI_RUNTIME static void fdt_map_efi_runtime(const char *prop, enum arm_efirt_mem_type type) { int len; const int chosen_off = fdt_path_offset(fdt_data, "/chosen"); if (chosen_off < 0) return; const uint64_t *map = fdt_getprop(fdt_data, chosen_off, prop, &len); if (map == NULL) return; while (len >= 24) { const paddr_t pa = be64toh(map[0]); const vaddr_t va = be64toh(map[1]); const uint64_t sz = be64toh(map[2]); VPRINTF("%s: %s %lx-%lx (%lx-%lx)\n", __func__, prop, pa, pa+sz-1, va, va+sz-1); arm_efirt_md_map_range(va, pa, sz, type); map += 3; len -= 24; } } #endif u_int initarm(void *arg); u_int initarm(void *arg) { const struct arm_platform *plat; uint64_t memory_start, memory_end; /* set temporally to work printf()/panic() even before consinit() */ cn_tab = &earlycons; /* Load FDT */ int error = fdt_check_header(fdt_addr_r); if (error == 0) { /* If the DTB is too big, try to pack it in place first. */ if (fdt_totalsize(fdt_addr_r) > sizeof(fdt_data)) (void)fdt_pack(__UNCONST(fdt_addr_r)); error = fdt_open_into(fdt_addr_r, fdt_data, sizeof(fdt_data)); if (error != 0) panic("fdt_move failed: %s", fdt_strerror(error)); fdtbus_set_data(fdt_data); } else { panic("fdt_check_header failed: %s", fdt_strerror(error)); } /* Lookup platform specific backend */ plat = arm_fdt_platform(); if (plat == NULL) panic("Kernel does not support this device"); /* Early console may be available, announce ourselves. */ VPRINTF("FDT<%p>\n", fdt_addr_r); const int chosen = OF_finddevice("/chosen"); if (chosen >= 0) OF_getprop(chosen, "bootargs", bootargs, sizeof(bootargs)); boot_args = bootargs; /* Heads up ... Setup the CPU / MMU / TLB functions. */ VPRINTF("cpufunc\n"); if (set_cpufuncs()) panic("cpu not recognized!"); /* * Memory is still identity/flat mapped this point so using ttbr for * l1pt VA is fine */ VPRINTF("devmap\n"); extern char ARM_BOOTSTRAP_LxPT[]; pmap_devmap_bootstrap((vaddr_t)ARM_BOOTSTRAP_LxPT, plat->ap_devmap()); VPRINTF("bootstrap\n"); plat->ap_bootstrap(); /* * If stdout-path is specified on the command line, override the * value in /chosen/stdout-path before initializing console. */ VPRINTF("stdout\n"); fdt_update_stdout_path(); /* * Done making changes to the FDT. */ fdt_pack(fdt_data); VPRINTF("consinit "); consinit(); VPRINTF("ok\n"); VPRINTF("uboot: args %#lx, %#lx, %#lx, %#lx\n", uboot_args[0], uboot_args[1], uboot_args[2], uboot_args[3]); cpu_reset_address = fdt_reset; cpu_powerdown_address = fdt_powerdown; evbarm_device_register = fdt_device_register; evbarm_device_register_post_config = fdt_device_register_post_config; evbarm_cpu_rootconf = fdt_cpu_rootconf; /* Talk to the user */ printf("NetBSD/evbarm (fdt) booting ...\n"); #ifdef BOOT_ARGS char mi_bootargs[] = BOOT_ARGS; parse_mi_bootargs(mi_bootargs); #endif fdt_get_memory(&memory_start, &memory_end); #if !defined(_LP64) /* Cannot map memory above 4GB */ if (memory_end >= 0x100000000ULL) memory_end = 0x100000000ULL - PAGE_SIZE; #endif uint64_t memory_size = memory_end - memory_start; VPRINTF("%s: memory start %" PRIx64 " end %" PRIx64 " (len %" PRIx64 ")\n", __func__, memory_start, memory_end, memory_size); /* Parse ramdisk info */ fdt_probe_initrd(&initrd_start, &initrd_end); /* * Populate bootconfig structure for the benefit of * dodumpsys */ VPRINTF("%s: fdt_build_bootconfig\n", __func__); fdt_build_bootconfig(memory_start, memory_end); #ifdef EFI_RUNTIME fdt_map_efi_runtime("netbsd,uefi-runtime-code", ARM_EFIRT_MEM_CODE); fdt_map_efi_runtime("netbsd,uefi-runtime-data", ARM_EFIRT_MEM_DATA); fdt_map_efi_runtime("netbsd,uefi-runtime-mmio", ARM_EFIRT_MEM_MMIO); #endif /* Perform PT build and VM init */ cpu_kernel_vm_init(memory_start, memory_size); VPRINTF("bootargs: %s\n", bootargs); parse_mi_bootargs(boot_args); VPRINTF("Memory regions:\n"); fdt_memory_foreach(fdt_add_boot_physmem, &memory_size); u_int sp = initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, fdt_physmem, nfdt_physmem); /* * initarm_commmon flushes cache if required before AP start */ error = 0; if ((boothowto & RB_MD1) == 0) { VPRINTF("mpstart\n"); if (plat->ap_mpstart) error = plat->ap_mpstart(); } if (error) return sp; /* * Now we have APs started the pages used for stacks and L1PT can * be given to uvm */ extern char const __start__init_memory[]; extern char const __stop__init_memory[] __weak; if (__start__init_memory != __stop__init_memory) { const paddr_t spa = KERN_VTOPHYS((vaddr_t)__start__init_memory); const paddr_t epa = KERN_VTOPHYS((vaddr_t)__stop__init_memory); const paddr_t spg = atop(spa); const paddr_t epg = atop(epa); uvm_page_physload(spg, epg, spg, epg, VM_FREELIST_DEFAULT); VPRINTF(" start %08lx end %08lx", ptoa(spa), ptoa(epa)); } return sp; } static void fdt_update_stdout_path(void) { char *stdout_path, *ep; int stdout_path_len; char buf[256]; const int chosen_off = fdt_path_offset(fdt_data, "/chosen"); if (chosen_off == -1) return; if (get_bootconf_option(boot_args, "stdout-path", BOOTOPT_TYPE_STRING, &stdout_path) == 0) return; ep = strchr(stdout_path, ' '); stdout_path_len = ep ? (ep - stdout_path) : strlen(stdout_path); if (stdout_path_len >= sizeof(buf)) return; strncpy(buf, stdout_path, stdout_path_len); buf[stdout_path_len] = '\0'; fdt_setprop(fdt_data, chosen_off, "stdout-path", buf, stdout_path_len + 1); } void consinit(void) { static bool initialized = false; const struct arm_platform *plat = arm_fdt_platform(); const struct fdt_console *cons = fdtbus_get_console(); struct fdt_attach_args faa; u_int uart_freq = 0; if (initialized || cons == NULL) return; plat->ap_init_attach_args(&faa); faa.faa_phandle = fdtbus_get_stdout_phandle(); if (plat->ap_uart_freq != NULL) uart_freq = plat->ap_uart_freq(); cons->consinit(&faa, uart_freq); initialized = true; } void delay(u_int us) { const struct arm_platform *plat = arm_fdt_platform(); plat->ap_delay(us); } static void fdt_detect_root_device(device_t dev) { struct mbr_sector mbr; uint8_t buf[DEV_BSIZE]; uint8_t hash[16]; const uint8_t *rhash; char rootarg[64]; struct vnode *vp; MD5_CTX md5ctx; int error, len; size_t resid; u_int part; const int chosen = OF_finddevice("/chosen"); if (chosen < 0) return; if (of_hasprop(chosen, "netbsd,mbr") && of_hasprop(chosen, "netbsd,partition")) { /* * The bootloader has passed in a partition index and MD5 hash * of the MBR sector. Read the MBR of this device, calculate the * hash, and compare it with the value passed in. */ rhash = fdtbus_get_prop(chosen, "netbsd,mbr", &len); if (rhash == NULL || len != 16) return; of_getprop_uint32(chosen, "netbsd,partition", &part); if (part >= MAXPARTITIONS) return; vp = opendisk(dev); if (!vp) return; error = vn_rdwr(UIO_READ, vp, buf, sizeof(buf), 0, UIO_SYSSPACE, 0, NOCRED, &resid, NULL); VOP_CLOSE(vp, FREAD, NOCRED); vput(vp); if (error != 0) return; memcpy(&mbr, buf, sizeof(mbr)); MD5Init(&md5ctx); MD5Update(&md5ctx, (void *)&mbr, sizeof(mbr)); MD5Final(hash, &md5ctx); if (memcmp(rhash, hash, 16) != 0) return; snprintf(rootarg, sizeof(rootarg), " root=%s%c", device_xname(dev), part + 'a'); strcat(boot_args, rootarg); } if (of_hasprop(chosen, "netbsd,gpt-guid")) { char guidbuf[UUID_STR_LEN]; const struct uuid *guid = fdtbus_get_prop(chosen, "netbsd,gpt-guid", &len); if (guid == NULL || len != 16) return; uuid_snprintf(guidbuf, sizeof(guidbuf), guid); snprintf(rootarg, sizeof(rootarg), " root=wedge:%s", guidbuf); strcat(boot_args, rootarg); } if (of_hasprop(chosen, "netbsd,gpt-label")) { const char *label = fdtbus_get_string(chosen, "netbsd,gpt-label"); if (label == NULL || *label == '\0') return; device_t dv = dkwedge_find_by_wname(label); if (dv != NULL) booted_device = dv; } if (of_hasprop(chosen, "netbsd,booted-mac-address")) { const uint8_t *macaddr = fdtbus_get_prop(chosen, "netbsd,booted-mac-address", &len); if (macaddr == NULL || len != 6) return; int s = pserialize_read_enter(); struct ifnet *ifp; IFNET_READER_FOREACH(ifp) { if (memcmp(macaddr, CLLADDR(ifp->if_sadl), len) == 0) { device_t dv = device_find_by_xname(ifp->if_xname); if (dv != NULL) booted_device = dv; break; } } pserialize_read_exit(s); } } static void fdt_device_register(device_t self, void *aux) { const struct arm_platform *plat = arm_fdt_platform(); if (device_is_a(self, "armfdt")) fdt_setup_initrd(); if (plat && plat->ap_device_register) plat->ap_device_register(self, aux); } static void fdt_device_register_post_config(device_t self, void *aux) { #if NUKBD > 0 && NWSDISPLAY > 0 if (device_is_a(self, "wsdisplay")) { struct wsdisplay_softc *sc = device_private(self); if (wsdisplay_isconsole(sc)) ukbd_cnattach(); } #endif } static void fdt_cpu_rootconf(void) { device_t dev; deviter_t di; char *ptr; for (dev = deviter_first(&di, 0); dev; dev = deviter_next(&di)) { if (device_class(dev) != DV_DISK) continue; if (get_bootconf_option(boot_args, "root", BOOTOPT_TYPE_STRING, &ptr) != 0) break; if (device_is_a(dev, "ld") || device_is_a(dev, "sd") || device_is_a(dev, "wd")) fdt_detect_root_device(dev); } deviter_release(&di); } static void fdt_reset(void) { const struct arm_platform *plat = arm_fdt_platform(); fdtbus_power_reset(); if (plat && plat->ap_reset) plat->ap_reset(); } static void fdt_powerdown(void) { fdtbus_power_poweroff(); }