/* $NetBSD: pbbat.c,v 1.2 2025/04/09 00:10:02 nat Exp $ */

/*-
 * Copyright (c) 2025 Nathanial Sloss <nathanialsloss@yahoo.com.au>
 * 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 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.
 */

/* Based on acpibat(4). */

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

/* AC Adaptor attachment and logic based on macppc/smartbat(4). */

/*-
 * Copyright (c) 2007 Michael Lorenz
 *               2008 Magnus Henoch
 * 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: pbbat.c,v 1.2 2025/04/09 00:10:02 nat Exp $");

#include <sys/param.h>
#include <sys/device.h>
#include <sys/kmem.h>
#include <sys/types.h>
#include <sys/systm.h>

#include <dev/sysmon/sysmonvar.h>

#include <machine/param.h>
#include <machine/cpu.h>

#include <mac68k/dev/pm_direct.h>

static int      pbbatmatch(device_t, cfdata_t, void *);
static void     pbbatattach(device_t, device_t, void *);

static void     bat_get_pm_limits(device_t);
static uint16_t bat_get_status(device_t);
static void     bat_init_envsys(device_t);
static void     bat_update_status(void *);

extern int      pm_pmgrop_pm1(PMData *);

struct pbatt_softc {
        device_t                 sc_dev;
        struct sysmon_envsys    *sc_ac_sme;
        envsys_data_t            sc_ac_sensor[1];
        struct sysmon_pswitch    sc_sm_acpower;
        int8_t                   sc_ac_state;
        struct sysmon_envsys    *sc_bat_sme;
        envsys_data_t           *sc_bat_sensor;
        struct timeval           sc_last;
        kmutex_t                 sc_mutex;
        int32_t                  sc_dcapacity;
        int32_t                  sc_dvoltage;
        int32_t                  sc_disrate;
        int32_t                  sc_chargerate;
        int32_t                  sc_empty;
        int32_t                  sc_lcapacity;
        int32_t                  sc_wcapacity;
        int                      sc_present;
};

#define PBBAT_AC_PRESENT         0

/* AC Adaptor states */
#define PBBAT_AC_UNKNOWN        -1
#define PBBAT_AC_DISCONNECTED    0
#define PBBAT_AC_CONNECTED       1

enum {
        PBBAT_PRESENT            = 0,
        PBBAT_DVOLTAGE           = 1,
        PBBAT_VOLTAGE            = 2,
        PBBAT_DCAPACITY          = 3,
        PBBAT_LFCCAPACITY        = 4,
        PBBAT_CAPACITY           = 5,
        PBBAT_CHARGERATE         = 6,
        PBBAT_DISCHARGERATE      = 7,
        PBBAT_CHARGING           = 8,
        PBBAT_CHARGE_STATE       = 9,
        PBBAT_COUNT              = 10
};

/* Driver definition */
CFATTACH_DECL_NEW(pbbat, sizeof(struct pbatt_softc),
    pbbatmatch, pbbatattach, NULL, NULL);

/* Battery voltage definitions (mV) */
#define VOLTS_DESIGN    6000
#define WATTS_DESIGN    60000   /* mW */
#define VOLTS_CHARGING  6600
#define VOLTS_NOBATT    7700

#define VOLTS_MULTI     35      /* PM value multiplier. */
#define LIMIT_SCALE     (100 * 100 / (VOLTS_DESIGN / 1000))

#define PM_BATT_VOLTS   0x68    /* 0x69 is a duplicate. */
#define PM_BATT_LIMITS  0x6a

static int
pbbatmatch(device_t parent, cfdata_t cf, void *aux)
{
        switch (mac68k_machine.machineid) {
                case MACH_MACPB140:
                case MACH_MACPB145:
                case MACH_MACPB160:
                case MACH_MACPB165:
                case MACH_MACPB165C:
                case MACH_MACPB170:
                case MACH_MACPB180:
                case MACH_MACPB180C:
                        return 1;
                        break;
                default:
                        return 0;
        }

        return 0;
}

