 @@ -1,836 +1,846 @@
-/*	$NetBSD: acpi_bat.c,v 1.106 2011/01/04 05:48:48 jruoho Exp $	*/
+/*	$NetBSD: acpi_bat.c,v 1.107 2011/01/09 09:47:55 jruoho Exp $	*/
 /*-
  * Copyright (c) 2003 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 Bill Sommerfeld.
  * 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 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.
  */
 /*
  * ACPI Battery Driver.
+ *
  * ACPI defines two different battery device interfaces: "Control
  * Method" batteries, in which AML methods are defined in order to get
  * battery status and set battery alarm thresholds, and a "Smart
  * Battery" device, which is an SMbus device accessed through the ACPI
  * Embedded Controller device.
+ *
  * This driver is for the "Control Method"-style battery only.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: acpi_bat.c,v 1.106 2011/01/04 05:48:48 jruoho Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi_bat.c,v 1.107 2011/01/09 09:47:55 jruoho Exp $");
 #include <sys/param.h>
 #include <sys/condvar.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 #include <sys/mutex.h>
 #include <sys/systm.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #define _COMPONENT		 ACPI_BAT_COMPONENT
 ACPI_MODULE_NAME		 ("acpi_bat")
 #define	ACPI_NOTIFY_BAT_STATUS	 0x80
 #define	ACPI_NOTIFY_BAT_INFO	 0x81
 /*
  * Sensor indexes.
  */
 enum {
 	ACPIBAT_PRESENT		 = 0,
 	ACPIBAT_DVOLTAGE	 = 1,
 	ACPIBAT_VOLTAGE		 = 2,
 	ACPIBAT_DCAPACITY	 = 3,
 	ACPIBAT_LFCCAPACITY	 = 4,
 	ACPIBAT_CAPACITY	 = 5,
 	ACPIBAT_CHARGERATE	 = 6,
 	ACPIBAT_DISCHARGERATE	 = 7,
 	ACPIBAT_CHARGING	 = 8,
 	ACPIBAT_CHARGE_STATE	 = 9,
 	ACPIBAT_COUNT		 = 10
 };
 /*
  * Battery Information, _BIF
  * (ACPI 3.0, sec. 10.2.2.1).
  */
 enum {
 	ACPIBAT_BIF_UNIT	 = 0,
 	ACPIBAT_BIF_DCAPACITY	 = 1,
 	ACPIBAT_BIF_LFCCAPACITY	 = 2,
 	ACPIBAT_BIF_TECHNOLOGY	 = 3,
 	ACPIBAT_BIF_DVOLTAGE	 = 4,
 	ACPIBAT_BIF_WCAPACITY	 = 5,
 	ACPIBAT_BIF_LCAPACITY	 = 6,
 	ACPIBAT_BIF_GRANULARITY1 = 7,
 	ACPIBAT_BIF_GRANULARITY2 = 8,
 	ACPIBAT_BIF_MODEL	 = 9,
 	ACPIBAT_BIF_SERIAL	 = 10,
 	ACPIBAT_BIF_TYPE	 = 11,
 	ACPIBAT_BIF_OEM		 = 12,
 	ACPIBAT_BIF_COUNT	 = 13
 };
 /*
  * Battery Status, _BST
  * (ACPI 3.0, sec. 10.2.2.3).
  */
 enum {
 	ACPIBAT_BST_STATE	 = 0,
 	ACPIBAT_BST_RATE	 = 1,
 	ACPIBAT_BST_CAPACITY	 = 2,
 	ACPIBAT_BST_VOLTAGE	 = 3,
 	ACPIBAT_BST_COUNT	 = 4
 };
 struct acpibat_softc {
 	struct acpi_devnode	*sc_node;
 	struct sysmon_envsys	*sc_sme;
 	envsys_data_t		*sc_sensor;
 	char			 sc_serial[64];
 	kmutex_t		 sc_mutex;
 	kcondvar_t		 sc_condvar;
 	int32_t			 sc_lcapacity;
 	int32_t			 sc_wcapacity;
 	int                      sc_present;
 };
 static const char * const bat_hid[] = {
 	"PNP0C0A",
 	NULL
 };
 #define ACPIBAT_PWRUNIT_MA	0x00000001  /* mA not mW */
 #define ACPIBAT_ST_DISCHARGING	0x00000001  /* battery is discharging */
 #define ACPIBAT_ST_CHARGING	0x00000002  /* battery is charging */
 #define ACPIBAT_ST_CRITICAL	0x00000004  /* battery is critical */
 /*
  * A value used when _BST or _BIF is temporarily unknown.
  */
 #define ACPIBAT_VAL_UNKNOWN	0xFFFFFFFF
 #define ACPIBAT_VAL_ISVALID(x)						      \
 	(((x) != ACPIBAT_VAL_UNKNOWN) ? ENVSYS_SVALID : ENVSYS_SINVALID)
 static int	    acpibat_match(device_t, cfdata_t, void *);
 static void	    acpibat_attach(device_t, device_t, void *);
 static int	    acpibat_detach(device_t, int);
 static int          acpibat_get_sta(device_t);
 static ACPI_OBJECT *acpibat_get_object(ACPI_HANDLE, const char *, uint32_t);
 static void         acpibat_get_info(device_t);
 static void	    acpibat_print_info(device_t, ACPI_OBJECT *);
 static void         acpibat_get_status(device_t);
 static void         acpibat_update_info(void *);
 static void         acpibat_update_status(void *);
 static void         acpibat_init_envsys(device_t);
 static void         acpibat_notify_handler(ACPI_HANDLE, uint32_t, void *);
 static void         acpibat_refresh(struct sysmon_envsys *, envsys_data_t *);
 static bool	    acpibat_resume(device_t, const pmf_qual_t *);
 static void	    acpibat_get_limits(struct sysmon_envsys *, envsys_data_t *,
 				       sysmon_envsys_lim_t *, uint32_t *);
 CFATTACH_DECL_NEW(acpibat, sizeof(struct acpibat_softc),
     acpibat_match, acpibat_attach, acpibat_detach, NULL);
 /*
  * acpibat_match:
+ *
  *	Autoconfiguration `match' routine.
  */
 static int
 acpibat_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct acpi_attach_args *aa = aux;
 	if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
 		return 0;
 	return acpi_match_hid(aa->aa_node->ad_devinfo, bat_hid);
