/*-
 * Copyright (c) 2013 Phileas Fogg
 * 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/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/device.h>
#include <sys/proc.h>
#include <sys/mutex.h>
#include <sys/time.h>
#include <sys/reboot.h>
#include <sys/sysctl.h>
#include <sys/kthread.h>

#include <machine/autoconf.h>

#include <dev/ofw/openfirm.h>
#include <dev/i2c/i2cvar.h>
#include <dev/clock_subr.h>
#include <dev/sysmon/sysmonvar.h>
#include <dev/sysmon/sysmon_taskq.h>

#include <macppc/dev/obiovar.h>
#include <macppc/dev/smuvar.h>
#include <macppc/dev/fancontrolvar.h>

#include "opt_smu.h"

struct smu_softc;

struct smu_cmd {
        u_char cmd;
        u_char len;
        u_char data[254];
};

struct smu_fan {
        struct smu_softc* sc;

        char location[32];
        int reg;
        int zone;
        int rpm_ctl;
        int min_rpm;
        int max_rpm;
        int default_rpm;
        int wanted_rpm;
        int current_rpm;
        int fault;
        time_t last_update;
};

struct smu_iicbus {
        struct smu_softc* sc;

        int reg;
        struct i2c_controller i2c;
};

#define SMU_MAX_FANS            8
#define SMU_MAX_IICBUS          3
#define SMU_MAX_SME_SENSORS     (SMU_MAX_FANS + 8)


#define SMU_ZONE_CPU            0
#define SMU_ZONE_CASE           1
#define SMU_ZONE_DRIVEBAY       2
#define SMU_ZONES               3

#define C_TO_uK(n) (n * 1000000 + 273150000)

struct smu_softc {
        device_t sc_dev;
        int sc_node;
        struct sysctlnode *sc_sysctl_me;

        kmutex_t sc_cmd_lock;
        kmutex_t sc_msg_lock;
        struct smu_cmd *sc_cmd;
        paddr_t sc_cmd_paddr;
        int sc_dbell_mbox;
        int sc_dbell_gpio;

        int sc_num_fans;
        struct smu_fan sc_fans[SMU_MAX_FANS];

        int sc_num_iicbus;
        struct smu_iicbus sc_iicbus[SMU_MAX_IICBUS];

        struct todr_chip_handle sc_todr;

        struct sysmon_envsys *sc_sme;
        envsys_data_t sc_sme_sensors[SMU_MAX_SME_SENSORS];
        uint32_t cpu_m;
        int32_t  cpu_b;

        fancontrol_zone_t sc_zones[SMU_ZONES];
        lwp_t *sc_thread;
        bool sc_dying;
};

#define SMU_CMD_FAN     0x4a
#define SMU_CMD_RTC     0x8e
#define SMU_CMD_I2C     0x9a
#define SMU_CMD_POWER   0xaa
#define SMU_CMD_ADC     0xd8
#define SMU_MISC        0xee
#define  SMU_MISC_GET_DATA      0x02
#define  SMU_MISC_LED_CTRL      0x04

#define SMU_CPUTEMP_CAL 0x18
#define SMU_CPUVOLT_CAL 0x21
#define SMU_SLOTPW_CAL  0x78

#define SMU_PARTITION           0x3e
#define SMU_PARTITION_LATEST    0x01
#define SMU_PARTITION_BASE      0x02
#define SMU_PARTITION_UPDATE    0x03

#ifdef SMU_DEBUG
#define DPRINTF printf
#else
#define DPRINTF while (0) printf
#endif

static int smu_match(device_t, struct cfdata *, void *);
static void smu_attach(device_t, device_t, void *);
static int smu_setup_doorbell(struct smu_softc *);
static void smu_setup_fans(struct smu_softc *);
static void smu_setup_iicbus(struct smu_softc *);
static void smu_setup_sme(struct smu_softc *);
static int smu_iicbus_print(void *, const char *);
static void smu_sme_refresh(struct sysmon_envsys *, envsys_data_t *);
static int smu_do_cmd(struct smu_softc *, struct smu_cmd *, int);
static int smu_dbell_gpio_intr(void *);
static int smu_todr_gettime_ymdhms(todr_chip_handle_t, struct clock_ymdhms *);
static int smu_todr_settime_ymdhms(todr_chip_handle_t, struct clock_ymdhms *);
static int smu_fan_update_rpm(struct smu_fan *);
static int smu_read_adc(struct smu_softc *, int);

static int smu_iicbus_exec(void *, i2c_op_t, i2c_addr_t, const void *,
    size_t, void *, size_t, int);

static void smu_setup_zones(struct smu_softc *);
static void smu_adjust(void *);

static bool is_cpu_sensor(const envsys_data_t *);
static bool is_drive_sensor(const envsys_data_t *);
static bool is_slots_sensor(const envsys_data_t *);
static int smu_fan_get_rpm(void *, int);
static int smu_fan_set_rpm(void *, int, int);

int smu_get_datablock(int, uint8_t *, size_t);

CFATTACH_DECL_NEW(smu, sizeof(struct smu_softc),
    smu_match, smu_attach, NULL, NULL);

static struct smu_softc *smu0 = NULL;

static int
smu_match(device_t parent, struct cfdata *cf, void *aux)
{
        struct confargs *ca = aux;

        if (strcmp(ca->ca_name, "smu") == 0)
                return 5;
        
        return 0;
}

static void
smu_attach(device_t parent, device_t self, void *aux)
{
        struct confargs *ca = aux;
        struct smu_softc *sc = device_private(self);
        uint16_t data[4];

        sc->sc_dev = self;
        sc->sc_node = ca->ca_node;

        if (smu0 == NULL)
                smu0 = sc;

        sysctl_createv(NULL, 0, NULL, (void *) &sc->sc_sysctl_me,
            CTLFLAG_READWRITE,
            CTLTYPE_NODE, device_xname(sc->sc_dev), NULL,
            NULL, 0, NULL, 0,
            CTL_MACHDEP, CTL_CREATE, CTL_EOL);

        if (smu_setup_doorbell(sc) != 0) {
                aprint_normal(": unable to set up doorbell\n");
                return;
        }

        aprint_normal("\n");

        smu_setup_fans(sc);
        smu_setup_iicbus(sc);

        sc->sc_todr.todr_gettime_ymdhms = smu_todr_gettime_ymdhms;
        sc->sc_todr.todr_settime_ymdhms = smu_todr_settime_ymdhms;
        sc->sc_todr.todr_dev = self;
        todr_attach(&sc->sc_todr);

        /* calibration data */
        memset(data, 0, 8);     
        smu_get_datablock(SMU_CPUTEMP_CAL, (void *)data, 8);
        DPRINTF("data %04x %04x %04x %04x\n", data[0], data[1], data[2], data[3]);
        sc->cpu_m = data[2]; 
        sc->cpu_b = (int16_t)data[3];

        smu_setup_sme(sc);

        smu_setup_zones(sc);
}

