/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2026 Abdelkader Boudih <dragonflybsd@seuros.com>
 *
 * Ported from FreeBSD's asmc(4) driver.
 *
 * DragonFlyBSD port: adapted for kmalloc/kfree, lockmgr 2-arg form,
 * taskqueue_start_threads ncpu arg, sys/bus_resource.h, acpica paths.
 * Added MMIO (T2) backend support.
 */

/*
 * Apple SMC — sysctl handlers.
 *
 * All SYSCTL_HANDLER_ARGS callbacks: fan speed, temperature, SMS axes,
 * keyboard backlight, battery charge limit, system state keys, and
 * the optional raw-key debug interface.
 */

#include "smc.h"

#include <machine/specialreg.h>
#include <machine/cpufunc.h>

static int
apple_smc_key_check_writable(device_t dev, const char *key)
{
        uint8_t attrs;

        if (apple_smc_key_getattrs(dev, key, &attrs) == 0 &&
            (attrs & ASMC_ATTR_WRITABLE) == 0) {
                device_printf(dev, "%s: attrs=0x%02x, not writable\n",
                    key, attrs);
                return (EPERM);
        }
        return (0);
}

/*
 * Module-scope cached keyboard backlight level.  Shared across all device
 * instances so suspend/resume can restore the last requested brightness even
 * though the resume path only has a device_t and not sysctl request context.
 */
static unsigned int light_control = 0;

/* Retrieve the cached module-level brightness value for resume restore. */
unsigned int
apple_smc_get_light_control(void)
{
        return (light_control);
}

int
apple_smc_mb_sysctl_fanspeed(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        int fan = arg2;
        int32_t v;

        v = apple_smc_fan_getvalue(dev, ASMC_KEY_FANSPEED, fan);
        return (sysctl_handle_int(oidp, &v, 0, req));
}

int
apple_smc_mb_sysctl_fanid(SYSCTL_HANDLER_ARGS)
{
        uint8_t buf[16];
        device_t dev = (device_t)arg1;
        int fan = arg2;
        char *desc;

        desc = apple_smc_fan_getstring(dev, ASMC_KEY_FANID, fan,
            buf, sizeof(buf));
        if (desc == NULL) {
                return (EIO);
        }
        return (sysctl_handle_string(oidp, desc, 0, req));
}

int
apple_smc_mb_sysctl_fansafespeed(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        int fan = arg2;
        int32_t v;

        v = apple_smc_fan_getvalue(dev, ASMC_KEY_FANSAFESPEED, fan);
        return (sysctl_handle_int(oidp, &v, 0, req));
}

/*
 * Fan speed keys that support both read and write.
 * Index into this table is packed in arg2 bits [15:8].
 */
static const char *apple_smc_fan_rw_keys[] = {
        ASMC_KEY_FANMINSPEED,           /* 0 */
        ASMC_KEY_FANMAXSPEED,           /* 1 */
        ASMC_KEY_FANTARGETSPEED,        /* 2 */
};

int
apple_smc_mb_sysctl_fanrw(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        int key_idx = (arg2 >> 8) & 0xFF;
        int fan = arg2 & 0xFF;
        const char *key;
        int error;
        int32_t v;

        if (key_idx >= (int)nitems(apple_smc_fan_rw_keys))
                return (EINVAL);
        key = apple_smc_fan_rw_keys[key_idx];

        v = apple_smc_fan_getvalue(dev, key, fan);
        error = sysctl_handle_int(oidp, &v, 0, req);
        if (error == 0 && req->newptr != NULL) {
                error = apple_smc_fan_setvalue(dev, key, fan, v);
        }
        return (error);
}

