 @@ -1,1193 +1,1193 @@
-/*	$NetBSD: acpi.c,v 1.208 2010/07/25 12:54:46 pgoyette Exp $	*/
+/*	$NetBSD: acpi.c,v 1.209 2010/08/06 18:10:40 jruoho Exp $	*/
 /*-
  * Copyright (c) 2003, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum of By Noon Software, Inc.
+ *
  * 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.
  */
 /*
  * Copyright 2001, 2003 Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
+ *
  * 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 for the NetBSD Project by
  *	Wasabi Systems, Inc.
  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
  *    or promote products derived from this software without specific prior
  *    written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC
  * 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: acpi.c,v 1.208 2010/07/25 12:54:46 pgoyette Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi.c,v 1.209 2010/08/06 18:10:40 jruoho Exp $");
 #include "opt_acpi.h"
 #include "opt_pcifixup.h"
 #include <sys/param.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/module.h>
 #include <sys/mutex.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
 #include <sys/timetc.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_osd.h>
 #include <dev/acpi/acpi_pci.h>
 #include <dev/acpi/acpi_power.h>
 #include <dev/acpi/acpi_timer.h>
 #include <dev/acpi/acpi_wakedev.h>
 #define _COMPONENT	ACPI_BUS_COMPONENT
 ACPI_MODULE_NAME	("acpi")
 #if defined(ACPI_PCI_FIXUP)
 #error The option ACPI_PCI_FIXUP has been obsoleted by PCI_INTR_FIXUP_DISABLED.  Please adjust your kernel configuration file.
 #endif
 #ifdef PCI_INTR_FIXUP_DISABLED
 #include <dev/pci/pcidevs.h>
 #endif
 MALLOC_DECLARE(M_ACPI);
 #include <machine/acpi_machdep.h>
 #ifdef ACPI_DEBUGGER
 #define	ACPI_DBGR_INIT		0x01
 #define	ACPI_DBGR_TABLES	0x02
 #define	ACPI_DBGR_ENABLE	0x04
 #define	ACPI_DBGR_PROBE		0x08
 #define	ACPI_DBGR_RUNNING	0x10
 static int acpi_dbgr = 0x00;
 #endif
 /*
  * This is a flag we set when the ACPI subsystem is active.  Machine
  * dependent code may wish to skip other steps (such as attaching
  * subsystems that ACPI supercedes) when ACPI is active.
  */
 int	acpi_active;
 int	acpi_force_load;
 int	acpi_suspended = 0;
 struct acpi_softc *acpi_softc;
 static uint64_t acpi_root_pointer;
 extern kmutex_t acpi_interrupt_list_mtx;
 static ACPI_HANDLE acpi_scopes[4];
 /*
  * This structure provides a context for the ACPI
  * namespace walk performed in acpi_build_tree().
  */
 struct acpi_walkcontext {
 	struct acpi_softc	*aw_sc;
 	struct acpi_devnode	*aw_parent;
 };
 /*
  * Ignored HIDs.
  */
 static const char * const acpi_ignored_ids[] = {
 #if defined(i386) || defined(x86_64)
 	"PNP0000",	/* AT interrupt controller is handled internally */
 	"PNP0200",	/* AT DMA controller is handled internally */
 	"PNP0A??",	/* PCI Busses are handled internally */
 	"PNP0B00",	/* AT RTC is handled internally */
 	"PNP0C0B",	/* No need for "ACPI fan" driver */
 	"PNP0C0F",	/* ACPI PCI link devices are handled internally */
 	"IFX0102",	/* No driver for Infineon TPM */
 	"INT0800",	/* No driver for Intel Firmware Hub device */
 #endif
 #if defined(x86_64)
 	"PNP0C04",	/* FPU is handled internally */
 #endif
 	NULL
 };
 static int		acpi_match(device_t, cfdata_t, void *);
 static int		acpi_submatch(device_t, cfdata_t, const int *, void *);
 static void		acpi_attach(device_t, device_t, void *);
 static int		acpi_detach(device_t, int);
 static void		acpi_childdet(device_t, device_t);
 static bool		acpi_suspend(device_t, const pmf_qual_t *);
 static bool		acpi_resume(device_t, const pmf_qual_t *);
 static void		acpi_build_tree(struct acpi_softc *);
 static ACPI_STATUS	acpi_make_devnode(ACPI_HANDLE, uint32_t,
 					  void *, void **);
 static ACPI_STATUS	acpi_make_devnode_post(ACPI_HANDLE, uint32_t,
 					       void *, void **);
 #ifdef ACPI_ACTIVATE_DEV
 static void		acpi_activate_device(ACPI_HANDLE, ACPI_DEVICE_INFO **);
 static ACPI_STATUS	acpi_allocate_resources(ACPI_HANDLE);
 #endif
 static int		acpi_rescan(device_t, const char *, const int *);
 static void		acpi_rescan_nodes(struct acpi_softc *);
 static void		acpi_rescan_capabilities(struct acpi_softc *);
 static int		acpi_print(void *aux, const char *);
 static void		acpi_notify_handler(ACPI_HANDLE, uint32_t, void *);
 static void		acpi_register_fixed_button(struct acpi_softc *, int);
 static void		acpi_deregister_fixed_button(struct acpi_softc *, int);
 static uint32_t		acpi_fixed_button_handler(void *);
 static void		acpi_fixed_button_pressed(void *);
 static void		acpi_sleep_init(struct acpi_softc *);
-static int		sysctl_hw_acpi_fixedstats(SYSCTLFN_ARGS);
+static int		sysctl_hw_acpi_fixedstats(SYSCTLFN_PROTO);
-static int		sysctl_hw_acpi_sleepstate(SYSCTLFN_ARGS);
+static int		sysctl_hw_acpi_sleepstate(SYSCTLFN_PROTO);
-static int		sysctl_hw_acpi_sleepstates(SYSCTLFN_ARGS);
+static int		sysctl_hw_acpi_sleepstates(SYSCTLFN_PROTO);
 static bool		  acpi_is_scope(struct acpi_devnode *);
 static ACPI_TABLE_HEADER *acpi_map_rsdt(void);
 static void		  acpi_unmap_rsdt(ACPI_TABLE_HEADER *);
 extern struct cfdriver acpi_cd;
 /* Handle routine vectors and loading for acpiverbose module */
 void acpi_null(void);
 void acpi_print_devnodes_stub(struct acpi_softc *);
 void acpi_print_tree_stub(struct acpi_devnode *, uint32_t);
 void acpi_print_dev_stub(const char *);
 void acpi_wmidump_stub(void *);
 void (*acpi_print_devnodes)(struct acpi_softc *) = acpi_print_devnodes_stub;
 void (*acpi_print_tree)(struct acpi_devnode *, uint32_t) = acpi_print_tree_stub;
 void (*acpi_print_dev)(const char *) = acpi_print_dev_stub;
 void (*acpi_wmidump)(void *) = acpi_wmidump_stub;
 int acpi_verbose_loaded = 0;
 /*
  * Support for ACPIVERBOSE.
  */
 void
 acpi_null(void)
+{
 	/* Nothing to do. */
+}
 void
 acpi_load_verbose(void)
+{
 	if (acpi_verbose_loaded == 0) {
 		mutex_enter(&module_lock);
 		module_autoload("acpiverbose", MODULE_CLASS_MISC);
 		mutex_exit(&module_lock);
+	}
+}
 void
 acpi_print_devnodes_stub(struct acpi_softc *sc)