static int
smu_setup_doorbell(struct smu_softc *sc)
{
        int node, parent, reg[4], gpio_base, irq;

        mutex_init(&sc->sc_cmd_lock, MUTEX_DEFAULT, IPL_NONE);
        sc->sc_cmd = malloc(4096, M_DEVBUF, M_WAITOK);
        sc->sc_cmd_paddr = vtophys((vaddr_t) sc->sc_cmd);

        DPRINTF("%s: cmd vaddr 0x%x paddr 0x%x\n",
            __func__, (unsigned int) sc->sc_cmd,
            (unsigned int) sc->sc_cmd_paddr);

        if (OF_getprop(sc->sc_node, "platform-doorbell-buff",
                &node, sizeof(node)) <= 0)
                return -1;

        if (OF_getprop(node, "platform-do-doorbell-buff",
                reg, sizeof(reg)) < sizeof(reg))
                return -1;

        sc->sc_dbell_mbox = reg[3];

        if (OF_getprop(sc->sc_node, "platform-doorbell-ack",
                &node, sizeof(node)) <= 0)
                return -1;

        parent = OF_parent(node);
        if (parent == 0)
                return -1;

        if (OF_getprop(parent, "reg", &gpio_base, sizeof(gpio_base)) <= 0)
                return -1;

        if (OF_getprop(node, "reg", reg, sizeof(reg)) <= 0)
                return -1;

        if (OF_getprop(node, "interrupts", &irq, sizeof(irq)) <= 0)
                return -1;

        sc->sc_dbell_gpio = gpio_base + reg[0];

        aprint_normal(" mbox 0x%x gpio 0x%x irq %d",
            sc->sc_dbell_mbox, sc->sc_dbell_gpio, irq);

        intr_establish_xname(irq, IST_EDGE_FALLING, IPL_TTY,
            smu_dbell_gpio_intr, sc, device_xname(sc->sc_dev));

        return 0;
}

