/*      $NetBSD: pcf8591_envctrl.c,v 1.19 2021/01/27 02:20:03 thorpej Exp $     */
/*      $OpenBSD: pcf8591_envctrl.c,v 1.6 2007/10/25 21:17:20 kettenis Exp $ */

/*
* Copyright (c) 2006 Damien Miller <[email protected]>
* Copyright (c) 2007 Mark Kettenis <[email protected]>
*
* 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: pcf8591_envctrl.c,v 1.19 2021/01/27 02:20:03 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>

#include <dev/sysmon/sysmonvar.h>
#include <dev/sysmon/sysmon_taskq.h>

#include <machine/autoconf.h>

#include <dev/ofw/openfirm.h>
#include <dev/i2c/i2cvar.h>

#ifdef ECADC_DEBUG
#define DPRINTF printf
#else
#define DPRINTF if (0) printf
#endif

/* Translation tables contain 254 entries */
#define XLATE_SIZE              256
#define XLATE_MAX               (XLATE_SIZE - 2)

#define PCF8591_CHANNELS        4

#define PCF8591_CTRL_CH0        0x00
#define PCF8591_CTRL_CH1        0x01
#define PCF8591_CTRL_CH2        0x02
#define PCF8591_CTRL_CH3        0x03
#define PCF8591_CTRL_AUTOINC    0x04
#define PCF8591_CTRL_OSCILLATOR 0x40

#define PCF8591_TEMP_SENS       0x00
#define PCF8591_SYS_FAN_CTRL    0x01

struct ecadc_channel {
       u_int           chan_num;
       u_int           chan_type;
       envsys_data_t   chan_sensor;
       u_char          *chan_xlate;
       int64_t         chan_factor;
       int64_t         chan_min;
       int64_t         chan_warn;
       int64_t         chan_crit;
       u_int8_t        chan_speed;
};

struct ecadc_softc {
       device_t                sc_dev;
       i2c_tag_t               sc_tag;
       i2c_addr_t              sc_addr;
       u_char                  sc_ps_xlate[XLATE_SIZE];
       u_char                  sc_cpu_xlate[XLATE_SIZE];
       u_char                  sc_cpu_fan_spd[XLATE_SIZE];
       u_int                   sc_nchan;
       struct ecadc_channel    sc_channels[PCF8591_CHANNELS];
       struct sysmon_envsys    *sc_sme;
       int                     sc_hastimer;
       callout_t               sc_timer;
};

static int      ecadc_match(device_t, cfdata_t, void *);
static void     ecadc_attach(device_t, device_t, void *);
static int      ecadc_detach(device_t, int);
static void     ecadc_refresh(struct sysmon_envsys *, envsys_data_t *);
static void     ecadc_get_limits(struct sysmon_envsys *, envsys_data_t *,
                       sysmon_envsys_lim_t *, u_int32_t *);
static int      ecadc_set_fan_speed(struct ecadc_softc *, u_int8_t, u_int8_t);
static void     ecadc_timeout(void *);
static void     ecadc_fan_adjust(void *);

CFATTACH_DECL3_NEW(ecadc, sizeof(struct ecadc_softc),
       ecadc_match, ecadc_attach, ecadc_detach, NULL, NULL, NULL,
       DVF_DETACH_SHUTDOWN);

static const struct device_compatible_entry compat_data[] = {
       { .compat = "ecadc" },
       DEVICE_COMPAT_EOL
};

static int
ecadc_match(device_t parent, cfdata_t cf, void *aux)
{
       struct i2c_attach_args *ia = aux;
       int match_result;

       if (iic_use_direct_match(ia, cf, compat_data, &match_result))
               return match_result;

       /* This driver is direct-config only. */

       return 0;
}