+{
 	acpi_load_verbose();
 	if (acpi_verbose_loaded)
 		acpi_print_devnodes(sc);
+}
 void
 acpi_print_tree_stub(struct acpi_devnode *ad, uint32_t level)
+{
 	acpi_load_verbose();
 	if (acpi_verbose_loaded)
 		acpi_print_tree(ad, level);
+}
 void
 acpi_print_dev_stub(const char *pnpstr)
+{
 	acpi_load_verbose();
 	if (acpi_verbose_loaded)
 		acpi_print_dev(pnpstr);
+}
 void
 acpi_wmidump_stub(void *arg)
+{
 	acpi_load_verbose();
 	if (acpi_verbose_loaded)
 		acpi_wmidump(arg);
+}
 CFATTACH_DECL2_NEW(acpi, sizeof(struct acpi_softc),
     acpi_match, acpi_attach, acpi_detach, NULL, acpi_rescan, acpi_childdet);
 /*
  * Probe for ACPI support.
+ *
  * This is called by the machine-dependent ACPI front-end.
  * Note: this is not an autoconfiguration interface function.
  */
 int
 acpi_probe(void)
+{
 	ACPI_TABLE_HEADER *rsdt;
 	const char *func;
 	static int once;
 	bool initialized;
 	ACPI_STATUS rv;
 	if (once != 0)
 		panic("%s: already probed", __func__);
 	once = 1;
 	func = NULL;
 	initialized = false;
 	mutex_init(&acpi_interrupt_list_mtx, MUTEX_DEFAULT, IPL_NONE);
 	/*
 	 * Start up ACPICA.
 	 */
 #ifdef ACPI_DEBUGGER
 	if (acpi_dbgr & ACPI_DBGR_INIT)
 		acpi_osd_debugger();
 #endif
 	CTASSERT(TRUE == true);
 	CTASSERT(FALSE == false);
 	AcpiGbl_AllMethodsSerialized = false;
 	AcpiGbl_EnableInterpreterSlack = true;
 	rv = AcpiInitializeSubsystem();
 	if (ACPI_SUCCESS(rv))
 		initialized = true;
 	else {
 		func = "AcpiInitializeSubsystem()";
 		goto fail;
+	}
 	/*
 	 * Allocate space for RSDT/XSDT and DSDT,
 	 * but allow resizing if more tables exist.
 	 */
 	rv = AcpiInitializeTables(NULL, 2, true);
 	if (ACPI_FAILURE(rv)) {
 		func = "AcpiInitializeTables()";
 		goto fail;
+	}
 #ifdef ACPI_DEBUGGER
 	if (acpi_dbgr & ACPI_DBGR_TABLES)
 		acpi_osd_debugger();
 #endif
 	rv = AcpiLoadTables();
 	if (ACPI_FAILURE(rv)) {
 		func = "AcpiLoadTables()";
 		goto fail;
+	}
 	rsdt = acpi_map_rsdt();
 	if (rsdt == NULL) {
 		func = "acpi_map_rsdt()";
 		rv = AE_ERROR;
 		goto fail;
+	}
 	if (acpi_force_load == 0 && (acpi_find_quirks() & ACPI_QUIRK_BROKEN)) {
 		aprint_normal("ACPI: BIOS is listed as broken:\n");
 		aprint_normal("ACPI: X/RSDT: OemId <%6.6s,%8.8s,%08x>, "
 		       "AslId <%4.4s,%08x>\n",
 			rsdt->OemId, rsdt->OemTableId,
 		        rsdt->OemRevision,
 			rsdt->AslCompilerId,
 		        rsdt->AslCompilerRevision);
 		aprint_normal("ACPI: Not used. Set acpi_force_load to use.\n");
 		acpi_unmap_rsdt(rsdt);
 		AcpiTerminate();
 		return 0;
+	}
 	acpi_unmap_rsdt(rsdt);
 	rv = AcpiEnableSubsystem(~(ACPI_NO_HARDWARE_INIT|ACPI_NO_ACPI_ENABLE));
 	if (ACPI_FAILURE(rv)) {
 		func = "AcpiEnableSubsystem()";
 		goto fail;
+	}
 	/*
 	 * Looks like we have ACPI!
 	 */
 	return 1;
 fail:
 	KASSERT(rv != AE_OK);
 	KASSERT(func != NULL);
 	aprint_error("%s: failed to probe ACPI: %s\n",
 	    func, AcpiFormatException(rv));
 	if (initialized != false)
 		(void)AcpiTerminate();
 	return 0;
+}
 int
 acpi_check(device_t parent, const char *ifattr)
+{
 	return (config_search_ia(acpi_submatch, parent, ifattr, NULL) != NULL);
+}
 /*
  * Autoconfiguration.
  */
 static int
 acpi_match(device_t parent, cfdata_t match, void *aux)
+{
 	/*
 	 * XXX: Nada; MD code has called acpi_probe().
 	 */
 	return 1;
+}
 static int
 acpi_submatch(device_t parent, cfdata_t cf, const int *locs, void *aux)
+{
 	struct cfattach *ca;
 	ca = config_cfattach_lookup(cf->cf_name, cf->cf_atname);
 	return (ca == &acpi_ca);
+}
 static void
 acpi_attach(device_t parent, device_t self, void *aux)
+{
 	struct acpi_softc *sc = device_private(self);
 	struct acpibus_attach_args *aa = aux;
 	ACPI_TABLE_HEADER *rsdt;
 	ACPI_STATUS rv;
 	aprint_naive("\n");
 	aprint_normal(": Intel ACPICA %08x\n", ACPI_CA_VERSION);
 	if (acpi_softc != NULL)
 		panic("%s: already attached", __func__);
 	rsdt = acpi_map_rsdt();
 	if (rsdt == NULL)
 		aprint_error_dev(self, "X/RSDT: Not found\n");
 	else {
 		aprint_verbose_dev(self,
 		    "X/RSDT: OemId <%6.6s,%8.8s,%08x>, AslId <%4.4s,%08x>\n",
 		    rsdt->OemId, rsdt->OemTableId,
 		    rsdt->OemRevision,
 		    rsdt->AslCompilerId, rsdt->AslCompilerRevision);
+	}
 	acpi_unmap_rsdt(rsdt);
 	sc->sc_dev = self;
 	sc->sc_root = NULL;
 	sc->sc_sleepstate = ACPI_STATE_S0;
 	sc->sc_quirks = acpi_find_quirks();
 	sysmon_power_settype("acpi");
 	sc->sc_iot = aa->aa_iot;
 	sc->sc_memt = aa->aa_memt;
 	sc->sc_pc = aa->aa_pc;
 	sc->sc_pciflags = aa->aa_pciflags;
 	sc->sc_ic = aa->aa_ic;
 	SIMPLEQ_INIT(&sc->ad_head);
 	acpi_softc = sc;
 	if (pmf_device_register(self, acpi_suspend, acpi_resume) != true)
 		aprint_error_dev(self, "couldn't establish power handler\n");
 	/*
 	 * Bring ACPI on-line.
 	 */
 #ifdef ACPI_DEBUGGER
 	if (acpi_dbgr & ACPI_DBGR_ENABLE)
 		acpi_osd_debugger();
 #endif
 #define ACPI_ENABLE_PHASE1 \
     (ACPI_NO_HANDLER_INIT | ACPI_NO_EVENT_INIT)
 #define ACPI_ENABLE_PHASE2 \
     (ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE | \
      ACPI_NO_ADDRESS_SPACE_INIT)
 	rv = AcpiEnableSubsystem(ACPI_ENABLE_PHASE1);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	acpi_md_callback();
 	rv = AcpiEnableSubsystem(ACPI_ENABLE_PHASE2);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	/*
 	 * Early EC handler initialization if ECDT table is available.
 	 */
 	config_found_ia(self, "acpiecdtbus", aa, NULL);
 	rv = AcpiInitializeObjects(ACPI_FULL_INITIALIZATION);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	/*
 	 * Install global notify handlers.
 	 */
 	rv = AcpiInstallNotifyHandler(ACPI_ROOT_OBJECT,
 	    ACPI_SYSTEM_NOTIFY, acpi_notify_handler, NULL);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	rv = AcpiInstallNotifyHandler(ACPI_ROOT_OBJECT,
 	    ACPI_DEVICE_NOTIFY, acpi_notify_handler, NULL);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	acpi_active = 1;
 	/* Show SCI interrupt. */
 	aprint_verbose_dev(self, "SCI interrupting at int %u\n",
 	    AcpiGbl_FADT.SciInterrupt);
 	/*
 	 * Install fixed-event handlers.
 	 */
 	acpi_register_fixed_button(sc, ACPI_EVENT_POWER_BUTTON);
 	acpi_register_fixed_button(sc, ACPI_EVENT_SLEEP_BUTTON);
 	acpitimer_init(sc);
 #ifdef ACPI_DEBUGGER
 	if (acpi_dbgr & ACPI_DBGR_PROBE)
 		acpi_osd_debugger();
 #endif
 	/*
 	 * Scan the namespace and build our device tree.
 	 */
 	acpi_build_tree(sc);
 	acpi_sleep_init(sc);
 #ifdef ACPI_DEBUGGER
 	if (acpi_dbgr & ACPI_DBGR_RUNNING)
 		acpi_osd_debugger();
 #endif
 #ifdef ACPI_DEBUG
 	acpi_debug_init();
 #endif
 	return;
 fail:
 	KASSERT(rv != AE_OK);
 	aprint_error("%s: failed to initialize ACPI: %s\n",
 	    __func__, AcpiFormatException(rv));
+}
 /*
  * XXX: This is incomplete.
  */
 static int
 acpi_detach(device_t self, int flags)
