/*      $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);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.