static void
smu_setup_fans(struct smu_softc *sc)
{
        struct smu_fan *fan;
        char type[32];
        int node, i;
        const char *fans[] = { "fans", "rpm-fans", 0 };
        int n = 0;
        
        while (fans[n][0] != 0) {
                node = of_getnode_byname(sc->sc_node, fans[n]);
                for (node = OF_child(node);
                    (node != 0) && (sc->sc_num_fans < SMU_MAX_FANS);
                    node = OF_peer(node)) {
                        fan = &sc->sc_fans[sc->sc_num_fans];
                        fan->sc = sc;

                        memset(fan->location, 0, sizeof(fan->location));
                        OF_getprop(node, "location", fan->location,
                            sizeof(fan->location));

                        if (OF_getprop(node, "reg", &fan->reg,
                                sizeof(fan->reg)) <= 0)
                                continue;

                        if (OF_getprop(node, "zone", &fan->zone ,
                                sizeof(fan->zone)) <= 0)
                                continue;

                        memset(type, 0, sizeof(type));
                        OF_getprop(node, "device_type", type, sizeof(type));
                        if (strcmp(type, "fan-rpm-control") == 0)
                                fan->rpm_ctl = 1;
                        else
                                fan->rpm_ctl = 0;

                        if (OF_getprop(node, "min-value", &fan->min_rpm,
                            sizeof(fan->min_rpm)) <= 0)
                                fan->min_rpm = 0;

                        if (OF_getprop(node, "max-value", &fan->max_rpm,
                            sizeof(fan->max_rpm)) <= 0)
                                fan->max_rpm = 0xffff;

                        if (OF_getprop(node, "unmanage-value", &fan->default_rpm,
                            sizeof(fan->default_rpm)) <= 0)
                                fan->default_rpm = fan->max_rpm;

                        DPRINTF("fan: location %s reg %x zone %d rpm_ctl %d "
                            "min_rpm %d max_rpm %d default_rpm %d\n",
                            fan->location, fan->reg, fan->zone, fan->rpm_ctl,
                            fan->min_rpm, fan->max_rpm, fan->default_rpm);

                        fan->wanted_rpm = fan->default_rpm;
                        fan->fault = 0; 
                        sc->sc_num_fans++;
                }
                n++;
        }

        for (i = 0; i < sc->sc_num_fans; i++) {
                fan = &sc->sc_fans[i];
                smu_fan_set_rpm(sc, i, fan->default_rpm);
                smu_fan_update_rpm(fan);
        }
}

static void
smu_setup_iicbus(struct smu_softc *sc)
{
        struct smu_iicbus *iicbus;
        struct i2c_controller *i2c;
        struct smu_iicbus_confargs ca;
        int node;
        char name[32];

        devhandle_t selfh = device_handle(sc->sc_dev);
        node = of_getnode_byname(sc->sc_node, "smu-i2c-control");
        if (node == 0) node = sc->sc_node;
        for (node = OF_child(node);
            (node != 0) && (sc->sc_num_iicbus < SMU_MAX_IICBUS);
            node = OF_peer(node)) {
                memset(name, 0, sizeof(name));
                OF_getprop(node, "name", name, sizeof(name));
                if ((strcmp(name, "i2c-bus") != 0) &&
                    (strcmp(name, "i2c") != 0))
                        continue;

                iicbus = &sc->sc_iicbus[sc->sc_num_iicbus];
                iicbus->sc = sc;
                i2c = &iicbus->i2c;

                if (OF_getprop(node, "reg", &iicbus->reg, sizeof(iicbus->reg)) <= 0)
                        continue;

                DPRINTF("iicbus: reg %x\n", iicbus->reg);

                iic_tag_init(i2c);
                i2c->ic_cookie = iicbus;
                i2c->ic_exec = smu_iicbus_exec;

                ca.ca_name = name;
                ca.ca_node = node;
                ca.ca_tag = i2c;
                config_found(sc->sc_dev, &ca, smu_iicbus_print,
                    CFARGS(.devhandle = devhandle_from_of(selfh, node)));

                sc->sc_num_iicbus++;
        }
}

