/*      $NetBSD: emcfan.c,v 1.2 2025/07/08 18:15:03 gutteridge Exp $    */

/*
 * Copyright (c) 2025 Brad Spencer <brad@anduin.eldar.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: emcfan.c,v 1.2 2025/07/08 18:15:03 gutteridge Exp $");

/*
 * Driver for the EMC-210x and EMC-230x fan controllers on a
 * I2C bus.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/module.h>
#include <sys/conf.h>
#include <sys/sysctl.h>
#include <sys/mutex.h>
#include <sys/condvar.h>
#include <sys/kthread.h>
#include <sys/pool.h>
#include <sys/kmem.h>

#include <dev/sysmon/sysmonvar.h>
#include <dev/i2c/i2cvar.h>
#include <dev/i2c/emcfanreg.h>
#include <dev/i2c/emcfanvar.h>
#include <dev/i2c/emcfaninfo.h>

static int      emcfan_poke(i2c_tag_t, i2c_addr_t, bool);
static int      emcfan_match(device_t, cfdata_t, void *);
static void     emcfan_attach(device_t, device_t, void *);
static int      emcfan_detach(device_t, int);
static void     emcfan_refresh(struct sysmon_envsys *, envsys_data_t *);
static int      emcfan_activate(device_t, enum devact);
static int      emcfan_verify_sysctl(SYSCTLFN_ARGS);
static void     emcfan_attach_gpio(struct emcfan_sc *, uint8_t);

#define EMCFAN_DEBUG
#ifdef EMCFAN_DEBUG
#define DPRINTF(s, l, x) \
    do { \
        if (l <= s->sc_emcfandebug) \
            printf x; \
    } while (/*CONSTCOND*/0)
#else
#define DPRINTF(s, l, x)
#endif

CFATTACH_DECL_NEW(emcfan, sizeof(struct emcfan_sc),
    emcfan_match, emcfan_attach, emcfan_detach, emcfan_activate);

extern struct cfdriver emcfan_cd;

static dev_type_open(emcfanopen);
static dev_type_read(emcfanread);
static dev_type_write(emcfanwrite);
static dev_type_close(emcfanclose);
const struct cdevsw emcfan_cdevsw = {
        .d_open = emcfanopen,
        .d_close = emcfanclose,
        .d_read = emcfanread,
        .d_write = emcfanwrite,
        .d_ioctl = noioctl,
        .d_stop = nostop,
        .d_tty = notty,
        .d_poll = nopoll,
        .d_mmap = nommap,
        .d_kqfilter = nokqfilter,
        .d_discard = nodiscard,
        .d_flag = D_OTHER
};

static bool
emcfan_reg_is_real(struct emcfan_sc *sc, uint8_t reg)
{
        int segment;
        uint64_t index;

        segment = reg / 64;
        index = reg % 64;

        DPRINTF(sc, 10, ("%s: void check 1: reg=%02x, segment=%d, index=%jd, sc_info_info=%d\n", __func__, reg,
            segment, index, sc->sc_info_index));
        DPRINTF(sc, 10, ("%s: void check 2: register_void=%jx, shift=%jx\n", __func__,
            emcfan_chip_infos[sc->sc_info_index].register_void[segment], ((uint64_t)1 << index)));

        return(emcfan_chip_infos[sc->sc_info_index].register_void[segment] & ((uint64_t)1 << index));
}

static int
emcfan_read_registerr(i2c_tag_t tag, i2c_addr_t addr, uint8_t reg,
    uint8_t *res)
{
        int error = 0;

        error = iic_exec(tag, I2C_OP_READ_WITH_STOP, addr, &reg, 1, res, 1, 0);

        return error;
}

static int
emcfan_read_register(struct emcfan_sc *sc, uint8_t reg, uint8_t *res)
{
        if (emcfan_reg_is_real(sc,reg))
                return(emcfan_read_registerr(sc->sc_tag, sc->sc_addr, reg, res));
        else
                *res = EMCFAN_VOID_READ;
        return 0;
}

static int
emcfan_write_registerr(i2c_tag_t tag, i2c_addr_t addr, uint8_t reg,
    uint8_t value)
{
        int error = 0;

        error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, &reg, 1, &value, 1, 0);

        return error;
}

static int
emcfan_write_register(struct emcfan_sc *sc, uint8_t reg, uint8_t value)
{
        if (emcfan_reg_is_real(sc,reg))
                return(emcfan_write_registerr(sc->sc_tag, sc->sc_addr, reg, value));
        else
                return EACCES;
}

static int
emcfan_poke(i2c_tag_t tag, i2c_addr_t addr, bool matchdebug)
{
        int error;
        uint8_t res;

        error = emcfan_read_registerr(tag, addr, EMCFAN_MANUFACTURER_ID, &res);
        if (matchdebug) {
                printf("poke X 1: %d %d\n", addr, error);
        }

        /* Ok..  something was there, but the ID did not match what was expected.
         * We get away with doing this because the poke is just getting the Manufacturer
         * ID, which is a fixed value.
         */

        if (!error) {
                if (res != EMCFAN_VALID_MANUFACTURER_ID)
                        error = EIO;
        }

        return error;
}

static bool
emcfan_check_i2c_addr(i2c_addr_t addr)
{
        bool r = false;

        for(int i = 0;i < __arraycount(emcfan_typical_addrs); i++)
                if (addr == emcfan_typical_addrs[i]) {
                        r = true;
                        break;
                }

        return(r);
}

static int
emcfan_match(device_t parent, cfdata_t match, void *aux)
{
        struct i2c_attach_args *ia = aux;
        int error, match_result;
        const bool matchdebug = false;

        if (iic_use_direct_match(ia, match, NULL, &match_result))
                return match_result;

        if (matchdebug) {
                printf("Looking at ia_addr: %x\n",ia->ia_addr);
        }

        /* Look to see if there is a device indirectly */

        if (! emcfan_check_i2c_addr(ia->ia_addr))
                return 0;

        /*
         * Check to see if something is really at this i2c address.
         * This will keep phantom devices from appearing
         */
        if (iic_acquire_bus(ia->ia_tag, 0) != 0) {
                if (matchdebug)
                        printf("in match acquire bus failed\n");
                return 0;
        }

        error = emcfan_poke(ia->ia_tag, ia->ia_addr, matchdebug);
        iic_release_bus(ia->ia_tag, 0);

        return error == 0 ? I2C_MATCH_ADDRESS_AND_PROBE : 0;
}

static int
emcfan_find_info(uint8_t product)
{
        for(int i = 0;i < __arraycount(emcfan_chip_infos); i++)
                if (product == emcfan_chip_infos[i].product_id)
                        return(i);

        return(-1);
}

static const char *
emcfan_product_to_name(uint8_t info_index)
{
        KASSERT(info_index >= 0);

        return(emcfan_chip_infos[info_index].name);
}

int
emcfan_verify_sysctl(SYSCTLFN_ARGS)
{
        int error, t;
        struct sysctlnode node;

        node = *rnode;
        t = *(int *)rnode->sysctl_data;
        node.sysctl_data = &t;
        error = sysctl_lookup(SYSCTLFN_CALL(&node));
        if (error || newp == NULL)
                return error;

        if (t < 0)
                return EINVAL;

        *(int *)rnode->sysctl_data = t;

        return 0;
}

