1 /*- 2 * SPDX-License-Identifier: BSD-4-Clause 3 * 4 * Copyright (C) 1996 Wolfgang Solfrank. 5 * Copyright (C) 1996 TooLs GmbH. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by TooLs GmbH. 19 * 4. The name of TooLs GmbH may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 27 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 28 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 29 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 30 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 31 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 * 33 * $NetBSD: ofw_machdep.c,v 1.5 2000/05/23 13:25:43 tsubai Exp $ 34 */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 #include "opt_platform.h" 40 #include <sys/param.h> 41 #include <sys/bus.h> 42 #include <sys/systm.h> 43 #include <sys/conf.h> 44 #include <sys/disk.h> 45 #include <sys/fcntl.h> 46 #include <sys/malloc.h> 47 #include <sys/smp.h> 48 #include <sys/stat.h> 49 #include <sys/endian.h> 50 51 #include <net/ethernet.h> 52 53 #include <dev/fdt/fdt_common.h> 54 #include <dev/ofw/openfirm.h> 55 #include <dev/ofw/ofw_pci.h> 56 #include <dev/ofw/ofw_bus.h> 57 #include <dev/ofw/ofw_subr.h> 58 59 #include <vm/vm.h> 60 #include <vm/vm_param.h> 61 #include <vm/vm_page.h> 62 63 #include <machine/bus.h> 64 #include <machine/cpu.h> 65 #include <machine/md_var.h> 66 #include <machine/platform.h> 67 #include <machine/ofw_machdep.h> 68 #include <machine/trap.h> 69 70 #include <contrib/libfdt/libfdt.h> 71 72 static void *fdt; 73 int ofw_real_mode; 74 75 #ifdef AIM 76 extern register_t ofmsr[5]; 77 extern void *openfirmware_entry; 78 char save_trap_init[0x2f00]; /* EXC_LAST */ 79 char save_trap_of[0x2f00]; /* EXC_LAST */ 80 81 int ofwcall(void *); 82 static int openfirmware(void *args); 83 84 __inline void 85 ofw_save_trap_vec(char *save_trap_vec) 86 { 87 if (!ofw_real_mode || !hw_direct_map) 88 return; 89 90 bcopy((void *)PHYS_TO_DMAP(EXC_RST), save_trap_vec, EXC_LAST - EXC_RST); 91 } 92 93 static __inline void 94 ofw_restore_trap_vec(char *restore_trap_vec) 95 { 96 if (!ofw_real_mode || !hw_direct_map) 97 return; 98 99 bcopy(restore_trap_vec, (void *)PHYS_TO_DMAP(EXC_RST), 100 EXC_LAST - EXC_RST); 101 __syncicache((void *)PHYS_TO_DMAP(EXC_RSVD), EXC_LAST - EXC_RSVD); 102 } 103 104 /* 105 * Saved SPRG0-3 from OpenFirmware. Will be restored prior to the callback. 106 */ 107 register_t ofw_sprg0_save; 108 109 static __inline void 110 ofw_sprg_prepare(void) 111 { 112 if (ofw_real_mode) 113 return; 114 115 /* 116 * Assume that interrupt are disabled at this point, or 117 * SPRG1-3 could be trashed 118 */ 119 #ifdef __powerpc64__ 120 __asm __volatile("mtsprg1 %0\n\t" 121 "mtsprg2 %1\n\t" 122 "mtsprg3 %2\n\t" 123 : 124 : "r"(ofmsr[2]), 125 "r"(ofmsr[3]), 126 "r"(ofmsr[4])); 127 #else 128 __asm __volatile("mfsprg0 %0\n\t" 129 "mtsprg0 %1\n\t" 130 "mtsprg1 %2\n\t" 131 "mtsprg2 %3\n\t" 132 "mtsprg3 %4\n\t" 133 : "=&r"(ofw_sprg0_save) 134 : "r"(ofmsr[1]), 135 "r"(ofmsr[2]), 136 "r"(ofmsr[3]), 137 "r"(ofmsr[4])); 138 #endif 139 } 140 141 static __inline void 142 ofw_sprg_restore(void) 143 { 144 if (ofw_real_mode) 145 return; 146 147 /* 148 * Note that SPRG1-3 contents are irrelevant. They are scratch 149 * registers used in the early portion of trap handling when 150 * interrupts are disabled. 151 * 152 * PCPU data cannot be used until this routine is called ! 153 */ 154 #ifndef __powerpc64__ 155 __asm __volatile("mtsprg0 %0" :: "r"(ofw_sprg0_save)); 156 #endif 157 } 158 #endif 159 160 static int 161 parse_ofw_memory(phandle_t node, const char *prop, struct mem_region *output) 162 { 163 cell_t address_cells, size_cells; 164 cell_t OFmem[4 * PHYS_AVAIL_SZ]; 165 int sz, i, j; 166 phandle_t phandle; 167 168 sz = 0; 169 170 /* 171 * Get #address-cells from root node, defaulting to 1 if it cannot 172 * be found. 173 */ 174 phandle = OF_finddevice("/"); 175 if (OF_getencprop(phandle, "#address-cells", &address_cells, 176 sizeof(address_cells)) < (ssize_t)sizeof(address_cells)) 177 address_cells = 1; 178 if (OF_getencprop(phandle, "#size-cells", &size_cells, 179 sizeof(size_cells)) < (ssize_t)sizeof(size_cells)) 180 size_cells = 1; 181 182 /* 183 * Get memory. 184 */ 185 if (node == -1 || (sz = OF_getencprop(node, prop, 186 OFmem, sizeof(OFmem))) <= 0) 187 panic("Physical memory map not found"); 188 189 i = 0; 190 j = 0; 191 while (i < sz/sizeof(cell_t)) { 192 output[j].mr_start = OFmem[i++]; 193 if (address_cells == 2) { 194 output[j].mr_start <<= 32; 195 output[j].mr_start += OFmem[i++]; 196 } 197 198 output[j].mr_size = OFmem[i++]; 199 if (size_cells == 2) { 200 output[j].mr_size <<= 32; 201 output[j].mr_size += OFmem[i++]; 202 } 203 204 if (output[j].mr_start > BUS_SPACE_MAXADDR) 205 continue; 206 207 /* 208 * Constrain memory to that which we can access. 209 * 32-bit AIM can only reference 32 bits of address currently, 210 * but Book-E can access 36 bits. 211 */ 212 if (((uint64_t)output[j].mr_start + 213 (uint64_t)output[j].mr_size - 1) > 214 BUS_SPACE_MAXADDR) { 215 output[j].mr_size = BUS_SPACE_MAXADDR - 216 output[j].mr_start + 1; 217 } 218 219 j++; 220 } 221 sz = j*sizeof(output[0]); 222 223 return (sz); 224 } 225 226 #ifdef FDT 227 static int 228 excise_fdt_reserved(struct mem_region *avail, int asz) 229 { 230 struct { 231 uint64_t address; 232 uint64_t size; 233 } fdtmap[32]; 234 ssize_t fdtmapsize; 235 phandle_t chosen; 236 int i, j, k; 237 238 chosen = OF_finddevice("/chosen"); 239 fdtmapsize = OF_getprop(chosen, "fdtmemreserv", fdtmap, sizeof(fdtmap)); 240 241 for (j = 0; j < fdtmapsize/sizeof(fdtmap[0]); j++) { 242 fdtmap[j].address = be64toh(fdtmap[j].address) & ~PAGE_MASK; 243 fdtmap[j].size = round_page(be64toh(fdtmap[j].size)); 244 } 245 246 KASSERT(j*sizeof(fdtmap[0]) < sizeof(fdtmap), 247 ("Exceeded number of FDT reservations")); 248 /* Add a virtual entry for the FDT itself */ 249 if (fdt != NULL) { 250 fdtmap[j].address = (vm_offset_t)fdt & ~PAGE_MASK; 251 fdtmap[j].size = round_page(fdt_totalsize(fdt)); 252 fdtmapsize += sizeof(fdtmap[0]); 253 } 254 255 for (i = 0; i < asz; i++) { 256 for (j = 0; j < fdtmapsize/sizeof(fdtmap[0]); j++) { 257 /* 258 * Case 1: Exclusion region encloses complete 259 * available entry. Drop it and move on. 260 */ 261 if (fdtmap[j].address <= avail[i].mr_start && 262 fdtmap[j].address + fdtmap[j].size >= 263 avail[i].mr_start + avail[i].mr_size) { 264 for (k = i+1; k < asz; k++) 265 avail[k-1] = avail[k]; 266 asz--; 267 i--; /* Repeat some entries */ 268 continue; 269 } 270 271 /* 272 * Case 2: Exclusion region starts in available entry. 273 * Trim it to where the entry begins and append 274 * a new available entry with the region after 275 * the excluded region, if any. 276 */ 277 if (fdtmap[j].address >= avail[i].mr_start && 278 fdtmap[j].address < avail[i].mr_start + 279 avail[i].mr_size) { 280 if (fdtmap[j].address + fdtmap[j].size < 281 avail[i].mr_start + avail[i].mr_size) { 282 avail[asz].mr_start = 283 fdtmap[j].address + fdtmap[j].size; 284 avail[asz].mr_size = avail[i].mr_start + 285 avail[i].mr_size - 286 avail[asz].mr_start; 287 asz++; 288 } 289 290 avail[i].mr_size = fdtmap[j].address - 291 avail[i].mr_start; 292 } 293 294 /* 295 * Case 3: Exclusion region ends in available entry. 296 * Move start point to where the exclusion zone ends. 297 * The case of a contained exclusion zone has already 298 * been caught in case 2. 299 */ 300 if (fdtmap[j].address + fdtmap[j].size >= 301 avail[i].mr_start && fdtmap[j].address + 302 fdtmap[j].size < avail[i].mr_start + 303 avail[i].mr_size) { 304 avail[i].mr_size += avail[i].mr_start; 305 avail[i].mr_start = 306 fdtmap[j].address + fdtmap[j].size; 307 avail[i].mr_size -= avail[i].mr_start; 308 } 309 } 310 } 311 312 return (asz); 313 } 314 #endif 315 316 /* 317 * This is called during powerpc_init, before the system is really initialized. 318 * It shall provide the total and the available regions of RAM. 319 * The available regions need not take the kernel into account. 320 */ 321 void 322 ofw_mem_regions(struct mem_region *memp, int *memsz, 323 struct mem_region *availp, int *availsz) 324 { 325 phandle_t phandle; 326 int asz, msz; 327 int res; 328 char name[31]; 329 330 asz = msz = 0; 331 332 /* 333 * Get memory from all the /memory nodes. 334 */ 335 for (phandle = OF_child(OF_peer(0)); phandle != 0; 336 phandle = OF_peer(phandle)) { 337 if (OF_getprop(phandle, "name", name, sizeof(name)) <= 0) 338 continue; 339 if (strncmp(name, "memory", sizeof(name)) != 0 && 340 strncmp(name, "memory@", strlen("memory@")) != 0) 341 continue; 342 343 res = parse_ofw_memory(phandle, "reg", &memp[msz]); 344 msz += res/sizeof(struct mem_region); 345 346 /* 347 * On POWER9 Systems we might have both linux,usable-memory and 348 * reg properties. 'reg' denotes all available memory, but we 349 * must use 'linux,usable-memory', a subset, as some memory 350 * regions are reserved for NVLink. 351 */ 352 if (OF_getproplen(phandle, "linux,usable-memory") >= 0) 353 res = parse_ofw_memory(phandle, "linux,usable-memory", 354 &availp[asz]); 355 else if (OF_getproplen(phandle, "available") >= 0) 356 res = parse_ofw_memory(phandle, "available", 357 &availp[asz]); 358 else 359 res = parse_ofw_memory(phandle, "reg", &availp[asz]); 360 asz += res/sizeof(struct mem_region); 361 } 362 363 #ifdef FDT 364 phandle = OF_finddevice("/chosen"); 365 if (OF_hasprop(phandle, "fdtmemreserv")) 366 asz = excise_fdt_reserved(availp, asz); 367 #endif 368 369 *memsz = msz; 370 *availsz = asz; 371 } 372 373 void 374 OF_initial_setup(void *fdt_ptr, void *junk, int (*openfirm)(void *)) 375 { 376 #ifdef AIM 377 ofmsr[0] = mfmsr(); 378 #ifdef __powerpc64__ 379 ofmsr[0] &= ~PSL_SF; 380 #else 381 __asm __volatile("mfsprg0 %0" : "=&r"(ofmsr[1])); 382 #endif 383 __asm __volatile("mfsprg1 %0" : "=&r"(ofmsr[2])); 384 __asm __volatile("mfsprg2 %0" : "=&r"(ofmsr[3])); 385 __asm __volatile("mfsprg3 %0" : "=&r"(ofmsr[4])); 386 openfirmware_entry = openfirm; 387 388 if (ofmsr[0] & PSL_DR) 389 ofw_real_mode = 0; 390 else 391 ofw_real_mode = 1; 392 393 ofw_save_trap_vec(save_trap_init); 394 #else 395 ofw_real_mode = 1; 396 #endif 397 398 fdt = fdt_ptr; 399 } 400 401 boolean_t 402 OF_bootstrap() 403 { 404 boolean_t status = FALSE; 405 int err = 0; 406 407 #ifdef AIM 408 if (openfirmware_entry != NULL) { 409 if (ofw_real_mode) { 410 status = OF_install(OFW_STD_REAL, 0); 411 } else { 412 #ifdef __powerpc64__ 413 status = OF_install(OFW_STD_32BIT, 0); 414 #else 415 status = OF_install(OFW_STD_DIRECT, 0); 416 #endif 417 } 418 419 if (status != TRUE) 420 return status; 421 422 err = OF_init(openfirmware); 423 } else 424 #endif 425 if (fdt != NULL) { 426 #ifdef FDT 427 #ifdef AIM 428 bus_space_tag_t fdt_bt; 429 vm_offset_t tmp_fdt_ptr; 430 vm_size_t fdt_size; 431 uintptr_t fdt_va; 432 #endif 433 434 status = OF_install(OFW_FDT, 0); 435 if (status != TRUE) 436 return status; 437 438 #ifdef AIM /* AIM-only for now -- Book-E does this remapping in early init */ 439 /* Get the FDT size for mapping if we can */ 440 tmp_fdt_ptr = pmap_early_io_map((vm_paddr_t)fdt, PAGE_SIZE); 441 if (fdt_check_header((void *)tmp_fdt_ptr) != 0) { 442 pmap_early_io_unmap(tmp_fdt_ptr, PAGE_SIZE); 443 return FALSE; 444 } 445 fdt_size = fdt_totalsize((void *)tmp_fdt_ptr); 446 pmap_early_io_unmap(tmp_fdt_ptr, PAGE_SIZE); 447 448 /* 449 * Map this for real. Use bus_space_map() to take advantage 450 * of its auto-remapping function once the kernel is loaded. 451 * This is a dirty hack, but what we have. 452 */ 453 #ifdef _LITTLE_ENDIAN 454 fdt_bt = &bs_le_tag; 455 #else 456 fdt_bt = &bs_be_tag; 457 #endif 458 bus_space_map(fdt_bt, (vm_paddr_t)fdt, fdt_size, 0, &fdt_va); 459 460 err = OF_init((void *)fdt_va); 461 #else 462 err = OF_init(fdt); 463 #endif 464 #endif 465 } 466 467 #ifdef FDT_DTB_STATIC 468 /* 469 * Check for a statically included blob already in the kernel and 470 * needing no mapping. 471 */ 472 else { 473 status = OF_install(OFW_FDT, 0); 474 if (status != TRUE) 475 return status; 476 err = OF_init(&fdt_static_dtb); 477 } 478 #endif 479 480 if (err != 0) { 481 OF_install(NULL, 0); 482 status = FALSE; 483 } 484 485 return (status); 486 } 487 488 #ifdef AIM 489 void 490 ofw_quiesce(void) 491 { 492 struct { 493 cell_t name; 494 cell_t nargs; 495 cell_t nreturns; 496 } args; 497 498 KASSERT(!pmap_bootstrapped, ("Cannot call ofw_quiesce after VM is up")); 499 500 args.name = (cell_t)(uintptr_t)"quiesce"; 501 args.nargs = 0; 502 args.nreturns = 0; 503 openfirmware(&args); 504 } 505 506 static int 507 openfirmware_core(void *args) 508 { 509 int result; 510 register_t oldmsr; 511 512 if (openfirmware_entry == NULL) 513 return (-1); 514 515 /* 516 * Turn off exceptions - we really don't want to end up 517 * anywhere unexpected with PCPU set to something strange 518 * or the stack pointer wrong. 519 */ 520 oldmsr = intr_disable(); 521 522 ofw_sprg_prepare(); 523 524 /* Save trap vectors */ 525 ofw_save_trap_vec(save_trap_of); 526 527 /* Restore initially saved trap vectors */ 528 ofw_restore_trap_vec(save_trap_init); 529 530 #ifndef __powerpc64__ 531 /* 532 * Clear battable[] translations 533 */ 534 if (!(cpu_features & PPC_FEATURE_64)) 535 __asm __volatile("mtdbatu 2, %0\n" 536 "mtdbatu 3, %0" : : "r" (0)); 537 isync(); 538 #endif 539 540 result = ofwcall(args); 541 542 /* Restore trap vecotrs */ 543 ofw_restore_trap_vec(save_trap_of); 544 545 ofw_sprg_restore(); 546 547 intr_restore(oldmsr); 548 549 return (result); 550 } 551 552 #ifdef SMP 553 struct ofw_rv_args { 554 void *args; 555 int retval; 556 volatile int in_progress; 557 }; 558 559 static void 560 ofw_rendezvous_dispatch(void *xargs) 561 { 562 struct ofw_rv_args *rv_args = xargs; 563 564 /* NOTE: Interrupts are disabled here */ 565 566 if (PCPU_GET(cpuid) == 0) { 567 /* 568 * Execute all OF calls on CPU 0 569 */ 570 rv_args->retval = openfirmware_core(rv_args->args); 571 rv_args->in_progress = 0; 572 } else { 573 /* 574 * Spin with interrupts off on other CPUs while OF has 575 * control of the machine. 576 */ 577 while (rv_args->in_progress) 578 cpu_spinwait(); 579 } 580 } 581 #endif 582 583 static int 584 openfirmware(void *args) 585 { 586 int result; 587 #ifdef SMP 588 struct ofw_rv_args rv_args; 589 #endif 590 591 if (openfirmware_entry == NULL) 592 return (-1); 593 594 #ifdef SMP 595 if (cold) { 596 result = openfirmware_core(args); 597 } else { 598 rv_args.args = args; 599 rv_args.in_progress = 1; 600 smp_rendezvous(smp_no_rendezvous_barrier, 601 ofw_rendezvous_dispatch, smp_no_rendezvous_barrier, 602 &rv_args); 603 result = rv_args.retval; 604 } 605 #else 606 result = openfirmware_core(args); 607 #endif 608 609 return (result); 610 } 611 612 void 613 OF_reboot() 614 { 615 struct { 616 cell_t name; 617 cell_t nargs; 618 cell_t nreturns; 619 cell_t arg; 620 } args; 621 622 args.name = (cell_t)(uintptr_t)"interpret"; 623 args.nargs = 1; 624 args.nreturns = 0; 625 args.arg = (cell_t)(uintptr_t)"reset-all"; 626 openfirmware_core(&args); /* Don't do rendezvous! */ 627 628 for (;;); /* just in case */ 629 } 630 631 #endif /* AIM */ 632 633 void 634 OF_getetheraddr(device_t dev, u_char *addr) 635 { 636 phandle_t node; 637 638 node = ofw_bus_get_node(dev); 639 OF_getprop(node, "local-mac-address", addr, ETHER_ADDR_LEN); 640 } 641 642 /* 643 * Return a bus handle and bus tag that corresponds to the register 644 * numbered regno for the device referenced by the package handle 645 * dev. This function is intended to be used by console drivers in 646 * early boot only. It works by mapping the address of the device's 647 * register in the address space of its parent and recursively walk 648 * the device tree upward this way. 649 */ 650 int 651 OF_decode_addr(phandle_t dev, int regno, bus_space_tag_t *tag, 652 bus_space_handle_t *handle, bus_size_t *sz) 653 { 654 bus_addr_t addr; 655 bus_size_t size; 656 pcell_t pci_hi; 657 int flags, res; 658 659 res = ofw_reg_to_paddr(dev, regno, &addr, &size, &pci_hi); 660 if (res < 0) 661 return (res); 662 663 if (pci_hi == OFW_PADDR_NOT_PCI) { 664 *tag = &bs_be_tag; 665 flags = 0; 666 } else { 667 *tag = &bs_le_tag; 668 flags = (pci_hi & OFW_PCI_PHYS_HI_PREFETCHABLE) ? 669 BUS_SPACE_MAP_PREFETCHABLE: 0; 670 } 671 672 if (sz != NULL) 673 *sz = size; 674 675 return (bus_space_map(*tag, addr, size, flags, handle)); 676 } 677 678