static void
smu_setup_sme(struct smu_softc *sc)
{
        struct smu_fan *fan;
        envsys_data_t *sme_sensor;
        int i, sensors, child, reg;
        char loc[32], type[32];

        sc->sc_sme = sysmon_envsys_create();

        for (i = 0; i < sc->sc_num_fans; i++) {
                sme_sensor = &sc->sc_sme_sensors[i];
                fan = &sc->sc_fans[i];

                sme_sensor->units = ENVSYS_SFANRPM;
                sme_sensor->state = ENVSYS_SINVALID;
                snprintf(sme_sensor->desc, sizeof(sme_sensor->desc),
                    "%s", fan->location);

                if (sysmon_envsys_sensor_attach(sc->sc_sme, sme_sensor)) {
                        sysmon_envsys_destroy(sc->sc_sme);
                        return;
                }
        }
        sensors = OF_finddevice("/smu/sensors");
        child = OF_child(sensors);
        while (child != 0) {
                sme_sensor = &sc->sc_sme_sensors[i];
                if (OF_getprop(child, "location", loc, 32) == 0) goto next;
                if (OF_getprop(child, "device_type", type, 32) == 0) goto next;
                if (OF_getprop(child, "reg", &reg, 4) == 0) goto next;
                if (strcmp(type, "temp-sensor") == 0) {
                        sme_sensor->units = ENVSYS_STEMP;
                        sme_sensor->state = ENVSYS_SINVALID;
                        strncpy(sme_sensor->desc, loc, sizeof(sme_sensor->desc));
                        sme_sensor->private = reg;
                        sysmon_envsys_sensor_attach(sc->sc_sme, sme_sensor);
                        i++;
                        printf("%s: %s@%x\n", loc, type, reg); 
                }
next:
                child = OF_peer(child);
        }
                                                
        sc->sc_sme->sme_name = device_xname(sc->sc_dev);
        sc->sc_sme->sme_cookie = sc;
        sc->sc_sme->sme_refresh = smu_sme_refresh;

        if (sysmon_envsys_register(sc->sc_sme)) {
                aprint_error_dev(sc->sc_dev,
                    "unable to register with sysmon\n");
                sysmon_envsys_destroy(sc->sc_sme);
        }
}

static int
smu_iicbus_print(void *aux, const char *smu)
{
        struct smu_iicbus_confargs *ca = aux;

        if (smu)
                aprint_normal("%s at %s", ca->ca_name, smu);

        return UNCONF;
}

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

        edata->state = ENVSYS_SINVALID;

        if (which < sc->sc_num_fans) {

                ret = smu_fan_get_rpm(sc, which);
                if (ret != -1) {
                        sc->sc_fans[which].current_rpm = ret;
                        edata->value_cur = ret;
                        edata->state = ENVSYS_SVALID;
                }
        } else if (edata->private > 0) {
                /* this works only for the CPU diode */
                int64_t r = smu_read_adc(sc, edata->private);
                if (r != -1) {
                        r = r * sc->cpu_m;
                        r >>= 3;
                        r += (int64_t)sc->cpu_b << 9;
                        r <<= 1;
                        r *= 15625;
                        r /= 1024;
                        edata->value_cur = r + 273150000;
                        edata->state = ENVSYS_SVALID;
                }
        }
}