+{
 	struct acpi_softc *sc = device_private(self);
 	ACPI_STATUS rv;
 	int rc;
 	rv = AcpiRemoveNotifyHandler(ACPI_ROOT_OBJECT,
 	    ACPI_SYSTEM_NOTIFY, acpi_notify_handler);
 	if (ACPI_FAILURE(rv))
 		return EBUSY;
 	rv = AcpiRemoveNotifyHandler(ACPI_ROOT_OBJECT,
 	    ACPI_DEVICE_NOTIFY, acpi_notify_handler);
 	if (ACPI_FAILURE(rv))
 		return EBUSY;
 	if ((rc = config_detach_children(self, flags)) != 0)
 		return rc;
 	if ((rc = acpitimer_detach()) != 0)
 		return rc;
 	acpi_deregister_fixed_button(sc, ACPI_EVENT_POWER_BUTTON);
 	acpi_deregister_fixed_button(sc, ACPI_EVENT_SLEEP_BUTTON);
 	pmf_device_deregister(self);
 	acpi_softc = NULL;
 	return 0;
+}
 /*
  * XXX: Need to reclaim any resources? Yes.
  */
 static void
 acpi_childdet(device_t self, device_t child)
+{
 	struct acpi_softc *sc = device_private(self);
 	struct acpi_devnode *ad;
 	if (sc->sc_apmbus == child)
 		sc->sc_apmbus = NULL;
 	SIMPLEQ_FOREACH(ad, &sc->ad_head, ad_list) {
 		if (ad->ad_device == child)
 			ad->ad_device = NULL;
+	}
+}
 static bool
 acpi_suspend(device_t dv, const pmf_qual_t *qual)
+{
 	acpi_suspended = 1;
 	return true;
+}
 static bool
 acpi_resume(device_t dv, const pmf_qual_t *qual)
+{
 	acpi_suspended = 0;
 	return true;
+}
 /*
  * Namespace scan.
  */
 static void
 acpi_build_tree(struct acpi_softc *sc)
+{
 	struct acpi_walkcontext awc;
 	/*
 	 * Get the root scope handles.
 	 */
 	KASSERT(__arraycount(acpi_scopes) == 4);
 	(void)AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_PR_", &acpi_scopes[0]);
 	(void)AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_SB_", &acpi_scopes[1]);
 	(void)AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_SI_", &acpi_scopes[2]);
 	(void)AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_TZ_", &acpi_scopes[3]);
 	/*
 	 * Make the root node.
 	 */
 	awc.aw_sc = sc;
 	awc.aw_parent = NULL;
 	(void)acpi_make_devnode(ACPI_ROOT_OBJECT, 0, &awc, NULL);
 	KASSERT(sc->sc_root == NULL);
 	KASSERT(awc.aw_parent != NULL);
 	sc->sc_root = awc.aw_parent;
 	/*
 	 * Build the internal namespace.
 	 */
 	(void)AcpiWalkNamespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, UINT32_MAX,
 	    acpi_make_devnode, acpi_make_devnode_post, &awc, NULL);
 	/*
 	 * Scan the internal namespace.
 	 */
 	(void)acpi_rescan(sc->sc_dev, NULL, NULL);
 	acpi_rescan_capabilities(sc);
 	(void)acpi_pcidev_scan(sc->sc_root);
 	acpi_print_devnodes(sc);
 	acpi_print_tree(sc->sc_root, 0);
+}
 static ACPI_STATUS
 acpi_make_devnode(ACPI_HANDLE handle, uint32_t level,
     void *context, void **status)
+{
 	struct acpi_walkcontext *awc = context;
 	struct acpi_softc *sc = awc->aw_sc;
 	struct acpi_devnode *ad;
 	ACPI_DEVICE_INFO *devinfo;
 	ACPI_OBJECT_TYPE type;
 	ACPI_NAME_UNION *anu;
 	ACPI_STATUS rv;
 	int clear, i;
 	rv = AcpiGetObjectInfo(handle, &devinfo);
 	if (ACPI_FAILURE(rv))
 		return AE_OK;	/* Do not terminate the walk. */
 	type = devinfo->Type;
 	switch (type) {
 	case ACPI_TYPE_DEVICE:
 #ifdef ACPI_ACTIVATE_DEV
 		acpi_activate_device(handle, &devinfo);
 #endif
 	case ACPI_TYPE_PROCESSOR:
 	case ACPI_TYPE_THERMAL:
 	case ACPI_TYPE_POWER:
 		ad = malloc(sizeof(*ad), M_ACPI, M_NOWAIT | M_ZERO);
 		if (ad == NULL)
 			return AE_NO_MEMORY;
 		ad->ad_device = NULL;
 		ad->ad_notify = NULL;
 		ad->ad_pciinfo = NULL;
 		ad->ad_type = type;
 		ad->ad_handle = handle;
 		ad->ad_devinfo = devinfo;
 		ad->ad_root = sc->sc_dev;
 		ad->ad_parent = awc->aw_parent;
 		anu = (ACPI_NAME_UNION *)&devinfo->Name;
 		ad->ad_name[4] = '\0';
 		for (i = 3, clear = 0; i >= 0; i--) {
 			if (clear == 0 && anu->Ascii[i] == '_')
 				ad->ad_name[i] = '\0';
 			else {
 				ad->ad_name[i] = anu->Ascii[i];
 				clear = 1;
+			}
+		}
 		if (ad->ad_name[0] == '\0')
 			ad->ad_name[0] = '_';
 		SIMPLEQ_INIT(&ad->ad_child_head);
 		SIMPLEQ_INSERT_TAIL(&sc->ad_head, ad, ad_list);
 		acpi_set_node(ad);
 		if (ad->ad_parent != NULL) {
 			SIMPLEQ_INSERT_TAIL(&ad->ad_parent->ad_child_head,
 			    ad, ad_child_list);
+		}
 		awc->aw_parent = ad;
+	}
 	return AE_OK;
+}
 static ACPI_STATUS
 acpi_make_devnode_post(ACPI_HANDLE handle, uint32_t level,
     void *context, void **status)
