/* $NetBSD: fcu.c,v 1.5 2022/04/08 10:17:53 andvar 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.5 2022/04/08 10:17:53 andvar 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 <sys/sysctl.h>

#include <dev/i2c/i2cvar.h>

#include <dev/sysmon/sysmonvar.h>

#include <dev/ofw/openfirm.h>

#include <macppc/dev/fancontrolvar.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


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 sysctlnode 	*sc_sysctl_me;
	struct sysmon_envsys	*sc_sme;
	envsys_data_t		sc_sensors[32];
	int			sc_nsensors;
	fancontrol_zone_t	sc_zones[FCU_ZONE_COUNT];
	fcu_fan_t		sc_fans[FANCONTROL_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 int fcu_set_rpm(void *, int, int);
static int fcu_get_rpm(void *, 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, i;

	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");

	sysctl_createv(NULL, 0, NULL, (void *) &sc->sc_sysctl_me,
	    CTLFLAG_READWRITE,
	    CTLTYPE_NODE, device_xname(sc->sc_dev), NULL,
	    NULL, 0, NULL, 0,
	    CTL_MACHDEP, CTL_CREATE, CTL_EOL);

	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].name = "CPUs";
	sc->sc_zones[FCU_ZONE_CPU].filter = is_cpu;
	sc->sc_zones[FCU_ZONE_CPU].cookie = sc;
	sc->sc_zones[FCU_ZONE_CPU].get_rpm = fcu_get_rpm;
	sc->sc_zones[FCU_ZONE_CPU].set_rpm = fcu_set_rpm;
	sc->sc_zones[FCU_ZONE_CPU].Tmin = 50;
	sc->sc_zones[FCU_ZONE_CPU].Tmax = 85;
	sc->sc_zones[FCU_ZONE_CPU].nfans = 0;
	sc->sc_zones[FCU_ZONE_CASE].name = "Slots";
	sc->sc_zones[FCU_ZONE_CASE].filter = is_case;
	sc->sc_zones[FCU_ZONE_CASE].cookie = sc;
	sc->sc_zones[FCU_ZONE_CASE].Tmin = 50;
	sc->sc_zones[FCU_ZONE_CASE].Tmax = 75;
	sc->sc_zones[FCU_ZONE_CASE].nfans = 0;
	sc->sc_zones[FCU_ZONE_CASE].get_rpm = fcu_get_rpm;
	sc->sc_zones[FCU_ZONE_CASE].set_rpm = fcu_set_rpm;
	sc->sc_zones[FCU_ZONE_DRIVEBAY].name = "Drivebays";
	sc->sc_zones[FCU_ZONE_DRIVEBAY].filter = is_drive;
	sc->sc_zones[FCU_ZONE_DRIVEBAY].cookie = sc;
	sc->sc_zones[FCU_ZONE_DRIVEBAY].get_rpm = fcu_get_rpm;
	sc->sc_zones[FCU_ZONE_DRIVEBAY].set_rpm = fcu_set_rpm;
	sc->sc_zones[FCU_ZONE_DRIVEBAY].Tmin = 30;
	sc->sc_zones[FCU_ZONE_DRIVEBAY].Tmax = 50;
	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", &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) {
				fancontrol_zone_t *z = &sc->sc_zones[FCU_ZONE_CPU];
				z->fans[z->nfans].num = sc->sc_nfans;
				z->fans[z->nfans].min_rpm = fan->base_rpm;
				z->fans[z->nfans].max_rpm = fan->max_rpm;
				z->fans[z->nfans].name = s->desc;
				z->nfans++;
			} else if ((strstr(descr, "BACKSIDE") != NULL) ||
				   (strstr(descr, "SLOT") != NULL))  {
				fancontrol_zone_t *z = &sc->sc_zones[FCU_ZONE_CASE];
				z->fans[z->nfans].num = sc->sc_nfans;
				z->fans[z->nfans].min_rpm = fan->base_rpm;
				z->fans[z->nfans].max_rpm = fan->max_rpm;
				z->fans[z->nfans].name = s->desc;
				z->nfans++;
			} else if (strstr(descr, "DRIVE") != NULL) {
				fancontrol_zone_t *z = &sc->sc_zones[FCU_ZONE_DRIVEBAY];
				z->fans[z->nfans].num = sc->sc_nfans;
				z->fans[z->nfans].min_rpm = fan->base_rpm;
				z->fans[z->nfans].max_rpm = fan->max_rpm;
				z->fans[z->nfans].name = s->desc;
				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);

	/* setup sysctls for our zones etc. */
	for (i = 0; i < FCU_ZONE_COUNT; i++) {
		fancontrol_init_zone(&sc->sc_zones[i], sc->sc_sysctl_me);
	}

	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 int
fcu_get_rpm(void *cookie, int which)
{
	struct fcu_softc *sc = cookie;
	fcu_fan_t *f = &sc->sc_fans[which];
	int error;
	uint16_t data;
	uint8_t cmd;

	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);
	iic_release_bus(sc->sc_i2c, 0);
	if (error != 0) return -1;
	data = data >> 3;
	return data;
}

static int
fcu_set_rpm(void *cookie, int which, int speed)
{
	struct fcu_softc *sc = cookie;
	fcu_fan_t *f = &sc->sc_fans[which];
	int error = 0;
	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 0;
		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;
		int current_speed;
		/* pwm fan, measure speed, then adjust duty cycle */
		DPRINTF("pwm fan ");
		current_speed = fcu_get_rpm(sc, which);
		diff = current_speed - speed;
		DPRINTF("d %d s %d t %d diff %d ", f->duty, current_speed, 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;
			iic_acquire_bus(sc->sc_i2c, 0);
			error = iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP,
			    sc->sc_addr, &cmd, 1, &arg, 1, 0);
			iic_release_bus(sc->sc_i2c, 0);
			f->duty = nduty;
			sc->sc_pwm = TRUE;

		}
		DPRINTF("ok\n");
	}
	if (error) printf("boo\n");
	f->target = speed;
	return 0;
}

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++)
			fancontrol_adjust_zone(&sc->sc_zones[i]);
		/*
		 * take a shorter nap if we're in the process of adjusting a
		 * PWM fan, which relies on measuring speed and then changing
		 * its duty cycle until we're reasonable close to the target
		 * speed
		 */
		kpause("fanctrl", true, mstohz(sc->sc_pwm ? 1000 : 2000), NULL);
	}
	kthread_exit(0);
}