/*      $NetBSD: lm87.c,v 1.16 2022/07/02 16:28:39 andvar Exp $ */
/*      $OpenBSD: lm87.c,v 1.20 2008/11/10 05:19:48 cnst Exp $  */

/*
 * Copyright (c) 2005 Mark Kettenis
 *
 * 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: lm87.c,v 1.16 2022/07/02 16:28:39 andvar Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <dev/sysmon/sysmonvar.h>

#include <dev/i2c/i2cvar.h>

/* LM87 registers */
#define LM87_INT_HHIGH_L        0x13    /* Hardware int high limit (lockable) */
#define LM87_EXT_HHIGH_L        0x14    /* Hardware ext high limit (lockable) */
#define LM87_TEST               0x15
#define LM87_CHANNEL            0x16    /* Dual purpose pin and scaling */
#define LM87_INT_HHIGH          0x17    /* Hardware int temp high limit */
#define LM87_EXT_HHIGH          0x18    /* Hardware ext temp high limit */
#define LM87_DAC_DATA           0x19    /* DAC output scaling */
#define LM87_AIN1_LOW           0x1a    /* Analog in 1 low limit */
#define LM87_AIN2_LOW           0x1b    /* Analog in 2 low limit */
#define LM87_2_5V               0x20    /* +2.5V or ext temp 2 reading */
#define LM87_VCCP1              0x21    /* Vccp1 reading */
#define LM87_VCC                0x22    /* +Vcc reading */
#define LM87_5V                 0x23    /* +5V reading */
#define LM87_12V                0x24    /* +12V reading */
#define LM87_VCCP2              0x25    /* Vccp2 reading */
#define LM87_EXT_TEMP           0x26    /* External temperature 1 reading */
#define LM87_INT_TEMP           0x27    /* Internal temperature reading */
#define LM87_FAN1               0x28    /* Fan1 or AIN1 reading */
#define LM87_FAN2               0x29    /* Fan2 or AIN2 reading */
#define LM87_2_5V_HIGH          0x2b    /* +2.5V or ext temp 2 high limit */
#define LM87_2_5V_LOW           0x2c    /* +2.5V or ext temp 2 low limit */
#define LM87_VCCP1_HIGH         0x2d    /* Vccp1 high limit */
#define LM87_VCCP1_LOW          0x2e    /* Vccp1 low limit */
#define LM87_VCC_HIGH           0x2f    /* +3.3V (Vcc) high limit */
#define LM87_VCC_LOW            0x30    /* +3.3V (Vcc) low limit */
#define LM87_5V_HIGH            0x31    /* +5V high limit */
#define LM87_5V_LOW             0x32    /* +5V low limit */
#define LM87_12V_HIGH           0x33    /* +12V high limit */
#define LM87_12V_LOW            0x34    /* +12V low limit */
#define LM87_VCCP2_HIGH         0x35    /* Vccp2 high limit */
#define LM87_VCCP2_LOW          0x36    /* Vccp2 low limit */
#define LM87_EXT_HIGH           0x37    /* External temperature 1 high limit */
#define LM87_EXT_LOW            0x38    /* External temperature low limit */
#define LM87_INT_HIGH           0x39    /* Internal temperature 1 high limit */
#define LM87_INT_LOW            0x3a    /* Internal temperature low limit */
#define LM87_FAN1_HIGH          0x3b    /* Fan 1 count or AIN1 high limit */
#define LM87_FAN2_HIGH          0x3c    /* Fan 2 count or AIN2 high limit */
#define LM87_COMPANY_ID         0x3e    /* Company ID */
#define LM87_REVISION           0x3f    /* Revision */
#define LM87_CONFIG1            0x40    /* Configuration 1 */
#define LM87_INT_STAT1          0x41    /* Interrupt status 1 */
#define LM87_INT_STAT2          0x42    /* Interrupt status 2 */
#define LM87_INT_MASK1          0x43    /* Interrupt mask 1 */
#define LM87_INT_MASK2          0x44    /* Interrupt mask 2 */
#define LM87_CI_CLEAR           0x46    /* Chassis intrusion */
#define LM87_FANDIV             0x47    /* Fan divisor + VID 0-3 */
#define LM87_VID4               0x48    /* VID4 */
#define LM87_CONFIG2            0x4a    /* Configuration 2 */
#define LM87_INT_MIRR1          0x4c    /* Interrupt status 1 mirror */
#define LM87_INT_MIRR2          0x4d    /* Interrupt status 2 mirror */
#define LM87_ALERT              0x80    /* SMB Alert enable */