static void
pbbatattach(device_t parent, device_t self, void *aux)
{
        struct pbatt_softc *sc = device_private(self);

        aprint_naive(": PowerBook Battery\n");
        aprint_normal(": PowerBook Battery\n");

        mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);
        sc->sc_bat_sensor = kmem_zalloc(PBBAT_COUNT *
            sizeof(*sc->sc_bat_sensor), KM_SLEEP);

        memset(&sc->sc_sm_acpower, 0, sizeof(struct sysmon_pswitch));
        sc->sc_ac_state = PBBAT_AC_UNKNOWN;
        sc->sc_sm_acpower.smpsw_name = "AC Power";
        sc->sc_sm_acpower.smpsw_type = PSWITCH_TYPE_ACADAPTER;
        if (sysmon_pswitch_register(&sc->sc_sm_acpower) != 0)
                printf("%s: unable to register AC power status with sysmon\n",
                    device_xname(sc->sc_dev));

        config_interrupts(self, bat_init_envsys);
}

static void
bat_get_pm_limits(device_t self)
{
        int s;
        int rval;
        PMData pmdata;
        struct pbatt_softc *sc = device_private(self);

        s = splhigh();

        pmdata.command = PM_BATT_LIMITS;
        pmdata.num_data = 0;
        pmdata.data[0] = pmdata.data[1] = 0;
        pmdata.s_buf = pmdata.data;
        pmdata.r_buf = pmdata.data;
        rval = pm_pmgrop_pm1(&pmdata);
        if (rval != 0) {
#ifdef ADB_DEBUG
                if (adb_debug)
                        printf("pm: PM is not ready. error code=%08x\n", rval);
#endif
                splx(s);
                return;
        }

        splx(s);

        sc->sc_empty = (pmdata.data[1] & 0xff) * VOLTS_MULTI;
        sc->sc_lcapacity = (pmdata.data[0] & 0xff) * VOLTS_MULTI;
        sc->sc_wcapacity = sc->sc_lcapacity * 12 / 10;

        return;
}

static uint16_t
bat_get_voltage(void)
{
        int s;
        int rval;
        PMData pmdata;

        s = splhigh();

        pmdata.command = PM_BATT_VOLTS;
        pmdata.num_data = 0;
        pmdata.data[0] = pmdata.data[1] = 0;
        pmdata.s_buf = pmdata.data;
        pmdata.r_buf = pmdata.data;
        rval = pm_pmgrop_pm1(&pmdata);
        if (rval != 0) {
#ifdef ADB_DEBUG
                if (adb_debug)
                        printf("pm: PM is not ready. error code=%08x\n", rval);
#endif
                splx(s);
                return 0;
        }

        splx(s);

        return (pmdata.data[1] & 0xff) * VOLTS_MULTI;
}

static void
bat_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
        device_t self = sme->sme_cookie;
        struct pbatt_softc *sc = device_private(self);
        struct timeval tv, tmp;

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

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

        bat_update_status(self);
}

static void
bat_refresh_ac(struct sysmon_envsys *sme, envsys_data_t *edata)
{
        struct pbatt_softc *sc = sme->sme_cookie;
        int which = edata->sensor;

        mutex_enter(&sc->sc_mutex);
        switch (which) {
                case PBBAT_AC_PRESENT:
                        edata->value_cur =
                            (sc->sc_ac_state == PBBAT_AC_CONNECTED ? 1 : 0);
                        edata->state = ENVSYS_SVALID;
                        break;
                default:
                        edata->value_cur = 0;
                        edata->state = ENVSYS_SINVALID;
        }
        mutex_exit(&sc->sc_mutex);
}

static void
bat_get_info(device_t dv)
{
        struct pbatt_softc *sc = device_private(dv);
        int capunit;

        capunit = ENVSYS_SWATTHOUR;

        sc->sc_bat_sensor[PBBAT_DCAPACITY].units = capunit;
        sc->sc_bat_sensor[PBBAT_CHARGERATE].units = capunit;
        sc->sc_bat_sensor[PBBAT_DISCHARGERATE].units = capunit;
        sc->sc_bat_sensor[PBBAT_LFCCAPACITY].units = capunit;
        sc->sc_bat_sensor[PBBAT_CAPACITY].units = capunit;

        /* Design capacity. */

        /*
         * This is a guesstimate - repacked battery runs at 10 Watts/h for an
         * 1 hour.
         */

        sc->sc_bat_sensor[PBBAT_DCAPACITY].value_cur = WATTS_DESIGN * 1000;
        sc->sc_bat_sensor[PBBAT_DCAPACITY].state = ENVSYS_SVALID;

        /* Design voltage. */
        sc->sc_bat_sensor[PBBAT_DVOLTAGE].value_cur = VOLTS_DESIGN * 1000;
        sc->sc_bat_sensor[PBBAT_DVOLTAGE].state = ENVSYS_SVALID;

        sc->sc_bat_sensor[PBBAT_LFCCAPACITY].state = ENVSYS_SINVALID;

        bat_get_pm_limits(dv);

        sc->sc_bat_sensor[PBBAT_CAPACITY].value_max = 100 * 1000 * 1000;
}

