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