io/acpi_drv/acpi_drv.c

	acpi_drv.c revision 28b6fd27d5ff75fe6fdeb119a21575b0652a7e70
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/*
 * Copyright 2015 Hans Rosenfeld <rosenfeld@grumpf.hope-2000.org>
 */

/*
 * Driver for ACPI Battery, Lid, and Hotkey Control
 */
#include <sys/hotkey_drv.h>
#include <sys/sysevent/pwrctl.h>


#define ACPI_DRV_MOD_STRING     "ACPI driver"

#define ACPI_DRV_MAX_BAT_NUM        8
#define ACPI_DRV_MAX_AC_NUM     10

#define BST_FLAG_DISCHARGING        (0x1)
#define BST_FLAG_CHARGING       (0x2)
#define BST_FLAG_CRITICAL       (0x4)

/* Set if the battery is present */
#define STA_FLAG_BATT_PRESENT       (0x10)

#define ACPI_DEVNAME_CBAT       "PNP0C0A"
#define ACPI_DEVNAME_AC         "ACPI0003"
#define ACPI_DEVNAME_LID        "PNP0C0D"

#define ACPI_DRV_EVENTS         (POLLIN | POLLRDNORM)

#ifdef DEBUG

#define ACPI_DRV_PRINT_BUFFER_SIZE  512
static char acpi_drv_prt_buf[ACPI_DRV_PRINT_BUFFER_SIZE];
static kmutex_t acpi_drv_prt_mutex;

static int acpi_drv_debug = 0;
#define ACPI_DRV_DBG(lev, devp, ...) \
    do { \
        if (acpi_drv_debug) acpi_drv_printf((devp), \
(lev), __VA_ARGS__); \
_NOTE(CONSTCOND) } while (0)
#define ACPI_DRV_PRT_NOTIFY(hdl, val) \
    do { \
        if (acpi_drv_debug) acpi_drv_prt_notify((hdl), (val)); \
_NOTE(CONSTCOND) } while (0)

#else

#define ACPI_DRV_DBG(lev, devp, ...)
#define ACPI_DRV_PRT_NOTIFY(hdl, val)

#endif /* DEBUG */

/* ACPI notify types */
enum acpi_drv_notify {
    ACPI_DRV_NTF_UNKNOWN = -1,  /* No notifications seen, ever. */
    ACPI_DRV_NTF_CHANGED,
    ACPI_DRV_NTF_OK
};

static int acpi_drv_dev_present(struct acpi_drv_dev *);
#define acpi_drv_ac_present(a)  (((a)->dev.type == ACPI_DRV_TYPE_AC) ? \
                acpi_drv_dev_present(&(a)->dev) : -1)
#define acpi_drv_cbat_present(a)    (((a)->dev.type == ACPI_DRV_TYPE_CBAT) \
                    ? acpi_drv_dev_present(&(a)->dev) : -1)

static dev_info_t *acpi_drv_dip = NULL;
static kmutex_t acpi_drv_mutex;
static struct pollhead acpi_drv_pollhead;
static timeout_id_t acpi_drv_cbat_rescan_timeout;

/* Control Method Battery state */
struct acpi_drv_cbat_state {
    struct acpi_drv_dev dev;
    /* Caches of _BST and _BIF */
    enum acpi_drv_notify bat_bifok;
    acpi_bif_t bif_cache;
    enum acpi_drv_notify bat_bstok;
    acpi_bst_t bst_cache;

    uint32_t charge_warn;
    uint32_t charge_low;

    kstat_t *bat_bif_ksp;
    kstat_t *bat_bst_ksp;
} acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM];
static int nbat = 0;

/*
 * Synthesis battery state
 * When there are multiple batteries present, the battery subsystem
 * is not required to perform any synthesis of a composite battery
 * from the data of the separate batteries. In cases where the
 * battery subsystem does not synthesize a composite battery from
 * the separate battery's data, the OS must provide that synthesis.
 */
static uint32_t acpi_drv_syn_rem_cap;
static uint32_t acpi_drv_syn_last_cap;
static uint32_t acpi_drv_syn_oem_warn_cap;
static uint32_t acpi_drv_syn_oem_low_cap;

static int acpi_drv_warn_enabled;
static uint32_t acpi_drv_syn_warn_per;
static uint32_t acpi_drv_syn_low_per;
static uint32_t acpi_drv_syn_warn_cap;
static uint32_t acpi_drv_syn_low_cap;
/* Tracking boundery passing of _BST charge levels */
static uint32_t acpi_drv_syn_last_level;

/* AC state */
static struct acpi_drv_ac_state {
    struct acpi_drv_dev dev;
} acpi_drv_ac[ACPI_DRV_MAX_AC_NUM];
static int nac = 0;

/*
 * Current power source device
 * Note: assume only one device can be the power source device.
 */
static int acpi_drv_psr_type = ACPI_DRV_TYPE_UNKNOWN;
static struct acpi_drv_dev *acpi_drv_psr_devp = NULL;

struct obj_desc {
    char *name;
    int offset;
    int size;
    int type;
};

/* Object copy definitions */
#define OFFSETOF(s, m)      ((size_t)(&(((s *)0)->m)))
#define SIZEOF(s, m)        (sizeof (((s *)0)->m))
#define FIELD(n, s, m, t) \
    { n, OFFSETOF(s, m), SIZEOF(s, m), t }
#define FIELD_NULL      { NULL, -1, 0, ACPI_TYPE_ANY }

static struct obj_desc bif_desc[] = {
    FIELD("bif_unit",   acpi_bif_t, bif_unit,   ACPI_TYPE_INTEGER),
    FIELD("bif_design_cap", acpi_bif_t, bif_design_cap, ACPI_TYPE_INTEGER),
    FIELD("bif_last_cap",   acpi_bif_t, bif_last_cap,   ACPI_TYPE_INTEGER),
    FIELD("bif_tech",   acpi_bif_t, bif_tech,   ACPI_TYPE_INTEGER),
    FIELD("bif_voltage",    acpi_bif_t, bif_voltage, ACPI_TYPE_INTEGER),
    FIELD("bif_warn_cap",   acpi_bif_t, bif_warn_cap, ACPI_TYPE_INTEGER),
    FIELD("bif_low_cap",    acpi_bif_t, bif_low_cap,  ACPI_TYPE_INTEGER),
    FIELD("bif_gran1_cap",  acpi_bif_t, bif_gran1_cap, ACPI_TYPE_INTEGER),
    FIELD("bif_gran2_cap",  acpi_bif_t, bif_gran2_cap, ACPI_TYPE_INTEGER),
    FIELD("bif_model",  acpi_bif_t, bif_model,  ACPI_TYPE_STRING),
    FIELD("bif_serial", acpi_bif_t, bif_serial, ACPI_TYPE_STRING),
    FIELD("bif_type",   acpi_bif_t, bif_type,   ACPI_TYPE_STRING),
    FIELD("bif_oem_info",   acpi_bif_t, bif_oem_info, ACPI_TYPE_STRING),
    FIELD_NULL
};

static struct obj_desc bst_desc[] = {
    FIELD("bst_state",   acpi_bst_t, bst_state, ACPI_TYPE_INTEGER),
    FIELD("bst_rate",    acpi_bst_t, bst_rate,  ACPI_TYPE_INTEGER),
    FIELD("bst_rem_cap", acpi_bst_t, bst_rem_cap,   ACPI_TYPE_INTEGER),
    FIELD("bst_voltage", acpi_bst_t, bst_voltage,   ACPI_TYPE_INTEGER),
    FIELD_NULL
};

/* kstat definitions */
static kstat_t *acpi_drv_power_ksp;
static kstat_t *acpi_drv_warn_ksp;

acpi_drv_power_kstat_t acpi_drv_power_kstat = {
    { SYSTEM_POWER,         KSTAT_DATA_STRING },
    { SUPPORTED_BATTERY_COUNT,  KSTAT_DATA_UINT32 },
};

acpi_drv_warn_kstat_t acpi_drv_warn_kstat = {
    { BW_ENABLED,           KSTAT_DATA_UINT32 },
    { BW_POWEROFF_THRESHOLD,    KSTAT_DATA_UINT32 },
    { BW_SHUTDOWN_THRESHOLD,    KSTAT_DATA_UINT32 },
};

/* BIF */
acpi_drv_bif_kstat_t acpi_drv_bif_kstat = {
    { BIF_UNIT,     KSTAT_DATA_UINT32 },
    { BIF_DESIGN_CAP,   KSTAT_DATA_UINT32 },
    { BIF_LAST_CAP,     KSTAT_DATA_UINT32 },
    { BIF_TECH,     KSTAT_DATA_UINT32 },
    { BIF_VOLTAGE,      KSTAT_DATA_UINT32 },
    { BIF_WARN_CAP,     KSTAT_DATA_UINT32 },
    { BIF_LOW_CAP,      KSTAT_DATA_UINT32 },
    { BIF_GRAN1_CAP,    KSTAT_DATA_UINT32 },
    { BIF_GRAN2_CAP,    KSTAT_DATA_UINT32 },
    { BIF_MODEL,        KSTAT_DATA_STRING },
    { BIF_SERIAL,       KSTAT_DATA_STRING },
    { BIF_TYPE,     KSTAT_DATA_STRING },
    { BIF_OEM_INFO,     KSTAT_DATA_STRING },
};

