1 /* $OpenBSD: lm78.c,v 1.20 2007/06/25 22:50:18 cnst Exp $ */
4 * Copyright (c) 2005, 2006 Mark Kettenis
5 * Copyright (c) 2006, 2007 Constantine A. Murenin
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 #include <sys/param.h>
21 #include <sys/systm.h>
23 #include <sys/sensors.h>
28 #define DPRINTF(x) do { kprintf x; } while (0)
34 * LM78-compatible chips can typically measure voltages up to 4.096 V.
35 * To measure higher voltages the input is attenuated with (external)
36 * resistors. Negative voltages are measured using inverting op amps
37 * and resistors. So we have to convert the sensor values back to
38 * real voltages by applying the appropriate resistor factor.
40 #define RFACT_NONE 10000
41 #define RFACT(x, y) (RFACT_NONE * ((x) + (y)) / (y))
42 #define NRFACT(x, y) (-RFACT_NONE * (x) / (y))
44 int lm_match(struct lm_softc *);
45 int wb_match(struct lm_softc *);
46 int def_match(struct lm_softc *);
48 void lm_setup_sensors(struct lm_softc *, struct lm_sensor *);
49 void lm_refresh(void *);
51 void lm_refresh_sensor_data(struct lm_softc *);
52 void lm_refresh_volt(struct lm_softc *, int);
53 void lm_refresh_temp(struct lm_softc *, int);
54 void lm_refresh_fanrpm(struct lm_softc *, int);
56 void wb_refresh_sensor_data(struct lm_softc *);
57 void wb_w83637hf_refresh_vcore(struct lm_softc *, int);
58 void wb_refresh_nvolt(struct lm_softc *, int);
59 void wb_w83627ehf_refresh_nvolt(struct lm_softc *, int);
60 void wb_refresh_temp(struct lm_softc *, int);
61 void wb_refresh_fanrpm(struct lm_softc *, int);
62 void wb_w83792d_refresh_fanrpm(struct lm_softc *, int);
64 void as_refresh_temp(struct lm_softc *, int);
67 int (*chip_match)(struct lm_softc *);
70 struct lm_chip lm_chips[] = {
73 { def_match } /* Must be last */
76 struct lm_sensor lm78_sensors[] = {
78 { "VCore A", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
79 { "VCore B", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
80 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
81 { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(68, 100) },
82 { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(30, 10) },
83 { "-12V", SENSOR_VOLTS_DC, 0, 0x25, lm_refresh_volt, NRFACT(240, 60) },
84 { "-5V", SENSOR_VOLTS_DC, 0, 0x26, lm_refresh_volt, NRFACT(100, 60) },
87 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
90 { "", SENSOR_FANRPM, 0, 0x28, lm_refresh_fanrpm },
91 { "", SENSOR_FANRPM, 0, 0x29, lm_refresh_fanrpm },
92 { "", SENSOR_FANRPM, 0, 0x2a, lm_refresh_fanrpm },
97 struct lm_sensor w83627hf_sensors[] = {
99 { "VCore A", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
100 { "VCore B", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
101 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
102 { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
103 { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
104 { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
105 { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
106 { "5VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(17, 33) },
107 { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE },
110 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
111 { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
112 { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
115 { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
116 { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
117 { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
123 * The W83627EHF can measure voltages up to 2.048 V instead of the
124 * traditional 4.096 V. For measuring positive voltages, this can be
125 * accounted for by halving the resistor factor. Negative voltages
126 * need special treatment, also because the reference voltage is 2.048 V
127 * instead of the traditional 3.6 V.
129 struct lm_sensor w83627ehf_sensors[] = {
131 { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE / 2},
132 { "+12V", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT(56, 10) / 2 },
133 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT(34, 34) / 2 },
134 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 34) / 2 },
135 { "-12V", SENSOR_VOLTS_DC, 0, 0x24, wb_w83627ehf_refresh_nvolt },
136 { "", SENSOR_VOLTS_DC, 0, 0x25, lm_refresh_volt, RFACT_NONE / 2 },
137 { "", SENSOR_VOLTS_DC, 0, 0x26, lm_refresh_volt, RFACT_NONE / 2 },
138 { "3.3VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(34, 34) / 2 },
139 { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE / 2 },
140 { "", SENSOR_VOLTS_DC, 5, 0x52, lm_refresh_volt, RFACT_NONE / 2 },
143 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
144 { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
145 { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
148 { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
149 { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
150 { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
156 * w83627dhg is almost identical to w83627ehf, except that
157 * it has 9 instead of 10 voltage sensors
159 struct lm_sensor w83627dhg_sensors[] = {
161 { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE / 2},
162 { "+12V", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT(56, 10) / 2 },
163 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT(34, 34) / 2 },
164 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 34) / 2 },
165 { "-12V", SENSOR_VOLTS_DC, 0, 0x24, wb_w83627ehf_refresh_nvolt },
166 { "", SENSOR_VOLTS_DC, 0, 0x25, lm_refresh_volt, RFACT_NONE / 2 },
167 { "", SENSOR_VOLTS_DC, 0, 0x26, lm_refresh_volt, RFACT_NONE / 2 },
168 { "3.3VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(34, 34) / 2 },
169 { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE / 2 },
172 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
173 { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
174 { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
177 { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
178 { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
179 { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
184 struct lm_sensor w83637hf_sensors[] = {
186 { "VCore", SENSOR_VOLTS_DC, 0, 0x20, wb_w83637hf_refresh_vcore },
187 { "+12V", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT(28, 10) },
188 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
189 { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 51) },
190 { "-12V", SENSOR_VOLTS_DC, 0, 0x24, wb_refresh_nvolt, RFACT(232, 56) },
191 { "5VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(34, 51) },
192 { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE },
195 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
196 { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
197 { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
200 { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
201 { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
202 { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
207 struct lm_sensor w83697hf_sensors[] = {
209 { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
210 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
211 { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
212 { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
213 { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
214 { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
215 { "5VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(17, 33) },
216 { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE },
219 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
220 { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
223 { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
224 { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
230 * The datasheet doesn't mention the (internal) resistors used for the
231 * +5V, but using the values from the W83782D datasheets seems to
232 * provide sensible results.
234 struct lm_sensor w83781d_sensors[] = {
236 { "VCore A", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
237 { "VCore B", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
238 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
239 { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
240 { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
241 { "-12V", SENSOR_VOLTS_DC, 0, 0x25, lm_refresh_volt, NRFACT(2100, 604) },
242 { "-5V", SENSOR_VOLTS_DC, 0, 0x26, lm_refresh_volt, NRFACT(909, 604) },
245 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
246 { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
247 { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
250 { "", SENSOR_FANRPM, 0, 0x28, lm_refresh_fanrpm },
251 { "", SENSOR_FANRPM, 0, 0x29, lm_refresh_fanrpm },
252 { "", SENSOR_FANRPM, 0, 0x2a, lm_refresh_fanrpm },
257 struct lm_sensor w83782d_sensors[] = {
259 { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
260 { "VINR0", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
261 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
262 { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
263 { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
264 { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
265 { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
266 { "5VSB", SENSOR_VOLTS_DC, 5, 0x50, lm_refresh_volt, RFACT(17, 33) },
267 { "VBAT", SENSOR_VOLTS_DC, 5, 0x51, lm_refresh_volt, RFACT_NONE },
270 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
271 { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
272 { "", SENSOR_TEMP, 2, 0x50, wb_refresh_temp },
275 { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
276 { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
277 { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
282 struct lm_sensor w83783s_sensors[] = {
284 { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
285 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
286 { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
287 { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
288 { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
289 { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
292 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
293 { "", SENSOR_TEMP, 1, 0x50, wb_refresh_temp },
296 { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
297 { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
298 { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
303 struct lm_sensor w83791d_sensors[] = {
305 { "VCore", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
306 { "VINR0", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
307 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
308 { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
309 { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
310 { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
311 { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
312 { "5VSB", SENSOR_VOLTS_DC, 0, 0xb0, lm_refresh_volt, RFACT(17, 33) },
313 { "VBAT", SENSOR_VOLTS_DC, 0, 0xb1, lm_refresh_volt, RFACT_NONE },
314 { "VINR1", SENSOR_VOLTS_DC, 0, 0xb2, lm_refresh_volt, RFACT_NONE },
317 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
318 { "", SENSOR_TEMP, 0, 0xc0, wb_refresh_temp },
319 { "", SENSOR_TEMP, 0, 0xc8, wb_refresh_temp },
322 { "", SENSOR_FANRPM, 0, 0x28, wb_refresh_fanrpm },
323 { "", SENSOR_FANRPM, 0, 0x29, wb_refresh_fanrpm },
324 { "", SENSOR_FANRPM, 0, 0x2a, wb_refresh_fanrpm },
325 { "", SENSOR_FANRPM, 0, 0xba, wb_refresh_fanrpm },
326 { "", SENSOR_FANRPM, 0, 0xbb, wb_refresh_fanrpm },
331 struct lm_sensor w83792d_sensors[] = {
333 { "VCore A", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
334 { "VCore B", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
335 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
336 { "-5V", SENSOR_VOLTS_DC, 0, 0x23, wb_refresh_nvolt, RFACT(120, 56) },
337 { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
338 { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
339 { "+5V", SENSOR_VOLTS_DC, 0, 0x26, lm_refresh_volt, RFACT(34, 50) },
340 { "5VSB", SENSOR_VOLTS_DC, 0, 0xb0, lm_refresh_volt, RFACT(17, 33) },
341 { "VBAT", SENSOR_VOLTS_DC, 0, 0xb1, lm_refresh_volt, RFACT_NONE },
344 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
345 { "", SENSOR_TEMP, 0, 0xc0, wb_refresh_temp },
346 { "", SENSOR_TEMP, 0, 0xc8, wb_refresh_temp },
349 { "", SENSOR_FANRPM, 0, 0x28, wb_w83792d_refresh_fanrpm },
350 { "", SENSOR_FANRPM, 0, 0x29, wb_w83792d_refresh_fanrpm },
351 { "", SENSOR_FANRPM, 0, 0x2a, wb_w83792d_refresh_fanrpm },
352 { "", SENSOR_FANRPM, 0, 0xb8, wb_w83792d_refresh_fanrpm },
353 { "", SENSOR_FANRPM, 0, 0xb9, wb_w83792d_refresh_fanrpm },
354 { "", SENSOR_FANRPM, 0, 0xba, wb_w83792d_refresh_fanrpm },
355 { "", SENSOR_FANRPM, 0, 0xbe, wb_w83792d_refresh_fanrpm },
360 struct lm_sensor as99127f_sensors[] = {
362 { "VCore A", SENSOR_VOLTS_DC, 0, 0x20, lm_refresh_volt, RFACT_NONE },
363 { "VCore B", SENSOR_VOLTS_DC, 0, 0x21, lm_refresh_volt, RFACT_NONE },
364 { "+3.3V", SENSOR_VOLTS_DC, 0, 0x22, lm_refresh_volt, RFACT_NONE },
365 { "+5V", SENSOR_VOLTS_DC, 0, 0x23, lm_refresh_volt, RFACT(34, 50) },
366 { "+12V", SENSOR_VOLTS_DC, 0, 0x24, lm_refresh_volt, RFACT(28, 10) },
367 { "-12V", SENSOR_VOLTS_DC, 0, 0x25, wb_refresh_nvolt, RFACT(232, 56) },
368 { "-5V", SENSOR_VOLTS_DC, 0, 0x26, wb_refresh_nvolt, RFACT(120, 56) },
371 { "", SENSOR_TEMP, 0, 0x27, lm_refresh_temp },
372 { "", SENSOR_TEMP, 1, 0x50, as_refresh_temp },
373 { "", SENSOR_TEMP, 2, 0x50, as_refresh_temp },
376 { "", SENSOR_FANRPM, 0, 0x28, lm_refresh_fanrpm },
377 { "", SENSOR_FANRPM, 0, 0x29, lm_refresh_fanrpm },
378 { "", SENSOR_FANRPM, 0, 0x2a, lm_refresh_fanrpm },
384 lm_probe(struct lm_softc *sc)
388 for (i = 0; i < sizeof(lm_chips) / sizeof(lm_chips[0]); i++)
389 if (lm_chips[i].chip_match(sc))
394 lm_attach(struct lm_softc *sc)
398 /* No point in doing anything if we don't have any sensors. */
399 if (sc->numsensors == 0)
402 if (sensor_task_register(sc, lm_refresh, 5)) {
403 device_printf(sc->sc_dev, "unable to register update task\n");
407 /* Start the monitoring loop */
408 config = sc->lm_readreg(sc, LM_CONFIG);
409 sc->lm_writereg(sc, LM_CONFIG, config | 0x01);
412 strlcpy(sc->sensordev.xname, device_get_nameunit(sc->sc_dev),
413 sizeof(sc->sensordev.xname));
414 for (i = 0; i < sc->numsensors; ++i)
415 sensor_attach(&sc->sensordev, &sc->sensors[i]);
416 sensordev_install(&sc->sensordev);
420 lm_detach(struct lm_softc *sc)
425 sensordev_deinstall(&sc->sensordev);
426 for (i = 0; i < sc->numsensors; i++)
427 sensor_detach(&sc->sensordev, &sc->sensors[i]);
429 sensor_task_unregister(sc);
435 lm_match(struct lm_softc *sc)
441 /* See if we have an LM78 or LM79. */
442 chipid = sc->lm_readreg(sc, LM_CHIPID) & LM_CHIPID_MASK;
447 case LM_CHIPID_LM78J:
459 ksnprintf(fulldesc, sizeof(fulldesc),
460 "National Semiconductor %s Hardware Monitor", cdesc);
461 device_set_desc_copy(sc->sc_dev, fulldesc);
463 lm_setup_sensors(sc, lm78_sensors);
464 sc->refresh_sensor_data = lm_refresh_sensor_data;
469 def_match(struct lm_softc *sc)
474 chipid = sc->lm_readreg(sc, LM_CHIPID) & LM_CHIPID_MASK;
475 ksnprintf(fulldesc, sizeof(fulldesc),
476 "unknown Hardware Monitor (ID 0x%x)", chipid);
477 device_set_desc_copy(sc->sc_dev, fulldesc);
479 lm_setup_sensors(sc, lm78_sensors);
480 sc->refresh_sensor_data = lm_refresh_sensor_data;
485 wb_match(struct lm_softc *sc)
487 int banksel, vendid, devid;
493 banksel = sc->lm_readreg(sc, WB_BANKSEL);
494 sc->lm_writereg(sc, WB_BANKSEL, WB_BANKSEL_HBAC);
495 vendid = sc->lm_readreg(sc, WB_VENDID) << 8;
496 sc->lm_writereg(sc, WB_BANKSEL, 0);
497 vendid |= sc->lm_readreg(sc, WB_VENDID);
498 sc->lm_writereg(sc, WB_BANKSEL, banksel);
499 DPRINTF((" winbond vend id 0x%x\n", vendid));
500 if (vendid != WB_VENDID_WINBOND && vendid != WB_VENDID_ASUS)
503 /* Read device/chip ID */
504 sc->lm_writereg(sc, WB_BANKSEL, WB_BANKSEL_B0);
505 devid = sc->lm_readreg(sc, LM_CHIPID);
506 sc->chipid = sc->lm_readreg(sc, WB_BANK0_CHIPID);
507 sc->lm_writereg(sc, WB_BANKSEL, banksel);
508 DPRINTF((" winbond chip id 0x%x\n", sc->chipid));
510 case WB_CHIPID_W83627HF:
512 lm_setup_sensors(sc, w83627hf_sensors);
514 case WB_CHIPID_W83627THF:
516 lm_setup_sensors(sc, w83637hf_sensors);
518 case WB_CHIPID_W83627EHF_A:
519 cdesc = "W83627EHF-A";
520 lm_setup_sensors(sc, w83627ehf_sensors);
522 case WB_CHIPID_W83627EHF:
524 lm_setup_sensors(sc, w83627ehf_sensors);
526 case WB_CHIPID_W83627DHG:
528 lm_setup_sensors(sc, w83627dhg_sensors);
530 case WB_CHIPID_W83637HF:
532 sc->lm_writereg(sc, WB_BANKSEL, WB_BANKSEL_B0);
533 if (sc->lm_readreg(sc, WB_BANK0_CONFIG) & WB_CONFIG_VMR9)
535 sc->lm_writereg(sc, WB_BANKSEL, banksel);
536 lm_setup_sensors(sc, w83637hf_sensors);
538 case WB_CHIPID_W83697HF:
540 lm_setup_sensors(sc, w83697hf_sensors);
542 case WB_CHIPID_W83781D:
543 case WB_CHIPID_W83781D_2:
545 lm_setup_sensors(sc, w83781d_sensors);
547 case WB_CHIPID_W83782D:
549 lm_setup_sensors(sc, w83782d_sensors);
551 case WB_CHIPID_W83783S:
553 lm_setup_sensors(sc, w83783s_sensors);
555 case WB_CHIPID_W83791D:
557 lm_setup_sensors(sc, w83791d_sensors);
559 case WB_CHIPID_W83791SD:
562 case WB_CHIPID_W83792D:
563 if (devid >= 0x10 && devid <= 0x29)
564 ksnprintf(desc, sizeof(desc),
565 "W83792D rev %c", 'A' + devid - 0x10);
567 ksnprintf(desc, sizeof(desc),
568 "W83792D rev 0x%x", devid);
570 lm_setup_sensors(sc, w83792d_sensors);
572 case WB_CHIPID_AS99127F:
573 if (vendid == WB_VENDID_ASUS) {
575 lm_setup_sensors(sc, w83781d_sensors);
577 cdesc = "AS99127F rev 2";
578 lm_setup_sensors(sc, as99127f_sensors);
582 ksnprintf(fulldesc, sizeof(fulldesc),
583 "unknown Winbond Hardware Monitor (Chip ID 0x%x)",
585 device_set_desc_copy(sc->sc_dev, fulldesc);
586 /* Handle as a standard LM78. */
587 lm_setup_sensors(sc, lm78_sensors);
588 sc->refresh_sensor_data = lm_refresh_sensor_data;
593 ksnprintf(fulldesc, sizeof(fulldesc),
594 "Winbond %s Hardware Monitor", cdesc);
596 ksnprintf(fulldesc, sizeof(fulldesc),
597 "ASUS %s Hardware Monitor", cdesc);
598 device_set_desc_copy(sc->sc_dev, fulldesc);
600 sc->refresh_sensor_data = wb_refresh_sensor_data;
605 lm_setup_sensors(struct lm_softc *sc, struct lm_sensor *sensors)
609 for (i = 0; sensors[i].desc; i++) {
610 sc->sensors[i].type = sensors[i].type;
611 strlcpy(sc->sensors[i].desc, sensors[i].desc,
612 sizeof(sc->sensors[i].desc));
615 sc->lm_sensors = sensors;
619 lm_refresh(void *arg)
621 struct lm_softc *sc = arg;
623 sc->refresh_sensor_data(sc);
627 lm_refresh_sensor_data(struct lm_softc *sc)
631 for (i = 0; i < sc->numsensors; i++)
632 sc->lm_sensors[i].refresh(sc, i);
636 lm_refresh_volt(struct lm_softc *sc, int n)
638 struct ksensor *sensor = &sc->sensors[n];
641 data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
642 sensor->value = (data << 4);
643 sensor->value *= sc->lm_sensors[n].rfact;
648 lm_refresh_temp(struct lm_softc *sc, int n)
650 struct ksensor *sensor = &sc->sensors[n];
654 * The data sheet suggests that the range of the temperature
655 * sensor is between -55 degC and +125 degC.
657 sdata = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
658 if (sdata > 0x7d && sdata < 0xc9) {
659 sensor->flags |= SENSOR_FINVALID;
664 sensor->flags &= ~SENSOR_FINVALID;
665 sensor->value = sdata * 1000000 + 273150000;
670 lm_refresh_fanrpm(struct lm_softc *sc, int n)
672 struct ksensor *sensor = &sc->sensors[n];
673 int data, divisor = 1;
676 * We might get more accurate fan readings by adjusting the
677 * divisor, but that might interfere with APM or other SMM
678 * BIOS code reading the fan speeds.
681 /* FAN3 has a fixed fan divisor. */
682 if (sc->lm_sensors[n].reg == LM_FAN1 ||
683 sc->lm_sensors[n].reg == LM_FAN2) {
684 data = sc->lm_readreg(sc, LM_VIDFAN);
685 if (sc->lm_sensors[n].reg == LM_FAN1)
686 divisor = (data >> 4) & 0x03;
688 divisor = (data >> 6) & 0x03;
691 data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
692 if (data == 0xff || data == 0x00) {
693 sensor->flags |= SENSOR_FINVALID;
696 sensor->flags &= ~SENSOR_FINVALID;
697 sensor->value = 1350000 / (data << divisor);
702 wb_refresh_sensor_data(struct lm_softc *sc)
704 int banksel, bank, i;
707 * Properly save and restore bank selection register.
710 banksel = bank = sc->lm_readreg(sc, WB_BANKSEL);
711 for (i = 0; i < sc->numsensors; i++) {
712 if (bank != sc->lm_sensors[i].bank) {
713 bank = sc->lm_sensors[i].bank;
714 sc->lm_writereg(sc, WB_BANKSEL, bank);
716 sc->lm_sensors[i].refresh(sc, i);
718 sc->lm_writereg(sc, WB_BANKSEL, banksel);
722 wb_w83637hf_refresh_vcore(struct lm_softc *sc, int n)
724 struct ksensor *sensor = &sc->sensors[n];
727 data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
730 * Depending on the voltage detection method,
731 * one of the following formulas is used:
732 * VRM8 method: value = raw * 0.016V
733 * VRM9 method: value = raw * 0.00488V + 0.70V
736 sensor->value = (data * 4880) + 700000;
738 sensor->value = (data * 16000);
742 wb_refresh_nvolt(struct lm_softc *sc, int n)
744 struct ksensor *sensor = &sc->sensors[n];
747 data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
748 sensor->value = ((data << 4) - WB_VREF);
749 sensor->value *= sc->lm_sensors[n].rfact;
751 sensor->value += WB_VREF * 1000;
755 wb_w83627ehf_refresh_nvolt(struct lm_softc *sc, int n)
757 struct ksensor *sensor = &sc->sensors[n];
760 data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
761 sensor->value = ((data << 3) - WB_W83627EHF_VREF);
762 sensor->value *= RFACT(232, 10);
764 sensor->value += WB_W83627EHF_VREF * 1000;
768 wb_refresh_temp(struct lm_softc *sc, int n)
770 struct ksensor *sensor = &sc->sensors[n];
774 * The data sheet suggests that the range of the temperature
775 * sensor is between -55 degC and +125 degC. However, values
776 * around -48 degC seem to be a very common bogus values.
777 * Since such values are unreasonably low, we use -45 degC for
778 * the lower limit instead.
780 sdata = sc->lm_readreg(sc, sc->lm_sensors[n].reg) << 1;
781 sdata += sc->lm_readreg(sc, sc->lm_sensors[n].reg + 1) >> 7;
782 if (sdata > 0x0fa && sdata < 0x1a6) {
783 sensor->flags |= SENSOR_FINVALID;
788 sensor->flags &= ~SENSOR_FINVALID;
789 sensor->value = sdata * 500000 + 273150000;
794 wb_refresh_fanrpm(struct lm_softc *sc, int n)
796 struct ksensor *sensor = &sc->sensors[n];
797 int fan, data, divisor = 0;
800 * This is madness; the fan divisor bits are scattered all
804 if (sc->lm_sensors[n].reg == LM_FAN1 ||
805 sc->lm_sensors[n].reg == LM_FAN2 ||
806 sc->lm_sensors[n].reg == LM_FAN3) {
807 data = sc->lm_readreg(sc, WB_BANK0_VBAT);
808 fan = (sc->lm_sensors[n].reg - LM_FAN1);
809 if ((data >> 5) & (1 << fan))
813 if (sc->lm_sensors[n].reg == LM_FAN1 ||
814 sc->lm_sensors[n].reg == LM_FAN2) {
815 data = sc->lm_readreg(sc, LM_VIDFAN);
816 if (sc->lm_sensors[n].reg == LM_FAN1)
817 divisor |= (data >> 4) & 0x03;
819 divisor |= (data >> 6) & 0x03;
820 } else if (sc->lm_sensors[n].reg == LM_FAN3) {
821 data = sc->lm_readreg(sc, WB_PIN);
822 divisor |= (data >> 6) & 0x03;
823 } else if (sc->lm_sensors[n].reg == WB_BANK0_FAN4 ||
824 sc->lm_sensors[n].reg == WB_BANK0_FAN5) {
825 data = sc->lm_readreg(sc, WB_BANK0_FAN45);
826 if (sc->lm_sensors[n].reg == WB_BANK0_FAN4)
827 divisor |= (data >> 0) & 0x07;
829 divisor |= (data >> 4) & 0x07;
832 data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
833 if (data == 0xff || data == 0x00) {
834 sensor->flags |= SENSOR_FINVALID;
837 sensor->flags &= ~SENSOR_FINVALID;
838 sensor->value = 1350000 / (data << divisor);
843 wb_w83792d_refresh_fanrpm(struct lm_softc *sc, int n)
845 struct ksensor *sensor = &sc->sensors[n];
846 int reg, shift, data, divisor = 1;
848 switch (sc->lm_sensors[n].reg) {
850 reg = 0x47; shift = 0;
853 reg = 0x47; shift = 4;
856 reg = 0x5b; shift = 0;
859 reg = 0x5b; shift = 4;
862 reg = 0x5c; shift = 0;
865 reg = 0x5c; shift = 4;
868 reg = 0x9e; shift = 0;
875 data = sc->lm_readreg(sc, sc->lm_sensors[n].reg);
876 if (data == 0xff || data == 0x00) {
877 sensor->flags |= SENSOR_FINVALID;
881 divisor = (sc->lm_readreg(sc, reg) >> shift) & 0x7;
882 sensor->flags &= ~SENSOR_FINVALID;
883 sensor->value = 1350000 / (data << divisor);
888 as_refresh_temp(struct lm_softc *sc, int n)
890 struct ksensor *sensor = &sc->sensors[n];
894 * It seems a shorted temperature diode produces an all-ones
897 sdata = sc->lm_readreg(sc, sc->lm_sensors[n].reg) << 1;
898 sdata += sc->lm_readreg(sc, sc->lm_sensors[n].reg + 1) >> 7;
899 if (sdata == 0x1ff) {
900 sensor->flags |= SENSOR_FINVALID;
905 sensor->flags &= ~SENSOR_FINVALID;
906 sensor->value = sdata * 500000 + 273150000;