/* Register contents */
#define  LM87_CONFIG1_START     0x01
#define  LM87_CONFIG1_INTCLR    0x08

#define  LM87_CHANNEL_AIN1      0x01
#define  LM87_CHANNEL_AIN2      0x02
#define  LM87_CHANNEL_TEMP2     0x04
#define  LM87_CHANNEL_VCC5      0x08

struct lmenv_id {
        u_int8_t id, family;
        const char *name;
};

static const struct lmenv_id lmenv_ids[] = {
        { 0x01, 81, "LM81" },
        { 0x02, 87, "LM87" },   /* LM87 or LM87CIMT */
        { 0x23, 81, "ADM9240" },
        { 0xda, 81, "DSL780" },
        { 0x00, 0, NULL }
};

/* Sensors */
#define LMENV_2_5V              0
#define LMENV_VCCP1             1
#define LMENV_VCC               2
#define LMENV_5V                3
#define LMENV_12V               4
#define LMENV_VCCP2             5
#define LMENV_EXT_TEMP          6
#define LMENV_INT_TEMP          7
#define LMENV_FAN1              8
#define LMENV_FAN2              9
#define LMENV_NUM_SENSORS       10

struct lmenv_softc {
        i2c_tag_t sc_tag;
        i2c_addr_t sc_addr;

        int     sc_fan1_div, sc_fan2_div;
        int     sc_family;
        uint8_t sc_channel;

        struct sysmon_envsys *sc_sme;
        envsys_data_t sc_sensor[LMENV_NUM_SENSORS];
};

int     lmenv_match(device_t, cfdata_t, void *);
void    lmenv_attach(device_t, device_t, void *);

void    lmenv_refresh(struct sysmon_envsys *, envsys_data_t *);

CFATTACH_DECL_NEW(lmenv, sizeof(struct lmenv_softc),
        lmenv_match, lmenv_attach, NULL, NULL);

static const struct device_compatible_entry compat_data[] = {
        { .compat = "lm87" },
        { .compat = "lm87cimt" },
        { .compat = "adm9240" },
        { .compat = "lm81" },
        { .compat = "ds1780" },
        DEVICE_COMPAT_EOL
};

int
lmenv_match(device_t parent, cfdata_t match, void *aux)
{
        struct i2c_attach_args *ia = aux;
        u_int8_t cmd, val;
        int error, i, match_result;

        if (iic_use_direct_match(ia, match, compat_data, &match_result))
                return match_result;
        
        /*
         * Indirect config - not much we can do!
         * Check typical addresses and read the Company ID register
         */
        if ((ia->ia_addr < 0x2c) || (ia->ia_addr > 0x2f))
                return 0;

        cmd = LM87_COMPANY_ID;
        if (iic_acquire_bus(ia->ia_tag, 0))
                return 0;
        error = iic_exec(ia->ia_tag, I2C_OP_READ_WITH_STOP, ia->ia_addr,
            &cmd, 1, &val, 1, 0);
        iic_release_bus(ia->ia_tag, 0);

        if (error)
                return 0;

        for (i = 0; lmenv_ids[i].id != 0; i++)
                if (lmenv_ids[i].id == val)
                        return I2C_MATCH_ADDRESS_AND_PROBE;

        return 0;
}