/* BST */
acpi_drv_bst_kstat_t acpi_drv_bst_kstat = {
    { BST_STATE,        KSTAT_DATA_UINT32 },
    { BST_RATE,     KSTAT_DATA_UINT32 },
    { BST_REM_CAP,      KSTAT_DATA_UINT32 },
    { BST_VOLTAGE,      KSTAT_DATA_UINT32 },
};

struct acpi_drv_lid_state {
    struct acpi_drv_dev dev;
    enum acpi_drv_notify state_ok;
    int state;
} lid;
static int nlid = 0;

struct hotkey_drv acpi_hotkey;

static int acpi_drv_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);
static int acpi_drv_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);
static int acpi_drv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,
    void **resultp);
static int acpi_drv_open(dev_t *devp, int flag, int otyp, cred_t *crp);
static int acpi_drv_close(dev_t dev, int flag, int otyp, cred_t *crp);
static int acpi_drv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
    cred_t *cr, int *rval);
static int acpi_drv_chpoll(dev_t dev, short events, int anyyet,
    short *reventsp, struct pollhead **phpp);
static int acpi_drv_ac_ioctl(int index, int cmd, intptr_t arg, int mode,
    cred_t *cr, int *rval);
static int acpi_drv_cbat_ioctl(int index, int cmd, intptr_t arg, int mode,
    cred_t *cr, int *rval);
static int acpi_drv_lid_ioctl(int index, int cmd, intptr_t arg, int mode,
    cred_t *cr, int *rval);
#ifdef DEBUG
static void acpi_drv_printf(struct acpi_drv_dev *devp, uint_t lev,
    const char *fmt, ...);
#endif

static int acpi_drv_update_bif(struct acpi_drv_cbat_state *bp);
static int acpi_drv_update_bst(struct acpi_drv_cbat_state *bp);
static int acpi_drv_update_lid(struct acpi_drv_dev *bp);
static int acpi_drv_set_warn(acpi_drv_warn_t *bwp);
static struct acpi_drv_cbat_state *acpi_drv_idx2cbat(int idx);
static struct acpi_drv_ac_state *acpi_drv_idx2ac(int idx);
static int acpi_drv_acpi_init(void);
static void acpi_drv_acpi_fini(void);
static int acpi_drv_kstat_init(void);
static void acpi_drv_kstat_fini(void);

static int acpi_drv_kstat_bif_update(kstat_t *, int);
static int acpi_drv_kstat_bst_update(kstat_t *, int);

static void acpi_drv_cbat_rescan(void *);

static struct cb_ops acpi_drv_cb_ops = {
    acpi_drv_open,      /* open */
    acpi_drv_close,     /* close */
    nodev,          /* strategy */
    nodev,          /* print */
    nodev,          /* dump */
    nodev,          /* read */
    nodev,          /* write */
    acpi_drv_ioctl,     /* ioctl */
    nodev,          /* devmap */
    nodev,          /* mmap */
    nodev,          /* segmap */
    acpi_drv_chpoll,        /* chpoll */
    ddi_prop_op,        /* prop_op */
    NULL,           /* streamtab */
    D_NEW | D_MP,
    CB_REV,
    nodev,
    nodev
};

static struct dev_ops acpi_drv_dev_ops = {
    DEVO_REV,
    0,          /* refcnt */
    acpi_drv_getinfo,   /* getinfo */
    nulldev,        /* identify */
    nulldev,        /* probe */
    acpi_drv_attach,    /* attach */
    acpi_drv_detach,    /* detach */
    nodev,          /* reset */
    &acpi_drv_cb_ops,
    NULL,           /* no bus operations */
    NULL,           /* power */
    ddi_quiesce_not_needed, /* quiesce */
};

static struct modldrv modldrv1 = {
    &mod_driverops,
    ACPI_DRV_MOD_STRING,
    &acpi_drv_dev_ops
};

static struct modlinkage modlinkage = {
    MODREV_1,
    (void *)&modldrv1,
    NULL,
};

int
_init(void)
{
    int ret;

    mutex_init(&acpi_drv_mutex, NULL, MUTEX_DRIVER, NULL);
#ifdef DEBUG
    mutex_init(&acpi_drv_prt_mutex, NULL, MUTEX_DRIVER, NULL);
#endif

    if ((ret = mod_install(&modlinkage)) != 0) {
        mutex_destroy(&acpi_drv_mutex);
#ifdef DEBUG
        mutex_destroy(&acpi_drv_prt_mutex);
#endif
    }
    return (ret);
}

int
_fini(void)
{
    int ret;

    if ((ret = mod_remove(&modlinkage)) == 0) {
#ifdef DEBUG
        mutex_destroy(&acpi_drv_prt_mutex);
#endif
        mutex_destroy(&acpi_drv_mutex);
    }

    return (ret);
}

int
_info(struct modinfo *mp)
{
    return (mod_info(&modlinkage, mp));
}

static int
acpi_drv_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
    switch (cmd) {
    case DDI_ATTACH:
        /* Limit to one instance of driver */
        if (acpi_drv_dip) {
            return (DDI_FAILURE);
        }
        break;
    case DDI_RESUME:
    case DDI_PM_RESUME:
        return (DDI_SUCCESS);
    default:
        return (DDI_FAILURE);
    }

    acpi_drv_dip = devi;

    /* Init ACPI related stuff */
    if (acpi_drv_acpi_init() != ACPI_DRV_OK) {
        goto error;
    }

    /* Init kstat related stuff */
    if (acpi_drv_kstat_init() != ACPI_DRV_OK) {
        goto error;
    }

    acpi_drv_cbat_rescan_timeout = timeout(acpi_drv_cbat_rescan, NULL,
        drv_usectohz(MICROSEC));

    return (DDI_SUCCESS);

error:
    ddi_remove_minor_node(devi, NULL);
    acpi_drv_kstat_fini();
    acpi_drv_acpi_fini();
    acpi_drv_dip = NULL;
    return (DDI_FAILURE);
}

static int
acpi_drv_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
    timeout_id_t tmp_rescan_timeout;

    if (cmd != DDI_DETACH) {
        return (DDI_FAILURE);
    }

    /*
     * Clear the timeout id to indicate that the handler should not
     * reschedule itself.
     */
    mutex_enter(&acpi_drv_mutex);
    tmp_rescan_timeout = acpi_drv_cbat_rescan_timeout;
    acpi_drv_cbat_rescan_timeout = 0;
    mutex_exit(&acpi_drv_mutex);

    (void) untimeout(tmp_rescan_timeout);

    mutex_enter(&acpi_drv_mutex);
    ddi_remove_minor_node(devi, NULL);

    acpi_drv_kstat_fini();
    acpi_drv_acpi_fini();
    mutex_exit(&acpi_drv_mutex);
    return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
acpi_drv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
{
    switch (cmd) {
    case DDI_INFO_DEVT2DEVINFO:
        *resultp = acpi_drv_dip;
        return (DDI_SUCCESS);
    case DDI_INFO_DEVT2INSTANCE:
        *resultp = (void*) 0;
        return (DDI_SUCCESS);
    default:
        return (DDI_FAILURE);
    }
}

/*ARGSUSED*/
static int
acpi_drv_open(dev_t *devp, int flag, int otyp, cred_t *crp)
{
    if (acpi_drv_dip == NULL) {
        return (ENXIO);
    }

    return (0);
}

/*ARGSUSED*/
static int
acpi_drv_close(dev_t dev, int flag, int otyp, cred_t *crp)
{
    return (0);
}

/*ARGSUSED*/
static int
acpi_drv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cr,
    int *rval)
{
    int minor;
    int type, index;
    int res = 0;

    minor = getminor(dev);
    type = MINOR2TYPE(minor);
    index = MINOR2IDX(minor);

    mutex_enter(&acpi_drv_mutex);

    switch (type) {
    case ACPI_DRV_TYPE_CBAT:
        res = acpi_drv_cbat_ioctl(index, cmd, arg, mode, cr, rval);
        break;
    case ACPI_DRV_TYPE_AC:
        res = acpi_drv_ac_ioctl(index, cmd, arg, mode, cr, rval);
        break;
    case ACPI_DRV_TYPE_LID:
        res = acpi_drv_lid_ioctl(index, cmd, arg, mode, cr, rval);
        break;
    case ACPI_DRV_TYPE_HOTKEY:
        res = acpi_drv_hotkey_ioctl(cmd, arg, mode, cr, rval);
        break;
    default:
        res = EINVAL;
        break;
    }

    mutex_exit(&acpi_drv_mutex);
    return (res);
}