+}
 /*
  * acpibat_attach:
+ *
  *	Autoconfiguration `attach' routine.
  */
 static void
 acpibat_attach(device_t parent, device_t self, void *aux)
+{
 	struct acpibat_softc *sc = device_private(self);
 	struct acpi_attach_args *aa = aux;
 	ACPI_HANDLE tmp;
 	ACPI_STATUS rv;
 	aprint_naive(": ACPI Battery\n");
 	aprint_normal(": ACPI Battery\n");
 	sc->sc_node = aa->aa_node;
 	sc->sc_present = 0;
 	sc->sc_lcapacity = 0;
 	sc->sc_wcapacity = 0;
 	sc->sc_sme = NULL;
 	sc->sc_sensor = NULL;
 	mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&sc->sc_condvar, device_xname(self));
 	(void)pmf_device_register(self, NULL, acpibat_resume);
 	(void)memset(sc->sc_serial, '\0', sizeof(sc->sc_serial));
 	(void)acpi_register_notify(sc->sc_node, acpibat_notify_handler);
 	sc->sc_sensor = kmem_zalloc(ACPIBAT_COUNT *
 	    sizeof(*sc->sc_sensor), KM_SLEEP);
 	if (sc->sc_sensor == NULL)
 		return;
 	acpibat_init_envsys(self);
 	/*
 	 * If this is ever seen, the driver should be extended.
 	 */
 	rv = AcpiGetHandle(sc->sc_node->ad_handle, "_BIX", &tmp);
 	if (ACPI_SUCCESS(rv))
 		aprint_verbose_dev(self, "ACPI 4.0 functionality present\n");