static int
smu_do_cmd(struct smu_softc *sc, struct smu_cmd *cmd, int timo)
{
        int gpio, ret, bail;
        u_char ack;

        mutex_enter(&sc->sc_cmd_lock);

        DPRINTF("%s: cmd %02x len %02x\n", __func__, cmd->cmd, cmd->len);
        DPRINTF("%s: data %02x %02x %02x %02x %02x %02x %02x %02x\n", __func__,
            cmd->data[0], cmd->data[1], cmd->data[2], cmd->data[3],
            cmd->data[4], cmd->data[5], cmd->data[6], cmd->data[7]);

        sc->sc_cmd->cmd = cmd->cmd;
        sc->sc_cmd->len = cmd->len;
        memcpy(sc->sc_cmd->data, cmd->data, cmd->len);

        __asm volatile ("dcbf 0,%0; sync" :: "r"(sc->sc_cmd) : "memory");

        obio_write_4(sc->sc_dbell_mbox, sc->sc_cmd_paddr);
        obio_write_1(sc->sc_dbell_gpio, 0x04);

        bail = 0;

        gpio = obio_read_1(sc->sc_dbell_gpio);

        while (((gpio & 0x07) != 0x07) && (bail < timo)) {
                ret = tsleep(sc->sc_cmd, PWAIT, "smu_cmd", mstohz(10));
                if (ret != 0) {
                        bail++;
                }
                gpio = obio_read_1(sc->sc_dbell_gpio);
        }

        if ((gpio & 0x07) != 0x07) {
                mutex_exit(&sc->sc_cmd_lock);
                return EWOULDBLOCK;
        }
                
        __asm volatile ("dcbf 0,%0; sync" :: "r"(sc->sc_cmd) : "memory");

        ack = (~cmd->cmd) & 0xff;
        if (sc->sc_cmd->cmd != ack) {
                DPRINTF("%s: invalid ack, got %x expected %x\n",
                    __func__, sc->sc_cmd->cmd, ack);
                mutex_exit(&sc->sc_cmd_lock);
                return EIO;
        }

        cmd->cmd = sc->sc_cmd->cmd;
        cmd->len = sc->sc_cmd->len;
        memcpy(cmd->data, sc->sc_cmd->data, sc->sc_cmd->len);

        mutex_exit(&sc->sc_cmd_lock);

        return 0;
}


static int
smu_dbell_gpio_intr(void *arg)
{
        struct smu_softc *sc = arg;

        DPRINTF("%s\n", __func__);

        wakeup(sc->sc_cmd);

        return 1;
}

void
smu_poweroff(void)
{
        struct smu_cmd cmd;

        if (smu0 == NULL)
                return;

        cmd.cmd = SMU_CMD_POWER;
        strcpy(cmd.data, "SHUTDOWN");
        cmd.len = strlen(cmd.data) + 1;
        smu_do_cmd(smu0, &cmd, 800);

        for (;;);
}

void
smu_restart(void)
{
        struct smu_cmd cmd;

        if (smu0 == NULL)
                return;

        cmd.cmd = SMU_CMD_POWER;
        strcpy(cmd.data, "RESTART");
        cmd.len = strlen(cmd.data) + 1;
        smu_do_cmd(smu0, &cmd, 800);

        for (;;);
}

static int
smu_todr_gettime_ymdhms(todr_chip_handle_t tch, struct clock_ymdhms *dt)
{
        struct smu_softc *sc = device_private(tch->todr_dev);
        struct smu_cmd cmd;
        int ret;

        cmd.cmd = SMU_CMD_RTC;
        cmd.len = 1;
        cmd.data[0] = 0x81;

        ret = smu_do_cmd(sc, &cmd, 800);
        if (ret != 0)
                return ret;

        dt->dt_sec = bcdtobin(cmd.data[0]);
        dt->dt_min = bcdtobin(cmd.data[1]);
        dt->dt_hour = bcdtobin(cmd.data[2]);
        dt->dt_wday = bcdtobin(cmd.data[3]);
        dt->dt_day = bcdtobin(cmd.data[4]);
        dt->dt_mon = bcdtobin(cmd.data[5]);
        dt->dt_year = bcdtobin(cmd.data[6]) + 2000;

        return 0;
}

static int
smu_todr_settime_ymdhms(todr_chip_handle_t tch, struct clock_ymdhms *dt)
{
        struct smu_softc *sc = device_private(tch->todr_dev);
        struct smu_cmd cmd;

        cmd.cmd = SMU_CMD_RTC;
        cmd.len = 8;
        cmd.data[0] = 0x80;
        cmd.data[1] = bintobcd(dt->dt_sec);
        cmd.data[2] = bintobcd(dt->dt_min);
        cmd.data[3] = bintobcd(dt->dt_hour);
        cmd.data[4] = bintobcd(dt->dt_wday);
        cmd.data[5] = bintobcd(dt->dt_day);
        cmd.data[6] = bintobcd(dt->dt_mon);
        cmd.data[7] = bintobcd(dt->dt_year - 2000);

        return smu_do_cmd(sc, &cmd, 800);
}