/*ARGSUSED*/
static int
acpi_drv_cbat_ioctl(int index, int cmd, intptr_t arg, int mode, cred_t *cr,
    int *rval)
{
    int res = 0;
    acpi_drv_warn_t bwarn;
    struct acpi_drv_cbat_state *bp;

    ASSERT(mutex_owned(&acpi_drv_mutex));

    bp = acpi_drv_idx2cbat(index);
    if (!bp || bp->dev.valid != 1) {
        return (ENXIO);
    }

    switch (cmd) {
    /*
     * Return _BIF(Battery Information) of battery[index],
     * if battery plugged.
     */
    case ACPI_DRV_IOC_INFO:
        if (bp->dev.present == 0) {
            res = ENXIO;
            break;
        }

        res = acpi_drv_update_bif(bp);
        if (res != ACPI_DRV_OK) {
            break;
        }
        if (copyout(&bp->bif_cache, (void *)arg,
            sizeof (bp->bif_cache))) {
            res = EFAULT;
        }
        break;

    /*
     * Return _BST(Battery Status) of battery[index],
     * if battery plugged.
     */
    case ACPI_DRV_IOC_STATUS:
        if (bp->dev.present == 0) {
            res = ENXIO;
            break;
        }

        res = acpi_drv_update_bst(bp);
        if (res != ACPI_DRV_OK) {
            break;
        }
        if (copyout(&bp->bst_cache, (void *)arg,
            sizeof (bp->bst_cache))) {
            res = EFAULT;
        }
        break;

    /* Return the state of the battery bays in the system */
    case ACPI_DRV_IOC_BAY:
        {
            batt_bay_t bay;

            bay.bay_number = nbat;
            bay.battery_map = 0;
            for (bp = &acpi_drv_cbat[0];
                bp < &acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM]; bp++) {
                if (bp->dev.valid) {
                    if (bp->dev.present) {
                        bay.battery_map |=
                            (1 << bp->dev.index);
                    }
                }
            }
            if (copyout(&bay, (void *)arg, sizeof (bay))) {
                res = EFAULT;
                break;
            }
        }
        break;

    /*
     * Return the current power source device if available:
     * 0 -- battery supplying power
     * 1 -- AC supplying power
     */
    case ACPI_DRV_IOC_POWER_STATUS:
        {
            int val;

            /* State not available */
            if (acpi_drv_psr_type == ACPI_DRV_TYPE_UNKNOWN) {
                res = ENXIO;
                break;
            }
            val = (acpi_drv_psr_type == ACPI_DRV_TYPE_AC) ? 1 : 0;
            if (copyout(&val, (void *)arg, sizeof (val))) {
                res = EFAULT;
                break;
            }
        }
        break;

    /* Get charge-warn and charge-low levels for the whole system */
    case ACPI_DRV_IOC_GET_WARNING:
        bwarn.bw_enabled = acpi_drv_warn_enabled;
        bwarn.bw_charge_warn = acpi_drv_syn_warn_per;
        bwarn.bw_charge_low = acpi_drv_syn_low_per;
        if (copyout(&bwarn, (void *)arg, sizeof (&bwarn))) {
            res = EFAULT;
        }
        break;

    /* Set charge-warn and charge-low levels for the whole system */
    case ACPI_DRV_IOC_SET_WARNING:
        if (drv_priv(cr)) {
            res = EPERM;
            break;
        }
        if (copyin((void *)arg, &bwarn, sizeof (bwarn))) {
            res = EFAULT;
            break;
        }
        res = acpi_drv_set_warn(&bwarn);
        break;

    default:
        res = EINVAL;
        break;
    }

    return (res);
}

/*ARGSUSED*/
static int
acpi_drv_ac_ioctl(int index, int cmd, intptr_t arg, int mode, cred_t *cr,
    int *rval)
{
    int res = 0;
    int ac_state;
    struct acpi_drv_ac_state *acp;

    ASSERT(mutex_owned(&acpi_drv_mutex));

    acp = acpi_drv_idx2ac(index);
    if (!acp || acp->dev.valid != 1) {
        return (ENXIO);
    }

    switch (cmd) {
    /* Return the number of AC adapters in the system */
    case ACPI_DRV_IOC_AC_COUNT:
        if (copyout(&nac, (void *)arg, sizeof (nac))) {
            res = EFAULT;
        }
        break;

    /*
     * Return the state of AC[index] if available:
     * 0 -- Off-line
     * 1 -- On-line
     */
    case ACPI_DRV_IOC_POWER_STATUS:
        if (!acp || acp->dev.valid != 1) {
            res = ENXIO;
            break;
        }
        /* State not available */
        if ((ac_state = acpi_drv_ac_present(acp)) == -1) {
            res = ENXIO;
            break;
        }
        if (copyout(&ac_state, (void *)arg, sizeof (ac_state))) {
            res = EFAULT;
        }
        break;

    default:
        res = EINVAL;
        break;
    }

    return (res);
}

/*ARGSUSED*/
static int
acpi_drv_lid_ioctl(int index, int cmd, intptr_t arg, int mode, cred_t *cr,
    int *rval)
{
    int res = 0;

    /*
     * lid.state 0 means lid is closed.
     * lid.state non-zero means lid is open.
     */
    switch (cmd) {
    case ACPI_DRV_IOC_LID_STATUS:
        if (lid.state_ok == ACPI_DRV_NTF_UNKNOWN) {
            /* State not available */
            res = acpi_drv_update_lid(&lid.dev);
            if (res != ACPI_DRV_OK) {
                res = ENXIO;
                break;
            }
        }
        if (copyout(&lid.state, (void *)arg, sizeof (lid.state))) {
            res = EFAULT;
        }
        break;
    case ACPI_DRV_IOC_LID_UPDATE:
        res = acpi_drv_update_lid(&lid.dev);
        if (res != ACPI_DRV_OK) {
            res = ENXIO;
            break;
        }
        if (copyout(&lid.state, (void *)arg, sizeof (lid.state))) {
            res = EFAULT;
        }
        break;

    default:
        res = EINVAL;
        break;
    }
    return (res);
}

/*ARGSUSED*/
static int
acpi_drv_chpoll(dev_t dev, short events, int anyyet,  short *reventsp,
    struct pollhead **phpp)
{
    if (!anyyet) {
        *phpp = &acpi_drv_pollhead;
    }
    *reventsp = 0;
    return (0);
}

#ifdef DEBUG
static void
acpi_drv_printf(struct acpi_drv_dev *devp, uint_t lev,
    const char *fmt, ...)
{
    va_list args;

    mutex_enter(&acpi_drv_prt_mutex);

    va_start(args, fmt);
    (void) vsprintf(acpi_drv_prt_buf, fmt, args);
    va_end(args);

    if (devp) {
        cmn_err(lev, "%s.%s: %s", devp->hid, devp->uid,
            acpi_drv_prt_buf);
    } else {
        cmn_err(lev, "%s", acpi_drv_prt_buf);
    }
    mutex_exit(&acpi_drv_prt_mutex);
}

static void
acpi_drv_prt_notify(ACPI_HANDLE hdl, UINT32 val)
{
    ACPI_BUFFER buf;
    char str[1024];

    buf.Length = sizeof (str);
    buf.Pointer = str;
    (void) AcpiGetName(hdl, ACPI_FULL_PATHNAME, &buf);
    cmn_err(CE_NOTE, "AcpiNotify(%s, 0x%02x)", str, val);
}
#endif /* DEBUG */

void
acpi_drv_gen_sysevent(struct acpi_drv_dev *devp, char *ev, uint32_t val)
{
    nvlist_t *attr_list = NULL;
    int err;
    char pathname[MAXPATHLEN];

    /* Allocate and build sysevent attribute list */
    err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
    if (err != 0) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "cannot allocate memory for sysevent attributes\n");
        return;
    }

    /* Add attributes */
    err = nvlist_add_string(attr_list, PWRCTL_DEV_HID, devp->hid);
    if (err != 0) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "Failed to add attr [%s] for %s/%s event",
            PWRCTL_DEV_HID, EC_PWRCTL, ev);
        nvlist_free(attr_list);
        return;
    }

    err = nvlist_add_string(attr_list, PWRCTL_DEV_UID, devp->uid);
    if (err != 0) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "Failed to add attr [%s] for %s/%s event",
            PWRCTL_DEV_UID, EC_PWRCTL, ev);
        nvlist_free(attr_list);
        return;
    }

    err = nvlist_add_uint32(attr_list, PWRCTL_DEV_INDEX, devp->index);
    if (err != 0) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "Failed to add attr [%s] for %s/%s event",
            PWRCTL_DEV_INDEX, EC_PWRCTL, ev);
        nvlist_free(attr_list);
        return;
    }

    (void) ddi_pathname(acpi_drv_dip, pathname);
    err = nvlist_add_string(attr_list, PWRCTL_DEV_PHYS_PATH, pathname);
    if (err != 0) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "Failed to add attr [%s] for %s/%s event",
            PWRCTL_DEV_PHYS_PATH, EC_PWRCTL, ev);
        nvlist_free(attr_list);
        return;
    }

    if (strcmp(ev, ESC_PWRCTL_WARN) && strcmp(ev, ESC_PWRCTL_LOW)) {
        goto finish;
    }

    err = nvlist_add_uint32(attr_list, PWRCTL_CHARGE_LEVEL, val);
    if (err != 0) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "Failed to add attr [%s] for %s/%s event",
            PWRCTL_CHARGE_LEVEL, EC_PWRCTL, ev);
        nvlist_free(attr_list);
        return;
    }