+}
 /*
  * acpibat_detach:
+ *
  *	Autoconfiguration `detach' routine.
  */
 static int
 acpibat_detach(device_t self, int flags)
+{
 	struct acpibat_softc *sc = device_private(self);
 	acpi_deregister_notify(sc->sc_node);
 	cv_destroy(&sc->sc_condvar);
 	mutex_destroy(&sc->sc_mutex);
 	if (sc->sc_sme != NULL)
 		sysmon_envsys_unregister(sc->sc_sme);
 	if (sc->sc_sensor != NULL)
 		kmem_free(sc->sc_sensor, ACPIBAT_COUNT *
 		    sizeof(*sc->sc_sensor));
 	pmf_device_deregister(self);
 	return 0;
+}
 /*
  * acpibat_get_sta:
+ *
  *	Evaluate whether the battery is present or absent.
+ *
  *	Returns: 0 for no battery, 1 for present, and -1 on error.
  */
 static int
 acpibat_get_sta(device_t dv)
+{
 	struct acpibat_softc *sc = device_private(dv);
 	ACPI_INTEGER val;
 	ACPI_STATUS rv;
 	rv = acpi_eval_integer(sc->sc_node->ad_handle, "_STA", &val);
 	if (ACPI_FAILURE(rv)) {
 		aprint_error_dev(dv, "failed to evaluate _STA\n");
 		return -1;
+	}
 	sc->sc_sensor[ACPIBAT_PRESENT].state = ENVSYS_SVALID;
 	if ((val & ACPI_STA_BATTERY_PRESENT) == 0) {
 		sc->sc_sensor[ACPIBAT_PRESENT].value_cur = 0;
 		return 0;
+	}
 	sc->sc_sensor[ACPIBAT_PRESENT].value_cur = 1;
 	return 1;
+}
 static ACPI_OBJECT *
 acpibat_get_object(ACPI_HANDLE hdl, const char *pth, uint32_t count)
+{
 	ACPI_OBJECT *obj;
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	rv = acpi_eval_struct(hdl, pth, &buf);
 	if (ACPI_FAILURE(rv))
 		return NULL;
 	obj = buf.Pointer;
 	if (obj->Type != ACPI_TYPE_PACKAGE) {
 		ACPI_FREE(buf.Pointer);
 		return NULL;
+	}
 	if (obj->Package.Count != count) {
 		ACPI_FREE(buf.Pointer);
 		return NULL;
+	}
 	return obj;
+}
 /*
  * acpibat_get_info:
+ *
  * 	Get the battery info.
  */
 static void
 acpibat_get_info(device_t dv)
