FreeBSD/Linux Kernel Cross Reference
sys/dev/isa/fins.c

     /*      $OpenBSD: fins.c,v 1.6 2022/04/08 15:02:28 naddy Exp $  */
     
     /*
      * Copyright (c) 2005, 2006 Mark Kettenis
      * Copyright (c) 2007, 2008 Geoff Steckel
      *
      * 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/param.h>
    #include <sys/systm.h>
    #include <sys/device.h>
    #include <sys/kernel.h>
    #include <sys/queue.h>
    #include <sys/sensors.h>
    #include <machine/bus.h>
    
    #include <dev/isa/isareg.h>
    #include <dev/isa/isavar.h>
    
    /* Derived from LM78 code.  Only handles chips attached to ISA bus */
    
    /*
     * Fintek F71805 registers and constants
     * http://www.fintek.com.tw/files/productfiles/F71805F_V025.pdf
     * This chip is a multi-io chip with many functions.
     * Each function may be relocated in I/O space by the BIOS.
     * The base address (2E or 4E) accesses a configuration space which
     * has pointers to the individual functions. The config space must be
     * unlocked with a cookie and relocked afterwards. The chip ID is stored
     * in config space so it is not normally visible.
     *
     * We assume that the monitor is enabled. We don't try to start or stop it.
     * The voltage dividers specified are from reading the chips on one board.
     * There is no way to determine what they are in the general case.
     * This section of the chip controls the fans. We don't do anything to them.
     */
    
    #define FINS_UNLOCK     0x87    /* magic constant - write 2x to select chip */
    #define FINS_LOCK       0xaa    /* magic constant - write 1x to deselect reg */
    
    /* ISA registers index to an internal register space on chip */
    #define FINS_ADDR       0x00
    #define FINS_DATA       0x01
    
    #define FINS_FUNC_SEL   0x07    /* select which chip function to access */
    #define FINS_CHIP       0x20    /* chip ID */
    #define FINS_MANUF      0x23    /* manufacturer ID */
    #define FINS_BASEADDR   0x60    /* I/O base of chip function */
    
    #define FINS_71806      0x0341  /* same as F71872 */
    #define FINS_71805      0x0406
    #define FINS_71882      0x0541  /* same as F71883 */
    #define FINS_71862      0x0601  /* same as F71863 */
    #define FINTEK_ID       0x1934
    
    #define FINS_FUNC_SENSORS       0x04
    #define FINS_FUNC_WATCHDOG      0x07
    
    /* sensors device registers */
    #define FINS_SENS_TMODE(sc)     ((sc)->fins_chipid <= FINS_71805 ? 0x01 : 0x6b)
    #define FINS_SENS_VDIVS         0x0e
    
    /* watchdog device registers (mapped straight to i/o port offsets) */
    #define FINS_WDOG_CR0   0x00
    #define FINS_WDOG_CR1   0x05
    #define FINS_WDOG_TIMER 0x06
    
    /* CR0 flags */
    #define FINS_WDOG_OUTEN 0x80
    
    /* CR1 flags */
    #define FINS_WDOG_EN    0x20
    #define FINS_WDOG_MINS  0x08
    
    #define FINS_MAX_SENSORS 18
    /*
     * Fintek chips typically measure voltages using 8mv steps.
     * To measure higher voltages the input is attenuated with (external)
     * resistors.  Negative voltages are measured using inverting op amps
     * and resistors.  So we have to convert the sensor values back to
     * real voltages by applying the appropriate resistor factor.
     */
    #define FRFACT_NONE     8000
    #define FRFACT(x, y)    (FRFACT_NONE * ((x) + (y)) / (y))
    #define FNRFACT(x, y)   (-FRFACT_NONE * (x) / (y))
    
    struct fins_softc;
    
   struct fins_sensor {
           char *fs_desc;
           void (*fs_refresh)(struct fins_softc *, int);
           enum sensor_type fs_type;
           int fs_aux;
           u_int8_t fs_reg;
   };
   
   struct fins_softc {
           struct device sc_dev;
   
           struct ksensor fins_ksensors[FINS_MAX_SENSORS];
           struct ksensordev fins_sensordev;
           struct sensor_task *fins_sensortask;
           const struct fins_sensor *fins_sensors;
   
           bus_space_handle_t sc_ioh_sens;
           bus_space_handle_t sc_ioh_wdog;
           bus_space_tag_t sc_iot;
   
           u_int16_t fins_chipid;
           u_int8_t fins_tempsel;
           u_int8_t fins_wdog_cr;
   };
   
   int  fins_match(struct device *, void *, void *);
   void fins_attach(struct device *, struct device *, void *);
   int  fins_activate(struct device *, int);
   
   void fins_unlock(bus_space_tag_t, bus_space_handle_t);
   void fins_lock(bus_space_tag_t, bus_space_handle_t);
   
   u_int8_t fins_read(bus_space_tag_t, bus_space_handle_t, int);
   u_int16_t fins_read_2(bus_space_tag_t, bus_space_handle_t, int);
   void fins_write(bus_space_tag_t, bus_space_handle_t, int, u_int8_t);
   
   static __inline u_int8_t fins_read_sens(struct fins_softc *, int);
   static __inline u_int16_t fins_read_sens_2(struct fins_softc *, int);
   
   static __inline u_int8_t fins_read_wdog(struct fins_softc *, int);
   static __inline void fins_write_wdog(struct fins_softc *, int, u_int8_t);
   
   void fins_setup_sensors(struct fins_softc *, const struct fins_sensor *);
   void fins_refresh(void *);
   
   void fins_get_rpm(struct fins_softc *, int);
   void fins_get_temp(struct fins_softc *, int);
   void fins_get_volt(struct fins_softc *, int);
   
   int fins_wdog_cb(void *, int);
   
   const struct cfattach fins_ca = {
           sizeof(struct fins_softc),
           fins_match,
           fins_attach,
           NULL,
           fins_activate
   };
   
   struct cfdriver fins_cd = {
           NULL, "fins", DV_DULL
   };
   
   const struct fins_sensor fins_71805_sensors[] = {
           { "+3.3V",  fins_get_volt, SENSOR_VOLTS_DC, FRFACT(100, 100),   0x10 },
           { "Vtt",    fins_get_volt, SENSOR_VOLTS_DC, FRFACT_NONE,        0x11 },
           { "Vram",   fins_get_volt, SENSOR_VOLTS_DC, FRFACT(100, 100),   0x12 },
           { "Vchips", fins_get_volt, SENSOR_VOLTS_DC, FRFACT(47, 100),    0x13 },
           { "+5V",    fins_get_volt, SENSOR_VOLTS_DC, FRFACT(200, 47),    0x14 },
           { "+12V",   fins_get_volt, SENSOR_VOLTS_DC, FRFACT(200, 20),    0x15 },
           { "+1.5V",  fins_get_volt, SENSOR_VOLTS_DC, FRFACT_NONE,        0x16 },
           { "Vcore",  fins_get_volt, SENSOR_VOLTS_DC, FRFACT_NONE,        0x17 },
           { "Vsb",    fins_get_volt, SENSOR_VOLTS_DC, FRFACT(200, 47),    0x18 },
           { "Vsbint", fins_get_volt, SENSOR_VOLTS_DC, FRFACT(200, 47),    0x19 },
           { "Vbat",   fins_get_volt, SENSOR_VOLTS_DC, FRFACT(200, 47),    0x1a },
   
           { NULL, fins_get_temp, SENSOR_TEMP, 0x01, 0x1b },
           { NULL, fins_get_temp, SENSOR_TEMP, 0x02, 0x1c },
           { NULL, fins_get_temp, SENSOR_TEMP, 0x04, 0x1d },
   
           { NULL, fins_get_rpm, SENSOR_FANRPM, 0, 0x20 },
           { NULL, fins_get_rpm, SENSOR_FANRPM, 0, 0x22 },
           { NULL, fins_get_rpm, SENSOR_FANRPM, 0, 0x24 },
   
           { NULL }
   };
   
   const struct fins_sensor fins_71882_sensors[] = {
           { "+3.3V",  fins_get_volt, SENSOR_VOLTS_DC, FRFACT(100, 100),   0x20 },
           { "Vcore",  fins_get_volt, SENSOR_VOLTS_DC, FRFACT_NONE,        0x21 },
           { "Vram",   fins_get_volt, SENSOR_VOLTS_DC, FRFACT(100, 100),   0x22 },
           { "Vchips", fins_get_volt, SENSOR_VOLTS_DC, FRFACT(47, 100),    0x23 },
           { "+5V",    fins_get_volt, SENSOR_VOLTS_DC, FRFACT(200, 47),    0x24 },
           { "+12V",   fins_get_volt, SENSOR_VOLTS_DC, FRFACT(200, 20),    0x25 },
           { "+1.5V",  fins_get_volt, SENSOR_VOLTS_DC, FRFACT_NONE,        0x26 },
           { "Vsb",    fins_get_volt, SENSOR_VOLTS_DC, FRFACT(100, 100),   0x27 },
           { "Vbat",   fins_get_volt, SENSOR_VOLTS_DC, FRFACT(100, 100),   0x28 },
   
           { NULL, fins_get_temp, SENSOR_TEMP, 0x02, 0x72 },
           { NULL, fins_get_temp, SENSOR_TEMP, 0x04, 0x74 },
           { NULL, fins_get_temp, SENSOR_TEMP, 0x08, 0x76 },
   
           { NULL, fins_get_rpm, SENSOR_FANRPM, 0, 0xa0 },
           { NULL, fins_get_rpm, SENSOR_FANRPM, 0, 0xb0 },
           { NULL, fins_get_rpm, SENSOR_FANRPM, 0, 0xc0 },
           { NULL, fins_get_rpm, SENSOR_FANRPM, 0, 0xd0 },
   
           { NULL }
   };
   
   int
   fins_match(struct device *parent, void *match, void *aux)
   {
           struct isa_attach_args *ia = aux;
           bus_space_handle_t ioh;
           bus_space_tag_t iot;
           int ret = 0;
           u_int16_t id;
   
           iot = ia->ia_iot;
           if (bus_space_map(iot, ia->ipa_io[0].base, 2, 0, &ioh))
                   return (0);
   
           /* Fintek uses magic cookie locks to distinguish their chips */
           fins_unlock(iot, ioh);
   
           fins_write(iot, ioh, FINS_FUNC_SEL, 0); /* IDs appear only in space 0 */
           if (fins_read_2(iot, ioh, FINS_MANUF) != FINTEK_ID)
                   goto match_done;
           id = fins_read_2(iot, ioh, FINS_CHIP);
           switch(id) {
           case FINS_71882:
           case FINS_71862:
                   ia->ipa_nio = 3;
                   fins_write(iot, ioh, FINS_FUNC_SEL, FINS_FUNC_WATCHDOG);
                   ia->ipa_io[2].base = fins_read_2(iot, ioh, FINS_BASEADDR);
                   ia->ipa_io[2].length = 8;
                   fins_write(iot, ioh, FINS_FUNC_SEL, FINS_FUNC_SENSORS);
                   ia->ipa_io[1].base = fins_read_2(iot, ioh, FINS_BASEADDR);
                   ia->ipa_io[1].base += 5;
                   break;
           case FINS_71806:
           case FINS_71805:
                   ia->ipa_nio = 2;
                   fins_write(iot, ioh, FINS_FUNC_SEL, FINS_FUNC_SENSORS);
                   ia->ipa_io[1].base = fins_read_2(iot, ioh, FINS_BASEADDR);
                   break;
           default:
                   goto match_done;
           }
           ia->ipa_io[0].length = ia->ipa_io[1].length = 2;
           ia->ipa_nmem = ia->ipa_nirq = ia->ipa_ndrq = 0;
           ia->ia_aux = (void *)(u_long)id;
           ret = 1;
   match_done:
           fins_lock(iot, ioh);
           return (ret);
   }
   
   void
   fins_attach(struct device *parent, struct device *self, void *aux)
   {
           struct fins_softc *sc = (struct fins_softc *)self;
           struct isa_attach_args *ia = aux;
           bus_addr_t iobase;
           u_int32_t iosize;
           u_int i;
   
           sc->sc_iot = ia->ia_iot;
           sc->fins_chipid = (u_int16_t)(u_long)ia->ia_aux;
           iobase = ia->ipa_io[1].base;
           iosize = ia->ipa_io[1].length;
           if (bus_space_map(sc->sc_iot, iobase, iosize, 0, &sc->sc_ioh_sens)) {
                   printf(": can't map sensor i/o space\n");
                   return;
           }
           switch(sc->fins_chipid) {
           case FINS_71882:
           case FINS_71862:
                   fins_setup_sensors(sc, fins_71882_sensors);
                   break;
           case FINS_71806:
           case FINS_71805:
                   fins_setup_sensors(sc, fins_71805_sensors);
                   break;
           }
           sc->fins_sensortask = sensor_task_register(sc, fins_refresh, 5);
           if (sc->fins_sensortask == NULL) {
                   printf(": can't register update task\n");
                   return;
           }
           for (i = 0; sc->fins_sensors[i].fs_refresh != NULL; ++i)
                   sensor_attach(&sc->fins_sensordev, &sc->fins_ksensors[i]);
           sensordev_install(&sc->fins_sensordev);
   
           if (sc->fins_chipid <= FINS_71805)
                   goto attach_done;
           iobase = ia->ipa_io[2].base;
           iosize = ia->ipa_io[2].length;
           if (bus_space_map(sc->sc_iot, iobase, iosize, 0, &sc->sc_ioh_wdog)) {
                   printf(": can't map watchdog i/o space\n");
                   return;
           }
           sc->fins_wdog_cr = fins_read_wdog(sc, FINS_WDOG_CR1);
           sc->fins_wdog_cr &= ~(FINS_WDOG_MINS | FINS_WDOG_EN);
           fins_write_wdog(sc, FINS_WDOG_CR1, sc->fins_wdog_cr);
           wdog_register(fins_wdog_cb, sc);
   attach_done:
           printf("\n");
   }
   
   int
   fins_activate(struct device *self, int act)
   {
           switch (act) {
           case DVACT_POWERDOWN:
                   wdog_shutdown(self);
                   break;
           }
   
           return (0);
   }
   
   u_int8_t
   fins_read(bus_space_tag_t iot, bus_space_handle_t ioh, int reg)
   {
           bus_space_write_1(iot, ioh, FINS_ADDR, reg);
           return (bus_space_read_1(iot, ioh, FINS_DATA));
   }
   
   u_int16_t
   fins_read_2(bus_space_tag_t iot, bus_space_handle_t ioh, int reg)
   {
           u_int16_t val;
   
           bus_space_write_1(iot, ioh, FINS_ADDR, reg);
           val = bus_space_read_1(iot, ioh, FINS_DATA) << 8;
           bus_space_write_1(iot, ioh, FINS_ADDR, reg + 1);
           return (val | bus_space_read_1(iot, ioh, FINS_DATA));
   }
   
   void
   fins_write(bus_space_tag_t iot, bus_space_handle_t ioh, int reg, u_int8_t val)
   {
           bus_space_write_1(iot, ioh, FINS_ADDR, reg);
           bus_space_write_1(iot, ioh, FINS_DATA, val);
   }
   
   static __inline u_int8_t
   fins_read_sens(struct fins_softc *sc, int reg)
   {
           return (fins_read(sc->sc_iot, sc->sc_ioh_sens, reg));
   }
   
   static __inline u_int16_t
   fins_read_sens_2(struct fins_softc *sc, int reg)
   {
           return (fins_read_2(sc->sc_iot, sc->sc_ioh_sens, reg));
   }
   
   static __inline u_int8_t
   fins_read_wdog(struct fins_softc *sc, int reg)
   {
           return (bus_space_read_1(sc->sc_iot, sc->sc_ioh_wdog, reg));
   }
   
   static __inline void
   fins_write_wdog(struct fins_softc *sc, int reg, u_int8_t val)
   {
           bus_space_write_1(sc->sc_iot, sc->sc_ioh_wdog, reg, val);
   }
   
   void
   fins_unlock(bus_space_tag_t iot, bus_space_handle_t ioh)
   {
           bus_space_write_1(iot, ioh, 0, FINS_UNLOCK);
           bus_space_write_1(iot, ioh, 0, FINS_UNLOCK);
   }
   
   void
   fins_lock(bus_space_tag_t iot, bus_space_handle_t ioh)
   {
           bus_space_write_1(iot, ioh, 0, FINS_LOCK);
           bus_space_unmap(iot, ioh, 2);
   }
   
   void
   fins_setup_sensors(struct fins_softc *sc, const struct fins_sensor *sensors)
   {
           int i;
   
           for (i = 0; sensors[i].fs_refresh != NULL; ++i) {
                   sc->fins_ksensors[i].type = sensors[i].fs_type;
                   if (sensors[i].fs_desc != NULL)
                           strlcpy(sc->fins_ksensors[i].desc, sensors[i].fs_desc,
                                   sizeof(sc->fins_ksensors[i].desc));
           }
           strlcpy(sc->fins_sensordev.xname, sc->sc_dev.dv_xname,
                   sizeof(sc->fins_sensordev.xname));
           sc->fins_sensors = sensors;
           sc->fins_tempsel = fins_read_sens(sc, FINS_SENS_TMODE(sc));
   }
   
   #if 0
   void
   fins_get_dividers(struct fins_softc *sc)
   {
           int i, p, m;
           u_int16_t r = fins_read_sens_2(sc, FINS_SENS_VDIVS);
   
           for (i = 0; i < 6; ++i) {
                   p = (i < 4) ? i : i + 2;
                   m = (r & (0x03 << p)) >> p;
                   if (m == 3)
                           m = 4;
                   fins_71882_sensors[i + 1].fs_aux = FRFACT_NONE << m;
           }
   }
   #endif
   
   void
   fins_refresh(void *arg)
   {
           struct fins_softc *sc = arg;
           int i;
   
           for (i = 0; sc->fins_sensors[i].fs_refresh != NULL; ++i)
                   sc->fins_sensors[i].fs_refresh(sc, i);
   }
   
   void
   fins_get_volt(struct fins_softc *sc, int n)
   {
           struct ksensor *sensor = &sc->fins_ksensors[n];
           const struct fins_sensor *fs = &sc->fins_sensors[n];
           int data;
   
           data = fins_read_sens(sc, fs->fs_reg);
           if (data == 0xff || data == 0) {
                   sensor->flags |= SENSOR_FINVALID;
                   sensor->value = 0;
           } else {
                   sensor->flags &= ~SENSOR_FINVALID;
                   sensor->value = data * fs->fs_aux;
           }
   }
   
   /* The BIOS seems to add a fudge factor to the CPU temp of +5C */
   void
   fins_get_temp(struct fins_softc *sc, int n)
   {
           struct ksensor *sensor = &sc->fins_ksensors[n];
           const struct fins_sensor *fs = &sc->fins_sensors[n];
           u_int data;
           u_int max;
   
           /*
            * The data sheet says that the range of the temperature
            * sensor is between 0 and 127 or 140 degrees C depending on
            * what kind of sensor is used.
            * A disconnected sensor seems to read over 110 or so.
            */
           data = fins_read_sens(sc, fs->fs_reg);
           max = (sc->fins_tempsel & fs->fs_aux) ? 111 : 128;
           if (data == 0 || data >= max) { /* disconnected? */
                   sensor->flags |= SENSOR_FINVALID;
                   sensor->value = 0;
           } else {
                   sensor->flags &= ~SENSOR_FINVALID;
                   sensor->value = data * 1000000 + 273150000;
           }
   }
   
   /* The chip holds a fudge factor for BJT sensors */
   /* this is currently unused but might be reenabled */
   #if 0
   void
   fins_refresh_offset(struct fins_softc *sc, int n)
   {
           struct ksensor *sensor = &sc->fins_ksensors[n];
           const struct fins_sensor *fs = &sc->fins_sensors[n];
           u_int data;
   
           sensor->flags &= ~SENSOR_FINVALID;
           data = fins_read_sens(sc, fs->fs_reg);
           data |= ~0 * (data & 0x40);     /* sign extend 7-bit value */
           sensor->value = data * 1000000 + 273150000;
   }
   #endif
   
   /* fan speed appears to be a 12-bit number */
   void
   fins_get_rpm(struct fins_softc *sc, int n)
   {
           struct ksensor *sensor = &sc->fins_ksensors[n];
           const struct fins_sensor *fs = &sc->fins_sensors[n];
           int data;
   
           data = fins_read_sens_2(sc, fs->fs_reg);
           if (data >= 0xfff) {
                   sensor->value = 0;
                   sensor->flags |= SENSOR_FINVALID;
           } else {
                   sensor->value = 1500000 / data;
                   sensor->flags &= ~SENSOR_FINVALID;
           }
   }
   
   int
   fins_wdog_cb(void *arg, int period)
   {
           struct fins_softc *sc = arg;
           u_int8_t cr0, cr1, t;
   
           cr0 = fins_read_wdog(sc, FINS_WDOG_CR0) & ~FINS_WDOG_OUTEN;
           fins_write_wdog(sc, FINS_WDOG_CR0, cr0);
   
           cr1 = sc->fins_wdog_cr;
           if (period > 0xff) {
                   cr1 |= FINS_WDOG_MINS;
                   t = (period + 59) / 60;
                   period = (int)t * 60;
           } else if (period > 0)
                   t = period;
           else
                   return (0);
   
           fins_write_wdog(sc, FINS_WDOG_TIMER, t);
           fins_write_wdog(sc, FINS_WDOG_CR0, cr0 | FINS_WDOG_OUTEN);
           fins_write_wdog(sc, FINS_WDOG_CR1, cr1 | FINS_WDOG_EN);
           return (period);
   }

Cache object: f85753254c2fa94e08df379cd22ee88e