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