void
lmenv_attach(device_t parent, device_t self, void *aux)
{
        struct lmenv_softc *sc = device_private(self);
        struct i2c_attach_args *ia = aux;
        u_int8_t cmd, data, data2;
        int i;

        sc->sc_tag = ia->ia_tag;
        sc->sc_addr = ia->ia_addr;

        iic_acquire_bus(sc->sc_tag, 0);

        cmd = LM87_COMPANY_ID;
        if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
            sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
                iic_release_bus(sc->sc_tag, 0);
                printf(": cannot read ID register\n");
                return;
        }
        for (i = 0; lmenv_ids[i].id != 0; i++)
                if (lmenv_ids[i].id == data)
                        break;

        cmd = LM87_REVISION;
        if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
            sc->sc_addr, &cmd, sizeof cmd, &data2, sizeof data, 0)) {
                iic_release_bus(sc->sc_tag, 0);
                printf(": cannot read revision register\n");
                return;
        }
        printf(": %s rev %x\n", lmenv_ids[i].name, data2);
        sc->sc_family = lmenv_ids[i].family;

        cmd = LM87_FANDIV;
        if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
            sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
                iic_release_bus(sc->sc_tag, 0);
                printf(", cannot read Fan Divisor register\n");
                return;
        }
        sc->sc_fan1_div = 1 << ((data >> 4) & 0x03);
        sc->sc_fan2_div = 1 << ((data >> 6) & 0x03);

        if (sc->sc_family == 87) {
                cmd = LM87_CHANNEL;
                if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
                    sc->sc_addr, &cmd, sizeof cmd, &sc->sc_channel,
                    sizeof sc->sc_channel, 0)) {
                        iic_release_bus(sc->sc_tag, 0);
                        printf(", cannot read Channel register\n");
                        return;
                }
        } else
                sc->sc_channel = 0;

        cmd = LM87_CONFIG1;
        if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
            sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
                iic_release_bus(sc->sc_tag, 0);
                printf(", cannot read Configuration Register 1\n");
                return;
        }

        /*
         * if chip is not running, try to start it.
         * if it is stalled doing an interrupt, unstall it
         */
        data2 = (data | LM87_CONFIG1_START);
        data2 = data2 & ~LM87_CONFIG1_INTCLR;

        if (data != data2) {
                if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
                    sc->sc_addr, &cmd, sizeof cmd, &data2, sizeof data2, 0)) {
                        iic_release_bus(sc->sc_tag, 0);
                        printf(", cannot write Configuration Register 1\n");
                        return;
                }
        }
        iic_release_bus(sc->sc_tag, 0);

        /* Initialize sensor data. */
        sc->sc_sensor[LMENV_2_5V].state = ENVSYS_SINVALID;
        if (sc->sc_channel & LM87_CHANNEL_TEMP2) {
                sc->sc_sensor[LMENV_INT_TEMP].units = ENVSYS_STEMP;
                strlcpy(sc->sc_sensor[LMENV_2_5V].desc, "External 2",
                    sizeof(sc->sc_sensor[LMENV_2_5V].desc));
        } else {
                sc->sc_sensor[LMENV_2_5V].units = ENVSYS_SVOLTS_DC;
                strlcpy(sc->sc_sensor[LMENV_2_5V].desc, "+2.5Vin",
                    sizeof(sc->sc_sensor[LMENV_2_5V].desc));
        }

        sc->sc_sensor[LMENV_VCCP1].state = ENVSYS_SINVALID;
        sc->sc_sensor[LMENV_VCCP1].units = ENVSYS_SVOLTS_DC;
        strlcpy(sc->sc_sensor[LMENV_VCCP1].desc, "Vccp1",
            sizeof(sc->sc_sensor[LMENV_VCCP1].desc));

        sc->sc_sensor[LMENV_VCC].state = ENVSYS_SINVALID;
        sc->sc_sensor[LMENV_VCC].units = ENVSYS_SVOLTS_DC;
        strlcpy(sc->sc_sensor[LMENV_VCC].desc, "+Vcc",
            sizeof(sc->sc_sensor[LMENV_VCC].desc));

        sc->sc_sensor[LMENV_5V].state = ENVSYS_SINVALID;
        sc->sc_sensor[LMENV_5V].units = ENVSYS_SVOLTS_DC;
        strlcpy(sc->sc_sensor[LMENV_5V].desc, "+5Vin/Vcc",
            sizeof(sc->sc_sensor[LMENV_5V].desc));

        sc->sc_sensor[LMENV_12V].state = ENVSYS_SINVALID;
        sc->sc_sensor[LMENV_12V].units = ENVSYS_SVOLTS_DC;
        strlcpy(sc->sc_sensor[LMENV_12V].desc, "+12Vin",
            sizeof(sc->sc_sensor[LMENV_12V].desc));

        sc->sc_sensor[LMENV_VCCP2].state = ENVSYS_SINVALID;
        if (!(sc->sc_channel & LM87_CHANNEL_TEMP2)) {
                sc->sc_sensor[LMENV_VCCP2].units = ENVSYS_SVOLTS_DC;
                strlcpy(sc->sc_sensor[LMENV_VCCP2].desc, "Vccp2",
                    sizeof(sc->sc_sensor[LMENV_VCCP2].desc));
        }

        sc->sc_sensor[LMENV_EXT_TEMP].state = ENVSYS_SINVALID;
        sc->sc_sensor[LMENV_EXT_TEMP].units = ENVSYS_STEMP;
        if (sc->sc_channel & LM87_CHANNEL_TEMP2)
                strlcpy(sc->sc_sensor[LMENV_EXT_TEMP].desc, "External 1",
                    sizeof(sc->sc_sensor[LMENV_EXT_TEMP].desc));
        else
                strlcpy(sc->sc_sensor[LMENV_EXT_TEMP].desc, "External",
                    sizeof(sc->sc_sensor[LMENV_EXT_TEMP].desc));

        sc->sc_sensor[LMENV_INT_TEMP].state = ENVSYS_SINVALID;
        sc->sc_sensor[LMENV_INT_TEMP].units = ENVSYS_STEMP;
        strlcpy(sc->sc_sensor[LMENV_INT_TEMP].desc, "Internal",
            sizeof(sc->sc_sensor[LMENV_INT_TEMP].desc));

        sc->sc_sensor[LMENV_FAN1].state = ENVSYS_SINVALID;
        if (sc->sc_channel & LM87_CHANNEL_AIN1) {
                sc->sc_sensor[LMENV_FAN1].units = ENVSYS_SVOLTS_DC;
                strlcpy(sc->sc_sensor[LMENV_FAN1].desc, "AIN1",
                    sizeof(sc->sc_sensor[LMENV_FAN1].desc));
        } else {
                sc->sc_sensor[LMENV_FAN1].units = ENVSYS_SFANRPM;
                strlcpy(sc->sc_sensor[LMENV_FAN1].desc, "FAN1",
                    sizeof(sc->sc_sensor[LMENV_FAN1].desc));
        }

        sc->sc_sensor[LMENV_FAN2].state = ENVSYS_SINVALID;
        if (sc->sc_channel & LM87_CHANNEL_AIN2) {
                sc->sc_sensor[LMENV_FAN2].units = ENVSYS_SVOLTS_DC;
                strlcpy(sc->sc_sensor[LMENV_FAN2].desc, "AIN2",
                    sizeof(sc->sc_sensor[LMENV_FAN2].desc));
        } else {
                sc->sc_sensor[LMENV_FAN2].units = ENVSYS_SFANRPM;
                strlcpy(sc->sc_sensor[LMENV_FAN2].desc, "FAN2",
                    sizeof(sc->sc_sensor[LMENV_FAN2].desc));
        }

        sc->sc_sme = sysmon_envsys_create();
        for (i = 0; i < LMENV_NUM_SENSORS; i++)
                if (sysmon_envsys_sensor_attach(sc->sc_sme,
                    &sc->sc_sensor[i])) {
                        sysmon_envsys_destroy(sc->sc_sme);
                        aprint_error_dev(self,
                            "unable to attach sensor %d at sysmon\n", i);
                        return;
                }
        sc->sc_sme->sme_name = device_xname(self);
        sc->sc_sme->sme_cookie = sc;
        sc->sc_sme->sme_refresh = lmenv_refresh;
        if (sysmon_envsys_register(sc->sc_sme)) {
                aprint_error_dev(self,
                    "unable to register with sysmon\n");
                sysmon_envsys_destroy(sc->sc_sme);
                return;
        }
}

