 @@ -1,503 +1,513 @@
-/*	$NetBSD: machdep.c,v 1.169 2019/01/28 02:25:01 sevan Exp $	*/
+/*	$NetBSD: machdep.c,v 1.170 2020/07/07 02:33:54 rin Exp $	*/
 /*
  * Copyright (C) 1995, 1996 Wolfgang Solfrank.
  * Copyright (C) 1995, 1996 TooLs GmbH.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by TooLs GmbH.
  * 4. The name of TooLs GmbH may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.169 2019/01/28 02:25:01 sevan Exp $");
+__KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.170 2020/07/07 02:33:54 rin Exp $");
 #include "opt_compat_netbsd.h"
 #include "opt_ddb.h"
 #include "opt_kgdb.h"
 #include "opt_altivec.h"
 #include "opt_multiprocessor.h"
 #include "adb.h"
 #include "zsc.h"
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/boot_flag.h>
 #include <sys/bus.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/exec.h>
 #include <sys/kernel.h>
 #include <sys/ksyms.h>
 #include <sys/mbuf.h>
 #include <sys/mount.h>
 #include <sys/msgbuf.h>
 #include <sys/proc.h>
 #include <sys/reboot.h>
 #include <sys/syscallargs.h>
 #include <sys/syslog.h>
 #include <sys/systm.h>
 #ifdef DDB
 #include <powerpc/db_machdep.h>
 #include <ddb/db_extern.h>
 #endif
 #ifdef KGDB
 #include <sys/kgdb.h>
 #endif
 #include <dev/ofw/openfirm.h>
 #include <dev/wsfb/genfbvar.h>
 #include <machine/autoconf.h>
 #include <machine/powerpc.h>
 #include <powerpc/trap.h>
 #include <powerpc/fpu.h>
 #include <powerpc/oea/bat.h>
 #include <powerpc/spr.h>
 #ifdef ALTIVEC
 #include <powerpc/altivec.h>
 #endif
 #include <powerpc/ofw_cons.h>
 #include <powerpc/pic/picvar.h>
 #ifdef MULTIPROCESSOR
 #include <powerpc/pic/ipivar.h>
 #endif
 #include <macppc/dev/adbvar.h>
 #include <macppc/dev/pmuvar.h>
 #include <macppc/dev/cudavar.h>
 #include <macppc/dev/smuvar.h>
 #include <macppc/macppc/static_edid.h>
 #include "ksyms.h"
 #include "pmu.h"
 #include "cuda.h"
 #include "smu.h"
 struct genfb_colormap_callback gfb_cb;
 struct genfb_parameter_callback gpc_backlight, gpc_brightness;
 /*
  * OpenFirmware gives us no way to check the brightness level or the backlight
  * state so we assume the backlight is on and about 4/5 up which seems
  * reasonable for most laptops
  */
 int backlight_state = 1;
 int brightness_level = 200;
 static void of_set_palette(void *, int, int, int, int);
 static void add_model_specifics(prop_dictionary_t);
 static int of_get_backlight(void *, int *);
 static int of_set_backlight(void *, int);
 static int of_get_brightness(void *, int *);
 static int of_set_brightness(void *, int);
 static int of_upd_brightness(void *, int);
 void
 initppc(u_int startkernel, u_int endkernel, char *args)
+{
 	ofwoea_initppc(startkernel, endkernel, args);
+}
 /* perform model-specific actions at initppc() */
 void
 model_init(void)
+{
+}
 void
 consinit(void)
+{
 	ofwoea_consinit();
+}
 /*
  * Machine dependent startup code.
  */
 void
 cpu_startup(void)
+{
 	oea_startup(NULL);
+}
 /*
  * Crash dump handling.
  */
 void
 dumpsys(void)
+{
 	printf("dumpsys: TBD\n");
+}
 /*
  * Halt or reboot the machine after syncing/dumping according to howto.
  */
 void
 cpu_reboot(int howto, char *what)
+{
 	static int syncing;
 	static char str[256];
 	char *ap = str, *ap1 = ap;
 	/*
 	 * Enable external interrupts in case someone is rebooting
 	 * from a strange context via ddb.
 	 */
 	mtmsr(mfmsr() | PSL_EE);
 	boothowto = howto;
 	if (!cold && !(howto & RB_NOSYNC) && !syncing) {
 		syncing = 1;
 		vfs_shutdown();		/* sync */
 		resettodr();		/* set wall clock */
+	}
 #ifdef MULTIPROCESSOR
 	/* Halt other CPU */
 	cpu_send_ipi(IPI_DST_NOTME, IPI_HALT);
 	delay(100000);	/* XXX */
 #endif
 	splhigh();
 	if (!cold && (howto & RB_DUMP))
 		dumpsys();
 	doshutdownhooks();
 	pmf_system_shutdown(boothowto);
 	if ((howto & RB_POWERDOWN) == RB_POWERDOWN) {
 		delay(1000000);
 #if NCUDA > 0
 		cuda_poweroff();
 #endif
 #if NPMU > 0
 		pmu_poweroff();
 #endif
 #if NADB > 0
 		adb_poweroff();
 		printf("WARNING: powerdown failed!\n");
 #endif
 #if NSMU > 0
 		smu_poweroff();
 #endif
+	}
 	if (howto & RB_HALT) {
 		printf("halted\n\n");
 		/* flush cache for msgbuf */
 		__syncicache((void *)msgbuf_paddr, round_page(MSGBUFSIZE));
 		ppc_exit();
+	}
 	printf("rebooting\n\n");
 	if (what && *what) {
 		if (strlen(what) > sizeof str - 5)
 			printf("boot string too large, ignored\n");
 		else {
 			strcpy(str, what);
 			ap1 = ap = str + strlen(str);
 			*ap++ = ' ';
+		}
+	}
 	*ap++ = '-';
 	if (howto & RB_SINGLE)
 		*ap++ = 's';
 	if (howto & RB_KDB)
 		*ap++ = 'd';
 	*ap++ = 0;
 	if (ap[-2] == '-')
 		*ap1 = 0;
 	/* flush cache for msgbuf */
 	__syncicache((void *)msgbuf_paddr, round_page(MSGBUFSIZE));
 #if NCUDA > 0
 	cuda_restart();
 #endif
 #if NPMU > 0
 	pmu_restart();
 #endif
 #if NADB > 0
 	adb_restart();	/* not return */
 #endif
 #if NSMU > 0
 	smu_restart();
 #endif
 	ppc_exit();
+}
 #if 0
 /*
  * OpenFirmware callback routine
  */
 void
 callback(void *p)
+{
 	panic("callback");	/* for now			XXX */
+}
 #endif
 void
 copy_disp_props(device_t dev, int node, prop_dictionary_t dict)