+{
 	struct acpibat_softc *sc = device_private(dv);
 	ACPI_HANDLE hdl = sc->sc_node->ad_handle;
 	ACPI_OBJECT *elm, *obj;
 	ACPI_STATUS rv = AE_OK;
 	int capunit, i, rateunit;
 	uint64_t val;
 	obj = acpibat_get_object(hdl, "_BIF", ACPIBAT_BIF_COUNT);
 	if (obj == NULL) {
 		rv = AE_ERROR;
 		goto out;
+	}
 	elm = obj->Package.Elements;
 	for (i = ACPIBAT_BIF_UNIT; i < ACPIBAT_BIF_MODEL; i++) {
 		if (elm[i].Type != ACPI_TYPE_INTEGER) {
 			rv = AE_TYPE;
 			goto out;
+		}
 		KDASSERT((uint64_t)elm[i].Integer.Value < INT_MAX);
+	}
 	if ((elm[ACPIBAT_BIF_UNIT].Integer.Value & ACPIBAT_PWRUNIT_MA) != 0) {
 		capunit = ENVSYS_SAMPHOUR;
 		rateunit = ENVSYS_SAMPS;
 	} else {
 		capunit = ENVSYS_SWATTHOUR;
 		rateunit = ENVSYS_SWATTS;
+	}
 	sc->sc_sensor[ACPIBAT_DCAPACITY].units = capunit;
 	sc->sc_sensor[ACPIBAT_LFCCAPACITY].units = capunit;
 	sc->sc_sensor[ACPIBAT_CHARGERATE].units = rateunit;
 	sc->sc_sensor[ACPIBAT_DISCHARGERATE].units = rateunit;
 	sc->sc_sensor[ACPIBAT_CAPACITY].units = capunit;
 	/* Design capacity. */
 	val = elm[ACPIBAT_BIF_DCAPACITY].Integer.Value;
 	sc->sc_sensor[ACPIBAT_DCAPACITY].value_cur = val * 1000;
 	sc->sc_sensor[ACPIBAT_DCAPACITY].state = ACPIBAT_VAL_ISVALID(val);
 	/* Last full charge capacity. */
 	val = elm[ACPIBAT_BIF_LFCCAPACITY].Integer.Value;
 	sc->sc_sensor[ACPIBAT_LFCCAPACITY].value_cur = val * 1000;
 	sc->sc_sensor[ACPIBAT_LFCCAPACITY].state = ACPIBAT_VAL_ISVALID(val);
 	/* Design voltage. */
 	val = elm[ACPIBAT_BIF_DVOLTAGE].Integer.Value;
 	sc->sc_sensor[ACPIBAT_DVOLTAGE].value_cur = val * 1000;
 	sc->sc_sensor[ACPIBAT_DVOLTAGE].state = ACPIBAT_VAL_ISVALID(val);
 	/* Design low and warning capacity. */
 	sc->sc_lcapacity = elm[ACPIBAT_BIF_LCAPACITY].Integer.Value * 1000;
 	sc->sc_wcapacity = elm[ACPIBAT_BIF_WCAPACITY].Integer.Value * 1000;
 	/*
 	 * Initialize the maximum of current capacity
 	 * to the last known full charge capacity.
 	 */
 	val = sc->sc_sensor[ACPIBAT_LFCCAPACITY].value_cur;
 	sc->sc_sensor[ACPIBAT_CAPACITY].value_max = val;
 	acpibat_print_info(dv, elm);
 out:
 	if (obj != NULL)
 		ACPI_FREE(obj);
 	if (ACPI_FAILURE(rv))
 		aprint_error_dev(dv, "failed to evaluate _BIF: %s\n",
 		    AcpiFormatException(rv));
+}
 /*
  * acpibat_print_info:
+ *
  * 	Display the battery info.
  */
 static void
 acpibat_print_info(device_t dv, ACPI_OBJECT *elm)
