root/dev/ic/lm78.c

DEFINITIONS

1. lm_attach
2. lm_detach
3. lm_match
4. def_match
5. wb_match
6. lm_setup_sensors
7. lm_refresh
8. lm_refresh_sensor_data
9. lm_refresh_volt
10. lm_refresh_temp
11. lm_refresh_fanrpm
12. wb_refresh_sensor_data
13. wb_w83637hf_refresh_vcore
14. wb_refresh_nvolt
15. wb_w83627ehf_refresh_nvolt
16. wb_refresh_temp
17. wb_refresh_fanrpm
18. wb_w83792d_refresh_fanrpm
19. as_refresh_temp

    1 /*      $OpenBSD: lm78.c,v 1.20 2007/06/25 22:50:18 cnst Exp $  */
    3 /*
    4  * Copyright (c) 2005, 2006 Mark Kettenis
    5  *
    6  * Permission to use, copy, modify, and distribute this software for any
    7  * purpose with or without fee is hereby granted, provided that the above
    8  * copyright notice and this permission notice appear in all copies.
    9  *
   10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   17  */
   19 #include <sys/param.h>
   20 #include <sys/systm.h>
   21 #include <sys/device.h>
   22 #include <sys/kernel.h>
   23 #include <sys/queue.h>
   24 #include <sys/sensors.h>
   25 #include <machine/bus.h>
   27 #include <dev/ic/lm78var.h>
   29 #if defined(LMDEBUG)
   30 #define DPRINTF(x)              do { printf x; } while (0)
   31 #else
   32 #define DPRINTF(x)
   33 #endif
   35 /*
   36  * LM78-compatible chips can typically measure voltages up to 4.096 V.
   37  * To measure higher voltages the input is attenuated with (external)
   38  * resistors.  Negative voltages are measured using inverting op amps
   39  * and resistors.  So we have to convert the sensor values back to
   40  * real voltages by applying the appropriate resistor factor.
   41  */
   42 #define RFACT_NONE      10000
   43 #define RFACT(x, y)     (RFACT_NONE * ((x) + (y)) / (y))
   44 #define NRFACT(x, y)    (-RFACT_NONE * (x) / (y))
   46 struct cfdriver lm_cd = {
NULL, "lm", DV_DULL
   48 };
   50 int  lm_match(struct lm_softc *);
   51 int  wb_match(struct lm_softc *);
   52 int  def_match(struct lm_softc *);
   54 void lm_setup_sensors(struct lm_softc *, struct lm_sensor *);
   55 void lm_refresh(void *);
   57 void lm_refresh_sensor_data(struct lm_softc *);
   58 void lm_refresh_volt(struct lm_softc *, int);
   59 void lm_refresh_temp(struct lm_softc *, int);
   60 void lm_refresh_fanrpm(struct lm_softc *, int);
   62 void wb_refresh_sensor_data(struct lm_softc *);
   63 void wb_w83637hf_refresh_vcore(struct lm_softc *, int);
   64 void wb_refresh_nvolt(struct lm_softc *, int);
   65 void wb_w83627ehf_refresh_nvolt(struct lm_softc *, int);
   66 void wb_refresh_temp(struct lm_softc *, int);
   67 void wb_refresh_fanrpm(struct lm_softc *, int);
   68 void wb_w83792d_refresh_fanrpm(struct lm_softc *, int);
   70 void as_refresh_temp(struct lm_softc *, int);
   72 struct lm_chip {
   73         int (*chip_match)(struct lm_softc *);
   74 };
   76 struct lm_chip lm_chips[] = {
   77         { wb_match },
   78         { lm_match },
   79         { def_match } /* Must be last */
   80 };
   82 struct lm_sensor lm78_sensors[] = {
   83         /* Voltage */
   84         { "VCore A", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
   85         { "VCore B", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
   86         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
   87         { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(68, 100) },
   88         { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(30, 10) },
   89         { "-12V", SENSOR_VOLTS_DC, 0, 0x25, lm_refresh_volt, NRFACT(240, 60) },
   90         { "-5V", SENSOR_VOLTS_DC, 0, 0x26, lm_refresh_volt, NRFACT(100, 60) },
   92         /* Temperature */
   93         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
   95         /* Fans */
   96         { "", SENSOR_FANRPM, 0, 0x28, lm_refresh_fanrpm },
   97         { "", SENSOR_FANRPM, 0, 0x29, lm_refresh_fanrpm },
   98         { "", SENSOR_FANRPM, 0, 0x2a, lm_refresh_fanrpm },
  100         { NULL }
  101 };
  103 struct lm_sensor w83627hf_sensors[] = {
  104         /* Voltage */
  105         { "VCore A", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
  106         { "VCore B", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
  107         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
  108         { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
  109         { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
  110         { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
  111         { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
  112         { "5VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(17, 33) },
  113         { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE },
  115         /* Temperature */
  116         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  117         { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
  118         { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
  120         /* Fans */
  121         { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
  122         { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
  123         { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
  125         { NULL }
  126 };
  128 /*
  129  * The W83627EHF can measure voltages up to 2.048 V instead of the
  130  * traditional 4.096 V.  For measuring positive voltages, this can be
  131  * accounted for by halving the resistor factor.  Negative voltages
  132  * need special treatment, also because the reference voltage is 2.048 V
  133  * instead of the traditional 3.6 V.
  134  */
  135 struct lm_sensor w83627ehf_sensors[] = {
  136         /* Voltage */
  137         { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE / 2},
  138         { "+12V", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT(56, 10) / 2 },
  139         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT(34, 34) / 2 },
  140         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 34) / 2 },
  141         { "-12V", SENSOR_VOLTS_DC, 0, 0x24, wb_w83627ehf_refresh_nvolt },
  142         { "", SENSOR_VOLTS_DC, 0, 0x25, lm_refresh_volt, RFACT_NONE / 2 },
  143         { "", SENSOR_VOLTS_DC, 0, 0x26, lm_refresh_volt, RFACT_NONE / 2 },
  144         { "3.3VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(34, 34) / 2 },
  145         { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE / 2 },
  146         { "", SENSOR_VOLTS_DC, 5, 0x52, lm_refresh_volt, RFACT_NONE / 2 },
  148         /* Temperature */
  149         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  150         { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
  151         { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
  153         /* Fans */
  154         { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
  155         { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
  156         { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
  158         { NULL }
  159 };
  161 /* 
  162  * w83627dhg is almost identical to w83627ehf, except that 
  163  * it has 9 instead of 10 voltage sensors
  164  */
  165 struct lm_sensor w83627dhg_sensors[] = {
  166         /* Voltage */
  167         { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE / 2},
  168         { "+12V", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT(56, 10) / 2 },
  169         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT(34, 34) / 2 },
  170         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 34) / 2 },
  171         { "-12V", SENSOR_VOLTS_DC, 0, 0x24, wb_w83627ehf_refresh_nvolt },
  172         { "", SENSOR_VOLTS_DC, 0, 0x25, lm_refresh_volt, RFACT_NONE / 2 },
  173         { "", SENSOR_VOLTS_DC, 0, 0x26, lm_refresh_volt, RFACT_NONE / 2 },
  174         { "3.3VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(34, 34) / 2 },
  175         { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE / 2 },
  177         /* Temperature */
  178         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  179         { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
  180         { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
  182         /* Fans */
  183         { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
  184         { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
  185         { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
  187         { NULL }
  188 };
  190 struct lm_sensor w83637hf_sensors[] = {
  191         /* Voltage */
  192         { "VCore", SENSOR_VOLTS_DC, 0, 0x20, wb_w83637hf_refresh_vcore },
  193         { "+12V", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT(28, 10) },
  194         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
  195         { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 51) },
  196         { "-12V", SENSOR_VOLTS_DC, 0, 0x24, wb_refresh_nvolt, RFACT(232, 56) },
  197         { "5VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(34, 51) },
  198         { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE },
  200         /* Temperature */
  201         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  202         { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
  203         { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
  205         /* Fans */
  206         { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
  207         { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
  208         { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
  210         { NULL }
  211 };
  213 struct lm_sensor w83697hf_sensors[] = {
  214         /* Voltage */
  215         { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
  216         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
  217         { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
  218         { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
  219         { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
  220         { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
  221         { "5VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(17, 33) },
  222         { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE },
  224         /* Temperature */
  225         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  226         { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
  228         /* Fans */
  229         { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
  230         { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
  232         { NULL }
  233 };
  235 /*
  236  * The datasheet doesn't mention the (internal) resistors used for the
  237  * +5V, but using the values from the W83782D datasheets seems to
  238  * provide sensible results.
  239  */
  240 struct lm_sensor w83781d_sensors[] = {
  241         /* Voltage */
  242         { "VCore A", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
  243         { "VCore B", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
  244         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
  245         { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
  246         { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
  247         { "-12V", SENSOR_VOLTS_DC, 0, 0x25, lm_refresh_volt, NRFACT(2100, 604) },
  248         { "-5V", SENSOR_VOLTS_DC, 0, 0x26, lm_refresh_volt, NRFACT(909, 604) },
  250         /* Temperature */
  251         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  252         { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
  253         { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
  255         /* Fans */
  256         { "", SENSOR_FANRPM, 0, 0x28, lm_refresh_fanrpm },
  257         { "", SENSOR_FANRPM, 0, 0x29, lm_refresh_fanrpm },
  258         { "", SENSOR_FANRPM, 0, 0x2a, lm_refresh_fanrpm },
  260         { NULL }
  261 };
  263 struct lm_sensor w83782d_sensors[] = {
  264         /* Voltage */
  265         { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
  266         { "VINR0", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
  267         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
  268         { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
  269         { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
  270         { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
  271         { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
  272         { "5VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(17, 33) },
  273         { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE },
  275         /* Temperature */
  276         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  277         { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
  278         { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
  280         /* Fans */
  281         { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
  282         { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
  283         { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
  285         { NULL }
  286 };
  288 struct lm_sensor w83783s_sensors[] = {
  289         /* Voltage */
  290         { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
  291         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
  292         { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
  293         { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
  294         { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
  295         { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
  297         /* Temperature */
  298         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  299         { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
  301         /* Fans */
  302         { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
  303         { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
  304         { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
  306         { NULL }
  307 };
  309 struct lm_sensor w83791d_sensors[] = {
  310         /* Voltage */
  311         { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, 10000 },
  312         { "VINR0", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, 10000 },
  313         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, 10000 },
  314         { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
  315         { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
  316         { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
  317         { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
  318         { "5VSB", SENSOR_VOLTS_DC, 0, 0xb0, lm_refresh_volt, RFACT(17, 33) },
  319         { "VBAT", SENSOR_VOLTS_DC, 0, 0xb1, lm_refresh_volt, RFACT_NONE },
  320         { "VINR1", SENSOR_VOLTS_DC, 0, 0xb2, lm_refresh_volt, RFACT_NONE },
  322         /* Temperature */
  323         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  324         { "", SENSOR_TEMP, 0, 0xc0, wb_refresh_temp },
  325         { "", SENSOR_TEMP, 0, 0xc8, wb_refresh_temp },
  327         /* Fans */
  328         { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
  329         { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
  330         { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
  331         { "", SENSOR_FANRPM, 0, 0xba, wb_refresh_fanrpm },
  332         { "", SENSOR_FANRPM, 0, 0xbb, wb_refresh_fanrpm },
  334         { NULL }
  335 };
  337 struct lm_sensor w83792d_sensors[] = {
  338         /* Voltage */
  339         { "VCore A", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
  340         { "VCore B", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
  341         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
  342         { "-5V", SENSOR_VOLTS_DC, 0, 0x23, wb_refresh_nvolt, RFACT(120, 56) },
  343         { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
  344         { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
  345         { "+5V", SENSOR_VOLTS_DC, 0, 0x26, lm_refresh_volt, RFACT(34, 50) },
  346         { "5VSB", SENSOR_VOLTS_DC, 0, 0xb0, lm_refresh_volt, RFACT(17, 33) },
  347         { "VBAT", SENSOR_VOLTS_DC, 0, 0xb1, lm_refresh_volt, RFACT_NONE },
  349         /* Temperature */
  350         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  351         { "", SENSOR_TEMP, 0, 0xc0, wb_refresh_temp },
  352         { "", SENSOR_TEMP, 0, 0xc8, wb_refresh_temp },
  354         /* Fans */
  355         { "", SENSOR_FANRPM, 0, 0x28, wb_w83792d_refresh_fanrpm },
  356         { "", SENSOR_FANRPM, 0, 0x29, wb_w83792d_refresh_fanrpm },
  357         { "", SENSOR_FANRPM, 0, 0x2a, wb_w83792d_refresh_fanrpm },
  358         { "", SENSOR_FANRPM, 0, 0xb8, wb_w83792d_refresh_fanrpm },
  359         { "", SENSOR_FANRPM, 0, 0xb9, wb_w83792d_refresh_fanrpm },
  360         { "", SENSOR_FANRPM, 0, 0xba, wb_w83792d_refresh_fanrpm },
  361         { "", SENSOR_FANRPM, 0, 0xbe, wb_w83792d_refresh_fanrpm },
  363         { NULL }
  364 };
  366 struct lm_sensor as99127f_sensors[] = {
  367         /* Voltage */
  368         { "VCore A", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
  369         { "VCore B", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
  370         { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
  371         { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
  372         { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
  373         { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
  374         { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
  376         /* Temperature */
  377         { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
  378         { "", SENSOR_TEMP, 1, 0x50, as_refresh_temp },
  379         { "", SENSOR_TEMP, 2, 0x50, as_refresh_temp },
  381         /* Fans */
  382         { "", SENSOR_FANRPM, 0, 0x28, lm_refresh_fanrpm },
  383         { "", SENSOR_FANRPM, 0, 0x29, lm_refresh_fanrpm },
  384         { "", SENSOR_FANRPM, 0, 0x2a, lm_refresh_fanrpm },
  386         { NULL }
  387 };
  389 void
lm_attach(struct lm_softc *sc)
  391 {
u_int i, config;
  394         for (i = 0; i < sizeof(lm_chips) / sizeof(lm_chips[0]); i++)
  395                 if (lm_chips[i].chip_match(sc))
  396                         break;
  398         /* No point in doing anything if we don't have any sensors. */
  399         if (sc->numsensors == 0)
  400                 return;
sc->sensortask = sensor_task_register(sc, lm_refresh, 5);
  403         if (sc->sensortask == NULL) {
printf("%s: unable to register update task\n",
sc->sc_dev.dv_xname);
  406                 return;
  407         }
  409         /* Start the monitoring loop */
config = sc->lm_readreg(sc, LM_CONFIG);
sc->lm_writereg(sc, LM_CONFIG, config | 0x01);
  413         /* Add sensors */
  414         for (i = 0; i < sc->numsensors; ++i)
sensor_attach(&sc->sensordev, &sc->sensors[i]);
sensordev_install(&sc->sensordev);
  417 }
  419 int
lm_detach(struct lm_softc *sc)
  421 {
  422         int i;
  424         /* Remove sensors */
sensordev_deinstall(&sc->sensordev);
  426         for (i = 0; i < sc->numsensors; i++)
sensor_detach(&sc->sensordev, &sc->sensors[i]);
  429         if (sc->sensortask != NULL)
sensor_task_unregister(sc->sensortask);
  432         return 0;
  433 }
  435 int
lm_match(struct lm_softc *sc)
  437 {
  438         int chipid;
  440         /* See if we have an LM78 or LM79. */
chipid = sc->lm_readreg(sc, LM_CHIPID) & LM_CHIPID_MASK;
  442         switch(chipid) {
  443         case LM_CHIPID_LM78:
printf(": LM78\n");
  445                 break;
  446         case LM_CHIPID_LM78J:
printf(": LM78J\n");
  448                 break;
  449         case LM_CHIPID_LM79:
printf(": LM79\n");
  451                 break;
  452         case LM_CHIPID_LM81:
printf(": LM81\n");
  454                 break;
  455         default:
  456                 return 0;
  457         }
lm_setup_sensors(sc, lm78_sensors);
sc->refresh_sensor_data = lm_refresh_sensor_data;
  461         return 1;
  462 }
  464 int
def_match(struct lm_softc *sc)
  466 {
  467         int chipid;
chipid = sc->lm_readreg(sc, LM_CHIPID) & LM_CHIPID_MASK;
printf(": unknown chip (ID %d)\n", chipid);
lm_setup_sensors(sc, lm78_sensors);
sc->refresh_sensor_data = lm_refresh_sensor_data;
  474         return 1;
  475 }
  477 int
wb_match(struct lm_softc *sc)
  479 {
  480         int banksel, vendid, devid;
  482         /* Read vendor ID */
banksel = sc->lm_readreg(sc, WB_BANKSEL);
sc->lm_writereg(sc, WB_BANKSEL, WB_BANKSEL_HBAC);
vendid = sc->lm_readreg(sc, WB_VENDID) << 8;
sc->lm_writereg(sc, WB_BANKSEL, 0);
vendid |= sc->lm_readreg(sc, WB_VENDID);
sc->lm_writereg(sc, WB_BANKSEL, banksel);
DPRINTF((" winbond vend id 0x%x\n", vendid));
  490         if (vendid != WB_VENDID_WINBOND && vendid != WB_VENDID_ASUS)
  491                 return 0;
  493         /* Read device/chip ID */
sc->lm_writereg(sc, WB_BANKSEL, WB_BANKSEL_B0);
devid = sc->lm_readreg(sc, LM_CHIPID);
sc->chipid = sc->lm_readreg(sc, WB_BANK0_CHIPID);
sc->lm_writereg(sc, WB_BANKSEL, banksel);
DPRINTF((" winbond chip id 0x%x\n", sc->chipid));
  499         switch(sc->chipid) {
  500         case WB_CHIPID_W83627HF:
printf(": W83627HF\n");
lm_setup_sensors(sc, w83627hf_sensors);
  503                 break;
  504         case WB_CHIPID_W83627THF:
printf(": W83627THF\n");
lm_setup_sensors(sc, w83637hf_sensors);
  507                 break;
  508         case WB_CHIPID_W83627EHF_A:
printf(": W83627EHF-A\n");
lm_setup_sensors(sc, w83627ehf_sensors);
  511                 break;
  512         case WB_CHIPID_W83627EHF:
printf(": W83627EHF\n");
lm_setup_sensors(sc, w83627ehf_sensors);
  515                 break;
  516         case WB_CHIPID_W83627DHG:
printf(": W83627DHG\n");
lm_setup_sensors(sc, w83627dhg_sensors);
  519                 break;
  520         case WB_CHIPID_W83637HF:
printf(": W83637HF\n");
sc->lm_writereg(sc, WB_BANKSEL, WB_BANKSEL_B0);
  523                 if (sc->lm_readreg(sc, WB_BANK0_CONFIG) & WB_CONFIG_VMR9)
sc->vrm9 = 1;
sc->lm_writereg(sc, WB_BANKSEL, banksel);
lm_setup_sensors(sc, w83637hf_sensors);
  527                 break;
  528         case WB_CHIPID_W83697HF:
printf(": W83697HF\n");
lm_setup_sensors(sc, w83697hf_sensors);
  531                 break;
  532         case WB_CHIPID_W83781D:
  533         case WB_CHIPID_W83781D_2:
printf(": W83781D\n");
lm_setup_sensors(sc, w83781d_sensors);
  536                 break;
  537         case WB_CHIPID_W83782D:
printf(": W83782D\n");
lm_setup_sensors(sc, w83782d_sensors);
  540                 break;
  541         case WB_CHIPID_W83783S:
printf(": W83783S\n");
lm_setup_sensors(sc, w83783s_sensors);
  544                 break;
  545         case WB_CHIPID_W83791D:
printf(": W83791D\n");
lm_setup_sensors(sc, w83791d_sensors);
  548                 break;
  549         case WB_CHIPID_W83791SD:
printf(": W83791SD\n");
  551                 break;
  552         case WB_CHIPID_W83792D:
  553                 if (devid >= 0x10 && devid <= 0x29)
printf(": W83792D rev %c\n", 'A' + devid - 0x10);
  555                 else
printf(": W83792D rev 0x%x\n", devid);
lm_setup_sensors(sc, w83792d_sensors);
  558                 break;
  559         case WB_CHIPID_AS99127F:
  560                 if (vendid == WB_VENDID_ASUS) {
printf(": AS99127F\n");
lm_setup_sensors(sc, w83781d_sensors);
  563                 } else {
printf(": AS99127F rev 2\n");
lm_setup_sensors(sc, as99127f_sensors);
  566                 }
  567                 break;
  568         default:
printf(": unknown Winbond chip (ID 0x%x)\n", sc->chipid);
  570                 /* Handle as a standard LM78. */
lm_setup_sensors(sc, lm78_sensors);
sc->refresh_sensor_data = lm_refresh_sensor_data;
  573                 return 1;
  574         }
sc->refresh_sensor_data = wb_refresh_sensor_data;
  577         return 1;
  578 }
  580 void
lm_setup_sensors(struct lm_softc *sc, struct lm_sensor *sensors)
  582 {
  583         int i;
strlcpy(sc->sensordev.xname, sc->sc_dev.dv_xname,
  586             sizeof(sc->sensordev.xname));
  588         for (i = 0; sensors[i].desc; i++) {
sc->sensors[i].type = sensors[i].type;
strlcpy(sc->sensors[i].desc, sensors[i].desc,
  591                     sizeof(sc->sensors[i].desc));
sc->numsensors++;
  593         }
sc->lm_sensors = sensors;
  595 }
  597 void
lm_refresh(void *arg)
  599 {
  600         struct lm_softc *sc = arg;
sc->refresh_sensor_data(sc);
  603 }
  605 void
lm_refresh_sensor_data(struct lm_softc *sc)
  607 {
  608         int i;
  610         for (i = 0; i < sc->numsensors; i++)
sc->lm_sensors[i].refresh(sc, i);
  612 }
  614 void
lm_refresh_volt(struct lm_softc *sc, int n)
  616 {
  617         struct ksensor *sensor = &sc->sensors[n];
  618         int data;
data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
sensor->value = (data << 4);
sensor->value *= sc->lm_sensors[n].rfact;
sensor->value /= 10;
  624 }
  626 void
lm_refresh_temp(struct lm_softc *sc, int n)
  628 {
  629         struct ksensor *sensor = &sc->sensors[n];
  630         int sdata;
  632         /*
  633          * The data sheet suggests that the range of the temperature
  634          * sensor is between -55 degC and +125 degC.
  635          */
sdata = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
  637         if (sdata > 0x7d && sdata < 0xc9) {
sensor->flags |= SENSOR_FINVALID;
sensor->value = 0;
  640         } else {
  641                 if (sdata & 0x80)
sdata -= 0x100;
sensor->flags &= ~SENSOR_FINVALID;
sensor->value = sdata * 1000000 + 273150000;
  645         }
  646 }
  648 void
lm_refresh_fanrpm(struct lm_softc *sc, int n)
  650 {
  651         struct ksensor *sensor = &sc->sensors[n];
  652         int data, divisor = 1;
  654         /*
  655          * We might get more accurate fan readings by adjusting the
  656          * divisor, but that might interfere with APM or other SMM
  657          * BIOS code reading the fan speeds.
  658          */
  660         /* FAN3 has a fixed fan divisor. */
  661         if (sc->lm_sensors[n].reg == LM_FAN1 ||
sc->lm_sensors[n].reg == LM_FAN2) {
data = sc->lm_readreg(sc, LM_VIDFAN);
  664                 if (sc->lm_sensors[n].reg == LM_FAN1)
divisor = (data >> 4) & 0x03;
  666                 else
divisor = (data >> 6) & 0x03;
  668         }
data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
  671         if (data == 0xff || data == 0x00) {
sensor->flags |= SENSOR_FINVALID;
sensor->value = 0;
  674         } else {
sensor->flags &= ~SENSOR_FINVALID;
sensor->value = 1350000 / (data << divisor);
  677         }
  678 }
  680 void
wb_refresh_sensor_data(struct lm_softc *sc)
  682 {
  683         int banksel, bank, i;
  685         /*
  686          * Properly save and restore bank selection register.
  687          */
banksel = bank = sc->lm_readreg(sc, WB_BANKSEL);
  690         for (i = 0; i < sc->numsensors; i++) {
  691                 if (bank != sc->lm_sensors[i].bank) {
bank = sc->lm_sensors[i].bank;
sc->lm_writereg(sc, WB_BANKSEL, bank);
  694                 }
sc->lm_sensors[i].refresh(sc, i);
  696         }
sc->lm_writereg(sc, WB_BANKSEL, banksel);
  698 }
  700 void
wb_w83637hf_refresh_vcore(struct lm_softc *sc, int n)
  702 {
  703         struct ksensor *sensor = &sc->sensors[n];
  704         int data;
data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
  708         /*
  709          * Depending on the voltage detection method,
  710          * one of the following formulas is used:
  711          *      VRM8 method: value = raw * 0.016V
  712          *      VRM9 method: value = raw * 0.00488V + 0.70V
  713          */
  714         if (sc->vrm9)
sensor->value = (data * 4880) + 700000;
  716         else
sensor->value = (data * 16000);
  718 }
  720 void
wb_refresh_nvolt(struct lm_softc *sc, int n)
  722 {
  723         struct ksensor *sensor = &sc->sensors[n];
  724         int data;
data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
sensor->value = ((data << 4) - WB_VREF);
sensor->value *= sc->lm_sensors[n].rfact;
sensor->value /= 10;
sensor->value += WB_VREF * 1000;
  731 }
  733 void
wb_w83627ehf_refresh_nvolt(struct lm_softc *sc, int n)
  735 {
  736         struct ksensor *sensor = &sc->sensors[n];
  737         int data;
data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
sensor->value = ((data << 3) - WB_W83627EHF_VREF);
sensor->value *= RFACT(232, 10);
sensor->value /= 10;
sensor->value += WB_W83627EHF_VREF * 1000;
  744 }
  746 void
wb_refresh_temp(struct lm_softc *sc, int n)
  748 {
  749         struct ksensor *sensor = &sc->sensors[n];
  750         int sdata;
  752         /*
  753          * The data sheet suggests that the range of the temperature
  754          * sensor is between -55 degC and +125 degC.  However, values
  755          * around -48 degC seem to be a very common bogus values.
  756          * Since such values are unreasonably low, we use -45 degC for
  757          * the lower limit instead.
  758          */
sdata = sc->lm_readreg(sc, sc->lm_sensors[n].reg) << 1;
sdata += sc->lm_readreg(sc, sc->lm_sensors[n].reg + 1) >> 7;
  761         if (sdata > 0x0fa && sdata < 0x1a6) {
sensor->flags |= SENSOR_FINVALID;
sensor->value = 0;
  764         } else {
  765                 if (sdata & 0x100)
sdata -= 0x200;
sensor->flags &= ~SENSOR_FINVALID;
sensor->value = sdata * 500000 + 273150000;
  769         }
  770 }
  772 void
wb_refresh_fanrpm(struct lm_softc *sc, int n)
  774 {
  775         struct ksensor *sensor = &sc->sensors[n];
  776         int fan, data, divisor = 0;
  778         /* 
  779          * This is madness; the fan divisor bits are scattered all
  780          * over the place.
  781          */
  783         if (sc->lm_sensors[n].reg == LM_FAN1 ||
sc->lm_sensors[n].reg == LM_FAN2 ||
sc->lm_sensors[n].reg == LM_FAN3) {
data = sc->lm_readreg(sc, WB_BANK0_VBAT);
fan = (sc->lm_sensors[n].reg - LM_FAN1);
  788                 if ((data >> 5) & (1 << fan))
divisor |= 0x04;
  790         }
  792         if (sc->lm_sensors[n].reg == LM_FAN1 ||
sc->lm_sensors[n].reg == LM_FAN2) {
data = sc->lm_readreg(sc, LM_VIDFAN);
  795                 if (sc->lm_sensors[n].reg == LM_FAN1)
divisor |= (data >> 4) & 0x03;
  797                 else
divisor |= (data >> 6) & 0x03;
  799         } else if (sc->lm_sensors[n].reg == LM_FAN3) {
data = sc->lm_readreg(sc, WB_PIN);
divisor |= (data >> 6) & 0x03;
  802         } else if (sc->lm_sensors[n].reg == WB_BANK0_FAN4 ||
sc->lm_sensors[n].reg == WB_BANK0_FAN5) {
data = sc->lm_readreg(sc, WB_BANK0_FAN45);
  805                 if (sc->lm_sensors[n].reg == WB_BANK0_FAN4)
divisor |= (data >> 0) & 0x07;
  807                 else
divisor |= (data >> 4) & 0x07;
  809         }
data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
  812         if (data == 0xff || data == 0x00) {
sensor->flags |= SENSOR_FINVALID;
sensor->value = 0;
  815         } else {
sensor->flags &= ~SENSOR_FINVALID;
sensor->value = 1350000 / (data << divisor);
  818         }
  819 }
  821 void
wb_w83792d_refresh_fanrpm(struct lm_softc *sc, int n)
  823 {
  824         struct ksensor *sensor = &sc->sensors[n];
  825         int reg, shift, data, divisor = 1;
  827         switch (sc->lm_sensors[n].reg) {
  828         case 0x28:
reg = 0x47; shift = 0;
  830                 break;
  831         case 0x29:
reg = 0x47; shift = 4;
  833                 break;
  834         case 0x2a:
reg = 0x5b; shift = 0;
  836                 break;
  837         case 0xb8:
reg = 0x5b; shift = 4;
  839                 break;
  840         case 0xb9:
reg = 0x5c; shift = 0;
  842                 break;
  843         case 0xba:
reg = 0x5c; shift = 4;
  845                 break;
  846         case 0xbe:
reg = 0x9e; shift = 0;
  848                 break;
  849         default:
reg = 0;
  851                 break;
  852         }
data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
  855         if (data == 0xff || data == 0x00) {
sensor->flags |= SENSOR_FINVALID;
sensor->value = 0;
  858         } else {
  859                 if (reg != 0)
divisor = (sc->lm_readreg(sc, reg) >> shift) & 0x7;
sensor->flags &= ~SENSOR_FINVALID;
sensor->value = 1350000 / (data << divisor);
  863         }
  864 }
  866 void
as_refresh_temp(struct lm_softc *sc, int n)
  868 {
  869         struct ksensor *sensor = &sc->sensors[n];
  870         int sdata;
  872         /*
  873          * It seems a shorted temperature diode produces an all-ones
  874          * bit pattern.
  875          */
sdata = sc->lm_readreg(sc, sc->lm_sensors[n].reg) << 1;
sdata += sc->lm_readreg(sc, sc->lm_sensors[n].reg + 1) >> 7;
  878         if (sdata == 0x1ff) {
sensor->flags |= SENSOR_FINVALID;
sensor->value = 0;
  881         } else {
  882                 if (sdata & 0x100)
sdata -= 0x200;
sensor->flags &= ~SENSOR_FINVALID;
sensor->value = sdata * 500000 + 273150000;
  886         }
  887 }