+{
 	char name[32];
 	uint32_t temp;
 	uint64_t cmap_cb, backlight_cb, brightness_cb;
 	int have_backlight = 0;
 #ifdef PMAC_G5
 	int have_palette = 0;
 #else
 	int have_palette = 1;
 #endif
 	if (node != console_node) {
 		/*
 		 * see if any child matches since OF attaches nodes for
 		 * each head and /chosen/stdout points to the head
 		 * rather than the device itself in this case
 		 */
 		int sub;
 		sub = OF_child(node);
 		while ((sub != 0) && (sub != console_node)) {
 			sub = OF_peer(sub);
+		}
 		if (sub != console_node)
 			return;
 		node = sub;
+	}
 	prop_dictionary_set_bool(dict, "is_console", 1);
 	if (!of_to_uint32_prop(dict, node, "width", "width")) {
 		OF_interpret("screen-width", 0, 1, &temp);
 		prop_dictionary_set_uint32(dict, "width", temp);
+	}
 	if (!of_to_uint32_prop(dict, node, "height", "height")) {
 		OF_interpret("screen-height", 0, 1, &temp);
 		prop_dictionary_set_uint32(dict, "height", temp);
+	}
 	of_to_uint32_prop(dict, node, "linebytes", "linebytes");
 	if (!of_to_uint32_prop(dict, node, "depth", "depth")) {
 		/*
 		 * XXX we should check linebytes vs. width but those
 		 * FBs that don't have a depth property ( /chaos/control... )
 		 * won't have linebytes either
 		 */
 		prop_dictionary_set_uint32(dict, "depth", 8);
+	}
 	if (!of_to_uint32_prop(dict, node, "address", "address")) {
 		uint32_t fbaddr = 0;
 			OF_interpret("frame-buffer-adr", 0, 1, &fbaddr);
 		if (fbaddr != 0)
 			prop_dictionary_set_uint32(dict, "address", fbaddr);
+	}
 	if (of_to_dataprop(dict, node, "EDID", "EDID")) {
 		aprint_debug("found EDID property...\n");
 	} else if (of_to_dataprop(dict, node, "EDID,A", "EDID")) {
 		aprint_debug("found EDID,A\n");
 	} else if (of_to_dataprop(dict, node, "EDID,B", "EDID")) {
 		memset(name, 0, sizeof(name));
 		OF_getprop(node, "name", name, sizeof(name));
 		if (strcmp(name, "NVDA,NVMac") == 0) {
 			aprint_debug("found EDID,B on nvidia - assuming digital output\n");
 			prop_dictionary_set_bool(dict, "no_palette_control", 1);
 			have_palette = 0;
+		}
+	}
 	add_model_specifics(dict);
 	temp = 0;
 	if (OF_getprop(node, "ATY,RefCLK", &temp, sizeof(temp)) != 4) {
 		OF_getprop(OF_parent(node), "ATY,RefCLK", &temp,
 		    sizeof(temp));
+	}
 	if (temp != 0)
 		prop_dictionary_set_uint32(dict, "refclk", temp / 10);
 	if (have_palette && ofw_quiesce) {
 		aprint_debug(
 		    "OFW has been quiesced - disabling palette callback\n");
 		have_palette = 0;
+	}
 	if (have_palette) {
 		gfb_cb.gcc_cookie = (void *)console_instance;
 		gfb_cb.gcc_set_mapreg = of_set_palette;
 		cmap_cb = (uint64_t)(uintptr_t)&gfb_cb;
 		prop_dictionary_set_uint64(dict, "cmap_callback", cmap_cb);
+	}
 	/* now let's look for backlight control */
 	have_backlight = 0;
 	if (OF_getprop(node, "backlight-control", &temp, sizeof(temp)) == 4) {
 		have_backlight = 1;
 	} else if (OF_getprop(OF_parent(node), "backlight-control", &temp,
 		    sizeof(temp)) == 4) {
 		have_backlight = 1;
+	}
 	if (have_backlight && ofw_quiesce) {
 		aprint_debug(
 		    "OFW has been quiesced - disabling backlight callbacks\n");
 		have_palette = 0;
+	}
 	if (have_backlight) {
 		gpc_backlight.gpc_cookie = (void *)console_instance;
 		gpc_backlight.gpc_set_parameter = of_set_backlight;
 		gpc_backlight.gpc_get_parameter = of_get_backlight;
 		gpc_backlight.gpc_upd_parameter = NULL;
 		backlight_cb = (uint64_t)(uintptr_t)&gpc_backlight;
 		prop_dictionary_set_uint64(dict, "backlight_callback",
 		    backlight_cb);
 		gpc_brightness.gpc_cookie = (void *)console_instance;
 		gpc_brightness.gpc_set_parameter = of_set_brightness;
 		gpc_brightness.gpc_get_parameter = of_get_brightness;
 		gpc_brightness.gpc_upd_parameter = of_upd_brightness;
 		brightness_cb = (uint64_t)(uintptr_t)&gpc_brightness;
 		prop_dictionary_set_uint64(dict, "brightness_callback",
 		    brightness_cb);
+	}
+}
 static void
 add_model_specifics(prop_dictionary_t dict)
+{
 	const char *bl_rev_models[] = {
 		"PowerBook4,3", "PowerBook6,3", "PowerBook6,5", NULL};
 	const char *clamshell[] = {
 		"PowerBook2,1", "PowerBook2,2", NULL};
 	const char *pismo[] = {
 		"PowerBook3,1", NULL};
 	const char *mini1[] = {
 		"PowerMac10,1", NULL};
 	const char *mini2[] = {
 		"PowerMac10,2", NULL};
 	int node;
 	node = OF_finddevice("/");
 	if (of_compatible(node, bl_rev_models) != -1) {
 		prop_dictionary_set_bool(dict, "backlight_level_reverted", 1);
+	}
 	if (of_compatible(node, clamshell) != -1) {
 		prop_data_t edid;
 		edid = prop_data_create_data(edid_clamshell, sizeof(edid_clamshell));
 		prop_dictionary_set(dict, "EDID", edid);
 		prop_object_release(edid);
+	}
 	if (of_compatible(node, pismo) != -1) {
 		prop_data_t edid;
 		edid = prop_data_create_data(edid_pismo, sizeof(edid_pismo));
 		prop_dictionary_set(dict, "EDID", edid);
 		prop_object_release(edid);
+	}
 	if (of_compatible(node, mini1) != -1) {
 		prop_dictionary_set_bool(dict, "dvi-internal", 1);
+	}
 	if (of_compatible(node, mini2) != -1) {
 		prop_dictionary_set_bool(dict, "dvi-external", 1);
+	}
+}
 static void
 of_set_palette(void *cookie, int index, int r, int g, int b)
+{
 	int ih = (int)cookie;
 	OF_call_method_1("color!", ih, 4, r, g, b, index);
+}
 static int
 of_get_backlight(void *cookie, int *state)
+{
 	if (backlight_state < 0)
 		return ENODEV;
 	*state = backlight_state;
 	return 0;
+}
 static int
 of_set_backlight(void *cookie, int state)
+{
 	int ih = (int)cookie;
 	KASSERT(state >= 0 && state <= 1);
 	backlight_state = state;
 	if (state)
 		OF_call_method_1("backlight-on", ih, 0);
 	else
 		OF_call_method_1("backlight-off", ih, 0);
 	return 0;	/* XXX or use return value of OF_call_method_1? */
+}
 static int
 of_get_brightness(void *cookie, int *level)
+{
 	/*
 	 * We don't know how to read the brightness level from OF alone - we
 	 * should read the value from the PMU.  Here, we just return whatever
 	 * we set last (if any).
 	 */
 	if (brightness_level < 0)
 		return ENODEV;
 	*level = brightness_level;
 	return 0;
+}
 static int
 of_set_brightness(void *cookie, int level)
+{
 	int ih = (int)cookie;
 	KASSERT(level >= 0 && level <= 255);
 	brightness_level = level;
 	OF_call_method_1("set-contrast", ih, 1, brightness_level);
 	return 0;	/* XXX or use return value of OF_call_method_1? */
+}
 static int
 of_upd_brightness(void *cookie, int delta)