int
apple_smc_mb_sysctl_fanmanual(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        int fan = arg2;
        int error;
        int32_t v;
        uint8_t buf[2];
        uint16_t val;
        char fmkey[5];

        ksnprintf(fmkey, sizeof(fmkey), ASMC_KEY_FANMANUAL_T2, fan);
        if (sc->sc_is_t2 &&
            apple_smc_key_getinfo(dev, fmkey, NULL, NULL) == 0) {
                error = apple_smc_key_read(dev, fmkey, buf, 1);
                if (error != 0) {
                        return (error);
                }
                v = buf[0] ? 1 : 0;
                error = sysctl_handle_int(oidp, &v, 0, req);
                if (error == 0 && req->newptr != NULL) {
                        if (v != 0 && v != 1) {
                                return (EINVAL);
                        }
                        buf[0] = (uint8_t)v;
                        error = apple_smc_key_write(dev, fmkey, buf, 1);
                }
                return (error);
        }

        error = apple_smc_key_read(dev, ASMC_KEY_FANMANUAL, buf, sizeof(buf));
        if (error != 0) {
                return (error);
        }

        val = (buf[0] << 8) | buf[1];
        v = (val >> fan) & 0x01;
        error = sysctl_handle_int(oidp, &v, 0, req);
        if (error == 0 && req->newptr != NULL) {
                if (v != 0 && v != 1) {
                        return (EINVAL);
                }
                error = apple_smc_key_read(dev, ASMC_KEY_FANMANUAL,
                    buf, sizeof(buf));
                if (error == 0) {
                        val = (buf[0] << 8) | buf[1];
                        if (v) {
                                val |= (1 << fan);
                        } else {
                                val &= ~(1 << fan);
                        }
                        buf[0] = val >> 8;
                        buf[1] = val & 0xff;
                        error = apple_smc_key_write(dev, ASMC_KEY_FANMANUAL,
                            buf, sizeof(buf));
                }
        }
        return (error);
}

int
apple_smc_temp_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        int error;
        int val;

        if (arg2 < 0 || arg2 >= sc->sc_temp_count) {
                return (EINVAL);
        }
        error = apple_smc_sensor_read(dev, sc->sc_temp_sensors[arg2], &val);
        if (error != 0) {
                return (error);
        }
        return (sysctl_handle_int(oidp, &val, 0, req));
}

int
apple_smc_dts_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        int error, val;

        if (arg2 < 0 || arg2 >= sc->sc_dts_count)
                return (EINVAL);
        error = apple_smc_sensor_read(dev, sc->sc_dts_sensors[arg2], &val);
        if (error != 0)
                return (error);
        /* Sentinel check: a disconnected key can return 0x8x00 at runtime too. */
        if (val <= -120000)
                return (ENODEV);
        /* DTS value is a negative offset from Tj,max; convert to absolute. */
        val = sc->sc_tj_max * 1000 + val;
        return (sysctl_handle_int(oidp, &val, 0, req));
}

int
apple_smc_sensor_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        int error, val;
        int sensor_type = (arg2 >> 8) & 0xFF;
        int sensor_idx  = arg2 & 0xFF;
        const char *key = NULL;

        switch (sensor_type) {
        case 'V':
                if (sensor_idx < sc->sc_voltage_count) {
                        key = sc->sc_voltage_sensors[sensor_idx];
                }
                break;
        case 'I':
                if (sensor_idx < sc->sc_current_count) {
                        key = sc->sc_current_sensors[sensor_idx];
                }
                break;
        case 'P':
                if (sensor_idx < sc->sc_power_count) {
                        key = sc->sc_power_sensors[sensor_idx];
                }
                break;
        case 'L':
                if (sensor_idx < sc->sc_light_count) {
                        key = sc->sc_light_sensors[sensor_idx];
                }
                break;
        default:
                return (EINVAL);
        }
        if (key == NULL) {
                return (ENOENT);
        }

        error = apple_smc_sensor_read(dev, key, &val);
        if (error != 0) {
                return (error);
        }
        return (sysctl_handle_int(oidp, &val, 0, req));
}

static int
apple_smc_sms_axis(device_t dev, const char *key,
    struct sysctl_oid *oidp, struct sysctl_req *req)
{
        int16_t val;
        int32_t v;
        int error;