finish:
    ACPI_DRV_DBG(CE_NOTE, NULL, "SysEv(%s, %s.%s, %d)",
        ev, devp->hid, devp->uid, val);
    /* Generate/log sysevent */
    err = ddi_log_sysevent(acpi_drv_dip, DDI_VENDOR_SUNW, EC_PWRCTL,
        ev, attr_list, NULL, DDI_NOSLEEP);
#ifdef DEBUG
    if (err != DDI_SUCCESS) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "cannot log sysevent, err code %x\n", err);
    }
#endif

    nvlist_free(attr_list);
}

static int
acpi_drv_obj_copy(ACPI_OBJECT *op, char *bp, struct obj_desc *dp)
{
    ACPI_OBJECT *ep;
    char *fp;

    ep = &op->Package.Elements[0];
    for (; dp->offset != -1; dp++) {
        fp = bp + dp->offset;
        if (dp->type == ACPI_TYPE_INTEGER &&
            ep->Type == dp->type) {
#ifdef DEBUG
            if (dp->size <= 4) {
                ACPI_DRV_DBG(CE_NOTE, NULL, "\t%s: %u",
                    dp->name,
                    (uint32_t)ep->Integer.Value);
            } else {
#ifdef _LP64
                ACPI_DRV_DBG(CE_NOTE, NULL, "\t%s: %lu",
                    dp->name, (uint64_t)ep->Integer.Value);
            }
#else
                ACPI_DRV_DBG(CE_NOTE, NULL, "\t%s: %llu",
                    dp->name, (uint64_t)ep->Integer.Value);
            }
#endif /* _LP64 */
#endif /* DEBUG */
            *(uint32_t *)fp = ep->Integer.Value;
        } else if (dp->type == ACPI_TYPE_STRING &&
            ep->Type == dp->type) {
            ACPI_DRV_DBG(CE_NOTE, NULL, "\t%s: \"%s\"",
                dp->name, ep->String.Pointer);
            (void) strlcpy(fp, ep->String.Pointer, dp->size);
        } else if (dp->type == ACPI_TYPE_STRING &&
            ep->Type == ACPI_TYPE_BUFFER) {
#ifdef DEBUG
            int len;
            char buf[MAXNAMELEN + 1];

            len = (MAXNAMELEN < ep->Buffer.Length) ?
                MAXNAMELEN : ep->Buffer.Length;
            bcopy(ep->Buffer.Pointer, buf, len);
            buf[len] = 0;
            ACPI_DRV_DBG(CE_NOTE, NULL, "\t%s: [%d] \"%s\"",
                dp->name, len, buf);
#endif

            ASSERT(MAXNAMELEN >= ep->Buffer.Length);
            bcopy(ep->Buffer.Pointer, fp, ep->Buffer.Length);
        } else {
            ACPI_DRV_DBG(CE_WARN, NULL,
                "Bad field at offset %d: type %d",
                dp->offset, ep->Type);
            if (dp->type != ACPI_TYPE_STRING) {
                return (ACPI_DRV_ERR);
            }
        }
        ep++;
    }

    return (ACPI_DRV_OK);
}

/*
 * Returns the current power source devices. Used for the AC adapter and is
 * located under the AC adapter object in name space. Used to determine if
 * system is running off the AC adapter. This will report that the system is
 * not running on the AC adapter if any of the batteries in the system is
 * being forced to discharge through _BMC.
 *
 * Return value:
 *   0 -- Off-line, ie. battery supplying system power
 *   1 -- On-line, ie. AC supplying system power
 *  -1 -- Unknown, some error ocurred.
 * Note: It will also update the driver ac state.
 */
static int
acpi_drv_get_psr(struct acpi_drv_ac_state *acp)
{
    struct acpi_drv_dev *devp = &acp->dev;
    int ac;

    if (!devp->valid) {
        ACPI_DRV_DBG(CE_WARN, NULL, "device not valid");
        return (-1);
    }

    if (acpica_eval_int(devp->hdl, "_PSR", &ac) == AE_OK) {
        ACPI_DRV_DBG(CE_NOTE, devp, "_PSR = %d", ac);
        devp->present = ac;
    } else {
        ACPI_DRV_DBG(CE_WARN, NULL, "AcpiEval _PSR failed");
        devp->present = -1;
    }

    return (ac);
}

/*
 * For most systems, the _STA for this device will always
 * return a value with bits 0-3 set and will toggle bit 4
 * to indicate the actual presence of a battery.
 *
 * Return value:
 *   0 -- battery not present
 *   1 -- battery present
 *  -1 -- Unknown, some error ocurred.
 * Note: It will also update the driver cbat state.
 */
static int
acpi_drv_get_sta(struct acpi_drv_cbat_state *bp)
{
    struct acpi_drv_dev *devp = &bp->dev;
    int val;

    if (!devp->valid) {
        ACPI_DRV_DBG(CE_WARN, NULL, "device not valid");
        return (-1);
    }

    if (acpica_eval_int(devp->hdl, "_STA", &val) == AE_OK) {
        ACPI_DRV_DBG(CE_NOTE, devp, "_STA = 0x%x", val);
        devp->present = ((val & STA_FLAG_BATT_PRESENT) != 0);
    } else {
        ACPI_DRV_DBG(CE_WARN, NULL, "AcpiEval _STA failed");
        devp->present = -1;
    }

    return (val);
}

static int
acpi_drv_update_bif(struct acpi_drv_cbat_state *bp)
{
    ACPI_BUFFER buf;
    ACPI_OBJECT *objp;

    /* BIF is only available when battery plugged */
    ASSERT(bp->dev.present != 0);

    /* Update internal BIF cache */
    bp->bat_bifok = ACPI_DRV_NTF_UNKNOWN;

    buf.Length = ACPI_ALLOCATE_BUFFER;
    if (ACPI_FAILURE(AcpiEvaluateObjectTyped(bp->dev.hdl, "_BIF",
        NULL, &buf, ACPI_TYPE_PACKAGE))) {
        ACPI_DRV_DBG(CE_WARN, NULL, "AcpiEval _BIF failed");
        return (ACPI_DRV_ERR);
    }

    objp = buf.Pointer;
    ACPI_DRV_DBG(CE_NOTE, &bp->dev, "get _BIF");
    if (acpi_drv_obj_copy(objp, (char *)&bp->bif_cache, bif_desc) ==
        ACPI_DRV_ERR) {
        AcpiOsFree(objp);
        return (ACPI_DRV_ERR);
    }
    AcpiOsFree(objp);
    bp->bat_bifok = ACPI_DRV_NTF_OK;
    return (ACPI_DRV_OK);
}

static int
acpi_drv_update_bst(struct acpi_drv_cbat_state *bp)
{
    ACPI_BUFFER buf;
    ACPI_OBJECT *objp;

    /* BST is only available when battery plugged */
    ASSERT(bp->dev.present != 0);

    /* Update internal BST cache */
    bp->bat_bstok = ACPI_DRV_NTF_UNKNOWN;

    buf.Length = ACPI_ALLOCATE_BUFFER;
    if (ACPI_FAILURE(AcpiEvaluateObjectTyped(bp->dev.hdl, "_BST",
        NULL, &buf, ACPI_TYPE_PACKAGE))) {
        ACPI_DRV_DBG(CE_WARN, NULL, "AcpiEval _BST failed");
        return (ACPI_DRV_ERR);
    }

    objp = buf.Pointer;
    ACPI_DRV_DBG(CE_NOTE, &bp->dev, "get _BST");
    if (acpi_drv_obj_copy(objp, (char *)&bp->bst_cache, bst_desc) ==
        ACPI_DRV_ERR) {
        AcpiOsFree(objp);
        return (ACPI_DRV_ERR);
    }
    AcpiOsFree(objp);

    if (bp->bst_cache.bst_rate == 0) {
        bp->bst_cache.bst_state &= ~(ACPI_DRV_BST_CHARGING |
            ACPI_DRV_BST_DISCHARGING);
    }
    bp->bat_bstok = ACPI_DRV_NTF_OK;
    return (ACPI_DRV_OK);
}

/*
 * Return value:
 *   1 -- device On-line
 *   0 -- device Off-line
 *  -1 -- Unknown, some error ocurred.
 */
static int
acpi_drv_dev_present(struct acpi_drv_dev *devp)
{
    if (!devp->valid) {
        ACPI_DRV_DBG(CE_WARN, NULL, "device not valid");
        return (-1);
    }

    ASSERT(devp->type != ACPI_DRV_TYPE_UNKNOWN);

    /* Update the device state */
    if (devp->present == -1) {
        if (devp->type == ACPI_DRV_TYPE_AC) {
            (void) acpi_drv_get_psr((struct acpi_drv_ac_state *)
                devp);
        } else if (devp->type == ACPI_DRV_TYPE_CBAT) {
            (void) acpi_drv_get_sta((struct acpi_drv_cbat_state *)
                devp);
        }
    }

    return (devp->present);
}

/*
 * Check if the device p existance state has changed.
 * Return value:
 *   1 -- changed
 *   0 -- no change
 *  -1 -- unknown
 */
static int
acpi_drv_update_present(struct acpi_drv_dev *p)
{
    int old_present = p->present;
    int new_present;

    ASSERT(p && p->valid);

    p->present = -1;
    new_present = acpi_drv_dev_present(p);
    if (new_present == -1) {
        return (-1);
    }
    if (new_present != old_present) {
        return (1);
    }
    return (0);
}