+{
 	int ih = (int)cookie;
 	if (brightness_level < 0)
 		return ENODEV;
 	brightness_level += delta;
 	if (brightness_level < 0) brightness_level = 0;
 	if (brightness_level > 255) brightness_level = 255;
 	OF_call_method_1("set-contrast", ih, 1, brightness_level);
 	return 0;	/* XXX or use return value of OF_call_method_1? */
+}

 @@ -1,297 +1,309 @@
-/*	$NetBSD: ofw_rascons.c,v 1.15 2020/07/07 02:10:20 rin Exp $	*/
+/*	$NetBSD: ofw_rascons.c,v 1.16 2020/07/07 02:33:54 rin Exp $	*/
 /*
  * Copyright (c) 1995, 1996 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Chris G. Demetriou
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
+ *
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
  * Carnegie Mellon requests users of this software to return to
+ *
  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ofw_rascons.c,v 1.15 2020/07/07 02:10:20 rin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ofw_rascons.c,v 1.16 2020/07/07 02:33:54 rin Exp $");
 #include "wsdisplay.h"
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/bus.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/ioctl.h>
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <dev/ofw/openfirm.h>
 #include <uvm/uvm_extern.h>
 #include <machine/autoconf.h>
 #include <dev/wscons/wsconsio.h>
 #include <dev/wscons/wsdisplayvar.h>
 #include <dev/rasops/rasops.h>
 #include <dev/wscons/wsdisplay_vconsvar.h>
 #include <dev/wsfont/wsfont.h>
 #include <powerpc/oea/bat.h>
 #include <powerpc/oea/cpufeat.h>
 #include <powerpc/oea/ofw_rasconsvar.h>
 /* we need a wsdisplay to do anything halfway useful */
 #if NWSDISPLAY > 0
 static int copy_rom_font(void);
 static struct wsdisplay_font openfirm6x11;
 static vaddr_t fbaddr;
 static int romfont_loaded = 0;
 static int needs_finalize = 0;
 #define FONTBUFSIZE (2048)	/* enough for 96 6x11 bitmap characters */
 static uint8_t fontbuf[FONTBUFSIZE];
 struct vcons_screen rascons_console_screen;
 struct wsscreen_descr rascons_stdscreen = {
 	"std",
 , 0,	/* will be filled in -- XXX shouldn't, it's global */
 ,
 , 0,
 	WSSCREEN_REVERSE
 };
 int
 rascons_cnattach(void)
+{
 	struct rasops_info *ri = &rascons_console_screen.scr_ri;
 	long defattr;
 	int crow = 0;
 	/* get current cursor position */
 	OF_interpret("line#", 0, 1, &crow);
 	if (crow < 0)
 		crow = 0;
 	/* move (rom monitor) cursor to the lowest line - 1 */
 	/* XXXX - Why? */
 #if 0
 	OF_interpret("#lines 2 - to line#", 0, 0);
 #endif
 	wsfont_init();
 	if (copy_rom_font() == 0) {
 #if !defined(OFWOEA_WSCONS_NO_ROM_FONT)
 		romfont_loaded = 1;
 #endif /* !OFWOEA_WSCONS_NO_ROM_FONT */
+	}
 	/* set up rasops */
 	rascons_init_rasops(console_node, ri);
 	/*
 	 * no need to clear the screen here when we're mimicing firmware
 	 * output anyway
 	 */
 #if 0
 	if (ri->ri_width >= 1024 && ri->ri_height >= 768) {
 		int i, screenbytes = ri->ri_stride * ri->ri_height;
 		for (i = 0; i < screenbytes; i += sizeof(u_int32_t))
 			*(u_int32_t *)(fbaddr + i) = 0xffffffff;
 		crow = 0;
+	}
 #endif
 	rascons_stdscreen.nrows = ri->ri_rows;
 	rascons_stdscreen.ncols = ri->ri_cols;
 	rascons_stdscreen.textops = &ri->ri_ops;
 	rascons_stdscreen.capabilities = ri->ri_caps;
 	/*
 	 * XXX
 	 * On some G5 models ( so far, 970FX but not 970MP ) we can't seem to
 	 * access video memory in real mode, but a lot of code relies on rasops
 	 * data structures being set up early so we can't just push the whole
 	 * thing further down. Instead set things up but don't actually attach
 	 * the console until later.
 	 * This needs a better trigger but for now I can't reliably tell which
 	 * exact models / CPUs / other hardware actually need it.
 	 */
 	if ((oeacpufeat & OEACPU_64_BRIDGE) != 0) {
 		needs_finalize = 1;
 	} else {
 		ri->ri_ops.allocattr(ri, 0, 0, 0, &defattr);
 		wsdisplay_preattach(&rascons_stdscreen, ri, 0, uimax(0,
 		    uimin(crow, ri->ri_rows - 1)), defattr);
+	}
 #if notyet
 	rascons_init_cmap(NULL);
 #endif
 	return 0;
+}
 void
 rascons_add_rom_font(void)
+{
 	wsfont_init();
 	if (romfont_loaded) {
 		wsfont_add(&openfirm6x11, 0);
+	}
+}
 void
 rascons_finalize(void)
+{
 	struct rasops_info *ri = &rascons_console_screen.scr_ri;
 	long defattr;
 	int crow = 0;
 	if (needs_finalize == 0) return;
 	/* get current cursor position */
 	if (romfont_loaded) {
 		OF_interpret("line#", 0, 1, &crow);
 		if (crow < 0)
 			crow = 0;
+	}
 	ri->ri_ops.allocattr(ri, 0, 0, 0, &defattr);
 	wsdisplay_preattach(&rascons_stdscreen, ri, 0, uimax(0,
 		    uimin(crow, ri->ri_rows - 1)), defattr);
+}
 static int
 copy_rom_font(void)
+{
 	u_char *romfont;
 	int char_width, char_height, stride;
 	int chosen, mmu, m, e, size;
 	/*
 	 * Get ROM FONT address.
+	 *
 	 * For some machines like ``PowerMac11,2'', Open Firmware does not
 	 * initialize console-related variables when auto-boot? is true;
 	 * -1 is returned instead of correct value. Fall back to wsfont
 	 * embedded in kernel in this case.
 	 */
 	OF_interpret("font-adr", 0, 1, &romfont);
 	if (romfont == NULL || romfont == (u_char *)-1)
 		return -1;
 	chosen = OF_finddevice("/chosen");
 	OF_getprop(chosen, "mmu", &mmu, 4);
 	/*
 	 * Convert to physcal address.  We cannot access to Open Firmware's
 	 * virtual address space.
 	 */
 	OF_call_method("translate", mmu, 1, 3, romfont, &romfont, &m, &e);
 	/* Get character size */
 	OF_interpret("char-width", 0, 1, &char_width);
 	OF_interpret("char-height", 0, 1, &char_height);
 	stride = (char_width + 7) >> 3;
 	size = stride * char_height * 96;
 	if (size > FONTBUFSIZE) return -1;
 	memcpy(fontbuf, romfont, size);
 	openfirm6x11.name = "Open Firmware";
 	openfirm6x11.firstchar = 32;
 	openfirm6x11.numchars = 96;
 	openfirm6x11.encoding = WSDISPLAY_FONTENC_ISO;
 	openfirm6x11.fontwidth = char_width;
 	openfirm6x11.fontheight = char_height;
 	openfirm6x11.stride = stride;
 	openfirm6x11.bitorder = WSDISPLAY_FONTORDER_L2R;
 	openfirm6x11.byteorder = WSDISPLAY_FONTORDER_L2R;
 	openfirm6x11.data = fontbuf;
 	return 0;
+}
 int
 rascons_init_rasops(int node, struct rasops_info *ri)