        error = apple_smc_sms_read(dev, key, &val);
        if (error != 0) {
                return (error);
        }
        v = (int32_t)val;
        return (sysctl_handle_int(oidp, &v, 0, req));
}

static const char *apple_smc_sms_keys[] = {
        ASMC_KEY_SMS_X,         /* 0 */
        ASMC_KEY_SMS_Y,         /* 1 */
        ASMC_KEY_SMS_Z,         /* 2 */
};

int
apple_smc_mb_sysctl_sms(SYSCTL_HANDLER_ARGS)
{
        if (arg2 < 0 || arg2 >= (int)nitems(apple_smc_sms_keys))
                return (EINVAL);
        return (apple_smc_sms_axis((device_t)arg1, apple_smc_sms_keys[arg2],
            oidp, req));
}

static int
apple_smc_light_sensor(device_t dev, const char *key,
    struct sysctl_oid *oidp, struct sysctl_req *req)
{
        uint8_t buf[6];
        int error;
        int32_t v;

        error = apple_smc_key_read(dev, key, buf, sizeof(buf));
        if (error != 0) {
                return (error);
        }
        v = buf[2];
        return (sysctl_handle_int(oidp, &v, 0, req));
}

static const char *apple_smc_light_keys[] = {
        ASMC_KEY_LIGHTLEFT,     /* 0 */
        ASMC_KEY_LIGHTRIGHT,    /* 1 */
};

int
apple_smc_mbp_sysctl_light(SYSCTL_HANDLER_ARGS)
{
        if (arg2 < 0 || arg2 >= (int)nitems(apple_smc_light_keys))
                return (EINVAL);
        return (apple_smc_light_sensor((device_t)arg1,
            apple_smc_light_keys[arg2], oidp, req));
}

int
apple_smc_mbp_sysctl_light_left_10byte(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t buf[10];
        uint32_t v;
        int error;

        error = apple_smc_key_read(dev, ASMC_KEY_LIGHTLEFT, buf, sizeof(buf));
        if (error != 0) {
                return (error);
        }
        v = be32dec(&buf[6]);
        v = v >> 8;
        if (v > 255) {
                v = 255;
        }
        return (sysctl_handle_int(oidp, &v, 0, req));
}

int
apple_smc_mbp_sysctl_light_control(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        uint8_t buf[2];
        int error, v;

        v = light_control;
        error = sysctl_handle_int(oidp, &v, 0, req);
        if (error == 0 && req->newptr != NULL) {
                if (v < 0 || v > 255) {
                        return (EINVAL);
                }
                light_control = v;
                sc->sc_kbd_bkl_level = v * 100 / 255;
                buf[0] = light_control;
                buf[1] = 0x00;
                error = apple_smc_key_write(dev, ASMC_KEY_LIGHTVALUE, buf,
                    sizeof(buf));
        }
        return (error);
}

/*
 * Generic RW sysctl for single-byte flag keys (0 or 1).
 * arg1 = device_t, arg2 = pointer to 4-char SMC key name.
 */
int
apple_smc_flag_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        const char *key = (const char *)(intptr_t)arg2;
        uint8_t raw;
        int val, error;

        if (apple_smc_key_read(dev, key, &raw, 1) != 0)
                return (EIO);
        val = (raw != 0) ? 1 : 0;
        error = sysctl_handle_int(oidp, &val, 0, req);
        if (error != 0 || req->newptr == NULL)
                return (error);
        if (val != 0 && val != 1)
                return (EINVAL);
        raw = (uint8_t)val;
        return (apple_smc_key_write(dev, key, &raw, 1) != 0 ? EIO : 0);
}

int
apple_smc_bclm_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t bclm;
        int val, error;

        if (apple_smc_key_read(dev, ASMC_KEY_BCLM, &bclm, 1) != 0) {
                return (EIO);
        }
        val = (int)bclm;
        error = sysctl_handle_int(oidp, &val, 0, req);
        if (error != 0 || req->newptr == NULL) {
                return (error);
        }
        if (val < 0 || val > 100) {
                return (EINVAL);
        }
        bclm = (uint8_t)val;
        return (apple_smc_key_write(dev, ASMC_KEY_BCLM, &bclm, 1) != 0 ?
            EIO : 0);
}