static int
emcfan_sysctl_init(struct emcfan_sc *sc)
{
        int error;
        const struct sysctlnode *cnode;
        int sysctlroot_num;
        char pole_name[8];

        if ((error = sysctl_createv(&sc->sc_emcfanlog, 0, NULL, &cnode,
            0, CTLTYPE_NODE, device_xname(sc->sc_dev),
            SYSCTL_DESCR("emcfan controls"), NULL, 0, NULL, 0, CTL_HW,
            CTL_CREATE, CTL_EOL)) != 0)
                return error;

        sysctlroot_num = cnode->sysctl_num;

#ifdef EMCFAN_DEBUG
        if ((error = sysctl_createv(&sc->sc_emcfanlog, 0, NULL, &cnode,
            CTLFLAG_READWRITE, CTLTYPE_INT, "debug",
            SYSCTL_DESCR("Debug level"), emcfan_verify_sysctl, 0,
            &sc->sc_emcfandebug, 0, CTL_HW, sysctlroot_num, CTL_CREATE,
            CTL_EOL)) != 0)
                return error;

#endif

        if (emcfan_chip_infos[sc->sc_info_index].family == EMCFAN_FAMILY_230X ||
            emcfan_chip_infos[sc->sc_info_index].product_id == EMCFAN_PRODUCT_2103_1 ||
            emcfan_chip_infos[sc->sc_info_index].product_id == EMCFAN_PRODUCT_2103_24 ||
            emcfan_chip_infos[sc->sc_info_index].product_id == EMCFAN_PRODUCT_2104 ||
            emcfan_chip_infos[sc->sc_info_index].product_id == EMCFAN_PRODUCT_2106) {
                for(int i=0;i < emcfan_chip_infos[sc->sc_info_index].num_tachs;i++) {
                        snprintf(pole_name,sizeof(pole_name),"poles%d",i+1);
                        if ((error = sysctl_createv(&sc->sc_emcfanlog, 0, NULL, &cnode,
                            CTLFLAG_READWRITE, CTLTYPE_INT, pole_name,
                            SYSCTL_DESCR("Number of poles"), emcfan_verify_sysctl, 0,
                            &sc->sc_num_poles[i], 0, CTL_HW, sysctlroot_num, CTL_CREATE,
                            CTL_EOL)) != 0)
                                return error;
                }
        }
        if (emcfan_chip_infos[sc->sc_info_index].product_id == EMCFAN_PRODUCT_2103_1 ||
            emcfan_chip_infos[sc->sc_info_index].product_id == EMCFAN_PRODUCT_2103_24) {
                if ((error = sysctl_createv(&sc->sc_emcfanlog, 0, NULL, &cnode,
                    CTLFLAG_READWRITE, CTLTYPE_INT, "ftach",
                    SYSCTL_DESCR("ftach frequency"), emcfan_verify_sysctl, 0,
                    &sc->sc_ftach, 0, CTL_HW, sysctlroot_num, CTL_CREATE,
                    CTL_EOL)) != 0)
                        return error;
        }
        if (emcfan_chip_infos[sc->sc_info_index].vin4_temp_zone) {
                if ((error = sysctl_createv(&sc->sc_emcfanlog, 0, NULL, &cnode,
                    CTLFLAG_READWRITE, CTLTYPE_BOOL, "vin4",
                    SYSCTL_DESCR("Use VIN4 pin as a temperature sensor input"), NULL, 0,
                    &sc->sc_vin4_temp, 0, CTL_HW, sysctlroot_num, CTL_CREATE,
                    CTL_EOL)) != 0)
                        return error;
        }

        return 0;
}

static void
emcfan_attach(device_t parent, device_t self, void *aux)
{
        struct emcfan_sc *sc;
        struct i2c_attach_args *ia;
        uint8_t product_id, revision;
        int error;

        ia = aux;
        sc = device_private(self);

        sc->sc_dev = self;
        sc->sc_tag = ia->ia_tag;
        sc->sc_addr = ia->ia_addr;
        sc->sc_opened = false;
        sc->sc_dying = false;
        sc->sc_ftach = 32000;
        sc->sc_vin4_temp = false;
        for(int i=0;i < EMCFAN_NUM_FANS;i++)
                sc->sc_num_poles[i] = 2;
        sc->sc_emcfandebug = 0;

        mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);

        aprint_normal("\n");

        if ((sc->sc_sme = sysmon_envsys_create()) == NULL) {
                aprint_error_dev(self,
                    "Unable to create sysmon structure\n");
                sc->sc_sme = NULL;
                return;
        }

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                aprint_error_dev(self, "Could not acquire iic bus: %d\n",
                    error);
                goto out;
        }

        error = emcfan_read_registerr(sc->sc_tag, sc->sc_addr, EMCFAN_PRODUCT_ID, &product_id);
        if (error != 0) {
                aprint_error_dev(self, "Could not get the product id\n");
        } else {
                error = emcfan_read_registerr(sc->sc_tag, sc->sc_addr, EMCFAN_REVISION, &revision);
                if (error != 0) {
                        aprint_error_dev(self, "Could not get the revision of the chip\n");
                }
        }

        iic_release_bus(sc->sc_tag, 0);
        if (error != 0) {
                aprint_error_dev(self, "Unable to setup device\n");
                goto out;
        }

        sc->sc_info_index = emcfan_find_info(product_id);
        if (sc->sc_info_index < 0) {
                aprint_error_dev(self, "Unknown product id: %02x\n",product_id);
                goto out;
        }

        if ((error = emcfan_sysctl_init(sc)) != 0) {
                sc->sc_emcfanlog = NULL;
                aprint_error_dev(self, "Can't setup sysctl tree (%d)\n", error);
                goto out;
        }

        for(int i=0;i < EMCFAN_NUM_SENSORS;i++)
                sc->sc_sensor_instances[i].sc_i_member = -1;

        int sensor_instance = 0;
        /* Set up the tachs */
        for(int i = 0;i < emcfan_chip_infos[sc->sc_info_index].num_tachs &&
                sensor_instance < EMCFAN_NUM_SENSORS;
            i++) {
                snprintf(sc->sc_sensors[sensor_instance].desc,
                    sizeof(sc->sc_sensors[sensor_instance].desc),
                    "FAN %d",i+1);

                DPRINTF(sc, 2, ("%s: TACH registering fan sensor %d (%s)\n", __func__,
                    sensor_instance, sc->sc_sensors[sensor_instance].desc));

                sc->sc_sensor_instances[sensor_instance].sc_i_flags = 0;
                sc->sc_sensor_instances[sensor_instance].sc_i_member = i + 1;
                sc->sc_sensors[sensor_instance].units = ENVSYS_SFANRPM;
                sc->sc_sensors[sensor_instance].state = ENVSYS_SINVALID;

                error = sysmon_envsys_sensor_attach(sc->sc_sme,
                    &sc->sc_sensors[sensor_instance]);
                if (error) {
                        aprint_error_dev(self,
                            "Unable to attach sensor %d: %d\n", i, error);
                        goto out;
                }

                sc->sc_sensor_instances[sensor_instance].sc_i_envnum =
                    sc->sc_sensors[sensor_instance].sensor;

                DPRINTF(sc, 2, ("%s: TACH recorded sensor instance number %d->%d\n", __func__,
                    sensor_instance, sc->sc_sensor_instances[sensor_instance].sc_i_envnum));

                sensor_instance++;
        }

        /* Set up internal temperature sensor */
        if (emcfan_chip_infos[sc->sc_info_index].internal_temp_zone) {
                snprintf(sc->sc_sensors[sensor_instance].desc,
                    sizeof(sc->sc_sensors[sensor_instance].desc),
                    "internal temperature");

                DPRINTF(sc, 2, ("%s: IT registering internal temperature sensor %d (%s)\n", __func__,
                    sensor_instance, sc->sc_sensors[sensor_instance].desc));

                sc->sc_sensor_instances[sensor_instance].sc_i_flags = EMCFAN_INTERNAL_TEMP;
                sc->sc_sensor_instances[sensor_instance].sc_i_member = 1;
                sc->sc_sensors[sensor_instance].units = ENVSYS_STEMP;
                sc->sc_sensors[sensor_instance].state = ENVSYS_SINVALID;

                error = sysmon_envsys_sensor_attach(sc->sc_sme,
                    &sc->sc_sensors[sensor_instance]);
                if (error) {
                        aprint_error_dev(self,
                            "Unable to attach internal sensor: %d\n", error);
                        goto out;
                }

                sc->sc_sensor_instances[sensor_instance].sc_i_envnum =
                    sc->sc_sensors[sensor_instance].sensor;

                DPRINTF(sc, 2, ("%s: IT recorded sensor instance number %d->%d\n", __func__,
                    sensor_instance, sc->sc_sensor_instances[sensor_instance].sc_i_envnum));

                sensor_instance++;
        }

        /* Set up VIN4 temperature sensor */
        if (emcfan_chip_infos[sc->sc_info_index].vin4_temp_zone) {
                snprintf(sc->sc_sensors[sensor_instance].desc,
                    sizeof(sc->sc_sensors[sensor_instance].desc),
                    "VIN4 temperature");

                DPRINTF(sc, 2, ("%s: registering VIN4 temperature sensor %d (%s)\n", __func__,
                    sensor_instance, sc->sc_sensors[sensor_instance].desc));

                sc->sc_sensor_instances[sensor_instance].sc_i_flags = EMCFAN_VIN4_TEMP;
                sc->sc_sensor_instances[sensor_instance].sc_i_member = 1;
                sc->sc_sensors[sensor_instance].units = ENVSYS_STEMP;
                sc->sc_sensors[sensor_instance].state = ENVSYS_SINVALID;

                error = sysmon_envsys_sensor_attach(sc->sc_sme,
                    &sc->sc_sensors[sensor_instance]);
                if (error) {
                        aprint_error_dev(self,
                            "Unable to attach VIN4 sensor: %d\n", error);
                        goto out;
                }

                sc->sc_sensor_instances[sensor_instance].sc_i_envnum =
                    sc->sc_sensors[sensor_instance].sensor;

                DPRINTF(sc, 2, ("%s: VIN4 recorded sensor instance number %d->%d\n", __func__,
                    sensor_instance, sc->sc_sensor_instances[sensor_instance].sc_i_envnum));

                sensor_instance++;
        }

        /* Set up external temperature sensors */
        for(int i = 0;i < emcfan_chip_infos[sc->sc_info_index].num_external_temp_zones &&
                sensor_instance < EMCFAN_NUM_SENSORS;
            i++) {
                snprintf(sc->sc_sensors[sensor_instance].desc,
                    sizeof(sc->sc_sensors[sensor_instance].desc),
                    "temperature zone %d",i+1);

                DPRINTF(sc, 2, ("%s: ET registering fan sensor %d (%s)\n", __func__,
                    sensor_instance, sc->sc_sensors[sensor_instance].desc));

                sc->sc_sensor_instances[sensor_instance].sc_i_flags = 0;
                sc->sc_sensor_instances[sensor_instance].sc_i_member = i + 1;
                sc->sc_sensors[sensor_instance].units = ENVSYS_STEMP;
                sc->sc_sensors[sensor_instance].state = ENVSYS_SINVALID;

                error = sysmon_envsys_sensor_attach(sc->sc_sme,
                    &sc->sc_sensors[sensor_instance]);
                if (error) {
                        aprint_error_dev(self,
                            "Unable to attach sensor %d: %d\n", i, error);
                        goto out;
                }

                sc->sc_sensor_instances[sensor_instance].sc_i_envnum =
                    sc->sc_sensors[sensor_instance].sensor;

                DPRINTF(sc, 2, ("%s: ET recorded sensor instance number %d->%d\n", __func__,
                    sensor_instance, sc->sc_sensor_instances[sensor_instance].sc_i_envnum));

                sensor_instance++;
        }

        sc->sc_sme->sme_name = device_xname(sc->sc_dev);
        sc->sc_sme->sme_cookie = sc;
        sc->sc_sme->sme_refresh = emcfan_refresh;

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

        aprint_normal_dev(self, "Microchip Technology %s fan controller, "
            "Revision: %02x\n",
            emcfan_product_to_name(sc->sc_info_index),
            revision);
        int e = emcfan_chip_infos[sc->sc_info_index].num_external_temp_zones;
        if (emcfan_chip_infos[sc->sc_info_index].vin4_temp_zone)
                e++;
        aprint_normal_dev(self, "Fans: %d, Tachometers: %d, Internal Temperature: %s, External Sensors: %d, GPIO: %s\n",
            emcfan_chip_infos[sc->sc_info_index].num_fans,
            emcfan_chip_infos[sc->sc_info_index].num_tachs,
            (emcfan_chip_infos[sc->sc_info_index].internal_temp_zone) ? "Yes" : "No",
            e,
            (emcfan_chip_infos[sc->sc_info_index].num_gpio_pins > 0) ? "Yes" : "No");

            if (emcfan_chip_infos[sc->sc_info_index].num_gpio_pins > 0)
                    emcfan_attach_gpio(sc, product_id);
        return;