+{
 	int32_t width, height, linebytes, depth;
 	/* XXX /chaos/control doesn't have "width", "height", ... */
 	width = height = -1;
 	if (OF_getprop(node, "width", &width, 4) != 4)
 		OF_interpret("screen-width", 0, 1, &width);
 	if (OF_getprop(node, "height", &height, 4) != 4)
 		OF_interpret("screen-height", 0, 1, &height);
 	if (OF_getprop(node, "linebytes", &linebytes, 4) != 4)
 		linebytes = width;			/* XXX */
 	if (OF_getprop(node, "depth", &depth, 4) != 4)
 		depth = 8;				/* XXX */
 	if (OF_getprop(node, "address", &fbaddr, 4) != 4)
 		OF_interpret("frame-buffer-adr", 0, 1, &fbaddr);
 	if (width == -1 || height == -1 || fbaddr == 0 || fbaddr == -1)
 		return false;
 	/* initialize rasops */
 	ri->ri_width = width;
 	ri->ri_height = height;
 	ri->ri_depth = depth;
 	ri->ri_stride = linebytes;
 	ri->ri_bits = (char *)fbaddr;
 	ri->ri_flg = RI_CENTER | RI_FULLCLEAR | RI_NO_AUTO;
 	/* mimic firmware output if we can find the ROM font */
 	if (romfont_loaded) {
 		int cols = 0, rows = 0;
 		/*
 		 * XXX this assumes we're the console which may or may not
 		 * be the case
 		 */
 		OF_interpret("#lines", 0, 1, &rows);
 		OF_interpret("#columns", 0, 1, &cols);
 		ri->ri_font = &openfirm6x11;
 		ri->ri_wsfcookie = -1;		/* not using wsfont */
 		rasops_init(ri, rows, cols);
 #ifdef RASCONS_DEBUG
 		char buffer[128];
 		snprintf(buffer, 128, "bits %08x c %d w %d -> %d %d\n",
 		    (uint32_t)ri->ri_bits, cols, width, ri->ri_xorigin, ri->ri_yorigin);
 		OF_write(console_instance, buffer, strlen(buffer));
 #endif
 	} else {
 		/* use as much of the screen as the font permits */
 		rasops_init(ri, height/8, width/8);
 		ri->ri_caps = WSSCREEN_WSCOLORS;
 		rasops_reconfig(ri, height / ri->ri_font->fontheight,
 		    width / ri->ri_font->fontwidth);
+	}
 	if (depth == 8 && ofw_quiesce) {
 		/*
 		 * Open Firmware will be quiesced. This is last chance to
 		 * set color palette via ``color!'' method.
 		 */
 		for (int i = 0; i < 256; i++) {
 			OF_call_method_1("color!", console_instance, 4,
 			    rasops_cmap[3 * i], rasops_cmap[3 * i + 1],
 			    rasops_cmap[3 * i + 2], i);
+		}
+	}
 	return true;
+}
 #else	/* NWSDISPLAY > 0 */
 int
 rascons_cnattach(void)
+{
 	return -1;
+}
 #endif

 @@ -1,860 +1,865 @@
-/* $NetBSD: ofwoea_machdep.c,v 1.49 2020/07/06 10:59:37 rin Exp $ */
+/* $NetBSD: ofwoea_machdep.c,v 1.50 2020/07/07 02:33:54 rin Exp $ */
 /*-
  * Copyright (c) 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Tim Rightnour
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ofwoea_machdep.c,v 1.49 2020/07/06 10:59:37 rin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ofwoea_machdep.c,v 1.50 2020/07/07 02:33:54 rin Exp $");
 #include "ksyms.h"
 #include "wsdisplay.h"
 #ifdef _KERNEL_OPT
 #include "opt_ddb.h"
 #include "opt_kgdb.h"
 #include "opt_modular.h"
 #include "opt_multiprocessor.h"
 #include "opt_oea.h"
 #include "opt_ofwoea.h"
 #include "opt_ppcarch.h"
 #endif
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/boot_flag.h>
 #include <sys/extent.h>
 #include <sys/kernel.h>
 #include <sys/ksyms.h>
 #include <uvm/uvm_extern.h>
 #include <dev/ofw/openfirm.h>
 #include <dev/wscons/wsconsio.h>
 #include <dev/wscons/wsdisplayvar.h>
 #include <dev/rasops/rasops.h>
 #include <dev/wscons/wsdisplay_vconsvar.h>
 #include <machine/pmap.h>
 #include <machine/powerpc.h>
 #include <machine/trap.h>
 #include <machine/vmparam.h>
 #include <machine/autoconf.h>
 #include <sys/bus.h>
 #include <powerpc/oea/bat.h>
 #include <powerpc/oea/ofw_rasconsvar.h>
 #include <powerpc/oea/cpufeat.h>
 #include <powerpc/include/oea/spr.h>
 #include <powerpc/ofw_cons.h>
 #include <powerpc/spr.h>
 #include <powerpc/pic/picvar.h>
 #ifdef DDB
 #include <machine/db_machdep.h>
 #include <ddb/db_extern.h>
 #endif
 #ifdef KGDB
 #include <sys/kgdb.h>
 #endif
 #ifdef ofppc
 extern struct model_data modeldata;
 #endif
 #ifdef OFWOEA_DEBUG
 #define DPRINTF printf
 #else
 #define DPRINTF while (0) printf
 #endif
 typedef struct _rangemap {
 	u_int32_t addr;
 	u_int32_t size;
 	int type;
 } rangemap_t;
 struct ofw_translations {
 	vaddr_t va;
 	int len;
 #if defined (PMAC_G5)
 	register64_t pa;
 #else
 	register_t pa;
 #endif
 	int mode;
 }__attribute__((packed));
 struct pmap ofw_pmap;
 struct ofw_translations ofmap[32];
 char bootpath[256];
 char model_name[64];
 #if NKSYMS || defined(DDB) || defined(MODULAR)
 void *startsym, *endsym;
 #endif
 #if PPC_OEA601
 #define TIMEBASE_FREQ (1000000000)  /* RTC register */
 #endif
 #ifdef TIMEBASE_FREQ
 u_int timebase_freq = TIMEBASE_FREQ;
 #else
 u_int timebase_freq = 0;
 #endif
 int ofw_quiesce;
 extern int ofwmsr;
 extern int chosen;
 extern uint32_t ticks_per_sec;
 extern uint32_t ns_per_tick;
 extern uint32_t ticks_per_intr;
 static int save_ofmap(struct ofw_translations *, int);
 static void restore_ofmap(struct ofw_translations *, int);
 static void set_timebase(void);
 extern void cpu_spinstart(u_int);
 extern volatile u_int cpu_spinstart_ack;
 void
 ofwoea_initppc(u_int startkernel, u_int endkernel, char *args)
