1213904Sandreast/*- 2213904Sandreast * Copyright (c) 2010 Andreas Tobler 3213904Sandreast * All rights reserved. 4213904Sandreast * 5213904Sandreast * Redistribution and use in source and binary forms, with or without 6213904Sandreast * modification, are permitted provided that the following conditions 7213904Sandreast * are met: 8213904Sandreast * 1. Redistributions of source code must retain the above copyright 9213904Sandreast * notice, this list of conditions and the following disclaimer. 10213904Sandreast * 2. Redistributions in binary form must reproduce the above copyright 11213904Sandreast * notice, this list of conditions and the following disclaimer in the 12213904Sandreast * documentation and/or other materials provided with the distribution. 13213904Sandreast * 14213904Sandreast * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 15213904Sandreast * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16213904Sandreast * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17213904Sandreast * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 18213904Sandreast * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 19213904Sandreast * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 20213904Sandreast * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 21213904Sandreast * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 22213904Sandreast * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23213904Sandreast * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24213904Sandreast * SUCH DAMAGE. 25213904Sandreast */ 26213904Sandreast 27213904Sandreast#include <sys/cdefs.h> 28213904Sandreast__FBSDID("$FreeBSD$"); 29213904Sandreast 30213904Sandreast#include <sys/param.h> 31213904Sandreast#include <sys/bus.h> 32213904Sandreast#include <sys/systm.h> 33213904Sandreast#include <sys/module.h> 34213904Sandreast#include <sys/callout.h> 35213904Sandreast#include <sys/conf.h> 36213904Sandreast#include <sys/cpu.h> 37213904Sandreast#include <sys/ctype.h> 38213904Sandreast#include <sys/kernel.h> 39213904Sandreast#include <sys/reboot.h> 40213904Sandreast#include <sys/rman.h> 41213904Sandreast#include <sys/sysctl.h> 42213904Sandreast#include <sys/limits.h> 43213904Sandreast 44213904Sandreast#include <machine/bus.h> 45213904Sandreast#include <machine/md_var.h> 46213904Sandreast 47213904Sandreast#include <dev/iicbus/iicbus.h> 48213904Sandreast#include <dev/iicbus/iiconf.h> 49213904Sandreast 50213904Sandreast#include <dev/ofw/openfirm.h> 51213904Sandreast#include <dev/ofw/ofw_bus.h> 52222458Snwhitehorn#include <powerpc/powermac/powermac_thermal.h> 53213904Sandreast 54213904Sandreast/* FCU registers 55213904Sandreast * /u3@0,f8000000/i2c@f8001000/fan@15e 56213904Sandreast */ 57213904Sandreast#define FCU_RPM_FAIL 0x0b /* fans states in bits 0<1-6>7 */ 58213904Sandreast#define FCU_RPM_AVAILABLE 0x0c 59213904Sandreast#define FCU_RPM_ACTIVE 0x0d 60213904Sandreast#define FCU_RPM_READ(x) 0x11 + (x) * 2 61213904Sandreast#define FCU_RPM_SET(x) 0x10 + (x) * 2 62213904Sandreast 63213904Sandreast#define FCU_PWM_FAIL 0x2b 64213904Sandreast#define FCU_PWM_AVAILABLE 0x2c 65213904Sandreast#define FCU_PWM_ACTIVE 0x2d 66217286Sandreast#define FCU_PWM_RPM(x) 0x31 + (x) * 2 /* Get RPM. */ 67217286Sandreast#define FCU_PWM_SGET(x) 0x30 + (x) * 2 /* Set or get PWM. */ 68213904Sandreast 69213904Sandreaststruct fcu_fan { 70222458Snwhitehorn struct pmac_fan fan; 71222458Snwhitehorn device_t dev; 72222458Snwhitehorn 73213904Sandreast int id; 74213904Sandreast enum { 75213904Sandreast FCU_FAN_RPM, 76213904Sandreast FCU_FAN_PWM 77213904Sandreast } type; 78213904Sandreast int setpoint; 79217286Sandreast int rpm; 80213904Sandreast}; 81213904Sandreast 82213904Sandreaststruct fcu_softc { 83213904Sandreast device_t sc_dev; 84213904Sandreast struct intr_config_hook enum_hook; 85213904Sandreast uint32_t sc_addr; 86213904Sandreast struct fcu_fan *sc_fans; 87213904Sandreast int sc_nfans; 88213904Sandreast}; 89213904Sandreast 90217286Sandreast/* We can read the PWM and the RPM from a PWM controlled fan. 91217286Sandreast * Offer both values via sysctl. 92217286Sandreast */ 93217286Sandreastenum { 94217286Sandreast FCU_PWM_SYSCTL_PWM = 1 << 8, 95217286Sandreast FCU_PWM_SYSCTL_RPM = 2 << 8 96217286Sandreast}; 97217286Sandreast 98213904Sandreaststatic int fcu_rpm_shift; 99213904Sandreast 100213904Sandreast/* Regular bus attachment functions */ 101213904Sandreaststatic int fcu_probe(device_t); 102213904Sandreaststatic int fcu_attach(device_t); 103213904Sandreast 104213904Sandreast/* Utility functions */ 105213904Sandreaststatic void fcu_attach_fans(device_t dev); 106213904Sandreaststatic int fcu_fill_fan_prop(device_t dev); 107222458Snwhitehornstatic int fcu_fan_set_rpm(struct fcu_fan *fan, int rpm); 108222458Snwhitehornstatic int fcu_fan_get_rpm(struct fcu_fan *fan); 109222458Snwhitehornstatic int fcu_fan_set_pwm(struct fcu_fan *fan, int pwm); 110217286Sandreaststatic int fcu_fan_get_pwm(device_t dev, struct fcu_fan *fan, int *pwm, 111217286Sandreast int *rpm); 112213904Sandreaststatic int fcu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS); 113213904Sandreaststatic void fcu_start(void *xdev); 114213904Sandreaststatic int fcu_write(device_t dev, uint32_t addr, uint8_t reg, uint8_t *buf, 115213904Sandreast int len); 116213904Sandreaststatic int fcu_read_1(device_t dev, uint32_t addr, uint8_t reg, uint8_t *data); 117213904Sandreast 118213904Sandreaststatic device_method_t fcu_methods[] = { 119213904Sandreast /* Device interface */ 120213904Sandreast DEVMETHOD(device_probe, fcu_probe), 121213904Sandreast DEVMETHOD(device_attach, fcu_attach), 122213904Sandreast { 0, 0 }, 123213904Sandreast}; 124213904Sandreast 125213904Sandreaststatic driver_t fcu_driver = { 126213904Sandreast "fcu", 127213904Sandreast fcu_methods, 128213904Sandreast sizeof(struct fcu_softc) 129213904Sandreast}; 130213904Sandreast 131213904Sandreaststatic devclass_t fcu_devclass; 132213904Sandreast 133213904SandreastDRIVER_MODULE(fcu, iicbus, fcu_driver, fcu_devclass, 0, 0); 134227293Sedstatic MALLOC_DEFINE(M_FCU, "fcu", "FCU Sensor Information"); 135213904Sandreast 136213904Sandreaststatic int 137213904Sandreastfcu_write(device_t dev, uint32_t addr, uint8_t reg, uint8_t *buff, 138213904Sandreast int len) 139213904Sandreast{ 140213904Sandreast unsigned char buf[4]; 141222675Sandreast int try = 0; 142222675Sandreast 143213904Sandreast struct iic_msg msg[] = { 144213904Sandreast { addr, IIC_M_WR, 0, buf } 145213904Sandreast }; 146213904Sandreast 147213904Sandreast msg[0].len = len + 1; 148213904Sandreast buf[0] = reg; 149213904Sandreast memcpy(buf + 1, buff, len); 150213904Sandreast 151222675Sandreast for (;;) 152222675Sandreast { 153222675Sandreast if (iicbus_transfer(dev, msg, 1) == 0) 154222675Sandreast return (0); 155213904Sandreast 156222675Sandreast if (++try > 5) { 157222675Sandreast device_printf(dev, "iicbus write failed\n"); 158222675Sandreast return (-1); 159222675Sandreast } 160222675Sandreast pause("fcu_write", hz); 161222675Sandreast } 162213904Sandreast} 163213904Sandreast 164213904Sandreaststatic int 165213904Sandreastfcu_read_1(device_t dev, uint32_t addr, uint8_t reg, uint8_t *data) 166213904Sandreast{ 167213904Sandreast uint8_t buf[4]; 168222675Sandreast int err, try = 0; 169213904Sandreast 170213904Sandreast struct iic_msg msg[2] = { 171213904Sandreast { addr, IIC_M_WR | IIC_M_NOSTOP, 1, ® }, 172213904Sandreast { addr, IIC_M_RD, 1, buf }, 173213904Sandreast }; 174213904Sandreast 175222675Sandreast for (;;) 176222675Sandreast { 177222675Sandreast err = iicbus_transfer(dev, msg, 2); 178222675Sandreast if (err != 0) 179222675Sandreast goto retry; 180222675Sandreast 181222675Sandreast *data = *((uint8_t*)buf); 182222675Sandreast return (0); 183222675Sandreast retry: 184222675Sandreast if (++try > 5) { 185222675Sandreast device_printf(dev, "iicbus read failed\n"); 186222675Sandreast return (-1); 187222675Sandreast } 188222675Sandreast pause("fcu_read_1", hz); 189213904Sandreast } 190213904Sandreast} 191213904Sandreast 192213904Sandreaststatic int 193213904Sandreastfcu_probe(device_t dev) 194213904Sandreast{ 195213904Sandreast const char *name, *compatible; 196213904Sandreast struct fcu_softc *sc; 197213904Sandreast 198213904Sandreast name = ofw_bus_get_name(dev); 199213904Sandreast compatible = ofw_bus_get_compat(dev); 200213904Sandreast 201213904Sandreast if (!name) 202213904Sandreast return (ENXIO); 203213904Sandreast 204213904Sandreast if (strcmp(name, "fan") != 0 || strcmp(compatible, "fcu") != 0) 205213904Sandreast return (ENXIO); 206213904Sandreast 207213904Sandreast sc = device_get_softc(dev); 208213904Sandreast sc->sc_dev = dev; 209213904Sandreast sc->sc_addr = iicbus_get_addr(dev); 210213904Sandreast 211213904Sandreast device_set_desc(dev, "Apple Fan Control Unit"); 212213904Sandreast 213213904Sandreast return (0); 214213904Sandreast} 215213904Sandreast 216213904Sandreaststatic int 217213904Sandreastfcu_attach(device_t dev) 218213904Sandreast{ 219213904Sandreast struct fcu_softc *sc; 220213904Sandreast 221213904Sandreast sc = device_get_softc(dev); 222213904Sandreast 223213904Sandreast sc->enum_hook.ich_func = fcu_start; 224213904Sandreast sc->enum_hook.ich_arg = dev; 225213904Sandreast 226213904Sandreast /* We have to wait until interrupts are enabled. I2C read and write 227213904Sandreast * only works if the interrupts are available. 228213904Sandreast * The unin/i2c is controlled by the htpic on unin. But this is not 229213904Sandreast * the master. The openpic on mac-io is controlling the htpic. 230213904Sandreast * This one gets attached after the mac-io probing and then the 231213904Sandreast * interrupts will be available. 232213904Sandreast */ 233213904Sandreast 234213904Sandreast if (config_intrhook_establish(&sc->enum_hook) != 0) 235213904Sandreast return (ENOMEM); 236213904Sandreast 237213904Sandreast return (0); 238213904Sandreast} 239213904Sandreast 240213904Sandreaststatic void 241213904Sandreastfcu_start(void *xdev) 242213904Sandreast{ 243213904Sandreast unsigned char buf[1] = { 0xff }; 244213904Sandreast struct fcu_softc *sc; 245213904Sandreast 246213904Sandreast device_t dev = (device_t)xdev; 247213904Sandreast 248213904Sandreast sc = device_get_softc(dev); 249213904Sandreast 250213904Sandreast /* Start the fcu device. */ 251213904Sandreast fcu_write(sc->sc_dev, sc->sc_addr, 0xe, buf, 1); 252213904Sandreast fcu_write(sc->sc_dev, sc->sc_addr, 0x2e, buf, 1); 253213904Sandreast fcu_read_1(sc->sc_dev, sc->sc_addr, 0, buf); 254213904Sandreast fcu_rpm_shift = (buf[0] == 1) ? 2 : 3; 255213904Sandreast 256213904Sandreast device_printf(dev, "FCU initialized, RPM shift: %d\n", 257213904Sandreast fcu_rpm_shift); 258213904Sandreast 259213904Sandreast /* Detect and attach child devices. */ 260213904Sandreast 261213904Sandreast fcu_attach_fans(dev); 262213904Sandreast 263213904Sandreast config_intrhook_disestablish(&sc->enum_hook); 264213904Sandreast 265213904Sandreast} 266213904Sandreast 267213904Sandreaststatic int 268222458Snwhitehornfcu_fan_set_rpm(struct fcu_fan *fan, int rpm) 269213904Sandreast{ 270213904Sandreast uint8_t reg; 271213904Sandreast struct fcu_softc *sc; 272213904Sandreast unsigned char buf[2]; 273213904Sandreast 274222458Snwhitehorn sc = device_get_softc(fan->dev); 275213904Sandreast 276213904Sandreast /* Clamp to allowed range */ 277222458Snwhitehorn rpm = max(fan->fan.min_rpm, rpm); 278222458Snwhitehorn rpm = min(fan->fan.max_rpm, rpm); 279213904Sandreast 280213904Sandreast if (fan->type == FCU_FAN_RPM) { 281213904Sandreast reg = FCU_RPM_SET(fan->id); 282213904Sandreast fan->setpoint = rpm; 283213904Sandreast } else { 284222458Snwhitehorn device_printf(fan->dev, "Unknown fan type: %d\n", fan->type); 285224505Snwhitehorn return (ENXIO); 286213904Sandreast } 287213904Sandreast 288217286Sandreast buf[0] = rpm >> (8 - fcu_rpm_shift); 289217286Sandreast buf[1] = rpm << fcu_rpm_shift; 290213904Sandreast 291222675Sandreast if (fcu_write(sc->sc_dev, sc->sc_addr, reg, buf, 2) < 0) 292224505Snwhitehorn return (EIO); 293217286Sandreast 294213904Sandreast return (0); 295213904Sandreast} 296213904Sandreast 297213904Sandreaststatic int 298222458Snwhitehornfcu_fan_get_rpm(struct fcu_fan *fan) 299213904Sandreast{ 300213904Sandreast uint8_t reg; 301213904Sandreast struct fcu_softc *sc; 302213904Sandreast uint8_t buff[2] = { 0, 0 }; 303213904Sandreast uint8_t active = 0, avail = 0, fail = 0; 304222458Snwhitehorn int rpm; 305213904Sandreast 306222458Snwhitehorn sc = device_get_softc(fan->dev); 307213904Sandreast 308213904Sandreast if (fan->type == FCU_FAN_RPM) { 309213904Sandreast /* Check if the fan is available. */ 310213904Sandreast reg = FCU_RPM_AVAILABLE; 311222675Sandreast if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &avail) < 0) 312222675Sandreast return (-1); 313213904Sandreast if ((avail & (1 << fan->id)) == 0) { 314222458Snwhitehorn device_printf(fan->dev, 315222458Snwhitehorn "RPM Fan not available ID: %d\n", fan->id); 316222458Snwhitehorn return (-1); 317213904Sandreast } 318213904Sandreast /* Check if we have a failed fan. */ 319213904Sandreast reg = FCU_RPM_FAIL; 320222675Sandreast if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &fail) < 0) 321222675Sandreast return (-1); 322213904Sandreast if ((fail & (1 << fan->id)) != 0) { 323222458Snwhitehorn device_printf(fan->dev, 324222458Snwhitehorn "RPM Fan failed ID: %d\n", fan->id); 325222458Snwhitehorn return (-1); 326213904Sandreast } 327213904Sandreast /* Check if fan is active. */ 328213904Sandreast reg = FCU_RPM_ACTIVE; 329222675Sandreast if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &active) < 0) 330222675Sandreast return (-1); 331213904Sandreast if ((active & (1 << fan->id)) == 0) { 332222458Snwhitehorn device_printf(fan->dev, "RPM Fan not active ID: %d\n", 333213904Sandreast fan->id); 334222458Snwhitehorn return (-1); 335213904Sandreast } 336213904Sandreast reg = FCU_RPM_READ(fan->id); 337217286Sandreast 338217286Sandreast } else { 339222458Snwhitehorn device_printf(fan->dev, "Unknown fan type: %d\n", fan->type); 340222458Snwhitehorn return (-1); 341217286Sandreast } 342217286Sandreast 343217286Sandreast /* It seems that we can read the fans rpm. */ 344222675Sandreast if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, buff) < 0) 345222675Sandreast return (-1); 346217286Sandreast 347222458Snwhitehorn rpm = (buff[0] << (8 - fcu_rpm_shift)) | buff[1] >> fcu_rpm_shift; 348217286Sandreast 349222458Snwhitehorn return (rpm); 350217286Sandreast} 351217286Sandreast 352217286Sandreaststatic int 353222458Snwhitehornfcu_fan_set_pwm(struct fcu_fan *fan, int pwm) 354217286Sandreast{ 355217286Sandreast uint8_t reg; 356217286Sandreast struct fcu_softc *sc; 357217286Sandreast uint8_t buf[2]; 358217286Sandreast 359222458Snwhitehorn sc = device_get_softc(fan->dev); 360217286Sandreast 361217286Sandreast /* Clamp to allowed range */ 362222458Snwhitehorn pwm = max(fan->fan.min_rpm, pwm); 363222458Snwhitehorn pwm = min(fan->fan.max_rpm, pwm); 364217286Sandreast 365217286Sandreast if (fan->type == FCU_FAN_PWM) { 366217286Sandreast reg = FCU_PWM_SGET(fan->id); 367217286Sandreast if (pwm > 100) 368217286Sandreast pwm = 100; 369217286Sandreast if (pwm < 30) 370217286Sandreast pwm = 30; 371217286Sandreast fan->setpoint = pwm; 372217286Sandreast } else { 373222458Snwhitehorn device_printf(fan->dev, "Unknown fan type: %d\n", fan->type); 374217286Sandreast return (EIO); 375217286Sandreast } 376217286Sandreast 377217286Sandreast buf[0] = (pwm * 2550) / 1000; 378217286Sandreast 379222675Sandreast if (fcu_write(sc->sc_dev, sc->sc_addr, reg, buf, 1) < 0) 380224505Snwhitehorn return (EIO); 381217286Sandreast return (0); 382217286Sandreast} 383217286Sandreast 384217286Sandreaststatic int 385217286Sandreastfcu_fan_get_pwm(device_t dev, struct fcu_fan *fan, int *pwm, int *rpm) 386217286Sandreast{ 387217286Sandreast uint8_t reg; 388217286Sandreast struct fcu_softc *sc; 389217286Sandreast uint8_t buf[2]; 390217286Sandreast uint8_t active = 0, avail = 0, fail = 0; 391217286Sandreast 392217286Sandreast sc = device_get_softc(dev); 393217286Sandreast 394217286Sandreast if (fan->type == FCU_FAN_PWM) { 395213904Sandreast /* Check if the fan is available. */ 396213904Sandreast reg = FCU_PWM_AVAILABLE; 397222675Sandreast if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &avail) < 0) 398222675Sandreast return (-1); 399213904Sandreast if ((avail & (1 << fan->id)) == 0) { 400213904Sandreast device_printf(dev, "PWM Fan not available ID: %d\n", 401213904Sandreast fan->id); 402222675Sandreast return (-1); 403213904Sandreast } 404213904Sandreast /* Check if we have a failed fan. */ 405213904Sandreast reg = FCU_PWM_FAIL; 406222675Sandreast if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &fail) < 0) 407222675Sandreast return (-1); 408213904Sandreast if ((fail & (1 << fan->id)) != 0) { 409213904Sandreast device_printf(dev, "PWM Fan failed ID: %d\n", fan->id); 410222675Sandreast return (-1); 411213904Sandreast } 412213904Sandreast /* Check if fan is active. */ 413213904Sandreast reg = FCU_PWM_ACTIVE; 414222675Sandreast if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &active) < 0) 415222675Sandreast return (-1); 416213904Sandreast if ((active & (1 << fan->id)) == 0) { 417213904Sandreast device_printf(dev, "PWM Fan not active ID: %d\n", 418213904Sandreast fan->id); 419222675Sandreast return (-1); 420213904Sandreast } 421217286Sandreast reg = FCU_PWM_SGET(fan->id); 422213904Sandreast } else { 423213904Sandreast device_printf(dev, "Unknown fan type: %d\n", fan->type); 424213904Sandreast return (EIO); 425213904Sandreast } 426213904Sandreast 427217286Sandreast /* It seems that we can read the fans pwm. */ 428222675Sandreast if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, buf) < 0) 429222675Sandreast return (-1); 430213904Sandreast 431217286Sandreast *pwm = (buf[0] * 1000) / 2550; 432213904Sandreast 433217286Sandreast /* Now read the rpm. */ 434217286Sandreast reg = FCU_PWM_RPM(fan->id); 435222675Sandreast if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, buf) < 0) 436222675Sandreast return (-1); 437222675Sandreast 438217286Sandreast *rpm = (buf[0] << (8 - fcu_rpm_shift)) | buf[1] >> fcu_rpm_shift; 439217286Sandreast 440213904Sandreast return (0); 441213904Sandreast} 442213904Sandreast 443213904Sandreast/* 444213904Sandreast * This function returns the number of fans. If we call it the second time 445213904Sandreast * and we have allocated memory for sc->sc_fans, we fill in the properties. 446213904Sandreast */ 447213904Sandreaststatic int 448213904Sandreastfcu_fill_fan_prop(device_t dev) 449213904Sandreast{ 450213904Sandreast phandle_t child; 451213904Sandreast struct fcu_softc *sc; 452213904Sandreast u_int id[8]; 453213904Sandreast char location[96]; 454213904Sandreast char type[64]; 455213904Sandreast int i = 0, j, len = 0, prop_len, prev_len = 0; 456213904Sandreast 457213904Sandreast sc = device_get_softc(dev); 458213904Sandreast 459213904Sandreast child = ofw_bus_get_node(dev); 460213904Sandreast 461213904Sandreast /* Fill the fan location property. */ 462213904Sandreast prop_len = OF_getprop(child, "hwctrl-location", location, 463213904Sandreast sizeof(location)); 464213904Sandreast while (len < prop_len) { 465213904Sandreast if (sc->sc_fans != NULL) { 466222458Snwhitehorn strcpy(sc->sc_fans[i].fan.name, location + len); 467213904Sandreast } 468213904Sandreast prev_len = strlen(location + len) + 1; 469213904Sandreast len += prev_len; 470213904Sandreast i++; 471213904Sandreast } 472213904Sandreast if (sc->sc_fans == NULL) 473213904Sandreast return (i); 474213904Sandreast 475213904Sandreast /* Fill the fan type property. */ 476213904Sandreast len = 0; 477213904Sandreast i = 0; 478213904Sandreast prev_len = 0; 479213904Sandreast prop_len = OF_getprop(child, "hwctrl-type", type, sizeof(type)); 480213904Sandreast while (len < prop_len) { 481213904Sandreast if (strcmp(type + len, "fan-rpm") == 0) 482213904Sandreast sc->sc_fans[i].type = FCU_FAN_RPM; 483213904Sandreast else 484213904Sandreast sc->sc_fans[i].type = FCU_FAN_PWM; 485213904Sandreast prev_len = strlen(type + len) + 1; 486213904Sandreast len += prev_len; 487213904Sandreast i++; 488213904Sandreast } 489213904Sandreast 490213904Sandreast /* Fill the fan ID property. */ 491213904Sandreast prop_len = OF_getprop(child, "hwctrl-id", id, sizeof(id)); 492213904Sandreast for (j = 0; j < i; j++) 493213904Sandreast sc->sc_fans[j].id = ((id[j] >> 8) & 0x0f) % 8; 494213904Sandreast 495222458Snwhitehorn /* Fill the fan zone property. */ 496222458Snwhitehorn prop_len = OF_getprop(child, "hwctrl-zone", id, sizeof(id)); 497222458Snwhitehorn for (j = 0; j < i; j++) 498222458Snwhitehorn sc->sc_fans[j].fan.zone = id[j]; 499222458Snwhitehorn 500222458Snwhitehorn /* Finish setting up fan properties */ 501222458Snwhitehorn for (j = 0; j < i; j++) { 502222458Snwhitehorn sc->sc_fans[j].dev = sc->sc_dev; 503222458Snwhitehorn if (sc->sc_fans[j].type == FCU_FAN_RPM) { 504222458Snwhitehorn sc->sc_fans[j].fan.min_rpm = 4800 >> fcu_rpm_shift; 505222458Snwhitehorn sc->sc_fans[j].fan.max_rpm = 56000 >> fcu_rpm_shift; 506222458Snwhitehorn sc->sc_fans[j].setpoint = 507222458Snwhitehorn fcu_fan_get_rpm(&sc->sc_fans[j]); 508222458Snwhitehorn sc->sc_fans[j].fan.read = 509222458Snwhitehorn (int (*)(struct pmac_fan *))(fcu_fan_get_rpm); 510222458Snwhitehorn sc->sc_fans[j].fan.set = 511222458Snwhitehorn (int (*)(struct pmac_fan *, int))(fcu_fan_set_rpm); 512222458Snwhitehorn } else { 513223555Snwhitehorn sc->sc_fans[j].fan.min_rpm = 30; /* Percent */ 514222458Snwhitehorn sc->sc_fans[j].fan.max_rpm = 100; 515222458Snwhitehorn sc->sc_fans[j].fan.read = NULL; 516222458Snwhitehorn sc->sc_fans[j].fan.set = 517222458Snwhitehorn (int (*)(struct pmac_fan *, int))(fcu_fan_set_pwm); 518222458Snwhitehorn } 519222458Snwhitehorn sc->sc_fans[j].fan.default_rpm = sc->sc_fans[j].fan.max_rpm; 520222458Snwhitehorn } 521222458Snwhitehorn 522213904Sandreast return (i); 523213904Sandreast} 524213904Sandreast 525213904Sandreaststatic int 526213904Sandreastfcu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS) 527213904Sandreast{ 528213904Sandreast device_t fcu; 529213904Sandreast struct fcu_softc *sc; 530213904Sandreast struct fcu_fan *fan; 531222675Sandreast int rpm = 0, pwm = 0, error = 0; 532213904Sandreast 533213904Sandreast fcu = arg1; 534213904Sandreast sc = device_get_softc(fcu); 535217286Sandreast fan = &sc->sc_fans[arg2 & 0x00ff]; 536217286Sandreast if (fan->type == FCU_FAN_RPM) { 537222458Snwhitehorn rpm = fcu_fan_get_rpm(fan); 538222675Sandreast if (rpm < 0) 539224505Snwhitehorn return (EIO); 540217286Sandreast error = sysctl_handle_int(oidp, &rpm, 0, req); 541217286Sandreast } else { 542222675Sandreast error = fcu_fan_get_pwm(fcu, fan, &pwm, &rpm); 543222675Sandreast if (error < 0) 544224505Snwhitehorn return (EIO); 545213904Sandreast 546217286Sandreast switch (arg2 & 0xff00) { 547217286Sandreast case FCU_PWM_SYSCTL_PWM: 548217286Sandreast error = sysctl_handle_int(oidp, &pwm, 0, req); 549217286Sandreast break; 550217286Sandreast case FCU_PWM_SYSCTL_RPM: 551217286Sandreast error = sysctl_handle_int(oidp, &rpm, 0, req); 552217286Sandreast break; 553217286Sandreast default: 554217286Sandreast /* This should never happen */ 555224505Snwhitehorn return (EINVAL); 556217286Sandreast }; 557217286Sandreast } 558217286Sandreast 559217286Sandreast /* We can only read the RPM from a PWM controlled fan, so return. */ 560217286Sandreast if ((arg2 & 0xff00) == FCU_PWM_SYSCTL_RPM) 561217286Sandreast return (0); 562217286Sandreast 563213904Sandreast if (error || !req->newptr) 564213904Sandreast return (error); 565213904Sandreast 566217286Sandreast if (fan->type == FCU_FAN_RPM) 567222458Snwhitehorn return (fcu_fan_set_rpm(fan, rpm)); 568217286Sandreast else 569222458Snwhitehorn return (fcu_fan_set_pwm(fan, pwm)); 570213904Sandreast} 571213904Sandreast 572213904Sandreaststatic void 573213904Sandreastfcu_attach_fans(device_t dev) 574213904Sandreast{ 575213904Sandreast struct fcu_softc *sc; 576213904Sandreast struct sysctl_oid *oid, *fanroot_oid; 577213904Sandreast struct sysctl_ctx_list *ctx; 578213904Sandreast char sysctl_name[32]; 579213904Sandreast int i, j; 580213904Sandreast 581213904Sandreast sc = device_get_softc(dev); 582213904Sandreast 583213904Sandreast sc->sc_nfans = 0; 584213904Sandreast 585213904Sandreast /* Count the actual number of fans. */ 586213904Sandreast sc->sc_nfans = fcu_fill_fan_prop(dev); 587213904Sandreast 588213904Sandreast device_printf(dev, "%d fans detected!\n", sc->sc_nfans); 589213904Sandreast 590213904Sandreast if (sc->sc_nfans == 0) { 591213904Sandreast device_printf(dev, "WARNING: No fans detected!\n"); 592213904Sandreast return; 593213904Sandreast } 594213904Sandreast 595213904Sandreast sc->sc_fans = malloc(sc->sc_nfans * sizeof(struct fcu_fan), M_FCU, 596213904Sandreast M_WAITOK | M_ZERO); 597213904Sandreast 598213904Sandreast ctx = device_get_sysctl_ctx(dev); 599213904Sandreast fanroot_oid = SYSCTL_ADD_NODE(ctx, 600213904Sandreast SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "fans", 601213904Sandreast CTLFLAG_RD, 0, "FCU Fan Information"); 602213904Sandreast 603213904Sandreast /* Now we can fill the properties into the allocated struct. */ 604213904Sandreast sc->sc_nfans = fcu_fill_fan_prop(dev); 605213904Sandreast 606222458Snwhitehorn /* Register fans with pmac_thermal */ 607222458Snwhitehorn for (i = 0; i < sc->sc_nfans; i++) 608222458Snwhitehorn pmac_thermal_fan_register(&sc->sc_fans[i].fan); 609222458Snwhitehorn 610213904Sandreast /* Add sysctls for the fans. */ 611213904Sandreast for (i = 0; i < sc->sc_nfans; i++) { 612222458Snwhitehorn for (j = 0; j < strlen(sc->sc_fans[i].fan.name); j++) { 613222458Snwhitehorn sysctl_name[j] = tolower(sc->sc_fans[i].fan.name[j]); 614213904Sandreast if (isspace(sysctl_name[j])) 615213904Sandreast sysctl_name[j] = '_'; 616213904Sandreast } 617213904Sandreast sysctl_name[j] = 0; 618213904Sandreast 619217286Sandreast if (sc->sc_fans[i].type == FCU_FAN_RPM) { 620217286Sandreast oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(fanroot_oid), 621217286Sandreast OID_AUTO, sysctl_name, 622217286Sandreast CTLFLAG_RD, 0, "Fan Information"); 623217286Sandreast SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 624217286Sandreast "minrpm", CTLTYPE_INT | CTLFLAG_RD, 625222458Snwhitehorn &(sc->sc_fans[i].fan.min_rpm), 626222458Snwhitehorn sizeof(int), "Minimum allowed RPM"); 627217286Sandreast SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 628217286Sandreast "maxrpm", CTLTYPE_INT | CTLFLAG_RD, 629222458Snwhitehorn &(sc->sc_fans[i].fan.max_rpm), 630222458Snwhitehorn sizeof(int), "Maximum allowed RPM"); 631217286Sandreast /* I use i to pass the fan id. */ 632217286Sandreast SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 633217286Sandreast "rpm", CTLTYPE_INT | CTLFLAG_RW, dev, i, 634217286Sandreast fcu_fanrpm_sysctl, "I", "Fan RPM"); 635217286Sandreast } else { 636217286Sandreast fcu_fan_get_pwm(dev, &sc->sc_fans[i], 637217286Sandreast &sc->sc_fans[i].setpoint, 638217286Sandreast &sc->sc_fans[i].rpm); 639217286Sandreast 640217286Sandreast oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(fanroot_oid), 641217286Sandreast OID_AUTO, sysctl_name, 642217286Sandreast CTLFLAG_RD, 0, "Fan Information"); 643217286Sandreast SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 644217286Sandreast "minpwm", CTLTYPE_INT | CTLFLAG_RD, 645222458Snwhitehorn &(sc->sc_fans[i].fan.min_rpm), 646222458Snwhitehorn sizeof(int), "Minimum allowed PWM in %"); 647217286Sandreast SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 648217286Sandreast "maxpwm", CTLTYPE_INT | CTLFLAG_RD, 649222458Snwhitehorn &(sc->sc_fans[i].fan.max_rpm), 650222458Snwhitehorn sizeof(int), "Maximum allowed PWM in %"); 651217286Sandreast /* I use i to pass the fan id or'ed with the type 652217286Sandreast * of info I want to display/modify. 653217286Sandreast */ 654217286Sandreast SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 655217286Sandreast "pwm", CTLTYPE_INT | CTLFLAG_RW, dev, 656217286Sandreast FCU_PWM_SYSCTL_PWM | i, 657217286Sandreast fcu_fanrpm_sysctl, "I", "Fan PWM in %"); 658217286Sandreast SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, 659217286Sandreast "rpm", CTLTYPE_INT | CTLFLAG_RD, dev, 660217286Sandreast FCU_PWM_SYSCTL_RPM | i, 661217286Sandreast fcu_fanrpm_sysctl, "I", "Fan RPM"); 662217286Sandreast } 663213904Sandreast } 664213904Sandreast 665213904Sandreast /* Dump fan location, type & RPM. */ 666213904Sandreast if (bootverbose) { 667213904Sandreast device_printf(dev, "Fans\n"); 668213904Sandreast for (i = 0; i < sc->sc_nfans; i++) { 669217286Sandreast device_printf(dev, "Location: %s type: %d ID: %d " 670222458Snwhitehorn "RPM: %d\n", sc->sc_fans[i].fan.name, 671213904Sandreast sc->sc_fans[i].type, sc->sc_fans[i].id, 672217286Sandreast (sc->sc_fans[i].type == FCU_FAN_RPM) ? 673217286Sandreast sc->sc_fans[i].setpoint : 674217286Sandreast sc->sc_fans[i].rpm ); 675213904Sandreast } 676213904Sandreast } 677213904Sandreast} 678