static void
acpi_drv_set_psr(struct acpi_drv_dev *p)
{
    acpi_drv_psr_devp = p;
    if (p != NULL) {
        ACPI_DRV_DBG(CE_NOTE, p, "psr = .");
        acpi_drv_psr_type = p->type;
    } else {
        ACPI_DRV_DBG(CE_NOTE, p, "psr = ?");
        acpi_drv_psr_type = ACPI_DRV_TYPE_UNKNOWN;
    }
}

/*
 * OSPM can determine independent warning and low battery
 * capacity values based on the OEM-designed levels, but
 * cannot set these values lower than the OEM-designed values.
 */
static int
acpi_drv_set_warn(acpi_drv_warn_t *bwp)
{
    uint32_t warn, low;

    warn = acpi_drv_syn_last_cap * bwp->bw_charge_warn / 100;
    low = acpi_drv_syn_last_cap * bwp->bw_charge_low / 100;

    /* Update internal state */
    if (bwp->bw_enabled) {
        if (low >= warn || warn < acpi_drv_syn_oem_warn_cap ||
            low < acpi_drv_syn_oem_low_cap) {
            ACPI_DRV_DBG(CE_WARN, NULL, "charge level error");
            return (EINVAL);
        }

        ACPI_DRV_DBG(CE_NOTE, NULL, "set warn: warn=%d low=%d", warn,
            low);

        acpi_drv_syn_warn_per = bwp->bw_charge_warn;
        acpi_drv_syn_low_per = bwp->bw_charge_low;
        acpi_drv_syn_warn_cap = warn;
        acpi_drv_syn_low_cap = low;
        acpi_drv_warn_enabled = 1;
    } else {
        acpi_drv_warn_enabled = 0;
    }

    return (0);
}

/*
 * Update information for the synthesis battery
 *
 * Note: Sometimes the value to be returned from _BST or _BIF will be
 * temporarily unknown. In this case, the method may return the value
 * 0xFFFFFFFF as a placeholder. When the value becomes known, the
 * appropriate notification (0x80 for _BST or 0x81 for BIF) should be
 * issued, in like manner to any other change in the data returned by
 * these methods. This will cause OSPM to re-evaluate the method obtaining
 * the correct data value.
 */
static void
acpi_drv_update_cap(int bif_changed)
{
    struct acpi_drv_cbat_state *bp;

    if (bif_changed != 0) {
        acpi_drv_syn_oem_warn_cap = 0xffffffff;
        acpi_drv_syn_oem_low_cap = 0xffffffff;
        acpi_drv_syn_last_cap = 0xffffffff;
    }
    acpi_drv_syn_last_level = acpi_drv_syn_rem_cap;
    acpi_drv_syn_rem_cap = 0xffffffff; /* initially unknown */

    for (bp = &acpi_drv_cbat[0]; bp < &acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM];
        bp++) {
        if (bp->dev.valid) {
            /* Escape the empty bays */
            if (acpi_drv_cbat_present(bp) <= 0) {
                continue;
            }

            if (bif_changed != 0 &&
                bp->bat_bifok == ACPI_DRV_NTF_OK) {
                acpi_bif_t *bif;

                bif = &bp->bif_cache;

                if (acpi_drv_syn_last_cap == 0xffffffff) {
                    acpi_drv_syn_last_cap = 0;
                }
                acpi_drv_syn_last_cap += bif->bif_last_cap;

                if (bif->bif_warn_cap == 0xffffffff ||
                    bif->bif_low_cap == 0xffffffff) {
                    ACPI_DRV_DBG(CE_WARN, &bp->dev,
                        "BIF value "
                        "invalid, warn_cap=0x%x "
                        "low_cap=0x%x", bif->bif_warn_cap,
                        bif->bif_low_cap);
                    continue;
                }
                if (acpi_drv_syn_oem_warn_cap == 0xffffffff) {
                    acpi_drv_syn_oem_warn_cap = 0;
                }
                if (acpi_drv_syn_oem_low_cap == 0xffffffff) {
                    acpi_drv_syn_oem_low_cap = 0;
                }

                /*
                 * Use the highest level as the synthesis
                 * level.
                 */
                if (bif->bif_warn_cap >
                    acpi_drv_syn_oem_warn_cap) {
                    acpi_drv_syn_oem_low_cap =
                        bif->bif_low_cap;
                    acpi_drv_syn_oem_warn_cap =
                        bif->bif_warn_cap;
                }
            }
#ifdef DEBUG
            else if (bif_changed) {
                ACPI_DRV_DBG(CE_NOTE, &bp->dev,
                    "BIF not ready");
            }
#endif

            if (bp->bat_bstok == ACPI_DRV_NTF_OK) {
                acpi_bst_t *bst;

                bst = &bp->bst_cache;

                /*
                 * Batteries that are rechargeable and are in
                 * the discharging state are required to return
                 * a valid Battery Present Rate value.
                 * 0xFFFFFFFF - Unknown rate/capacity
                 */
                if (bst->bst_rem_cap == 0xffffffff) {
                    ACPI_DRV_DBG(CE_WARN, &bp->dev,
                        "BST value invalid, "
                        "rate=0x%x cap=0x%x",
                        bst->bst_rate, bst->bst_rem_cap);
                    continue;
                }

                if (acpi_drv_syn_rem_cap == 0xffffffff) {
                    acpi_drv_syn_rem_cap = 0;
                }
                acpi_drv_syn_rem_cap += bst->bst_rem_cap;
                /* Check for overflow */
                ASSERT(acpi_drv_syn_rem_cap >=
                    bst->bst_rem_cap);
            }
#ifdef DEBUG
            else {
                ACPI_DRV_DBG(CE_NOTE, &bp->dev,
                    "BST not ready");
            }
#endif
        }
    }

    ACPI_DRV_DBG(CE_NOTE, NULL, "syn_cap: %d syn_oem_warn: %d "
        "syn_oem_low: %d", acpi_drv_syn_rem_cap, acpi_drv_syn_oem_warn_cap,
        acpi_drv_syn_oem_low_cap);
}

static struct acpi_drv_cbat_state *
acpi_drv_idx2cbat(int idx)
{
    if (idx >= ACPI_DRV_MAX_BAT_NUM) {
        return (NULL);
    }
    return (&acpi_drv_cbat[idx]);
}

static struct acpi_drv_ac_state *
acpi_drv_idx2ac(int idx)
{
    if (idx >= ACPI_DRV_MAX_AC_NUM) {
        return (NULL);
    }
    return (&acpi_drv_ac[idx]);
}

/*ARGSUSED*/
static void
acpi_drv_cbat_notify(ACPI_HANDLE hdl, UINT32 val, void *ctx)
{
    struct acpi_drv_cbat_state *bp = ctx;
    struct acpi_drv_dev *devp = &bp->dev;
    int bif_changed;
    uint32_t eval;
    char *ev;
    acpi_bst_t *bst;

    mutex_enter(&acpi_drv_mutex);
    ACPI_DRV_PRT_NOTIFY(hdl, val);

    switch (val) {
    /*
     * BST has changed
     * Whenever the Battery State value changes, the
     * system will generate an SCI to notify the OS.
     *
     * Note: trip point is not used to implement the
     * warning levels.
     */
    case 0x80:
        /*
         * We always get 0x80 and 0x81 at battery plug/unplug,
         * but 0x80 may come first. In case that situation, we have
         * to update battery present state here too to update bst
         * correctly.
         */
        bif_changed = acpi_drv_update_present(devp);

        if (devp->present == 0) {
            if (acpi_drv_psr_devp == devp) {
                acpi_drv_set_psr(NULL);
            }
            goto done;
        }

        if (acpi_drv_update_bst(bp) != ACPI_DRV_OK) {
            break;
        }
        acpi_drv_update_cap(bif_changed);

        bst = &bp->bst_cache;
        eval = bst->bst_rem_cap;

        if (bst->bst_state & BST_FLAG_DISCHARGING) {
            acpi_drv_set_psr(devp);
        }
        /*
         * The Critical battery state indicates that all
         * available batteries are discharged and do not
         * appear to be able to supply power to run the
         * system any longer. When this occurs, the OS
         * should attempt to perform an emergency shutdown.
         * Right now we do not shutdown.  This would
         * need some discussion first since it could be
         * controversial.
         */
#ifdef DEBUG
        if (bst->bst_state & BST_FLAG_CRITICAL) {
            ACPI_DRV_DBG(CE_WARN, devp, "BST_FLAG_CRITICAL set");

            /*
             * BST_FLAG_CRITICAL may set even with AC,
             * plugged, when plug/unplug battery. Check
             * to avoid erroneous shutdown.
             */
            if (acpi_drv_psr_devp == devp &&
                bst->bst_rem_cap != 0xffffffff) {
                ACPI_DRV_DBG(CE_WARN, NULL,
                    "Battery in critical state");
            }
        } else
#endif
        if (acpi_drv_warn_enabled &&
            (bst->bst_state & BST_FLAG_DISCHARGING)) {
            /*
             * This value is an estimation of the amount of
             * energy or battery capacity required by the
             * system to transition to any supported sleeping
             * state. When the OS detects that the total
             * available battery capacity is less than this
             * value, it will transition the system to a user
             * defined system state (S1-S5).
             */
            if (acpi_drv_syn_last_level > acpi_drv_syn_low_cap &&
                acpi_drv_syn_rem_cap <= acpi_drv_syn_low_cap) {
                acpi_drv_gen_sysevent(devp, ESC_PWRCTL_LOW,
                    eval);
            /*
             * When the total available energy (mWh) or capacity
             * (mAh) in the batteries falls below this level,
             * the OS will notify the user through the UI.
             */
            } else if (acpi_drv_syn_last_level >
                acpi_drv_syn_warn_cap &&
                acpi_drv_syn_rem_cap <= acpi_drv_syn_warn_cap) {
                acpi_drv_gen_sysevent(devp, ESC_PWRCTL_WARN,
                    eval);
            }
        }

done:
        acpi_drv_gen_sysevent(devp, ESC_PWRCTL_STATE_CHANGE, 0);
        pollwakeup(&acpi_drv_pollhead, ACPI_DRV_EVENTS);
        break;

    /* battery has been removed completely */
    case 0x03:
    /* BIF has changed */
    case 0x81:
        /*
         * Note: Do not eliminate multiple ADD/REMOVE here,
         * because they may corresponding to different batterys.
         */
        (void) acpi_drv_update_present(devp);
        if (devp->present == 1) {
            if (acpi_drv_update_bif(bp) != ACPI_DRV_OK) {
                break;
            }
        }

        acpi_drv_update_cap(1);

        eval = devp->present;
        ev = eval ? ESC_PWRCTL_ADD : ESC_PWRCTL_REMOVE;
        acpi_drv_gen_sysevent(devp, ev, 0);
        pollwakeup(&acpi_drv_pollhead, ACPI_DRV_EVENTS);
        break;

    case 0x82:
    default:
        break;
    }

    mutex_exit(&acpi_drv_mutex);
}

