adm1021.c revision 1.28
1 /* $NetBSD: adm1021.c,v 1.28 2021/06/15 04:41:01 mlelstv 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.28 2021/06/15 04:41:01 mlelstv 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 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 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 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 nonexistant 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 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_cstring_nocopy(sc->sc_prop, "s00", &desc)) { 413 strncpy(iname, desc, 64); 414 } 415 416 if (prop_dictionary_get_cstring_nocopy(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 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 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 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 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 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 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 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 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
Indexes created Mon Sep 29 21:09:56 GMT 2025