+{
 	int ofmaplen, node, l;
 	register_t scratch;
 #if defined(MULTIPROCESSOR) && defined(ofppc)
 	char cpupath[32];
 	int i;
 #endif
 	/* initialze bats */
 	if ((oeacpufeat & OEACPU_NOBAT) == 0)
 		ofwoea_batinit();
 #if NKSYMS || defined(DDB) || defined(MODULAR)
 	/* get info of kernel symbol table from bootloader */
 	memcpy(&startsym, args + strlen(args) + 1, sizeof(startsym));
 	memcpy(&endsym, args + strlen(args) + 1 + sizeof(startsym),
 	    sizeof(endsym));
 	if (startsym == NULL || endsym == NULL)
 	    startsym = endsym = NULL;
 #endif
 	/* get model name and perform model-specific actions */
 	memset(model_name, 0, sizeof(model_name));
 	node = OF_finddevice("/");
 	if (node != -1) {
 		l = OF_getprop(node, "model", model_name, sizeof(model_name));
 		if (l == -1)
 			OF_getprop(node, "name", model_name,
 			    sizeof(model_name));
 		model_init();
+	}
 	if (strncmp(model_name, "PowerMac11,2", 12) == 0 ||
 	    strncmp(model_name, "PowerMac12,1", 12) == 0)
-		OF_quiesce();
+		ofw_quiesce = 1;
 	/* switch CPUs to full speed */
 	if  (strncmp(model_name, "PowerMac7,", 10) == 0) {
 		int clock_ih = OF_open("/u3/i2c/i2c-hwclock");
 		if (clock_ih != 0) {
 			OF_call_method_1("slew-high", clock_ih, 0);
+		}
+	}
 	/* Initialize bus_space */
 	ofwoea_bus_space_init();
 	ofwoea_consinit();
 	if (ofw_quiesce)
 		OF_quiesce();
 #if defined(MULTIPROCESSOR) && defined(ofppc)
 	for (i=1; i < CPU_MAXNUM; i++) {
 		snprintf(cpupath, sizeof(cpupath), "/cpus/@%x", i);
 		node = OF_finddevice(cpupath);
 		if (node <= 0)
 			continue;
 		aprint_verbose("Starting up CPU %d %s\n", i, cpupath);
 		OF_start_cpu(node, (u_int)cpu_spinstart, i);
 		for (l=0; l < 100000000; l++) {
 			if (cpu_spinstart_ack == i) {
 				aprint_verbose("CPU %d spun up.\n", i);
 				break;
+			}
 			__asm volatile ("sync");
+		}
+	}
 #endif
 	oea_init(pic_ext_intr);
 	ofmaplen = save_ofmap(NULL, 0);
 	if (ofmaplen > 0)
 		save_ofmap(ofmap, ofmaplen);
 /*
  * XXX
  * we need to do this here instead of earlier on in ofwinit() for some reason
  * At least some versions of Apple OF 2.0.1 hang if we do this earlier
  */
 	ofwmsr &= ~PSL_IP;
 	/* Parse the args string */
 	if (args) {
 		strcpy(bootpath, args);
 		args = bootpath;
 		while (*++args && *args != ' ');
 		if (*args) {
 			*args++ = 0;
 			while (*args)
 				BOOT_FLAG(*args++, boothowto);
+		}
 	} else {
 		int chs = OF_finddevice("/chosen");
 		int len;
 		len = OF_getprop(chs, "bootpath", bootpath, sizeof(bootpath) - 1);
 		if (len > -1)
 			bootpath[len] = 0;
+	}
 	uvm_md_init();
 	pmap_bootstrap(startkernel, endkernel);
 /* as far as I can tell, the pmap_setup_seg0 stuff is horribly broken */
 #if defined(PPC_OEA64) || defined (PPC_OEA64_BRIDGE)
 #if defined (PMAC_G5)
 	/* Mapin 1st 256MB segment 1:1, also map in mem needed to access OFW*/
 	if (oeacpufeat & OEACPU_64_BRIDGE) {
 		vaddr_t va;
 		paddr_t pa;
 		int i;
 		pmap_setup_segment0_map(0, msgbuf_paddr, msgbuf_paddr,
 		    round_page(MSGBUFSIZE), 0x0);
 		/* Map OFW code+data */
 		for (i = 0; i < ofmaplen / sizeof(struct ofw_translations); i++) {
 			if (ofmap[i].va < 0xff800000)
 				continue;
 			for (va = ofmap[i].va, pa = ofmap[i].pa;
 			    va < ofmap[i].va + ofmap[i].len;
 			    va += PAGE_SIZE, pa += PAGE_SIZE) {
 				pmap_enter(pmap_kernel(), va, pa, VM_PROT_ALL,
 				    VM_PROT_ALL | PMAP_WIRED);
+			}
+		}
 #if NWSDISPLAY > 0
 		/* Map video frame buffer */
 		struct rasops_info *ri = &rascons_console_screen.scr_ri;
 		if (ri->ri_bits != NULL) {
 			for (va = (vaddr_t) ri->ri_bits;
 			    va < round_page((vaddr_t) ri->ri_bits +
 				ri->ri_height * ri->ri_stride);
 			    va += PAGE_SIZE) {
 				pmap_enter(pmap_kernel(), va, va,
 				    VM_PROT_READ | VM_PROT_WRITE,
 				    PMAP_NOCACHE | PMAP_WIRED);
+			}
+		}
 #endif
+	}
 #elif defined (MAMBO)
 	/* Mapin 1st 256MB segment 1:1, also map in mem needed to access OFW*/
 	if (oeacpufeat & OEACPU_64_BRIDGE)
 		pmap_setup_segment0_map(0, 0xf4000000, 0xf4000000, 0x1000, 0x0);
 #endif /* PMAC_G5 */
 #endif /* PPC_OEA64 || PPC_OEA64_BRIDGE */
 	/* Now enable translation (and machine checks/recoverable interrupts) */
 	__asm __volatile ("sync; mfmsr %0; ori %0,%0,%1; mtmsr %0; isync"
 	    : "=r"(scratch)
 	    : "K"(PSL_IR|PSL_DR|PSL_ME|PSL_RI));
 	restore_ofmap(ofmap, ofmaplen);
 	rascons_finalize();
 #if NKSYMS || defined(DDB) || defined(MODULAR)
 	ksyms_addsyms_elf((int)((uintptr_t)endsym - (uintptr_t)startsym), startsym, endsym);
 #endif
 	/* CPU clock stuff */
 	set_timebase();
 #ifdef DDB
 	if (boothowto & RB_KDB)
 		Debugger();
 #endif
+}
 void
 set_timebase(void)