out:
        sysmon_envsys_destroy(sc->sc_sme);
        sc->sc_sme = NULL;
}

/* The EMC-2101 is quite a bit different than the other EMC fan controllers.
 * Handle it differently.
 */

static void
emcfan_refresh_2101_tach(struct sysmon_envsys *sme, envsys_data_t *edata, int instance)
{
        struct emcfan_sc *sc = sme->sme_cookie;

        int error;
        uint8_t tach_high_reg;
        uint8_t tach_low_reg;
        uint8_t tach_high;
        uint8_t tach_low;

        switch(sc->sc_sensor_instances[instance].sc_i_member) {
        case 1:
                tach_high_reg = EMCFAN_2101_TACH_HIGH;
                tach_low_reg = EMCFAN_2101_TACH_LOW;
                break;
        default:
                panic("A 2101 can not have more than one tach\n");
                break;
        };

        DPRINTF(sc, 2, ("%s: dev=%s, instance=%d, sc_i_member=%d, tach_high_reg=0x%02X, tach_low_reg=0x%02X\n", __func__,
            device_xname(sc->sc_dev), instance,
            sc->sc_sensor_instances[instance].sc_i_member,
            tach_high_reg, tach_low_reg));

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                device_printf(sc->sc_dev,"%s: could not acquire I2C bus: %d\n",__func__, error);
                return;
        }

        /* There is a interlock thing with the low and high bytes.  Read the
         * low byte first.
         */

        error = emcfan_read_register(sc, tach_low_reg, &tach_low);
        if (error) {
                device_printf(sc->sc_dev,"%s: could not read tach low register: %d\n",__func__, error);
                iic_release_bus(sc->sc_tag, 0);
                return;
        }
        error = emcfan_read_register(sc, tach_high_reg, &tach_high);
        if (error) {
                device_printf(sc->sc_dev,"%s: could not read tach high register: %d\n",__func__, error);
                iic_release_bus(sc->sc_tag, 0);
                return;
        }

        iic_release_bus(sc->sc_tag, 0);

        uint16_t count;
        count = tach_high << 8;
        count |= tach_low;

        DPRINTF(sc, 2, ("%s: instance=%d, tach_high=%d 0x%02X, tach_low=%d 0x%02X, count=%d\n", __func__,
            instance, tach_high, tach_high, tach_low, tach_low, count));

        /* 0xffff indicates that the fan is not present, stopped / stalled
         * or below the RPM that can be measured or the chip is not configured
         * to read tach signals on the pin, but is being used for an alert
         */

        if (count == 0xffff)
                return;

        /* The formula is:
         *
         * rpm = 5400000 / count
         *
         */

        uint64_t irpm;

        irpm = 5400000 / count;

        edata->value_cur = (uint32_t) irpm;
        edata->state = ENVSYS_SVALID;
}

static void
emcfan_refresh_210_346_230x_tach(int product_family, uint8_t product_id,
    struct sysmon_envsys *sme, envsys_data_t *edata, int instance)
{
        struct emcfan_sc *sc = sme->sme_cookie;

        int error;
        uint8_t tach_high_reg;
        uint8_t tach_low_reg;
        uint8_t fan_config_reg;
        uint8_t chip_config;
        uint8_t fan_config;
        uint8_t tach_high;
        uint8_t tach_low;
        int ftach = 32000;
        int edges;
        int poles;
        int m;