static void
ecadc_attach(device_t parent, device_t self, void *aux)
{
       struct i2c_attach_args *ia = aux;
       struct ecadc_softc *sc = device_private(self);
       u_char term[256];
       u_char *cp, *desc;
       int64_t minv, warnv, crit, num, den;
       u_int8_t junk[PCF8591_CHANNELS + 1];
       envsys_data_t *sensor;
       int len, error, addr, chan, node = (int)ia->ia_cookie;
       u_int i;

       sc->sc_dev = self;
       sc->sc_nchan = 0;
       sc->sc_hastimer = 0;

       DPRINTF("\n");
       if ((len = OF_getprop(node, "thermisters", term,
           sizeof(term))) < 0) {
               aprint_error(": couldn't find \"thermisters\" property\n");
               return;
       }

       if (OF_getprop(node, "cpu-temp-factors", &sc->sc_cpu_xlate[2],
           XLATE_MAX) < 0) {
               aprint_error(": couldn't find \"cpu-temp-factors\" property\n");
               return;
       }
       sc->sc_cpu_xlate[0] = sc->sc_cpu_xlate[1] = sc->sc_cpu_xlate[2];

       /* Only the Sun Enterprise 450 has these. */
       OF_getprop(node, "ps-temp-factors", &sc->sc_ps_xlate[2], XLATE_MAX);
       sc->sc_ps_xlate[0] = sc->sc_ps_xlate[1] = sc->sc_ps_xlate[2];

       cp = term;
       while (cp < term + len) {
               addr = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4;
               chan = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4;
               minv = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4;
               warnv = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4;
               crit = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4;
               num = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4;
               den = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4;
               desc = cp;
               while (cp < term + len && *cp++);

               if (addr != (ia->ia_addr << 1))
                       continue;

               if (num == 0 || den == 0)
                       num = den = 1;

               sc->sc_channels[sc->sc_nchan].chan_num = chan;
               sc->sc_channels[sc->sc_nchan].chan_type = PCF8591_TEMP_SENS;

               sensor = &sc->sc_channels[sc->sc_nchan].chan_sensor;
               sensor->units = ENVSYS_STEMP;
               sensor->flags |= ENVSYS_FMONLIMITS;
               sensor->state = ENVSYS_SINVALID;
               strlcpy(sensor->desc, desc, sizeof(sensor->desc));

               if (strncmp(desc, "CPU", 3) == 0) {
                       sc->sc_channels[sc->sc_nchan].chan_xlate =
                           sc->sc_cpu_xlate;
                       DPRINTF("%s: "
                           "added %s sensor (chan %d) with cpu_xlate\n",
                           device_xname(sc->sc_dev), desc, chan);
               } else if (strncmp(desc, "PS", 2) == 0) {
                       sc->sc_channels[sc->sc_nchan].chan_xlate =
                           sc->sc_ps_xlate;
                       DPRINTF("%s: "
                           "added %s sensor (chan %d) with ps_xlate\n",
                           device_xname(sc->sc_dev), desc, chan);
               } else {
                       sc->sc_channels[sc->sc_nchan].chan_factor =
                           (1000000 * num) / den;
                       DPRINTF("%s: "
                           "added %s sensor (chan %d) without xlate\n",
                           device_xname(sc->sc_dev), desc, chan);
               }
               sc->sc_channels[sc->sc_nchan].chan_min =
                   273150000 + 1000000 * minv;
               sc->sc_channels[sc->sc_nchan].chan_warn =
                   273150000 + 1000000 * warnv;
               sc->sc_channels[sc->sc_nchan].chan_crit =
                   273150000 + 1000000 * crit;
               sc->sc_nchan++;
       }

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

       iic_acquire_bus(sc->sc_tag, 0);

       /* Try a read now, so we can fail if this component isn't present */
       if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr,
           NULL, 0, junk, sc->sc_nchan + 1, 0)) {
               aprint_normal(": read failed\n");
               iic_release_bus(sc->sc_tag, 0);
               return;
       }

       iic_release_bus(sc->sc_tag, 0);

       /*
        * Fan speed changing information is missing from OFW
        * The E250 CPU fan is connected to the sensor at addr 0x4a, channel 1
        */
       if (ia->ia_addr == 0x4a && !strcmp(machine_model, "SUNW,Ultra-250") &&
           OF_getprop(node, "cpu-fan-speeds", &sc->sc_cpu_fan_spd,
           XLATE_MAX) > 0) {
               sc->sc_channels[sc->sc_nchan].chan_num = 1;
               sc->sc_channels[sc->sc_nchan].chan_type = PCF8591_SYS_FAN_CTRL;
               sensor = &sc->sc_channels[sc->sc_nchan].chan_sensor;
               sensor->units = ENVSYS_INTEGER;
               sensor->flags = ENVSYS_FMONNOTSUPP;
               sensor->state = ENVSYS_SINVALID;
               strlcpy(sensor->desc, "SYSFAN", sizeof(sensor->desc));
               sc->sc_channels[sc->sc_nchan].chan_xlate = sc->sc_cpu_fan_spd;
               DPRINTF("%s: "
                   "added CPUFAN sensor (chan %d) with cpu-fan xlate\n",
                   device_xname(sc->sc_dev),
                   sc->sc_channels[sc->sc_nchan].chan_num);

               /* Set the fan to medium speed */
               sc->sc_channels[sc->sc_nchan].chan_speed =
                   (sc->sc_cpu_fan_spd[0]+sc->sc_cpu_fan_spd[XLATE_MAX])/2;
               ecadc_set_fan_speed(sc, sc->sc_channels[sc->sc_nchan].chan_num,
                   sc->sc_channels[sc->sc_nchan].chan_speed);

               sc->sc_nchan++;
               sc->sc_hastimer = 1;
       }

       /* Hook us into the sysmon_envsys subsystem */
       sc->sc_sme = sysmon_envsys_create();
       sc->sc_sme->sme_name = device_xname(self);
       sc->sc_sme->sme_cookie = sc;
       sc->sc_sme->sme_refresh = ecadc_refresh;
       sc->sc_sme->sme_get_limits = ecadc_get_limits;

       /* Initialize sensor data. */
       for (i = 0; i < sc->sc_nchan; i++)
               sysmon_envsys_sensor_attach(sc->sc_sme,
                   &sc->sc_channels[i].chan_sensor);

       error = sysmon_envsys_register(sc->sc_sme);
       if (error) {
               aprint_error_dev(self, "error %d registering with sysmon\n",
                       error);
               sysmon_envsys_destroy(sc->sc_sme);
               sc->sc_sme = NULL;
               return;
       }

       if (sc->sc_hastimer) {
               callout_init(&sc->sc_timer, CALLOUT_MPSAFE);
               callout_reset(&sc->sc_timer, hz*20, ecadc_timeout, sc);
       }

       aprint_naive(": Temp Sensors\n");
       aprint_normal(": %s Temp Sensors (%d channels)\n", ia->ia_name,
           sc->sc_nchan);
}