+{
 	struct acpibat_softc *sc = device_private(dv);
 	const char *model, *serial, *tech, *unit;
 	int i;
 	for (i = ACPIBAT_BIF_OEM; i > ACPIBAT_BIF_GRANULARITY2; i--) {
 		if (elm[i].Type != ACPI_TYPE_STRING)
 			return;
 		if (elm[i].String.Pointer == NULL)
 			return;
 		if (elm[i].String.Pointer[0] == '\0')
 			return;
+	}
 	model = elm[ACPIBAT_BIF_MODEL].String.Pointer;
 	serial = elm[ACPIBAT_BIF_SERIAL].String.Pointer;
 	if (elm[ACPIBAT_BIF_SERIAL].String.Length > sizeof(sc->sc_serial))
 		return;
 	if (sc->sc_serial[0] == '\0')
 		(void)strlcpy(sc->sc_serial, serial, sizeof(sc->sc_serial));
 	else {
 		if (strcmp(sc->sc_serial, serial) == 0)
 			return;
 		(void)memset(sc->sc_serial, '\0', sizeof(sc->sc_serial));
 		(void)strlcpy(sc->sc_serial, serial, sizeof(sc->sc_serial));
+	}
 	tech = (elm[ACPIBAT_BIF_TECHNOLOGY].Integer.Value != 0) ?
 	    "rechargeable" : "non-rechargeable";
 	aprint_normal_dev(dv, "%s %s %s battery\n",
 	    elm[ACPIBAT_BIF_OEM].String.Pointer,
 	    elm[ACPIBAT_BIF_TYPE].String.Pointer, tech);
 	aprint_verbose_dev(dv, "model number %s, serial number %s\n",
 	    model, serial);
 #define SCALE(x) (((int)x) / 1000000), ((((int)x) % 1000000) / 1000)
 	/*
 	 * These values are defined as follows (ACPI 4.0, p. 388):
+	 *
 	 * Granularity 1.	"Battery capacity granularity between low
 	 *			 and warning in [mAh] or [mWh]. That is,
 	 *			 this is the smallest increment in capacity
 	 *			 that the battery is capable of measuring."
+	 *
 	 * Granularity 2.	"Battery capacity granularity between warning
 	 *			 and full in [mAh] or [mWh]. [...]"
 	 */
 	if ((elm[ACPIBAT_BIF_UNIT].Integer.Value & ACPIBAT_PWRUNIT_MA) != 0)
 		unit = "Ah";
 	else
 		unit = "Wh";
 	aprint_verbose_dev(dv, "granularity: "
 	    "low->warn %d.%03d %s, warn->full %d.%03d %s\n",
 	    SCALE(elm[ACPIBAT_BIF_GRANULARITY1].Integer.Value * 1000), unit,
 	    SCALE(elm[ACPIBAT_BIF_GRANULARITY2].Integer.Value * 1000), unit);
+}
 /*
  * acpibat_get_status:
+ *
  *	Get the current battery status.
  */
 static void
 acpibat_get_status(device_t dv)