        if (product_family == EMCFAN_FAMILY_210X) {
                switch(sc->sc_sensor_instances[instance].sc_i_member) {
                case 1:
                        fan_config_reg = EMCFAN_210_346_CONFIG_1;
                        tach_high_reg = EMCFAN_210_346_TACH_1_HIGH;
                        tach_low_reg = EMCFAN_210_346_TACH_1_LOW;
                        break;
                case 2:
                        fan_config_reg = EMCFAN_210_346_CONFIG_2;
                        tach_high_reg = EMCFAN_210_346_TACH_2_HIGH;
                        tach_low_reg = EMCFAN_210_346_TACH_2_LOW;
                        break;
                default:
                        panic("210X family do not know how to deal with member: %d\n",
                            sc->sc_sensor_instances[instance].sc_i_member);
                        break;
                };
        } else {
                switch(sc->sc_sensor_instances[instance].sc_i_member) {
                case 1:
                        fan_config_reg = EMCFAN_230X_CONFIG_1;
                        tach_high_reg = EMCFAN_230X_TACH_1_HIGH;
                        tach_low_reg = EMCFAN_230X_TACH_1_LOW;
                        break;
                case 2:
                        fan_config_reg = EMCFAN_230X_CONFIG_2;
                        tach_high_reg = EMCFAN_230X_TACH_2_HIGH;
                        tach_low_reg = EMCFAN_230X_TACH_2_LOW;
                        break;
                case 3:
                        fan_config_reg = EMCFAN_230X_CONFIG_3;
                        tach_high_reg = EMCFAN_230X_TACH_3_HIGH;
                        tach_low_reg = EMCFAN_230X_TACH_3_LOW;
                        break;
                case 4:
                        fan_config_reg = EMCFAN_230X_CONFIG_4;
                        tach_high_reg = EMCFAN_230X_TACH_4_HIGH;
                        tach_low_reg = EMCFAN_230X_TACH_4_LOW;
                        break;
                case 5:
                        fan_config_reg = EMCFAN_230X_CONFIG_5;
                        tach_high_reg = EMCFAN_230X_TACH_5_HIGH;
                        tach_low_reg = EMCFAN_230X_TACH_5_LOW;
                        break;
                default:
                        panic("230X family do not know how to deal with member: %d\n",
                            sc->sc_sensor_instances[instance].sc_i_member);
                        break;
                };
        }

        DPRINTF(sc, 2, ("%s: dev=%s, instance=%d, sc_i_member=%d, fan_config_reg=0x%02X, tach_high_reg=0x%02X, tach_low_reg=0x%02X\n", __func__,
            device_xname(sc->sc_dev), instance,
            sc->sc_sensor_instances[instance].sc_i_member,
            fan_config_reg, tach_high_reg, tach_low_reg));

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                device_printf(sc->sc_dev,"%s: could not acquire I2C bus: %d\n",__func__, error);
                return;
        }

        if (product_id == EMCFAN_PRODUCT_2103_1 ||
            product_id == EMCFAN_PRODUCT_2103_24) {
                ftach = sc->sc_ftach;
        } else {
                chip_config = 0x00;
                if (product_family == EMCFAN_FAMILY_230X) {
                        error = emcfan_read_register(sc, EMCFAN_CHIP_CONFIG, &chip_config);
                } else {
                        if (product_id == EMCFAN_PRODUCT_2104 ||
                            product_id == EMCFAN_PRODUCT_2106) {
                                error = emcfan_read_register(sc, EMCFAN_MUX_PINS, &chip_config);
                        }
                }
                if (error) {
                        device_printf(sc->sc_dev,"%s: could not read chip config: %d\n",__func__, error);
                        iic_release_bus(sc->sc_tag, 0);
                        return;
                }

                /* Figure out if there is an external clock involved */
                if (product_family == EMCFAN_FAMILY_230X) {
                        if (chip_config & 0x02)
                                ftach = 32000;
                        else
                                if (chip_config & 0x01)
                                        ftach = 32768;
                                else
                                        ftach = 32000;
                } else {
                        if (product_id == EMCFAN_PRODUCT_2104 ||
                            product_id == EMCFAN_PRODUCT_2106) {
                                if (chip_config & 0x01)
                                        ftach = 32768;
                                else
                                        ftach = 32000;
                        }
                }

        }

        error = emcfan_read_register(sc, fan_config_reg, &fan_config);
        if (error) {
                device_printf(sc->sc_dev,"%s: could not read fan config: %d\n",__func__, error);
                iic_release_bus(sc->sc_tag, 0);
                return;
        }

        /* There is a interlock thing with the low and high bytes.  Read the
         * low byte first.
         */

        error = emcfan_read_register(sc, tach_low_reg, &tach_low);
        if (error) {
                device_printf(sc->sc_dev,"%s: could not read tach low register: %d\n",__func__, error);
                iic_release_bus(sc->sc_tag, 0);
                return;
        }
        error = emcfan_read_register(sc, tach_high_reg, &tach_high);
        if (error) {
                device_printf(sc->sc_dev,"%s: could not read tach high register: %d\n",__func__, error);
                iic_release_bus(sc->sc_tag, 0);
                return;
        }

        iic_release_bus(sc->sc_tag, 0);

        /* Return early if the fan is stalled or not hooked up.  It might be better to look at
         * the stalled fan status register, but that works differently depending on which chip
         * you are looking at.
         */

        if (product_family == EMCFAN_FAMILY_210X) {
                /* The datasheet is not at all clear as to what will be set in the low byte of the tach
                 * 0xc0, 0xe0 and 0xf0 all seem to depend on the minimum expected rpm and 0xf8 appears
                 * to mean that the fan is stalled in some way.
                 *
                 * Further to confuse matters, some chips may be able to adjust what invalid means.
                 * See the fan config register (0x4A) on the EMC2101 for an example of that.  We check
                 * tach_low here just in case these chips can do that too.
                 */
                if (tach_high == 0xff &&
                    (tach_low == 0xc0 || tach_low == 0xe0 ||
                    tach_low == 0xf0 || tach_low == 0xf8 ||
                    tach_low == 0xff))
                        return;
        } else {
                /* The datasheet for the 230X family was a little clearer.  In that one, if the high byte is
                 * 0xff the tach reading is invalid.
                 */
                if (tach_high == 0xff)
                        return;
        }

        /* Extract the M value, also known as the tach multiplier */
        m = fan_config & 0b01100000;
        m = m >> 5;

        DPRINTF(sc, 2, ("%s: fan_config=%d 0x%02X, raw m=%d 0x%02X\n",
            __func__, fan_config, fan_config, m, m));

        m = (1 << m);

        /* Extract the number of configured edges */
        edges = fan_config & 0b00011000;
        edges = edges >> 3;

        DPRINTF(sc, 2, ("%s: fan_config=%d 0x%02X, raw edges=%d 0x%02X\n",
            __func__, fan_config, fan_config, edges, edges));

        edges = ((edges + 1) * 2) + 1;

        /* Calculate the tach count, which needs to use bit weights */
        int count = 0;
        count = (tach_high << 5) | tach_low;

        /* The number of poles is a sysctl setting */
        poles = sc->sc_num_poles[sc->sc_sensor_instances[instance].sc_i_member - 1];

        DPRINTF(sc, 2, ("%s: instance=%d, ftach=%d, m=%d, edges=%d, poles=%d, tach_high=%d 0x%02X, tach_low=%d 0x%02X, count=%d\n", __func__,
            instance, ftach, m, edges, poles, tach_high, tach_high, tach_low, tach_low, count));

        /* The formula is:
         *
         * rpm = 1/poles * ((edges - 1) / count * 1/m) * ftach * 60
         *
         * ftach is either 32.000khz or 32.768khz
         *
         */

        int64_t irpm;
        int ip1, ip2;
        int64_t ip3;

        ip1 = 10000 / poles;
        /*
        printf("poles: %d ; ip1: %d\n",poles,ip1);
        */
        ip2 = 10000 / m;
        /*
        printf("m: %d ; ip2: %d\n",m,ip2);
        */
        ip2 = count * ip2;
        /*
        printf("count: %d ; ip2: %d\n",count,ip2);
        */
        ip3 = (int64_t)((edges - 1) * (int64_t)100000000000) / (int64_t)ip2;
        /*
        printf("edges: %d ; ip3: %d\n",edges,ip3);
        */

        irpm = (ip1 * ip3 * ftach * 60) / 100000000000;

        edata->value_cur = (uint32_t) irpm;
        edata->state = ENVSYS_SVALID;
}

/* These two tables are taken from Appendix A in the 2104 and 2106 datasheet.
 * The index into the array is the ADC value and the value of the array is a
 * precomputed kelvin1000 (i.e celcius to kelvin * 1000) temperature.
 *
 * There are unusual holes as not all of the ADC values are present in the
 * *center* of the table these were made into xx.5 temperature values.
 *
 * Another quirk is that the table in the datasheets have multiple temperatures
 * for a particular ADC.  This behavior seems more common on the edges of the
 * table and may make sense.  What these tables do, is just take the first
 * temperature for any ADC value.
 *
 */

#define EMCFAN_VIN_NO_TEMP -1