static int
smu_fan_update_rpm(struct smu_fan *fan)
{
        struct smu_softc *sc = fan->sc;
        struct smu_cmd cmd;
        int ret, diff;

        cmd.cmd = SMU_CMD_FAN;
        cmd.len = 2;
        cmd.data[0] = 0x31;
        cmd.data[1] = fan->reg;

        ret = smu_do_cmd(sc, &cmd, 800);
        if (ret == 0) {
                fan->last_update = time_uptime;
                fan->current_rpm = (cmd.data[0] << 8) | cmd.data[1];
        } else {
                cmd.cmd = SMU_CMD_FAN;
                cmd.len = 1;
                cmd.data[0] = 0x01;

                ret = smu_do_cmd(sc, &cmd, 800);
                if (ret == 0) {
                        fan->last_update = time_uptime;
                        fan->current_rpm = (cmd.data[1 + fan->reg * 2] << 8) |
                            cmd.data[2 + fan->reg * 2];
                }
        }
        diff = abs(fan->current_rpm - fan->wanted_rpm);
        if (diff > fan->max_rpm >> 3) {
                fan->fault++;
        } else fan->fault = 0;
        return ret;
}

static int
smu_fan_get_rpm(void *cookie, int which)
{
        struct smu_softc *sc = cookie;
        struct smu_fan *fan = &sc->sc_fans[which];
        int ret;
        ret = 0;

        if (time_uptime - fan->last_update > 1) {
                ret = smu_fan_update_rpm(fan);
                if (ret != 0)
                        return -1;
        }

        return fan->current_rpm;
}

static int
smu_fan_set_rpm(void *cookie, int which, int rpm)
{
        struct smu_softc *sc = cookie;
        struct smu_fan *fan = &sc->sc_fans[which];
        struct smu_cmd cmd;
        int ret;

        DPRINTF("%s: fan %s rpm %d\n", __func__, fan->location, rpm);

        rpm = uimax(fan->min_rpm, rpm);
        rpm = uimin(fan->max_rpm, rpm);

        fan->wanted_rpm = rpm;

        cmd.cmd = SMU_CMD_FAN;
        cmd.len = 4;
        cmd.data[0] = 0x30;
        cmd.data[1] = fan->reg;
        cmd.data[2] = (rpm >> 8) & 0xff;
        cmd.data[3] = rpm & 0xff;

        ret = smu_do_cmd(sc, &cmd, 800);
        if (ret != 0) {
                cmd.cmd = SMU_CMD_FAN;
                cmd.len = 14;
                cmd.data[0] = fan->rpm_ctl ? 0x00 : 0x10;
                cmd.data[1] = 1 << fan->reg;
                cmd.data[2] = cmd.data[2 + fan->reg * 2] = (rpm >> 8) & 0xff;
                cmd.data[3] = cmd.data[3 + fan->reg * 2] = rpm & 0xff;

                ret = smu_do_cmd(sc, &cmd, 800);
        }

        return ret;
}

static int
smu_read_adc(struct smu_softc *sc, int id)
{
        struct smu_cmd cmd;
        int ret;

        cmd.cmd = SMU_CMD_ADC;
        cmd.len = 1;
        cmd.data[0] = id;

        ret = smu_do_cmd(sc, &cmd, 800);
        if (ret == 0) {
                return cmd.data[0] << 8 | cmd.data[1];
        }
        return -1;
}

