adm1021.c revision 1.21
1 /* $NetBSD: adm1021.c,v 1.21 2020/12/10 17:02:51 jdc 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.21 2020/12/10 17:02:51 jdc 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 /* XXX: add flags for compats to admtemp_setflags() */ 147 static const struct device_compatible_entry compat_data[] = { 148 { "i2c-max1617", 0 }, 149 { "max6642", 0 }, 150 { "max6690", 0 }, 151 { NULL, 0 } 152 }; 153 154 int 155 admtemp_match(device_t parent, cfdata_t match, void *aux) 156 { 157 struct i2c_attach_args *ia = aux; 158 int match_result; 159 160 if (iic_use_direct_match(ia, match, compat_data, &match_result)) 161 return match_result; 162 163 /* 164 * Indirect config - not much we can do! 165 * Check typical addresses. 166 */ 167 if (((ia->ia_addr >= 0x18) && (ia->ia_addr <= 0x1a)) || 168 ((ia->ia_addr >= 0x29) && (ia->ia_addr <= 0x2b)) || 169 ((ia->ia_addr >= 0x48) && (ia->ia_addr <= 0x4e))) 170 return I2C_MATCH_ADDRESS_ONLY; 171 172 return 0; 173 } 174 175 static int 176 admtemp_exec(struct admtemp_softc *sc, i2c_op_t op, uint8_t *cmd, 177 uint8_t *data) 178 { 179 return iic_exec(sc->sc_tag, op, sc->sc_addr, cmd, sizeof(*cmd), data, 180 sizeof(*data), 0); 181 } 182 183 /* 184 * Set flags based on chip type for direct config, or by testing for 185 * indirect config. 186 * 187 * LM84, MAX1617, and NE1617A don't have company/revision registers. 188 * If we can't read the company register, we'll check the 189 * internal low limit to see if we have an LM84. 190 * 191 * To check if an ADM chip has 11-bit sensors, we'll write 0.125 192 * to the external temperature limit low byte register and read it 193 * back (because we can't tell from the id/rev). 194 * 195 * To check if an ADM chip has a Therm output, we check that we 196 * read 0x55 (default value) from the external therm limit. 197 * 198 * If an ADM chip doesn't have 11-bit sensors, check the revision to 199 * determine if it handles negative temperatures. 200 */ 201 static void 202 admtemp_setflags(struct admtemp_softc *sc, struct i2c_attach_args *ia, 203 uint8_t* comp, uint8_t *rev, char* name) 204 { 205 uint8_t cmd, data, tmp; 206 int i; 207 208 *comp = 0; 209 *rev = 0; 210 211 cmd = ADM1021_COMPANY; 212 admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, comp); 213 214 cmd = ADM1021_DIE_REVISION; 215 admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, rev); 216 217 sc->sc_noneg = 1; 218 sc->sc_nolow = 0; 219 sc->sc_ext11 = 0; 220 sc->sc_therm = 0; 221 222 /* Direct config */ 223 for (i = 0; i < ia->ia_ncompat; i++) { 224 if (strcmp("i2c-max1617", ia->ia_compat[i]) == 0) { 225 sc->sc_noneg = 0; 226 strlcpy(name, "MAX1617A", ADMTEMP_NAMELEN); 227 return; 228 } 229 if (strcmp("max6642", ia->ia_compat[i]) == 0) { 230 sc->sc_noneg = 0; 231 sc->sc_nolow = 1; 232 strlcpy(name, "MAX6642", ADMTEMP_NAMELEN); 233 return; 234 } 235 if (strcmp("max6690", ia->ia_compat[i]) == 0) { 236 sc->sc_noneg = 0; 237 sc->sc_ext11 = 1; 238 strlcpy(name, "MAX6690", ADMTEMP_NAMELEN); 239 return; 240 } 241 } 242 243 /* Indirect config */ 244 if (*comp == 0) { 245 sc->sc_noneg = 0; 246 cmd = ADM1021_INT_LOW_READ; 247 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, comp) == 0 && 248 *comp != ADMTEMP_LOW_DEFAULT) { 249 sc->sc_nolow = 1; 250 strlcpy(name, "LM84", ADMTEMP_NAMELEN); 251 } else 252 strlcpy(name, "MAX1617", ADMTEMP_NAMELEN); 253 } 254 255 if (*comp == ADM1021_COMPANY_MAXIM) { 256 sc->sc_noneg = 0; 257 /* 258 * MAX6642 doesn't have a revision register 259 * XXX this works only on macppc with iic at pmu because the 260 * pmu doesn't return an error for nonexistant registers, it 261 * just repeats previous data 262 */ 263 if (*comp == *rev) { 264 sc->sc_therm = 0; /* */ 265 sc->sc_nolow = 1; 266 strlcpy(name, "MAX6642", ADMTEMP_NAMELEN); 267 } else if (*rev == 0) { 268 strlcpy(name, "MAX6690", ADMTEMP_NAMELEN); 269 sc->sc_ext11 = 1; 270 } else { 271 strlcpy(name, "MAX1617A", ADMTEMP_NAMELEN); 272 } 273 } 274 275 if (*comp == ADM1021_COMPANY_GMT) { 276 sc->sc_ext11 = 1; 277 sc->sc_therm = 1; 278 strlcpy(name, "G781", ADMTEMP_NAMELEN); 279 } 280 281 if (*comp == ADM1021_COMPANY_ADM) { 282 cmd = ADM1023_EXT_HIGH2; 283 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &data) == 0) { 284 tmp = 1 << ADM1023_EXT2_SHIFT; 285 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &tmp); 286 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, 287 &tmp) == 0 && tmp == 1 << ADM1023_EXT2_SHIFT) { 288 sc->sc_ext11 = 1; 289 strlcpy(name, "ADM1023", ADMTEMP_NAMELEN); 290 } 291 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &data); 292 } 293 cmd = ADM1032_EXT_THERM; 294 if (sc->sc_ext11 && 295 admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &data) == 0 296 && data == 0x55) { 297 sc->sc_therm = 1; 298 strlcpy(name, "ADM1032", ADMTEMP_NAMELEN); 299 } 300 if (!sc->sc_ext11 && 301 (*rev & ADM1021_REV_MASK) == ADM1021_REV_1021A) { 302 sc->sc_noneg = 0; 303 strlcpy(name, "ADM1021A", ADMTEMP_NAMELEN); 304 } else 305 strlcpy(name, "ADM1021", ADMTEMP_NAMELEN); 306 } 307 } 308 309 void 310 admtemp_attach(device_t parent, device_t self, void *aux) 311 { 312 struct admtemp_softc *sc = device_private(self); 313 struct i2c_attach_args *ia = aux; 314 uint8_t cmd, data, stat, comp, rev; 315 char name[ADMTEMP_NAMELEN]; 316 char ename[64] = "external", iname[64] = "internal"; 317 const char *desc; 318 319 sc->sc_tag = ia->ia_tag; 320 sc->sc_addr = ia->ia_addr; 321 sc->sc_prop = ia->ia_prop; 322 323 iic_acquire_bus(sc->sc_tag, 0); 324 cmd = ADM1021_CONFIG_READ; 325 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &data) != 0) { 326 iic_release_bus(sc->sc_tag, 0); 327 aprint_error_dev(self, "cannot get control register\n"); 328 return; 329 } 330 if (data & ADM1021_CONFIG_RUN) { 331 cmd = ADM1021_STATUS; 332 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &stat)) { 333 iic_release_bus(sc->sc_tag, 0); 334 aprint_error_dev(self, 335 "cannot read status register\n"); 336 return; 337 } 338 if ((stat & ADM1021_STATUS_INVAL) == ADM1021_STATUS_INVAL) { 339 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, 340 &stat)) { 341 iic_release_bus(sc->sc_tag, 0); 342 aprint_error_dev(self, 343 "cannot read status register\n"); 344 return; 345 } 346 } 347 348 /* means external is dead */ 349 if ((stat & ADM1021_STATUS_INVAL) != ADM1021_STATUS_INVAL && 350 (stat & ADM1021_STATUS_NOEXT)) 351 sc->sc_noexternal = 1; 352 353 data &= ~ADM1021_CONFIG_RUN; 354 cmd = ADM1021_CONFIG_WRITE; 355 if (admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &data)) { 356 iic_release_bus(sc->sc_tag, 0); 357 aprint_error_dev(self, 358 "cannot set control register\n"); 359 return; 360 } 361 } 362 363 admtemp_setflags(sc, ia, &comp, &rev, name); 364 365 iic_release_bus(sc->sc_tag, 0); 366 367 aprint_normal(": %s temperature sensor", name); 368 if (comp) 369 aprint_normal(": id. 0x%02x, rev. 0x%02x\n", comp, rev); 370 else 371 aprint_normal("\n"); 372 aprint_naive(": Temperature sensor\n"); 373 374 /* Initialize sensor data. */ 375 sc->sc_sensor[ADMTEMP_INT].state = ENVSYS_SINVALID; 376 sc->sc_sensor[ADMTEMP_INT].units = ENVSYS_STEMP; 377 sc->sc_sensor[ADMTEMP_EXT].state = ENVSYS_SINVALID; 378 sc->sc_sensor[ADMTEMP_EXT].units = ENVSYS_STEMP; 379 sc->sc_sensor[ADMTEMP_INT].flags = ENVSYS_FMONLIMITS; 380 sc->sc_sensor[ADMTEMP_EXT].flags = ENVSYS_FMONLIMITS; 381 382 if (prop_dictionary_get_cstring_nocopy(sc->sc_prop, "s00", &desc)) { 383 strncpy(iname, desc, 64); 384 } 385 386 if (prop_dictionary_get_cstring_nocopy(sc->sc_prop, "s01", &desc)) { 387 strncpy(ename, desc, 64); 388 } 389 390 strlcpy(sc->sc_sensor[ADMTEMP_INT].desc, iname, 391 sizeof(sc->sc_sensor[ADMTEMP_INT].desc)); 392 strlcpy(sc->sc_sensor[ADMTEMP_EXT].desc, ename, 393 sizeof(sc->sc_sensor[ADMTEMP_EXT].desc)); 394 395 sc->sc_sme = sysmon_envsys_create(); 396 if (sysmon_envsys_sensor_attach( 397 sc->sc_sme, &sc->sc_sensor[ADMTEMP_INT])) { 398 sysmon_envsys_destroy(sc->sc_sme); 399 sc->sc_sme = NULL; 400 aprint_error_dev(self, 401 "unable to attach internal at sysmon\n"); 402 return; 403 } 404 if (sc->sc_noexternal == 0 && 405 sysmon_envsys_sensor_attach( 406 sc->sc_sme, &sc->sc_sensor[ADMTEMP_EXT])) { 407 sysmon_envsys_destroy(sc->sc_sme); 408 sc->sc_sme = NULL; 409 aprint_error_dev(self, 410 "unable to attach external at sysmon\n"); 411 return; 412 } 413 sc->sc_sme->sme_name = device_xname(self); 414 sc->sc_sme->sme_cookie = sc; 415 sc->sc_sme->sme_refresh = admtemp_refresh; 416 if (sc->sc_therm) { 417 sc->sc_sme->sme_get_limits = admtemp_getlim_1032; 418 sc->sc_sme->sme_set_limits = admtemp_setlim_1032; 419 } else if (sc->sc_ext11) { 420 sc->sc_sme->sme_get_limits = admtemp_getlim_1023; 421 sc->sc_sme->sme_set_limits = admtemp_setlim_1023; 422 } else { 423 sc->sc_sme->sme_get_limits = admtemp_getlim_1021; 424 sc->sc_sme->sme_set_limits = admtemp_setlim_1021; 425 } 426 if (sysmon_envsys_register(sc->sc_sme)) { 427 aprint_error_dev(self, 428 "unable to register with sysmon\n"); 429 sysmon_envsys_destroy(sc->sc_sme); 430 sc->sc_sme = NULL; 431 return; 432 } 433 } 434 435 436 void 437 admtemp_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 438 { 439 struct admtemp_softc *sc = sme->sme_cookie; 440 uint8_t cmd, xdata; 441 int8_t sdata; 442 443 if (iic_acquire_bus(sc->sc_tag, 0)) { 444 edata->state = ENVSYS_SINVALID; 445 return; 446 } 447 448 if (edata->sensor == ADMTEMP_INT) 449 cmd = ADM1021_INT_TEMP; 450 else 451 cmd = ADM1021_EXT_TEMP; 452 453 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &sdata) == 0) { 454 if (sdata == ADM1021_STATUS_INVAL) { 455 edata->state = ENVSYS_SINVALID; 456 } else { 457 edata->value_cur = 273150000 + 1000000 * sdata; 458 edata->state = ENVSYS_SVALID; 459 } 460 } 461 if (edata->sensor == ADMTEMP_EXT && sc->sc_ext11) { 462 cmd = ADM1023_EXT_TEMP2; 463 admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &xdata); 464 edata->value_cur += 465 (xdata >> ADM1023_EXT2_SHIFT & ADM1023_EXT2_MASK) * 125000; 466 } 467 468 iic_release_bus(sc->sc_tag, 0); 469 } 470 471 void 472 admtemp_getlim_1021(struct sysmon_envsys *sme, envsys_data_t *edata, 473 sysmon_envsys_lim_t *limits, uint32_t *props) 474 { 475 struct admtemp_softc *sc = sme->sme_cookie; 476 uint8_t cmd; 477 int8_t hdata = 0x7f, ldata = 0xc9; 478 479 *props &= ~(PROP_CRITMAX | PROP_CRITMIN); 480 481 if (iic_acquire_bus(sc->sc_tag, 0)) 482 return; 483 484 if (edata->sensor == ADMTEMP_INT) 485 cmd = ADM1021_INT_HIGH_READ; 486 else 487 cmd = ADM1021_EXT_HIGH_READ; 488 489 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &hdata) == 0 && 490 hdata != ADMTEMP_LIM_INVAL) { 491 limits->sel_critmax = 273150000 + 1000000 * hdata; 492 *props |= PROP_CRITMAX; 493 } 494 495 if (sc->sc_nolow == 1) { 496 goto release; 497 } 498 499 if (edata->sensor == ADMTEMP_INT) 500 cmd = ADM1021_INT_LOW_READ; 501 else 502 cmd = ADM1021_EXT_LOW_READ; 503 504 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &ldata) == 0 && 505 ldata != ADMTEMP_LIM_INVAL) { 506 limits->sel_critmin = 273150000 + 1000000 * ldata; 507 *props |= PROP_CRITMIN; 508 } 509 510 release: 511 iic_release_bus(sc->sc_tag, 0); 512 513 /* Save the values if this is the first time through. */ 514 if (sc->sc_setdef[edata->sensor] == 0) { 515 sc->sc_setdef[edata->sensor] = 1; 516 sc->sc_highlim[edata->sensor] = hdata; 517 sc->sc_lowlim[edata->sensor] = ldata; 518 } 519 } 520 521 void 522 admtemp_getlim_1023(struct sysmon_envsys *sme, envsys_data_t *edata, 523 sysmon_envsys_lim_t *limits, uint32_t *props) 524 { 525 struct admtemp_softc *sc = sme->sme_cookie; 526 uint8_t cmd, xhdata = 0, xldata = 0; 527 int8_t hdata = 0x7f, ldata = 0xc9; 528 529 *props &= ~(PROP_CRITMAX | PROP_CRITMIN); 530 531 if (iic_acquire_bus(sc->sc_tag, 0)) 532 return; 533 534 if (edata->sensor == ADMTEMP_INT) 535 cmd = ADM1021_INT_HIGH_READ; 536 else 537 cmd = ADM1021_EXT_HIGH_READ; 538 539 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &hdata) == 0 && 540 hdata != ADMTEMP_LIM_INVAL) { 541 limits->sel_critmax = 273150000 + 1000000 * hdata; 542 *props |= PROP_CRITMAX; 543 } 544 545 if (edata->sensor == ADMTEMP_EXT) { 546 cmd = ADM1023_EXT_HIGH2; 547 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &xhdata) == 0) 548 limits->sel_critmax += 549 (xhdata >> ADM1023_EXT2_SHIFT & ADM1023_EXT2_MASK) 550 * 125000; 551 } 552 553 if (edata->sensor == ADMTEMP_INT) 554 cmd = ADM1021_INT_LOW_READ; 555 else 556 cmd = ADM1021_EXT_LOW_READ; 557 558 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &ldata) == 0 && 559 ldata != ADMTEMP_LIM_INVAL) { 560 limits->sel_critmin = 273150000 + 1000000 * ldata; 561 *props |= PROP_CRITMIN; 562 } 563 564 if (edata->sensor == ADMTEMP_EXT) { 565 cmd = ADM1023_EXT_LOW2; 566 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &xldata) == 0) 567 limits->sel_critmin += 568 (xldata >> ADM1023_EXT2_SHIFT & ADM1023_EXT2_MASK) 569 * 125000; 570 } 571 572 iic_release_bus(sc->sc_tag, 0); 573 574 /* Save the values if this is the first time through. */ 575 if (sc->sc_setdef[edata->sensor] == 0) { 576 sc->sc_setdef[edata->sensor] = 1; 577 sc->sc_highlim[edata->sensor] = hdata; 578 sc->sc_lowlim[edata->sensor] = ldata; 579 if (edata->sensor == ADMTEMP_EXT) { 580 sc->sc_highlim2 = xhdata; 581 sc->sc_lowlim2 = xldata; 582 } 583 } 584 } 585 586 void 587 admtemp_getlim_1032(struct sysmon_envsys *sme, envsys_data_t *edata, 588 sysmon_envsys_lim_t *limits, uint32_t *props) 589 { 590 struct admtemp_softc *sc = sme->sme_cookie; 591 uint8_t cmd, xhdata = 0, xldata = 0; 592 int8_t tdata = 0x55, hdata = 0x55, ldata = 0; 593 594 *props &= ~(PROP_WARNMAX | PROP_CRITMAX | PROP_WARNMIN); 595 596 if (iic_acquire_bus(sc->sc_tag, 0)) 597 return; 598 599 if (edata->sensor == ADMTEMP_INT) 600 cmd = ADM1032_INT_THERM; 601 else 602 cmd = ADM1032_EXT_THERM; 603 604 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &tdata) == 0 && 605 tdata != ADMTEMP_LIM_INVAL) { 606 limits->sel_critmax = 273150000 + 1000000 * tdata; 607 *props |= PROP_CRITMAX; 608 } 609 610 if (edata->sensor == ADMTEMP_INT) 611 cmd = ADM1021_INT_HIGH_READ; 612 else 613 cmd = ADM1021_EXT_HIGH_READ; 614 615 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &hdata) == 0 && 616 hdata != ADMTEMP_LIM_INVAL) { 617 limits->sel_warnmax = 273150000 + 1000000 * hdata; 618 *props |= PROP_WARNMAX; 619 } 620 621 if (edata->sensor == ADMTEMP_EXT) { 622 cmd = ADM1023_EXT_HIGH2; 623 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &xhdata) == 0) 624 limits->sel_warnmax += 625 (xhdata >> ADM1023_EXT2_SHIFT & ADM1023_EXT2_MASK) 626 * 125000; 627 } 628 629 if (edata->sensor == ADMTEMP_INT) 630 cmd = ADM1021_INT_LOW_READ; 631 else 632 cmd = ADM1021_EXT_LOW_READ; 633 634 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &ldata) == 0 && 635 ldata != ADMTEMP_LIM_INVAL) { 636 limits->sel_warnmin = 273150000 + 1000000 * ldata; 637 *props |= PROP_WARNMIN; 638 } 639 640 if (edata->sensor == ADMTEMP_EXT) { 641 cmd = ADM1023_EXT_LOW2; 642 if (admtemp_exec(sc, I2C_OP_READ_WITH_STOP, &cmd, &xldata) == 0) 643 limits->sel_warnmin += 644 (xldata >> ADM1023_EXT2_SHIFT & ADM1023_EXT2_MASK) 645 * 125000; 646 } 647 648 iic_release_bus(sc->sc_tag, 0); 649 650 /* Save the values if this is the first time through. */ 651 if (sc->sc_setdef[edata->sensor] == 0) { 652 sc->sc_setdef[edata->sensor] = 1; 653 sc->sc_thermlim[edata->sensor] = tdata; 654 sc->sc_highlim[edata->sensor] = hdata; 655 sc->sc_lowlim[edata->sensor] = ldata; 656 if (edata->sensor == ADMTEMP_EXT) { 657 sc->sc_highlim2 = xhdata; 658 sc->sc_lowlim2 = xldata; 659 } 660 } 661 } 662 663 void 664 admtemp_setlim_1021(struct sysmon_envsys *sme, envsys_data_t *edata, 665 sysmon_envsys_lim_t *limits, uint32_t *props) 666 { 667 struct admtemp_softc *sc = sme->sme_cookie; 668 uint8_t cmd; 669 int tmp; 670 int8_t sdata; 671 672 if (iic_acquire_bus(sc->sc_tag, 0)) 673 return; 674 675 if (*props & PROP_CRITMAX) { 676 if (edata->sensor == ADMTEMP_INT) 677 cmd = ADM1021_INT_HIGH_WRITE; 678 else 679 cmd = ADM1021_EXT_HIGH_WRITE; 680 681 if (limits == NULL) /* Restore defaults */ 682 sdata = sc->sc_highlim[edata->sensor]; 683 else { 684 tmp = (limits->sel_critmax - 273150000) / 1000000; 685 if (tmp > ADMTEMP_MAX_POS) 686 sdata = ADMTEMP_MAX_POS; 687 else if (tmp < 0 && sc->sc_noneg) 688 sdata = 0; 689 else if (tmp < ADMTEMP_MAX_NEG) 690 sdata = ADMTEMP_MAX_NEG; 691 else 692 sdata = tmp & 0xff; 693 } 694 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata); 695 } 696 697 if (*props & PROP_CRITMIN && sc->sc_nolow == 0) { 698 if (edata->sensor == ADMTEMP_INT) 699 cmd = ADM1021_INT_LOW_WRITE; 700 else 701 cmd = ADM1021_EXT_LOW_WRITE; 702 if (limits == NULL) 703 sdata = sc->sc_lowlim[edata->sensor]; 704 else { 705 tmp = (limits->sel_critmin - 273150000) / 1000000; 706 if (tmp > ADMTEMP_MAX_POS) 707 sdata = ADMTEMP_MAX_POS; 708 else if (tmp < 0 && sc->sc_noneg) 709 sdata = 0; 710 else if (tmp < ADMTEMP_MAX_NEG) 711 sdata = ADMTEMP_MAX_NEG; 712 else 713 sdata = tmp & 0xff; 714 } 715 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata); 716 } 717 718 iic_release_bus(sc->sc_tag, 0); 719 } 720 721 static void 722 admtemp_encode_temp(const uint32_t val, int8_t *sdata, uint8_t *xdata, 723 const int ext11) 724 { 725 int32_t tmp; 726 727 if (ext11) { 728 /* Split temperature into high and low bytes */ 729 tmp = (val - 273150000) / 125000; 730 *xdata = (tmp & ADM1023_EXT2_MASK) << ADM1023_EXT2_SHIFT; 731 tmp -= (int32_t) (*xdata >> ADM1023_EXT2_SHIFT); 732 tmp /= 8; /* 1000000 / 125000 */ 733 } else { 734 *xdata = 0; 735 tmp = (val - 273150000) / 1000000; 736 } 737 if (tmp > ADMTEMP_MAX_POS) 738 *sdata = ADMTEMP_MAX_POS; 739 else if (tmp < 0) 740 *sdata = 0; 741 else 742 *sdata = tmp & 0xff; 743 } 744 745 void 746 admtemp_setlim_1023(struct sysmon_envsys *sme, envsys_data_t *edata, 747 sysmon_envsys_lim_t *limits, uint32_t *props) 748 { 749 struct admtemp_softc *sc = sme->sme_cookie; 750 int ext11; 751 uint8_t cmd, xdata; 752 int8_t sdata; 753 754 if (edata->sensor == ADMTEMP_INT) 755 ext11 = 0; 756 else 757 ext11 = 1; 758 759 if (iic_acquire_bus(sc->sc_tag, 0)) 760 return; 761 762 if (*props & PROP_CRITMAX) { 763 if (edata->sensor == ADMTEMP_INT) 764 cmd = ADM1021_INT_HIGH_WRITE; 765 else 766 cmd = ADM1021_EXT_HIGH_WRITE; 767 768 if (limits == NULL) { /* Restore defaults */ 769 sdata = sc->sc_highlim[edata->sensor]; 770 xdata = sc->sc_highlim2; 771 } else 772 admtemp_encode_temp(limits->sel_critmax, &sdata, 773 &xdata, ext11); 774 775 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata); 776 if (ext11) { 777 cmd = ADM1023_EXT_HIGH2; 778 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &xdata); 779 } 780 } 781 782 if (*props & PROP_CRITMIN) { 783 if (edata->sensor == ADMTEMP_INT) 784 cmd = ADM1021_INT_LOW_WRITE; 785 else 786 cmd = ADM1021_EXT_LOW_WRITE; 787 if (limits == NULL) { 788 sdata = sc->sc_lowlim[edata->sensor]; 789 xdata = sc->sc_lowlim2; 790 } else 791 admtemp_encode_temp(limits->sel_critmax, &sdata, 792 &xdata, ext11); 793 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata); 794 if (ext11) { 795 cmd = ADM1023_EXT_LOW2; 796 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &xdata); 797 } 798 } 799 800 iic_release_bus(sc->sc_tag, 0); 801 } 802 803 void 804 admtemp_setlim_1032(struct sysmon_envsys *sme, envsys_data_t *edata, 805 sysmon_envsys_lim_t *limits, uint32_t *props) 806 { 807 struct admtemp_softc *sc = sme->sme_cookie; 808 int ext11; 809 uint8_t cmd, xdata; 810 int8_t sdata; 811 812 if (edata->sensor == ADMTEMP_INT) 813 ext11 = 0; 814 else 815 ext11 = 1; 816 817 if (iic_acquire_bus(sc->sc_tag, 0)) 818 return; 819 820 if (*props & PROP_CRITMAX) { 821 if (edata->sensor == ADMTEMP_INT) 822 cmd = ADM1032_INT_THERM; 823 else 824 cmd = ADM1032_EXT_THERM; 825 if (limits == NULL) /* Restore default */ 826 sdata = sc->sc_thermlim[edata->sensor]; 827 else 828 admtemp_encode_temp(limits->sel_critmax, &sdata, 829 &xdata, 0); 830 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata); 831 } 832 833 if (*props & PROP_WARNMAX) { 834 if (edata->sensor == ADMTEMP_INT) 835 cmd = ADM1021_INT_HIGH_WRITE; 836 else 837 cmd = ADM1021_EXT_HIGH_WRITE; 838 839 if (limits == NULL) { /* Restore defaults */ 840 sdata = sc->sc_highlim[edata->sensor]; 841 xdata = sc->sc_highlim2; 842 } else 843 admtemp_encode_temp(limits->sel_warnmax, &sdata, 844 &xdata, ext11); 845 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata); 846 847 if (ext11) { 848 cmd = ADM1023_EXT_HIGH2; 849 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &xdata); 850 } 851 } 852 853 if (*props & PROP_WARNMIN) { 854 if (edata->sensor == ADMTEMP_INT) 855 cmd = ADM1021_INT_LOW_WRITE; 856 else 857 cmd = ADM1021_EXT_LOW_WRITE; 858 if (limits == NULL) { 859 sdata = sc->sc_lowlim[edata->sensor]; 860 xdata = sc->sc_lowlim2; 861 } else 862 admtemp_encode_temp(limits->sel_warnmin, &sdata, 863 &xdata, ext11); 864 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &sdata); 865 866 if (ext11) { 867 cmd = ADM1023_EXT_LOW2; 868 admtemp_exec(sc, I2C_OP_WRITE_WITH_STOP, &cmd, &xdata); 869 } 870 } 871 872 iic_release_bus(sc->sc_tag, 0); 873 } 874
Indexes created Mon Sep 29 15:09:53 GMT 2025