static const int32_t emcfan_vin_temps[] = {
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        463150,
        461150,
        459150,
        457150,
        455150,
        453150,
        451150,
        450150,
        448150,
        446150,
        445150,
        443150,
        441150,
        440150,
        438150,
        437150,
        435150,
        434150,
        433150,
        431150,
        430150,
        429150,
        427150,
        426150,
        425150,
        424150,
        423150,
        421150,
        420150,
        419150,
        418150,
        417150,
        416150,
        415150,
        414150,
        413150,
        412150,
        411150,
        410150,
        409150,
        408150,
        407150,
        406150,
        405150,
        404150,
        403150,
        402150,
        398150,
        397150,
        396150,
        395150,
        394650,
        394150,
        393150,
        392150,
        391650,
        391150,
        390150,
        389150,
        388650,
        388150,
        387150,
        386650,
        386150,
        385150,
        384150,
        383650,
        383150,
        382150,
        381650,
        381150,
        380150,
        379650,
        379150,
        378150,
        377650,
        377150,
        376650,
        376150,
        375150,
        374650,
        374150,
        373150,
        372650,
        372150,
        371650,
        371150,
        370150,
        369650,
        369150,
        368650,
        368150,
        367150,
        366650,
        366150,
        365650,
        365150,
        364150,
        363650,
        363150,
        362650,
        362150,
        361650,
        361150,
        360150,
        359650,
        359150,
        358150,
        357650,
        357150,
        356650,
        356150,
        355650,
        355150,
        354150,
        353650,
        353150,
        352650,
        352150,
        351650,
        351150,
        350650,
        350150,
        349150,
        348650,
        348150,
        347650,
        347150,
        346150,
        345650,
        345150,
        344650,
        344150,
        343650,
        343150,
        342150,
        341650,
        341150,
        340650,
        340150,
        339150,
        338650,
        338150,
        337650,
        337150,
        336150,
        335650,
        335150,
        334650,
        334150,
        333150,
        332650,
        332150,
        331150,
        330650,
        330150,
        329650,
        329150,
        328150,
        327650,
        327150,
        326150,
        325650,
        325150,
        324150,
        323650,
        323150,
        322150,
        321150,
        320650,
        320150,
        319150,
        318650,
        318150,
        317150,
        316150,
        315150,
        314650,
        314150,
        313150,
        312150,
        311150,
        310650,
        310150,
        309150,
        308150,
        307150,
        306150,
        305150,
        304150,
        303150,
        302150,
        301150,
        300150,
        299150,
        298150,
        297150,
        296150,
        295150,
        293150,
        292150,
        291150,
        290150,
        288150,
        287150,
        285150,
        283150,
        282150,
        280150,
        278150,
        276150,
        273150,
        271150,
        268150,
        265150,
        262150,
        259150,
        255150,
        250150,
        244150,
        236150,
        229150,
        228150,
        EMCFAN_VIN_NO_TEMP
};

static const int32_t emcfan_vin_temps_i[] = {
        228150,
        229150,
        236150,
        244150,
        250150,
        255150,
        259150,
        262150,
        265150,
        268150,
        271150,
        273150,
        276150,
        278150,
        280150,
        281150,
        283150,
        285150,
        286150,
        288150,
        289150,
        291150,
        292150,
        293150,
        295150,
        296150,
        297150,
        298150,
        299150,
        300150,
        301150,
        302150,
        303150,
        304150,
        305150,
        306150,
        307150,
        308150,
        309150,
        310150,
        310650,
        311150,
        312150,
        313150,
        314150,
        314650,
        315150,
        316150,
        317150,
        317650,
        318150,
        319150,
        320150,
        320650,
        321150,
        322150,
        323150,
        323650,
        324150,
        325150,
        325650,
        326150,
        327150,
        327650,
        328150,
        329150,
        329650,
        330150,
        330650,
        331150,
        332150,
        332650,
        333150,
        334150,
        334650,
        335150,
        335650,
        336150,
        337150,
        337650,
        338150,
        338650,
        339150,
        340150,
        340650,
        341150,
        341650,
        342150,
        343150,
        343650,
        344150,
        344650,
        345150,
        345650,
        346150,
        347150,
        347650,
        348150,
        348650,
        349150,
        350150,
        350650,
        351150,
        351650,
        352150,
        352650,
        353150,
        353650,
        354150,
        355150,
        355650,
        356150,
        356650,
        357150,
        357650,
        358150,
        359150,
        359650,
        360150,
        360650,
        361150,
        362150,
        362650,
        363150,
        363650,
        364150,
        365150,
        365650,
        366150,
        366650,
        367150,
        368150,
        368650,
        369150,
        369650,
        370150,
        371150,
        371650,
        372150,
        372650,
        373150,
        374150,
        374650,
        375150,
        376150,
        376650,
        377150,
        377650,
        378150,
        379150,
        379650,
        380150,
        381150,
        381650,
        382150,
        383150,
        383650,
        384150,
        385150,
        386150,
        386650,
        387150,
        388150,
        388650,
        389150,
        390150,
        391150,
        391650,
        392150,
        393150,
        394150,
        394650,
        395150,
        396150,
        397150,
        398150,
        402150,
        403150,
        404150,
        405150,
        406150,
        407150,
        408150,
        409150,
        410150,
        411150,
        412150,
        413150,
        414150,
        415150,
        416150,
        417150,
        418150,
        419150,
        420150,
        421150,
        423150,
        424150,
        425150,
        426150,
        427150,
        429150,
        430150,
        431150,
        433150,
        434150,
        435150,
        437150,
        438150,
        440150,
        441150,
        443150,
        445150,
        446150,
        448150,
        450150,
        451150,
        453150,
        455150,
        457150,
        459150,
        461150,
        463150,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP,
        EMCFAN_VIN_NO_TEMP
};

static void
emcfan_refresh_temp(int product_family, uint8_t product_id,
    struct sysmon_envsys *sme, envsys_data_t *edata, int instance)
{
        struct emcfan_sc *sc = sme->sme_cookie;

        int error;
        uint8_t temp_config;
        uint8_t raw_temp_config_3;
        uint8_t temp_config_3;
        uint8_t temp_high;
        uint8_t temp_low;
        uint8_t external_temp_high_reg;
        uint8_t external_temp_low_reg;
        bool is_internal = false;
        bool is_vin4 = false;
        bool using_apd = false;
        bool using_vin = false;
        bool inverted = false;