static int
smu_iicbus_exec(void *cookie, i2c_op_t op, i2c_addr_t addr, const void *send,
    size_t send_len, void *recv, size_t recv_len, int flags)
{
        struct smu_iicbus *iicbus = cookie;
        struct smu_softc *sc = iicbus->sc;
        struct smu_cmd cmd;
        int retries, ret;

        DPRINTF("%s: op %x addr %x send_len %d recv_len %d\n",
            __func__, op, addr, send_len, recv_len);

        cmd.cmd = SMU_CMD_I2C;
        cmd.len = 9 + recv_len;
        cmd.data[0] = iicbus->reg;
        cmd.data[1] = I2C_OP_READ_P(op) ? 0x02 : 0x00;
        cmd.data[2] = addr << 1;
        cmd.data[3] = send_len;
        memcpy(&cmd.data[4], send, send_len);
        cmd.data[7] = addr << 1;
        if (I2C_OP_READ_P(op))
                cmd.data[7] |= 0x01;
        cmd.data[8] = recv_len;
        memcpy(&cmd.data[9], recv, recv_len);

        ret = smu_do_cmd(sc, &cmd, 800);
        if (ret != 0)
                return (ret);

        for (retries = 0; retries < 10; retries++) {
                cmd.cmd = SMU_CMD_I2C;
                cmd.len = 1;
                cmd.data[0] = 0x00;
                memset(&cmd.data[1], 0xff, recv_len);

                ret = smu_do_cmd(sc, &cmd, 800);

                DPRINTF("%s: cmd data[0] %x\n", __func__, cmd.data[0]);

                if (ret == 0 && (cmd.data[0] & 0x80) == 0)
                        break;

                DELAY(10000);
        }

        if (cmd.data[0] & 0x80)
                return EIO;

        if (I2C_OP_READ_P(op))
                memcpy(recv, &cmd.data[1], recv_len);

        return 0;
}

SYSCTL_SETUP(smu_sysctl_setup, "SMU sysctl subtree setup")
{
        sysctl_createv(NULL, 0, NULL, NULL,
            CTLFLAG_PERMANENT, CTLTYPE_NODE, "machdep", NULL,
            NULL, 0, NULL, 0, CTL_MACHDEP, CTL_EOL);
}

static void
smu_setup_zones(struct smu_softc *sc)
{
        struct smu_fan *f;
        fancontrol_zone_t *z;
        int i;

        /* init zones */
        sc->sc_zones[SMU_ZONE_CPU].name = "CPUs";
        sc->sc_zones[SMU_ZONE_CPU].filter = is_cpu_sensor;
        sc->sc_zones[SMU_ZONE_CPU].cookie = sc;
        sc->sc_zones[SMU_ZONE_CPU].get_rpm = smu_fan_get_rpm;
        sc->sc_zones[SMU_ZONE_CPU].set_rpm = smu_fan_set_rpm;
        sc->sc_zones[SMU_ZONE_CPU].Tmin = 45;
        sc->sc_zones[SMU_ZONE_CPU].Tmax = 80;
        sc->sc_zones[SMU_ZONE_CPU].nfans = 0;
        sc->sc_zones[SMU_ZONE_CASE].name = "Slots";
        sc->sc_zones[SMU_ZONE_CASE].filter = is_slots_sensor;
        sc->sc_zones[SMU_ZONE_CASE].cookie = sc;
        sc->sc_zones[SMU_ZONE_CASE].Tmin = 50;
        sc->sc_zones[SMU_ZONE_CASE].Tmax = 75;
        sc->sc_zones[SMU_ZONE_CASE].nfans = 0;
        sc->sc_zones[SMU_ZONE_CASE].get_rpm = smu_fan_get_rpm;
        sc->sc_zones[SMU_ZONE_CASE].set_rpm = smu_fan_set_rpm;
        sc->sc_zones[SMU_ZONE_DRIVEBAY].name = "Drivebays";
        sc->sc_zones[SMU_ZONE_DRIVEBAY].filter = is_drive_sensor;
        sc->sc_zones[SMU_ZONE_DRIVEBAY].cookie = sc;
        sc->sc_zones[SMU_ZONE_DRIVEBAY].get_rpm = smu_fan_get_rpm;
        sc->sc_zones[SMU_ZONE_DRIVEBAY].set_rpm = smu_fan_set_rpm;
        sc->sc_zones[SMU_ZONE_DRIVEBAY].Tmin = 30;
        sc->sc_zones[SMU_ZONE_DRIVEBAY].Tmax = 50;
        sc->sc_zones[SMU_ZONE_DRIVEBAY].nfans = 0;

        /* find CPU fans */
        z = &sc->sc_zones[SMU_ZONE_CPU];
        for (i = 0; i < SMU_MAX_FANS; i++) {
                f = &sc->sc_fans[i];
                if ((strstr(f->location, "CPU") != NULL) || 
                    (strstr(f->location, "System") != NULL)) {
                        z->fans[z->nfans].num = i;
                        z->fans[z->nfans].min_rpm = f->min_rpm;
                        z->fans[z->nfans].max_rpm = f->max_rpm;
                        z->fans[z->nfans].name = f->location;
                        z->nfans++;
                }
        }
        aprint_normal_dev(sc->sc_dev,
            "using %d fans for CPU zone\n", z->nfans);

        z = &sc->sc_zones[SMU_ZONE_DRIVEBAY];
        for (i = 0; i < SMU_MAX_FANS; i++) {
                f = &sc->sc_fans[i];
                if ((strstr(f->location, "DRIVE") != NULL) ||
                    (strstr(f->location, "Drive") != NULL)) {
                        z->fans[z->nfans].num = i;
                        z->fans[z->nfans].min_rpm = f->min_rpm;
                        z->fans[z->nfans].max_rpm = f->max_rpm;
                        z->fans[z->nfans].name = f->location;
                        z->nfans++;
                }
        }
        aprint_normal_dev(sc->sc_dev,
            "using %d fans for drive bay zone\n", z->nfans);

        z = &sc->sc_zones[SMU_ZONE_CASE];
        for (i = 0; i < SMU_MAX_FANS; i++) {
                f = &sc->sc_fans[i];
                if ((strstr(f->location, "BACKSIDE") != NULL) ||
                    (strstr(f->location, "SLOTS") != NULL)) {
                        z->fans[z->nfans].num = i;
                        z->fans[z->nfans].min_rpm = f->min_rpm;
                        z->fans[z->nfans].max_rpm = f->max_rpm;
                        z->fans[z->nfans].name = f->location;
                        z->nfans++;
                }
        }
        aprint_normal_dev(sc->sc_dev,
            "using %d fans for expansion slots zone\n", z->nfans);

        /* setup sysctls for our zones etc. */
        for (i = 0; i < SMU_ZONES; i++) {
                fancontrol_init_zone(&sc->sc_zones[i], sc->sc_sysctl_me);
        }

        sc->sc_dying = false;
        kthread_create(PRI_NONE, 0, curcpu(), smu_adjust, sc, &sc->sc_thread,
            "fan control"); 
}