static const char *
apple_smc_cause_str(int8_t cause)
{
        switch (cause) {
        case -128: return "power-loss";
        case -127: return "software-powerdown";
        case -125: return "thermtrip";
        case -50:  return "overtemp-shutdown";
        case -20:  return "watchdog";
        case -15:  return "battery-low";
        case 0:    return "unknown";
        case 1:    return "overtemp-sleep";
        case 3:    return "power-button";
        case 5:    return "good-shutdown";
        default:   return NULL;
        }
}

static const char *apple_smc_cause_keys[] = {
        ASMC_KEY_MSSD,          /* 0 */
        ASMC_KEY_MSSP,          /* 1 */
};

int
apple_smc_cause_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        const char *key, *desc;
        int8_t cause;
        char buf[48];

        if (arg2 < 0 || arg2 >= (int)nitems(apple_smc_cause_keys))
                return (EINVAL);
        key = apple_smc_cause_keys[arg2];

        if (apple_smc_key_read(dev, key, (uint8_t *)&cause, 1) != 0)
                return (EIO);
        desc = apple_smc_cause_str(cause);
        if (desc)
                ksnprintf(buf, sizeof(buf), "%d (%s)", (int)cause, desc);
        else
                ksnprintf(buf, sizeof(buf), "%d", (int)cause);
        return (sysctl_handle_string(oidp, buf, sizeof(buf), req));
}

int
apple_smc_msal_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t msal; char buf[80];

        if (apple_smc_key_read(dev, ASMC_KEY_MSAL, &msal, 1) != 0) {
                return (EIO);
        }
        /*
         * Bits 0x04, 0x10 and 0x20 are present in observed hardware values but
         * are not documented here yet, so report the raw byte and decode only the
         * known flags.
         */
        ksnprintf(buf, sizeof(buf),
            "0x%02x (tss=%d therm_valid=%d calib_valid=%d prochot=%d plimits=%d)",
            msal,
            (msal & 0x01) != 0, (msal & 0x02) != 0,
            (msal & 0x08) != 0, (msal & 0x40) != 0, (msal & 0x80) != 0);
        return (sysctl_handle_string(oidp, buf, sizeof(buf), req));
}

int
apple_smc_clkt_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t buf[4]; uint32_t secs;

        if (apple_smc_key_read(dev, ASMC_KEY_CLKT, buf, 4) != 0) {
                return (EIO);
        }
        secs = be32dec(buf);
        return (sysctl_handle_32(oidp, &secs, 0, req));
}

int
apple_smc_clwk_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t buf[2];
        uint32_t secs;
        int error;

        if (apple_smc_key_read(dev, ASMC_KEY_CLWK, buf, 2) != 0)
                return (EIO);

        /* CLWK is ui16 BE; 0 = disabled. */
        secs = be16dec(buf);
        error = sysctl_handle_32(oidp, &secs, 0, req);
        if (error != 0 || req->newptr == NULL)
                return (error);

        if (secs >= 86400)
                return (EINVAL);

        error = apple_smc_key_check_writable(dev, ASMC_KEY_CLWK);
        if (error != 0)
                return (error);

        be16enc(buf, (uint16_t)secs);
        if (apple_smc_key_write(dev, ASMC_KEY_CLWK, buf, 2) != 0)
                return (EIO);

        /* Verify write; retry as LE if readback mismatches. */
        if (apple_smc_key_read(dev, ASMC_KEY_CLWK, buf, 2) == 0) {
                uint16_t readback = be16dec(buf);
                if (readback != (uint16_t)secs) {
                        le16enc(buf, (uint16_t)secs);
                        return (apple_smc_key_write(dev, ASMC_KEY_CLWK,
                            buf, 2) != 0 ? EIO : 0);
                }
        }
        return (0);
}