+{
 	struct acpibat_softc *sc = device_private(dv);
 	ACPI_HANDLE hdl = sc->sc_node->ad_handle;
 	ACPI_OBJECT *elm, *obj;
 	ACPI_STATUS rv = AE_OK;
 	int i, rate, state;
 	uint64_t val;
 	obj = acpibat_get_object(hdl, "_BST", ACPIBAT_BST_COUNT);
 	if (obj == NULL) {
 		rv = AE_ERROR;
 		goto out;
+	}
 	elm = obj->Package.Elements;
 	for (i = ACPIBAT_BST_STATE; i < ACPIBAT_BST_COUNT; i++) {
 		if (elm[i].Type != ACPI_TYPE_INTEGER) {
 			rv = AE_TYPE;
 			goto out;
+		}
+	}
 	state = elm[ACPIBAT_BST_STATE].Integer.Value;
 	if ((state & ACPIBAT_ST_CHARGING) != 0) {
 		/* XXX rate can be invalid */
 		rate = elm[ACPIBAT_BST_RATE].Integer.Value;
 		sc->sc_sensor[ACPIBAT_CHARGERATE].state = ENVSYS_SVALID;
 		sc->sc_sensor[ACPIBAT_CHARGERATE].value_cur = rate * 1000;
 		sc->sc_sensor[ACPIBAT_DISCHARGERATE].state = ENVSYS_SINVALID;
 		sc->sc_sensor[ACPIBAT_CHARGING].state = ENVSYS_SVALID;
 		sc->sc_sensor[ACPIBAT_CHARGING].value_cur = 1;
 	} else if ((state & ACPIBAT_ST_DISCHARGING) != 0) {
 		rate = elm[ACPIBAT_BST_RATE].Integer.Value;
 		sc->sc_sensor[ACPIBAT_DISCHARGERATE].state = ENVSYS_SVALID;
 		sc->sc_sensor[ACPIBAT_DISCHARGERATE].value_cur = rate * 1000;
 		sc->sc_sensor[ACPIBAT_CHARGERATE].state = ENVSYS_SINVALID;
 		sc->sc_sensor[ACPIBAT_CHARGING].state = ENVSYS_SVALID;
 		sc->sc_sensor[ACPIBAT_CHARGING].value_cur = 0;
 	} else {
 		sc->sc_sensor[ACPIBAT_CHARGING].state = ENVSYS_SVALID;
 		sc->sc_sensor[ACPIBAT_CHARGING].value_cur = 0;
 		sc->sc_sensor[ACPIBAT_CHARGERATE].state = ENVSYS_SINVALID;
 		sc->sc_sensor[ACPIBAT_DISCHARGERATE].state = ENVSYS_SINVALID;
+	}
 	/* Remaining capacity. */
 	val = elm[ACPIBAT_BST_CAPACITY].Integer.Value;
 	sc->sc_sensor[ACPIBAT_CAPACITY].value_cur = val * 1000;
 	sc->sc_sensor[ACPIBAT_CAPACITY].state = ACPIBAT_VAL_ISVALID(val);
 	/* Battery voltage. */
 	val = elm[ACPIBAT_BST_VOLTAGE].Integer.Value;
 	sc->sc_sensor[ACPIBAT_VOLTAGE].value_cur = val * 1000;
 	sc->sc_sensor[ACPIBAT_VOLTAGE].state = ACPIBAT_VAL_ISVALID(val);
 	sc->sc_sensor[ACPIBAT_CHARGE_STATE].state = ENVSYS_SVALID;
 	sc->sc_sensor[ACPIBAT_CHARGE_STATE].value_cur =
 	    ENVSYS_BATTERY_CAPACITY_NORMAL;
 	if (sc->sc_sensor[ACPIBAT_CAPACITY].value_cur < sc->sc_wcapacity) {
 		sc->sc_sensor[ACPIBAT_CAPACITY].state = ENVSYS_SWARNUNDER;
 		sc->sc_sensor[ACPIBAT_CHARGE_STATE].value_cur =
 		    ENVSYS_BATTERY_CAPACITY_WARNING;
+	}
 	if (sc->sc_sensor[ACPIBAT_CAPACITY].value_cur < sc->sc_lcapacity) {
 		sc->sc_sensor[ACPIBAT_CAPACITY].state = ENVSYS_SCRITUNDER;
 		sc->sc_sensor[ACPIBAT_CHARGE_STATE].value_cur =
 		    ENVSYS_BATTERY_CAPACITY_LOW;
+	}
 	if ((state & ACPIBAT_ST_CRITICAL) != 0) {
 		sc->sc_sensor[ACPIBAT_CAPACITY].state = ENVSYS_SCRITICAL;
 		sc->sc_sensor[ACPIBAT_CHARGE_STATE].value_cur =
 		    ENVSYS_BATTERY_CAPACITY_CRITICAL;
+	}
 out:
 	if (obj != NULL)
 		ACPI_FREE(obj);
 	if (ACPI_FAILURE(rv))
 		aprint_error_dev(dv, "failed to evaluate _BST: %s\n",
 		    AcpiFormatException(rv));
+}
 static void
 acpibat_update_info(void *arg)
+{
 	device_t dv = arg;
 	struct acpibat_softc *sc = device_private(dv);
 	int i, rv;
 	mutex_enter(&sc->sc_mutex);
 	rv = acpibat_get_sta(dv);
 	if (rv > 0) {
 		acpibat_get_info(dv);
 		/*
 		 * If the status changed, update the limits.
 		 */
 		if (sc->sc_present == 0 &&
 		    sc->sc_sensor[ACPIBAT_CAPACITY].value_max > 0)
 			sysmon_envsys_update_limits(sc->sc_sme,
 			    &sc->sc_sensor[ACPIBAT_CAPACITY]);
 	} else {
 		i = (rv < 0) ? 0 : ACPIBAT_DVOLTAGE;
 		while (i < ACPIBAT_COUNT) {
 			sc->sc_sensor[i].state = ENVSYS_SINVALID;
 			i++;
+		}
+	}
 	sc->sc_present = rv;
 	mutex_exit(&sc->sc_mutex);
+}
 static void
 acpibat_update_status(void *arg)