static void
smu_adjust(void *cookie)
{
        struct smu_softc *sc = cookie;
        int i;

        while (!sc->sc_dying) {
                for (i = 0; i < SMU_ZONES; i++)
                        if (sc->sc_zones[i].nfans > 0)
                                fancontrol_adjust_zone(&sc->sc_zones[i]);
                kpause("fanctrl", true, mstohz(2000), NULL);
        }
        kthread_exit(0);
}

static bool is_cpu_sensor(const envsys_data_t *edata)
{
        if (edata->units != ENVSYS_STEMP)
                return false;
        if (strstr(edata->desc, "CPU") != NULL)
                return TRUE;
        return false;
}

static bool is_drive_sensor(const envsys_data_t *edata)
{
        if (edata->units != ENVSYS_STEMP)
                return false;
        if (strstr(edata->desc, "DRIVE") != NULL)
                return TRUE;
        if (strstr(edata->desc, "drive") != NULL)
                return TRUE;
        return false;
}

static bool is_slots_sensor(const envsys_data_t *edata)
{
        if (edata->units != ENVSYS_STEMP)
                return false;
        if (strstr(edata->desc, "BACKSIDE") != NULL)
                return TRUE;
        if (strstr(edata->desc, "INLET") != NULL)
                return TRUE;
        if (strstr(edata->desc, "DIODE") != NULL)
                return TRUE;
        if (strstr(edata->desc, "TUNNEL") != NULL)
                return TRUE;
        return false;
}

int
smu_get_datablock(int id, uint8_t *buf, size_t len)
{
        struct smu_cmd cmd;

        cmd.cmd = SMU_PARTITION;
        cmd.len = 2;
        cmd.data[0] = SMU_PARTITION_LATEST;
        cmd.data[1] = id;
        smu_do_cmd(smu0, &cmd, 100);

        cmd.data[4] = cmd.data[0];
        cmd.data[5] = cmd.data[1];

        cmd.cmd = SMU_MISC;
        cmd.len = 7;
        cmd.data[0] = SMU_MISC_GET_DATA;
        cmd.data[1] = 4;
        cmd.data[2] = 0;
        cmd.data[3] = 0;
        cmd.data[6] = len;
        smu_do_cmd(smu0, &cmd, 100);

        memcpy(buf, cmd.data, len);
        return 0;
}