1/*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2010 Andreas Tobler 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 AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29#include <sys/cdefs.h> 30__FBSDID("$FreeBSD$"); 31 32#include <sys/param.h> 33#include <sys/bus.h> 34#include <sys/systm.h> 35#include <sys/module.h> 36#include <sys/callout.h> 37#include <sys/conf.h> 38#include <sys/cpu.h> 39#include <sys/ctype.h> 40#include <sys/kernel.h> 41#include <sys/reboot.h> 42#include <sys/rman.h> 43#include <sys/sysctl.h> 44#include <sys/limits.h> 45 46#include <machine/bus.h> 47#include <machine/md_var.h> 48 49#include <dev/iicbus/iicbus.h> 50#include <dev/iicbus/iiconf.h> 51 52#include <dev/ofw/openfirm.h> 53#include <dev/ofw/ofw_bus.h> 54#include <powerpc/powermac/powermac_thermal.h> 55 56/* FCU registers 57 * /u3@0,f8000000/i2c@f8001000/fan@15e 58 */ 59#define FCU_RPM_FAIL 0x0b /* fans states in bits 0<1-6>7 */ 60#define FCU_RPM_AVAILABLE 0x0c 61#define FCU_RPM_ACTIVE 0x0d 62#define FCU_RPM_READ(x) 0x11 + (x) * 2 63#define FCU_RPM_SET(x) 0x10 + (x) * 2 64 65#define FCU_PWM_FAIL 0x2b 66#define FCU_PWM_AVAILABLE 0x2c 67#define FCU_PWM_ACTIVE 0x2d 68#define FCU_PWM_RPM(x) 0x31 + (x) * 2 /* Get RPM. */ 69#define FCU_PWM_SGET(x) 0x30 + (x) * 2 /* Set or get PWM. */ 70 71struct fcu_fan { 72 struct pmac_fan fan; 73 device_t dev; 74 75 int id; 76 enum { 77 FCU_FAN_RPM, 78 FCU_FAN_PWM 79 } type; 80 int setpoint; 81 int rpm; 82}; 83 84struct fcu_softc { 85 device_t sc_dev; 86 struct intr_config_hook enum_hook; 87 uint32_t sc_addr; 88 struct fcu_fan *sc_fans; 89 int sc_nfans; 90}; 91 92/* We can read the PWM and the RPM from a PWM controlled fan. 93 * Offer both values via sysctl. 94 */ 95enum { 96 FCU_PWM_SYSCTL_PWM = 1 << 8, 97 FCU_PWM_SYSCTL_RPM = 2 << 8 98}; 99 100static int fcu_rpm_shift; 101 102/* Regular bus attachment functions */ 103static int fcu_probe(device_t); 104static int fcu_attach(device_t); 105 106/* Utility functions */ 107static void fcu_attach_fans(device_t dev); 108static int fcu_fill_fan_prop(device_t dev); 109static int fcu_fan_set_rpm(struct fcu_fan *fan, int rpm); 110static int fcu_fan_get_rpm(struct fcu_fan *fan); 111static int fcu_fan_set_pwm(struct fcu_fan *fan, int pwm); 112static int fcu_fan_get_pwm(device_t dev, struct fcu_fan *fan, int *pwm, 113 int *rpm); 114static int fcu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS); 115static void fcu_start(void *xdev); 116static int fcu_write(device_t dev, uint32_t addr, uint8_t reg, uint8_t *buf, 117 int len); 118static int fcu_read_1(device_t dev, uint32_t addr, uint8_t reg, uint8_t *data); 119 120static device_method_t fcu_methods[] = { 121 /* Device interface */ 122 DEVMETHOD(device_probe, fcu_probe), 123 DEVMETHOD(device_attach, fcu_attach), 124 { 0, 0 }, 125}; 126 127static driver_t fcu_driver = { 128 "fcu", 129 fcu_methods, 130 sizeof(struct fcu_softc) 131}; 132 133static devclass_t fcu_devclass; 134 135DRIVER_MODULE(fcu, iicbus, fcu_driver, fcu_devclass, 0, 0); 136static MALLOC_DEFINE(M_FCU, "fcu", "FCU Sensor Information"); 137 138static int 139fcu_write(device_t dev, uint32_t addr, uint8_t reg, uint8_t *buff, 140 int len) 141{ 142 unsigned char buf[4]; 143 int try = 0; 144 145 struct iic_msg msg[] = { 146 { addr, IIC_M_WR, 0, buf } 147 }; 148 149 msg[0].len = len + 1; 150 buf[0] = reg; 151 memcpy(buf + 1, buff, len); 152 153 for (;;) 154 { 155 if (iicbus_transfer(dev, msg, 1) == 0) 156 return (0); 157 158 if (++try > 5) { 159 device_printf(dev, "iicbus write failed\n"); 160 return (-1); 161 } 162 pause("fcu_write", hz); 163 } 164} 165 166static int 167fcu_read_1(device_t dev, uint32_t addr, uint8_t reg, uint8_t *data) 168{ 169 uint8_t buf[4]; 170 int err, try = 0; 171 172 struct iic_msg msg[2] = { 173 { addr, IIC_M_WR | IIC_M_NOSTOP, 1, ® }, 174 { addr, IIC_M_RD, 1, buf }, 175 }; 176 177 for (;;) 178 { 179 err = iicbus_transfer(dev, msg, 2); 180 if (err != 0) 181 goto retry; 182 183 *data = *((uint8_t*)buf); 184 return (0); 185 retry: 186 if (++try > 5) { 187 device_printf(dev, "iicbus read failed\n"); 188 return (-1); 189 } 190 pause("fcu_read_1", hz); 191 } 192} 193 194static int 195fcu_probe(device_t dev) 196{ 197 const char *name, *compatible; 198 struct fcu_softc *sc; 199 200 name = ofw_bus_get_name(dev); 201 compatible = ofw_bus_get_compat(dev); 202 203 if (!name) 204 return (ENXIO); 205 206 if (strcmp(name, "fan") != 0 || strcmp(compatible, "fcu") != 0) 207 return (ENXIO); 208 209 sc = device_get_softc(dev); 210 sc->sc_dev = dev; 211 sc->sc_addr = iicbus_get_addr(dev); 212 213 device_set_desc(dev, "Apple Fan Control Unit"); 214 215 return (0); 216} 217 218static int 219fcu_attach(device_t dev) 220{ 221 struct fcu_softc *sc; 222 223 sc = device_get_softc(dev); 224 225 sc->enum_hook.ich_func = fcu_start; 226 sc->enum_hook.ich_arg = dev; 227 228 /* We have to wait until interrupts are enabled. I2C read and write 229 * only works if the interrupts are available. 230 * The unin/i2c is controlled by the htpic on unin. But this is not 231 * the master. The openpic on mac-io is controlling the htpic. 232 * This one gets attached after the mac-io probing and then the 233 * interrupts will be available. 234 */ 235 236 if (config_intrhook_establish(&sc->enum_hook) != 0) 237 return (ENOMEM); 238 239 return (0); 240} 241 242static void 243fcu_start(void *xdev) 244{ 245 unsigned char buf[1] = { 0xff }; 246 struct fcu_softc *sc; 247 248 device_t dev = (device_t)xdev; 249 250 sc = device_get_softc(dev); 251 252 /* Start the fcu device. */ 253 fcu_write(sc->sc_dev, sc->sc_addr, 0xe, buf, 1); 254 fcu_write(sc->sc_dev, sc->sc_addr, 0x2e, buf, 1); 255 fcu_read_1(sc->sc_dev, sc->sc_addr, 0, buf); 256 fcu_rpm_shift = (buf[0] == 1) ? 2 : 3; 257 258 device_printf(dev, "FCU initialized, RPM shift: %d\n", 259 fcu_rpm_shift); 260 261 /* Detect and attach child devices. */ 262 263 fcu_attach_fans(dev); 264 265 config_intrhook_disestablish(&sc->enum_hook); 266 267} 268 269static int 270fcu_fan_set_rpm(struct fcu_fan *fan, int rpm) 271{ 272 uint8_t reg; 273 struct fcu_softc *sc; 274 unsigned char buf[2]; 275 276 sc = device_get_softc(fan->dev); 277 278 /* Clamp to allowed range */ 279 rpm = max(fan->fan.min_rpm, rpm); 280 rpm = min(fan->fan.max_rpm, rpm); 281 282 if (fan->type == FCU_FAN_RPM) { 283 reg = FCU_RPM_SET(fan->id); 284 fan->setpoint = rpm; 285 } else { 286 device_printf(fan->dev, "Unknown fan type: %d\n", fan->type); 287 return (ENXIO); 288 } 289 290 buf[0] = rpm >> (8 - fcu_rpm_shift); 291 buf[1] = rpm << fcu_rpm_shift; 292 293 if (fcu_write(sc->sc_dev, sc->sc_addr, reg, buf, 2) < 0) 294 return (EIO); 295 296 return (0); 297} 298 299static int 300fcu_fan_get_rpm(struct fcu_fan *fan) 301{ 302 uint8_t reg; 303 struct fcu_softc *sc; 304 uint8_t buff[2] = { 0, 0 }; 305 uint8_t active = 0, avail = 0, fail = 0; 306 int rpm; 307 308 sc = device_get_softc(fan->dev); 309 310 if (fan->type == FCU_FAN_RPM) { 311 /* Check if the fan is available. */ 312 reg = FCU_RPM_AVAILABLE; 313 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &avail) < 0) 314 return (-1); 315 if ((avail & (1 << fan->id)) == 0) { 316 device_printf(fan->dev, 317 "RPM Fan not available ID: %d\n", fan->id); 318 return (-1); 319 } 320 /* Check if we have a failed fan. */ 321 reg = FCU_RPM_FAIL; 322 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &fail) < 0) 323 return (-1); 324 if ((fail & (1 << fan->id)) != 0) { 325 device_printf(fan->dev, 326 "RPM Fan failed ID: %d\n", fan->id); 327 return (-1); 328 } 329 /* Check if fan is active. */ 330 reg = FCU_RPM_ACTIVE; 331 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &active) < 0) 332 return (-1); 333 if ((active & (1 << fan->id)) == 0) { 334 device_printf(fan->dev, "RPM Fan not active ID: %d\n", 335 fan->id); 336 return (-1); 337 } 338 reg = FCU_RPM_READ(fan->id); 339 340 } else { 341 device_printf(fan->dev, "Unknown fan type: %d\n", fan->type); 342 return (-1); 343 } 344 345 /* It seems that we can read the fans rpm. */ 346 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, buff) < 0) 347 return (-1); 348 349 rpm = (buff[0] << (8 - fcu_rpm_shift)) | buff[1] >> fcu_rpm_shift; 350 351 return (rpm); 352} 353 354static int 355fcu_fan_set_pwm(struct fcu_fan *fan, int pwm) 356{ 357 uint8_t reg; 358 struct fcu_softc *sc; 359 uint8_t buf[2]; 360 361 sc = device_get_softc(fan->dev); 362 363 /* Clamp to allowed range */ 364 pwm = max(fan->fan.min_rpm, pwm); 365 pwm = min(fan->fan.max_rpm, pwm); 366 367 if (fan->type == FCU_FAN_PWM) { 368 reg = FCU_PWM_SGET(fan->id); 369 if (pwm > 100) 370 pwm = 100; 371 if (pwm < 30) 372 pwm = 30; 373 fan->setpoint = pwm; 374 } else { 375 device_printf(fan->dev, "Unknown fan type: %d\n", fan->type); 376 return (EIO); 377 } 378 379 buf[0] = (pwm * 2550) / 1000; 380 381 if (fcu_write(sc->sc_dev, sc->sc_addr, reg, buf, 1) < 0) 382 return (EIO); 383 return (0); 384} 385 386static int 387fcu_fan_get_pwm(device_t dev, struct fcu_fan *fan, int *pwm, int *rpm) 388{ 389 uint8_t reg; 390 struct fcu_softc *sc; 391 uint8_t buf[2]; 392 uint8_t active = 0, avail = 0, fail = 0; 393 394 sc = device_get_softc(dev); 395 396 if (fan->type == FCU_FAN_PWM) { 397 /* Check if the fan is available. */ 398 reg = FCU_PWM_AVAILABLE; 399 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &avail) < 0) 400 return (-1); 401 if ((avail & (1 << fan->id)) == 0) { 402 device_printf(dev, "PWM Fan not available ID: %d\n", 403 fan->id); 404 return (-1); 405 } 406 /* Check if we have a failed fan. */ 407 reg = FCU_PWM_FAIL; 408 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &fail) < 0) 409 return (-1); 410 if ((fail & (1 << fan->id)) != 0) { 411 device_printf(dev, "PWM Fan failed ID: %d\n", fan->id); 412 return (-1); 413 } 414 /* Check if fan is active. */ 415 reg = FCU_PWM_ACTIVE; 416 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &active) < 0) 417 return (-1); 418 if ((active & (1 << fan->id)) == 0) { 419 device_printf(dev, "PWM Fan not active ID: %d\n", 420 fan->id); 421 return (-1); 422 } 423 reg = FCU_PWM_SGET(fan->id); 424 } else { 425 device_printf(dev, "Unknown fan type: %d\n", fan->type); 426 return (EIO); 427 } 428 429 /* It seems that we can read the fans pwm. */ 430 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, buf) < 0) 431 return (-1); 432 433 *pwm = (buf[0] * 1000) / 2550; 434 435 /* Now read the rpm. */ 436 reg = FCU_PWM_RPM(fan->id); 437 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, buf) < 0) 438 return (-1); 439 440 *rpm = (buf[0] << (8 - fcu_rpm_shift)) | buf[1] >> fcu_rpm_shift; 441 442 return (0); 443} 444 445/* 446 * This function returns the number of fans. If we call it the second time 447 * and we have allocated memory for sc->sc_fans, we fill in the properties. 448 */ 449static int 450fcu_fill_fan_prop(device_t dev) 451{ 452 phandle_t child; 453 struct fcu_softc *sc; 454 u_int id[12]; 455 char location[144]; 456 char type[96]; 457 int i = 0, j, len = 0, prop_len, prev_len = 0; 458 459 sc = device_get_softc(dev); 460 461 child = ofw_bus_get_node(dev); 462 463 /* Fill the fan location property. */ 464 prop_len = OF_getprop(child, "hwctrl-location", location, 465 sizeof(location)); 466 while (len < prop_len) { 467 if (sc->sc_fans != NULL) { 468 strcpy(sc->sc_fans[i].fan.name, location + len); 469 } 470 prev_len = strlen(location + len) + 1; 471 len += prev_len; 472 i++; 473 } 474 if (sc->sc_fans == NULL) 475 return (i); 476 477 /* Fill the fan type property. */ 478 len = 0; 479 i = 0; 480 prev_len = 0; 481 prop_len = OF_getprop(child, "hwctrl-type", type, sizeof(type)); 482 while (len < prop_len) { 483 if (strcmp(type + len, "fan-rpm") == 0) 484 sc->sc_fans[i].type = FCU_FAN_RPM; 485 else 486 sc->sc_fans[i].type = FCU_FAN_PWM; 487 prev_len = strlen(type + len) + 1; 488 len += prev_len; 489 i++; 490 } 491 492 /* Fill the fan ID property. */ 493 prop_len = OF_getprop(child, "hwctrl-id", id, sizeof(id)); 494 for (j = 0; j < i; j++) 495 sc->sc_fans[j].id = ((id[j] >> 8) & 0x0f) % 8; 496 497 /* Fill the fan zone property. */ 498 prop_len = OF_getprop(child, "hwctrl-zone", id, sizeof(id)); 499 for (j = 0; j < i; j++) 500 sc->sc_fans[j].fan.zone = id[j]; 501 502 /* Finish setting up fan properties */ 503 for (j = 0; j < i; j++) { 504 sc->sc_fans[j].dev = sc->sc_dev; 505 if (sc->sc_fans[j].type == FCU_FAN_RPM) { 506 sc->sc_fans[j].fan.min_rpm = 4800 >> fcu_rpm_shift; 507 sc->sc_fans[j].fan.max_rpm = 56000 >> fcu_rpm_shift; 508 sc->sc_fans[j].setpoint = 509 fcu_fan_get_rpm(&sc->sc_fans[j]); 510 sc->sc_fans[j].fan.read = 511 (int (*)(struct pmac_fan *))(fcu_fan_get_rpm); 512 sc->sc_fans[j].fan.set = 513 (int (*)(struct pmac_fan *, int))(fcu_fan_set_rpm); 514 } else { 515 sc->sc_fans[j].fan.min_rpm = 30; /* Percent */ 516 sc->sc_fans[j].fan.max_rpm = 100; 517 sc->sc_fans[j].fan.read = NULL; 518 sc->sc_fans[j].fan.set = 519 (int (*)(struct pmac_fan *, int))(fcu_fan_set_pwm); 520 } 521 sc->sc_fans[j].fan.default_rpm = sc->sc_fans[j].fan.max_rpm; 522 } 523 524 return (i); 525} 526 527static int 528fcu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS) 529{ 530 device_t fcu; 531 struct fcu_softc *sc; 532 struct fcu_fan *fan; 533 int rpm = 0, pwm = 0, error = 0; 534 535 fcu = arg1; 536 sc = device_get_softc(fcu); 537 fan = &sc->sc_fans[arg2 & 0x00ff]; 538 if (fan->type == FCU_FAN_RPM) { 539 rpm = fcu_fan_get_rpm(fan); 540 if (rpm < 0) 541 return (EIO); 542 error = sysctl_handle_int(oidp, &rpm, 0, req); 543 } else { 544 error = fcu_fan_get_pwm(fcu, fan, &pwm, &rpm); 545 if (error < 0) 546 return (EIO); 547 548 switch (arg2 & 0xff00) { 549 case FCU_PWM_SYSCTL_PWM: 550 error = sysctl_handle_int(oidp, &pwm, 0, req); 551 break; 552 case FCU_PWM_SYSCTL_RPM: 553 error = sysctl_handle_int(oidp, &rpm, 0, req); 554 break; 555 default: 556 /* This should never happen */ 557 return (EINVAL); 558 } 559 } 560 561 /* We can only read the RPM from a PWM controlled fan, so return. */ 562 if ((arg2 & 0xff00) == FCU_PWM_SYSCTL_RPM) 563 return (0); 564 565 if (error || !req->newptr) 566 return (error); 567 568 if (fan->type == FCU_FAN_RPM) 569 return (fcu_fan_set_rpm(fan, rpm)); 570 else 571 return (fcu_fan_set_pwm(fan, pwm)); 572} 573 574static void 575fcu_attach_fans(device_t dev) 576{ 577 struct fcu_softc *sc; 578 struct sysctl_oid *oid, *fanroot_oid; 579 struct sysctl_ctx_list *ctx; 580 char sysctl_name[32]; 581 int i, j; 582 583 sc = device_get_softc(dev); 584 585 sc->sc_nfans = 0; 586 587 /* Count the actual number of fans. */ 588 sc->sc_nfans = fcu_fill_fan_prop(dev); 589 590 device_printf(dev, "%d fans detected!\n", sc->sc_nfans); 591 592 if (sc->sc_nfans == 0) { 593 device_printf(dev, "WARNING: No fans detected!\n"); 594 return; 595 } 596 597 sc->sc_fans = malloc(sc->sc_nfans * sizeof(struct fcu_fan), M_FCU, 598 M_WAITOK | M_ZERO); 599 600 ctx = device_get_sysctl_ctx(dev); 601 fanroot_oid = SYSCTL_ADD_NODE(ctx, 602 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "fans", 603 CTLFLAG_RD, 0, "FCU Fan Information"); 604 605 /* Now we can fill the properties into the allocated struct. */ 606 sc->sc_nfans = fcu_fill_fan_prop(dev); 607 608 /* Register fans with pmac_thermal */ 609 for (i = 0; i < sc->sc_nfans; i++) 610 pmac_thermal_fan_register(&sc->sc_fans[i].fan); 611 612 /* Add sysctls for the fans. */ 613 for (i = 0; i < sc->sc_nfans; i++) { 614 for (j = 0; j < strlen(sc->sc_fans[i].fan.name); j++) { 615 sysctl_name[j] = tolower(sc->sc_fans[i].fan.name[j]); 616 if (isspace(sysctl_name[j])) 617 sysctl_name[j] = '_'; 618 } 619 sysctl_name[j] = 0; 620 621 if (sc->sc_fans[i].type == FCU_FAN_RPM) { 622 oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(fanroot_oid), 623 OID_AUTO, sysctl_name, 624 CTLFLAG_RD, 0, "Fan Information"); 625 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 626 "minrpm", CTLFLAG_RD, 627 &(sc->sc_fans[i].fan.min_rpm), 0, 628 "Minimum allowed RPM"); 629 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 630 "maxrpm", CTLFLAG_RD, 631 &(sc->sc_fans[i].fan.max_rpm), 0, 632 "Maximum allowed RPM"); 633 /* I use i to pass the fan id. */ 634 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 635 "rpm", CTLTYPE_INT | CTLFLAG_RW, dev, i, 636 fcu_fanrpm_sysctl, "I", "Fan RPM"); 637 } else { 638 fcu_fan_get_pwm(dev, &sc->sc_fans[i], 639 &sc->sc_fans[i].setpoint, 640 &sc->sc_fans[i].rpm); 641 642 oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(fanroot_oid), 643 OID_AUTO, sysctl_name, 644 CTLFLAG_RD, 0, "Fan Information"); 645 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 646 "minpwm", CTLFLAG_RD, 647 &(sc->sc_fans[i].fan.min_rpm), 0, 648 "Minimum allowed PWM in %"); 649 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 650 "maxpwm", CTLFLAG_RD, 651 &(sc->sc_fans[i].fan.max_rpm), 0, 652 "Maximum allowed PWM in %"); 653 /* I use i to pass the fan id or'ed with the type 654 * of info I want to display/modify. 655 */ 656 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 657 "pwm", CTLTYPE_INT | CTLFLAG_RW, dev, 658 FCU_PWM_SYSCTL_PWM | i, 659 fcu_fanrpm_sysctl, "I", "Fan PWM in %"); 660 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 661 "rpm", CTLTYPE_INT | CTLFLAG_RD, dev, 662 FCU_PWM_SYSCTL_RPM | i, 663 fcu_fanrpm_sysctl, "I", "Fan RPM"); 664 } 665 } 666 667 /* Dump fan location, type & RPM. */ 668 if (bootverbose) { 669 device_printf(dev, "Fans\n"); 670 for (i = 0; i < sc->sc_nfans; i++) { 671 device_printf(dev, "Location: %s type: %d ID: %d " 672 "RPM: %d\n", sc->sc_fans[i].fan.name, 673 sc->sc_fans[i].type, sc->sc_fans[i].id, 674 (sc->sc_fans[i].type == FCU_FAN_RPM) ? 675 sc->sc_fans[i].setpoint : 676 sc->sc_fans[i].rpm ); 677 } 678 } 679} 680