        is_internal = sc->sc_sensor_instances[instance].sc_i_flags & EMCFAN_INTERNAL_TEMP;
        is_vin4 = sc->sc_sensor_instances[instance].sc_i_flags & EMCFAN_VIN4_TEMP;

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                device_printf(sc->sc_dev,"%s: could not acquire I2C bus: %d\n",__func__, error);
                return;
        }

        if (is_internal) {
                /* There might be a data interlock thing going on with the high and low
                 * registers, to make sure, read the high one first.  This works in the
                 * opposite of the tach.
                 */
                error = emcfan_read_register(sc, EMCFAN_INTERNAL_TEMP_HIGH, &temp_high);
                if (error) {
                        device_printf(sc->sc_dev,"%s: could not read internal temp high: %d\n",__func__, error);
                        iic_release_bus(sc->sc_tag, 0);
                        return;
                }
                /* The 2101 does not have fractions on the internal temperature sensor */
                if (product_id == EMCFAN_PRODUCT_2101) {
                        temp_low = 0;
                } else {
                        error = emcfan_read_register(sc, EMCFAN_INTERNAL_TEMP_LOW, &temp_low);
                        if (error) {
                                device_printf(sc->sc_dev,"%s: could not read internal temp low: %d\n",__func__, error);
                                iic_release_bus(sc->sc_tag, 0);
                                return;
                        }
                }
        } else {
                if (is_vin4) {
                        if (sc->sc_vin4_temp) {
                                using_vin = true;

                                error = emcfan_read_register(sc, EMCFAN_CHIP_CONFIG, &temp_config);
                                if (error) {
                                        device_printf(sc->sc_dev,"%s: could not read chip config register: %d\n",__func__, error);
                                        iic_release_bus(sc->sc_tag, 0);
                                        return;
                                }
                                inverted = temp_config & 0x80;

                                error = emcfan_read_register(sc, EMCFAN_VIN4_VOLTAGE, &temp_high);
                                if (error) {
                                        device_printf(sc->sc_dev,"%s: could not read external temp high: %d\n",__func__, error);
                                        iic_release_bus(sc->sc_tag, 0);
                                        return;
                                }
                        } else {
                                iic_release_bus(sc->sc_tag, 0);
                                return;
                        }
                } else {
                        /* The 2101 has its external sensor on a different set of registers
                         * than the rest.
                         */
                        if (product_id == EMCFAN_PRODUCT_2101) {
                                error = emcfan_read_register(sc, EMCFAN_2101_EXTERNAL_TEMP_LOW, &temp_low);
                                if (error) {
                                        device_printf(sc->sc_dev,"%s: could not read external temp low: %d\n",__func__, error);
                                        iic_release_bus(sc->sc_tag, 0);
                                        return;
                                }
                                error = emcfan_read_register(sc, EMCFAN_2101_EXTERNAL_TEMP_HIGH, &temp_high);
                                if (error) {
                                        device_printf(sc->sc_dev,"%s: could not read external temp high: %d\n",__func__, error);
                                        iic_release_bus(sc->sc_tag, 0);
                                        return;
                                }
                        } else {
                                switch(sc->sc_sensor_instances[instance].sc_i_member) {
                                case 1:
                                        external_temp_high_reg = EMCFAN_EXTERNAL_1_TEMP_HIGH;
                                        external_temp_low_reg = EMCFAN_EXTERNAL_1_TEMP_LOW;
                                        break;
                                case 2:
                                        external_temp_high_reg = EMCFAN_EXTERNAL_2_TEMP_HIGH;
                                        external_temp_low_reg = EMCFAN_EXTERNAL_2_TEMP_LOW;
                                        break;
                                case 3:
                                        external_temp_high_reg = EMCFAN_EXTERNAL_3_TEMP_HIGH;
                                        external_temp_low_reg = EMCFAN_EXTERNAL_3_TEMP_LOW;
                                        break;
                                case 4:
                                        external_temp_high_reg = EMCFAN_EXTERNAL_4_TEMP_HIGH;
                                        external_temp_low_reg = EMCFAN_EXTERNAL_4_TEMP_LOW;
                                        break;
                                default:
                                        panic("Unknown member: %d\n",
                                            sc->sc_sensor_instances[instance].sc_i_member);
                                        break;
                                };

                                /* The 2103-2, 2103-4, 2104 and 2106 can use APD mode.  This is a method
                                 * of using two sensors in parallel on a single set of pins.  The way one
                                 * wires this up is in the datasheets for the chip.
                                 */

                                if (product_id == EMCFAN_PRODUCT_2103_24 ||
                                    product_id == EMCFAN_PRODUCT_2104 ||
                                    product_id == EMCFAN_PRODUCT_2106) {
                                        error = emcfan_read_register(sc, EMCFAN_CHIP_CONFIG, &temp_config);
                                        if (error) {
                                                device_printf(sc->sc_dev,"%s: could not read chip config register: %d\n",__func__, error);
                                                iic_release_bus(sc->sc_tag, 0);
                                                return;
                                        }

                                        using_apd = temp_config & 0x01;
                                }

                                /* The 2104, 2105 and 2106 has some other special abilities, such as being
                                 * able to use thermistors.
                                 */

                                if (product_id == EMCFAN_PRODUCT_2104 ||
                                    product_id == EMCFAN_PRODUCT_2106) {
                                        error = emcfan_read_register(sc, EMCFAN_TEMP_CONFIG_3, &raw_temp_config_3);
                                        if (error) {
                                                device_printf(sc->sc_dev,"%s: could not read temperature config register: %d\n",__func__, error);
                                                iic_release_bus(sc->sc_tag, 0);
                                                return;
                                        }
                                        switch(sc->sc_sensor_instances[instance].sc_i_member) {
                                        case 1:
                                                temp_config_3 = raw_temp_config_3 & 0x03;
                                                break;
                                        case 2:
                                                temp_config_3 = raw_temp_config_3 >> 2;
                                                temp_config_3 = temp_config_3 & 0x03;
                                                break;
                                        case 3:
                                                temp_config_3 = raw_temp_config_3 >> 4;
                                                temp_config_3 = temp_config_3 & 0x03;
                                                break;
                                        default:
                                                temp_config_3 = 0;
                                                break;
                                        };

                                        using_vin = temp_config_3 & 0x02;
                                        inverted = temp_config_3 & 0x01;


                                        /* There is a strange situation if sensor 3 is being used as a VIN
                                         * sensor, then sensor 4 is not available at all.  Note that this
                                         * sensor 4 is *NOT* the sensor that might be attached to the VIN4
                                         * pin.
                                         */

                                        if (sc->sc_sensor_instances[instance].sc_i_member == 4 &&
                                            raw_temp_config_3 & 0x20) {
                                                iic_release_bus(sc->sc_tag, 0);
                                                return;
                                        }
                                }

                                if (product_id == EMCFAN_PRODUCT_2103_24) {
                                        /* The anti-parallel mode, apd, must be enabled before sensor 3 will
                                         * be available.
                                         */
                                        if (!using_apd &&
                                            sc->sc_sensor_instances[instance].sc_i_member == 3) {
                                                iic_release_bus(sc->sc_tag, 0);
                                                return;
                                        }
                                }

                                if (product_id == EMCFAN_PRODUCT_2104 ||
                                    product_id == EMCFAN_PRODUCT_2106) {
                                        /* The anti-parallel mode, apd, must be enabled before sensor 4 will
                                         * be available.  This, of course, might conflict if sensor 3 is a VIN
                                         * sensor.  Don't do that....
                                         */
                                        if (!using_apd &&
                                            sc->sc_sensor_instances[instance].sc_i_member == 4) {
                                                iic_release_bus(sc->sc_tag, 0);
                                                return;
                                        }
                                }

                                /* There is a data interlock thing going on with the high and low
                                 * registers, but it works the opposite from the tach.
                                 */

                                error = emcfan_read_register(sc, external_temp_high_reg, &temp_high);
                                if (error) {
                                        device_printf(sc->sc_dev,"%s: could not read external temp high: %d\n",__func__, error);
                                        iic_release_bus(sc->sc_tag, 0);
                                        return;
                                }
                                if (using_vin) {
                                        temp_low = 0;
                                } else {
                                        error = emcfan_read_register(sc, external_temp_low_reg, &temp_low);
                                        if (error) {
                                                device_printf(sc->sc_dev,"%s: could not read external temp low: %d\n",__func__, error);
                                                iic_release_bus(sc->sc_tag, 0);
                                                return;
                                        }
                                }
                        }
                }
        }

        iic_release_bus(sc->sc_tag, 0);

        /* It appears that on the 2101, if the high byte is 0x7f and the low byte is 0,\
         * then there is a fault or no sensor.
         */

        if (product_id == EMCFAN_PRODUCT_2101 &&
            !is_internal) {
                if (temp_high == 0x7f &&
                    temp_low == 0) {
                        return;
                }
        }

        /* For everyone else, if the external sensor read 0x80 on the high byte and
         * the fraction is 0, then there is a fault or no sensor.
         */

        if (!is_internal && !using_vin) {
                if (temp_high == 0x80 &&
                    (temp_low >> 5) == 0x00) {
                        return;
                    }
        }

        int32_t kelvin1000 = 0;
        int32_t frac = 0;
        uint8_t tl;

        if (!using_vin) {
                kelvin1000 = (int8_t)temp_high * 1000;
                tl = temp_low >> 5;
                if (temp_high & 0x80) {
                        tl = (~tl) & 0x07;
                        tl++;
                }
                frac = 125 * tl;
                if (temp_high & 0x80) {
                        kelvin1000 -= frac;
                } else {
                        kelvin1000 += frac;
                }
                kelvin1000 += 273150;
        } else {
                int32_t vin1000 = EMCFAN_VIN_NO_TEMP;

                if (inverted) {
                        if (emcfan_vin_temps_i[temp_high] != EMCFAN_VIN_NO_TEMP) {
                                vin1000 = emcfan_vin_temps_i[temp_high];
                        }
                } else {
                        if (emcfan_vin_temps[temp_high] != EMCFAN_VIN_NO_TEMP) {
                                vin1000 = emcfan_vin_temps[temp_high];
                        }
                }

                if (vin1000 != EMCFAN_VIN_NO_TEMP)
                        kelvin1000 = vin1000;
                else
                        return;
        }

        edata->value_cur = (uint32_t) kelvin1000 * 1000;
        edata->state = ENVSYS_SVALID;
}