static int
ecadc_detach(device_t self, int flags)
{
       struct ecadc_softc *sc = device_private(self);
       int c, i;

       if (sc->sc_hastimer) {
               callout_halt(&sc->sc_timer, NULL);
               callout_destroy(&sc->sc_timer);
       }

       if (sc->sc_sme != NULL)
               sysmon_envsys_unregister(sc->sc_sme);

       for (i = 0; i < sc->sc_nchan; i++) {
               struct ecadc_channel *chp = &sc->sc_channels[i];

               if (chp->chan_type == PCF8591_SYS_FAN_CTRL) {
                       /* Loop in case the bus is busy */
                       for (c = 0; c < 5; c++) {
                               chp->chan_speed = sc->sc_cpu_fan_spd[0];
                               if (!ecadc_set_fan_speed(sc, chp->chan_num,
                                   chp->chan_speed))
                                       return 0;
                               delay(10000);
                       }
                       printf("%s: cannot set fan speed (chan %d)\n",
                           device_xname(sc->sc_dev), chp->chan_num);
               }
       }

       return 0;
}

static void
ecadc_refresh(struct sysmon_envsys *sme, envsys_data_t *sensor)
{
       struct ecadc_softc *sc = sme->sme_cookie;
       u_int i;
       u_int8_t data[PCF8591_CHANNELS + 1];
       u_int8_t ctrl = PCF8591_CTRL_CH0 | PCF8591_CTRL_AUTOINC |
           PCF8591_CTRL_OSCILLATOR;

       if (iic_acquire_bus(sc->sc_tag, 0))
               return;
       if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_addr,
           &ctrl, 1, NULL, 0, 0)) {
               iic_release_bus(sc->sc_tag, 0);
               return;
       }
       /*
        * Each data byte that we read is the result of the previous request,
        * so read num_channels + 1 and update envsys values from chan + 1.
        */
       if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr,
           NULL, 0, data, PCF8591_CHANNELS + 1, 0)) {
               iic_release_bus(sc->sc_tag, 0);
               return;
       }
       iic_release_bus(sc->sc_tag, 0);

       /* Temperature with/without translation or relative (ADC value) */
       for (i = 0; i < sc->sc_nchan; i++) {
               struct ecadc_channel *chp = &sc->sc_channels[i];

               if (chp->chan_type == PCF8591_TEMP_SENS) {

                       /* Encode the raw value to use for the fan control */
                       if (chp->chan_xlate) {
                               int32_t temp;

                               temp = 273150000 + 1000000 *
                                   chp->chan_xlate[data[1 + chp->chan_num]];
                               temp &= ~0xff;
                               temp += data[1 + chp->chan_num];
                               chp->chan_sensor.value_cur = temp;
                               DPRINTF("%s: xlate %s sensor = %d"
                                   " (0x%x > 0x%x)\n",
                                   device_xname(sc->sc_dev),
                                   chp->chan_sensor.desc, temp,
                                   data[1 + chp->chan_num],
                                   chp->chan_xlate[data[1 + chp->chan_num]]);
                       } else {
                               chp->chan_sensor.value_cur = 273150000 +
                                   chp->chan_factor * data[1 + chp->chan_num];
                               DPRINTF("%s: read %s sensor = %d (0x%x)\n",
                                   device_xname(sc->sc_dev),
                                   chp->chan_sensor.desc,
                                   chp->chan_sensor.value_cur,
                                   data[1 + chp->chan_num]);
                       }
                       chp->chan_sensor.flags |= ENVSYS_FMONLIMITS;
               }
               if (chp->chan_type == PCF8591_SYS_FAN_CTRL)
                       chp->chan_sensor.value_cur = data[1 + chp->chan_num];

               chp->chan_sensor.state = ENVSYS_SVALID;
       }
}