+{
 	int qhandle, phandle, msr, scratch, node;
 	char type[32];
 	if (timebase_freq != 0) {
 		ticks_per_sec = timebase_freq;
 		goto found;
+	}
 	node = OF_finddevice("/cpus/@0");
 	if (node != -1 &&
 	    OF_getprop(node, "timebase-frequency", &ticks_per_sec,
 		       sizeof ticks_per_sec) > 0) {
 		goto found;
+	}
 	node = OF_finddevice("/");
 	for (qhandle = node; qhandle; qhandle = phandle) {
 		if (OF_getprop(qhandle, "device_type", type, sizeof type) > 0
 		    && strcmp(type, "cpu") == 0
 		    && OF_getprop(qhandle, "timebase-frequency",
 			&ticks_per_sec, sizeof ticks_per_sec) > 0) {
 			goto found;
+		}
 		if ((phandle = OF_child(qhandle)))
 			continue;
 		while (qhandle) {
 			if ((phandle = OF_peer(qhandle)))
 				break;
 			qhandle = OF_parent(qhandle);
+		}
+	}
 	panic("no cpu node");
 found:
 	__asm volatile ("mfmsr %0; andi. %1,%0,%2; mtmsr %1"
 		: "=r"(msr), "=r"(scratch) : "K"((u_short)~PSL_EE));
 	ns_per_tick = 1000000000 / ticks_per_sec;
 	ticks_per_intr = ticks_per_sec / hz;
 	cpu_timebase = ticks_per_sec;
 #ifdef PPC_OEA601
 	if ((mfpvr() >> 16) == MPC601)
 	    curcpu()->ci_lasttb = rtc_nanosecs();
 	else
 #endif
 	curcpu()->ci_lasttb = mftbl();
 	mtspr(SPR_DEC, ticks_per_intr);
 	mtmsr(msr);
+}
 static int
 save_ofmap(struct ofw_translations *map, int maxlen)
+{
 	int mmui, mmu, len;
 	OF_getprop(chosen, "mmu", &mmui, sizeof mmui);
 	mmu = OF_instance_to_package(mmui);
 	if (map) {
 		memset(map, 0, maxlen); /* to be safe */
 		len = OF_getprop(mmu, "translations", map, maxlen);
 	} else
 		len = OF_getproplen(mmu, "translations");
 	if (len < 0)
 		len = 0;
 	return len;
+}
 /* The PMAC_G5 code here needs to be replaced by code that looks for the
    size_cells and does the right thing automatically.
 */
 void
 restore_ofmap(struct ofw_translations *map, int len)
+{
 	int n = len / sizeof(struct ofw_translations);
 	int i;
 	pmap_pinit(&ofw_pmap);
 #ifndef _LP64
 	ofw_pmap.pm_sr[0] = KERNELN_SEGMENT(0)|SR_PRKEY;
 	ofw_pmap.pm_sr[KERNEL_SR] = KERNEL_SEGMENT|SR_SUKEY|SR_PRKEY;
 #ifdef KERNEL2_SR
 	ofw_pmap.pm_sr[KERNEL2_SR] = KERNEL2_SEGMENT|SR_SUKEY|SR_PRKEY;
 #endif
 #endif
 	for (i = 0; i < n; i++) {
 #if defined (PMAC_G5)
 		register64_t pa = map[i].pa;
 #else
 		register_t pa = map[i].pa;
 #endif
 		vaddr_t va = map[i].va;
 		size_t length = map[i].len;
 		if (va < 0xf0000000) /* XXX */
 			continue;
 		while (length > 0) {
 			pmap_enter(&ofw_pmap, va, (paddr_t)pa, VM_PROT_ALL,
 			    VM_PROT_ALL|PMAP_WIRED);
 			pa += PAGE_SIZE;
 			va += PAGE_SIZE;
 			length -= PAGE_SIZE;
+		}
+	}
 	pmap_update(&ofw_pmap);
+}
 /*
  * Scan the device tree for ranges, and return them as bitmap 0..15
  */
 #if !defined(macppc) && defined(PPC_OEA)
 static u_int16_t
 ranges_bitmap(int node, u_int16_t bitmap)
+{
 	int child, mlen, acells, scells, reclen, i, j;
 	u_int32_t addr, len, map[160];
 	for (child = OF_child(node); child; child = OF_peer(child)) {
 		mlen = OF_getprop(child, "ranges", map, sizeof(map));
 		if (mlen == -1)
 			goto noranges;
 		j = OF_getprop(child, "#address-cells", &acells,
 		    sizeof(acells));
 		if (j == -1)
 			goto noranges;
 		j = OF_getprop(child, "#size-cells", &scells,
 		    sizeof(scells));
 		if (j == -1)
 			goto noranges;
 #ifdef ofppc
 		reclen = acells + modeldata.ranges_offset + scells;
 #else
 		reclen = acells + 1 + scells;
 #endif
 		for (i=0; i < (mlen/4)/reclen; i++) {
 			addr = map[reclen * i + acells];
 			len = map[reclen * i + reclen - 1];
 			for (j = 0; j < len / 0x10000000; j++)
 				bitmap |= 1 << ((addr+j*0x10000000) >>28);
 			bitmap |= 1 << (addr >> 28);
+		}
 noranges:
 		bitmap |= ranges_bitmap(child, bitmap);
 		continue;
+	}
 	return bitmap;
+}
 #endif /* !macppc && PPC_OEA */
 void
 ofwoea_batinit(void)
+{
 #if defined (PPC_OEA)
 #ifdef macppc
 	/*
 	 * cover PCI and register space but not the firmware ROM
 	 */
 #ifdef PPC_OEA601
         /*
 	 * use segment registers for the 601
 	 */
 	if ((mfpvr() >> 16 ) == MPC601)
 	    oea_batinit(
 x80000000, BAT_BL_256M,
 x90000000, BAT_BL_256M,
 xa0000000, BAT_BL_256M,
 xb0000000, BAT_BL_256M,
 xf0000000, BAT_BL_256M,
 );
 	else
 #endif
 	/*
 	 * map to bats
 	 */
 	oea_batinit(0x80000000, BAT_BL_1G,
 xf0000000, BAT_BL_128M,
 xf8000000, BAT_BL_64M,
 xfe000000, BAT_BL_8M,	/* Grackle IO */
 );
 #else
 	uint16_t bitmap;
 	int node, i;
 	node = OF_finddevice("/");
 	bitmap = ranges_bitmap(node, 0);
 	oea_batinit(0);
 	for (i=1; i < 0x10; i++) {
 		/* skip the three vital SR regions */
 		if (i == USER_SR || i == KERNEL_SR || i == KERNEL2_SR)
 			continue;
 		if (bitmap & (1 << i)) {
 			oea_iobat_add(0x10000000 * i, BAT_BL_256M);
 			DPRINTF("Batmapped 256M at 0x%x\n", 0x10000000 * i);
+		}
+	}
 #endif
 #endif /* OEA */
+}
 /* we define these partially, as we will fill the rest in later */
 struct powerpc_bus_space genppc_isa_io_space_tag = {
 	.pbs_flags = _BUS_SPACE_LITTLE_ENDIAN|_BUS_SPACE_IO_TYPE,
 	.pbs_base = 0x00000000,
 };
 struct powerpc_bus_space genppc_isa_mem_space_tag = {
 	.pbs_flags = _BUS_SPACE_LITTLE_ENDIAN|_BUS_SPACE_MEM_TYPE,
 	.pbs_base = 0x00000000,
 };
 /* This gives us a maximum of 6 PCI busses, assuming both io/mem on each.
  * Increase if necc.
  */
 static char ex_storage[EXSTORAGE_MAX][EXTENT_FIXED_STORAGE_SIZE(EXTMAP_RANGES)]
 	__attribute__((aligned(8)));
 static void
 find_ranges(int base, rangemap_t *regions, int *cur, int type)