+{
 	struct acpi_walkcontext *awc = context;
 	KASSERT(awc != NULL);
 	KASSERT(awc->aw_parent != NULL);
 	if (handle == awc->aw_parent->ad_handle)
 		awc->aw_parent = awc->aw_parent->ad_parent;
 	return AE_OK;
+}
 #ifdef ACPI_ACTIVATE_DEV
 static void
 acpi_activate_device(ACPI_HANDLE handle, ACPI_DEVICE_INFO **di)
+{
 	static const int valid = ACPI_VALID_STA | ACPI_VALID_HID;
 	ACPI_DEVICE_INFO *newdi;
 	ACPI_STATUS rv;
 	uint32_t old;
 	/*
 	 * If the device is valid and present,
 	 * but not enabled, try to activate it.
 	 */
 	if (((*di)->Valid & valid) != valid)
 		return;
 	old = (*di)->CurrentStatus;
 	if ((old & (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED)) !=
 	    ACPI_STA_DEVICE_PRESENT)
 		return;
 	rv = acpi_allocate_resources(handle);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	rv = AcpiGetObjectInfo(handle, &newdi);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	ACPI_FREE(*di);
 	*di = newdi;
 	aprint_verbose_dev(acpi_softc->sc_dev,
 	    "%s activated, STA 0x%08X -> STA 0x%08X\n",
 	    (*di)->HardwareId.String, old, (*di)->CurrentStatus);
 	return;
 fail:
 	aprint_error_dev(acpi_softc->sc_dev, "failed to "
 	    "activate %s\n", (*di)->HardwareId.String);
+}
 /*
  * XXX: This very incomplete.
  */
 ACPI_STATUS
 acpi_allocate_resources(ACPI_HANDLE handle)
+{
 	ACPI_BUFFER bufp, bufc, bufn;
 	ACPI_RESOURCE *resp, *resc, *resn;
 	ACPI_RESOURCE_IRQ *irq;
 	ACPI_RESOURCE_EXTENDED_IRQ *xirq;
 	ACPI_STATUS rv;
 	uint delta;
 	rv = acpi_get(handle, &bufp, AcpiGetPossibleResources);
 	if (ACPI_FAILURE(rv))
 		goto out;
 	rv = acpi_get(handle, &bufc, AcpiGetCurrentResources);
 	if (ACPI_FAILURE(rv)) {
 		goto out1;
+	}
 	bufn.Length = 1000;
 	bufn.Pointer = resn = malloc(bufn.Length, M_ACPI, M_WAITOK);
 	resp = bufp.Pointer;
 	resc = bufc.Pointer;
 	while (resc->Type != ACPI_RESOURCE_TYPE_END_TAG &&
 	       resp->Type != ACPI_RESOURCE_TYPE_END_TAG) {
 		while (resc->Type != resp->Type && resp->Type != ACPI_RESOURCE_TYPE_END_TAG)
 			resp = ACPI_NEXT_RESOURCE(resp);
 		if (resp->Type == ACPI_RESOURCE_TYPE_END_TAG)
 			break;
 		/* Found identical Id */
 		resn->Type = resc->Type;
 		switch (resc->Type) {
 		case ACPI_RESOURCE_TYPE_IRQ:
 			memcpy(&resn->Data, &resp->Data,
 			       sizeof(ACPI_RESOURCE_IRQ));
 			irq = (ACPI_RESOURCE_IRQ *)&resn->Data;
 			irq->Interrupts[0] =
 			    ((ACPI_RESOURCE_IRQ *)&resp->Data)->
 			        Interrupts[irq->InterruptCount-1];
 			irq->InterruptCount = 1;
 			resn->Length = ACPI_RS_SIZE(ACPI_RESOURCE_IRQ);
 			break;
 		case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 			memcpy(&resn->Data, &resp->Data,
 			       sizeof(ACPI_RESOURCE_EXTENDED_IRQ));
 			xirq = (ACPI_RESOURCE_EXTENDED_IRQ *)&resn->Data;
 #if 0
 			/*
 			 * XXX:	Not duplicating the interrupt logic above
 			 *	because its not clear what it accomplishes.
 			 */
 			xirq->Interrupts[0] =
 			    ((ACPI_RESOURCE_EXT_IRQ *)&resp->Data)->
 			    Interrupts[irq->NumberOfInterrupts-1];
 			xirq->NumberOfInterrupts = 1;
 #endif
 			resn->Length = ACPI_RS_SIZE(ACPI_RESOURCE_EXTENDED_IRQ);
 			break;
 		case ACPI_RESOURCE_TYPE_IO:
 			memcpy(&resn->Data, &resp->Data,
 			       sizeof(ACPI_RESOURCE_IO));
 			resn->Length = resp->Length;
 			break;
 		default:
 			aprint_error_dev(acpi_softc->sc_dev,
 			    "%s: invalid type %u\n", __func__, resc->Type);
 			rv = AE_BAD_DATA;
 			goto out2;
+		}
 		resc = ACPI_NEXT_RESOURCE(resc);
 		resn = ACPI_NEXT_RESOURCE(resn);
 		resp = ACPI_NEXT_RESOURCE(resp);
 		delta = (uint8_t *)resn - (uint8_t *)bufn.Pointer;
 		if (delta >=
 		    bufn.Length-ACPI_RS_SIZE(ACPI_RESOURCE_DATA)) {
 			bufn.Length *= 2;
 			bufn.Pointer = realloc(bufn.Pointer, bufn.Length,
 					       M_ACPI, M_WAITOK);
 			resn = (ACPI_RESOURCE *)((uint8_t *)bufn.Pointer +
 			    delta);
+		}
+	}
 	if (resc->Type != ACPI_RESOURCE_TYPE_END_TAG) {
 		aprint_error_dev(acpi_softc->sc_dev,
 		    "%s: resc not exhausted\n", __func__);
 		rv = AE_BAD_DATA;
 		goto out3;
+	}
 	resn->Type = ACPI_RESOURCE_TYPE_END_TAG;
 	rv = AcpiSetCurrentResources(handle, &bufn);
 	if (ACPI_FAILURE(rv))
 		aprint_error_dev(acpi_softc->sc_dev, "%s: failed to set "
 		    "resources: %s\n", __func__, AcpiFormatException(rv));
 out3:
 	free(bufn.Pointer, M_ACPI);
 out2:
 	ACPI_FREE(bufc.Pointer);
 out1:
 	ACPI_FREE(bufp.Pointer);
 out:
 	return rv;
+}
 #endif /* ACPI_ACTIVATE_DEV */
 /*
  * Device attachment.
  */
 static int
 acpi_rescan(device_t self, const char *ifattr, const int *locators)