static void
bat_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata,
    sysmon_envsys_lim_t *limits, uint32_t *props)
{
        device_t self = sme->sme_cookie;
        struct pbatt_softc *sc = device_private(self);

        if (edata->sensor != PBBAT_CAPACITY)
                return;

        limits->sel_critmin = sc->sc_lcapacity * LIMIT_SCALE;
        limits->sel_warnmin = sc->sc_wcapacity * LIMIT_SCALE;

        *props |= PROP_BATTCAP | PROP_BATTWARN | PROP_DRIVER_LIMITS;
}

static void
bat_update_status(void *arg)
{
        device_t dv = arg;
        struct pbatt_softc *sc = device_private(dv);
        int i;
        uint16_t val;

        mutex_enter(&sc->sc_mutex);

        val = bat_get_status(dv);
        if (val != 0) {
                if (sc->sc_present == 0)
                        bat_get_info(dv);
        } else {
                i = PBBAT_DVOLTAGE;
                while (i < PBBAT_COUNT) {
                        sc->sc_bat_sensor[i].state = ENVSYS_SINVALID;
                        i++;
                }
        }

        sc->sc_present = (val >= VOLTS_NOBATT ? 0 : 1);

        microuptime(&sc->sc_last);

        mutex_exit(&sc->sc_mutex);
}