static void
emcfan_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
        struct emcfan_sc *sc = sme->sme_cookie;
        int instance = -1;

        /* Hunt down the instance for this sensor.
         *
         * The type is held in sc_sensors, but the actual hardware
         * instance is held in sc_sensor_instances in the member
         * field.  It would be nice if the edata structure had a
         * field that could be used as an opaque value.
         */
        for(int i = 0;i < EMCFAN_NUM_SENSORS;i++)
                if (sc->sc_sensor_instances[i].sc_i_envnum == edata->sensor) {
                        instance = i;
                        break;
                }

        KASSERT(instance > -1);

        DPRINTF(sc, 2, ("%s: using sensor instance %d\n", __func__,
            instance));

        edata->state = ENVSYS_SINVALID;

        /* Unlike the manner of the refresh functions in other drivers, this
         * one will select the sensor based upon the type and instance.
         * Due to the fact that the order will vary depending on which
         * chip you are using.
         */

        switch(edata->units) {
        case ENVSYS_SFANRPM:
                switch(emcfan_chip_infos[sc->sc_info_index].family) {
                case EMCFAN_FAMILY_210X:
                        switch(emcfan_chip_infos[sc->sc_info_index].product_id) {
                        case EMCFAN_PRODUCT_2101:
                                emcfan_refresh_2101_tach(sme, edata, instance);
                                break;
                                /* 2103, 2104 and 2106 use nearly the same algorithm as the 230x family */
                        default:
                                emcfan_refresh_210_346_230x_tach(emcfan_chip_infos[sc->sc_info_index].family,
                                    emcfan_chip_infos[sc->sc_info_index].product_id,
                                    sme, edata, instance);
                                break;
                        };
                        break;
                case EMCFAN_FAMILY_230X:
                        emcfan_refresh_210_346_230x_tach(emcfan_chip_infos[sc->sc_info_index].family,
                            emcfan_chip_infos[sc->sc_info_index].product_id,
                            sme, edata, instance);
                        break;
                default:
                        panic("Unknown family: %d\n",emcfan_chip_infos[sc->sc_info_index].family);
                        break;
                }
                break;
        case ENVSYS_STEMP:
                emcfan_refresh_temp(emcfan_chip_infos[sc->sc_info_index].family,
                    emcfan_chip_infos[sc->sc_info_index].product_id,
                    sme, edata, instance);
                break;
        default:
                panic("Unknown edata units value: %d\n",edata->units);
                break;
        };
}

static int
emcfanopen(dev_t dev, int flags, int fmt, struct lwp *l)
{
        struct emcfan_sc *sc;

        sc = device_lookup_private(&emcfan_cd, minor(dev));
        if (!sc)
                return ENXIO;

        if (sc->sc_opened)
                return EBUSY;

        mutex_enter(&sc->sc_mutex);
        sc->sc_opened = true;
        mutex_exit(&sc->sc_mutex);

        return 0;
}

static int
emcfanread(dev_t dev, struct uio *uio, int flags)
{
        struct emcfan_sc *sc;
        int error;

        if ((sc = device_lookup_private(&emcfan_cd, minor(dev))) == NULL)
                return ENXIO;

        /* We do not make this an error.  There is nothing wrong with running
         * off the end here, just return EOF.
         */
        if (uio->uio_offset > 0xff)
                return 0;

        if ((error = iic_acquire_bus(sc->sc_tag, 0)) != 0)
                return error;

        while (uio->uio_resid &&
            uio->uio_offset <= 0xff &&
            !sc->sc_dying) {
                uint8_t buf;
                int reg_addr = uio->uio_offset;

                if ((error = emcfan_read_register(sc, reg_addr, &buf)) != 0) {
                        iic_release_bus(sc->sc_tag, 0);
                        aprint_error_dev(sc->sc_dev,
                            "%s: read failed at 0x%02x: %d\n",
                            __func__, reg_addr, error);
                        return error;
                }

                if (sc->sc_dying)
                        break;

                if ((error = uiomove(&buf, 1, uio)) != 0) {
                        iic_release_bus(sc->sc_tag, 0);
                        return error;
                }
        }

        iic_release_bus(sc->sc_tag, 0);

        if (sc->sc_dying) {
                return EIO;
        }

        return 0;
}

static int
emcfanwrite(dev_t dev, struct uio *uio, int flags)
{
        struct emcfan_sc *sc;
        int error;

        if ((sc = device_lookup_private(&emcfan_cd, minor(dev))) == NULL)
                return ENXIO;

        /* Same thing as read, this is not considered an error */
        if (uio->uio_offset > 0xff)
                return 0;

        if ((error = iic_acquire_bus(sc->sc_tag, 0)) != 0)
                return error;

        while (uio->uio_resid &&
            uio->uio_offset <= 0xff &&
            !sc->sc_dying) {
                uint8_t buf;
                int reg_addr = uio->uio_offset;

                if ((error = uiomove(&buf, 1, uio)) != 0)
                        break;

                if (sc->sc_dying)
                        break;

                if ((error = emcfan_write_register(sc, (uint8_t)reg_addr, buf)) != 0) {
                        iic_release_bus(sc->sc_tag, 0);
                        aprint_error_dev(sc->sc_dev,
                            "%s: write failed at 0x%02x: %d\n",
                            __func__, reg_addr, error);
                        return error;
                }
        }

        iic_release_bus(sc->sc_tag, 0);

        if (sc->sc_dying) {
                return EIO;
        }

        return error;
}

static int
emcfanclose(dev_t dev, int flags, int fmt, struct lwp *l)
{
        struct emcfan_sc *sc;

        sc = device_lookup_private(&emcfan_cd, minor(dev));

        mutex_enter(&sc->sc_mutex);
        sc->sc_opened = false;
        mutex_exit(&sc->sc_mutex);

        return(0);
}

static int
emcfan_detach(device_t self, int flags)
{
        int err;
        struct emcfan_sc *sc;

        sc = device_private(self);

        mutex_enter(&sc->sc_mutex);
        sc->sc_dying = true;

        err = config_detach_children(self, flags);
        if (err)
                return err;

        /* Remove the sysctl tree */
        if (sc->sc_emcfanlog != NULL)
                sysctl_teardown(&sc->sc_emcfanlog);

        /* Remove the sensors */
        if (sc->sc_sme != NULL) {
                sysmon_envsys_unregister(sc->sc_sme);
                sc->sc_sme = NULL;
        }

        mutex_exit(&sc->sc_mutex);

        mutex_destroy(&sc->sc_mutex);

        return 0;
}

int
emcfan_activate(device_t self, enum devact act)
{
        struct emcfan_sc *sc = device_private(self);

        switch (act) {
        case DVACT_DEACTIVATE:
                sc->sc_dying = true;
                return 0;
        default:
                return EOPNOTSUPP;
        }
}

/* --- GPIO --- */

static int
emcfan_current_gpio_flags(struct emcfan_sc *sc,
    uint8_t product_id,
    int pin)
{
        int error = 0;
        int f = 0;
        uint8_t mux_reg = 0;
        uint8_t dir_reg;
        uint8_t out_config;
        uint8_t pin_mask;
        uint8_t pin_maska1;
        uint8_t pin_maska2;

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                return 0;
        }

        if (product_id != EMCFAN_PRODUCT_2103_24) {
                error = emcfan_read_register(sc, EMCFAN_MUX_PINS, &mux_reg);
                if (error != 0) {
                        return 0;
                }
        }
        error = emcfan_read_register(sc, EMCFAN_DIR_PINS, &dir_reg);
        if (error != 0) {
                return 0;
        }
        error = emcfan_read_register(sc, EMCFAN_OUTPUT_PIN_CONFIG, &out_config);
        if (error != 0) {
                return 0;
        }
        iic_release_bus(sc->sc_tag, 0);

        pin_mask = 1 << pin;

        if (product_id != EMCFAN_PRODUCT_2103_24) {
                if (pin <= 4) {
                        if (pin <= 2) {
                                if ((mux_reg & pin_mask) == 0)
                                        f = GPIO_PIN_ALT0;
                        } else {
                                if (pin == 3) {
                                        pin_maska1 = 0x08;
                                        pin_maska2 = 0x10;
                                } else {
                                        pin_maska1 = 0x20;
                                        pin_maska2 = 0x40;
                                }
                                if (mux_reg & pin_maska1 &&
                                    mux_reg & pin_maska2) {
                                        f = GPIO_PIN_ALT1;
                                } else {
                                        if (((mux_reg & pin_maska1) == 0) &&
                                            ((mux_reg & pin_maska2) == 0)) {
                                                f = GPIO_PIN_ALT0;
                                        }
                                }
                        }
                }
        }

        if (f == 0) {
                if (dir_reg & pin_mask) {
                        f = GPIO_PIN_OUTPUT;
                } else {
                        f = GPIO_PIN_INPUT;
                }

                if (out_config & pin_mask) {
                        f |= GPIO_PIN_PUSHPULL;
                } else {
                        f |= GPIO_PIN_OPENDRAIN;
                }
        }

        return f;
}