+{
 	struct acpi_softc *sc = device_private(self);
 	if (ifattr_match(ifattr, "acpinodebus"))
 		acpi_rescan_nodes(sc);
 	if (ifattr_match(ifattr, "acpiapmbus") && sc->sc_apmbus == NULL)
 		sc->sc_apmbus = config_found_ia(sc->sc_dev,
 		    "acpiapmbus", NULL, NULL);
 	return 0;
+}
 static void
 acpi_rescan_nodes(struct acpi_softc *sc)
+{
 	struct acpi_attach_args aa;
 	struct acpi_devnode *ad;
 	ACPI_DEVICE_INFO *di;
 	SIMPLEQ_FOREACH(ad, &sc->ad_head, ad_list) {
 		if (ad->ad_device != NULL)
 			continue;
 		/*
 		 * There is a bug in ACPICA: it defines the type
 		 * of the scopes incorrectly for its own reasons.
 		 */
 		if (acpi_is_scope(ad) != false)
 			continue;
 		di = ad->ad_devinfo;
 		/*
 		 * We only attach devices which are present, enabled, and
 		 * functioning properly. However, if a device is enabled,
 		 * it is decoding resources and we should claim these,
 		 * if possible. This requires changes to bus_space(9).
 		 */
 		if (di->Type == ACPI_TYPE_DEVICE) {
 			if ((di->Valid & ACPI_VALID_STA) != 0 &&
 			    (di->CurrentStatus & ACPI_STA_OK) != ACPI_STA_OK)
 				continue;
+		}
 		/*
 		 * The same problem as above. As for example
 		 * thermal zones and power resources do not
 		 * have a valid HID, only evaluate devices.
 		 */
 		if (di->Type == ACPI_TYPE_DEVICE &&
 		   (di->Valid & ACPI_VALID_HID) == 0)
 			continue;
 		/*
 		 * Handled internally.
 		 */
 		if (di->Type == ACPI_TYPE_POWER)
 			continue;
 		/*
 		 * Skip ignored HIDs.
 		 */
 		if (acpi_match_hid(di, acpi_ignored_ids))
 			continue;
 		aa.aa_node = ad;
 		aa.aa_iot = sc->sc_iot;
 		aa.aa_memt = sc->sc_memt;
 		aa.aa_pc = sc->sc_pc;
 		aa.aa_pciflags = sc->sc_pciflags;
 		aa.aa_ic = sc->sc_ic;
 		ad->ad_device = config_found_ia(sc->sc_dev,
 		    "acpinodebus", &aa, acpi_print);
+	}
+}
 static void
 acpi_rescan_capabilities(struct acpi_softc *sc)
+{
 	struct acpi_devnode *ad;
 	ACPI_HANDLE tmp;
 	ACPI_STATUS rv;
 	SIMPLEQ_FOREACH(ad, &sc->ad_head, ad_list) {
 		if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE)
 			continue;
 		/*
 		 * Scan power resource capabilities.
+		 *
 		 * If any power states are supported,
 		 * at least _PR0 and _PR3 must be present.
 		 */
 		rv = AcpiGetHandle(ad->ad_handle, "_PR0", &tmp);
 		if (ACPI_SUCCESS(rv)) {
 			ad->ad_flags |= ACPI_DEVICE_POWER;
 			acpi_power_add(ad);
+		}
 		/*
 		 * Scan wake-up capabilities.
 		 */
 		rv = AcpiGetHandle(ad->ad_handle, "_PRW", &tmp);
 		if (ACPI_SUCCESS(rv)) {
 			ad->ad_flags |= ACPI_DEVICE_WAKEUP;
 			acpi_wakedev_add(ad);
+		}
+	}
+}
 static int
 acpi_print(void *aux, const char *pnp)
+{
 	struct acpi_attach_args *aa = aux;
 	ACPI_STATUS rv;
 	if (pnp) {
 		if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_HID) {
 			char *pnpstr =
 			    aa->aa_node->ad_devinfo->HardwareId.String;
 			ACPI_BUFFER buf;
 			aprint_normal("%s (%s) ", aa->aa_node->ad_name,
 			    pnpstr);
 			rv = acpi_eval_struct(aa->aa_node->ad_handle,
 			    "_STR", &buf);
 			if (ACPI_SUCCESS(rv)) {
 				ACPI_OBJECT *obj = buf.Pointer;
 				switch (obj->Type) {
 				case ACPI_TYPE_STRING:
 					aprint_normal("[%s] ", obj->String.Pointer);
 					break;
 				case ACPI_TYPE_BUFFER:
 					aprint_normal("buffer %p ", obj->Buffer.Pointer);
 					break;
 				default:
 					aprint_normal("type %u ",obj->Type);
 					break;
+				}
 				ACPI_FREE(buf.Pointer);
+			}
 			else
 				acpi_print_dev(pnpstr);
 			aprint_normal("at %s", pnp);
 		} else if (aa->aa_node->ad_devinfo->Type != ACPI_TYPE_DEVICE) {
 			aprint_normal("%s (ACPI Object Type '%s' "
 			    "[0x%02x]) ", aa->aa_node->ad_name,
 			     AcpiUtGetTypeName(aa->aa_node->ad_devinfo->Type),
 			     aa->aa_node->ad_devinfo->Type);
 			aprint_normal("at %s", pnp);
 		} else
 			return 0;
 	} else {
 		aprint_normal(" (%s", aa->aa_node->ad_name);
 		if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_HID) {
 			aprint_normal(", %s", aa->aa_node->ad_devinfo->HardwareId.String);
 			if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_UID) {
 				const char *uid;
 				uid = aa->aa_node->ad_devinfo->UniqueId.String;
 				if (uid[0] == '\0')
 					uid = "<null>";
 				aprint_normal("-%s", uid);
+			}
+		}
 		aprint_normal(")");
+	}
 	return UNCONF;
+}
 /*
  * Notify.
  */
 static void
 acpi_notify_handler(ACPI_HANDLE handle, uint32_t event, void *aux)
+{
 	struct acpi_softc *sc = acpi_softc;
 	struct acpi_devnode *ad;
 	KASSERT(sc != NULL);
 	KASSERT(aux == NULL);
 	KASSERT(acpi_active != 0);
 	if (acpi_suspended != 0)
 		return;
 	/*
 	 *  System: 0x00 - 0x7F.
 	 *  Device: 0x80 - 0xFF.
 	 */
 	switch (event) {
 	case ACPI_NOTIFY_BUS_CHECK:
 	case ACPI_NOTIFY_DEVICE_CHECK:
 	case ACPI_NOTIFY_DEVICE_WAKE:
 	case ACPI_NOTIFY_EJECT_REQUEST:
 	case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
 	case ACPI_NOTIFY_FREQUENCY_MISMATCH:
 	case ACPI_NOTIFY_BUS_MODE_MISMATCH:
 	case ACPI_NOTIFY_POWER_FAULT:
 	case ACPI_NOTIFY_CAPABILITIES_CHECK:
 	case ACPI_NOTIFY_DEVICE_PLD_CHECK:
 	case ACPI_NOTIFY_RESERVED:
 	case ACPI_NOTIFY_LOCALITY_UPDATE:
 		break;
+	}
 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "notification 0x%02X for "
 		"%s (%p)\n", event, acpi_name(handle), handle));
 	/*
 	 * We deliver notifications only to drivers
 	 * that have been succesfully attached and
 	 * that have registered a handler with us.
 	 * The opaque pointer is always the device_t.
 	 */
 	SIMPLEQ_FOREACH(ad, &sc->ad_head, ad_list) {
 		if (ad->ad_device == NULL)
 			continue;
 		if (ad->ad_notify == NULL)
 			continue;
 		if (ad->ad_handle != handle)
 			continue;
 		(*ad->ad_notify)(ad->ad_handle, event, ad->ad_device);
 		return;
+	}
 	aprint_debug_dev(sc->sc_dev, "unhandled notify 0x%02X "
 	    "for %s (%p)\n", event, acpi_name(handle), handle);