static void
bat_init_envsys(device_t dv)
{
        struct pbatt_softc *sc = device_private(dv);
        int i;

#define INITDATA(index, unit, string)                                   \
        sc->sc_ac_sensor[index].units = unit;                           \
        sc->sc_ac_sensor[index].state = ENVSYS_SINVALID;                \
        snprintf(sc->sc_ac_sensor[index].desc,                          \
            sizeof(sc->sc_ac_sensor[index].desc), "%s", string);

                INITDATA(PBBAT_AC_PRESENT, ENVSYS_INDICATOR, "connected");
#undef INITDATA

        sc->sc_ac_sme = sysmon_envsys_create();

        if (sysmon_envsys_sensor_attach(sc->sc_ac_sme, &sc->sc_ac_sensor[0])) {
                sysmon_envsys_destroy(sc->sc_ac_sme);
                return;
        }

        sc->sc_ac_sme->sme_name = "AC Adaptor";
        sc->sc_ac_sme->sme_cookie = sc;
        sc->sc_ac_sme->sme_refresh = bat_refresh_ac;
        sc->sc_ac_sme->sme_class = SME_CLASS_ACADAPTER;

        if (sysmon_envsys_register(sc->sc_ac_sme)) {
                aprint_error("%s: unable to register AC with sysmon\n",
                    device_xname(sc->sc_dev));
                sysmon_envsys_destroy(sc->sc_ac_sme);
        }

#define INITDATA(index, unit, string)                                   \
        do {                                                            \
                sc->sc_bat_sensor[index].state = ENVSYS_SVALID;         \
                sc->sc_bat_sensor[index].units = unit;                  \
                (void)strlcpy(sc->sc_bat_sensor[index].desc, string,    \
                    sizeof(sc->sc_bat_sensor[index].desc));                     \
        } while (/* CONSTCOND */ 0)

        INITDATA(PBBAT_PRESENT, ENVSYS_INDICATOR, "present");
        INITDATA(PBBAT_DCAPACITY, ENVSYS_SWATTHOUR, "design cap");
        INITDATA(PBBAT_LFCCAPACITY, ENVSYS_SWATTHOUR, "last full cap");
        INITDATA(PBBAT_DVOLTAGE, ENVSYS_SVOLTS_DC, "design voltage");
        INITDATA(PBBAT_VOLTAGE, ENVSYS_SVOLTS_DC, "voltage");
        INITDATA(PBBAT_CAPACITY, ENVSYS_SWATTHOUR, "charge");
        INITDATA(PBBAT_CHARGERATE, ENVSYS_SWATTS, "charge rate");
        INITDATA(PBBAT_DISCHARGERATE, ENVSYS_SWATTS, "discharge rate");
        INITDATA(PBBAT_CHARGING, ENVSYS_BATTERY_CHARGE, "charging");
        INITDATA(PBBAT_CHARGE_STATE, ENVSYS_BATTERY_CAPACITY, "charge state");

#undef INITDATA

        sc->sc_bat_sensor[PBBAT_CHARGE_STATE].value_cur =
                ENVSYS_BATTERY_CAPACITY_NORMAL;

        sc->sc_bat_sensor[PBBAT_CAPACITY].flags |=
            ENVSYS_FPERCENT | ENVSYS_FVALID_MAX | ENVSYS_FMONLIMITS;

        sc->sc_bat_sensor[PBBAT_CHARGE_STATE].flags |= ENVSYS_FMONSTCHANGED;

        /* Disable userland monitoring on these sensors. */
        sc->sc_bat_sensor[PBBAT_VOLTAGE].flags = ENVSYS_FMONNOTSUPP;
        sc->sc_bat_sensor[PBBAT_CHARGERATE].flags = ENVSYS_FMONNOTSUPP;
        sc->sc_bat_sensor[PBBAT_DISCHARGERATE].flags = ENVSYS_FMONNOTSUPP;
        sc->sc_bat_sensor[PBBAT_DCAPACITY].flags = ENVSYS_FMONNOTSUPP;
        sc->sc_bat_sensor[PBBAT_LFCCAPACITY].flags = ENVSYS_FMONNOTSUPP;
        sc->sc_bat_sensor[PBBAT_DVOLTAGE].flags = ENVSYS_FMONNOTSUPP;

        sc->sc_bat_sensor[PBBAT_CHARGERATE].flags |= ENVSYS_FHAS_ENTROPY;
        sc->sc_bat_sensor[PBBAT_DISCHARGERATE].flags |= ENVSYS_FHAS_ENTROPY;

        sc->sc_bat_sme = sysmon_envsys_create();

        for (i = 0; i < PBBAT_COUNT; i++) {
                if (sysmon_envsys_sensor_attach(sc->sc_bat_sme,
                        &sc->sc_bat_sensor[i]))
                        goto fail;
        }

        sc->sc_bat_sme->sme_name = device_xname(dv);
        sc->sc_bat_sme->sme_cookie = dv;
        sc->sc_bat_sme->sme_refresh = bat_refresh;
        sc->sc_bat_sme->sme_class = SME_CLASS_BATTERY;
        sc->sc_bat_sme->sme_flags = SME_POLL_ONLY;
        sc->sc_bat_sme->sme_get_limits = bat_get_limits;

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

        bat_get_pm_limits(dv);
        bat_update_status(dv);

        return;
fail:
        aprint_error("failed to initialize sysmon\n");

        sysmon_envsys_destroy(sc->sc_bat_sme);
        kmem_free(sc->sc_bat_sensor, PBBAT_COUNT * sizeof(*sc->sc_bat_sensor));

        sc->sc_bat_sme = NULL;
        sc->sc_bat_sensor = NULL;
}