static int
acpi_drv_update_lid(struct acpi_drv_dev *p)
{
    struct acpi_drv_lid_state *lp = (struct acpi_drv_lid_state *)p;

    if (acpica_eval_int(p->hdl, "_LID", &lp->state) == AE_OK) {
        lp->state_ok = ACPI_DRV_NTF_OK;
        return (ACPI_DRV_OK);
    }
    return (ACPI_DRV_ERR);
}

/*ARGSUSED*/
static void
acpi_drv_ac_notify(ACPI_HANDLE hdl, UINT32 val, void *ctx)
{
    struct acpi_drv_ac_state *acp = ctx;
    struct acpi_drv_dev *devp = &acp->dev;
    int old_present;
    char *ev;
    int eval;

    ACPI_DRV_PRT_NOTIFY(hdl, val);
    if (val != 0x80) {
        return;
    }

    mutex_enter(&acpi_drv_mutex);
    /*
     * Note: if unplug and then quickly plug back, two ADD
     * events will be generated.
     */
    old_present = devp->present;
    eval = acpi_drv_get_psr(acp);

    /* Eliminate redundant events */
    if (eval != -1 && eval != old_present) {
        /* Keep tracking the current power source device */
        if (eval == 1) {
            ev = ESC_PWRCTL_ADD;
            acpi_drv_set_psr(devp);
        } else {
            ev = ESC_PWRCTL_REMOVE;
            /* If AC was supplying the power, it's not now */
            if (acpi_drv_psr_devp == devp) {
                acpi_drv_set_psr(NULL);
            }
        }

        acpi_drv_gen_sysevent(devp, ev, 0);
        pollwakeup(&acpi_drv_pollhead, ACPI_DRV_EVENTS);
    }

    mutex_exit(&acpi_drv_mutex);
}

static void
acpi_drv_lid_notify(ACPI_HANDLE hdl, UINT32 val, void *ctx)
{
    struct acpi_drv_lid_state *p = ctx;

    ACPI_DRV_PRT_NOTIFY(hdl, val);
    if (val == 0x80) {
        mutex_enter(&acpi_drv_mutex);
        if (acpi_drv_update_lid(&p->dev) == ACPI_DRV_OK) {
            acpi_drv_gen_sysevent(&p->dev, p->state ?
                ESC_PWRCTL_ADD : ESC_PWRCTL_REMOVE, 0);
        }
        mutex_exit(&acpi_drv_mutex);
    }
}

static int
acpi_drv_obj_init(struct acpi_drv_dev *p)
{
    ACPI_DEVICE_INFO *info;
    ACPI_NOTIFY_HANDLER ntf_handler = NULL;
    ACPI_STATUS ret;
    char name[KSTAT_STRLEN];

    ASSERT(p != NULL && p->hdl != NULL);

    p->valid = 0;

    /* Info size is variable depending on existance of _CID */
    ret = AcpiGetObjectInfo(p->hdl, &info);
    if (ACPI_FAILURE(ret)) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "AcpiGetObjectInfo() fail: %d", (int32_t)ret);
        return (ACPI_DRV_ERR);
    }

    if ((info->Valid & ACPI_VALID_HID) == 0) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "AcpiGetObjectInfo(): _HID not available");
        p->hid[0] = 0;
    } else {
        (void) strlcpy(p->hid, info->HardwareId.String, ID_LEN);
    }

    /*
     * This object is optional, but is required when the device
     * has no other way to report a persistent unique device ID.
     */
    if ((info->Valid & ACPI_VALID_UID) == 0) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "AcpiGetObjectInfo(): _UID not available");
        /* Use 0 as the default _UID */
        p->uid[0] = 0;
    } else {
        (void) strlcpy(p->uid, info->UniqueId.String, ID_LEN);
    }

    AcpiOsFree(info);
    p->valid = 1;

    if (strcmp(p->hid, ACPI_DEVNAME_CBAT) == 0) {
        struct acpi_drv_cbat_state *bp =
            (struct acpi_drv_cbat_state *)p;
        kstat_t *ksp;

        p->type = ACPI_DRV_TYPE_CBAT;
        p->index = nbat - 1;

        /* Update device present state */
        (void) acpi_drv_update_present(p);
        if (p->present) {
            (void) acpi_drv_update_bif(bp);
            (void) acpi_drv_update_bst(bp);

            /* Init the current power source */
            if (bp->bst_cache.bst_state & BST_FLAG_DISCHARGING) {
                acpi_drv_set_psr(p);
            }
        }
        ntf_handler = acpi_drv_cbat_notify;
        ACPI_DRV_DBG(CE_NOTE, p, "battery %s",
            (p->present ? "present" : "absent"));

        /* Create minor node for battery */
        (void) snprintf(name, sizeof (name), "battery%d", p->index);
        if (ddi_create_minor_node(acpi_drv_dip, name, S_IFCHR,
            MINOR_BATT(p->index), DDI_PSEUDO, 0) == DDI_FAILURE)
            ACPI_DRV_DBG(CE_WARN, NULL,
                "%s: minor node create failed", name);

        /*
         * Allocate, initialize and install BIF and BST kstat
         */
        /* BIF kstat */
        (void) snprintf(name, KSTAT_STRLEN-1, "%s%d",
            ACPI_DRV_BIF_KSTAT_NAME, bp->dev.index);
        ksp = kstat_create(ACPI_DRV_NAME, 0, name, "misc",
            KSTAT_TYPE_NAMED,
            sizeof (acpi_drv_bif_kstat) / sizeof (kstat_named_t),
            KSTAT_FLAG_VIRTUAL);
        if (ksp != NULL) {
            ACPI_DRV_DBG(CE_NOTE, NULL, "kstat_create(%s) ok",
                name);

            bp->bat_bif_ksp = ksp;
            ksp->ks_data = &acpi_drv_bif_kstat;
            ksp->ks_update = acpi_drv_kstat_bif_update;
            ksp->ks_data_size += MAXNAMELEN * 4;
            ksp->ks_private = bp;

            kstat_install(ksp);
        } else {
            ACPI_DRV_DBG(CE_WARN, NULL,
                "kstat_create(%s) fail", name);
        }

        /* BST kstat */
        (void) snprintf(name, KSTAT_STRLEN-1, "%s%d",
            ACPI_DRV_BST_KSTAT_NAME, bp->dev.index);
        ksp = kstat_create(ACPI_DRV_NAME, 0, name, "misc",
            KSTAT_TYPE_NAMED,
            sizeof (acpi_drv_bst_kstat) / sizeof (kstat_named_t),
            KSTAT_FLAG_VIRTUAL);
        if (ksp != NULL) {
            ACPI_DRV_DBG(CE_NOTE, NULL, "kstat_create(%s) ok",
                name);

            bp->bat_bst_ksp = ksp;
            ksp->ks_data = &acpi_drv_bst_kstat;
            ksp->ks_update = acpi_drv_kstat_bst_update;
            ksp->ks_data_size += MAXNAMELEN * 4;
            ksp->ks_private = bp;

            kstat_install(ksp);
        } else {
            ACPI_DRV_DBG(CE_WARN, NULL,
                "kstat_create(%s) fail", name);
        }
    } else if (strcmp(p->hid, ACPI_DEVNAME_AC) == 0) {
        p->type = ACPI_DRV_TYPE_AC;
        p->index = nac - 1;

        /* Update device present state */
        (void) acpi_drv_update_present(p);
        if (p->present) {
            /* Init the current power source */
            acpi_drv_set_psr(p);
        }
        ntf_handler = acpi_drv_ac_notify;
        ACPI_DRV_DBG(CE_NOTE, p, "AC %s",
            (p->present ? "on-line" : "off-line"));

        /* Create minor node for AC */
        (void) snprintf(name, sizeof (name), "ac%d", p->index);
        if (ddi_create_minor_node(acpi_drv_dip, name, S_IFCHR,
            MINOR_AC(p->index), DDI_PSEUDO, 0) == DDI_FAILURE)
            ACPI_DRV_DBG(CE_WARN, NULL,
                "%s: minor node create failed", name);
    } else if (strcmp(p->hid, ACPI_DEVNAME_LID) == 0) {
        p->type = ACPI_DRV_TYPE_LID;
        p->index = 0;
        lid.state_ok = ACPI_DRV_NTF_UNKNOWN;
        (void) acpi_drv_update_lid(p);
        ntf_handler = acpi_drv_lid_notify;
        ACPI_DRV_DBG(CE_NOTE, p, "added");

        /* Create minor node for lid. */
        if (ddi_create_minor_node(acpi_drv_dip, "lid", S_IFCHR,
            MINOR_LID(p->index), DDI_PSEUDO, 0) == DDI_FAILURE)
            ACPI_DRV_DBG(CE_WARN, NULL,
                "lid: minor node create failed");
    } else {
        ACPI_DRV_DBG(CE_NOTE, p, "unknown device");
        p->valid = 0;
    }

    /* Register ACPI battery related events */
    if (ntf_handler != NULL) {
        if (ACPI_FAILURE(AcpiInstallNotifyHandler(p->hdl,
            ACPI_ALL_NOTIFY, ntf_handler, p))) {
            ACPI_DRV_DBG(CE_NOTE, NULL,
                "Notify handler for %s.%s install failed",
                p->hid, p->uid);
            return (ACPI_DRV_ERR);
        }
    }

    return (ACPI_DRV_OK);
}