static void
ecadc_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata,
               sysmon_envsys_lim_t *limits, u_int32_t *props)
{
       struct ecadc_softc *sc = sme->sme_cookie;
       int i;

       for (i = 0; i < sc->sc_nchan; i++) {
               if (edata != &sc->sc_channels[i].chan_sensor)
                       continue;
               if (sc->sc_channels[i].chan_type == PCF8591_TEMP_SENS) {
                       *props |= PROP_WARNMIN|PROP_WARNMAX|PROP_CRITMAX;
                       limits->sel_warnmin = sc->sc_channels[i].chan_min;
                       limits->sel_warnmax = sc->sc_channels[i].chan_warn;
                       limits->sel_critmax = sc->sc_channels[i].chan_crit;
               }
               return;
       }
}

static void
ecadc_timeout(void *v)
{
       struct ecadc_softc *sc = v;

       sysmon_task_queue_sched(0, ecadc_fan_adjust, sc);
       callout_reset(&sc->sc_timer, hz*60, ecadc_timeout, sc);
}

static bool
is_cpu_temp(const envsys_data_t *edata)
{
       if (edata->units != ENVSYS_STEMP)
               return false;
       return strncmp(edata->desc, "CPU", 3) == 0;
}

static bool
is_high_temp(const envsys_data_t *edata)
{
       if (edata->units != ENVSYS_INDICATOR)
               return false;
       return strcmp(edata->desc, "high_temp") == 0;
}

static bool
is_fan_fail(const envsys_data_t *edata)
{
       if (edata->units != ENVSYS_INDICATOR)
               return false;
       return strcmp(edata->desc, "fan_fail") == 0;
}

static int
ecadc_set_fan_speed(struct ecadc_softc *sc, u_int8_t chan, u_int8_t val)
{
       u_int8_t ctrl = PCF8591_CTRL_AUTOINC | PCF8591_CTRL_OSCILLATOR;
       int ret;

       ctrl |= chan;
       ret = iic_acquire_bus(sc->sc_tag, 0);
       if (ret) {
               printf("%s: error acquiring i2c bus (ch %d)\n",
                   device_xname(sc->sc_dev), chan);
               return ret;
       }
       ret = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_addr,
           &ctrl, 1, &val, 1, 0);
       if (ret)
               printf("%s: error changing fan speed (ch %d)\n",
                   device_xname(sc->sc_dev), chan);
       else
               DPRINTF("%s changed fan speed (ch %d) to 0x%x\n",
                   device_xname(sc->sc_dev), chan, val);
       iic_release_bus(sc->sc_tag, 0);
       return ret;
}

static void
ecadc_fan_adjust(void *v)
{
       struct ecadc_softc *sc = v;
       struct ecadc_channel *chp;
       int i;
       u_int8_t temp, speed;
       u_int32_t htemp, ffail;

       for (i = 0; i < sc->sc_nchan; i++) {
               chp = &sc->sc_channels[i];
               if (chp->chan_type != PCF8591_SYS_FAN_CTRL)
                       continue;

               /* Check for high temperature or fan failure */
               htemp = sysmon_envsys_get_max_value(is_high_temp, true);
               ffail = sysmon_envsys_get_max_value(is_fan_fail, true);
               if (htemp) {
                       printf("%s: High temperature detected\n",
                           device_xname(sc->sc_dev));
                       /* Set fans to maximum speed */
                       speed = sc->sc_cpu_fan_spd[0];
               } else if (ffail) {
                       printf("%s: Fan failure detected\n",
                           device_xname(sc->sc_dev));
                       /* Set fans to maximum speed */
                       speed = sc->sc_cpu_fan_spd[0];
               } else {
                       /* Extract the raw value from the max CPU temp */
                       temp = sysmon_envsys_get_max_value(is_cpu_temp, true)
                           & 0xff;
                       if (!temp) {
                               printf("%s: skipping temp adjustment"
                                   " - no sensor values\n",
                                   device_xname(sc->sc_dev));
                               return;
                       }
                       if (temp > XLATE_MAX)
                               temp = XLATE_MAX;
                       speed = chp->chan_xlate[temp];
               }
               if (speed != chp->chan_speed) {
                       if (!ecadc_set_fan_speed(sc, chp->chan_num,
                           speed))
                               chp->chan_speed = speed;
               }
       }
}

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.