+}
 bool
 acpi_register_notify(struct acpi_devnode *ad, ACPI_NOTIFY_HANDLER notify)
+{
 	struct acpi_softc *sc = acpi_softc;

 @@ -1,800 +1,800 @@
-/* $NetBSD: acpi_power.c,v 1.21 2010/07/01 09:28:37 jruoho Exp $ */
+/* $NetBSD: acpi_power.c,v 1.22 2010/08/06 18:10:40 jruoho Exp $ */
 /*-
  * Copyright (c) 2009, 2010 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jukka Ruohonen.
+ *
  * 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.
  */
 /*-
  * Copyright (c) 2001 Michael Smith
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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: acpi_power.c,v 1.21 2010/07/01 09:28:37 jruoho Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi_power.c,v 1.22 2010/08/06 18:10:40 jruoho Exp $");
 #include <sys/param.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 #include <sys/sysctl.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_power.h>
 #define _COMPONENT			ACPI_BUS_COMPONENT
 ACPI_MODULE_NAME			("acpi_power")
 #define	ACPI_STA_POW_OFF		0x00
 #define	ACPI_STA_POW_ON			0x01
 /*
  * References.
  */
 struct acpi_power_ref {
 	ACPI_HANDLE			ref_handle;
 	SIMPLEQ_ENTRY(acpi_power_ref)	ref_list;
 };
 /*
  * Resources.
  */
 struct acpi_power_res {
 	ACPI_HANDLE			res_handle;
 	ACPI_INTEGER			res_level;
 	ACPI_INTEGER			res_order;
 	char				res_name[5];
 	kmutex_t			res_mutex;
 	TAILQ_ENTRY(acpi_power_res)	res_list;
 	SIMPLEQ_HEAD(, acpi_power_ref)	ref_head;
 };
 static TAILQ_HEAD(, acpi_power_res) res_head =
 	TAILQ_HEAD_INITIALIZER(res_head);
 static const struct sysctlnode	*anode = NULL;
 static struct acpi_power_res	*acpi_power_res_init(ACPI_HANDLE);
 static struct acpi_power_res	*acpi_power_res_get(ACPI_HANDLE);
 static ACPI_STATUS	 acpi_power_get_direct(struct acpi_devnode *);
 static ACPI_STATUS	 acpi_power_get_indirect(struct acpi_devnode *);
 static ACPI_STATUS	 acpi_power_switch(struct acpi_devnode *,
 						   int, bool);
 static ACPI_STATUS	 acpi_power_res_ref(struct acpi_power_res *,
 					    ACPI_HANDLE);
 static ACPI_STATUS	 acpi_power_res_deref(struct acpi_power_res *,
 					      ACPI_HANDLE);
 static ACPI_STATUS	 acpi_power_res_sta(ACPI_OBJECT *, void *);
 static ACPI_OBJECT	*acpi_power_pkg_get(ACPI_HANDLE, int);
-static int		 acpi_power_sysctl(SYSCTLFN_ARGS);
+static int		 acpi_power_sysctl(SYSCTLFN_PROTO);
 static const char	*acpi_xname(ACPI_HANDLE);
 static struct acpi_power_res *
 acpi_power_res_init(ACPI_HANDLE hdl)
+{
 	struct acpi_power_res *tmp = NULL;
 	struct acpi_power_res *res = NULL;
 	ACPI_OBJECT *obj;
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	rv = acpi_eval_struct(hdl, NULL, &buf);
 	if (ACPI_FAILURE(rv))
 		goto out;
 	obj = buf.Pointer;
 	if (obj->Type != ACPI_TYPE_POWER) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	res = kmem_zalloc(sizeof(*res), KM_SLEEP);
 	if (res == NULL) {
 		rv = AE_NO_MEMORY;
 		goto out;
+	}
 	res->res_handle = hdl;
 	res->res_level = obj->PowerResource.SystemLevel;
 	res->res_order = obj->PowerResource.ResourceOrder;
 	(void)strlcpy(res->res_name,
 	    acpi_xname(hdl), sizeof(res->res_name));
 	SIMPLEQ_INIT(&res->ref_head);
 	mutex_init(&res->res_mutex, MUTEX_DEFAULT, IPL_NONE);
 	/*
 	 * Power resources should be ordered.
+	 *
 	 * These *should* be enabled from low values to high
 	 * values and disabled from high values to low values.
 	 */
 	TAILQ_FOREACH(tmp, &res_head, res_list) {
 		if (res->res_order < tmp->res_order) {
 			TAILQ_INSERT_BEFORE(tmp, res, res_list);
 			break;
+		}
+	}
 	if (tmp == NULL)
 		TAILQ_INSERT_TAIL(&res_head, res, res_list);
 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s added to the "
 		"power resource queue\n", res->res_name));
 out:
 	if (buf.Pointer != NULL)
 		ACPI_FREE(buf.Pointer);
 	return res;
+}
 static struct acpi_power_res *
 acpi_power_res_get(ACPI_HANDLE hdl)
+{
 	struct acpi_power_res *res;
 	TAILQ_FOREACH(res, &res_head, res_list) {
 		if (res->res_handle == hdl)
 			return res;
+	}
 	return acpi_power_res_init(hdl);
+}
 bool
 acpi_power_register(ACPI_HANDLE hdl)
+{
 	struct acpi_devnode *ad = acpi_get_node(hdl);
 	if (ad == NULL)
 		return false;
 	if ((ad->ad_flags & ACPI_DEVICE_POWER) == 0)
 		return false;
 	return true;
+}
 void
 acpi_power_deregister(ACPI_HANDLE hdl)
+{
 	struct acpi_devnode *ad = acpi_get_node(hdl);
 	struct acpi_power_res *res;
 	if (ad == NULL)
 		return;
 	if ((ad->ad_flags & ACPI_DEVICE_POWER) == 0)
 		return;
 	/*
 	 * Remove all references in each resource.
 	 */
 	TAILQ_FOREACH(res, &res_head, res_list)
 	    (void)acpi_power_res_deref(res, ad->ad_handle);
+}
 /*
  * Get the D-state of an ACPI device node.
  */
 bool
 acpi_power_get(ACPI_HANDLE hdl, int *state)
+{
 	struct acpi_devnode *ad = acpi_get_node(hdl);
 	ACPI_STATUS rv;
 	if (ad == NULL)
 		return false;
 	if ((ad->ad_flags & ACPI_DEVICE_POWER) == 0) {
 		rv = AE_SUPPORT;
 		goto fail;
+	}
 	/*
 	 * Because the _PSC control method, like _STA,
 	 * is known to be implemented incorrectly in
 	 * some systems, we first try to retrieve the
 	 * power state indirectly via power resources.
 	 */
 	rv = acpi_power_get_indirect(ad);
 	if (ACPI_FAILURE(rv))
 		rv = acpi_power_get_direct(ad);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	KASSERT(ad->ad_state != ACPI_STATE_ERROR);
 	if (ad->ad_state < ACPI_STATE_D0 || ad->ad_state > ACPI_STATE_D3) {
 		rv = AE_BAD_VALUE;
 		goto fail;
+	}
 	if (state != NULL)
 		*state = ad->ad_state;
 	return true;
 fail:
 	ad->ad_state = ACPI_STATE_ERROR;
 	if (state != NULL)
 		*state = ad->ad_state;
 	aprint_error_dev(ad->ad_root, "failed to get power state "
 	    "for %s: %s\n", ad->ad_name, AcpiFormatException(rv));
 	return false;
+}
 static ACPI_STATUS
 acpi_power_get_direct(struct acpi_devnode *ad)