void
lmenv_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
        struct lmenv_softc *sc = sme->sme_cookie;
        u_int8_t cmd, data;
        u_int tmp;

        iic_acquire_bus(sc->sc_tag, 0);

        cmd = LM87_2_5V + edata->sensor;
        if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
            sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
                edata->state = ENVSYS_SINVALID;
                return;
        }

        switch (edata->sensor) {
        case LMENV_2_5V:
                /* Might be external temperature 2 */
                if (sc->sc_channel & LM87_CHANNEL_TEMP2) {
                        if (data == 0x80)
                                edata->state = ENVSYS_SINVALID;
                        else {
                                edata->value_cur =
                                    (int8_t)data * 1000000 + 273150000;
                                edata->state = ENVSYS_SVALID;
                        }
                        break;
                }
                edata->value_cur = 2500000 * data / 192;
                edata->state = ENVSYS_SVALID;
                break;
        case LMENV_5V:
                edata->value_cur = 5000000 * data / 192;
                edata->state = ENVSYS_SVALID;
                break;
        case LMENV_12V:
                edata->value_cur = 12000000 * data / 192;
                edata->state = ENVSYS_SVALID;
                break;
        case LMENV_VCCP1:
                edata->value_cur = 2700000 * data / 192;
                edata->state = ENVSYS_SVALID;
                break;
        case LMENV_VCCP2:
                /* If monitoring external temperature 2, this isn't monitored */
                if (sc->sc_channel & LM87_CHANNEL_TEMP2) {
                        edata->state = ENVSYS_SINVALID;
                        break;
                }
                edata->value_cur = 2700000 * data / 192;
                edata->state = ENVSYS_SVALID;
                break;
        case LMENV_VCC:
                /* Voltage scale selectable (5V or 3.3V) */
                edata->value_cur =
                    (LM87_CHANNEL_VCC5 ? 5000000 : 3300000) * data / 192;
                edata->state = ENVSYS_SVALID;
                break;
        case LMENV_EXT_TEMP:
                if (sc->sc_family == 81) {
                        edata->state = ENVSYS_SINVALID;
                        break;          /* missing on LM81 */
                }
                /* FALLTHROUGH */
        case LMENV_INT_TEMP:
                if (data == 0x80)
                        edata->state = ENVSYS_SINVALID;
                else {
                        edata->value_cur = (int8_t)data * 1000000 + 273150000;
                        edata->state = ENVSYS_SVALID;
                }
                break;
        case LMENV_FAN1:
                /* Might be analogue input 1 */
                if (sc->sc_channel & LM87_CHANNEL_AIN1) {
                        edata->value_cur = 1870000 * data / 192;
                        edata->state = ENVSYS_SVALID;
                        break;
                }
                if (data == 0xff) {
                        edata->state = ENVSYS_SINVALID;
                        break;
                }
                tmp = data * sc->sc_fan1_div;
                if (tmp == 0)
                        edata->state = ENVSYS_SINVALID;
                else {
                        edata->value_cur = 1350000 / tmp;
                        edata->state = ENVSYS_SVALID;
                }
                break;
        case LMENV_FAN2:
                /* Might be analogue input 2 */
                if (sc->sc_channel & LM87_CHANNEL_AIN2) {
                        edata->value_cur = 1870000 * data / 192;
                        edata->state = ENVSYS_SVALID;
                        break;
                }
                if (data == 0xff) {
                        edata->state = ENVSYS_SINVALID;
                        break;
                }
                tmp = data * sc->sc_fan2_div;
                if (tmp == 0)
                        edata->state = ENVSYS_SINVALID;
                else {
                        edata->value_cur = 1350000 / tmp;
                        edata->state = ENVSYS_SVALID;
                }
                break;
        default:
                edata->state = ENVSYS_SINVALID;
                break;
        }

        iic_release_bus(sc->sc_tag, 0);
}