1 /* $NetBSD: adm1026.c,v 1.17 2026/05/27 10:30:27 jdc Exp $ */ 2 3 /*- 4 * Copyright (c) 2015 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Julian Coleman. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: adm1026.c,v 1.17 2026/05/27 10:30:27 jdc Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/device.h> 38 #include <sys/kernel.h> 39 #include <sys/sysctl.h> 40 41 #include <dev/sysmon/sysmonvar.h> 42 43 #include <dev/i2c/i2cvar.h> 44 #include <dev/i2c/adm1026reg.h> 45 46 /* Temperature sensors descriptions and registers */ 47 struct adm1026_temp_info { 48 const char* desc; 49 uint8_t v_reg, t_reg, h_reg, l_reg, check_tdm2; 50 }; 51 52 static struct adm1026_temp_info adm1026_temps_table[] = { 53 { "internal", ADM1026_INT_TEMP_VAL, ADM1026_INT_THERM_HIGH, 54 ADM1026_INT_TEMP_HIGH, ADM1026_INT_TEMP_LOW, 0 }, 55 { "external 1", ADM1026_TDM1_VAL, ADM1026_TDM1_THERM_HIGH, 56 ADM1026_TDM1_HIGH, ADM1026_TDM1_LOW, 0 }, 57 { "external 2", ADM1026_TDM2_AIN9_VAL, ADM1026_TDM2_THERM_HIGH, 58 ADM1026_TDM2_AIN9_HIGH, ADM1026_TDM2_AIN9_LOW, 1 }, 59 }; 60 61 /* Voltage/analog sensors descriptions and registers */ 62 struct adm1026_volts_info { 63 const char* desc; 64 int incr, offset; 65 uint8_t v_reg, h_reg, l_reg, check_tdm2; 66 }; 67 68 /* Voltage maximums (in mV) from datasheet table 7 divided by 254 increments */ 69 static struct adm1026_volts_info adm1026_volts_table[] = { 70 { "Vbatt", 15685, 0, ADM1026_VBAT_VAL, 71 ADM1026_VBATT_HIGH, ADM1026_VBATT_LOW, 0 }, 72 { "V3.3 standby", 17413, 0, ADM1026_33VSTBY_VAL, 73 ADM1026_33V_STBY_HIGH, ADM1026_33V_STBY_LOW, 0 }, 74 { "V3.3 main", 17413, 0, ADM1026_33VMAIN_VAL, 75 ADM1026_33V_MAIN_HIGH, ADM1026_33V_MAIN_LOW, 0 }, 76 { "V5.0", 26145, 0, ADM1026_50V_VAL, 77 ADM1026_50V_HIGH, ADM1026_50V_LOW, 0 }, 78 { "Vccp", 11763, 0, ADM1026_VCCP_VAL, 79 ADM1026_VCCP_HIGH, ADM1026_VCCP_LOW, 0 }, 80 { "V+12", 62748, 0, ADM1026_12V_VAL, 81 ADM1026_12V_HIGH, ADM1026_12V_LOW, 0 }, 82 { "V-12", 72268, -15928000, ADM1026_N12V_VAL, 83 ADM1026_N12V_HIGH, ADM1026_N12V_LOW,0 }, 84 { "V3.0 0", 11763, 0, ADM1026_AIN_VAL(0), 85 ADM1026_AIN_HIGH(0), ADM1026_AIN_LOW(0), 0 }, 86 { "V3.0 1", 11763, 0, ADM1026_AIN_VAL(1), 87 ADM1026_AIN_HIGH(1), ADM1026_AIN_LOW(1), 0 }, 88 { "V3.0 2", 11763, 0, ADM1026_AIN_VAL(2), 89 ADM1026_AIN_HIGH(2), ADM1026_AIN_LOW(2), 0 }, 90 { "V3.0 3", 11763, 0, ADM1026_AIN_VAL(3), 91 ADM1026_AIN_HIGH(3), ADM1026_AIN_LOW(3), 0 }, 92 { "V3.0 4", 11763, 0, ADM1026_AIN_VAL(4), 93 ADM1026_AIN_HIGH(4), ADM1026_AIN_LOW(4), 0 }, 94 { "V3.0 5", 11763, 0, ADM1026_AIN_VAL(5), 95 ADM1026_AIN_HIGH(5), ADM1026_AIN_LOW(5), 0 }, 96 { "V2.5 0", 9803, 0, ADM1026_AIN_VAL(6), 97 ADM1026_AIN_HIGH(6), ADM1026_AIN_LOW(6), 0 }, 98 { "V2.5 1", 9803, 0, ADM1026_AIN_VAL(7), 99 ADM1026_AIN_HIGH(7), ADM1026_AIN_LOW(7), 0 }, 100 { "V2.5 2", 9803, 0, ADM1026_AIN8_VAL, 101 ADM1026_AIN8_HIGH, ADM1026_AIN8_LOW, 1 }, 102 { "V2.5 3", 9803, 0, ADM1026_TDM2_AIN9_VAL, 103 ADM1026_TDM2_AIN9_HIGH, ADM1026_TDM2_AIN9_LOW, 1 }, 104 }; 105 106 #define VBATT_NUM 0 /* Vbatt is first in the table */ 107 #define VBATT_MIN 0x60 /* 1.5V is the minimum valid reading */ 108 109 /* Maximum number of each type of sensor */ 110 #define ADM1026_MAX_FANS 8 111 #define ADM1026_MAX_TEMPS 3 112 #define ADM1026_MAX_VOLTS (sizeof(adm1026_volts_table) / \ 113 sizeof (adm1026_volts_table[0])) 114 #define ADM1026_MAX_SENSORS \ 115 (ADM1026_MAX_FANS + ADM1026_MAX_TEMPS + ADM1026_MAX_VOLTS) 116 117 /* Fan/temp/volt sensor offsets */ 118 #define ADM1026_FAN_NUM(x) (x) 119 #define ADM1026_TEMP_NUM(x) (x + ADM1026_MAX_FANS) 120 #define ADM1026_VOLT_NUM(x) (x + ADM1026_MAX_FANS + ADM1026_MAX_TEMPS) 121 122 /* Fan conversions */ 123 #define VAL_TO_SPEED(val, div) (1350000 / (val * div)) 124 #define SPEED_TO_VAL(spd, div) ((1350000 / (spd * div)) & 0xff) 125 126 /* Temperature conversions */ 127 #define VAL_TO_TEMP(val) (val & 0x80 ? \ 128 145150000 + 1000000 * (val & 0x7f) : /* -128C */ \ 129 273150000 + 1000000 * val) 130 #define TEMP_TO_VAL(temp) ((temp < 273150000 ? \ 131 ((temp - 145150000) / 1000000) ^ 0x80 : \ 132 (temp - 273150000) / 1000000) & 0xff) 133 134 /* Voltage conversions */ 135 #define VAL_TO_VOLT(val, num) (val * adm1026_volts_table[num].incr + \ 136 adm1026_volts_table[num].offset) 137 #define VOLT_TO_VAL(volt, num) (((volt - adm1026_volts_table[num].offset) / \ 138 adm1026_volts_table[num].incr) & 0xff) 139 140 141 struct adm1026_softc { 142 device_t sc_dev; 143 i2c_tag_t sc_tag; 144 int sc_address; 145 bool sc_monitor; 146 147 uint8_t sc_cfg[2]; 148 int sc_fandiv[ADM1026_MAX_FANS]; 149 int sc_nfans, sc_ntemps, sc_nvolts; 150 int sc_map[ADM1026_MAX_SENSORS]; /* Map sysmon numbers to sensors */ 151 struct sysmon_envsys *sc_sme; 152 envsys_data_t sc_sensor[ADM1026_MAX_SENSORS]; 153 uint8_t sc_thermlim[ADM1026_MAX_SENSORS]; 154 uint8_t sc_highlim[ADM1026_MAX_SENSORS]; 155 uint8_t sc_lowlim[ADM1026_MAX_SENSORS]; 156 }; 157 158 static int adm1026_match(device_t, cfdata_t, void *); 159 static int adm1026_ident(i2c_tag_t, i2c_addr_t, int, uint8_t*); 160 static void adm1026_attach(device_t, device_t, void *); 161 static int adm1026_detach(device_t, int); 162 bool adm1026_pmf_suspend(device_t, const pmf_qual_t *); 163 bool adm1026_pmf_resume(device_t, const pmf_qual_t *); 164 165 static int adm1026_start_monitor(struct adm1026_softc *, int, uint8_t); 166 static int adm1026_stop_monitor(struct adm1026_softc *); 167 static int adm1026_setup_fans(struct adm1026_softc *, int, uint8_t); 168 static int adm1026_setup_temps(struct adm1026_softc *); 169 static int adm1026_setup_volts(struct adm1026_softc *); 170 171 void adm1026_refresh(struct sysmon_envsys *, envsys_data_t *); 172 static void adm1026_read_fan_val(struct adm1026_softc *, envsys_data_t *); 173 static void adm1026_read_temp_val(struct adm1026_softc *, envsys_data_t *); 174 static void adm1026_read_volt_val(struct adm1026_softc *, envsys_data_t *); 175 176 void adm1026_get_limits(struct sysmon_envsys *, envsys_data_t *, 177 sysmon_envsys_lim_t *, uint32_t *); 178 void adm1026_set_limits(struct sysmon_envsys *, envsys_data_t *, 179 sysmon_envsys_lim_t *, uint32_t *); 180 static void adm1026_get_fan_limits(struct adm1026_softc *, 181 envsys_data_t *, sysmon_envsys_lim_t *, uint32_t *); 182 static void adm1026_get_temp_limits(struct adm1026_softc *, 183 envsys_data_t *, sysmon_envsys_lim_t *, uint32_t *); 184 static void adm1026_get_volt_limits(struct adm1026_softc *, 185 envsys_data_t *, sysmon_envsys_lim_t *, uint32_t *); 186 static void adm1026_set_fan_limits(struct adm1026_softc *, 187 envsys_data_t *, sysmon_envsys_lim_t *, uint32_t *); 188 static void adm1026_set_temp_limits(struct adm1026_softc *, 189 envsys_data_t *, sysmon_envsys_lim_t *, uint32_t *); 190 static void adm1026_set_volt_limits(struct adm1026_softc *, 191 envsys_data_t *, sysmon_envsys_lim_t *, uint32_t *); 192 193 static int adm1026_read_reg_int(i2c_tag_t, i2c_addr_t, uint8_t, uint8_t *); 194 static int adm1026_write_reg(struct adm1026_softc *, uint8_t, uint8_t); 195 196 static inline int 197 adm1026_read_reg(struct adm1026_softc *sc, uint8_t reg, uint8_t *val) 198 { 199 return adm1026_read_reg_int(sc->sc_tag, sc->sc_address, reg, val); 200 } 201 202 CFATTACH_DECL_NEW(adm1026hm, sizeof(struct adm1026_softc), 203 adm1026_match, adm1026_attach, adm1026_detach, NULL); 204 205 static const struct device_compatible_entry compat_data[] = { 206 { .compat = "i2c-adm1026" }, 207 DEVICE_COMPAT_EOL 208 }; 209 210 static int 211 adm1026_match(device_t parent, cfdata_t cf, void *aux) 212 { 213 struct i2c_attach_args *ia = aux; 214 int match_result; 215 uint8_t rev; 216 217 if (iic_use_direct_match(ia, cf, compat_data, &match_result)) 218 return match_result; 219 220 if (ia->ia_addr == ADM1026_ADDR1 221 && adm1026_ident(ia->ia_tag, ia->ia_addr, 1, &rev)) 222 return I2C_MATCH_ADDRESS_AND_PROBE; 223 224 return 0; 225 } 226 227 static int 228 adm1026_ident(i2c_tag_t tag, i2c_addr_t addr, int probe_only, uint8_t *rev) 229 { 230 uint8_t reg, val; 231 int err; 232 233 /* Manufacturer ID and revision/stepping */ 234 reg = ADM1026_ID; 235 err = adm1026_read_reg_int(tag, addr, reg, &val); 236 if (err || val != ADM1026_MANF_ID) { 237 if (!probe_only) 238 aprint_verbose("adm1026_ident: " 239 "manufacturer ID invalid or missing\n"); 240 return 0; 241 } 242 reg = ADM1026_REV; 243 err = adm1026_read_reg_int(tag, addr, reg, rev); 244 if (err || ADM1026_REVISION(*rev) != ADM1026_MANF_REV) { 245 if (!probe_only) 246 aprint_verbose("adm1026_ident: " 247 "manufacturer revision invalid or missing\n"); 248 return 0; 249 } 250 return 1; 251 } 252 253 static void 254 adm1026_attach(device_t parent, device_t self, void *aux) 255 { 256 struct adm1026_softc *sc = device_private(self); 257 struct i2c_attach_args *ia = aux; 258 prop_dictionary_t props = device_properties(self); 259 uint8_t reg, val, rev, fan_div2, fan_mask; 260 int div2_val; 261 262 sc->sc_tag = ia->ia_tag; 263 sc->sc_address = ia->ia_addr; 264 sc->sc_dev = self; 265 266 if (prop_dictionary_get_uint8(props, "fan_div2", &fan_div2) != 0) 267 div2_val = fan_div2; 268 else 269 div2_val = -1; 270 if (prop_dictionary_get_uint8(props, "fan_mask", &fan_mask) == 0) 271 fan_mask = 0x00; /* 4 + 4 fans */ 272 273 (void) adm1026_ident(sc->sc_tag, sc->sc_address, 0, &rev); 274 aprint_normal(": ADM1026 hardware monitor: rev. 0x%x, step. 0x%x\n", 275 ADM1026_REVISION(rev), ADM1026_STEPPING(rev)); 276 277 #if 0 /* ADM1026_DEBUG */ 278 do { 279 int i; 280 281 printf("Register dump\n"); 282 for (i = 0; i < 0x70; i++) { 283 if (i == 0x14 || i == 0x15) 284 /* Don't read test registers */ 285 continue; 286 adm1026_read_reg(sc, i, &val); 287 printf("reg %02x: %02x\n", i, val); 288 } 289 } while (0); 290 #endif 291 292 /* 293 * Start monitoring if not already monitoring. 294 * Wait 1.8s for the fan readings to stabilise. 295 */ 296 reg = ADM1026_CONF1; 297 if (adm1026_read_reg(sc, reg, &val) != 0) { 298 aprint_error_dev(sc->sc_dev, ": unable to read conf1\n"); 299 return; 300 } 301 if (!(val & ADM1026_CONF1_MONITOR)) { 302 sc->sc_monitor = 1; 303 aprint_normal_dev(sc->sc_dev, 304 ": starting monitoring, waiting 1.8s for readings\n"); 305 val |= ADM1026_CONF1_MONITOR; 306 if (adm1026_start_monitor(sc, 0, val)) 307 return; 308 } else 309 sc->sc_monitor = 0; 310 sc->sc_cfg[0] = val; 311 312 sc->sc_sme = sysmon_envsys_create(); 313 314 sc->sc_nfans = 0; 315 sc->sc_ntemps = 0; 316 sc->sc_nvolts = 0; 317 if (adm1026_setup_fans(sc, div2_val, fan_mask)) 318 goto bad; 319 if (adm1026_setup_temps(sc)) 320 goto bad; 321 if (adm1026_setup_volts(sc)) 322 goto bad; 323 aprint_normal_dev(self, "%d fans, %d temperatures, %d voltages\n", 324 sc->sc_nfans, sc->sc_ntemps, sc->sc_nvolts); 325 326 sc->sc_sme->sme_name = device_xname(self); 327 sc->sc_sme->sme_cookie = sc; 328 sc->sc_sme->sme_refresh = adm1026_refresh; 329 sc->sc_sme->sme_get_limits = adm1026_get_limits; 330 sc->sc_sme->sme_set_limits = adm1026_set_limits; 331 if (sysmon_envsys_register(sc->sc_sme)) { 332 aprint_error_dev(self, 333 "unable to register with sysmon\n"); 334 goto bad; 335 } 336 337 if (!pmf_device_register(self, adm1026_pmf_suspend, adm1026_pmf_resume)) 338 aprint_error_dev(self, "couldn't establish power handler\n"); 339 340 return; 341 342 bad: 343 sysmon_envsys_destroy(sc->sc_sme); 344 sc->sc_sme = NULL; 345 return; 346 } 347 348 /* Stop (suspend/detach) and restart (resume) monitoring, if we started it. */ 349 bool 350 adm1026_pmf_suspend(device_t dev, const pmf_qual_t *qual) 351 { 352 353 struct adm1026_softc *sc = device_private(dev); 354 355 if (sc->sc_monitor == 1) { 356 if (adm1026_stop_monitor(sc)) 357 return false; 358 } 359 return true; 360 } 361 362 bool 363 adm1026_pmf_resume(device_t dev, const pmf_qual_t *qual) 364 { 365 struct adm1026_softc *sc = device_private(dev); 366 367 if (sc->sc_monitor == 1) { 368 if (adm1026_start_monitor(sc, 1, 0)) 369 return false; 370 } 371 return true; 372 } 373 374 static int 375 adm1026_detach(device_t self, int flags) 376 { 377 struct adm1026_softc *sc = device_private(self); 378 379 pmf_device_deregister(self); 380 381 if (sc->sc_sme != NULL) 382 sysmon_envsys_unregister(sc->sc_sme); 383 384 if (sc->sc_monitor == 1) { 385 if (!adm1026_stop_monitor(sc)) 386 return 1; 387 } 388 return 0; 389 } 390 391 static int adm1026_start_monitor(struct adm1026_softc *sc, int do_read, 392 uint8_t newval) 393 { 394 uint8_t reg, val; 395 396 reg = ADM1026_CONF1; 397 if (do_read) { 398 if (adm1026_read_reg(sc, reg, &val) != 0) { 399 aprint_error_dev(sc->sc_dev, 400 ": unable to read conf1\n"); 401 return 1; 402 } 403 val |= ADM1026_CONF1_MONITOR; 404 } else 405 val = newval; 406 407 if (adm1026_write_reg(sc, reg, val) != 0) { 408 aprint_error_dev(sc->sc_dev, ": unable to write conf1\n"); 409 return 1; 410 } 411 412 delay(1800000); 413 414 return 0; 415 } 416 417 static int adm1026_stop_monitor(struct adm1026_softc *sc) 418 { 419 uint8_t reg, val; 420 421 reg = ADM1026_CONF1; 422 if (adm1026_read_reg(sc, reg, &val) != 0) { 423 device_printf(sc->sc_dev, ": unable to read conf1\n"); 424 return 1; 425 } 426 427 val &= ~ADM1026_CONF1_MONITOR; 428 if (adm1026_write_reg(sc, reg, val) != 0) { 429 device_printf(sc->sc_dev, ": unable to write conf1\n"); 430 return 1; 431 } 432 return 0; 433 } 434 435 static int 436 adm1026_setup_fans(struct adm1026_softc *sc, int div2_val, uint8_t fan_mask) 437 { 438 int i, map, snum; 439 uint8_t reg, div1, div2, val; 440 441 /* Read fan-related registers (configuration and divisors) */ 442 reg = ADM1026_CONF2; 443 if (adm1026_read_reg(sc, reg, &sc->sc_cfg[1]) != 0) { 444 aprint_error_dev(sc->sc_dev, "unable to read conf2\n"); 445 return 1; 446 } 447 reg = ADM1026_FAN_DIV1; 448 if (adm1026_read_reg(sc, reg, &div1) != 0) { 449 aprint_error_dev(sc->sc_dev, "unable to read fan_div1\n"); 450 return 1; 451 } 452 sc->sc_fandiv[0] = 1 << ADM1026_FAN0_DIV(div1); 453 sc->sc_fandiv[1] = 1 << ADM1026_FAN1_DIV(div1); 454 sc->sc_fandiv[2] = 1 << ADM1026_FAN2_DIV(div1); 455 sc->sc_fandiv[3] = 1 << ADM1026_FAN3_DIV(div1); 456 if (div2_val < 0) { 457 reg = ADM1026_FAN_DIV2; 458 if (adm1026_read_reg(sc, reg, &div2) != 0) { 459 aprint_error_dev(sc->sc_dev, 460 "unable to read fan_div2\n"); 461 return 1; 462 } 463 } else 464 div2 = div2_val; 465 sc->sc_fandiv[4] = 1 << ADM1026_FAN4_DIV(div2); 466 sc->sc_fandiv[5] = 1 << ADM1026_FAN5_DIV(div2); 467 sc->sc_fandiv[6] = 1 << ADM1026_FAN6_DIV(div2); 468 sc->sc_fandiv[7] = 1 << ADM1026_FAN7_DIV(div2); 469 for (i = 0; i < ADM1026_MAX_FANS; i++) 470 if (sc->sc_fandiv[i] < 1) 471 sc->sc_fandiv[i] = 1; 472 473 /* 474 * Check configuration2 register to see which pins are fans. 475 * This can be overridden by the fan_mask property to tell us 476 * how many fans are present in each group (numbers 0-3 and 4-7). 477 */ 478 for (i = 0; i < ADM1026_MAX_FANS; i++) { 479 /* Check configuration2 register to see which pins are fans. */ 480 if (!ADM1026_PIN_IS_FAN(sc->sc_cfg[1], i)) 481 continue; 482 /* Check mask property to override configuration. */ 483 if (!ADM1026_PIN_IS_FAN(fan_mask, i)) 484 continue; 485 486 snum = ADM1026_FAN_NUM(i); 487 488 /* Store initial limit */ 489 reg = ADM1026_FAN_HIGH(i); 490 if (adm1026_read_reg(sc, reg, &val) != 0) { 491 aprint_error_dev(sc->sc_dev, 492 "unable to read fan %d limit\n", i); 493 return 1; 494 } 495 sc->sc_highlim[snum] = val; 496 497 /* Set up sysmon sensor */ 498 sc->sc_sensor[snum].units = ENVSYS_SFANRPM; 499 sc->sc_sensor[snum].state = ENVSYS_SINVALID; 500 sc->sc_sensor[snum].flags = ENVSYS_FMONLIMITS; 501 snprintf(sc->sc_sensor[snum].desc, 502 sizeof(sc->sc_sensor[snum].desc), "fan %d", snum); 503 if (sysmon_envsys_sensor_attach( 504 sc->sc_sme, &sc->sc_sensor[snum])) { 505 aprint_error_dev(sc->sc_dev, 506 "unable to attach fan %d at sysmon\n", i); 507 return 1; 508 } 509 510 map = sc->sc_sensor[snum].sensor; 511 sc->sc_map[map] = i; 512 sc->sc_nfans++; 513 } 514 return 0; 515 } 516 517 static int 518 adm1026_setup_temps(struct adm1026_softc *sc) 519 { 520 int i, map, snum; 521 uint8_t reg, val; 522 523 for (i = 0; i < ADM1026_MAX_TEMPS; i++) { 524 /* Check configuration1 register to see if TDM2 is configured */ 525 if (adm1026_temps_table[i].check_tdm2 && 526 !ADM1026_PIN_IS_TDM2(sc->sc_cfg[0])) 527 continue; 528 529 snum = ADM1026_TEMP_NUM(i); 530 531 /* Store initial limits */ 532 reg = adm1026_temps_table[i].t_reg; 533 if (adm1026_read_reg(sc, reg, &val) != 0) { 534 aprint_error_dev(sc->sc_dev, 535 "unable to read temp %d therm limit\n", i); 536 return 1; 537 } 538 sc->sc_thermlim[snum] = val; 539 540 reg = adm1026_temps_table[i].h_reg; 541 if (adm1026_read_reg(sc, reg, &val) != 0) { 542 aprint_error_dev(sc->sc_dev, 543 "unable to read temp %d high limit\n", i); 544 return 1; 545 } 546 sc->sc_highlim[snum] = val; 547 548 reg = adm1026_temps_table[i].l_reg; 549 if (adm1026_read_reg(sc, reg, &val) != 0) { 550 aprint_error_dev(sc->sc_dev, 551 "unable to read temp %d low limit\n", i); 552 return 1; 553 } 554 sc->sc_lowlim[snum] = val; 555 556 /* Set up sysmon sensor */ 557 strlcpy(sc->sc_sensor[snum].desc, 558 adm1026_temps_table[i].desc, 559 sizeof(sc->sc_sensor[snum].desc)); 560 sc->sc_sensor[snum].units = ENVSYS_STEMP; 561 sc->sc_sensor[snum].state = ENVSYS_SINVALID; 562 sc->sc_sensor[snum].flags = 563 ENVSYS_FMONLIMITS | ENVSYS_FHAS_ENTROPY; 564 if (sysmon_envsys_sensor_attach( 565 sc->sc_sme, &sc->sc_sensor[snum])) { 566 aprint_error_dev(sc->sc_dev, 567 "unable to attach temp %d at sysmon\n", i); 568 return 1; 569 } 570 map = sc->sc_sensor[snum].sensor; 571 sc->sc_map[map] = i; 572 sc->sc_ntemps++; 573 } 574 return 0; 575 } 576 577 static int 578 adm1026_setup_volts(struct adm1026_softc *sc) 579 { 580 int i, map, snum; 581 uint8_t reg, val; 582 583 for (i = 0; i < ADM1026_MAX_VOLTS; i++) { 584 /* Check configuration1 register to see if TDM2 is configured */ 585 if (adm1026_volts_table[i].check_tdm2 && 586 ADM1026_PIN_IS_TDM2(sc->sc_cfg[0])) 587 continue; 588 589 snum = ADM1026_VOLT_NUM(i); 590 591 /* Store initial limits */ 592 reg = adm1026_volts_table[i].h_reg; 593 if (adm1026_read_reg(sc, reg, &val) != 0) { 594 aprint_error_dev(sc->sc_dev, 595 "unable to read volt %d high limit\n", i); 596 return 1; 597 } 598 sc->sc_highlim[snum] = val; 599 600 reg = adm1026_volts_table[i].l_reg; 601 if (adm1026_read_reg(sc, reg, &val) != 0) { 602 aprint_error_dev(sc->sc_dev, 603 "unable to read volt %d low limit\n", i); 604 return 1; 605 } 606 sc->sc_lowlim[snum] = val; 607 608 /* Set up sysmon sensor */ 609 strlcpy(sc->sc_sensor[snum].desc, 610 adm1026_volts_table[i].desc, 611 sizeof(sc->sc_sensor[snum].desc)); 612 sc->sc_sensor[snum].units = ENVSYS_SVOLTS_DC; 613 sc->sc_sensor[snum].state = ENVSYS_SINVALID; 614 sc->sc_sensor[snum].flags = ENVSYS_FMONLIMITS; 615 if (sysmon_envsys_sensor_attach( 616 sc->sc_sme, &sc->sc_sensor[snum])) { 617 sysmon_envsys_destroy(sc->sc_sme); 618 return 1; 619 } 620 map = sc->sc_sensor[snum].sensor; 621 sc->sc_map[map] = i; 622 sc->sc_nvolts++; 623 } 624 return 0; 625 } 626 627 void 628 adm1026_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 629 { 630 struct adm1026_softc *sc = sme->sme_cookie; 631 632 if (edata->sensor < sc->sc_nfans) 633 adm1026_read_fan_val(sc, edata); 634 else if (edata->sensor < sc->sc_nfans + sc->sc_ntemps) 635 adm1026_read_temp_val(sc, edata); 636 else 637 adm1026_read_volt_val(sc, edata); 638 } 639 640 static void 641 adm1026_read_fan_val(struct adm1026_softc *sc, envsys_data_t *edata) 642 { 643 int fan = sc->sc_map[edata->sensor]; 644 uint8_t reg, val; 645 646 reg = ADM1026_FAN_VAL(fan); 647 if (adm1026_read_reg(sc, reg, &val) != 0) { 648 edata->state = ENVSYS_SINVALID; 649 return; 650 } 651 if (val == 0xff || val == 0x00) /* Fan missing or stopped */ 652 edata->value_cur = 0; 653 else 654 edata->value_cur = VAL_TO_SPEED(val, sc->sc_fandiv[fan]); 655 edata->state = ENVSYS_SVALID; 656 } 657 658 static void 659 adm1026_read_temp_val(struct adm1026_softc *sc, envsys_data_t *edata) 660 { 661 int temp = sc->sc_map[edata->sensor]; 662 uint8_t reg, val; 663 664 reg = adm1026_temps_table[temp].v_reg; 665 if (adm1026_read_reg(sc, reg, &val) != 0) { 666 edata->state = ENVSYS_SINVALID; 667 return; 668 } 669 670 edata->value_cur = VAL_TO_TEMP(val); 671 edata->state = ENVSYS_SVALID; 672 } 673 674 static void 675 adm1026_read_volt_val(struct adm1026_softc *sc, envsys_data_t *edata) 676 { 677 int volt = sc->sc_map[edata->sensor]; 678 uint8_t reg, val; 679 680 reg = adm1026_volts_table[volt].v_reg; 681 if (adm1026_read_reg(sc, reg, &val) != 0) { 682 edata->state = ENVSYS_SINVALID; 683 return; 684 } 685 /* Vbatt is not valid for < 1.5V */ 686 if (volt == VBATT_NUM && val < VBATT_MIN) 687 edata->state = ENVSYS_SINVALID; 688 edata->value_cur = VAL_TO_VOLT(val, volt); 689 edata->state = ENVSYS_SVALID; 690 } 691 692 void 693 adm1026_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata, 694 sysmon_envsys_lim_t *limits, uint32_t *props) 695 { 696 struct adm1026_softc *sc = sme->sme_cookie; 697 698 if (edata->sensor < sc->sc_nfans) 699 adm1026_get_fan_limits(sc, edata, limits, props); 700 else if (edata->sensor < sc->sc_nfans + sc->sc_ntemps) 701 adm1026_get_temp_limits(sc, edata, limits, props); 702 else 703 adm1026_get_volt_limits(sc, edata, limits, props); 704 } 705 706 static void 707 adm1026_get_fan_limits(struct adm1026_softc *sc, envsys_data_t *edata, 708 sysmon_envsys_lim_t *limits, uint32_t *props) 709 { 710 int fan = sc->sc_map[edata->sensor]; 711 uint8_t reg, val; 712 713 /* The chip measures intervals, so the high limit is for low speed. */ 714 *props &= ~PROP_WARNMIN; 715 716 reg = ADM1026_FAN_HIGH(fan); 717 if (adm1026_read_reg(sc, reg, &val) != 0) 718 return; 719 if (val == 0x00) /* No limit */ 720 return; 721 limits->sel_warnmin = VAL_TO_SPEED(val, sc->sc_fandiv[fan]); 722 *props |= PROP_WARNMIN; 723 } 724 725 static void 726 adm1026_get_temp_limits(struct adm1026_softc *sc, envsys_data_t *edata, 727 sysmon_envsys_lim_t *limits, uint32_t *props) 728 { 729 int temp = sc->sc_map[edata->sensor]; 730 uint8_t reg, val; 731 732 *props &= ~(PROP_CRITMAX | PROP_WARNMAX | PROP_WARNMIN); 733 734 reg = adm1026_temps_table[temp].t_reg; 735 if (adm1026_read_reg(sc, reg, &val) != 0) 736 return; 737 limits->sel_critmax = VAL_TO_TEMP(val); 738 *props |= PROP_CRITMAX; 739 740 reg = adm1026_temps_table[temp].h_reg; 741 if (adm1026_read_reg(sc, reg, &val) != 0) 742 return; 743 limits->sel_warnmax = VAL_TO_TEMP(val); 744 *props |= PROP_WARNMAX; 745 746 reg = adm1026_temps_table[temp].l_reg; 747 if (adm1026_read_reg(sc, reg, &val) != 0) 748 return; 749 limits->sel_warnmin = VAL_TO_TEMP(val); 750 *props |= PROP_WARNMIN; 751 } 752 753 static void 754 adm1026_get_volt_limits(struct adm1026_softc *sc, envsys_data_t *edata, 755 sysmon_envsys_lim_t *limits, uint32_t *props) 756 { 757 int volt = sc->sc_map[edata->sensor]; 758 uint8_t reg, val; 759 760 *props &= ~(PROP_WARNMAX | PROP_WARNMIN); 761 762 reg = adm1026_volts_table[volt].h_reg; 763 if (adm1026_read_reg(sc, reg, &val) != 0) 764 return; 765 limits->sel_warnmax = VAL_TO_VOLT(val, volt); 766 *props |= PROP_WARNMAX; 767 768 reg = adm1026_volts_table[volt].l_reg; 769 if (adm1026_read_reg(sc, reg, &val) != 0) 770 return; 771 limits->sel_warnmin = VAL_TO_VOLT(val, volt); 772 *props |= PROP_WARNMIN; 773 } 774 775 void 776 adm1026_set_limits(struct sysmon_envsys *sme, envsys_data_t *edata, 777 sysmon_envsys_lim_t *limits, uint32_t *props) 778 { 779 struct adm1026_softc *sc = sme->sme_cookie; 780 781 if (edata->sensor < sc->sc_nfans) 782 adm1026_set_fan_limits(sc, edata, limits, props); 783 else if (edata->sensor < sc->sc_nfans + sc->sc_ntemps) 784 adm1026_set_temp_limits(sc, edata, limits, props); 785 else 786 adm1026_set_volt_limits(sc, edata, limits, props); 787 } 788 789 static void 790 adm1026_set_fan_limits(struct adm1026_softc *sc, envsys_data_t *edata, 791 sysmon_envsys_lim_t *limits, uint32_t *props) 792 { 793 int fan, snum; 794 uint8_t reg, val; 795 796 fan = sc->sc_map[edata->sensor]; 797 snum = ADM1026_FAN_NUM(fan); 798 799 if (limits == NULL || *props & PROP_WARNMIN) { 800 if (limits == NULL) /* Restore defaults */ 801 val = sc->sc_highlim[snum]; 802 else { 803 if (limits->sel_warnmin == 0) 804 val = 0xff; 805 else 806 val = SPEED_TO_VAL(limits->sel_warnmin, 807 sc->sc_fandiv[fan]); 808 } 809 reg = ADM1026_FAN_HIGH(fan); 810 adm1026_write_reg(sc, reg, val); 811 } 812 } 813 814 static void 815 adm1026_set_temp_limits(struct adm1026_softc *sc, envsys_data_t *edata, 816 sysmon_envsys_lim_t *limits, uint32_t *props) 817 { 818 int temp, snum; 819 uint8_t reg, val; 820 821 temp = sc->sc_map[edata->sensor]; 822 snum = ADM1026_TEMP_NUM(temp); 823 824 if (limits == NULL || *props & PROP_CRITMAX) { 825 if (limits == NULL) /* Restore defaults */ 826 val = sc->sc_highlim[snum]; 827 else { 828 val = TEMP_TO_VAL(limits->sel_critmax); 829 } 830 reg = adm1026_temps_table[temp].h_reg; 831 adm1026_write_reg(sc, reg, val); 832 } 833 834 if (limits == NULL || *props & PROP_WARNMAX) { 835 if (limits == NULL) /* Restore defaults */ 836 val = sc->sc_thermlim[snum]; 837 else { 838 val = TEMP_TO_VAL(limits->sel_warnmax); 839 } 840 reg = adm1026_temps_table[temp].t_reg; 841 adm1026_write_reg(sc, reg, val); 842 } 843 844 if (limits == NULL || *props & PROP_WARNMIN) { 845 if (limits == NULL) /* Restore defaults */ 846 val = sc->sc_lowlim[snum]; 847 else { 848 val = TEMP_TO_VAL(limits->sel_warnmin); 849 } 850 reg = adm1026_temps_table[temp].l_reg; 851 adm1026_write_reg(sc, reg, val); 852 } 853 } 854 855 static void 856 adm1026_set_volt_limits(struct adm1026_softc *sc, envsys_data_t *edata, 857 sysmon_envsys_lim_t *limits, uint32_t *props) 858 { 859 int volt, snum; 860 uint8_t reg, val; 861 862 volt = sc->sc_map[edata->sensor]; 863 snum = ADM1026_VOLT_NUM(volt); 864 865 if (limits == NULL || *props & PROP_WARNMAX) { 866 if (limits == NULL) /* Restore defaults */ 867 val = sc->sc_highlim[snum]; 868 else { 869 val = VOLT_TO_VAL(limits->sel_warnmax, volt); 870 } 871 reg = adm1026_volts_table[volt].h_reg; 872 adm1026_write_reg(sc, reg, val); 873 } 874 875 if (limits == NULL || *props & PROP_WARNMIN) { 876 if (limits == NULL) /* Restore defaults */ 877 val = sc->sc_lowlim[snum]; 878 else { 879 val = VOLT_TO_VAL(limits->sel_warnmin, volt); 880 } 881 reg = adm1026_volts_table[volt].l_reg; 882 adm1026_write_reg(sc, reg, val); 883 } 884 } 885 886 static int 887 adm1026_read_reg_int(i2c_tag_t tag, i2c_addr_t addr, uint8_t reg, uint8_t *val) 888 { 889 int err = 0; 890 891 if ((err = iic_acquire_bus(tag, 0)) != 0) 892 return err; 893 err = iic_exec(tag, I2C_OP_READ_WITH_STOP, addr, ®, 1, val, 1, 0); 894 iic_release_bus(tag, 0); 895 return err; 896 } 897 898 static int 899 adm1026_write_reg(struct adm1026_softc *sc, uint8_t reg, uint8_t val) 900 { 901 int err = 0; 902 903 if ((err = iic_acquire_bus(sc->sc_tag, 0)) != 0) 904 return err; 905 err = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_address, 906 ®, 1, &val, 1, 0); 907 iic_release_bus(sc->sc_tag, 0); 908 return err; 909 } 910
Indexes created Sun Oct 25 00:26:45 UTC 2026