int
apple_smc_msps_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t buf[2]; uint32_t state;

        if (apple_smc_key_read(dev, ASMC_KEY_MSPS, buf, 2) != 0) {
                return (EIO);
        }
        state = ((uint32_t)buf[0] << 8) | buf[1];
        return (sysctl_handle_32(oidp, &state, 0, req));
}

int
apple_smc_rplt_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t buf[9]; char name[9];

        memset(buf, 0, sizeof(buf));
        if (apple_smc_key_read(dev, ASMC_KEY_RPLT, buf, 8) != 0) {
                return (EIO);
        }
        memcpy(name, buf, 8);
        name[8] = '\0';
        return (sysctl_handle_string(oidp, name, sizeof(name), req));
}

int
apple_smc_rgen_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t gen; uint32_t val;

        if (apple_smc_key_read(dev, ASMC_KEY_RGEN, &gen, 1) != 0) {
                return (EIO);
        }
        val = gen;
        return (sysctl_handle_32(oidp, &val, 0, req));
}

int
apple_smc_raw_key_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        char newkey[ASMC_KEYLEN + 1];
        uint8_t keylen;
        int error;

        strlcpy(newkey, sc->sc_rawkey, sizeof(newkey));
        error = sysctl_handle_string(oidp, newkey, sizeof(newkey), req);
        if (error || req->newptr == NULL) {
                return (error);
        }
        if (strlen(newkey) != ASMC_KEYLEN) {
                return (EINVAL);
        }
        if (apple_smc_key_getinfo(dev, newkey, &keylen, sc->sc_rawtype) != 0) {
                return (ENOENT);
        }
        if (keylen > ASMC_MAXVAL) {
                keylen = ASMC_MAXVAL;
        }
        strlcpy(sc->sc_rawkey, newkey, sizeof(sc->sc_rawkey));
        sc->sc_rawlen = keylen;
        memset(sc->sc_rawval, 0, sizeof(sc->sc_rawval));
        /* Read may fail; allow setting key for subsequent write. */
        apple_smc_key_read(dev, sc->sc_rawkey, sc->sc_rawval,
            sc->sc_rawlen);
        return (0);
}

int
apple_smc_raw_value_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        char hexbuf[ASMC_MAXVAL * 2 + 1];
        int error, i;

        if (sc->sc_rawkey[0] != '\0') {
                error = apple_smc_key_read(dev, sc->sc_rawkey, sc->sc_rawval,
                    sc->sc_rawlen > 0 ? sc->sc_rawlen : ASMC_MAXVAL);
                if (error != 0) {
                        return (error);
                }
        }

        for (i = 0; i < sc->sc_rawlen && i < ASMC_MAXVAL; i++) {
                ksnprintf(hexbuf + i * 2, 3, "%02x", sc->sc_rawval[i]);
        }
        hexbuf[i * 2] = '\0';

        error = sysctl_handle_string(oidp, hexbuf, sizeof(hexbuf), req);
        if (error || req->newptr == NULL) {
                return (error);
        }
        if (sc->sc_rawkey[0] == '\0') {
                return (EINVAL);
        }

        memset(sc->sc_rawval, 0, sizeof(sc->sc_rawval));
        for (i = 0; i < sc->sc_rawlen && hexbuf[i*2] && hexbuf[i*2+1]; i++) {
                unsigned int val;
                char tmp[3] = { hexbuf[i*2], hexbuf[i*2+1], 0 };

                if (ksscanf(tmp, "%02x", &val) == 1) {
                        sc->sc_rawval[i] = (uint8_t)val;
                }
        }
        return (apple_smc_key_write(dev, sc->sc_rawkey,
            sc->sc_rawval, sc->sc_rawlen) != 0 ? EIO : 0);
}

int
apple_smc_raw_len_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        int v = sc->sc_rawlen;
        return (sysctl_handle_int(oidp, &v, 0, req));
}

int
apple_smc_raw_type_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        return (sysctl_handle_string(oidp, sc->sc_rawtype,
            sizeof(sc->sc_rawtype), req));
}