+{
 	int node, i, len, reclen;
 	u_int32_t parent_acells, acells, scells, map[160];
 	char tmp[32];
 	node = base;
 	if (OF_getprop(node, "device_type", tmp, sizeof(tmp)) == -1)
 		goto rec;
 	if ((type == RANGE_TYPE_PCI || type == RANGE_TYPE_FIRSTPCI) &&
 	    strcmp("pci", tmp) != 0)
 		goto rec;
 	if (type == RANGE_TYPE_ISA && strcmp("isa", tmp) != 0)
 		goto rec;
 	if (type == RANGE_TYPE_MACIO && strcmp("memory-controller", tmp) == 0) {
 		len = OF_getprop(node, "reg", map, sizeof(map));
 		acells = 1;
 		scells = 1;
 	} else {
 		len = OF_getprop(node, "ranges", map, sizeof(map));
+	}
 	if (len == -1)
 		goto rec;
 	if (OF_getprop(OF_parent(node), "#address-cells", &parent_acells,
 	    sizeof(parent_acells)) != sizeof(parent_acells))
 		parent_acells = 1;
 	if (OF_getprop(node, "#address-cells", &acells,
 	    sizeof(acells)) != sizeof(acells))
 		acells = 3;
 	if (OF_getprop(node, "#size-cells", &scells,
 	    sizeof(scells)) != sizeof(scells))
 		scells = 2;
 #ifdef ofppc
 	if (modeldata.ranges_offset == 0)
 		scells -= 1;
 #endif
 	if (type == RANGE_TYPE_ISA)
 		reclen = 6;
 	else
 		reclen = parent_acells + acells + scells;
 	/*
 	 * There exist ISA buses with empty ranges properties.  This is
 	 * known to occur on the Pegasos II machine, and likely others.
 	 * According to them, that means that the isa bus is a fake bus, and
 	 * the real maps are the PCI maps of the preceeding bus.  To deal
 	 * with this, we will set cur to -1 and return.
 	 */
 	if (type == RANGE_TYPE_ISA && strcmp("isa", tmp) == 0 && len == 0) {
 		*cur = -1;
 		DPRINTF("Found empty range in isa bus\n");
 		return;
+	}
 	DPRINTF("found a map reclen=%d cur=%d len=%d\n", reclen, *cur, len);
 	switch (type) {
 		case RANGE_TYPE_PCI:
 		case RANGE_TYPE_FIRSTPCI:
 			for (i=0; i < len/(4*reclen); i++) {
 				DPRINTF("FOUND PCI RANGE\n");
 				regions[*cur].size =
 				    map[i*reclen + parent_acells + acells + scells - 1];
 				/* skip ranges of size==0 */
 				if (regions[*cur].size == 0)
 					continue;
 				regions[*cur].type = (map[i*reclen] >> 24) & 0x3;
 				regions[*cur].addr = map[i*reclen + parent_acells + acells - 1];
 				(*cur)++;
+			}
 			break;
 		case RANGE_TYPE_ISA:
 			for (i=0; i < len/(4*reclen); i++) {
 				if (map[i*reclen] == 1)
 					regions[*cur].type = RANGE_IO;
 				else
 					regions[*cur].type = RANGE_MEM;
 				DPRINTF("FOUND ISA RANGE TYPE=%d\n",
 					regions[*cur].type);
 				regions[*cur].size =
 				    map[i*reclen + acells + scells];
 				(*cur)++;
+			}
 			break;
 		case RANGE_TYPE_MACIO:
 			regions[*cur].type = RANGE_MEM;
 			if (len == 8) {
 				regions[*cur].size = map[1];
 				regions[*cur].addr = map[0];
 			} else {
 				regions[*cur].size = map[2];
 				regions[*cur].addr = map[1];
+			}
 			(*cur)++;
 			break;
+	}
 	DPRINTF("returning with CUR=%d\n", *cur);
 	return;
 rec:
 	for (node = OF_child(base); node; node = OF_peer(node)) {
 		DPRINTF("RECURSE 1 STEP\n");
 		find_ranges(node, regions, cur, type);
 		if (*cur == -1)
 			return;
+	}
+}
 static int
 find_lowest_range(rangemap_t *ranges, int nrof, int type)
+{
 	int i, low = 0;
 	u_int32_t addr = 0xffffffff;
 	for (i=0; i < nrof; i++) {
 		if (ranges[i].type == type && ranges[i].addr != 0 &&
 		    ranges[i].addr < addr) {
 			low = i;
 			addr = ranges[i].addr;
+		}
+	}
 	if (addr == 0xffffffff)
 		return -1;
 	return low;
+}
 /*
  * Find a region of memory, and create a bus_space_tag for it.
  * Notes:
  * For ISA node is ignored.
  * node is the starting node.  if -1, we start at / and map everything.
  */
 int
 ofwoea_map_space(int rangetype, int iomem, int node,
     struct powerpc_bus_space *tag, const char *name)
