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/lock.h> 47 #include <sys/malloc.h> 48 #include <sys/smp.h> 49 #include <sys/stat.h> 50 #include <sys/endian.h> 51 52 #include <net/ethernet.h> 53 54 #include <dev/fdt/fdt_common.h> 55 #include <dev/ofw/openfirm.h> 56 #include <dev/ofw/ofw_pci.h> 57 #include <dev/ofw/ofw_bus.h> 58 #include <dev/ofw/ofw_subr.h> 59 60 #include <vm/vm.h> 61 #include <vm/vm_param.h> 62 #include <vm/vm_page.h> 63 #include <vm/vm_phys.h> 64 65 #include <machine/bus.h> 66 #include <machine/cpu.h> 67 #include <machine/md_var.h> 68 #include <machine/platform.h> 69 #include <machine/ofw_machdep.h> 70 #include <machine/trap.h> 71 72 #include <contrib/libfdt/libfdt.h> 73 74 #ifdef POWERNV 75 #include <powerpc/powernv/opal.h> 76 #endif 77 78 static void *fdt; 79 int ofw_real_mode; 80 81 #ifdef AIM 82 extern register_t ofmsr[5]; 83 extern void *openfirmware_entry; 84 char save_trap_init[0x2f00]; /* EXC_LAST */ 85 char save_trap_of[0x2f00]; /* EXC_LAST */ 86 87 int ofwcall(void *); 88 static int openfirmware(void *args); 89 90 __inline void 91 ofw_save_trap_vec(char *save_trap_vec) 92 { 93 if (!ofw_real_mode || !hw_direct_map) 94 return; 95 96 bcopy((void *)PHYS_TO_DMAP(EXC_RST), save_trap_vec, EXC_LAST - EXC_RST); 97 } 98 99 static __inline void 100 ofw_restore_trap_vec(char *restore_trap_vec) 101 { 102 if (!ofw_real_mode || !hw_direct_map) 103 return; 104 105 bcopy(restore_trap_vec, (void *)PHYS_TO_DMAP(EXC_RST), 106 EXC_LAST - EXC_RST); 107 __syncicache((void *)PHYS_TO_DMAP(EXC_RSVD), EXC_LAST - EXC_RSVD); 108 } 109 110 /* 111 * Saved SPRG0-3 from OpenFirmware. Will be restored prior to the callback. 112 */ 113 register_t ofw_sprg0_save; 114 115 static __inline void 116 ofw_sprg_prepare(void) 117 { 118 if (ofw_real_mode) 119 return; 120 121 /* 122 * Assume that interrupt are disabled at this point, or 123 * SPRG1-3 could be trashed 124 */ 125 #ifdef __powerpc64__ 126 __asm __volatile("mtsprg1 %0\n\t" 127 "mtsprg2 %1\n\t" 128 "mtsprg3 %2\n\t" 129 : 130 : "r"(ofmsr[2]), 131 "r"(ofmsr[3]), 132 "r"(ofmsr[4])); 133 #else 134 __asm __volatile("mfsprg0 %0\n\t" 135 "mtsprg0 %1\n\t" 136 "mtsprg1 %2\n\t" 137 "mtsprg2 %3\n\t" 138 "mtsprg3 %4\n\t" 139 : "=&r"(ofw_sprg0_save) 140 : "r"(ofmsr[1]), 141 "r"(ofmsr[2]), 142 "r"(ofmsr[3]), 143 "r"(ofmsr[4])); 144 #endif 145 } 146 147 static __inline void 148 ofw_sprg_restore(void) 149 { 150 if (ofw_real_mode) 151 return; 152 153 /* 154 * Note that SPRG1-3 contents are irrelevant. They are scratch 155 * registers used in the early portion of trap handling when 156 * interrupts are disabled. 157 * 158 * PCPU data cannot be used until this routine is called ! 159 */ 160 #ifndef __powerpc64__ 161 __asm __volatile("mtsprg0 %0" :: "r"(ofw_sprg0_save)); 162 #endif 163 } 164 #endif 165 166 static int 167 parse_ofw_memory(phandle_t node, const char *prop, struct mem_region *output) 168 { 169 cell_t address_cells, size_cells; 170 cell_t OFmem[4 * PHYS_AVAIL_SZ]; 171 int sz, i, j; 172 phandle_t phandle; 173 174 sz = 0; 175 176 /* 177 * Get #address-cells from root node, defaulting to 1 if it cannot 178 * be found. 179 */ 180 phandle = OF_finddevice("/"); 181 if (OF_getencprop(phandle, "#address-cells", &address_cells, 182 sizeof(address_cells)) < (ssize_t)sizeof(address_cells)) 183 address_cells = 1; 184 if (OF_getencprop(phandle, "#size-cells", &size_cells, 185 sizeof(size_cells)) < (ssize_t)sizeof(size_cells)) 186 size_cells = 1; 187 188 /* 189 * Get memory. 190 */ 191 if (node == -1 || (sz = OF_getencprop(node, prop, 192 OFmem, sizeof(OFmem))) <= 0) 193 panic("Physical memory map not found"); 194 195 i = 0; 196 j = 0; 197 while (i < sz/sizeof(cell_t)) { 198 output[j].mr_start = OFmem[i++]; 199 if (address_cells == 2) { 200 output[j].mr_start <<= 32; 201 output[j].mr_start += OFmem[i++]; 202 } 203 204 output[j].mr_size = OFmem[i++]; 205 if (size_cells == 2) { 206 output[j].mr_size <<= 32; 207 output[j].mr_size += OFmem[i++]; 208 } 209 210 if (output[j].mr_start > BUS_SPACE_MAXADDR) 211 continue; 212 213 /* 214 * Constrain memory to that which we can access. 215 * 32-bit AIM can only reference 32 bits of address currently, 216 * but Book-E can access 36 bits. 217 */ 218 if (((uint64_t)output[j].mr_start + 219 (uint64_t)output[j].mr_size - 1) > 220 BUS_SPACE_MAXADDR) { 221 output[j].mr_size = BUS_SPACE_MAXADDR - 222 output[j].mr_start + 1; 223 } 224 225 j++; 226 } 227 228 return (j); 229 } 230 231 static int 232 parse_numa_ofw_memory(phandle_t node, const char *prop, 233 struct numa_mem_region *output) 234 { 235 cell_t address_cells, size_cells; 236 cell_t OFmem[4 * PHYS_AVAIL_SZ]; 237 int sz, i, j; 238 phandle_t phandle; 239 240 sz = 0; 241 242 /* 243 * Get #address-cells from root node, defaulting to 1 if it cannot 244 * be found. 245 */ 246 phandle = OF_finddevice("/"); 247 if (OF_getencprop(phandle, "#address-cells", &address_cells, 248 sizeof(address_cells)) < (ssize_t)sizeof(address_cells)) 249 address_cells = 1; 250 if (OF_getencprop(phandle, "#size-cells", &size_cells, 251 sizeof(size_cells)) < (ssize_t)sizeof(size_cells)) 252 size_cells = 1; 253 254 /* 255 * Get memory. 256 */ 257 if (node == -1 || (sz = OF_getencprop(node, prop, 258 OFmem, sizeof(OFmem))) <= 0) 259 panic("Physical memory map not found"); 260 261 i = 0; 262 j = 0; 263 while (i < sz/sizeof(cell_t)) { 264 output[j].mr_start = OFmem[i++]; 265 if (address_cells == 2) { 266 output[j].mr_start <<= 32; 267 output[j].mr_start += OFmem[i++]; 268 } 269 output[j].mr_size = OFmem[i++]; 270 if (size_cells == 2) { 271 output[j].mr_size <<= 32; 272 output[j].mr_size += OFmem[i++]; 273 } 274 j++; 275 } 276 277 return (j); 278 } 279 280 #ifdef FDT 281 static int 282 excise_reserved_regions(struct mem_region *avail, int asz, 283 struct mem_region *exclude, int esz) 284 { 285 int i, j, k; 286 287 for (i = 0; i < asz; i++) { 288 for (j = 0; j < esz; j++) { 289 /* 290 * Case 1: Exclusion region encloses complete 291 * available entry. Drop it and move on. 292 */ 293 if (exclude[j].mr_start <= avail[i].mr_start && 294 exclude[j].mr_start + exclude[j].mr_size >= 295 avail[i].mr_start + avail[i].mr_size) { 296 for (k = i+1; k < asz; k++) 297 avail[k-1] = avail[k]; 298 asz--; 299 i--; /* Repeat some entries */ 300 continue; 301 } 302 303 /* 304 * Case 2: Exclusion region starts in available entry. 305 * Trim it to where the entry begins and append 306 * a new available entry with the region after 307 * the excluded region, if any. 308 */ 309 if (exclude[j].mr_start >= avail[i].mr_start && 310 exclude[j].mr_start < avail[i].mr_start + 311 avail[i].mr_size) { 312 if (exclude[j].mr_start + exclude[j].mr_size < 313 avail[i].mr_start + avail[i].mr_size) { 314 avail[asz].mr_start = 315 exclude[j].mr_start + exclude[j].mr_size; 316 avail[asz].mr_size = avail[i].mr_start + 317 avail[i].mr_size - 318 avail[asz].mr_start; 319 asz++; 320 } 321 322 avail[i].mr_size = exclude[j].mr_start - 323 avail[i].mr_start; 324 } 325 326 /* 327 * Case 3: Exclusion region ends in available entry. 328 * Move start point to where the exclusion zone ends. 329 * The case of a contained exclusion zone has already 330 * been caught in case 2. 331 */ 332 if (exclude[j].mr_start + exclude[j].mr_size >= 333 avail[i].mr_start && exclude[j].mr_start + 334 exclude[j].mr_size < avail[i].mr_start + 335 avail[i].mr_size) { 336 avail[i].mr_size += avail[i].mr_start; 337 avail[i].mr_start = 338 exclude[j].mr_start + exclude[j].mr_size; 339 avail[i].mr_size -= avail[i].mr_start; 340 } 341 } 342 } 343 344 return (asz); 345 } 346 347 static int 348 excise_initrd_region(struct mem_region *avail, int asz) 349 { 350 phandle_t chosen; 351 uint64_t start, end; 352 ssize_t size; 353 struct mem_region initrdmap[1]; 354 pcell_t cell[2]; 355 356 chosen = OF_finddevice("/chosen"); 357 358 size = OF_getencprop(chosen, "linux,initrd-start", cell, sizeof(cell)); 359 if (size < 0) 360 return (asz); 361 else if (size == 4) 362 start = cell[0]; 363 else if (size == 8) 364 start = (uint64_t)cell[0] << 32 | cell[1]; 365 else { 366 /* Invalid value length */ 367 printf("WARNING: linux,initrd-start must be either 4 or 8 bytes long\n"); 368 return (asz); 369 } 370 371 size = OF_getencprop(chosen, "linux,initrd-end", cell, sizeof(cell)); 372 if (size < 0) 373 return (asz); 374 else if (size == 4) 375 end = cell[0]; 376 else if (size == 8) 377 end = (uint64_t)cell[0] << 32 | cell[1]; 378 else { 379 /* Invalid value length */ 380 printf("WARNING: linux,initrd-end must be either 4 or 8 bytes long\n"); 381 return (asz); 382 } 383 384 if (end <= start) 385 return (asz); 386 387 initrdmap[0].mr_start = start; 388 initrdmap[0].mr_size = end - start; 389 390 asz = excise_reserved_regions(avail, asz, initrdmap, 1); 391 392 return (asz); 393 } 394 395 #ifdef POWERNV 396 static int 397 excise_msi_region(struct mem_region *avail, int asz) 398 { 399 uint64_t start, end; 400 struct mem_region initrdmap[1]; 401 402 /* 403 * This range of physical addresses is used to implement optimized 404 * 32 bit MSI interrupts on POWER9. Exclude it to avoid accidentally 405 * using it for DMA, as this will cause an immediate PHB fence. 406 * While we could theoretically turn off this behavior in the ETU, 407 * doing so would break 32-bit MSI, so just reserve the range in 408 * the physical map instead. 409 * See section 4.4.2.8 of the PHB4 specification. 410 */ 411 start = 0x00000000ffff0000ul; 412 end = 0x00000000fffffffful; 413 414 initrdmap[0].mr_start = start; 415 initrdmap[0].mr_size = end - start; 416 417 asz = excise_reserved_regions(avail, asz, initrdmap, 1); 418 419 return (asz); 420 } 421 #endif 422 423 static int 424 excise_fdt_reserved(struct mem_region *avail, int asz) 425 { 426 struct mem_region fdtmap[32]; 427 ssize_t fdtmapsize; 428 phandle_t chosen; 429 int j, fdtentries; 430 431 chosen = OF_finddevice("/chosen"); 432 fdtmapsize = OF_getprop(chosen, "fdtmemreserv", fdtmap, sizeof(fdtmap)); 433 434 for (j = 0; j < fdtmapsize/sizeof(fdtmap[0]); j++) { 435 fdtmap[j].mr_start = be64toh(fdtmap[j].mr_start) & ~PAGE_MASK; 436 fdtmap[j].mr_size = round_page(be64toh(fdtmap[j].mr_size)); 437 } 438 439 KASSERT(j*sizeof(fdtmap[0]) < sizeof(fdtmap), 440 ("Exceeded number of FDT reservations")); 441 /* Add a virtual entry for the FDT itself */ 442 if (fdt != NULL) { 443 fdtmap[j].mr_start = (vm_offset_t)fdt & ~PAGE_MASK; 444 fdtmap[j].mr_size = round_page(fdt_totalsize(fdt)); 445 fdtmapsize += sizeof(fdtmap[0]); 446 } 447 448 fdtentries = fdtmapsize/sizeof(fdtmap[0]); 449 asz = excise_reserved_regions(avail, asz, fdtmap, fdtentries); 450 451 return (asz); 452 } 453 #endif 454 455 /* 456 * This is called during powerpc_init, before the system is really initialized. 457 * It shall provide the total and the available regions of RAM. 458 * The available regions need not take the kernel into account. 459 */ 460 void 461 ofw_numa_mem_regions(struct numa_mem_region *memp, int *memsz) 462 { 463 phandle_t phandle; 464 int res, count, msz; 465 char name[31]; 466 cell_t associativity[5]; 467 struct numa_mem_region *curmemp; 468 469 msz = 0; 470 /* 471 * Get memory from all the /memory nodes. 472 */ 473 for (phandle = OF_child(OF_peer(0)); phandle != 0; 474 phandle = OF_peer(phandle)) { 475 if (OF_getprop(phandle, "name", name, sizeof(name)) <= 0) 476 continue; 477 if (strncmp(name, "memory@", strlen("memory@")) != 0) 478 continue; 479 480 count = parse_numa_ofw_memory(phandle, "reg", &memp[msz]); 481 if (count == 0) 482 continue; 483 curmemp = &memp[msz]; 484 res = OF_getproplen(phandle, "ibm,associativity"); 485 if (res <= 0) 486 continue; 487 MPASS(count == 1); 488 OF_getencprop(phandle, "ibm,associativity", 489 associativity, res); 490 curmemp->mr_domain = associativity[3] - 1; 491 if (bootverbose) 492 printf("%s %#jx-%#jx domain(%ju)\n", 493 name, (uintmax_t)curmemp->mr_start, 494 (uintmax_t)curmemp->mr_start + curmemp->mr_size, 495 (uintmax_t)curmemp->mr_domain); 496 msz += count; 497 } 498 *memsz = msz; 499 } 500 /* 501 * This is called during powerpc_init, before the system is really initialized. 502 * It shall provide the total and the available regions of RAM. 503 * The available regions need not take the kernel into account. 504 */ 505 void 506 ofw_mem_regions(struct mem_region *memp, int *memsz, 507 struct mem_region *availp, int *availsz) 508 { 509 phandle_t phandle; 510 int asz, msz; 511 int res; 512 char name[31]; 513 514 asz = msz = 0; 515 516 /* 517 * Get memory from all the /memory nodes. 518 */ 519 for (phandle = OF_child(OF_peer(0)); phandle != 0; 520 phandle = OF_peer(phandle)) { 521 if (OF_getprop(phandle, "name", name, sizeof(name)) <= 0) 522 continue; 523 if (strncmp(name, "memory", sizeof(name)) != 0 && 524 strncmp(name, "memory@", strlen("memory@")) != 0) 525 continue; 526 527 res = parse_ofw_memory(phandle, "reg", &memp[msz]); 528 msz += res; 529 530 /* 531 * On POWER9 Systems we might have both linux,usable-memory and 532 * reg properties. 'reg' denotes all available memory, but we 533 * must use 'linux,usable-memory', a subset, as some memory 534 * regions are reserved for NVLink. 535 */ 536 if (OF_getproplen(phandle, "linux,usable-memory") >= 0) 537 res = parse_ofw_memory(phandle, "linux,usable-memory", 538 &availp[asz]); 539 else if (OF_getproplen(phandle, "available") >= 0) 540 res = parse_ofw_memory(phandle, "available", 541 &availp[asz]); 542 else 543 res = parse_ofw_memory(phandle, "reg", &availp[asz]); 544 asz += res; 545 } 546 547 #ifdef FDT 548 phandle = OF_finddevice("/chosen"); 549 if (OF_hasprop(phandle, "fdtmemreserv")) 550 asz = excise_fdt_reserved(availp, asz); 551 552 /* If the kernel is being loaded through kexec, initrd region is listed 553 * in /chosen but the region is not marked as reserved, so, we might exclude 554 * it here. 555 */ 556 if (OF_hasprop(phandle, "linux,initrd-start")) 557 asz = excise_initrd_region(availp, asz); 558 #endif 559 560 #ifdef POWERNV 561 if (opal_check() == 0) 562 asz = excise_msi_region(availp, asz); 563 #endif 564 565 *memsz = msz; 566 *availsz = asz; 567 } 568 569 void 570 OF_initial_setup(void *fdt_ptr, void *junk, int (*openfirm)(void *)) 571 { 572 #ifdef AIM 573 ofmsr[0] = mfmsr(); 574 #ifdef __powerpc64__ 575 ofmsr[0] &= ~PSL_SF; 576 #else 577 __asm __volatile("mfsprg0 %0" : "=&r"(ofmsr[1])); 578 #endif 579 __asm __volatile("mfsprg1 %0" : "=&r"(ofmsr[2])); 580 __asm __volatile("mfsprg2 %0" : "=&r"(ofmsr[3])); 581 __asm __volatile("mfsprg3 %0" : "=&r"(ofmsr[4])); 582 openfirmware_entry = openfirm; 583 584 if (ofmsr[0] & PSL_DR) 585 ofw_real_mode = 0; 586 else 587 ofw_real_mode = 1; 588 589 ofw_save_trap_vec(save_trap_init); 590 #else 591 ofw_real_mode = 1; 592 #endif 593 594 fdt = fdt_ptr; 595 } 596 597 boolean_t 598 OF_bootstrap() 599 { 600 boolean_t status = FALSE; 601 int err = 0; 602 603 #ifdef AIM 604 if (openfirmware_entry != NULL) { 605 if (ofw_real_mode) { 606 status = OF_install(OFW_STD_REAL, 0); 607 } else { 608 #ifdef __powerpc64__ 609 status = OF_install(OFW_STD_32BIT, 0); 610 #else 611 status = OF_install(OFW_STD_DIRECT, 0); 612 #endif 613 } 614 615 if (status != TRUE) 616 return status; 617 618 err = OF_init(openfirmware); 619 } else 620 #endif 621 if (fdt != NULL) { 622 #ifdef FDT 623 #ifdef AIM 624 bus_space_tag_t fdt_bt; 625 vm_offset_t tmp_fdt_ptr; 626 vm_size_t fdt_size; 627 uintptr_t fdt_va; 628 #endif 629 630 status = OF_install(OFW_FDT, 0); 631 if (status != TRUE) 632 return status; 633 634 #ifdef AIM /* AIM-only for now -- Book-E does this remapping in early init */ 635 /* Get the FDT size for mapping if we can */ 636 tmp_fdt_ptr = pmap_early_io_map((vm_paddr_t)fdt, PAGE_SIZE); 637 if (fdt_check_header((void *)tmp_fdt_ptr) != 0) { 638 pmap_early_io_unmap(tmp_fdt_ptr, PAGE_SIZE); 639 return FALSE; 640 } 641 fdt_size = fdt_totalsize((void *)tmp_fdt_ptr); 642 pmap_early_io_unmap(tmp_fdt_ptr, PAGE_SIZE); 643 644 /* 645 * Map this for real. Use bus_space_map() to take advantage 646 * of its auto-remapping function once the kernel is loaded. 647 * This is a dirty hack, but what we have. 648 */ 649 #ifdef _LITTLE_ENDIAN 650 fdt_bt = &bs_le_tag; 651 #else 652 fdt_bt = &bs_be_tag; 653 #endif 654 bus_space_map(fdt_bt, (vm_paddr_t)fdt, fdt_size, 0, &fdt_va); 655 656 err = OF_init((void *)fdt_va); 657 #else 658 err = OF_init(fdt); 659 #endif 660 #endif 661 } 662 663 #ifdef FDT_DTB_STATIC 664 /* 665 * Check for a statically included blob already in the kernel and 666 * needing no mapping. 667 */ 668 else { 669 status = OF_install(OFW_FDT, 0); 670 if (status != TRUE) 671 return status; 672 err = OF_init(&fdt_static_dtb); 673 } 674 #endif 675 676 if (err != 0) { 677 OF_install(NULL, 0); 678 status = FALSE; 679 } 680 681 return (status); 682 } 683 684 #ifdef AIM 685 void 686 ofw_quiesce(void) 687 { 688 struct { 689 cell_t name; 690 cell_t nargs; 691 cell_t nreturns; 692 } args; 693 694 KASSERT(!pmap_bootstrapped, ("Cannot call ofw_quiesce after VM is up")); 695 696 args.name = (cell_t)(uintptr_t)"quiesce"; 697 args.nargs = 0; 698 args.nreturns = 0; 699 openfirmware(&args); 700 } 701 702 static int 703 openfirmware_core(void *args) 704 { 705 int result; 706 register_t oldmsr; 707 708 if (openfirmware_entry == NULL) 709 return (-1); 710 711 /* 712 * Turn off exceptions - we really don't want to end up 713 * anywhere unexpected with PCPU set to something strange 714 * or the stack pointer wrong. 715 */ 716 oldmsr = intr_disable(); 717 718 ofw_sprg_prepare(); 719 720 /* Save trap vectors */ 721 ofw_save_trap_vec(save_trap_of); 722 723 /* Restore initially saved trap vectors */ 724 ofw_restore_trap_vec(save_trap_init); 725 726 #ifndef __powerpc64__ 727 /* 728 * Clear battable[] translations 729 */ 730 if (!(cpu_features & PPC_FEATURE_64)) 731 __asm __volatile("mtdbatu 2, %0\n" 732 "mtdbatu 3, %0" : : "r" (0)); 733 isync(); 734 #endif 735 736 result = ofwcall(args); 737 738 /* Restore trap vecotrs */ 739 ofw_restore_trap_vec(save_trap_of); 740 741 ofw_sprg_restore(); 742 743 intr_restore(oldmsr); 744 745 return (result); 746 } 747 748 #ifdef SMP 749 struct ofw_rv_args { 750 void *args; 751 int retval; 752 volatile int in_progress; 753 }; 754 755 static void 756 ofw_rendezvous_dispatch(void *xargs) 757 { 758 struct ofw_rv_args *rv_args = xargs; 759 760 /* NOTE: Interrupts are disabled here */ 761 762 if (PCPU_GET(cpuid) == 0) { 763 /* 764 * Execute all OF calls on CPU 0 765 */ 766 rv_args->retval = openfirmware_core(rv_args->args); 767 rv_args->in_progress = 0; 768 } else { 769 /* 770 * Spin with interrupts off on other CPUs while OF has 771 * control of the machine. 772 */ 773 while (rv_args->in_progress) 774 cpu_spinwait(); 775 } 776 } 777 #endif 778 779 static int 780 openfirmware(void *args) 781 { 782 int result; 783 #ifdef SMP 784 struct ofw_rv_args rv_args; 785 #endif 786 787 if (openfirmware_entry == NULL) 788 return (-1); 789 790 #ifdef SMP 791 if (cold) { 792 result = openfirmware_core(args); 793 } else { 794 rv_args.args = args; 795 rv_args.in_progress = 1; 796 smp_rendezvous(smp_no_rendezvous_barrier, 797 ofw_rendezvous_dispatch, smp_no_rendezvous_barrier, 798 &rv_args); 799 result = rv_args.retval; 800 } 801 #else 802 result = openfirmware_core(args); 803 #endif 804 805 return (result); 806 } 807 808 void 809 OF_reboot() 810 { 811 struct { 812 cell_t name; 813 cell_t nargs; 814 cell_t nreturns; 815 cell_t arg; 816 } args; 817 818 args.name = (cell_t)(uintptr_t)"interpret"; 819 args.nargs = 1; 820 args.nreturns = 0; 821 args.arg = (cell_t)(uintptr_t)"reset-all"; 822 openfirmware_core(&args); /* Don't do rendezvous! */ 823 824 for (;;); /* just in case */ 825 } 826 827 #endif /* AIM */ 828 829 void 830 OF_getetheraddr(device_t dev, u_char *addr) 831 { 832 phandle_t node; 833 834 node = ofw_bus_get_node(dev); 835 OF_getprop(node, "local-mac-address", addr, ETHER_ADDR_LEN); 836 } 837 838 /* 839 * Return a bus handle and bus tag that corresponds to the register 840 * numbered regno for the device referenced by the package handle 841 * dev. This function is intended to be used by console drivers in 842 * early boot only. It works by mapping the address of the device's 843 * register in the address space of its parent and recursively walk 844 * the device tree upward this way. 845 */ 846 int 847 OF_decode_addr(phandle_t dev, int regno, bus_space_tag_t *tag, 848 bus_space_handle_t *handle, bus_size_t *sz) 849 { 850 bus_addr_t addr; 851 bus_size_t size; 852 pcell_t pci_hi; 853 int flags, res; 854 855 res = ofw_reg_to_paddr(dev, regno, &addr, &size, &pci_hi); 856 if (res < 0) 857 return (res); 858 859 if (pci_hi == OFW_PADDR_NOT_PCI) { 860 *tag = &bs_be_tag; 861 flags = 0; 862 } else { 863 *tag = &bs_le_tag; 864 flags = (pci_hi & OFW_PCI_PHYS_HI_PREFETCHABLE) ? 865 BUS_SPACE_MAP_PREFETCHABLE: 0; 866 } 867 868 if (sz != NULL) 869 *sz = size; 870 871 return (bus_space_map(*tag, addr, size, flags, handle)); 872 } 873 874