+{
 	device_t dv = arg;
 	struct acpibat_softc *sc = device_private(dv);
 	int i, rv;
 	mutex_enter(&sc->sc_mutex);
 	rv = acpibat_get_sta(dv);
 	if (rv > 0) {
 		if (sc->sc_present == 0)
 			acpibat_get_info(dv);
 		acpibat_get_status(dv);
 	} else {
 		i = (rv < 0) ? 0 : ACPIBAT_DVOLTAGE;
 		while (i < ACPIBAT_COUNT) {
 			sc->sc_sensor[i].state = ENVSYS_SINVALID;
 			i++;
+		}
+	}
 	sc->sc_present = rv;
 	cv_broadcast(&sc->sc_condvar);
 	mutex_exit(&sc->sc_mutex);
+}
 /*
  * acpibat_notify_handler:
+ *
  *	Callback from ACPI interrupt handler to notify us of an event.
  */
 static void
 acpibat_notify_handler(ACPI_HANDLE handle, uint32_t notify, void *context)
+{
 	static const int handler = OSL_NOTIFY_HANDLER;
 	device_t dv = context;
 	switch (notify) {
 	case ACPI_NOTIFY_BUS_CHECK:
 		break;
 	case ACPI_NOTIFY_BAT_INFO:
 	case ACPI_NOTIFY_DEVICE_CHECK:
 		(void)AcpiOsExecute(handler, acpibat_update_info, dv);
 		break;
 	case ACPI_NOTIFY_BAT_STATUS:
 		(void)AcpiOsExecute(handler, acpibat_update_status, dv);
 		break;
 	default:
 		aprint_error_dev(dv, "unknown notify: 0x%02X\n", notify);
+	}
+}
 static void
 acpibat_init_envsys(device_t dv)
+{
 	struct acpibat_softc *sc = device_private(dv);
 	int i;
 #define INITDATA(index, unit, string)					\
 	do {								\
 		sc->sc_sensor[index].state = ENVSYS_SVALID;		\
 		sc->sc_sensor[index].units = unit;			\
 		(void)strlcpy(sc->sc_sensor[index].desc, string,	\
 		    sizeof(sc->sc_sensor[index].desc));			\
 	} while (/* CONSTCOND */ 0)
 	INITDATA(ACPIBAT_PRESENT, ENVSYS_INDICATOR, "present");
 	INITDATA(ACPIBAT_DCAPACITY, ENVSYS_SWATTHOUR, "design cap");
 	INITDATA(ACPIBAT_LFCCAPACITY, ENVSYS_SWATTHOUR, "last full cap");
 	INITDATA(ACPIBAT_DVOLTAGE, ENVSYS_SVOLTS_DC, "design voltage");
 	INITDATA(ACPIBAT_VOLTAGE, ENVSYS_SVOLTS_DC, "voltage");
 	INITDATA(ACPIBAT_CHARGERATE, ENVSYS_SWATTS, "charge rate");
 	INITDATA(ACPIBAT_DISCHARGERATE, ENVSYS_SWATTS, "discharge rate");
 	INITDATA(ACPIBAT_CAPACITY, ENVSYS_SWATTHOUR, "charge");
 	INITDATA(ACPIBAT_CHARGING, ENVSYS_BATTERY_CHARGE, "charging");
 	INITDATA(ACPIBAT_CHARGE_STATE, ENVSYS_BATTERY_CAPACITY, "charge state");
 #undef INITDATA
 	sc->sc_sensor[ACPIBAT_CAPACITY].flags |=
 	    ENVSYS_FPERCENT | ENVSYS_FVALID_MAX | ENVSYS_FMONLIMITS;
 	sc->sc_sensor[ACPIBAT_CHARGE_STATE].flags |= ENVSYS_FMONSTCHANGED;
 	/* Disable userland monitoring on these sensors. */
 	sc->sc_sensor[ACPIBAT_VOLTAGE].flags = ENVSYS_FMONNOTSUPP;
 	sc->sc_sensor[ACPIBAT_CHARGERATE].flags = ENVSYS_FMONNOTSUPP;
 	sc->sc_sensor[ACPIBAT_DISCHARGERATE].flags = ENVSYS_FMONNOTSUPP;
 	sc->sc_sensor[ACPIBAT_DCAPACITY].flags = ENVSYS_FMONNOTSUPP;
 	sc->sc_sensor[ACPIBAT_LFCCAPACITY].flags = ENVSYS_FMONNOTSUPP;
 	sc->sc_sensor[ACPIBAT_DVOLTAGE].flags = ENVSYS_FMONNOTSUPP;
 	sc->sc_sme = sysmon_envsys_create();
 	for (i = 0; i < ACPIBAT_COUNT; i++) {
 		if (sysmon_envsys_sensor_attach(sc->sc_sme,
 			&sc->sc_sensor[i]))
 			goto fail;
+	}
 	sc->sc_sme->sme_name = device_xname(dv);
 	sc->sc_sme->sme_cookie = dv;
 	sc->sc_sme->sme_refresh = acpibat_refresh;
 	sc->sc_sme->sme_class = SME_CLASS_BATTERY;
 	sc->sc_sme->sme_flags = SME_POLL_ONLY | SME_INIT_REFRESH;
 	sc->sc_sme->sme_get_limits = acpibat_get_limits;
 	acpibat_update_info(dv);
 	acpibat_update_status(dv);
 	if (sysmon_envsys_register(sc->sc_sme))
 		goto fail;
 	return;
 fail:
 	aprint_error_dev(dv, "failed to initialize sysmon\n");
 	sysmon_envsys_destroy(sc->sc_sme);
 	kmem_free(sc->sc_sensor, ACPIBAT_COUNT * sizeof(*sc->sc_sensor));
 	sc->sc_sme = NULL;
 	sc->sc_sensor = NULL;
+}
 static void
 acpibat_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
