/* $NetBSD: acpi_bat.c,v 1.123 2024/04/27 00:40:06 christos Exp $ */

/* $NetBSD: acpi_bat.c,v 1.123 2024/04/27 00:40:06 christos 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.123 2024/04/27 00:40:06 christos 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;
struct timeval sc_last;
envsys_data_t *sc_sensor;
kmutex_t sc_mutex;
kcondvar_t sc_condvar;
int32_t sc_dcapacity;
int32_t sc_dvoltage;
int32_t sc_lcapacity;
int32_t sc_wcapacity;
int sc_present;
bool sc_dying;
};

static const struct device_compatible_entry compat_data[] = {
{ .compat = "PNP0C0A" },
DEVICE_COMPAT_EOL
};

#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;

return acpi_compatible_match(aa, compat_data);
}

/*
* 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;

mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);
cv_init(&sc->sc_condvar, device_xname(self));

sc->sc_sensor = kmem_zalloc(ACPIBAT_COUNT *
sizeof(*sc->sc_sensor), KM_SLEEP);

config_interrupts(self, acpibat_init_envsys);

/*
* 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);

/* Prevent further use of sc->sc_sme in acpibat_update_info. */
mutex_enter(&sc->sc_mutex);
sc->sc_dying = true;
mutex_exit(&sc->sc_mutex);

/* Prevent further calls to acpibat_resume. */
pmf_device_deregister(self);

/* Prevent further calls to acpibat_notify_handler. */
acpi_deregister_notify(sc->sc_node);

/* Detach sensors and prevent further calls to acpibat_refresh. */
if (sc->sc_sme != NULL)
sysmon_envsys_unregister(sc->sc_sme);

/*
* Wait for calls to acpibat_update_info/status in case sysmon
* envsys refreshed the sensors and queued them but they didn't
* run before sysmon_envsys_unregister. After this point, no
* asynchronous access to the softc is possible.
*/
AcpiOsWaitEventsComplete();

if (sc->sc_sensor != NULL)
kmem_free(sc->sc_sensor, ACPIBAT_COUNT *
sizeof(*sc->sc_sensor));

cv_destroy(&sc->sc_condvar);
mutex_destroy(&sc->sc_mutex);

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: %s\n",
AcpiFormatException(rv));
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;
}
if (elm[i].Integer.Value != ACPIBAT_VAL_UNKNOWN &&
elm[i].Integer.Value >= INT_MAX) {
rv = AE_LIMIT;
goto out;
}
}

switch (elm[ACPIBAT_BIF_UNIT].Integer.Value) {
case ACPIBAT_PWRUNIT_MA:
capunit = ENVSYS_SAMPHOUR;
rateunit = ENVSYS_SAMPS;
break;
default:
capunit = ENVSYS_SWATTHOUR;
rateunit = ENVSYS_SWATTS;
break;
}

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 *tech, *unit;
int32_t dcap, dvol;
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;
}

dcap = elm[ACPIBAT_BIF_DCAPACITY].Integer.Value;
dvol = elm[ACPIBAT_BIF_DVOLTAGE].Integer.Value;

/*
* Try to detect whether the battery was switched.
*/
if (sc->sc_dcapacity == dcap && sc->sc_dvoltage == dvol)
return;
else {
sc->sc_dcapacity = dcap;
sc->sc_dvoltage = dvol;
}

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_debug_dev(dv, "model number %s, serial number %s\n",
elm[ACPIBAT_BIF_MODEL].String.Pointer,
elm[ACPIBAT_BIF_SERIAL].String.Pointer);

#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]. [...]"
*/
switch (elm[ACPIBAT_BIF_UNIT].Integer.Value) {
case ACPIBAT_PWRUNIT_MA:
unit = "Ah";
break;
default:
unit = "Wh";
break;
}

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);

/* Don't touch sc_sme if we're detaching. */
if (sc->sc_dying)
goto out;

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;
out:
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;
microtime(&sc->sc_last);

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_CHARGE_STATE].value_cur =
ENVSYS_BATTERY_CAPACITY_NORMAL;

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;

/* Attach rnd(9) to the (dis)charge rates. */
sc->sc_sensor[ACPIBAT_CHARGERATE].flags |= ENVSYS_FHAS_ENTROPY;
sc->sc_sensor[ACPIBAT_DISCHARGERATE].flags |= ENVSYS_FHAS_ENTROPY;

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;
sc->sc_sme->sme_get_limits = acpibat_get_limits;

if (sysmon_envsys_register(sc->sc_sme))
goto fail;

(void)acpi_register_notify(sc->sc_node, acpibat_notify_handler);
acpibat_update_info(dv);
acpibat_update_status(dv);

(void)pmf_device_register(dv, NULL, acpibat_resume);

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 self = sme->sme_cookie;
struct acpibat_softc *sc;
struct timeval tv, tmp;
ACPI_STATUS rv;

sc = device_private(self);

tmp.tv_sec = 10;
tmp.tv_usec = 0;

microtime(&tv);
timersub(&tv, &tmp, &tv);
if (timercmp(&tv, &sc->sc_last, <) != 0)
return;

if (mutex_tryenter(&sc->sc_mutex) == 0)
return;

rv = AcpiOsExecute(OSL_NOTIFY_HANDLER, acpibat_update_status, self);
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;
}

MODULE(MODULE_CLASS_DRIVER, acpibat, "sysmon_envsys");

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
acpibat_modcmd(modcmd_t cmd, void *aux)
{
int rv = 0;

switch (cmd) {
case MODULE_CMD_INIT:
#ifdef _MODULE
rv = config_init_component(cfdriver_ioconf_acpibat,
cfattach_ioconf_acpibat, cfdata_ioconf_acpibat);
#endif
break;
case MODULE_CMD_FINI:
#ifdef _MODULE
rv = config_fini_component(cfdriver_ioconf_acpibat,
cfattach_ioconf_acpibat, cfdata_ioconf_acpibat);
#endif
break;
default:
rv = ENOTTY;
}

return rv;
}