+{
 	int i, cur, range, nrofholes, error;
 	static int exmap=0;
 	rangemap_t region, holes[32], list[32];
 	memset(list, 0, sizeof(list));
 	memset(&region, 0, sizeof(region));
 	cur = 0;
 	if (rangetype == RANGE_TYPE_ISA || node == -1)
 		node = OF_finddevice("/");
 	if (rangetype == RANGE_TYPE_ISA) {
 		u_int32_t size = 0;
 		rangemap_t regions[32];
 		DPRINTF("LOOKING FOR FIRSTPCI\n");
 		find_ranges(node, list, &cur, RANGE_TYPE_FIRSTPCI);
 		range = 0;
 		DPRINTF("LOOKING FOR ISA\n");
 		find_ranges(node, regions, &range, RANGE_TYPE_ISA);
 		if (range == 0 || cur == 0)
 			return -1; /* no isa stuff found */
 		/*
 		 * This may be confusing to some.  The ISA ranges property
 		 * is supposed to be a set of IO ranges for the ISA bus, but
 		 * generally, it's just a set of pci devfunc lists that tell
 		 * you to go look at the parent PCI device for the actual
 		 * ranges.
 		 */
 		if (range == -1) {
 			/* we found a rangeless isa bus */
 			if (iomem == RANGE_IO)
 				size = 0x10000;
 			else
 				size = 0x1000000;
+		}
 		DPRINTF("found isa stuff\n");
 		for (i=0; i < range; i++)
 			if (regions[i].type == iomem)
 				size = regions[i].size;
 		if (iomem == RANGE_IO) {
 			/* the first io range is the one */
 			for (i=0; i < cur; i++)
 				if (list[i].type == RANGE_IO && size) {
 					DPRINTF("found IO\n");
 					tag->pbs_offset = list[i].addr;
 					tag->pbs_limit = size;
 					error = bus_space_init(tag, name,
 					    ex_storage[exmap],
 					    sizeof(ex_storage[exmap]));
 					exmap++;
 					return error;
+				}
 		} else {
 			for (i=0; i < cur; i++)
 				if (list[i].type == RANGE_MEM &&
 				    list[i].size == size) {
 					DPRINTF("found mem\n");
 					tag->pbs_offset = list[i].addr;
 					tag->pbs_limit = size;
 					error = bus_space_init(tag, name,
 					    ex_storage[exmap],
 					    sizeof(ex_storage[exmap]));
 					exmap++;
 					return error;
+				}
+		}
 		return -1; /* NO ISA FOUND */
+	}
 	find_ranges(node, list, &cur, rangetype);
 	DPRINTF("cur == %d\n", cur);
 	/* now list should contain a list of memory regions */
 	for (i=0; i < cur; i++)
 		DPRINTF("addr=0x%x size=0x%x type=%d\n", list[i].addr,
 		    list[i].size, list[i].type);
 	range = find_lowest_range(list, cur, iomem);
 	i = 0;
 	nrofholes = 0;
 	while (range != -1) {
 		DPRINTF("range==%d\n", range);
 		DPRINTF("i==%d\n", i);
 		if (i == 0) {
 			memcpy(&region, &list[range], sizeof(rangemap_t));
 			list[range].addr = 0;
 			i++;
 			range = find_lowest_range(list, cur, iomem);
 			continue;
+		}
 		if (region.addr + region.size < list[range].addr) {
 			/* allocate a hole */
 			holes[nrofholes].type = iomem;
 			holes[nrofholes].addr = region.size + region.addr;
 			holes[nrofholes].size = list[range].addr -
 			    holes[nrofholes].addr - 1;
 			nrofholes++;
+		}
 		region.size = list[range].size + list[range].addr -
 		    region.addr;
 		list[range].addr = 0;
 		range = find_lowest_range(list, cur, iomem);
+	}
 	DPRINTF("RANGE iomem=%d FOUND\n", iomem);
 	DPRINTF("addr=0x%x size=0x%x type=%d\n", region.addr,
 		    region.size, region.type);
 	DPRINTF("HOLES FOUND\n");
 	for (i=0; i < nrofholes; i++)
 		DPRINTF("addr=0x%x size=0x%x type=%d\n", holes[i].addr,
 		    holes[i].size, holes[i].type);
 	/* AT THIS POINT WE MAP IT */
 	if ((rangetype == RANGE_TYPE_PCI) || (rangetype == RANGE_TYPE_MACIO)) {
 		if (exmap == EXSTORAGE_MAX)
 			panic("Not enough ex_storage space. "
 			    "Increase EXSTORAGE_MAX");
 		/* XXX doing this in here might be wrong */
 		if (iomem == 1) {
 			/* we map an IO region */
 			tag->pbs_offset = region.addr;
 			tag->pbs_base = 0;
 			tag->pbs_limit = region.size;
 		} else {
 			/* ... or a memory region */
 			tag->pbs_offset = 0;
 			tag->pbs_base = region.addr;
 			tag->pbs_limit = region.size + region.addr;
+		}
 		error = bus_space_init(tag, name, ex_storage[exmap],
 		    sizeof(ex_storage[exmap]));
 		exmap++;
 		if (error)
 			panic("ofwoea_bus_space_init: can't init tag %s", name);
 		for (i=0; i < nrofholes; i++) {
 			if (holes[i].type == RANGE_IO) {
 				error = extent_alloc_region(tag->pbs_extent,
 				    holes[i].addr - tag->pbs_offset,
 				    holes[i].size, EX_NOWAIT);
 			} else {
 				error = extent_alloc_region(tag->pbs_extent,
 				    holes[i].addr, holes[i].size, EX_NOWAIT);
+			}
 			if (error)
 				panic("ofwoea_bus_space_init: can't block out"
 				    " reserved space 0x%x-0x%x: error=%d",
 				    holes[i].addr, holes[i].addr+holes[i].size,
 				    error);
+		}
 		return error;
+	}
 	return -1;
+}
 void
 ofwoea_bus_space_init(void)
+{
 	int error;
 	error = ofwoea_map_space(RANGE_TYPE_ISA, RANGE_IO, -1,
 	    &genppc_isa_io_space_tag, "isa-ioport");
 	if (error > 0)
 		panic("Could not map ISA IO");
 	error = ofwoea_map_space(RANGE_TYPE_ISA, RANGE_MEM, -1,
 	    &genppc_isa_mem_space_tag, "isa-iomem");
 	if (error > 0)
 		panic("Could not map ISA MEM");
+}

 @@ -1,87 +1,88 @@
-/*	$NetBSD: autoconf.h,v 1.19 2019/01/08 07:46:10 mrg Exp $	*/
+/*	$NetBSD: autoconf.h,v 1.20 2020/07/07 02:33:54 rin Exp $	*/
 /*-
  * Copyright (C) 1998	Internet Research Institute, Inc.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by
  *	Internet Research Institute, Inc.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef _MACHINE_AUTOCONF_H_
 #define _MACHINE_AUTOCONF_H_
 #include <sys/bus.h>
 #include <prop/proplib.h>
 struct confargs {
 	const char *ca_name;
 	u_int ca_node;
 	int ca_nreg;
 	u_int *ca_reg;
 	int ca_nintr;
 	int *ca_intr;
 	bus_addr_t ca_baseaddr;
 	bus_space_tag_t ca_tag;
 };
 /* there are in locore.S */
 void ofbcopy(const void *, void *, size_t);
 int badaddr(volatile void *, int);
 /* these are in clock.c */
 void calc_delayconst(void);
 void decr_intr(struct clockframe *);
 /* these are in cpu.c */
 void identifycpu(char *);
 /* these are in machdep.c */
 void initppc(u_int, u_int, char *);
 void model_init(void);
 paddr_t kvtop(void *);
 void dumpsys(void);
 void copy_disp_props(device_t, int, prop_dictionary_t);
 /* these are in extintr.c */
 void init_interrupt(void);
 /* these are in dev/akbd.c */
 int kbd_intr(void *);
 int akbd_cnattach(void);
 int adbkbd_cnattach(void);
 /* these are in dev/ofb.c */
 int ofb_is_console(void);
 int rascons_cnattach(void);
 extern int console_node;
 extern int console_instance;
 extern int ofw_quiesce;
 extern char model_name[64];
 #endif /* _MACHINE_AUTOCONF_H_ */

 @@ -1,58 +1,59 @@
-/*	$NetBSD: autoconf.h,v 1.16 2019/01/08 07:46:10 mrg Exp $	*/
+/*	$NetBSD: autoconf.h,v 1.17 2020/07/07 02:33:54 rin Exp $	*/
 #ifndef _OFPPC_AUTOCONF_H_
 #define _OFPPC_AUTOCONF_H_
 #include <sys/bus.h>
 #include <prop/proplib.h>
 struct confargs {
 	const char	*ca_name;
 	u_int		ca_node;
 	int		ca_nreg;
 	u_int		*ca_reg;
 	int		ca_nintr;
 	int		*ca_intr;
 	bus_addr_t	ca_baseaddr;
 	bus_space_tag_t	ca_tag;
 };
 struct pciio_info {
 	uint32_t	start;
 	uint32_t	limit;
 };
 /* to support machines with more than 4 busses, change the below */
 #define MAX_PCI_BUSSES		4
 struct model_data {
 	int			ranges_offset;
 	struct pciio_info	pciiodata[MAX_PCI_BUSSES];
 };
 extern int console_node;
 extern int ofw_quiesce;		/* XXX not used at the moment */
 extern char model_name[64];
 #ifdef _KERNEL
 void initppc(u_int, u_int, char *);
 void model_init(void);
 void strayintr(int);
 void dumpsys(void);
 void inittodr(time_t);
 void resettodr(void);
 void cpu_initclocks(void);
 void decr_intr(struct clockframe *);
 void setstatclockrate(int);
 void init_interrupt(void);
 void init_ofppc_interrupt(void);
 void ofppc_init_comcons(int);
 void copy_disp_props(device_t, int, prop_dictionary_t);
 void OF_start_cpu(int, u_int, int);
 int rascons_cnattach(void);
 #endif /* _KERNEL */
 #endif /* _OFPPC_AUTOCONF_H_ */