+{
 	device_t dv = sme->sme_cookie;
 	struct acpibat_softc *sc = device_private(dv);
 	ACPI_STATUS rv;
 	if (mutex_tryenter(&sc->sc_mutex) == 0)
 		return;
 	rv = AcpiOsExecute(OSL_NOTIFY_HANDLER, acpibat_update_status, dv);
 	if (ACPI_SUCCESS(rv))
 		cv_timedwait(&sc->sc_condvar, &sc->sc_mutex, hz);
 	mutex_exit(&sc->sc_mutex);
+}
 static bool
 acpibat_resume(device_t dv, const pmf_qual_t *qual)
+{
 	(void)AcpiOsExecute(OSL_NOTIFY_HANDLER, acpibat_update_info, dv);
 	(void)AcpiOsExecute(OSL_NOTIFY_HANDLER, acpibat_update_status, dv);
 	return true;
+}
 static void
 acpibat_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata,
     sysmon_envsys_lim_t *limits, uint32_t *props)
+{
 	device_t dv = sme->sme_cookie;
 	struct acpibat_softc *sc = device_private(dv);
 	if (edata->sensor != ACPIBAT_CAPACITY)
 		return;
 	limits->sel_critmin = sc->sc_lcapacity;
 	limits->sel_warnmin = sc->sc_wcapacity;
 	*props |= PROP_BATTCAP | PROP_BATTWARN | PROP_DRIVER_LIMITS;
+}
 #ifdef _MODULE
 MODULE(MODULE_CLASS_DRIVER, acpibat, NULL);
 #include "ioconf.c"
 static int
 acpibat_modcmd(modcmd_t cmd, void *context)
+{
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		return config_init_component(cfdriver_ioconf_acpibat,
 		    cfattach_ioconf_acpibat, cfdata_ioconf_acpibat);
 	case MODULE_CMD_FINI:
 		return config_fini_component(cfdriver_ioconf_acpibat,
 		    cfattach_ioconf_acpibat, cfdata_ioconf_acpibat);
 	default:
 		return ENOTTY;
+	}
+}
 #endif	/* _MODULE */