sys/powerpc/powermac/fcu.c

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