Module Name: src
Committed By: macallan
Date: Tue Jul 27 20:23:42 UTC 2021
Modified Files:
src/sys/arch/macppc/conf: files.macppc
src/sys/dev/i2c: files.i2c
Added Files:
src/sys/arch/macppc/dev: fcu.c
Removed Files:
src/sys/dev/i2c: fcu.c
Log Message:
move the fcu driver into arch/macppc where it belongs
To generate a diff of this commit:
cvs rdiff -u -r1.119 -r1.120 src/sys/arch/macppc/conf/files.macppc
cvs rdiff -u -r0 -r1.1 src/sys/arch/macppc/dev/fcu.c
cvs rdiff -u -r1.13 -r0 src/sys/dev/i2c/fcu.c
cvs rdiff -u -r1.115 -r1.116 src/sys/dev/i2c/files.i2c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sys/arch/macppc/conf/files.macppc
diff -u src/sys/arch/macppc/conf/files.macppc:1.119 src/sys/arch/macppc/conf/files.macppc:1.120
--- src/sys/arch/macppc/conf/files.macppc:1.119 Fri Jun 18 22:24:51 2021
+++ src/sys/arch/macppc/conf/files.macppc Tue Jul 27 20:23:41 2021
@@ -1,4 +1,4 @@
-# $NetBSD: files.macppc,v 1.119 2021/06/18 22:24:51 macallan Exp $
+# $NetBSD: files.macppc,v 1.120 2021/07/27 20:23:41 macallan Exp $
#
# macppc-specific configuration info
@@ -326,3 +326,8 @@ device lmu: sysmon_envsys
attach lmu at iic
file arch/macppc/dev/lmu.c lmu
defflag opt_lmu.h LMU_DEBUG
+
+# Apple Fan Control Unit found in some G5
+device fcu: sysmon_envsys
+attach fcu at iic
+file arch/macppc/dev/fcu.c fcu needs-flag
Index: src/sys/dev/i2c/files.i2c
diff -u src/sys/dev/i2c/files.i2c:1.115 src/sys/dev/i2c/files.i2c:1.116
--- src/sys/dev/i2c/files.i2c:1.115 Mon Jan 4 22:09:35 2021
+++ src/sys/dev/i2c/files.i2c Tue Jul 27 20:23:41 2021
@@ -1,4 +1,4 @@
-# $NetBSD: files.i2c,v 1.115 2021/01/04 22:09:35 thorpej Exp $
+# $NetBSD: files.i2c,v 1.116 2021/07/27 20:23:41 macallan Exp $
obsolete defflag opt_i2cbus.h I2C_SCAN
define i2cbus { }
@@ -305,11 +305,6 @@ device em3027rtc: sysmon_envsys
attach em3027rtc at iic
file dev/i2c/em3027.c em3027rtc
-# Apple Fan Control Unit found in some G5
-device fcu: sysmon_envsys
-attach fcu at iic
-file dev/i2c/fcu.c fcu needs-flag
-
# Analog Devices AD7417 thermometer and ADC
device adadc: sysmon_envsys
attach adadc at iic
Added files:
Index: src/sys/arch/macppc/dev/fcu.c
diff -u /dev/null src/sys/arch/macppc/dev/fcu.c:1.1
--- /dev/null Tue Jul 27 20:23:42 2021
+++ src/sys/arch/macppc/dev/fcu.c Tue Jul 27 20:23:41 2021
@@ -0,0 +1,493 @@
+/* $NetBSD: fcu.c,v 1.1 2021/07/27 20:23:41 macallan Exp $ */
+
+/*-
+ * Copyright (c) 2018 Michael Lorenz
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__KERNEL_RCSID(0, "$NetBSD: fcu.c,v 1.1 2021/07/27 20:23:41 macallan Exp $");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/device.h>
+#include <sys/conf.h>
+#include <sys/bus.h>
+#include <sys/kthread.h>
+
+#include <dev/i2c/i2cvar.h>
+
+#include <dev/sysmon/sysmonvar.h>
+
+#include <dev/ofw/openfirm.h>
+
+//#define FCU_DEBUG
+#ifdef FCU_DEBUG
+#define DPRINTF printf
+#else
+#define DPRINTF if (0) printf
+#endif
+
+/* FCU registers, from OpenBSD's fcu.c */
+#define FCU_FAN_FAIL 0x0b /* fans states in bits 0<1-6>7 */
+#define FCU_FAN_ACTIVE 0x0d
+#define FCU_FANREAD(x) 0x11 + (x)*2
+#define FCU_FANSET(x) 0x10 + (x)*2
+#define FCU_PWM_FAIL 0x2b
+#define FCU_PWM_ACTIVE 0x2d
+#define FCU_PWMREAD(x) 0x30 + (x)*2
+
+#define FCU_MAX_FANS 10
+
+typedef struct _fcu_zone {
+ bool (*filter)(const envsys_data_t *);
+ int nfans;
+ int fans[FCU_MAX_FANS];
+ int threshold;
+} fcu_zone_t;
+
+typedef struct _fcu_fan {
+ int target;
+ int reg;
+ int base_rpm, max_rpm;
+ int step;
+ int duty; /* for pwm fans */
+} fcu_fan_t;
+
+#define FCU_ZONE_CPU 0
+#define FCU_ZONE_CASE 1
+#define FCU_ZONE_DRIVEBAY 2
+#define FCU_ZONE_COUNT 3
+
+struct fcu_softc {
+ device_t sc_dev;
+ i2c_tag_t sc_i2c;
+ i2c_addr_t sc_addr;
+
+ struct sysmon_envsys *sc_sme;
+ envsys_data_t sc_sensors[32];
+ int sc_nsensors;
+ fcu_zone_t sc_zones[FCU_ZONE_COUNT];
+ fcu_fan_t sc_fans[FCU_MAX_FANS];
+ int sc_nfans;
+ lwp_t *sc_thread;
+ bool sc_dying, sc_pwm;
+ uint8_t sc_eeprom0[160];
+ uint8_t sc_eeprom1[160];
+};
+
+static int fcu_match(device_t, cfdata_t, void *);
+static void fcu_attach(device_t, device_t, void *);
+
+static void fcu_sensors_refresh(struct sysmon_envsys *, envsys_data_t *);
+
+static bool is_cpu(const envsys_data_t *);
+static bool is_case(const envsys_data_t *);
+static bool is_drive(const envsys_data_t *);
+
+static void fcu_set_fan_rpm(struct fcu_softc *, fcu_fan_t *, int);
+static void fcu_adjust_zone(struct fcu_softc *, int);
+static void fcu_adjust(void *);
+
+CFATTACH_DECL_NEW(fcu, sizeof(struct fcu_softc),
+ fcu_match, fcu_attach, NULL, NULL);
+
+static const struct device_compatible_entry compat_data[] = {
+ { .compat = "fcu" },
+ DEVICE_COMPAT_EOL
+};
+
+static int
+fcu_match(device_t parent, cfdata_t match, void *aux)
+{
+ struct i2c_attach_args *ia = aux;
+ int match_result;
+
+ if (iic_use_direct_match(ia, match, compat_data, &match_result))
+ return match_result;
+
+ if (ia->ia_addr == 0x2f)
+ return I2C_MATCH_ADDRESS_ONLY;
+
+ return 0;
+}
+
+static void
+fcu_attach(device_t parent, device_t self, void *aux)
+{
+ struct fcu_softc *sc = device_private(self);
+ struct i2c_attach_args *ia = aux;
+ int have_eeprom1 = 1;
+
+ sc->sc_dev = self;
+ sc->sc_i2c = ia->ia_tag;
+ sc->sc_addr = ia->ia_addr;
+
+ aprint_naive("\n");
+ aprint_normal(": Fan Control Unit\n");
+
+ if (get_cpuid(0, sc->sc_eeprom0) < 160) {
+ /*
+ * XXX this should never happen, we depend on the EEPROM for
+ * calibration data to make sense of temperature and voltage
+ * sensors elsewhere, and fan parameters here.
+ */
+ aprint_error_dev(self, "no EEPROM data for CPU 0\n");
+ return;
+ }
+ if (get_cpuid(1, sc->sc_eeprom1) < 160)
+ have_eeprom1 = 0;
+
+ /* init zones */
+ sc->sc_zones[FCU_ZONE_CPU].filter = is_cpu;
+ sc->sc_zones[FCU_ZONE_CPU].threshold = 50;
+ sc->sc_zones[FCU_ZONE_CPU].nfans = 0;
+ sc->sc_zones[FCU_ZONE_CASE].filter = is_case;
+ sc->sc_zones[FCU_ZONE_CASE].threshold = 50;
+ sc->sc_zones[FCU_ZONE_CASE].nfans = 0;
+ sc->sc_zones[FCU_ZONE_DRIVEBAY].filter = is_drive;
+ sc->sc_zones[FCU_ZONE_DRIVEBAY].threshold = 30;
+ sc->sc_zones[FCU_ZONE_DRIVEBAY].nfans = 0;
+
+ sc->sc_sme = sysmon_envsys_create();
+ sc->sc_sme->sme_name = device_xname(self);
+ sc->sc_sme->sme_cookie = sc;
+ sc->sc_sme->sme_refresh = fcu_sensors_refresh;
+
+ sc->sc_sensors[0].units = ENVSYS_SFANRPM;
+ sc->sc_sensors[1].state = ENVSYS_SINVALID;
+ sc->sc_nfans = 0;
+
+ /* round up sensors */
+ int ch;
+
+ sc->sc_nsensors = 0;
+ ch = OF_child(ia->ia_cookie);
+ while (ch != 0) {
+ char type[32], descr[32];
+ uint32_t reg;
+
+ envsys_data_t *s = &sc->sc_sensors[sc->sc_nsensors];
+
+ s->state = ENVSYS_SINVALID;
+
+ if (OF_getprop(ch, "device_type", type, 32) <= 0)
+ goto next;
+
+ if (strcmp(type, "fan-rpm-control") == 0) {
+ s->units = ENVSYS_SFANRPM;
+ } else if (strcmp(type, "fan-pwm-control") == 0) {
+ /* XXX we get the type from the register number */
+ s->units = ENVSYS_SFANRPM;
+/* skip those for now since we don't really know how to interpret them */
+#if 0
+ } else if (strcmp(type, "power-sensor") == 0) {
+ s->units = ENVSYS_SVOLTS_DC;
+#endif
+ } else if (strcmp(type, "gpi-sensor") == 0) {
+ s->units = ENVSYS_INDICATOR;
+ } else {
+ /* ignore other types for now */
+ goto next;
+ }
+
+ if (OF_getprop(ch, "reg", ®, sizeof(reg)) <= 0)
+ goto next;
+ s->private = reg;
+
+ if (OF_getprop(ch, "location", descr, 32) <= 0)
+ goto next;
+ strcpy(s->desc, descr);
+
+ if (s->units == ENVSYS_SFANRPM) {
+ fcu_fan_t *fan = &sc->sc_fans[sc->sc_nfans];
+ uint8_t *eeprom = NULL;
+ uint16_t rmin, rmax;
+
+ if (strstr(descr, "CPU A") != NULL)
+ eeprom = sc->sc_eeprom0;
+ if (strstr(descr, "CPU B") != NULL) {
+ /*
+ * XXX
+ * this should never happen
+ */
+ if (have_eeprom1 == 0) {
+ eeprom = sc->sc_eeprom0;
+ } else
+ eeprom = sc->sc_eeprom1;
+ }
+
+ fan->reg = reg;
+ fan->target = 0;
+ fan->duty = 0x80;
+
+ /* speed settings from EEPROM */
+ if (strstr(descr, "PUMP") != NULL) {
+ KASSERT(eeprom != NULL);
+ memcpy(&rmin, &eeprom[0x54], 2);
+ memcpy(&rmax, &eeprom[0x56], 2);
+ fan->base_rpm = rmin;
+ fan->max_rpm = rmax;
+ fan->step = (rmax - rmin) / 30;
+ } else if (strstr(descr, "INTAKE") != NULL) {
+ KASSERT(eeprom != NULL);
+ memcpy(&rmin, &eeprom[0x4c], 2);
+ memcpy(&rmax, &eeprom[0x4e], 2);
+ fan->base_rpm = rmin;
+ fan->max_rpm = rmax;
+ fan->step = (rmax - rmin) / 30;
+ } else if (strstr(descr, "EXHAUST") != NULL) {
+ KASSERT(eeprom != NULL);
+ memcpy(&rmin, &eeprom[0x50], 2);
+ memcpy(&rmax, &eeprom[0x52], 2);
+ fan->base_rpm = rmin;
+ fan->max_rpm = rmax;
+ fan->step = (rmax - rmin) / 30;
+ } else if (strstr(descr, "DRIVE") != NULL ) {
+ fan->base_rpm = 1000;
+ fan->max_rpm = 3000;
+ fan->step = 100;
+ } else {
+ fan->base_rpm = 1000;
+ fan->max_rpm = 3000;
+ fan->step = 100;
+ }
+ DPRINTF("fan %s: %d - %d rpm, step %d\n",
+ descr, fan->base_rpm, fan->max_rpm, fan->step);
+
+ /* now stuff them into zones */
+ if (strstr(descr, "CPU") != NULL) {
+ fcu_zone_t *z = &sc->sc_zones[FCU_ZONE_CPU];
+ z->fans[z->nfans] = sc->sc_nfans;
+ z->nfans++;
+ } else if ((strstr(descr, "BACKSIDE") != NULL) ||
+ (strstr(descr, "SLOT") != NULL)) {
+ fcu_zone_t *z = &sc->sc_zones[FCU_ZONE_CASE];
+ z->fans[z->nfans] = sc->sc_nfans;
+ z->nfans++;
+ } else if (strstr(descr, "DRIVE") != NULL) {
+ fcu_zone_t *z = &sc->sc_zones[FCU_ZONE_DRIVEBAY];
+ z->fans[z->nfans] = sc->sc_nfans;
+ z->nfans++;
+ }
+ sc->sc_nfans++;
+ }
+ sysmon_envsys_sensor_attach(sc->sc_sme, s);
+ sc->sc_nsensors++;
+next:
+ ch = OF_peer(ch);
+ }
+ sysmon_envsys_register(sc->sc_sme);
+
+ sc->sc_dying = FALSE;
+ kthread_create(PRI_NONE, 0, curcpu(), fcu_adjust, sc, &sc->sc_thread,
+ "fan control");
+}
+
+static void
+fcu_sensors_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
+{
+ struct fcu_softc *sc = sme->sme_cookie;
+ uint8_t cmd;
+ uint16_t data = -1;
+ int error;
+
+ if (edata->units == ENVSYS_SFANRPM) {
+ cmd = edata->private + 1;
+ } else
+ cmd = edata->private;
+
+ /* fcu is a macppc only thing so we can safely assume big endian */
+ iic_acquire_bus(sc->sc_i2c, 0);
+ error = iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP,
+ sc->sc_addr, &cmd, 1, &data, 2, 0);
+ iic_release_bus(sc->sc_i2c, 0);
+
+ if (error) {
+ edata->state = ENVSYS_SINVALID;
+ return;
+ }
+
+ edata->state = ENVSYS_SVALID;
+
+ switch (edata->units) {
+ case ENVSYS_SFANRPM:
+ edata->value_cur = data >> 3;
+ break;
+ case ENVSYS_SVOLTS_DC:
+ /* XXX this reads bogus */
+ edata->value_cur = data * 1000;
+ break;
+ case ENVSYS_INDICATOR:
+ /* guesswork for now */
+ edata->value_cur = data >> 8;
+ break;
+ default:
+ edata->state = ENVSYS_SINVALID;
+ }
+}
+
+static bool
+is_cpu(const envsys_data_t *edata)
+{
+ if (edata->units != ENVSYS_STEMP)
+ return false;
+ if (strstr(edata->desc, "CPU") != NULL)
+ return TRUE;
+ return false;
+}
+
+static bool
+is_case(const envsys_data_t *edata)
+{
+ if (edata->units != ENVSYS_STEMP)
+ return false;
+ if ((strstr(edata->desc, "MLB") != NULL) ||
+ (strstr(edata->desc, "BACKSIDE") != NULL) ||
+ (strstr(edata->desc, "U3") != NULL))
+ return TRUE;
+ return false;
+}
+
+static bool
+is_drive(const envsys_data_t *edata)
+{
+ if (edata->units != ENVSYS_STEMP)
+ return false;
+ if (strstr(edata->desc, "DRIVE") != NULL)
+ return TRUE;
+ return false;
+}
+
+static void
+fcu_set_fan_rpm(struct fcu_softc *sc, fcu_fan_t *f, int speed)
+{
+ int error;
+ uint8_t cmd;
+
+ if (speed > f->max_rpm) speed = f->max_rpm;
+ if (speed < f->base_rpm) speed = f->base_rpm;
+
+ if (f->reg < 0x30) {
+ uint16_t data;
+ /* simple rpm fan, just poke the register */
+
+ if (f->target == speed) return;
+ iic_acquire_bus(sc->sc_i2c, 0);
+ cmd = f->reg;
+ data = (speed << 3);
+ error = iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP,
+ sc->sc_addr, &cmd, 1, &data, 2, 0);
+ iic_release_bus(sc->sc_i2c, 0);
+ } else {
+ int diff;
+ int nduty = f->duty;
+ uint16_t data;
+ /* pwm fan, measure speed, then adjust duty cycle */
+ DPRINTF("pwm fan ");
+ iic_acquire_bus(sc->sc_i2c, 0);
+ cmd = f->reg + 1;
+ error = iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP,
+ sc->sc_addr, &cmd, 1, &data, 2, 0);
+ data = data >> 3;
+ diff = data - speed;
+ DPRINTF("d %d s %d t %d diff %d ", f->duty, data, speed, diff);
+ if (diff > 100) {
+ nduty = uimax(20, nduty - 1);
+ }
+ if (diff < -100) {
+ nduty = uimin(0xd0, nduty + 1);
+ }
+ cmd = f->reg;
+ DPRINTF("%s nduty %d", __func__, nduty);
+ if (nduty != f->duty) {
+ uint8_t arg = nduty;
+ error = iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP,
+ sc->sc_addr, &cmd, 1, &arg, 1, 0);
+ f->duty = nduty;
+ sc->sc_pwm = TRUE;
+
+ }
+ iic_release_bus(sc->sc_i2c, 0);
+ DPRINTF("ok\n");
+ }
+ if (error) printf("boo\n");
+ f->target = speed;
+}
+
+static void
+fcu_adjust_zone(struct fcu_softc *sc, int which)
+{
+ fcu_zone_t *z = &sc->sc_zones[which];
+ fcu_fan_t *f;
+ int temp, i, speed, diff;
+
+ if (z->nfans <= 0)
+ return;
+
+ temp = sysmon_envsys_get_max_value(z->filter, true);
+ if (temp == 0) {
+ /* no sensor data - leave fan alone */
+ DPRINTF("nodata\n");
+ return;
+ }
+
+ temp = (temp - 273150000) / 1000000;
+ diff = temp - z->threshold;
+ if (diff < 0) diff = 0;
+
+ /* now adjust each fan to the new duty cycle */
+ for (i = 0; i < z->nfans; i++) {
+ if (z->fans[i] > 8) {
+ printf("wtf?!\n");
+ continue;
+ }
+ f = &sc->sc_fans[z->fans[i]];
+ speed = f->base_rpm + diff * f->step;
+ DPRINTF("diff %d base %d sp %d\n", diff, f->base_rpm, speed);
+ fcu_set_fan_rpm(sc, f, speed);
+ }
+}
+
+static void
+fcu_adjust(void *cookie)
+{
+ struct fcu_softc *sc = cookie;
+ int i;
+ uint8_t cmd, data;
+
+ while (!sc->sc_dying) {
+ /* poke the FCU so we don't go 747 */
+ iic_acquire_bus(sc->sc_i2c, 0);
+ cmd = FCU_FAN_ACTIVE;
+ iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP,
+ sc->sc_addr, &cmd, 1, &data, 1, 0);
+ iic_release_bus(sc->sc_i2c, 0);
+ sc->sc_pwm = FALSE;
+ for (i = 0; i < FCU_ZONE_COUNT; i++)
+ fcu_adjust_zone(sc, i);
+ kpause("fanctrl", true, mstohz(sc->sc_pwm ? 1000 : 5000), NULL);
+ }
+ kthread_exit(0);
+}