int
apple_smc_raw_index_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        int idx = -1, error;
        char keyname[ASMC_KEYLEN + 1];
        uint8_t keylen;

        error = sysctl_handle_int(oidp, &idx, 0, req);
        if (error || req->newptr == NULL)
                return (error);
        if (idx < 0 || idx >= sc->sc_nkeys)
                return (EINVAL);

        error = apple_smc_key_dump_by_index(dev, idx, keyname,
            sc->sc_rawtype, &keylen);
        if (error != 0)
                return (EIO);
        strlcpy(sc->sc_rawkey, keyname, sizeof(sc->sc_rawkey));
        sc->sc_rawlen = keylen;
        memset(sc->sc_rawval, 0, sizeof(sc->sc_rawval));
        apple_smc_key_read(dev, sc->sc_rawkey, sc->sc_rawval, sc->sc_rawlen);
        return (0);
}

/* G3AO sysctl handler. */
int
apple_smc_g3ao_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t buf[4];
        uint32_t ts;
        int error;

        if (apple_smc_key_read(dev, ASMC_KEY_G3AO, buf, 4) != 0)
                return (EIO);
        ts = be32dec(buf);
        error = sysctl_handle_32(oidp, &ts, 0, req);
        if (error != 0 || req->newptr == NULL)
                return (error);

        error = apple_smc_key_check_writable(dev, ASMC_KEY_G3AO);
        if (error != 0)
                return (error);

        be32enc(buf, ts);
        return (apple_smc_key_write(dev, ASMC_KEY_G3AO, buf, 4) != 0 ?
            EIO : 0);
}


/* AUWT sysctl handler. */
int
apple_smc_auwt_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t buf[2];
        uint32_t secs;
        int error;

        if (apple_smc_key_read(dev, ASMC_KEY_AUWT, buf, 2) != 0)
                return (EIO);
        secs = be16dec(buf);
        error = sysctl_handle_32(oidp, &secs, 0, req);
        if (error != 0 || req->newptr == NULL)
                return (error);
        if (secs > 65535)
                return (EINVAL);
        be16enc(buf, (uint16_t)secs);
        return (apple_smc_key_write(dev, ASMC_KEY_AUWT, buf, 2) != 0 ?
            EIO : 0);
}

/* DPBR sysctl handler. */
int
apple_smc_dpbr_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t buf[2];
        uint32_t val;

        if (apple_smc_key_read(dev, ASMC_KEY_DPBR, buf, 2) != 0)
                return (EIO);
        val = be16dec(buf);
        return (sysctl_handle_32(oidp, &val, 0, req));
}

/* ENV0 sysctl handler. */
int
apple_smc_env0_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        uint8_t val;
        uint32_t v;

        if (apple_smc_key_read(dev, ASMC_KEY_ENV0, &val, 1) != 0)
                return (EIO);
        v = val;
        return (sysctl_handle_32(oidp, &v, 0, req));
}


int
apple_smc_prochot_override_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        int val, error;
        uint64_t msr;

        val = sc->sc_prochot_override;
        error = sysctl_handle_int(oidp, &val, 0, req);
        if (error || req->newptr == NULL)
                return (error);

        if (val != 0 && val != 1)
                return (EINVAL);
        if (val == sc->sc_prochot_override)
                return (0);

        if (rdmsr_safe(MSR_IA32_POWER_CTL, &msr) != 0)
                return (EIO);

        if (val)
                msr &= ~(uint64_t)IA32_POWER_CTL_BD_PROCHOT;
        else
                msr |= IA32_POWER_CTL_BD_PROCHOT;

        if (wrmsr_safe(MSR_IA32_POWER_CTL, msr) != 0)
                return (EIO);

        if (!val) {
                if (sc->sc_thermal_running) {
                        sc->sc_thermal_enabled = 0;
                        apple_smc_thermal_fans_to_max(dev);
                }
                apple_smc_fan_release_manual(dev);
        }

        sc->sc_prochot_override = val;
        return (0);
}