/*ARGSUSED*/
static ACPI_STATUS
acpi_drv_find_cb(ACPI_HANDLE ObjHandle, UINT32 NestingLevel, void *Context,
    void **ReturnValue)
{
    struct acpi_drv_dev *devp;
    int *type = (int *)Context;

    if (*type == ACPI_DRV_TYPE_CBAT) {
        struct acpi_drv_cbat_state *bp;

        for (bp = acpi_drv_cbat;
            bp != &acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM];
            bp++)
            if (bp->dev.hdl == ObjHandle)
                return (AE_OK);

        if (nbat == ACPI_DRV_MAX_BAT_NUM) {
            ACPI_DRV_DBG(CE_WARN, NULL,
                "Need to support more batteries: "
                "BATTERY_MAX = %d", ACPI_DRV_MAX_BAT_NUM);
            return (AE_LIMIT);
        }
        bp = &acpi_drv_cbat[nbat++];
        devp = (struct acpi_drv_dev *)bp;
    } else if (*type == ACPI_DRV_TYPE_AC) {
        struct acpi_drv_ac_state *ap;

        for (ap = acpi_drv_ac;
            ap != &acpi_drv_ac[ACPI_DRV_MAX_AC_NUM];
            ap++)
            if (ap->dev.hdl == ObjHandle)
                return (AE_OK);

        if (nac == ACPI_DRV_MAX_AC_NUM) {
            ACPI_DRV_DBG(CE_WARN, NULL, "Need to support more ACs: "
                "AC_MAX = %d", ACPI_DRV_MAX_AC_NUM);
            return (AE_LIMIT);
        }
        ap = &acpi_drv_ac[nac++];
        devp = (struct acpi_drv_dev *)ap;
    } else if (*type == ACPI_DRV_TYPE_LID) {
        struct acpi_drv_lid_state *lp;

        lp = &lid;
        if (lp->dev.hdl == ObjHandle)
            return (AE_OK);

        nlid++;
        devp = (struct acpi_drv_dev *)lp;
    } else {
        ACPI_DRV_DBG(CE_WARN, NULL, "acpi_drv_find_cb(): "
            "Unknown device");
        return (AE_ERROR);
    }

    devp->hdl = ObjHandle;

    /* Try to get as many working objs as possible */
    (void) acpi_drv_obj_init(devp);
    return (AE_OK);
}

/*ARGSUSED*/
static void
acpi_drv_cbat_rescan(void *arg)
{
    int *retp, type = ACPI_DRV_TYPE_CBAT;

    mutex_enter(&acpi_drv_mutex);

    /*
     * The detach routine clears the timeout id to tell us not to
     * reschedule ourselves. If thats the case there's also no point
     * in looking for new ACPI battery devices, so just return.
     */
    if (acpi_drv_cbat_rescan_timeout == 0) {
        mutex_exit(&acpi_drv_mutex);
        return;
    }

    (void) AcpiGetDevices(ACPI_DEVNAME_CBAT, acpi_drv_find_cb, &type,
        (void *)&retp);

    acpi_drv_cbat_rescan_timeout = timeout(acpi_drv_cbat_rescan, NULL,
        drv_usectohz(MICROSEC));
    mutex_exit(&acpi_drv_mutex);
}

static int
acpi_drv_acpi_init(void)
{
    int *retp, type;
    int status = ACPI_DRV_ERR;
    hotkey_drv_t *htkp;

    /* Check to see if ACPI CA services are available */
    if (AcpiSubsystemStatus() != AE_OK) {
        ACPI_DRV_DBG(CE_WARN, NULL, "ACPI CA not ready");
        return (status);
    }

    /* Init Control Method Batterys */
    type = ACPI_DRV_TYPE_CBAT;
    if (ACPI_SUCCESS(AcpiGetDevices(ACPI_DEVNAME_CBAT, acpi_drv_find_cb,
        &type, (void *)&retp)) && nbat) {
        status = ACPI_DRV_OK;
    }

    /* Init AC */
    type = ACPI_DRV_TYPE_AC;
    if (ACPI_SUCCESS(AcpiGetDevices(ACPI_DEVNAME_AC, acpi_drv_find_cb,
        &type, (void *)&retp)) && nac) {
        status = ACPI_DRV_OK;
    }

    /* Init LID */
    type = ACPI_DRV_TYPE_LID;
    if (ACPI_SUCCESS(AcpiGetDevices(ACPI_DEVNAME_LID, acpi_drv_find_cb,
        &type, (void *)&retp)) && nlid) {
        status = ACPI_DRV_OK;
    }

    /* Init Hotkey Device */
    type = ACPI_DRV_TYPE_HOTKEY;
    htkp = &acpi_hotkey;
    bzero(htkp, sizeof (hotkey_drv_t));
    htkp->dip = acpi_drv_dip;
    htkp->hotkey_lock = &acpi_drv_mutex;
    if (hotkey_init(htkp) == ACPI_DRV_OK) {
        status = ACPI_DRV_OK;
    }

    acpi_drv_update_cap(1);

    return (status);
}

static void
acpi_drv_acpi_fini(void)
{
    int i;
    struct acpi_drv_cbat_state *bp;

    for (bp = &acpi_drv_cbat[0]; bp < &acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM];
        bp++) {
        if (bp->dev.valid) {
            (void) AcpiRemoveNotifyHandler(bp->dev.hdl,
                ACPI_DEVICE_NOTIFY, acpi_drv_cbat_notify);
        }
    }
    for (i = 0; i < nac; i++) {
        (void) AcpiRemoveNotifyHandler(acpi_drv_ac[i].dev.hdl,
            ACPI_DEVICE_NOTIFY, acpi_drv_ac_notify);
    }
    (void) AcpiRemoveNotifyHandler(lid.dev.hdl, ACPI_DEVICE_NOTIFY,
        acpi_drv_lid_notify);

    if (acpi_hotkey.hotkey_method != HOTKEY_METHOD_NONE)
        (void) hotkey_fini(&acpi_hotkey);
}

/*ARGSUSED*/
static int
acpi_drv_kstat_power_update(kstat_t *ksp, int flag)
{
    if (flag == KSTAT_WRITE) {
        return (EACCES);
    }

    mutex_enter(&acpi_drv_mutex);
    if (acpi_drv_psr_type == ACPI_DRV_TYPE_UNKNOWN) {
        mutex_exit(&acpi_drv_mutex);
        return (EIO);
    }
    kstat_named_setstr(&acpi_drv_power_kstat.acpi_drv_power,
        acpi_drv_psr_type == ACPI_DRV_TYPE_AC ? AC : BATTERY);
    acpi_drv_power_kstat.acpi_drv_supported_battery_count.value.ui32 =
        (uint32_t)nbat;
    mutex_exit(&acpi_drv_mutex);

    return (0);
}

