1 /* $NetBSD: fdt_machdep.c,v 1.95 2022/09/30 06:39:54 skrll Exp $ */ 2 3 /*- 4 * Copyright (c) 2015-2017 Jared McNeill <jmcneill@invisible.ca> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: fdt_machdep.c,v 1.95 2022/09/30 06:39:54 skrll Exp $"); 31 32 #include "opt_arm_debug.h" 33 #include "opt_bootconfig.h" 34 #include "opt_cpuoptions.h" 35 #include "opt_ddb.h" 36 #include "opt_efi.h" 37 #include "opt_machdep.h" 38 #include "opt_md.h" 39 #include "opt_multiprocessor.h" 40 41 #include "genfb.h" 42 #include "ukbd.h" 43 #include "wsdisplay.h" 44 45 #include <sys/param.h> 46 #include <sys/types.h> 47 48 #include <sys/atomic.h> 49 #include <sys/bootblock.h> 50 #include <sys/bus.h> 51 #include <sys/conf.h> 52 #include <sys/cpu.h> 53 #include <sys/device.h> 54 #include <sys/disk.h> 55 #include <sys/disklabel.h> 56 #include <sys/endian.h> 57 #include <sys/exec.h> 58 #include <sys/fcntl.h> 59 #include <sys/kauth.h> 60 #include <sys/kernel.h> 61 #include <sys/kmem.h> 62 #include <sys/ksyms.h> 63 #include <sys/md5.h> 64 #include <sys/msgbuf.h> 65 #include <sys/proc.h> 66 #include <sys/pserialize.h> 67 #include <sys/reboot.h> 68 #include <sys/rnd.h> 69 #include <sys/rndsource.h> 70 #include <sys/systm.h> 71 #include <sys/termios.h> 72 #include <sys/vnode.h> 73 #include <sys/uuid.h> 74 75 #include <net/if.h> 76 #include <net/if_dl.h> 77 78 #include <dev/cons.h> 79 #include <uvm/uvm_extern.h> 80 81 #include <machine/db_machdep.h> 82 #include <ddb/db_sym.h> 83 #include <ddb/db_extern.h> 84 85 #include <machine/bootconfig.h> 86 #include <arm/armreg.h> 87 88 #include <arm/cpufunc.h> 89 90 #include <evbarm/include/autoconf.h> 91 #include <evbarm/fdt/machdep.h> 92 #include <evbarm/fdt/platform.h> 93 94 #include <arm/fdt/arm_fdtvar.h> 95 #include <dev/fdt/fdt_private.h> 96 #include <dev/fdt/fdt_memory.h> 97 98 #ifdef EFI_RUNTIME 99 #include <arm/arm/efi_runtime.h> 100 #endif 101 102 #if NWSDISPLAY > 0 && NGENFB > 0 103 #include <arm/fdt/arm_simplefb.h> 104 #endif 105 106 #if NUKBD > 0 107 #include <dev/usb/ukbdvar.h> 108 #endif 109 #if NWSDISPLAY > 0 110 #include <dev/wscons/wsdisplayvar.h> 111 #endif 112 113 #ifdef MEMORY_DISK_DYNAMIC 114 #include <dev/md.h> 115 #endif 116 117 #ifndef FDT_MAX_BOOT_STRING 118 #define FDT_MAX_BOOT_STRING 1024 119 #endif 120 121 BootConfig bootconfig; 122 char bootargs[FDT_MAX_BOOT_STRING] = ""; 123 char *boot_args = NULL; 124 125 /* filled in before cleaning bss. keep in .data */ 126 u_long uboot_args[4] __attribute__((__section__(".data"))); 127 const uint8_t *fdt_addr_r __attribute__((__section__(".data"))); 128 129 static uint64_t initrd_start, initrd_end; 130 static uint64_t rndseed_start, rndseed_end; /* our on-disk seed */ 131 static uint64_t efirng_start, efirng_end; /* firmware's EFI RNG output */ 132 133 #include <libfdt.h> 134 #include <dev/fdt/fdtvar.h> 135 #define FDT_BUF_SIZE (512*1024) 136 static uint8_t fdt_data[FDT_BUF_SIZE]; 137 138 extern char KERNEL_BASE_phys[]; 139 #define KERNEL_BASE_PHYS ((paddr_t)KERNEL_BASE_phys) 140 141 static void fdt_update_stdout_path(void); 142 static void fdt_device_register(device_t, void *); 143 static void fdt_device_register_post_config(device_t, void *); 144 static void fdt_cpu_rootconf(void); 145 static void fdt_reset(void); 146 static void fdt_powerdown(void); 147 148 #if BYTE_ORDER == BIG_ENDIAN 149 static void fdt_update_fb_format(void); 150 #endif 151 152 static void 153 earlyconsputc(dev_t dev, int c) 154 { 155 uartputc(c); 156 } 157 158 static int 159 earlyconsgetc(dev_t dev) 160 { 161 return -1; 162 } 163 164 static struct consdev earlycons = { 165 .cn_putc = earlyconsputc, 166 .cn_getc = earlyconsgetc, 167 .cn_pollc = nullcnpollc, 168 }; 169 170 #ifdef VERBOSE_INIT_ARM 171 #define VPRINTF(...) printf(__VA_ARGS__) 172 #else 173 #define VPRINTF(...) __nothing 174 #endif 175 176 static void 177 fdt_add_dram_blocks(const struct fdt_memory *m, void *arg) 178 { 179 BootConfig *bc = arg; 180 181 VPRINTF(" %" PRIx64 " - %" PRIx64 "\n", m->start, m->end - 1); 182 bc->dram[bc->dramblocks].address = m->start; 183 bc->dram[bc->dramblocks].pages = 184 (m->end - m->start) / PAGE_SIZE; 185 bc->dramblocks++; 186 } 187 188 #define MAX_PHYSMEM 64 189 static int nfdt_physmem = 0; 190 static struct boot_physmem fdt_physmem[MAX_PHYSMEM]; 191 192 static void 193 fdt_add_boot_physmem(const struct fdt_memory *m, void *arg) 194 { 195 const paddr_t saddr = round_page(m->start); 196 const paddr_t eaddr = trunc_page(m->end); 197 198 VPRINTF(" %" PRIx64 " - %" PRIx64, m->start, m->end - 1); 199 if (saddr >= eaddr) { 200 VPRINTF(" skipped\n"); 201 return; 202 } 203 VPRINTF("\n"); 204 205 struct boot_physmem *bp = &fdt_physmem[nfdt_physmem++]; 206 207 KASSERT(nfdt_physmem <= MAX_PHYSMEM); 208 209 bp->bp_start = atop(saddr); 210 bp->bp_pages = atop(eaddr) - bp->bp_start; 211 bp->bp_freelist = VM_FREELIST_DEFAULT; 212 213 #ifdef PMAP_NEED_ALLOC_POOLPAGE 214 const uint64_t memory_size = *(uint64_t *)arg; 215 if (atop(memory_size) > bp->bp_pages) { 216 arm_poolpage_vmfreelist = VM_FREELIST_DIRECTMAP; 217 bp->bp_freelist = VM_FREELIST_DIRECTMAP; 218 } 219 #endif 220 } 221 222 223 static void 224 fdt_print_memory(const struct fdt_memory *m, void *arg) 225 { 226 227 VPRINTF("FDT /memory @ 0x%" PRIx64 " size 0x%" PRIx64 "\n", 228 m->start, m->end - m->start); 229 } 230 231 232 /* 233 * Define usable memory regions. 234 */ 235 static void 236 fdt_build_bootconfig(uint64_t mem_start, uint64_t mem_end) 237 { 238 BootConfig *bc = &bootconfig; 239 240 uint64_t addr, size; 241 int index; 242 243 fdt_memory_remove_reserved(mem_start, mem_end); 244 245 const uint64_t initrd_size = 246 round_page(initrd_end) - trunc_page(initrd_start); 247 if (initrd_size > 0) 248 fdt_memory_remove_range(trunc_page(initrd_start), initrd_size); 249 250 const uint64_t rndseed_size = 251 round_page(rndseed_end) - trunc_page(rndseed_start); 252 if (rndseed_size > 0) 253 fdt_memory_remove_range(trunc_page(rndseed_start), 254 rndseed_size); 255 256 const uint64_t efirng_size = 257 round_page(efirng_end) - trunc_page(efirng_start); 258 if (efirng_size > 0) 259 fdt_memory_remove_range(trunc_page(efirng_start), efirng_size); 260 261 const int framebuffer = OF_finddevice("/chosen/framebuffer"); 262 if (framebuffer >= 0) { 263 for (index = 0; 264 fdtbus_get_reg64(framebuffer, index, &addr, &size) == 0; 265 index++) { 266 fdt_memory_remove_range(addr, size); 267 } 268 } 269 270 VPRINTF("Usable memory:\n"); 271 bc->dramblocks = 0; 272 fdt_memory_foreach(fdt_add_dram_blocks, bc); 273 } 274 275 static void 276 fdt_probe_range(const char *startname, const char *endname, 277 uint64_t *pstart, uint64_t *pend) 278 { 279 int chosen, len; 280 const void *start_data, *end_data; 281 282 *pstart = *pend = 0; 283 284 chosen = OF_finddevice("/chosen"); 285 if (chosen < 0) 286 return; 287 288 start_data = fdtbus_get_prop(chosen, startname, &len); 289 end_data = fdtbus_get_prop(chosen, endname, NULL); 290 if (start_data == NULL || end_data == NULL) 291 return; 292 293 switch (len) { 294 case 4: 295 *pstart = be32dec(start_data); 296 *pend = be32dec(end_data); 297 break; 298 case 8: 299 *pstart = be64dec(start_data); 300 *pend = be64dec(end_data); 301 break; 302 default: 303 printf("Unsupported len %d for /chosen `%s'\n", 304 len, startname); 305 return; 306 } 307 } 308 309 static void * 310 fdt_map_range(uint64_t start, uint64_t end, uint64_t *psize, 311 const char *purpose) 312 { 313 const paddr_t startpa = trunc_page(start); 314 const paddr_t endpa = round_page(end); 315 paddr_t pa; 316 vaddr_t va; 317 void *ptr; 318 319 *psize = end - start; 320 if (*psize == 0) 321 return NULL; 322 323 const vaddr_t voff = start & PAGE_MASK; 324 325 va = uvm_km_alloc(kernel_map, *psize, 0, UVM_KMF_VAONLY | UVM_KMF_NOWAIT); 326 if (va == 0) { 327 printf("Failed to allocate VA for %s\n", purpose); 328 return NULL; 329 } 330 ptr = (void *)(va + voff); 331 332 for (pa = startpa; pa < endpa; pa += PAGE_SIZE, va += PAGE_SIZE) 333 pmap_kenter_pa(va, pa, VM_PROT_READ | VM_PROT_WRITE, 0); 334 pmap_update(pmap_kernel()); 335 336 return ptr; 337 } 338 339 static void 340 fdt_unmap_range(void *ptr, uint64_t size) 341 { 342 const char *start = ptr, *end = start + size; 343 const vaddr_t startva = trunc_page((vaddr_t)(uintptr_t)start); 344 const vaddr_t endva = round_page((vaddr_t)(uintptr_t)end); 345 const vsize_t sz = endva - startva; 346 347 pmap_kremove(startva, sz); 348 pmap_update(pmap_kernel()); 349 350 uvm_km_free(kernel_map, startva, sz, UVM_KMF_VAONLY); 351 } 352 353 static void 354 fdt_probe_initrd(uint64_t *pstart, uint64_t *pend) 355 { 356 *pstart = *pend = 0; 357 358 #ifdef MEMORY_DISK_DYNAMIC 359 fdt_probe_range("linux,initrd-start", "linux,initrd-end", pstart, pend); 360 #endif 361 } 362 363 static void 364 fdt_setup_initrd(void) 365 { 366 #ifdef MEMORY_DISK_DYNAMIC 367 void *md_start; 368 uint64_t initrd_size; 369 370 md_start = fdt_map_range(initrd_start, initrd_end, &initrd_size, 371 "initrd"); 372 if (md_start == NULL) 373 return; 374 md_root_setconf(md_start, initrd_size); 375 #endif 376 } 377 378 static void 379 fdt_probe_rndseed(uint64_t *pstart, uint64_t *pend) 380 { 381 382 fdt_probe_range("netbsd,rndseed-start", "netbsd,rndseed-end", 383 pstart, pend); 384 } 385 386 static void 387 fdt_setup_rndseed(void) 388 { 389 uint64_t rndseed_size; 390 void *rndseed; 391 392 rndseed = fdt_map_range(rndseed_start, rndseed_end, &rndseed_size, 393 "rndseed"); 394 if (rndseed == NULL) 395 return; 396 rnd_seed(rndseed, rndseed_size); 397 fdt_unmap_range(rndseed, rndseed_size); 398 } 399 400 static void 401 fdt_probe_efirng(uint64_t *pstart, uint64_t *pend) 402 { 403 404 fdt_probe_range("netbsd,efirng-start", "netbsd,efirng-end", 405 pstart, pend); 406 } 407 408 static struct krndsource efirng_source; 409 410 static void 411 fdt_setup_efirng(void) 412 { 413 uint64_t efirng_size; 414 void *efirng; 415 416 efirng = fdt_map_range(efirng_start, efirng_end, &efirng_size, 417 "efirng"); 418 if (efirng == NULL) 419 return; 420 421 rnd_attach_source(&efirng_source, "efirng", RND_TYPE_RNG, 422 RND_FLAG_DEFAULT); 423 424 /* 425 * We don't really have specific information about the physical 426 * process underlying the data provided by the firmware via the 427 * EFI RNG API, so the entropy estimate here is heuristic. 428 * What efiboot provides us is up to 4096 bytes of data from 429 * the EFI RNG API, although in principle it may return short. 430 * 431 * The UEFI Specification (2.8 Errata A, February 2020[1]) says 432 * 433 * When a Deterministic Random Bit Generator (DRBG) is 434 * used on the output of a (raw) entropy source, its 435 * security level must be at least 256 bits. 436 * 437 * It's not entirely clear whether `it' refers to the DRBG or 438 * the entropy source; if it refers to the DRBG, it's not 439 * entirely clear how ANSI X9.31 3DES, one of the options for 440 * DRBG in the UEFI spec, can provide a `256-bit security 441 * level' because it has only 232 bits of inputs (three 56-bit 442 * keys and one 64-bit block). That said, even if it provides 443 * only 232 bits of entropy, that's enough to prevent all 444 * attacks and we probably get a few more bits from sampling 445 * the clock anyway. 446 * 447 * In the event we get raw samples, e.g. the bits sampled by a 448 * ring oscillator, we hope that the samples have at least half 449 * a bit of entropy per bit of data -- and efiboot tries to 450 * draw 4096 bytes to provide plenty of slop. Hence we divide 451 * the total number of bits by two and clamp at 256. There are 452 * ways this could go wrong, but on most machines it should 453 * behave reasonably. 454 * 455 * [1] https://uefi.org/sites/default/files/resources/UEFI_Spec_2_8_A_Feb14.pdf 456 */ 457 rnd_add_data(&efirng_source, efirng, efirng_size, 458 MIN(256, efirng_size*NBBY/2)); 459 460 explicit_memset(efirng, 0, efirng_size); 461 fdt_unmap_range(efirng, efirng_size); 462 } 463 464 #ifdef EFI_RUNTIME 465 static void 466 fdt_map_efi_runtime(const char *prop, enum arm_efirt_mem_type type) 467 { 468 int len; 469 470 const int chosen_off = fdt_path_offset(fdt_data, "/chosen"); 471 if (chosen_off < 0) 472 return; 473 474 const uint64_t *map = fdt_getprop(fdt_data, chosen_off, prop, &len); 475 if (map == NULL) 476 return; 477 478 while (len >= 24) { 479 const paddr_t pa = be64toh(map[0]); 480 const vaddr_t va = be64toh(map[1]); 481 const size_t sz = be64toh(map[2]); 482 VPRINTF("%s: %s %#" PRIxPADDR "-%#" PRIxVADDR " (%#" PRIxVADDR 483 "-%#" PRIxVSIZE ")\n", __func__, prop, pa, pa + sz - 1, 484 va, va + sz - 1); 485 arm_efirt_md_map_range(va, pa, sz, type); 486 map += 3; 487 len -= 24; 488 } 489 } 490 #endif 491 492 vaddr_t 493 initarm(void *arg) 494 { 495 const struct arm_platform *plat; 496 uint64_t memory_start, memory_end; 497 498 /* set temporally to work printf()/panic() even before consinit() */ 499 cn_tab = &earlycons; 500 501 /* Load FDT */ 502 int error = fdt_check_header(fdt_addr_r); 503 if (error != 0) 504 panic("fdt_check_header failed: %s", fdt_strerror(error)); 505 506 /* If the DTB is too big, try to pack it in place first. */ 507 if (fdt_totalsize(fdt_addr_r) > sizeof(fdt_data)) 508 (void)fdt_pack(__UNCONST(fdt_addr_r)); 509 510 error = fdt_open_into(fdt_addr_r, fdt_data, sizeof(fdt_data)); 511 if (error != 0) 512 panic("fdt_move failed: %s", fdt_strerror(error)); 513 514 fdtbus_init(fdt_data); 515 516 /* Lookup platform specific backend */ 517 plat = arm_fdt_platform(); 518 if (plat == NULL) 519 panic("Kernel does not support this device"); 520 521 /* Early console may be available, announce ourselves. */ 522 VPRINTF("FDT<%p>\n", fdt_addr_r); 523 524 const int chosen = OF_finddevice("/chosen"); 525 if (chosen >= 0) 526 OF_getprop(chosen, "bootargs", bootargs, sizeof(bootargs)); 527 boot_args = bootargs; 528 529 /* Heads up ... Setup the CPU / MMU / TLB functions. */ 530 VPRINTF("cpufunc\n"); 531 if (set_cpufuncs()) 532 panic("cpu not recognized!"); 533 534 /* 535 * Memory is still identity/flat mapped this point so using ttbr for 536 * l1pt VA is fine 537 */ 538 539 VPRINTF("devmap %p\n", plat->ap_devmap()); 540 extern char ARM_BOOTSTRAP_LxPT[]; 541 pmap_devmap_bootstrap((vaddr_t)ARM_BOOTSTRAP_LxPT, plat->ap_devmap()); 542 543 VPRINTF("bootstrap\n"); 544 plat->ap_bootstrap(); 545 546 /* 547 * If stdout-path is specified on the command line, override the 548 * value in /chosen/stdout-path before initializing console. 549 */ 550 VPRINTF("stdout\n"); 551 fdt_update_stdout_path(); 552 553 #if BYTE_ORDER == BIG_ENDIAN 554 /* 555 * Most boards are configured to little-endian mode initially, and 556 * switched to big-endian mode after kernel is loaded. In this case, 557 * framebuffer seems byte-swapped to CPU. Override FDT to let 558 * drivers know. 559 */ 560 VPRINTF("fb_format\n"); 561 fdt_update_fb_format(); 562 #endif 563 564 /* 565 * Done making changes to the FDT. 566 */ 567 fdt_pack(fdt_data); 568 569 VPRINTF("consinit "); 570 consinit(); 571 VPRINTF("ok\n"); 572 573 VPRINTF("uboot: args %#lx, %#lx, %#lx, %#lx\n", 574 uboot_args[0], uboot_args[1], uboot_args[2], uboot_args[3]); 575 576 cpu_reset_address = fdt_reset; 577 cpu_powerdown_address = fdt_powerdown; 578 evbarm_device_register = fdt_device_register; 579 evbarm_device_register_post_config = fdt_device_register_post_config; 580 evbarm_cpu_rootconf = fdt_cpu_rootconf; 581 582 /* Talk to the user */ 583 printf("NetBSD/evbarm (fdt) booting ...\n"); 584 585 #ifdef BOOT_ARGS 586 char mi_bootargs[] = BOOT_ARGS; 587 parse_mi_bootargs(mi_bootargs); 588 #endif 589 590 fdt_memory_get(&memory_start, &memory_end); 591 592 fdt_memory_foreach(fdt_print_memory, NULL); 593 594 #if !defined(_LP64) 595 /* Cannot map memory above 4GB (remove last page as well) */ 596 const uint64_t memory_limit = 0x100000000ULL - PAGE_SIZE; 597 if (memory_end > memory_limit) { 598 fdt_memory_remove_range(memory_limit , memory_end); 599 memory_end = memory_limit; 600 } 601 #endif 602 uint64_t memory_size = memory_end - memory_start; 603 604 VPRINTF("%s: memory start %" PRIx64 " end %" PRIx64 " (len %" 605 PRIx64 ")\n", __func__, memory_start, memory_end, memory_size); 606 607 /* Parse ramdisk info */ 608 fdt_probe_initrd(&initrd_start, &initrd_end); 609 610 /* Parse our on-disk rndseed and the firmware's RNG from EFI */ 611 fdt_probe_rndseed(&rndseed_start, &rndseed_end); 612 fdt_probe_efirng(&efirng_start, &efirng_end); 613 614 /* 615 * Populate bootconfig structure for the benefit of dodumpsys 616 */ 617 VPRINTF("%s: fdt_build_bootconfig\n", __func__); 618 fdt_build_bootconfig(memory_start, memory_end); 619 620 /* Perform PT build and VM init */ 621 cpu_kernel_vm_init(memory_start, memory_size); 622 623 VPRINTF("bootargs: %s\n", bootargs); 624 625 parse_mi_bootargs(boot_args); 626 627 VPRINTF("Memory regions:\n"); 628 629 /* Populate fdt_physmem / nfdt_physmem for initarm_common */ 630 fdt_memory_foreach(fdt_add_boot_physmem, &memory_size); 631 632 vaddr_t sp = initarm_common(KERNEL_VM_BASE, KERNEL_VM_SIZE, fdt_physmem, 633 nfdt_physmem); 634 635 /* 636 * initarm_common flushes cache if required before AP start 637 */ 638 error = 0; 639 if ((boothowto & RB_MD1) == 0) { 640 VPRINTF("mpstart\n"); 641 if (plat->ap_mpstart) 642 error = plat->ap_mpstart(); 643 } 644 645 if (error) 646 return sp; 647 648 /* 649 * Now we have APs started the pages used for stacks and L1PT can 650 * be given to uvm 651 */ 652 extern char const __start__init_memory[]; 653 extern char const __stop__init_memory[] __weak; 654 655 if (__start__init_memory != __stop__init_memory) { 656 const paddr_t spa = KERN_VTOPHYS((vaddr_t)__start__init_memory); 657 const paddr_t epa = KERN_VTOPHYS((vaddr_t)__stop__init_memory); 658 const paddr_t spg = atop(spa); 659 const paddr_t epg = atop(epa); 660 661 VPRINTF(" start %08lx end %08lx... " 662 "loading in freelist %d\n", spa, epa, VM_FREELIST_DEFAULT); 663 664 uvm_page_physload(spg, epg, spg, epg, VM_FREELIST_DEFAULT); 665 666 } 667 668 return sp; 669 } 670 671 static void 672 fdt_update_stdout_path(void) 673 { 674 char *stdout_path, *ep; 675 int stdout_path_len; 676 char buf[256]; 677 678 const int chosen_off = fdt_path_offset(fdt_data, "/chosen"); 679 if (chosen_off == -1) 680 return; 681 682 if (get_bootconf_option(boot_args, "stdout-path", 683 BOOTOPT_TYPE_STRING, &stdout_path) == 0) 684 return; 685 686 ep = strchr(stdout_path, ' '); 687 stdout_path_len = ep ? (ep - stdout_path) : strlen(stdout_path); 688 if (stdout_path_len >= sizeof(buf)) 689 return; 690 691 strncpy(buf, stdout_path, stdout_path_len); 692 buf[stdout_path_len] = '\0'; 693 fdt_setprop(fdt_data, chosen_off, "stdout-path", 694 buf, stdout_path_len + 1); 695 } 696 697 void 698 consinit(void) 699 { 700 static bool initialized = false; 701 const struct arm_platform *plat = arm_fdt_platform(); 702 const struct fdt_console *cons = fdtbus_get_console(); 703 struct fdt_attach_args faa; 704 u_int uart_freq = 0; 705 706 if (initialized || cons == NULL) 707 return; 708 709 plat->ap_init_attach_args(&faa); 710 faa.faa_phandle = fdtbus_get_stdout_phandle(); 711 712 if (plat->ap_uart_freq != NULL) 713 uart_freq = plat->ap_uart_freq(); 714 715 cons->consinit(&faa, uart_freq); 716 717 initialized = true; 718 } 719 720 void 721 cpu_startup_hook(void) 722 { 723 #ifdef EFI_RUNTIME 724 fdt_map_efi_runtime("netbsd,uefi-runtime-code", ARM_EFIRT_MEM_CODE); 725 fdt_map_efi_runtime("netbsd,uefi-runtime-data", ARM_EFIRT_MEM_DATA); 726 fdt_map_efi_runtime("netbsd,uefi-runtime-mmio", ARM_EFIRT_MEM_MMIO); 727 #endif 728 729 fdtbus_intr_init(); 730 731 fdt_setup_rndseed(); 732 fdt_setup_efirng(); 733 } 734 735 void 736 delay(u_int us) 737 { 738 const struct arm_platform *plat = arm_fdt_platform(); 739 740 plat->ap_delay(us); 741 } 742 743 static void 744 fdt_detect_root_device(device_t dev) 745 { 746 struct mbr_sector mbr; 747 uint8_t buf[DEV_BSIZE]; 748 uint8_t hash[16]; 749 const uint8_t *rhash; 750 char rootarg[64]; 751 struct vnode *vp; 752 MD5_CTX md5ctx; 753 int error, len; 754 size_t resid; 755 u_int part; 756 757 const int chosen = OF_finddevice("/chosen"); 758 if (chosen < 0) 759 return; 760 761 if (of_hasprop(chosen, "netbsd,mbr") && 762 of_hasprop(chosen, "netbsd,partition")) { 763 764 /* 765 * The bootloader has passed in a partition index and MD5 hash 766 * of the MBR sector. Read the MBR of this device, calculate the 767 * hash, and compare it with the value passed in. 768 */ 769 rhash = fdtbus_get_prop(chosen, "netbsd,mbr", &len); 770 if (rhash == NULL || len != 16) 771 return; 772 of_getprop_uint32(chosen, "netbsd,partition", &part); 773 if (part >= MAXPARTITIONS) 774 return; 775 776 vp = opendisk(dev); 777 if (!vp) 778 return; 779 error = vn_rdwr(UIO_READ, vp, buf, sizeof(buf), 0, UIO_SYSSPACE, 780 IO_NODELOCKED, NOCRED, &resid, NULL); 781 VOP_CLOSE(vp, FREAD, NOCRED); 782 vput(vp); 783 784 if (error != 0) 785 return; 786 787 memcpy(&mbr, buf, sizeof(mbr)); 788 MD5Init(&md5ctx); 789 MD5Update(&md5ctx, (void *)&mbr, sizeof(mbr)); 790 MD5Final(hash, &md5ctx); 791 792 if (memcmp(rhash, hash, 16) != 0) 793 return; 794 795 snprintf(rootarg, sizeof(rootarg), " root=%s%c", device_xname(dev), part + 'a'); 796 strcat(boot_args, rootarg); 797 } 798 799 if (of_hasprop(chosen, "netbsd,gpt-guid")) { 800 char guidbuf[UUID_STR_LEN]; 801 const struct uuid *guid = fdtbus_get_prop(chosen, "netbsd,gpt-guid", &len); 802 if (guid == NULL || len != 16) 803 return; 804 805 uuid_snprintf(guidbuf, sizeof(guidbuf), guid); 806 snprintf(rootarg, sizeof(rootarg), " root=wedge:%s", guidbuf); 807 strcat(boot_args, rootarg); 808 } 809 810 if (of_hasprop(chosen, "netbsd,gpt-label")) { 811 const char *label = fdtbus_get_string(chosen, "netbsd,gpt-label"); 812 if (label == NULL || *label == '\0') 813 return; 814 815 device_t dv = dkwedge_find_by_wname(label); 816 if (dv != NULL) 817 booted_device = dv; 818 } 819 820 if (of_hasprop(chosen, "netbsd,booted-mac-address")) { 821 const uint8_t *macaddr = fdtbus_get_prop(chosen, "netbsd,booted-mac-address", &len); 822 if (macaddr == NULL || len != 6) 823 return; 824 int s = pserialize_read_enter(); 825 struct ifnet *ifp; 826 IFNET_READER_FOREACH(ifp) { 827 if (memcmp(macaddr, CLLADDR(ifp->if_sadl), len) == 0) { 828 device_t dv = device_find_by_xname(ifp->if_xname); 829 if (dv != NULL) 830 booted_device = dv; 831 break; 832 } 833 } 834 pserialize_read_exit(s); 835 } 836 } 837 838 static void 839 fdt_device_register(device_t self, void *aux) 840 { 841 const struct arm_platform *plat = arm_fdt_platform(); 842 843 if (device_is_a(self, "armfdt")) { 844 fdt_setup_initrd(); 845 846 #if NWSDISPLAY > 0 && NGENFB > 0 847 /* 848 * Setup framebuffer console, if present. 849 */ 850 arm_simplefb_preattach(); 851 #endif 852 } 853 854 #if NWSDISPLAY > 0 && NGENFB > 0 855 if (device_is_a(self, "genfb")) { 856 prop_dictionary_t dict = device_properties(self); 857 prop_dictionary_set_uint64(dict, 858 "simplefb-physaddr", arm_simplefb_physaddr()); 859 } 860 #endif 861 862 if (plat && plat->ap_device_register) 863 plat->ap_device_register(self, aux); 864 } 865 866 static void 867 fdt_device_register_post_config(device_t self, void *aux) 868 { 869 #if NUKBD > 0 && NWSDISPLAY > 0 870 if (device_is_a(self, "wsdisplay")) { 871 struct wsdisplay_softc *sc = device_private(self); 872 if (wsdisplay_isconsole(sc)) 873 ukbd_cnattach(); 874 } 875 #endif 876 } 877 878 static void 879 fdt_cpu_rootconf(void) 880 { 881 device_t dev; 882 deviter_t di; 883 char *ptr; 884 885 if (booted_device != NULL) 886 return; 887 888 for (dev = deviter_first(&di, 0); dev; dev = deviter_next(&di)) { 889 if (device_class(dev) != DV_DISK) 890 continue; 891 892 if (get_bootconf_option(boot_args, "root", BOOTOPT_TYPE_STRING, &ptr) != 0) 893 break; 894 895 if (device_is_a(dev, "ld") || device_is_a(dev, "sd") || device_is_a(dev, "wd")) 896 fdt_detect_root_device(dev); 897 } 898 deviter_release(&di); 899 } 900 901 static void 902 fdt_reset(void) 903 { 904 const struct arm_platform *plat = arm_fdt_platform(); 905 906 fdtbus_power_reset(); 907 908 if (plat && plat->ap_reset) 909 plat->ap_reset(); 910 } 911 912 static void 913 fdt_powerdown(void) 914 { 915 fdtbus_power_poweroff(); 916 } 917 918 #if BYTE_ORDER == BIG_ENDIAN 919 static void 920 fdt_update_fb_format(void) 921 { 922 int off, len; 923 const char *format, *replace; 924 925 off = fdt_path_offset(fdt_data, "/chosen"); 926 if (off < 0) 927 return; 928 929 for (;;) { 930 off = fdt_node_offset_by_compatible(fdt_data, off, 931 "simple-framebuffer"); 932 if (off < 0) 933 return; 934 935 format = fdt_getprop(fdt_data, off, "format", &len); 936 if (format == NULL) 937 continue; 938 939 replace = NULL; 940 if (strcmp(format, "a8b8g8r8") == 0) 941 replace = "r8g8b8a8"; 942 else if (strcmp(format, "x8r8g8b8") == 0) 943 replace = "b8g8r8x8"; 944 if (replace != NULL) 945 fdt_setprop(fdt_data, off, "format", replace, 946 strlen(replace) + 1); 947 } 948 } 949 #endif 950