+{
 	ACPI_INTEGER val = 0;
 	ACPI_STATUS rv;
 	rv = acpi_eval_integer(ad->ad_handle, "_PSC", &val);
 	KDASSERT((uint64_t)val < INT_MAX);
 	ad->ad_state = (int)val;
 	return rv;
+}
 static ACPI_STATUS
 acpi_power_get_indirect(struct acpi_devnode *ad)
+{
 	ACPI_OBJECT *pkg;
 	ACPI_STATUS rv;
 	int i;
 	CTASSERT(ACPI_STATE_D0 == 0 && ACPI_STATE_D1 == 1);
 	CTASSERT(ACPI_STATE_D2 == 2 && ACPI_STATE_D3 == 3);
 	/*
 	 * The device is in a given D-state if all resources are on.
 	 * To derive this, evaluate all elements in each _PRx package
 	 * (x = 0 ... 3) and break if the noted condition becomes true.
 	 */
 	for (ad->ad_state = ACPI_STATE_D3, i = 0; i < ACPI_STATE_D3; i++) {
 		pkg = acpi_power_pkg_get(ad->ad_handle, i);
 		if (pkg == NULL)
 			continue;
 		/*
 		 * For each element in the _PRx package, evaluate _STA
 		 * and return AE_OK only if all power resources are on.
 		 */
 		rv = acpi_foreach_package_object(pkg, acpi_power_res_sta, ad);
 		if (ACPI_FAILURE(rv) && rv != AE_CTRL_FALSE)
 			goto out;
 		if (ACPI_SUCCESS(rv)) {
 			ad->ad_state = i;
 			goto out;
+		}
 		ACPI_FREE(pkg); pkg = NULL;
+	}
 	KASSERT(ad->ad_state == ACPI_STATE_D3);
 	return AE_OK;
 out:
 	ACPI_FREE(pkg);
 	return rv;
+}
 /*
  * Set the D-state of an ACPI device node.
  */
 bool
 acpi_power_set(ACPI_HANDLE hdl, int state)
+{
 	struct acpi_devnode *ad = acpi_get_node(hdl);
 	ACPI_STATUS rv;
 	char path[5];
 	int old;
 	if (ad == NULL)
 		return false;
 	if ((ad->ad_flags & ACPI_DEVICE_POWER) == 0) {
 		rv = AE_SUPPORT;
 		goto fail;
+	}
 	if (state < ACPI_STATE_D0 || state > ACPI_STATE_D3) {
 		rv = AE_BAD_PARAMETER;
 		goto fail;
+	}
 	if (acpi_power_get(ad->ad_handle, &old) != true) {
 		rv = AE_NOT_FOUND;
 		goto fail;
+	}
 	KASSERT(ad->ad_state == old);
 	KASSERT(ad->ad_state != ACPI_STATE_ERROR);
 	if (ad->ad_state == state) {
 		rv = AE_ALREADY_EXISTS;
 		goto fail;
+	}
 	/*
 	 * It is only possible to go to D0 ("on") from D3 ("off").
 	 */
 	if (ad->ad_state == ACPI_STATE_D3 && state != ACPI_STATE_D0) {
 		rv = AE_BAD_PARAMETER;
 		goto fail;
+	}
 	/*
 	 * As noted in ACPI 4.0 (appendix A.2.1), the bus power state
 	 * should never be lower than the highest state of one of its
 	 * devices. Consequently, we cannot set the state to a lower
 	 * (i.e. higher power) state than the parent device's state.
 	 */
 	if ((ad->ad_parent != NULL) &&
 	    (ad->ad_parent->ad_flags & ACPI_DEVICE_POWER) != 0) {
 		if (ad->ad_parent->ad_state > state) {
 			rv = AE_ABORT_METHOD;
 			goto fail;
+		}
+	}
 	/*
 	 * We first sweep through the resources required for the target
 	 * state, turning things on and building references. After this
 	 * we dereference the resources required for the current state,
 	 * turning the resources off as we go.
 	 */
 	rv = acpi_power_switch(ad, state, true);
 	if (ACPI_FAILURE(rv) && rv != AE_CTRL_CONTINUE)
 		goto fail;
 	rv = acpi_power_switch(ad, ad->ad_state, false);
 	if (ACPI_FAILURE(rv) && rv != AE_CTRL_CONTINUE)
 		goto fail;
 	/*
 	 * Last but not least, invoke the power state switch method,
 	 * if available. Because some systems use only _PSx for the
 	 * power state transitions, we do this even if there is no _PRx.
 	 */
 	(void)snprintf(path, sizeof(path), "_PS%d", state);
 	(void)AcpiEvaluateObject(ad->ad_handle, path, NULL, NULL);
 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s turned from "
 		"D%d to D%d\n", ad->ad_name, old, state));
 	ad->ad_state = state;
 	return true;
 fail:
 	ad->ad_state = ACPI_STATE_ERROR;
 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "failed to set power state to D%d "
 		"for %s: %s\n", state, ad->ad_name, AcpiFormatException(rv)));
 	return false;
+}
 static ACPI_STATUS
 acpi_power_switch(struct acpi_devnode *ad, int state, bool on)
+{
 	ACPI_OBJECT *elm, *pkg;
 	ACPI_STATUS rv = AE_OK;
 	ACPI_HANDLE hdl;
 	uint32_t i, n;
 	/*
 	 * For each element in the _PRx package, fetch
 	 * the reference handle, search for this handle
 	 * from the power resource queue, and turn the
 	 * resource behind the handle on or off.
 	 */
 	pkg = acpi_power_pkg_get(ad->ad_handle, state);
 	if (pkg == NULL)
 		return AE_CTRL_CONTINUE;
 	n = pkg->Package.Count;
 	for (i = 0; i < n; i++) {
 		elm = &pkg->Package.Elements[i];
 		rv = acpi_eval_reference_handle(elm, &hdl);
 		if (ACPI_FAILURE(rv))
 			continue;
 		(void)acpi_power_res(hdl, ad->ad_handle, on);
+	}
 	ACPI_FREE(pkg);
 	return rv;
+}
 ACPI_STATUS
 acpi_power_res(ACPI_HANDLE hdl, ACPI_HANDLE ref, bool on)
+{
 	struct acpi_power_res *res;
 	const char *str;
 	ACPI_STATUS rv;
 	/*
 	 * Search for the resource.
 	 */
 	res = acpi_power_res_get(hdl);
 	if (res == NULL)
 		return AE_NOT_FOUND;
 	/*
 	 * (De)reference the resource.
 	 */
 	switch (on) {
 	case true:
 		rv = acpi_power_res_ref(res, ref);
 		str = "_ON";
 		break;
 	case false:
 		rv = acpi_power_res_deref(res, ref);
 		str = "_OFF";
 		break;
 	default:
 		return AE_BAD_PARAMETER;
+	}
 	if (ACPI_FAILURE(rv))
 		return rv;
 	/*
 	 * Turn the resource on or off.
 	 */
 	return AcpiEvaluateObject(res->res_handle, str, NULL, NULL);
+}
 static ACPI_STATUS
 acpi_power_res_ref(struct acpi_power_res *res, ACPI_HANDLE hdl)