static uint16_t
bat_get_status(device_t dv)
{
        struct pbatt_softc *sc = device_private(dv);
        uint16_t val;

        val = bat_get_voltage();

        sc->sc_bat_sensor[PBBAT_PRESENT].state = ENVSYS_SVALID;
        sc->sc_bat_sensor[PBBAT_PRESENT].value_cur = 1;

        if (val > VOLTS_NOBATT) {
                sc->sc_bat_sensor[PBBAT_PRESENT].value_cur = 0;
                sc->sc_bat_sensor[PBBAT_CHARGING].state = ENVSYS_SVALID;
                sc->sc_bat_sensor[PBBAT_CHARGING].value_cur = 0;
                sc->sc_bat_sensor[PBBAT_CHARGERATE].state = ENVSYS_SINVALID;
                sc->sc_bat_sensor[PBBAT_DISCHARGERATE].state = ENVSYS_SINVALID;
                if (sc->sc_ac_state != PBBAT_AC_CONNECTED) {
                        sysmon_pswitch_event(&sc->sc_sm_acpower,
                            PSWITCH_EVENT_PRESSED);
                }
                sc->sc_ac_state = PBBAT_AC_CONNECTED;
        } else if (val > VOLTS_CHARGING) {
                sc->sc_bat_sensor[PBBAT_CHARGING].state = ENVSYS_SVALID;
                if (sc->sc_chargerate)
                        sc->sc_bat_sensor[PBBAT_CHARGING].value_cur = 1;
                else
                        sc->sc_bat_sensor[PBBAT_CHARGING].value_cur = 0;
                sc->sc_bat_sensor[PBBAT_CHARGERATE].state = ENVSYS_SVALID;
                sc->sc_bat_sensor[PBBAT_CHARGERATE].value_cur =
                    sc->sc_chargerate;
                sc->sc_bat_sensor[PBBAT_DISCHARGERATE].state = ENVSYS_SINVALID;
                if (sc->sc_ac_state != PBBAT_AC_CONNECTED) {
                        sysmon_pswitch_event(&sc->sc_sm_acpower,
                            PSWITCH_EVENT_PRESSED);
                }
                sc->sc_ac_state = PBBAT_AC_CONNECTED;
        } else {
                sc->sc_bat_sensor[PBBAT_CHARGING].value_cur = 0;
                sc->sc_bat_sensor[PBBAT_CHARGING].state = ENVSYS_SVALID;
                sc->sc_bat_sensor[PBBAT_CHARGERATE].state = ENVSYS_SINVALID;
                sc->sc_bat_sensor[PBBAT_DISCHARGERATE].state = ENVSYS_SVALID;
                sc->sc_bat_sensor[PBBAT_DISCHARGERATE].value_cur =
                    sc->sc_disrate;
                if (sc->sc_ac_state != PBBAT_AC_DISCONNECTED) {
                        sysmon_pswitch_event(&sc->sc_sm_acpower,
                            PSWITCH_EVENT_RELEASED);
                }
                sc->sc_ac_state = PBBAT_AC_DISCONNECTED;
        }

        /* Remaining capacity. */
        sc->sc_chargerate = sc->sc_bat_sensor[PBBAT_CAPACITY].value_cur;
        sc->sc_disrate = sc->sc_bat_sensor[PBBAT_CAPACITY].value_cur;

        sc->sc_bat_sensor[PBBAT_CAPACITY].value_cur =
            (val - sc->sc_empty) * 10 * LIMIT_SCALE;

        sc->sc_chargerate =
            (sc->sc_bat_sensor[PBBAT_CAPACITY].value_cur - sc->sc_chargerate) * 10;
        sc->sc_disrate =
            (sc->sc_disrate - sc->sc_bat_sensor[PBBAT_CAPACITY].value_cur) * 10;

        /* Battery voltage. */
        sc->sc_bat_sensor[PBBAT_VOLTAGE].value_cur = val * 1000;
        sc->sc_bat_sensor[PBBAT_VOLTAGE].state =
            (val >= VOLTS_NOBATT ? ENVSYS_SINVALID : ENVSYS_SVALID);

        if (val < sc->sc_lcapacity) {
                sc->sc_bat_sensor[PBBAT_CAPACITY].state = ENVSYS_SCRITUNDER;
                sc->sc_bat_sensor[PBBAT_CHARGE_STATE].value_cur =
                    ENVSYS_BATTERY_CAPACITY_CRITICAL;
        } else if (val < sc->sc_wcapacity) {
                sc->sc_bat_sensor[PBBAT_CAPACITY].state = ENVSYS_SWARNUNDER;
                sc->sc_bat_sensor[PBBAT_CHARGE_STATE].value_cur =
                    ENVSYS_BATTERY_CAPACITY_WARNING;
        } else {
                sc->sc_bat_sensor[PBBAT_CHARGE_STATE].value_cur =
                    ENVSYS_BATTERY_CAPACITY_NORMAL;
        }

        sc->sc_bat_sensor[PBBAT_CHARGE_STATE].state = ENVSYS_SVALID;

        return val;
}