static int
emcfan_gpio_pin_read(void *arg, int pin)
{
        struct emcfan_sc *sc = arg;
        int error = 0;
        int r = GPIO_PIN_LOW;
        uint8_t input_reg;
        uint8_t pin_mask;

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (!error) {
                error = emcfan_read_register(sc, EMCFAN_PINS_INPUT, &input_reg);
                if (!error) {
                        pin_mask = 1 << pin;
                        if (input_reg & pin_mask)
                                r = GPIO_PIN_HIGH;
                }

        }
        iic_release_bus(sc->sc_tag, 0);

        return r;
}

static void
emcfan_gpio_pin_write(void *arg, int pin, int value)
{
        struct emcfan_sc *sc = arg;
        int error = 0;
        uint8_t output_reg;
        uint8_t pin_mask;

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (!error) {
                error = emcfan_read_register(sc, EMCFAN_PINS_OUTPUT, &output_reg);
                if (!error) {
                        pin_mask = 1 << pin;

                        if (value == 0) {
                                pin_mask = ~pin_mask;
                                output_reg &= pin_mask;
                        } else {
                                output_reg |= pin_mask;
                        }
                        emcfan_write_register(sc, EMCFAN_PINS_OUTPUT, output_reg);
                }

        }
        iic_release_bus(sc->sc_tag, 0);
}

static void
emcfan_gpio_pin_ctl(void *arg, int pin, int flags)
{
        struct emcfan_sc *sc = arg;
        int error = 0;
        uint8_t product_id = emcfan_chip_infos[sc->sc_info_index].product_id;
        uint8_t pin_mask = 1 << pin;
        uint8_t pin_maska1;
        uint8_t pin_maska2;
        uint8_t mux_reg = 0;
        uint8_t dir_reg;
        uint8_t out_config;

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                return;
        }

        if (product_id != EMCFAN_PRODUCT_2103_24) {
                error = emcfan_read_register(sc, EMCFAN_MUX_PINS, &mux_reg);
                if (error != 0) {
                        return;
                }
        }
        error = emcfan_read_register(sc, EMCFAN_DIR_PINS, &dir_reg);
        if (error != 0) {
                return;
        }
        error = emcfan_read_register(sc, EMCFAN_OUTPUT_PIN_CONFIG, &out_config);
        if (error != 0) {
                return;
        }
        iic_release_bus(sc->sc_tag, 0);

        if (flags & GPIO_PIN_ALT0 ||
            flags & GPIO_PIN_ALT1) {
                if (product_id != EMCFAN_PRODUCT_2103_24) {
                        if (pin <= 4) {
                                if (pin <= 2) {
                                        mux_reg &= ~pin_mask;
                                } else {
                                        if (pin == 3) {
                                                pin_maska2 = 0x18;
                                        } else {
                                                pin_maska2 = 0x60;
                                        }
                                        if (flags & GPIO_PIN_ALT0) {
                                                mux_reg &= ~pin_maska2;
                                        } else {
                                                if (flags & GPIO_PIN_ALT1) {
                                                        mux_reg |= pin_maska2;
                                                }
                                        }
                                }
                                emcfan_write_register(sc, EMCFAN_MUX_PINS, mux_reg);
                        }
                }
        } else {
                if (product_id != EMCFAN_PRODUCT_2103_24) {
                        if (pin <= 4) {
                                if (pin <= 2) {
                                        mux_reg |= pin_mask;
                                } else {
                                        if (pin == 3) {
                                                pin_maska1 = 0x08;
                                                pin_maska2 = 0x18;
                                        } else {
                                                pin_maska1 = 0x20;
                                                pin_maska2 = 0x60;
                                        }
                                        mux_reg &= ~pin_maska2;
                                        mux_reg |= pin_maska1;
                                }
                                emcfan_write_register(sc, EMCFAN_MUX_PINS, mux_reg);
                        }
                }

                if (flags & GPIO_PIN_OPENDRAIN) {
                        out_config &= ~pin_mask;
                } else {
                        if (flags & GPIO_PIN_PUSHPULL)
                                out_config |= pin_mask;
                }
                emcfan_write_register(sc, EMCFAN_OUTPUT_PIN_CONFIG, out_config);

                if (flags & GPIO_PIN_INPUT) {
                        dir_reg &= ~pin_mask;
                } else {
                        if (flags & GPIO_PIN_OUTPUT)
                                dir_reg |= pin_mask;
                }
                emcfan_write_register(sc, EMCFAN_DIR_PINS, dir_reg);
        }
}

static void
emcfan_attach_gpio(struct emcfan_sc *sc, uint8_t product_id)
{
        struct gpiobus_attach_args gba;

        for(int i = 0; i < emcfan_chip_infos[sc->sc_info_index].num_gpio_pins;i++) {
                sc->sc_gpio_pins[i].pin_num = i;
                sc->sc_gpio_pins[i].pin_caps = emcfan_chip_infos[sc->sc_info_index].gpio_pin_ability[i];
                sc->sc_gpio_pins[i].pin_flags = emcfan_current_gpio_flags(sc, emcfan_chip_infos[sc->sc_info_index].product_id, i);
                sc->sc_gpio_pins[i].pin_intrcaps = 0;
                strncpy(sc->sc_gpio_pins[i].pin_defname,
                    emcfan_chip_infos[sc->sc_info_index].gpio_names[i],
                    strlen(emcfan_chip_infos[sc->sc_info_index].gpio_names[i]) + 1);
        }

        sc->sc_gpio_gc.gp_cookie = sc;
        sc->sc_gpio_gc.gp_pin_read = emcfan_gpio_pin_read;
        sc->sc_gpio_gc.gp_pin_write = emcfan_gpio_pin_write;
        sc->sc_gpio_gc.gp_pin_ctl = emcfan_gpio_pin_ctl;

        gba.gba_gc = &sc->sc_gpio_gc;
        gba.gba_pins = sc->sc_gpio_pins;
        gba.gba_npins = emcfan_chip_infos[sc->sc_info_index].num_gpio_pins;

        sc->sc_gpio_dev = config_found(sc->sc_dev, &gba, gpiobus_print, CFARGS(.iattr = "gpiobus"));

        return;
}

MODULE(MODULE_CLASS_DRIVER, emcfan, "iic,sysmon_envsys,gpio");

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

static int
emcfan_modcmd(modcmd_t cmd, void *opaque)
{
        int error;
#ifdef _MODULE
        int bmaj = -1, cmaj = -1;
#endif

        switch (cmd) {
        case MODULE_CMD_INIT:
#ifdef _MODULE
                error = devsw_attach("emcfan", NULL, &bmaj,
                    &emcfan_cdevsw, &cmaj);
                if (error) {
                        aprint_error("%s: unable to attach devsw\n",
                            emcfan_cd.cd_name);
                        return error;
                }

                error = config_init_component(cfdriver_ioconf_emcfan,
                    cfattach_ioconf_emcfan, cfdata_ioconf_emcfan);
                if (error) {
                        aprint_error("%s: unable to init component\n",
                            emcfan_cd.cd_name);
                        devsw_detach(NULL, &emcfan_cdevsw);
                }
                return error;
#else
                return 0;
#endif
        case MODULE_CMD_FINI:
#ifdef _MODULE
                error = config_fini_component(cfdriver_ioconf_emcfan,
                      cfattach_ioconf_emcfan, cfdata_ioconf_emcfan);
                devsw_detach(NULL, &emcfan_cdevsw);
                return error;
#else
                return 0;
#endif
        default:
                return ENOTTY;
        }
}