+{
 	struct acpi_power_ref *ref, *tmp;
 	ref = kmem_zalloc(sizeof(*ref), KM_SLEEP);
 	if (ref == NULL)
 		return AE_NO_MEMORY;
 	mutex_enter(&res->res_mutex);
 	SIMPLEQ_FOREACH(tmp, &res->ref_head, ref_list) {
 		if (tmp->ref_handle == hdl)
 			goto out;
+	}
 	ref->ref_handle = hdl;
 	SIMPLEQ_INSERT_TAIL(&res->ref_head, ref, ref_list);
 	mutex_exit(&res->res_mutex);
 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s referenced "
 		"by %s\n", res->res_name, acpi_xname(hdl)));
 	return AE_OK;
 out:
 	mutex_exit(&res->res_mutex);
 	kmem_free(ref, sizeof(*ref));
 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s already referenced "
 		"by %s?\n", res->res_name, acpi_xname(hdl)));
 	return AE_OK;
+}
 static ACPI_STATUS
 acpi_power_res_deref(struct acpi_power_res *res, ACPI_HANDLE hdl)
+{
 	struct acpi_power_ref *ref;
 	mutex_enter(&res->res_mutex);
 	if (SIMPLEQ_EMPTY(&res->ref_head) != 0) {
 		mutex_exit(&res->res_mutex);
 		return AE_OK;
+	}
 	SIMPLEQ_FOREACH(ref, &res->ref_head, ref_list) {
 		if (ref->ref_handle == hdl) {
 			SIMPLEQ_REMOVE(&res->ref_head,
 			    ref, acpi_power_ref, ref_list);
 			mutex_exit(&res->res_mutex);
 			kmem_free(ref, sizeof(*ref));
 			mutex_enter(&res->res_mutex);
 			break;
+		}
+	}
 	/*
 	 * If the queue remains non-empty,
 	 * something else is using the resource
 	 * and hence it can not be turned off.
 	 */
 	if (SIMPLEQ_EMPTY(&res->ref_head) == 0) {
 		mutex_exit(&res->res_mutex);
 		return AE_ABORT_METHOD;
+	}
 	mutex_exit(&res->res_mutex);
 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s dereferenced "
 		"by %s\n", res->res_name, acpi_xname(hdl)));
 	return AE_OK;
+}
 static ACPI_STATUS
 acpi_power_res_sta(ACPI_OBJECT *elm, void *arg)
+{
 	ACPI_INTEGER val;
 	ACPI_HANDLE hdl;
 	ACPI_STATUS rv;
 	rv = acpi_eval_reference_handle(elm, &hdl);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	rv = acpi_eval_integer(hdl, "_STA", &val);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	KDASSERT((uint64_t)val < INT_MAX);
 	if ((int)val != ACPI_STA_POW_ON && (int)val != ACPI_STA_POW_OFF)
 		return AE_BAD_VALUE;
 	if ((int)val != ACPI_STA_POW_ON)
 		return AE_CTRL_FALSE;		/* XXX: Not an error. */
 	return AE_OK;
 fail:
 	if (rv == AE_CTRL_FALSE)
 		rv = AE_ERROR;
 	ACPI_DEBUG_PRINT((ACPI_DB_DEBUG_OBJECT, "failed to evaluate _STA "
 		"for %s: %s\n", acpi_xname(hdl), AcpiFormatException(rv)));
 	return rv;
+}
 static ACPI_OBJECT *
 acpi_power_pkg_get(ACPI_HANDLE hdl, int state)
+{
 	char path[5] = "_PR?";
 	ACPI_OBJECT *obj;
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	path[3] = '0' + state;
 	rv = acpi_eval_struct(hdl, path, &buf);
 	if (ACPI_FAILURE(rv))
 		goto fail;
 	if (buf.Length == 0) {
 		rv = AE_LIMIT;
 		goto fail;
+	}
 	obj = buf.Pointer;
 	if (obj->Type != ACPI_TYPE_PACKAGE) {
 		rv = AE_TYPE;
 		goto fail;
+	}
 	if (obj->Package.Count == 0) {
 		rv = AE_LIMIT;
 		goto fail;
+	}
 	return obj;
 fail:
 	if (buf.Pointer != NULL)
 		ACPI_FREE(buf.Pointer);
 	ACPI_DEBUG_PRINT((ACPI_DB_DEBUG_OBJECT, "failed to evaluate %s for "
 		"%s: %s\n", path, acpi_xname(hdl), AcpiFormatException(rv)));
 	return NULL;
+}
 SYSCTL_SETUP(sysctl_acpi_power_setup, "sysctl hw.acpi.power subtree setup")
+{
 	int err;
 	err = sysctl_createv(NULL, 0, NULL, &anode,
 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw",
 	    NULL, NULL, 0, NULL, 0,
 	    CTL_HW, CTL_EOL);
 	if (err != 0)
 		goto fail;
 	err = sysctl_createv(NULL, 0, &anode, &anode,
 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "acpi",
 	    NULL, NULL, 0, NULL, 0,
 	    CTL_CREATE, CTL_EOL);
 	if (err != 0)
 		goto fail;
 	err = sysctl_createv(NULL, 0, &anode, &anode,
 	    CTLFLAG_PERMANENT, CTLTYPE_NODE,
 	    "power", SYSCTL_DESCR("ACPI device power states"),
 	    NULL, 0, NULL, 0,
 	    CTL_CREATE, CTL_EOL);
 	if (err != 0)
 		goto fail;
 	return;
 fail:
 	anode = NULL;
+}
 void
 acpi_power_add(struct acpi_devnode *ad)
+{
 	int err;
 	KASSERT(ad != NULL && ad->ad_root != NULL);
 	KASSERT((ad->ad_flags & ACPI_DEVICE_POWER) != 0);
 	if (anode == NULL)
 		return;
 	/*
 	 * Make this read-only: because a single power resource
 	 * may power multiple devices, it is unclear whether
 	 * power resources should be controllable by an user.
 	 */
 	err = sysctl_createv(NULL, 0, &anode, NULL,
 	    CTLFLAG_READONLY, CTLTYPE_STRING, ad->ad_name,
 	    NULL, acpi_power_sysctl, 0, ad, 0,
 	    CTL_CREATE, CTL_EOL);
 	if (err != 0)
 		aprint_error_dev(ad->ad_root, "sysctl_createv"
 		    "(hw.acpi.power.%s) failed (err %d)\n", ad->ad_name, err);
+}
 static int
 acpi_power_sysctl(SYSCTLFN_ARGS)
+{
 	struct acpi_devnode *ad;
 	struct sysctlnode node;
 	int err, state;
 	char t[3];
 	node = *rnode;
 	ad = rnode->sysctl_data;
 	if (acpi_power_get(ad->ad_handle, &state) != true)
 		state = 0;
 	(void)memset(t, '\0', sizeof(t));
 	(void)snprintf(t, sizeof(t), "D%d", state);
 	node.sysctl_data = &t;
 	err = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (err || newp == NULL)
 		return err;
 	return 0;
+}
 /*
  * XXX: Move this to acpi_util.c by refactoring
  *	acpi_name() to optionally return a single name.
  */
 static const char *
 acpi_xname(ACPI_HANDLE hdl)
+{
 	static char str[5];
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	buf.Pointer = str;
 	buf.Length = sizeof(str);
 	rv = AcpiGetName(hdl, ACPI_SINGLE_NAME, &buf);
 	if (ACPI_FAILURE(rv))
 		return "????";
 	return str;
+}