1 /* $NetBSD: adm1021.c,v 1.30 2022/01/24 09:42:14 andvar Exp $ */
2 /* $OpenBSD: adm1021.c,v 1.27 2007/06/24 05:34:35 dlg Exp $ */
3
4 /*
5 * Copyright (c) 2005 Theo de Raadt
6 *
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.
10 *
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.
18 */
19
20 /*
21 * Driver for ADM1021 and compatible temperature sensors, including ADM1021,
22 * ADM1021A, ADM1023, ADM1032, GL523SM, G781, LM84, MAX1617, MAX1617A,
23 * NE1617A, MAX6642 and Xeon embedded temperature sensors.
24 *
25 * Some sensors differ from the ADM1021/MAX1617/NE1617A:
26 * ADM1021A ADM1023 ADM1032 G781 LM84 MAX1617A MAX6642
27 * company/revision reg X X X X X X
28 * no negative temps X X X X
29 * 11-bit remote temp X X X X
30 * no low limits X X
31 * therm (high) limits X X X
32 *
33 * Registers 0x00 to 0x0f have separate read/write addresses, but
34 * registers 0x10 and above have the same read/write address.
35 * The 11-bit (extended) temperature consists of a separate register with
36 * 3 valid bits that are always added to the external temperature (even if
37 * the temperature is negative).
38 */
39
40 #include <sys/cdefs.h>
41 __KERNEL_RCSID(0, "$NetBSD: adm1021.c,v 1.30 2022/01/24 09:42:14 andvar Exp $");
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/device.h>
46 #include <dev/sysmon/sysmonvar.h>
47
48 #include <dev/i2c/i2cvar.h>
49
50 /* Registers */
51 #define ADM1021_INT_TEMP 0x00 /* Internal temperature value */
52 #define ADM1021_EXT_TEMP 0x01 /* External temperature value */
53 #define ADM1021_STATUS 0x02 /* Status */
54 #define ADM1021_CONFIG_READ 0x03 /* Read configuration */
55 #define ADM1021_CONV_RATE_READ 0x04 /* Read conversion rate */
56 #define ADM1021_INT_HIGH_READ 0x05 /* Read internal high limit */
57 #define ADM1021_INT_LOW_READ 0x06 /* Read internal low limit */
58 #define ADM1021_EXT_HIGH_READ 0x07 /* Read external high limit */
59 #define ADM1021_EXT_LOW_READ 0x08 /* Read external low limit */
60 #define ADM1021_CONFIG_WRITE 0x09 /* Write configuration */
61 #define ADM1021_CONV_RATE_WRITE 0x0a /* Write conversion rate */
62 #define ADM1021_INT_HIGH_WRITE 0x0b /* Write internal high limit */
63 #define ADM1021_INT_LOW_WRITE 0x0c /* Write internal low limit */
64 #define ADM1021_EXT_HIGH_WRITE 0x0d /* Write external high limit */
65 #define ADM1021_EXT_LOW_WRITE 0x0e /* Write external low limit */
66 #define ADM1021_ONE_SHOT 0x0f /* One shot command */
67 #define ADM1023_EXT_TEMP2 0x10 /* R/W external temp low byte */
68 #define ADM1023_EXT_TEMP_OFF 0x11 /* R/W external temp offset */
69 #define ADM1023_EXT_TEMP_OFF2 0x12 /* R/W external temp off low byte */
70 #define ADM1023_EXT_HIGH2 0x13 /* R/W external high lim low byte */
71 #define ADM1023_EXT_LOW2 0x14 /* R/W external low lim low byte */
72 #define ADM1032_EXT_THERM 0x19 /* R/W external Therm (high) limit */
73 #define ADM1032_INT_THERM 0x20 /* R/W internal Therm (high) limit */
74 #define ADM1032_THERM_HYST 0x21 /* R/W Therm hysteris */
75 #define ADM1032_ALERT_QUEUE 0x22 /* R/W consecutive alert queue */
76 #define ADM1021_COMPANY 0xfe /* Company ID */
77 #define ADM1021_DIE_REVISION 0xff /* Die revision code */
78
79 /* Register values */
80 #define ADM1021_CONFIG_RUN 0x40
81
82 #define ADM1021_STATUS_INVAL 0x7f
83 #define ADM1021_STATUS_NOEXT 0x40 /* External diode is open-circuit */
84
85 #define ADM1023_EXT2_SHIFT 5
86 #define ADM1023_EXT2_MASK 0x07
87
88 #define ADM1021_COMPANY_ADM 0x41 /* 'A' */
89 #define ADM1021_COMPANY_GMT 0x47 /* 'G' */
90 #define ADM1021_COMPANY_MAXIM 0x4d /* 'M' */
91
92 #define ADM1021_REV_1021 0x00
93 #define ADM1021_REV_1021A 0x30
94 #define ADM1021_REV_MASK 0xf0
95
96 /* Sensors */
97 #define ADMTEMP_INT 0
98 #define ADMTEMP_EXT 1
99 #define ADMTEMP_NUM_SENSORS 2
100
101 #define ADMTEMP_MAX_NEG -65
102 #define ADMTEMP_MAX_POS 127
103 #define ADMTEMP_LOW_DEFAULT 0xc9 /* (-55) */
104
105 /* Limit registers might read 0xff, so we ignore them if they do */
106 #define ADMTEMP_LIM_INVAL -1 /* 0xff */
107
108 #define ADMTEMP_NAMELEN 9 /* Maximum name length + 1 */
109
110 struct admtemp_softc {
111 i2c_tag_t sc_tag;
112 i2c_addr_t sc_addr;
113 prop_dictionary_t sc_prop;
114
115 int sc_flags;
116 int sc_noexternal, sc_noneg, sc_nolow;
117 int sc_ext11, sc_therm;
118 struct sysmon_envsys *sc_sme;
119 envsys_data_t sc_sensor[ADMTEMP_NUM_SENSORS];
120 int sc_setdef[ADMTEMP_NUM_SENSORS];
121 uint8_t sc_highlim[ADMTEMP_NUM_SENSORS];
122 uint8_t sc_lowlim[ADMTEMP_NUM_SENSORS];
123 uint8_t sc_highlim2, sc_lowlim2;
124 uint8_t sc_thermlim[ADMTEMP_NUM_SENSORS];
125 };
126
127 int admtemp_match(device_t, cfdata_t, void *);
128 void admtemp_attach(device_t, device_t, void *);
129 void admtemp_refresh(struct sysmon_envsys *, envsys_data_t *);
130 void admtemp_getlim_1021(struct sysmon_envsys *, envsys_data_t *,
131 sysmon_envsys_lim_t *, uint32_t *);
132 void admtemp_getlim_1023(struct sysmon_envsys *, envsys_data_t *,
133 sysmon_envsys_lim_t *, uint32_t *);
134 void admtemp_getlim_1032(struct sysmon_envsys *, envsys_data_t *,
135 sysmon_envsys_lim_t *, uint32_t *);
136 void admtemp_setlim_1021(struct sysmon_envsys *, envsys_data_t *,
137 sysmon_envsys_lim_t *, uint32_t *);
138 void admtemp_setlim_1023(struct sysmon_envsys *, envsys_data_t *,
139 sysmon_envsys_lim_t *, uint32_t *);
140 void admtemp_setlim_1032(struct sysmon_envsys *, envsys_data_t *,
141 sysmon_envsys_lim_t *, uint32_t *);
142
143 CFATTACH_DECL_NEW(admtemp, sizeof(struct admtemp_softc),
144 admtemp_match, admtemp_attach, NULL, NULL);
145
146 struct admtemp_params {
147 const char *name;
148 int noneg;
149 int nolow;
150 int ext11;
151 int therm;
152 };
153
154 static const struct admtemp_params admtemp_params_max1617 = {
155 .name = "MAX1617A",
156 .noneg = 0,
157 .nolow = 0,
158 .ext11 = 0,
159 .therm = 0,
160 };
161
162 static const struct admtemp_params admtemp_params_max6642 = {
163 .name = "MAX6642",
164 .noneg = 0,
165 .nolow = 1,
166 .ext11 = 0,
167 .therm = 0,
168 };
169
170 static const struct admtemp_params admtemp_params_max6690 = {
171 .name = "MAX6690",
172 .noneg = 0,
173 .nolow = 0,
174 .ext11 = 1,
175 .therm = 0,
176 };
177
178 static const struct device_compatible_entry compat_data[] = {
179 { .compat = "i2c-max1617", .data = &admtemp_params_max1617 },
180 { .compat = "max6642", .data = &admtemp_params_max6642 },
181 { .compat = "max6690", .data = &admtemp_params_max6690 },
182 DEVICE_COMPAT_EOL
183 };
184
185 int
admtemp_match(device_t parent,cfdata_t match,void * aux)186 admtemp_match(device_t parent, cfdata_t match, void *aux)
187 {
188 struct i2c_attach_args *ia = aux;
189 int match_result;
190
191 if (iic_use_direct_match(ia, match, compat_data, &match_result))
192 return match_result;
193
194 /*
195 * Indirect config - not much we can do!
196 * Check typical addresses.
197 */
198 if (((ia->ia_addr >= 0x18) && (ia->ia_addr <= 0x1a)) ||
199 ((ia->ia_addr >= 0x29) && (ia->ia_addr <= 0x2b)) ||
200 ((ia->ia_addr >= 0x48) && (ia->ia_addr <= 0x4e)))
201 return I2C_MATCH_ADDRESS_ONLY;
202
203 return 0;
204 }
205
206 static int
admtemp_exec(struct admtemp_softc * sc,i2c_op_t op,uint8_t * cmd,uint8_t * data)207 admtemp_exec(struct admtemp_softc *sc, i2c_op_t op, uint8_t *cmd,
208 uint8_t *data)
209 {
210 return iic_exec(sc->sc_tag, op, sc->sc_addr, cmd, sizeof(*cmd), data,
211 sizeof(*data), 0);
212 }
213
214 /*
215 * Set flags based on chip type for direct config, or by testing for
216 * indirect config.
217 *
218 * LM84, MAX1617, and NE1617A don't have company/revision registers.
219 * If we can't read the company register, we'll check the
220 * internal low limit to see if we have an LM84.
221 *
222 * To check if an ADM chip has 11-bit sensors, we'll write 0.125
223 * to the external temperature limit low byte register and read it
224 * back (because we can't tell from the id/rev).
225 *
226 * To check if an ADM chip has a Therm output, we check that we
227 * read 0x55 (default value) from the external therm limit.
228 *
229 * If an ADM chip doesn't have 11-bit sensors, check the revision to
230 * determine if it handles negative temperatures.
231 */
232 static void
admtemp_setflags(struct admtemp_softc * sc,struct i2c_attach_args * ia,uint8_t * comp,uint8_t * rev,char * name)233 admtemp_setflags(struct admtemp_softc *sc, struct i2c_attach_args *ia,
234 uint8_t* comp, uint8_t *rev, char* name)
235 {
236 uint8_t cmd, data, tmp;
237
238 *comp = 0;
239 *rev = 0;
240
241 cmd = ADM1021_COMPANY;
242 admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, comp);
243
244 cmd = ADM1021_DIE_REVISION;
245 admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, rev);
246
247 sc->sc_noneg = 1;
248 sc->sc_nolow = 0;
249 sc->sc_ext11 = 0;
250 sc->sc_therm = 0;
251
252 /* Direct config */
253 const struct device_compatible_entry *dce =
254 iic_compatible_lookup(ia, compat_data);
255 if (dce != NULL) {
256 const struct admtemp_params *params = dce->data;
257
258 sc->sc_noneg = params->noneg;
259 sc->sc_nolow = params->nolow;
260 sc->sc_ext11 = params->ext11;
261 sc->sc_therm = params->therm;
262 strlcpy(name, params->name, ADMTEMP_NAMELEN);
263 return;
264 }
265
266 /* Indirect config */
267 if (*comp == 0) {
268 sc->sc_noneg = 0;
269 cmd = ADM1021_INT_LOW_READ;
270 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, comp) == 0 &&
271 *comp != ADMTEMP_LOW_DEFAULT) {
272 sc->sc_nolow = 1;
273 strlcpy(name, "LM84", ADMTEMP_NAMELEN);
274 } else
275 strlcpy(name, "MAX1617", ADMTEMP_NAMELEN);
276 }
277
278 if (*comp == ADM1021_COMPANY_MAXIM) {
279 sc->sc_noneg = 0;
280 /*
281 * MAX6642 doesn't have a revision register
282 * XXX this works only on macppc with iic at pmu because the
283 * pmu doesn't return an error for nonexistent registers, it
284 * just repeats previous data
285 */
286 if (*comp == *rev) {
287 sc->sc_therm = 0; /* */
288 sc->sc_nolow = 1;
289 strlcpy(name, "MAX6642", ADMTEMP_NAMELEN);
290 } else if (*rev == 0) {
291 strlcpy(name, "MAX6690", ADMTEMP_NAMELEN);
292 sc->sc_ext11 = 1;
293 } else {
294 strlcpy(name, "MAX1617A", ADMTEMP_NAMELEN);
295 }
296 }
297
298 if (*comp == ADM1021_COMPANY_GMT) {
299 sc->sc_ext11 = 1;
300 sc->sc_therm = 1;
301 strlcpy(name, "G781", ADMTEMP_NAMELEN);
302 }
303
304 if (*comp == ADM1021_COMPANY_ADM) {
305 cmd = ADM1023_EXT_HIGH2;
306 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &data) == 0) {
307 tmp = 1 << ADM1023_EXT2_SHIFT;
308 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &tmp);
309 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd,
310 &tmp) == 0 && tmp == 1 << ADM1023_EXT2_SHIFT) {
311 sc->sc_ext11 = 1;
312 strlcpy(name, "ADM1023", ADMTEMP_NAMELEN);
313 }
314 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &data);
315 }
316 cmd = ADM1032_EXT_THERM;
317 if (sc->sc_ext11 &&
318 admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &data) == 0
319 && data == 0x55) {
320 sc->sc_therm = 1;
321 strlcpy(name, "ADM1032", ADMTEMP_NAMELEN);
322 }
323 if (!sc->sc_ext11 &&
324 (*rev & ADM1021_REV_MASK) == ADM1021_REV_1021A) {
325 sc->sc_noneg = 0;
326 strlcpy(name, "ADM1021A", ADMTEMP_NAMELEN);
327 } else
328 strlcpy(name, "ADM1021", ADMTEMP_NAMELEN);
329 }
330 }
331
332 void
admtemp_attach(device_t parent,device_t self,void * aux)333 admtemp_attach(device_t parent, device_t self, void *aux)
334 {
335 struct admtemp_softc *sc = device_private(self);
336 struct i2c_attach_args *ia = aux;
337 uint8_t cmd, data, stat, comp, rev;
338 char name[ADMTEMP_NAMELEN];
339 char ename[64] = "external", iname[64] = "internal";
340 const char *desc;
341
342 sc->sc_tag = ia->ia_tag;
343 sc->sc_addr = ia->ia_addr;
344 sc->sc_prop = ia->ia_prop;
345 prop_object_retain(sc->sc_prop);
346
347 if (iic_acquire_bus(sc->sc_tag, 0)) {
348 aprint_error_dev(self, "cannot acquire iic bus\n");
349 return;
350 }
351
352 cmd = ADM1021_CONFIG_READ;
353 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &data) != 0) {
354 iic_release_bus(sc->sc_tag, 0);
355 aprint_error_dev(self, "cannot get control register\n");
356 return;
357 }
358 if (data & ADM1021_CONFIG_RUN) {
359 cmd = ADM1021_STATUS;
360 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &stat)) {
361 iic_release_bus(sc->sc_tag, 0);
362 aprint_error_dev(self,
363 "cannot read status register\n");
364 return;
365 }
366 if ((stat & ADM1021_STATUS_INVAL) == ADM1021_STATUS_INVAL) {
367 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd,
368 &stat)) {
369 iic_release_bus(sc->sc_tag, 0);
370 aprint_error_dev(self,
371 "cannot read status register\n");
372 return;
373 }
374 }
375
376 /* means external is dead */
377 if ((stat & ADM1021_STATUS_INVAL) != ADM1021_STATUS_INVAL &&
378 (stat & ADM1021_STATUS_NOEXT))
379 sc->sc_noexternal = 1;
380
381 data &= ~ADM1021_CONFIG_RUN;
382 cmd = ADM1021_CONFIG_WRITE;
383 if (admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &data)) {
384 iic_release_bus(sc->sc_tag, 0);
385 aprint_error_dev(self,
386 "cannot set control register\n");
387 return;
388 }
389 }
390
391 admtemp_setflags(sc, ia, &comp, &rev, name);
392
393 iic_release_bus(sc->sc_tag, 0);
394
395 aprint_normal(": %s temperature sensor", name);
396 if (comp)
397 aprint_normal(": id. 0x%02x, rev. 0x%02x\n", comp, rev);
398 else
399 aprint_normal("\n");
400 aprint_naive(": Temperature sensor\n");
401
402 /* Initialize sensor data. */
403 sc->sc_sensor[ADMTEMP_INT].state = ENVSYS_SINVALID;
404 sc->sc_sensor[ADMTEMP_INT].units = ENVSYS_STEMP;
405 sc->sc_sensor[ADMTEMP_EXT].state = ENVSYS_SINVALID;
406 sc->sc_sensor[ADMTEMP_EXT].units = ENVSYS_STEMP;
407 sc->sc_sensor[ADMTEMP_INT].flags =
408 ENVSYS_FMONLIMITS | ENVSYS_FHAS_ENTROPY;
409 sc->sc_sensor[ADMTEMP_EXT].flags =
410 ENVSYS_FMONLIMITS | ENVSYS_FHAS_ENTROPY;
411
412 if (prop_dictionary_get_string(sc->sc_prop, "s00", &desc)) {
413 strncpy(iname, desc, 64);
414 }
415
416 if (prop_dictionary_get_string(sc->sc_prop, "s01", &desc)) {
417 strncpy(ename, desc, 64);
418 }
419
420 strlcpy(sc->sc_sensor[ADMTEMP_INT].desc, iname,
421 sizeof(sc->sc_sensor[ADMTEMP_INT].desc));
422 strlcpy(sc->sc_sensor[ADMTEMP_EXT].desc, ename,
423 sizeof(sc->sc_sensor[ADMTEMP_EXT].desc));
424
425 sc->sc_sme = sysmon_envsys_create();
426 if (sysmon_envsys_sensor_attach(
427 sc->sc_sme, &sc->sc_sensor[ADMTEMP_INT])) {
428 sysmon_envsys_destroy(sc->sc_sme);
429 sc->sc_sme = NULL;
430 aprint_error_dev(self,
431 "unable to attach internal at sysmon\n");
432 return;
433 }
434 if (sc->sc_noexternal == 0 &&
435 sysmon_envsys_sensor_attach(
436 sc->sc_sme, &sc->sc_sensor[ADMTEMP_EXT])) {
437 sysmon_envsys_destroy(sc->sc_sme);
438 sc->sc_sme = NULL;
439 aprint_error_dev(self,
440 "unable to attach external at sysmon\n");
441 return;
442 }
443 sc->sc_sme->sme_name = device_xname(self);
444 sc->sc_sme->sme_cookie = sc;
445 sc->sc_sme->sme_refresh = admtemp_refresh;
446 if (sc->sc_therm) {
447 sc->sc_sme->sme_get_limits = admtemp_getlim_1032;
448 sc->sc_sme->sme_set_limits = admtemp_setlim_1032;
449 } else if (sc->sc_ext11) {
450 sc->sc_sme->sme_get_limits = admtemp_getlim_1023;
451 sc->sc_sme->sme_set_limits = admtemp_setlim_1023;
452 } else {
453 sc->sc_sme->sme_get_limits = admtemp_getlim_1021;
454 sc->sc_sme->sme_set_limits = admtemp_setlim_1021;
455 }
456 if (sysmon_envsys_register(sc->sc_sme)) {
457 aprint_error_dev(self,
458 "unable to register with sysmon\n");
459 sysmon_envsys_destroy(sc->sc_sme);
460 sc->sc_sme = NULL;
461 return;
462 }
463 }
464
465
466 void
admtemp_refresh(struct sysmon_envsys * sme,envsys_data_t * edata)467 admtemp_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
468 {
469 struct admtemp_softc *sc = sme->sme_cookie;
470 uint8_t cmd, xdata;
471 int8_t sdata;
472
473 if (iic_acquire_bus(sc->sc_tag, 0) != 0)
474 return;
475
476 if (edata->sensor == ADMTEMP_INT)
477 cmd = ADM1021_INT_TEMP;
478 else
479 cmd = ADM1021_EXT_TEMP;
480
481 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &sdata) == 0) {
482 if (sdata == ADM1021_STATUS_INVAL) {
483 edata->state = ENVSYS_SINVALID;
484 } else {
485 edata->value_cur = 273150000 + 1000000 * sdata;
486 edata->state = ENVSYS_SVALID;
487 }
488 }
489 if (edata->sensor == ADMTEMP_EXT && sc->sc_ext11) {
490 cmd = ADM1023_EXT_TEMP2;
491 admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &xdata);
492 edata->value_cur +=
493 (xdata >> ADM1023_EXT2_SHIFT & ADM1023_EXT2_MASK) * 125000;
494 }
495
496 iic_release_bus(sc->sc_tag, 0);
497 }
498
499 void
admtemp_getlim_1021(struct sysmon_envsys * sme,envsys_data_t * edata,sysmon_envsys_lim_t * limits,uint32_t * props)500 admtemp_getlim_1021(struct sysmon_envsys *sme, envsys_data_t *edata,
501 sysmon_envsys_lim_t *limits, uint32_t *props)
502 {
503 struct admtemp_softc *sc = sme->sme_cookie;
504 uint8_t cmd;
505 int8_t hdata = 0x7f, ldata = 0xc9;
506
507 *props &= ~(PROP_CRITMAX | PROP_CRITMIN);
508
509 if (iic_acquire_bus(sc->sc_tag, 0))
510 return;
511
512 if (edata->sensor == ADMTEMP_INT)
513 cmd = ADM1021_INT_HIGH_READ;
514 else
515 cmd = ADM1021_EXT_HIGH_READ;
516
517 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &hdata) == 0 &&
518 hdata != ADMTEMP_LIM_INVAL) {
519 limits->sel_critmax = 273150000 + 1000000 * hdata;
520 *props |= PROP_CRITMAX;
521 }
522
523 if (sc->sc_nolow == 1) {
524 goto release;
525 }
526
527 if (edata->sensor == ADMTEMP_INT)
528 cmd = ADM1021_INT_LOW_READ;
529 else
530 cmd = ADM1021_EXT_LOW_READ;
531
532 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &ldata) == 0 &&
533 ldata != ADMTEMP_LIM_INVAL) {
534 limits->sel_critmin = 273150000 + 1000000 * ldata;
535 *props |= PROP_CRITMIN;
536 }
537
538 release:
539 iic_release_bus(sc->sc_tag, 0);
540
541 /* Save the values if this is the first time through. */
542 if (sc->sc_setdef[edata->sensor] == 0) {
543 sc->sc_setdef[edata->sensor] = 1;
544 sc->sc_highlim[edata->sensor] = hdata;
545 sc->sc_lowlim[edata->sensor] = ldata;
546 }
547 }
548
549 void
admtemp_getlim_1023(struct sysmon_envsys * sme,envsys_data_t * edata,sysmon_envsys_lim_t * limits,uint32_t * props)550 admtemp_getlim_1023(struct sysmon_envsys *sme, envsys_data_t *edata,
551 sysmon_envsys_lim_t *limits, uint32_t *props)
552 {
553 struct admtemp_softc *sc = sme->sme_cookie;
554 uint8_t cmd, xhdata = 0, xldata = 0;
555 int8_t hdata = 0x7f, ldata = 0xc9;
556
557 *props &= ~(PROP_CRITMAX | PROP_CRITMIN);
558
559 if (iic_acquire_bus(sc->sc_tag, 0))
560 return;
561
562 if (edata->sensor == ADMTEMP_INT)
563 cmd = ADM1021_INT_HIGH_READ;
564 else
565 cmd = ADM1021_EXT_HIGH_READ;
566
567 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &hdata) == 0 &&
568 hdata != ADMTEMP_LIM_INVAL) {
569 limits->sel_critmax = 273150000 + 1000000 * hdata;
570 *props |= PROP_CRITMAX;
571 }
572
573 if (edata->sensor == ADMTEMP_EXT) {
574 cmd = ADM1023_EXT_HIGH2;
575 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &xhdata) == 0)
576 limits->sel_critmax +=
577 (xhdata >> ADM1023_EXT2_SHIFT & ADM1023_EXT2_MASK)
578 * 125000;
579 }
580
581 if (edata->sensor == ADMTEMP_INT)
582 cmd = ADM1021_INT_LOW_READ;
583 else
584 cmd = ADM1021_EXT_LOW_READ;
585
586 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &ldata) == 0 &&
587 ldata != ADMTEMP_LIM_INVAL) {
588 limits->sel_critmin = 273150000 + 1000000 * ldata;
589 *props |= PROP_CRITMIN;
590 }
591
592 if (edata->sensor == ADMTEMP_EXT) {
593 cmd = ADM1023_EXT_LOW2;
594 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &xldata) == 0)
595 limits->sel_critmin +=
596 (xldata >> ADM1023_EXT2_SHIFT & ADM1023_EXT2_MASK)
597 * 125000;
598 }
599
600 iic_release_bus(sc->sc_tag, 0);
601
602 /* Save the values if this is the first time through. */
603 if (sc->sc_setdef[edata->sensor] == 0) {
604 sc->sc_setdef[edata->sensor] = 1;
605 sc->sc_highlim[edata->sensor] = hdata;
606 sc->sc_lowlim[edata->sensor] = ldata;
607 if (edata->sensor == ADMTEMP_EXT) {
608 sc->sc_highlim2 = xhdata;
609 sc->sc_lowlim2 = xldata;
610 }
611 }
612 }
613
614 void
admtemp_getlim_1032(struct sysmon_envsys * sme,envsys_data_t * edata,sysmon_envsys_lim_t * limits,uint32_t * props)615 admtemp_getlim_1032(struct sysmon_envsys *sme, envsys_data_t *edata,
616 sysmon_envsys_lim_t *limits, uint32_t *props)
617 {
618 struct admtemp_softc *sc = sme->sme_cookie;
619 uint8_t cmd, xhdata = 0, xldata = 0;
620 int8_t tdata = 0x55, hdata = 0x55, ldata = 0;
621
622 *props &= ~(PROP_WARNMAX | PROP_CRITMAX | PROP_WARNMIN);
623
624 if (iic_acquire_bus(sc->sc_tag, 0))
625 return;
626
627 if (edata->sensor == ADMTEMP_INT)
628 cmd = ADM1032_INT_THERM;
629 else
630 cmd = ADM1032_EXT_THERM;
631
632 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &tdata) == 0 &&
633 tdata != ADMTEMP_LIM_INVAL) {
634 limits->sel_critmax = 273150000 + 1000000 * tdata;
635 *props |= PROP_CRITMAX;
636 }
637
638 if (edata->sensor == ADMTEMP_INT)
639 cmd = ADM1021_INT_HIGH_READ;
640 else
641 cmd = ADM1021_EXT_HIGH_READ;
642
643 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &hdata) == 0 &&
644 hdata != ADMTEMP_LIM_INVAL) {
645 limits->sel_warnmax = 273150000 + 1000000 * hdata;
646 *props |= PROP_WARNMAX;
647 }
648
649 if (edata->sensor == ADMTEMP_EXT) {
650 cmd = ADM1023_EXT_HIGH2;
651 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &xhdata) == 0)
652 limits->sel_warnmax +=
653 (xhdata >> ADM1023_EXT2_SHIFT & ADM1023_EXT2_MASK)
654 * 125000;
655 }
656
657 if (edata->sensor == ADMTEMP_INT)
658 cmd = ADM1021_INT_LOW_READ;
659 else
660 cmd = ADM1021_EXT_LOW_READ;
661
662 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &ldata) == 0 &&
663 ldata != ADMTEMP_LIM_INVAL) {
664 limits->sel_warnmin = 273150000 + 1000000 * ldata;
665 *props |= PROP_WARNMIN;
666 }
667
668 if (edata->sensor == ADMTEMP_EXT) {
669 cmd = ADM1023_EXT_LOW2;
670 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &xldata) == 0)
671 limits->sel_warnmin +=
672 (xldata >> ADM1023_EXT2_SHIFT & ADM1023_EXT2_MASK)
673 * 125000;
674 }
675
676 iic_release_bus(sc->sc_tag, 0);
677
678 /* Save the values if this is the first time through. */
679 if (sc->sc_setdef[edata->sensor] == 0) {
680 sc->sc_setdef[edata->sensor] = 1;
681 sc->sc_thermlim[edata->sensor] = tdata;
682 sc->sc_highlim[edata->sensor] = hdata;
683 sc->sc_lowlim[edata->sensor] = ldata;
684 if (edata->sensor == ADMTEMP_EXT) {
685 sc->sc_highlim2 = xhdata;
686 sc->sc_lowlim2 = xldata;
687 }
688 }
689 }
690
691 void
admtemp_setlim_1021(struct sysmon_envsys * sme,envsys_data_t * edata,sysmon_envsys_lim_t * limits,uint32_t * props)692 admtemp_setlim_1021(struct sysmon_envsys *sme, envsys_data_t *edata,
693 sysmon_envsys_lim_t *limits, uint32_t *props)
694 {
695 struct admtemp_softc *sc = sme->sme_cookie;
696 uint8_t cmd;
697 int tmp;
698 int8_t sdata;
699
700 if (iic_acquire_bus(sc->sc_tag, 0))
701 return;
702
703 if (*props & PROP_CRITMAX) {
704 if (edata->sensor == ADMTEMP_INT)
705 cmd = ADM1021_INT_HIGH_WRITE;
706 else
707 cmd = ADM1021_EXT_HIGH_WRITE;
708
709 if (limits == NULL) /* Restore defaults */
710 sdata = sc->sc_highlim[edata->sensor];
711 else {
712 tmp = (limits->sel_critmax - 273150000) / 1000000;
713 if (tmp > ADMTEMP_MAX_POS)
714 sdata = ADMTEMP_MAX_POS;
715 else if (tmp < 0 && sc->sc_noneg)
716 sdata = 0;
717 else if (tmp < ADMTEMP_MAX_NEG)
718 sdata = ADMTEMP_MAX_NEG;
719 else
720 sdata = tmp & 0xff;
721 }
722 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata);
723 }
724
725 if (*props & PROP_CRITMIN && sc->sc_nolow == 0) {
726 if (edata->sensor == ADMTEMP_INT)
727 cmd = ADM1021_INT_LOW_WRITE;
728 else
729 cmd = ADM1021_EXT_LOW_WRITE;
730 if (limits == NULL)
731 sdata = sc->sc_lowlim[edata->sensor];
732 else {
733 tmp = (limits->sel_critmin - 273150000) / 1000000;
734 if (tmp > ADMTEMP_MAX_POS)
735 sdata = ADMTEMP_MAX_POS;
736 else if (tmp < 0 && sc->sc_noneg)
737 sdata = 0;
738 else if (tmp < ADMTEMP_MAX_NEG)
739 sdata = ADMTEMP_MAX_NEG;
740 else
741 sdata = tmp & 0xff;
742 }
743 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata);
744 }
745
746 iic_release_bus(sc->sc_tag, 0);
747 }
748
749 static void
admtemp_encode_temp(const uint32_t val,int8_t * sdata,uint8_t * xdata,const int ext11)750 admtemp_encode_temp(const uint32_t val, int8_t *sdata, uint8_t *xdata,
751 const int ext11)
752 {
753 int32_t tmp;
754
755 if (ext11) {
756 /* Split temperature into high and low bytes */
757 tmp = (val - 273150000) / 125000;
758 *xdata = (tmp & ADM1023_EXT2_MASK) << ADM1023_EXT2_SHIFT;
759 tmp -= (int32_t) (*xdata >> ADM1023_EXT2_SHIFT);
760 tmp /= 8; /* 1000000 / 125000 */
761 } else {
762 *xdata = 0;
763 tmp = (val - 273150000) / 1000000;
764 }
765 if (tmp > ADMTEMP_MAX_POS)
766 *sdata = ADMTEMP_MAX_POS;
767 else if (tmp < 0)
768 *sdata = 0;
769 else
770 *sdata = tmp & 0xff;
771 }
772
773 void
admtemp_setlim_1023(struct sysmon_envsys * sme,envsys_data_t * edata,sysmon_envsys_lim_t * limits,uint32_t * props)774 admtemp_setlim_1023(struct sysmon_envsys *sme, envsys_data_t *edata,
775 sysmon_envsys_lim_t *limits, uint32_t *props)
776 {
777 struct admtemp_softc *sc = sme->sme_cookie;
778 int ext11;
779 uint8_t cmd, xdata;
780 int8_t sdata;
781
782 if (edata->sensor == ADMTEMP_INT)
783 ext11 = 0;
784 else
785 ext11 = 1;
786
787 if (iic_acquire_bus(sc->sc_tag, 0))
788 return;
789
790 if (*props & PROP_CRITMAX) {
791 if (edata->sensor == ADMTEMP_INT)
792 cmd = ADM1021_INT_HIGH_WRITE;
793 else
794 cmd = ADM1021_EXT_HIGH_WRITE;
795
796 if (limits == NULL) { /* Restore defaults */
797 sdata = sc->sc_highlim[edata->sensor];
798 xdata = sc->sc_highlim2;
799 } else
800 admtemp_encode_temp(limits->sel_critmax, &sdata,
801 &xdata, ext11);
802
803 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata);
804 if (ext11) {
805 cmd = ADM1023_EXT_HIGH2;
806 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &xdata);
807 }
808 }
809
810 if (*props & PROP_CRITMIN) {
811 if (edata->sensor == ADMTEMP_INT)
812 cmd = ADM1021_INT_LOW_WRITE;
813 else
814 cmd = ADM1021_EXT_LOW_WRITE;
815 if (limits == NULL) {
816 sdata = sc->sc_lowlim[edata->sensor];
817 xdata = sc->sc_lowlim2;
818 } else
819 admtemp_encode_temp(limits->sel_critmax, &sdata,
820 &xdata, ext11);
821 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata);
822 if (ext11) {
823 cmd = ADM1023_EXT_LOW2;
824 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &xdata);
825 }
826 }
827
828 iic_release_bus(sc->sc_tag, 0);
829 }
830
831 void
admtemp_setlim_1032(struct sysmon_envsys * sme,envsys_data_t * edata,sysmon_envsys_lim_t * limits,uint32_t * props)832 admtemp_setlim_1032(struct sysmon_envsys *sme, envsys_data_t *edata,
833 sysmon_envsys_lim_t *limits, uint32_t *props)
834 {
835 struct admtemp_softc *sc = sme->sme_cookie;
836 int ext11;
837 uint8_t cmd, xdata;
838 int8_t sdata;
839
840 if (edata->sensor == ADMTEMP_INT)
841 ext11 = 0;
842 else
843 ext11 = 1;
844
845 if (iic_acquire_bus(sc->sc_tag, 0))
846 return;
847
848 if (*props & PROP_CRITMAX) {
849 if (edata->sensor == ADMTEMP_INT)
850 cmd = ADM1032_INT_THERM;
851 else
852 cmd = ADM1032_EXT_THERM;
853 if (limits == NULL) /* Restore default */
854 sdata = sc->sc_thermlim[edata->sensor];
855 else
856 admtemp_encode_temp(limits->sel_critmax, &sdata,
857 &xdata, 0);
858 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata);
859 }
860
861 if (*props & PROP_WARNMAX) {
862 if (edata->sensor == ADMTEMP_INT)
863 cmd = ADM1021_INT_HIGH_WRITE;
864 else
865 cmd = ADM1021_EXT_HIGH_WRITE;
866
867 if (limits == NULL) { /* Restore defaults */
868 sdata = sc->sc_highlim[edata->sensor];
869 xdata = sc->sc_highlim2;
870 } else
871 admtemp_encode_temp(limits->sel_warnmax, &sdata,
872 &xdata, ext11);
873 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata);
874
875 if (ext11) {
876 cmd = ADM1023_EXT_HIGH2;
877 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &xdata);
878 }
879 }
880
881 if (*props & PROP_WARNMIN) {
882 if (edata->sensor == ADMTEMP_INT)
883 cmd = ADM1021_INT_LOW_WRITE;
884 else
885 cmd = ADM1021_EXT_LOW_WRITE;
886 if (limits == NULL) {
887 sdata = sc->sc_lowlim[edata->sensor];
888 xdata = sc->sc_lowlim2;
889 } else
890 admtemp_encode_temp(limits->sel_warnmin, &sdata,
891 &xdata, ext11);
892 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata);
893
894 if (ext11) {
895 cmd = ADM1023_EXT_LOW2;
896 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &xdata);
897 }
898 }
899
900 iic_release_bus(sc->sc_tag, 0);
901 }
902