fcu.c revision 1.6
1 /* $NetBSD: fcu.c,v 1.6 2025/07/01 14:13:13 macallan Exp $ */ 2 3 /*- 4 * Copyright (c) 2018 Michael Lorenz 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: fcu.c,v 1.6 2025/07/01 14:13:13 macallan Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/device.h> 35 #include <sys/conf.h> 36 #include <sys/bus.h> 37 #include <sys/kthread.h> 38 #include <sys/sysctl.h> 39 40 #include <dev/i2c/i2cvar.h> 41 42 #include <dev/sysmon/sysmonvar.h> 43 44 #include <dev/ofw/openfirm.h> 45 46 #include <macppc/dev/fancontrolvar.h> 47 48 #include "opt_fcu.h" 49 50 #ifdef FCU_DEBUG 51 #define DPRINTF printf 52 #else 53 #define DPRINTF if (0) printf 54 #endif 55 56 /* FCU registers, from OpenBSD's fcu.c */ 57 #define FCU_FAN_FAIL 0x0b /* fans states in bits 0<1-6>7 */ 58 #define FCU_FAN_ACTIVE 0x0d 59 #define FCU_FANREAD(x) 0x11 + (x)*2 60 #define FCU_FANSET(x) 0x10 + (x)*2 61 #define FCU_PWM_FAIL 0x2b 62 #define FCU_PWM_ACTIVE 0x2d 63 #define FCU_PWMREAD(x) 0x30 + (x)*2 64 65 66 typedef struct _fcu_fan { 67 int target; 68 int reg; 69 int base_rpm, max_rpm; 70 int step; 71 int duty; /* for pwm fans */ 72 } fcu_fan_t; 73 74 #define FCU_ZONE_CPU 0 75 #define FCU_ZONE_CASE 1 76 #define FCU_ZONE_DRIVEBAY 2 77 #define FCU_ZONE_COUNT 3 78 79 struct fcu_softc { 80 device_t sc_dev; 81 i2c_tag_t sc_i2c; 82 i2c_addr_t sc_addr; 83 struct sysctlnode *sc_sysctl_me; 84 struct sysmon_envsys *sc_sme; 85 envsys_data_t sc_sensors[32]; 86 int sc_nsensors; 87 fancontrol_zone_t sc_zones[FCU_ZONE_COUNT]; 88 fcu_fan_t sc_fans[FANCONTROL_MAX_FANS]; 89 int sc_nfans; 90 lwp_t *sc_thread; 91 bool sc_dying, sc_pwm; 92 uint8_t sc_eeprom0[160]; 93 uint8_t sc_eeprom1[160]; 94 }; 95 96 static int fcu_match(device_t, cfdata_t, void *); 97 static void fcu_attach(device_t, device_t, void *); 98 99 static void fcu_sensors_refresh(struct sysmon_envsys *, envsys_data_t *); 100 static void fcu_configure_sensor(struct fcu_softc *, envsys_data_t *); 101 102 static bool is_cpu(const envsys_data_t *); 103 static bool is_case(const envsys_data_t *); 104 static bool is_drive(const envsys_data_t *); 105 106 static int fcu_set_rpm(void *, int, int); 107 static int fcu_get_rpm(void *, int); 108 static void fcu_adjust(void *); 109 110 CFATTACH_DECL_NEW(fcu, sizeof(struct fcu_softc), 111 fcu_match, fcu_attach, NULL, NULL); 112 113 static const struct device_compatible_entry compat_data[] = { 114 { .compat = "fcu" }, 115 DEVICE_COMPAT_EOL 116 }; 117 118 static int 119 fcu_match(device_t parent, cfdata_t match, void *aux) 120 { 121 struct i2c_attach_args *ia = aux; 122 int match_result; 123 124 if (iic_use_direct_match(ia, match, compat_data, &match_result)) 125 return match_result; 126 127 if (ia->ia_addr == 0x2f) 128 return I2C_MATCH_ADDRESS_ONLY; 129 130 return 0; 131 } 132 133 static void 134 fcu_attach(device_t parent, device_t self, void *aux) 135 { 136 struct fcu_softc *sc = device_private(self); 137 struct i2c_attach_args *ia = aux; 138 int i; 139 140 sc->sc_dev = self; 141 sc->sc_i2c = ia->ia_tag; 142 sc->sc_addr = ia->ia_addr; 143 144 aprint_naive("\n"); 145 aprint_normal(": Fan Control Unit\n"); 146 147 sysctl_createv(NULL, 0, NULL, (void *) &sc->sc_sysctl_me, 148 CTLFLAG_READWRITE, 149 CTLTYPE_NODE, device_xname(sc->sc_dev), NULL, 150 NULL, 0, NULL, 0, 151 CTL_MACHDEP, CTL_CREATE, CTL_EOL); 152 153 if (get_cpuid(0, sc->sc_eeprom0) < 160) { 154 /* 155 * XXX this should never happen, we depend on the EEPROM for 156 * calibration data to make sense of temperature and voltage 157 * sensors elsewhere, and fan parameters here. 158 */ 159 aprint_error_dev(self, "no EEPROM data for CPU 0\n"); 160 return; 161 } 162 163 /* init zones */ 164 sc->sc_zones[FCU_ZONE_CPU].name = "CPUs"; 165 sc->sc_zones[FCU_ZONE_CPU].filter = is_cpu; 166 sc->sc_zones[FCU_ZONE_CPU].cookie = sc; 167 sc->sc_zones[FCU_ZONE_CPU].get_rpm = fcu_get_rpm; 168 sc->sc_zones[FCU_ZONE_CPU].set_rpm = fcu_set_rpm; 169 sc->sc_zones[FCU_ZONE_CPU].Tmin = 50; 170 sc->sc_zones[FCU_ZONE_CPU].Tmax = 85; 171 sc->sc_zones[FCU_ZONE_CPU].nfans = 0; 172 sc->sc_zones[FCU_ZONE_CASE].name = "Slots"; 173 sc->sc_zones[FCU_ZONE_CASE].filter = is_case; 174 sc->sc_zones[FCU_ZONE_CASE].cookie = sc; 175 sc->sc_zones[FCU_ZONE_CASE].Tmin = 50; 176 sc->sc_zones[FCU_ZONE_CASE].Tmax = 75; 177 sc->sc_zones[FCU_ZONE_CASE].nfans = 0; 178 sc->sc_zones[FCU_ZONE_CASE].get_rpm = fcu_get_rpm; 179 sc->sc_zones[FCU_ZONE_CASE].set_rpm = fcu_set_rpm; 180 sc->sc_zones[FCU_ZONE_DRIVEBAY].name = "Drivebays"; 181 sc->sc_zones[FCU_ZONE_DRIVEBAY].filter = is_drive; 182 sc->sc_zones[FCU_ZONE_DRIVEBAY].cookie = sc; 183 sc->sc_zones[FCU_ZONE_DRIVEBAY].get_rpm = fcu_get_rpm; 184 sc->sc_zones[FCU_ZONE_DRIVEBAY].set_rpm = fcu_set_rpm; 185 sc->sc_zones[FCU_ZONE_DRIVEBAY].Tmin = 30; 186 sc->sc_zones[FCU_ZONE_DRIVEBAY].Tmax = 50; 187 sc->sc_zones[FCU_ZONE_DRIVEBAY].nfans = 0; 188 189 sc->sc_sme = sysmon_envsys_create(); 190 sc->sc_sme->sme_name = device_xname(self); 191 sc->sc_sme->sme_cookie = sc; 192 sc->sc_sme->sme_refresh = fcu_sensors_refresh; 193 194 sc->sc_sensors[0].units = ENVSYS_SFANRPM; 195 sc->sc_sensors[1].state = ENVSYS_SINVALID; 196 sc->sc_nfans = 0; 197 198 /* round up sensors */ 199 int ch; 200 201 sc->sc_nsensors = 0; 202 ch = OF_child(ia->ia_cookie); 203 if (ch == 0) { 204 /* old style data, no individual nodes for fans, annoying */ 205 char loc[256], tp[256], descr[32], type[32]; 206 uint32_t reg_rpm = 0x10, reg_pwm = 0x32, reg; 207 uint32_t id[16]; 208 int num, lidx = 0, tidx = 0; 209 210 num = OF_getprop(ia->ia_cookie, "hwctrl-id", id, 64); 211 OF_getprop(ia->ia_cookie, "hwctrl-location", loc, 1024); 212 OF_getprop(ia->ia_cookie, "hwctrl-type", tp, 1024); 213 while (num > 0) { 214 envsys_data_t *s = &sc->sc_sensors[sc->sc_nsensors]; 215 216 s->state = ENVSYS_SINVALID; 217 strcpy(descr, &loc[lidx]); 218 strcpy(type, &tp[tidx]); 219 if (strstr(type, "rpm") != NULL) { 220 s->units = ENVSYS_SFANRPM; 221 reg = reg_rpm; 222 reg_rpm += 2; 223 } else if (strstr(type, "pwm") != NULL) { 224 s->units = ENVSYS_SFANRPM; 225 reg = reg_pwm; 226 reg_pwm += 2; 227 } else goto skip; 228 229 s->private = reg; 230 strcpy(s->desc, descr); 231 232 fcu_configure_sensor(sc, s); 233 234 sysmon_envsys_sensor_attach(sc->sc_sme, s); 235 sc->sc_nsensors++; 236 skip: 237 lidx += strlen(descr) + 1; 238 tidx += strlen(type) + 1; 239 num -= 4; 240 } 241 } else { 242 /* new style, with individual nodes */ 243 while (ch != 0) { 244 char type[32], descr[32]; 245 uint32_t reg; 246 247 envsys_data_t *s = &sc->sc_sensors[sc->sc_nsensors]; 248 249 s->state = ENVSYS_SINVALID; 250 251 if (OF_getprop(ch, "device_type", type, 32) <= 0) 252 goto next; 253 254 if (strcmp(type, "fan-rpm-control") == 0) { 255 s->units = ENVSYS_SFANRPM; 256 } else if (strcmp(type, "fan-pwm-control") == 0) { 257 /* XXX we get the type from the register number */ 258 s->units = ENVSYS_SFANRPM; 259 /* skip those for now since we don't really know how to interpret them */ 260 #if 0 261 } else if (strcmp(type, "power-sensor") == 0) { 262 s->units = ENVSYS_SVOLTS_DC; 263 #endif 264 } else if (strcmp(type, "gpi-sensor") == 0) { 265 s->units = ENVSYS_INDICATOR; 266 } else { 267 /* ignore other types for now */ 268 goto next; 269 } 270 271 if (OF_getprop(ch, "reg", ®, sizeof(reg)) <= 0) 272 goto next; 273 s->private = reg; 274 275 if (OF_getprop(ch, "location", descr, 32) <= 0) 276 goto next; 277 strcpy(s->desc, descr); 278 279 fcu_configure_sensor(sc, s); 280 281 sysmon_envsys_sensor_attach(sc->sc_sme, s); 282 sc->sc_nsensors++; 283 next: 284 ch = OF_peer(ch); 285 } 286 } 287 sysmon_envsys_register(sc->sc_sme); 288 289 /* setup sysctls for our zones etc. */ 290 for (i = 0; i < FCU_ZONE_COUNT; i++) { 291 fancontrol_init_zone(&sc->sc_zones[i], sc->sc_sysctl_me); 292 } 293 294 sc->sc_dying = FALSE; 295 kthread_create(PRI_NONE, 0, curcpu(), fcu_adjust, sc, &sc->sc_thread, 296 "fan control"); 297 } 298 299 static void 300 fcu_configure_sensor(struct fcu_softc *sc, envsys_data_t *s) 301 { 302 int have_eeprom1 = 1; 303 304 if (get_cpuid(1, sc->sc_eeprom1) < 160) 305 have_eeprom1 = 0; 306 307 if (s->units == ENVSYS_SFANRPM) { 308 fcu_fan_t *fan = &sc->sc_fans[sc->sc_nfans]; 309 uint8_t *eeprom = NULL; 310 uint16_t rmin, rmax; 311 312 if (strstr(s->desc, "CPU A") != NULL) 313 eeprom = sc->sc_eeprom0; 314 if (strstr(s->desc, "CPU B") != NULL) { 315 /* 316 * XXX 317 * this should never happen 318 */ 319 if (have_eeprom1 == 0) { 320 eeprom = sc->sc_eeprom0; 321 } else 322 eeprom = sc->sc_eeprom1; 323 } 324 325 fan->reg = s->private; 326 fan->target = 0; 327 fan->duty = 0x80; 328 329 /* speed settings from EEPROM */ 330 if (strstr(s->desc, "PUMP") != NULL) { 331 KASSERT(eeprom != NULL); 332 memcpy(&rmin, &eeprom[0x54], 2); 333 memcpy(&rmax, &eeprom[0x56], 2); 334 fan->base_rpm = rmin; 335 fan->max_rpm = rmax; 336 fan->step = (rmax - rmin) / 30; 337 } else if (strstr(s->desc, "INTAKE") != NULL) { 338 KASSERT(eeprom != NULL); 339 memcpy(&rmin, &eeprom[0x4c], 2); 340 memcpy(&rmax, &eeprom[0x4e], 2); 341 fan->base_rpm = rmin; 342 fan->max_rpm = rmax; 343 fan->step = (rmax - rmin) / 30; 344 } else if (strstr(s->desc, "EXHAUST") != NULL) { 345 KASSERT(eeprom != NULL); 346 memcpy(&rmin, &eeprom[0x50], 2); 347 memcpy(&rmax, &eeprom[0x52], 2); 348 fan->base_rpm = rmin; 349 fan->max_rpm = rmax; 350 fan->step = (rmax - rmin) / 30; 351 } else if (strstr(s->desc, "DRIVE") != NULL ) { 352 fan->base_rpm = 1000; 353 fan->max_rpm = 3000; 354 fan->step = 100; 355 } else { 356 fan->base_rpm = 1000; 357 fan->max_rpm = 3000; 358 fan->step = 100; 359 } 360 DPRINTF("fan %s: %d - %d rpm, step %d\n", 361 s->desc, fan->base_rpm, fan->max_rpm, fan->step); 362 363 /* now stuff them into zones */ 364 if (strstr(s->desc, "CPU") != NULL) { 365 fancontrol_zone_t *z = &sc->sc_zones[FCU_ZONE_CPU]; 366 z->fans[z->nfans].num = sc->sc_nfans; 367 z->fans[z->nfans].min_rpm = fan->base_rpm; 368 z->fans[z->nfans].max_rpm = fan->max_rpm; 369 z->fans[z->nfans].name = s->desc; 370 z->nfans++; 371 } else if ((strstr(s->desc, "BACKSIDE") != NULL) || 372 (strstr(s->desc, "SLOT") != NULL)) { 373 fancontrol_zone_t *z = &sc->sc_zones[FCU_ZONE_CASE]; 374 z->fans[z->nfans].num = sc->sc_nfans; 375 z->fans[z->nfans].min_rpm = fan->base_rpm; 376 z->fans[z->nfans].max_rpm = fan->max_rpm; 377 z->fans[z->nfans].name = s->desc; 378 z->nfans++; 379 } else if (strstr(s->desc, "DRIVE") != NULL) { 380 fancontrol_zone_t *z = &sc->sc_zones[FCU_ZONE_DRIVEBAY]; 381 z->fans[z->nfans].num = sc->sc_nfans; 382 z->fans[z->nfans].min_rpm = fan->base_rpm; 383 z->fans[z->nfans].max_rpm = fan->max_rpm; 384 z->fans[z->nfans].name = s->desc; 385 z->nfans++; 386 } 387 sc->sc_nfans++; 388 } 389 } 390 static void 391 fcu_sensors_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 392 { 393 struct fcu_softc *sc = sme->sme_cookie; 394 uint8_t cmd; 395 uint16_t data = 0; 396 int error; 397 398 if (edata->units == ENVSYS_SFANRPM) { 399 cmd = edata->private + 1; 400 } else 401 cmd = edata->private; 402 403 /* fcu is a macppc only thing so we can safely assume big endian */ 404 iic_acquire_bus(sc->sc_i2c, 0); 405 error = iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP, 406 sc->sc_addr, &cmd, 1, &data, 2, 0); 407 iic_release_bus(sc->sc_i2c, 0); 408 409 if (error) { 410 edata->state = ENVSYS_SINVALID; 411 return; 412 } 413 414 edata->state = ENVSYS_SVALID; 415 416 switch (edata->units) { 417 case ENVSYS_SFANRPM: 418 edata->value_cur = data >> 3; 419 break; 420 case ENVSYS_SVOLTS_DC: 421 /* XXX this reads bogus */ 422 edata->value_cur = data * 1000; 423 break; 424 case ENVSYS_INDICATOR: 425 /* guesswork for now */ 426 edata->value_cur = data >> 8; 427 break; 428 default: 429 edata->state = ENVSYS_SINVALID; 430 } 431 } 432 433 static bool 434 is_cpu(const envsys_data_t *edata) 435 { 436 if (edata->units != ENVSYS_STEMP) 437 return false; 438 if (strstr(edata->desc, "CPU") != NULL) 439 return TRUE; 440 return false; 441 } 442 443 static bool 444 is_case(const envsys_data_t *edata) 445 { 446 if (edata->units != ENVSYS_STEMP) 447 return false; 448 if ((strstr(edata->desc, "MLB") != NULL) || 449 (strstr(edata->desc, "BACKSIDE") != NULL) || 450 (strstr(edata->desc, "U3") != NULL)) 451 return TRUE; 452 return false; 453 } 454 455 static bool 456 is_drive(const envsys_data_t *edata) 457 { 458 if (edata->units != ENVSYS_STEMP) 459 return false; 460 if (strstr(edata->desc, "DRIVE") != NULL) 461 return TRUE; 462 return false; 463 } 464 465 static int 466 fcu_get_rpm(void *cookie, int which) 467 { 468 struct fcu_softc *sc = cookie; 469 fcu_fan_t *f = &sc->sc_fans[which]; 470 int error; 471 uint16_t data = 0; 472 uint8_t cmd; 473 474 iic_acquire_bus(sc->sc_i2c, 0); 475 cmd = f->reg + 1; 476 error = iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP, 477 sc->sc_addr, &cmd, 1, &data, 2, 0); 478 iic_release_bus(sc->sc_i2c, 0); 479 if (error != 0) return 0; 480 data = data >> 3; 481 return data; 482 } 483 484 static int 485 fcu_set_rpm(void *cookie, int which, int speed) 486 { 487 struct fcu_softc *sc = cookie; 488 fcu_fan_t *f = &sc->sc_fans[which]; 489 int error = 0; 490 uint8_t cmd; 491 492 if (speed > f->max_rpm) speed = f->max_rpm; 493 if (speed < f->base_rpm) speed = f->base_rpm; 494 495 if (f->reg < 0x30) { 496 uint16_t data; 497 /* simple rpm fan, just poke the register */ 498 499 if (f->target == speed) return 0; 500 iic_acquire_bus(sc->sc_i2c, 0); 501 cmd = f->reg; 502 data = (speed << 3); 503 error = iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, 504 sc->sc_addr, &cmd, 1, &data, 2, 0); 505 iic_release_bus(sc->sc_i2c, 0); 506 } else { 507 int diff; 508 int nduty = f->duty; 509 int current_speed; 510 /* pwm fan, measure speed, then adjust duty cycle */ 511 DPRINTF("pwm fan "); 512 current_speed = fcu_get_rpm(sc, which); 513 diff = current_speed - speed; 514 DPRINTF("d %d s %d t %d diff %d ", f->duty, current_speed, speed, diff); 515 if (diff > 100) { 516 nduty = uimax(20, nduty - 1); 517 } 518 if (diff < -100) { 519 nduty = uimin(0xd0, nduty + 1); 520 } 521 cmd = f->reg; 522 DPRINTF("%s nduty %d", __func__, nduty); 523 if (nduty != f->duty) { 524 uint8_t arg = nduty; 525 iic_acquire_bus(sc->sc_i2c, 0); 526 error = iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, 527 sc->sc_addr, &cmd, 1, &arg, 1, 0); 528 iic_release_bus(sc->sc_i2c, 0); 529 f->duty = nduty; 530 sc->sc_pwm = TRUE; 531 532 } 533 DPRINTF("ok\n"); 534 } 535 if (error) printf("boo\n"); 536 f->target = speed; 537 return 0; 538 } 539 540 static void 541 fcu_adjust(void *cookie) 542 { 543 struct fcu_softc *sc = cookie; 544 int i; 545 uint8_t cmd, data; 546 547 while (!sc->sc_dying) { 548 /* poke the FCU so we don't go 747 */ 549 iic_acquire_bus(sc->sc_i2c, 0); 550 cmd = FCU_FAN_ACTIVE; 551 iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP, 552 sc->sc_addr, &cmd, 1, &data, 1, 0); 553 iic_release_bus(sc->sc_i2c, 0); 554 sc->sc_pwm = FALSE; 555 for (i = 0; i < FCU_ZONE_COUNT; i++) 556 fancontrol_adjust_zone(&sc->sc_zones[i]); 557 /* 558 * take a shorter nap if we're in the process of adjusting a 559 * PWM fan, which relies on measuring speed and then changing 560 * its duty cycle until we're reasonable close to the target 561 * speed 562 */ 563 kpause("fanctrl", true, mstohz(sc->sc_pwm ? 1000 : 2000), NULL); 564 } 565 kthread_exit(0); 566 } 567
Indexes created Wed Oct 01 19:09:53 GMT 2025