2 * SPDX-License-Identifier: BSD-4-Clause
4 * Copyright (C) 1996 Wolfgang Solfrank.
5 * Copyright (C) 1996 TooLs GmbH.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
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.
33 * $NetBSD: ofw_machdep.c,v 1.5 2000/05/23 13:25:43 tsubai Exp $
36 #include <sys/cdefs.h>
37 __FBSDID("$FreeBSD$");
39 #include "opt_platform.h"
40 #include <sys/param.h>
42 #include <sys/systm.h>
45 #include <sys/fcntl.h>
46 #include <sys/malloc.h>
49 #include <sys/endian.h>
51 #include <net/ethernet.h>
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>
60 #include <vm/vm_param.h>
61 #include <vm/vm_page.h>
62 #include <vm/vm_phys.h>
64 #include <machine/bus.h>
65 #include <machine/cpu.h>
66 #include <machine/md_var.h>
67 #include <machine/platform.h>
68 #include <machine/ofw_machdep.h>
69 #include <machine/trap.h>
71 #include <contrib/libfdt/libfdt.h>
74 #include <powerpc/powernv/opal.h>
81 extern register_t ofmsr[5];
82 extern void *openfirmware_entry;
83 char save_trap_init[0x2f00]; /* EXC_LAST */
84 char save_trap_of[0x2f00]; /* EXC_LAST */
87 static int openfirmware(void *args);
90 ofw_save_trap_vec(char *save_trap_vec)
92 if (!ofw_real_mode || !hw_direct_map)
95 bcopy((void *)PHYS_TO_DMAP(EXC_RST), save_trap_vec, EXC_LAST - EXC_RST);
99 ofw_restore_trap_vec(char *restore_trap_vec)
101 if (!ofw_real_mode || !hw_direct_map)
104 bcopy(restore_trap_vec, (void *)PHYS_TO_DMAP(EXC_RST),
106 __syncicache((void *)PHYS_TO_DMAP(EXC_RSVD), EXC_LAST - EXC_RSVD);
110 * Saved SPRG0-3 from OpenFirmware. Will be restored prior to the callback.
112 register_t ofw_sprg0_save;
115 ofw_sprg_prepare(void)
121 * Assume that interrupt are disabled at this point, or
122 * SPRG1-3 could be trashed
125 __asm __volatile("mtsprg1 %0\n\t"
133 __asm __volatile("mfsprg0 %0\n\t"
138 : "=&r"(ofw_sprg0_save)
147 ofw_sprg_restore(void)
153 * Note that SPRG1-3 contents are irrelevant. They are scratch
154 * registers used in the early portion of trap handling when
155 * interrupts are disabled.
157 * PCPU data cannot be used until this routine is called !
159 #ifndef __powerpc64__
160 __asm __volatile("mtsprg0 %0" :: "r"(ofw_sprg0_save));
166 parse_ofw_memory(phandle_t node, const char *prop, struct mem_region *output)
168 cell_t address_cells, size_cells;
169 cell_t OFmem[4 * PHYS_AVAIL_SZ];
176 * Get #address-cells from root node, defaulting to 1 if it cannot
179 phandle = OF_finddevice("/");
180 if (OF_getencprop(phandle, "#address-cells", &address_cells,
181 sizeof(address_cells)) < (ssize_t)sizeof(address_cells))
183 if (OF_getencprop(phandle, "#size-cells", &size_cells,
184 sizeof(size_cells)) < (ssize_t)sizeof(size_cells))
190 if (node == -1 || (sz = OF_getencprop(node, prop,
191 OFmem, sizeof(OFmem))) <= 0)
192 panic("Physical memory map not found");
196 while (i < sz/sizeof(cell_t)) {
197 output[j].mr_start = OFmem[i++];
198 if (address_cells == 2) {
199 output[j].mr_start <<= 32;
200 output[j].mr_start += OFmem[i++];
203 output[j].mr_size = OFmem[i++];
204 if (size_cells == 2) {
205 output[j].mr_size <<= 32;
206 output[j].mr_size += OFmem[i++];
209 if (output[j].mr_start > BUS_SPACE_MAXADDR)
213 * Constrain memory to that which we can access.
214 * 32-bit AIM can only reference 32 bits of address currently,
215 * but Book-E can access 36 bits.
217 if (((uint64_t)output[j].mr_start +
218 (uint64_t)output[j].mr_size - 1) >
220 output[j].mr_size = BUS_SPACE_MAXADDR -
221 output[j].mr_start + 1;
231 parse_numa_ofw_memory(phandle_t node, const char *prop,
232 struct numa_mem_region *output)
234 cell_t address_cells, size_cells;
235 cell_t OFmem[4 * PHYS_AVAIL_SZ];
242 * Get #address-cells from root node, defaulting to 1 if it cannot
245 phandle = OF_finddevice("/");
246 if (OF_getencprop(phandle, "#address-cells", &address_cells,
247 sizeof(address_cells)) < (ssize_t)sizeof(address_cells))
249 if (OF_getencprop(phandle, "#size-cells", &size_cells,
250 sizeof(size_cells)) < (ssize_t)sizeof(size_cells))
256 if (node == -1 || (sz = OF_getencprop(node, prop,
257 OFmem, sizeof(OFmem))) <= 0)
258 panic("Physical memory map not found");
262 while (i < sz/sizeof(cell_t)) {
263 output[j].mr_start = OFmem[i++];
264 if (address_cells == 2) {
265 output[j].mr_start <<= 32;
266 output[j].mr_start += OFmem[i++];
268 output[j].mr_size = OFmem[i++];
269 if (size_cells == 2) {
270 output[j].mr_size <<= 32;
271 output[j].mr_size += OFmem[i++];
281 excise_reserved_regions(struct mem_region *avail, int asz,
282 struct mem_region *exclude, int esz)
286 for (i = 0; i < asz; i++) {
287 for (j = 0; j < esz; j++) {
289 * Case 1: Exclusion region encloses complete
290 * available entry. Drop it and move on.
292 if (exclude[j].mr_start <= avail[i].mr_start &&
293 exclude[j].mr_start + exclude[j].mr_size >=
294 avail[i].mr_start + avail[i].mr_size) {
295 for (k = i+1; k < asz; k++)
296 avail[k-1] = avail[k];
298 i--; /* Repeat some entries */
303 * Case 2: Exclusion region starts in available entry.
304 * Trim it to where the entry begins and append
305 * a new available entry with the region after
306 * the excluded region, if any.
308 if (exclude[j].mr_start >= avail[i].mr_start &&
309 exclude[j].mr_start < avail[i].mr_start +
311 if (exclude[j].mr_start + exclude[j].mr_size <
312 avail[i].mr_start + avail[i].mr_size) {
313 avail[asz].mr_start =
314 exclude[j].mr_start + exclude[j].mr_size;
315 avail[asz].mr_size = avail[i].mr_start +
321 avail[i].mr_size = exclude[j].mr_start -
326 * Case 3: Exclusion region ends in available entry.
327 * Move start point to where the exclusion zone ends.
328 * The case of a contained exclusion zone has already
329 * been caught in case 2.
331 if (exclude[j].mr_start + exclude[j].mr_size >=
332 avail[i].mr_start && exclude[j].mr_start +
333 exclude[j].mr_size < avail[i].mr_start +
335 avail[i].mr_size += avail[i].mr_start;
337 exclude[j].mr_start + exclude[j].mr_size;
338 avail[i].mr_size -= avail[i].mr_start;
347 excise_initrd_region(struct mem_region *avail, int asz)
352 struct mem_region initrdmap[1];
355 chosen = OF_finddevice("/chosen");
357 size = OF_getencprop(chosen, "linux,initrd-start", cell, sizeof(cell));
363 start = (uint64_t)cell[0] << 32 | cell[1];
365 /* Invalid value length */
366 printf("WARNING: linux,initrd-start must be either 4 or 8 bytes long\n");
370 size = OF_getencprop(chosen, "linux,initrd-end", cell, sizeof(cell));
376 end = (uint64_t)cell[0] << 32 | cell[1];
378 /* Invalid value length */
379 printf("WARNING: linux,initrd-end must be either 4 or 8 bytes long\n");
386 initrdmap[0].mr_start = start;
387 initrdmap[0].mr_size = end - start;
389 asz = excise_reserved_regions(avail, asz, initrdmap, 1);
396 excise_msi_region(struct mem_region *avail, int asz)
399 struct mem_region initrdmap[1];
402 * This range of physical addresses is used to implement optimized
403 * 32 bit MSI interrupts on POWER9. Exclude it to avoid accidentally
404 * using it for DMA, as this will cause an immediate PHB fence.
405 * While we could theoretically turn off this behavior in the ETU,
406 * doing so would break 32-bit MSI, so just reserve the range in
407 * the physical map instead.
408 * See section 4.4.2.8 of the PHB4 specification.
410 start = 0x00000000ffff0000ul;
411 end = 0x00000000fffffffful;
413 initrdmap[0].mr_start = start;
414 initrdmap[0].mr_size = end - start;
416 asz = excise_reserved_regions(avail, asz, initrdmap, 1);
423 excise_fdt_reserved(struct mem_region *avail, int asz)
425 struct mem_region fdtmap[32];
430 chosen = OF_finddevice("/chosen");
431 fdtmapsize = OF_getprop(chosen, "fdtmemreserv", fdtmap, sizeof(fdtmap));
433 for (j = 0; j < fdtmapsize/sizeof(fdtmap[0]); j++) {
434 fdtmap[j].mr_start = be64toh(fdtmap[j].mr_start) & ~PAGE_MASK;
435 fdtmap[j].mr_size = round_page(be64toh(fdtmap[j].mr_size));
438 KASSERT(j*sizeof(fdtmap[0]) < sizeof(fdtmap),
439 ("Exceeded number of FDT reservations"));
440 /* Add a virtual entry for the FDT itself */
442 fdtmap[j].mr_start = (vm_offset_t)fdt & ~PAGE_MASK;
443 fdtmap[j].mr_size = round_page(fdt_totalsize(fdt));
444 fdtmapsize += sizeof(fdtmap[0]);
447 fdtentries = fdtmapsize/sizeof(fdtmap[0]);
448 asz = excise_reserved_regions(avail, asz, fdtmap, fdtentries);
455 * This is called during powerpc_init, before the system is really initialized.
456 * It shall provide the total and the available regions of RAM.
457 * The available regions need not take the kernel into account.
460 ofw_numa_mem_regions(struct numa_mem_region *memp, int *memsz)
465 cell_t associativity[5];
466 struct numa_mem_region *curmemp;
470 * Get memory from all the /memory nodes.
472 for (phandle = OF_child(OF_peer(0)); phandle != 0;
473 phandle = OF_peer(phandle)) {
474 if (OF_getprop(phandle, "name", name, sizeof(name)) <= 0)
476 if (strncmp(name, "memory@", strlen("memory@")) != 0)
479 count = parse_numa_ofw_memory(phandle, "reg", &memp[msz]);
482 curmemp = &memp[msz];
483 res = OF_getproplen(phandle, "ibm,associativity");
487 OF_getencprop(phandle, "ibm,associativity",
489 curmemp->mr_domain = associativity[3] - 1;
491 printf("%s %#jx-%#jx domain(%ju)\n",
492 name, (uintmax_t)curmemp->mr_start,
493 (uintmax_t)curmemp->mr_start + curmemp->mr_size,
494 (uintmax_t)curmemp->mr_domain);
500 * This is called during powerpc_init, before the system is really initialized.
501 * It shall provide the total and the available regions of RAM.
502 * The available regions need not take the kernel into account.
505 ofw_mem_regions(struct mem_region *memp, int *memsz,
506 struct mem_region *availp, int *availsz)
516 * Get memory from all the /memory nodes.
518 for (phandle = OF_child(OF_peer(0)); phandle != 0;
519 phandle = OF_peer(phandle)) {
520 if (OF_getprop(phandle, "name", name, sizeof(name)) <= 0)
522 if (strncmp(name, "memory", sizeof(name)) != 0 &&
523 strncmp(name, "memory@", strlen("memory@")) != 0)
526 res = parse_ofw_memory(phandle, "reg", &memp[msz]);
530 * On POWER9 Systems we might have both linux,usable-memory and
531 * reg properties. 'reg' denotes all available memory, but we
532 * must use 'linux,usable-memory', a subset, as some memory
533 * regions are reserved for NVLink.
535 if (OF_getproplen(phandle, "linux,usable-memory") >= 0)
536 res = parse_ofw_memory(phandle, "linux,usable-memory",
538 else if (OF_getproplen(phandle, "available") >= 0)
539 res = parse_ofw_memory(phandle, "available",
542 res = parse_ofw_memory(phandle, "reg", &availp[asz]);
547 phandle = OF_finddevice("/chosen");
548 if (OF_hasprop(phandle, "fdtmemreserv"))
549 asz = excise_fdt_reserved(availp, asz);
551 /* If the kernel is being loaded through kexec, initrd region is listed
552 * in /chosen but the region is not marked as reserved, so, we might exclude
555 if (OF_hasprop(phandle, "linux,initrd-start"))
556 asz = excise_initrd_region(availp, asz);
560 if (opal_check() == 0)
561 asz = excise_msi_region(availp, asz);
569 OF_initial_setup(void *fdt_ptr, void *junk, int (*openfirm)(void *))
576 __asm __volatile("mfsprg0 %0" : "=&r"(ofmsr[1]));
578 __asm __volatile("mfsprg1 %0" : "=&r"(ofmsr[2]));
579 __asm __volatile("mfsprg2 %0" : "=&r"(ofmsr[3]));
580 __asm __volatile("mfsprg3 %0" : "=&r"(ofmsr[4]));
581 openfirmware_entry = openfirm;
583 if (ofmsr[0] & PSL_DR)
588 ofw_save_trap_vec(save_trap_init);
599 boolean_t status = FALSE;
603 if (openfirmware_entry != NULL) {
605 status = OF_install(OFW_STD_REAL, 0);
608 status = OF_install(OFW_STD_32BIT, 0);
610 status = OF_install(OFW_STD_DIRECT, 0);
617 err = OF_init(openfirmware);
623 bus_space_tag_t fdt_bt;
624 vm_offset_t tmp_fdt_ptr;
629 status = OF_install(OFW_FDT, 0);
633 #ifdef AIM /* AIM-only for now -- Book-E does this remapping in early init */
634 /* Get the FDT size for mapping if we can */
635 tmp_fdt_ptr = pmap_early_io_map((vm_paddr_t)fdt, PAGE_SIZE);
636 if (fdt_check_header((void *)tmp_fdt_ptr) != 0) {
637 pmap_early_io_unmap(tmp_fdt_ptr, PAGE_SIZE);
640 fdt_size = fdt_totalsize((void *)tmp_fdt_ptr);
641 pmap_early_io_unmap(tmp_fdt_ptr, PAGE_SIZE);
644 * Map this for real. Use bus_space_map() to take advantage
645 * of its auto-remapping function once the kernel is loaded.
646 * This is a dirty hack, but what we have.
648 #ifdef _LITTLE_ENDIAN
653 bus_space_map(fdt_bt, (vm_paddr_t)fdt, fdt_size, 0, &fdt_va);
655 err = OF_init((void *)fdt_va);
662 #ifdef FDT_DTB_STATIC
664 * Check for a statically included blob already in the kernel and
665 * needing no mapping.
668 status = OF_install(OFW_FDT, 0);
671 err = OF_init(&fdt_static_dtb);
693 KASSERT(!pmap_bootstrapped, ("Cannot call ofw_quiesce after VM is up"));
695 args.name = (cell_t)(uintptr_t)"quiesce";
702 openfirmware_core(void *args)
707 if (openfirmware_entry == NULL)
711 * Turn off exceptions - we really don't want to end up
712 * anywhere unexpected with PCPU set to something strange
713 * or the stack pointer wrong.
715 oldmsr = intr_disable();
719 /* Save trap vectors */
720 ofw_save_trap_vec(save_trap_of);
722 /* Restore initially saved trap vectors */
723 ofw_restore_trap_vec(save_trap_init);
725 #ifndef __powerpc64__
727 * Clear battable[] translations
729 if (!(cpu_features & PPC_FEATURE_64))
730 __asm __volatile("mtdbatu 2, %0\n"
731 "mtdbatu 3, %0" : : "r" (0));
735 result = ofwcall(args);
737 /* Restore trap vecotrs */
738 ofw_restore_trap_vec(save_trap_of);
742 intr_restore(oldmsr);
751 volatile int in_progress;
755 ofw_rendezvous_dispatch(void *xargs)
757 struct ofw_rv_args *rv_args = xargs;
759 /* NOTE: Interrupts are disabled here */
761 if (PCPU_GET(cpuid) == 0) {
763 * Execute all OF calls on CPU 0
765 rv_args->retval = openfirmware_core(rv_args->args);
766 rv_args->in_progress = 0;
769 * Spin with interrupts off on other CPUs while OF has
770 * control of the machine.
772 while (rv_args->in_progress)
779 openfirmware(void *args)
783 struct ofw_rv_args rv_args;
786 if (openfirmware_entry == NULL)
791 result = openfirmware_core(args);
794 rv_args.in_progress = 1;
795 smp_rendezvous(smp_no_rendezvous_barrier,
796 ofw_rendezvous_dispatch, smp_no_rendezvous_barrier,
798 result = rv_args.retval;
801 result = openfirmware_core(args);
817 args.name = (cell_t)(uintptr_t)"interpret";
820 args.arg = (cell_t)(uintptr_t)"reset-all";
821 openfirmware_core(&args); /* Don't do rendezvous! */
823 for (;;); /* just in case */
829 OF_getetheraddr(device_t dev, u_char *addr)
833 node = ofw_bus_get_node(dev);
834 OF_getprop(node, "local-mac-address", addr, ETHER_ADDR_LEN);
838 * Return a bus handle and bus tag that corresponds to the register
839 * numbered regno for the device referenced by the package handle
840 * dev. This function is intended to be used by console drivers in
841 * early boot only. It works by mapping the address of the device's
842 * register in the address space of its parent and recursively walk
843 * the device tree upward this way.
846 OF_decode_addr(phandle_t dev, int regno, bus_space_tag_t *tag,
847 bus_space_handle_t *handle, bus_size_t *sz)
854 res = ofw_reg_to_paddr(dev, regno, &addr, &size, &pci_hi);
858 if (pci_hi == OFW_PADDR_NOT_PCI) {
863 flags = (pci_hi & OFW_PCI_PHYS_HI_PREFETCHABLE) ?
864 BUS_SPACE_MAP_PREFETCHABLE: 0;
870 return (bus_space_map(*tag, addr, size, flags, handle));