/*ARGSUSED*/
static int
acpi_drv_kstat_warn_update(kstat_t *ksp, int flag)
{
    if (flag == KSTAT_WRITE) {
        int ret = 0;
        acpi_drv_warn_t bw;
        acpi_drv_warn_kstat_t kbw;

        kbw = *(acpi_drv_warn_kstat_t *)acpi_drv_warn_ksp->ks_data;

        mutex_enter(&acpi_drv_mutex);
        bw.bw_enabled  = kbw.acpi_drv_bw_enabled.value.ui32;
        bw.bw_charge_warn = kbw.acpi_drv_bw_charge_warn.value.ui32;
        bw.bw_charge_low = kbw.acpi_drv_bw_charge_low.value.ui32;
        ret = acpi_drv_set_warn(&bw);
        mutex_exit(&acpi_drv_mutex);

        return (ret);
    } else {
        acpi_drv_warn_kstat_t *wp = &acpi_drv_warn_kstat;

        mutex_enter(&acpi_drv_mutex);
        wp->acpi_drv_bw_enabled.value.ui32 = acpi_drv_warn_enabled;
        wp->acpi_drv_bw_charge_warn.value.ui32 = acpi_drv_syn_warn_per;
        wp->acpi_drv_bw_charge_low.value.ui32 = acpi_drv_syn_low_per;
        mutex_exit(&acpi_drv_mutex);

        return (0);
    }
}

static int
acpi_drv_kstat_bif_update(kstat_t *ksp, int flag)
{
    struct acpi_drv_cbat_state *bp;
    acpi_bif_t *bif;
    acpi_drv_bif_kstat_t *kp;

    if (flag == KSTAT_WRITE) {
        return (EACCES);
    }

    bp = (struct acpi_drv_cbat_state *)ksp->ks_private;
    mutex_enter(&acpi_drv_mutex);

    if (acpi_drv_cbat_present(bp) <= 0) {
        mutex_exit(&acpi_drv_mutex);
        return (ENXIO);
    }

    bzero(&bif, sizeof (bif));
    if (acpi_drv_update_bif(bp) != ACPI_DRV_OK) {
        mutex_exit(&acpi_drv_mutex);
        return (ENXIO);
    }

    bif = &bp->bif_cache;
    kp = &acpi_drv_bif_kstat;

    /* Update BIF */
    kp->acpi_drv_bif_unit.value.ui32 = bif->bif_unit;
    kp->acpi_drv_bif_design_cap.value.ui32 = bif->bif_design_cap;
    kp->acpi_drv_bif_last_cap.value.ui32 = bif->bif_last_cap;
    kp->acpi_drv_bif_tech.value.ui32 = bif->bif_tech;
    kp->acpi_drv_bif_voltage.value.ui32 = bif->bif_voltage;
    kp->acpi_drv_bif_warn_cap.value.ui32 = bif->bif_warn_cap;
    kp->acpi_drv_bif_low_cap.value.ui32 = bif->bif_low_cap;
    kp->acpi_drv_bif_gran1_cap.value.ui32 = bif->bif_gran1_cap;
    kp->acpi_drv_bif_gran2_cap.value.ui32 = bif->bif_gran2_cap;

    kstat_named_setstr(&kp->acpi_drv_bif_model, bif->bif_model);
    kstat_named_setstr(&kp->acpi_drv_bif_serial, bif->bif_serial);
    kstat_named_setstr(&kp->acpi_drv_bif_type, bif->bif_type);
    kstat_named_setstr(&kp->acpi_drv_bif_oem_info, bif->bif_oem_info);

    mutex_exit(&acpi_drv_mutex);
    return (0);
}

static int
acpi_drv_kstat_bst_update(kstat_t *ksp, int flag)
{
    struct acpi_drv_cbat_state *bp;
    acpi_bst_t *bst;
    acpi_drv_bst_kstat_t *kp;

    if (flag == KSTAT_WRITE) {
        return (EACCES);
    }

    bp = (struct acpi_drv_cbat_state *)ksp->ks_private;
    mutex_enter(&acpi_drv_mutex);

    if (acpi_drv_cbat_present(bp) <= 0) {
        mutex_exit(&acpi_drv_mutex);
        return (ENXIO);
    }

    bzero(&bst, sizeof (bst));
    if (acpi_drv_update_bst(bp) != ACPI_DRV_OK) {
        mutex_exit(&acpi_drv_mutex);
        return (ENXIO);
    }

    bst = &bp->bst_cache;
    kp = &acpi_drv_bst_kstat;

    /* Update BST */
    kp->acpi_drv_bst_state.value.ui32 = bst->bst_state;
    kp->acpi_drv_bst_rate.value.ui32 = bst->bst_rate;
    kp->acpi_drv_bst_rem_cap.value.ui32 = bst->bst_rem_cap;
    kp->acpi_drv_bst_voltage.value.ui32 = bst->bst_voltage;

    mutex_exit(&acpi_drv_mutex);
    return (0);
}

static int
acpi_drv_kstat_init(void)
{
    /*
     * Allocate, initialize and install powerstatus and
     * supported_battery_count kstat.
     */
    acpi_drv_power_ksp = kstat_create(ACPI_DRV_NAME, 0,
        ACPI_DRV_POWER_KSTAT_NAME, "misc",
        KSTAT_TYPE_NAMED,
        sizeof (acpi_drv_power_kstat) / sizeof (kstat_named_t),
        KSTAT_FLAG_VIRTUAL);
    if (acpi_drv_power_ksp == NULL) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "kstat_create(%s) fail", ACPI_DRV_POWER_KSTAT_NAME);
        return (ACPI_DRV_ERR);
    }

    acpi_drv_power_ksp->ks_data = &acpi_drv_power_kstat;
    acpi_drv_power_ksp->ks_update = acpi_drv_kstat_power_update;
    acpi_drv_power_ksp->ks_data_size += MAXNAMELEN;
    kstat_install(acpi_drv_power_ksp);

    /*
     * Allocate, initialize and install battery_capacity_warning kstat.
     */
    acpi_drv_warn_ksp = kstat_create(ACPI_DRV_NAME, 0,
        ACPI_DRV_BTWARN_KSTAT_NAME, "misc",
        KSTAT_TYPE_NAMED,
        sizeof (acpi_drv_warn_kstat) / sizeof (kstat_named_t),
        KSTAT_FLAG_VIRTUAL | KSTAT_FLAG_WRITABLE);
    if (acpi_drv_warn_ksp == NULL) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "kstat_create(%s) fail", ACPI_DRV_BTWARN_KSTAT_NAME);
        return (ACPI_DRV_ERR);
    }

    acpi_drv_warn_ksp->ks_data = &acpi_drv_warn_kstat;
    acpi_drv_warn_ksp->ks_update = acpi_drv_kstat_warn_update;
    kstat_install(acpi_drv_warn_ksp);

    return (ACPI_DRV_OK);
}

static void
acpi_drv_kstat_fini()
{
    struct acpi_drv_cbat_state *bp;

    if (acpi_drv_power_ksp != NULL) {
        kstat_delete(acpi_drv_power_ksp);
    }
    if (acpi_drv_warn_ksp != NULL) {
        kstat_delete(acpi_drv_warn_ksp);
    }
    for (bp = &acpi_drv_cbat[0]; bp < &acpi_drv_cbat[ACPI_DRV_MAX_BAT_NUM];
        bp++) {
        if (bp->dev.valid) {
            if (bp->bat_bif_ksp != NULL) {
                kstat_delete(bp->bat_bif_ksp);
            }
            if (bp->bat_bst_ksp != NULL) {
                kstat_delete(bp->bat_bst_ksp);
            }
        }
    }
}

int
acpi_drv_set_int(ACPI_HANDLE dev, char *method, uint32_t aint)
{
    ACPI_OBJECT_LIST al;
    ACPI_OBJECT ao;

    al.Pointer = &ao;
    al.Count = 1;
    ao.Type = ACPI_TYPE_INTEGER;
    ao.Integer.Value = aint;
    return (AcpiEvaluateObject(dev, method, &al, NULL));
}

int
acpi_drv_dev_init(struct acpi_drv_dev *p)
{
    ACPI_DEVICE_INFO *info;
    ACPI_STATUS ret;

    ASSERT(p != NULL && p->hdl != NULL);

    p->valid = 0;

    /* Info size is variable depending on existance of _CID */
    ret = AcpiGetObjectInfo(p->hdl, &info);
    if (ACPI_FAILURE(ret)) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "AcpiGetObjectInfo() fail: %d", (int32_t)ret);
        return (ACPI_DRV_ERR);
    }

    if ((info->Valid & ACPI_VALID_HID) == 0) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "!AcpiGetObjectInfo(): _HID not available");
        p->hid[0] = 0;
    } else {
        (void) strlcpy(p->hid, info->HardwareId.String, ID_LEN);
    }

    /*
     * This object is optional, but is required when the device
     * has no other way to report a persistent unique device ID.
     */
    if ((info->Valid & ACPI_VALID_UID) == 0) {
        ACPI_DRV_DBG(CE_WARN, NULL,
            "!AcpiGetObjectInfo(): _UID not available");
        /* Use 0 as the default _UID */
        p->uid[0] = 0;
    } else {
        (void) strlcpy(p->uid, info->UniqueId.String, ID_LEN);
    }

    if (info->Valid & ACPI_VALID_ADR) {
        p->valid = 1;
        p->type = ACPI_DRV_TYPE_HOTKEY;
    }

    AcpiOsFree(info);

    return (ACPI_DRV_OK);
}