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