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