xref: /src/sys/dev/i2c/fan53555.c

/* $NetBSD: fan53555.c,v 1.9 2021/01/27 02:29:48 thorpej Exp $ */

/*-
 * Copyright (c) 2018 Jared McNeill <jmcneill (at) invisible.ca>
 * 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: fan53555.c,v 1.9 2021/01/27 02:29:48 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <sys/bus.h>
#include <sys/kmem.h>

#include <dev/i2c/i2cvar.h>

#include <dev/fdt/fdtvar.h>

#define	VSEL0_REG		0x00
#define	VSEL1_REG		0x01
#define	 VSEL_BUCK_EN			__BIT(7)
#define	 VSEL_MODE			__BIT(6)
#define	 VSEL_NSEL			__BITS(5,0)
#define	CONTROL_REG		0x02
#define	 CONTROL_OUTPUT_DISCHARGE	__BIT(7)
#define	 CONTROL_SLEW			__BITS(6,4)
#define	 CONTROL_RESET			__BIT(2)
#define	ID1_REG			0x03
#define	 ID1_VENDOR			__BITS(7,5)
#define	 ID1_DIE_ID			__BITS(3,0)
#define	  SILERGY_DIE_ID_SYR82X		8
#define	  SILERGY_DIE_ID_SYR83X		9
#define	ID2_REG			0x04
#define	 ID2_DIE_REV			__BITS(3,0)
#define	MONITOR_REG		0x05
#define	 MONITOR_PGOOD			__BIT(7)

struct fan53555_softc {
	device_t	sc_dev;
	i2c_tag_t	sc_i2c;
	i2c_addr_t	sc_addr;
	int		sc_phandle;

	u_int		sc_suspend_reg;
	u_int		sc_runtime_reg;

	u_int		sc_base;
	u_int		sc_step;

	u_int		sc_ramp_delay;
	u_int		sc_suspend_voltage_selector;
};

enum fan53555_vendor {
	FAN_VENDOR_FAIRCHILD = 1,
	FAN_VENDOR_SILERGY,
};

/*
 * Transition slew rates.
 * Array index is reg value, value is slew rate in uV / us
 */
static const int fan53555_slew_rates[] = {
	64000, 32000, 16000, 8000, 4000, 2000, 1000, 500
};

static const struct device_compatible_entry compat_data[] = {
	{ .compat = "silergy,syr827",	.value = FAN_VENDOR_SILERGY },
	{ .compat = "silergy,syr828",	.value = FAN_VENDOR_SILERGY },
	DEVICE_COMPAT_EOL
};

static uint8_t
fan53555_read(struct fan53555_softc *sc, uint8_t reg, int flags)
{
	uint8_t val = 0;
	int error;

	error = iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP, sc->sc_addr,
	    &reg, 1, &val, 1, flags);
	if (error != 0)
		aprint_error_dev(sc->sc_dev, "error reading reg %#x: %d\n", reg, error);

	return val;
}

static void
fan53555_write(struct fan53555_softc *sc, uint8_t reg, uint8_t val, int flags)
{
	uint8_t buf[2];
	int error;

	buf[0] = reg;
	buf[1] = val;

	error = iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, sc->sc_addr,
	    NULL, 0, buf, 2, flags);
	if (error != 0)
		aprint_error_dev(sc->sc_dev, "error writing reg %#x: %d\n", reg, error);
}

#define	I2C_READ(sc, reg)	fan53555_read((sc), (reg), 0)
#define	I2C_WRITE(sc, reg, val)	fan53555_write((sc), (reg), (val), 0)
#define	I2C_LOCK(sc)		iic_acquire_bus((sc)->sc_i2c, 0)
#define	I2C_UNLOCK(sc)		iic_release_bus((sc)->sc_i2c, 0)

static int
fan53555_acquire(device_t dev)
{
	return 0;
}

static void
fan53555_release(device_t dev)
{
}

static int
fan53555_enable(device_t dev, bool enable)
{
	struct fan53555_softc * const sc = device_private(dev);
	uint8_t val;

	I2C_LOCK(sc);
	val = I2C_READ(sc, sc->sc_runtime_reg);
	if (enable)
		val |= VSEL_BUCK_EN;
	else
		val &= ~VSEL_BUCK_EN;
	I2C_WRITE(sc, sc->sc_runtime_reg, val);
	I2C_UNLOCK(sc);

	if (sc->sc_ramp_delay)
		delay(sc->sc_ramp_delay);

	return 0;
}

static int
fan53555_set_voltage(device_t dev, u_int min_uvol, u_int max_uvol)
{
	struct fan53555_softc * const sc = device_private(dev);
	uint8_t val, oval;
	u_int cur_uvol;

	I2C_LOCK(sc);

	/* Get current voltage */
	oval = I2C_READ(sc, sc->sc_runtime_reg);
	cur_uvol = __SHIFTOUT(oval, VSEL_NSEL) * sc->sc_step + sc->sc_base;

	/* Set new voltage */
	val = oval & ~VSEL_NSEL;
	val |= __SHIFTIN((min_uvol - sc->sc_base) / sc->sc_step, VSEL_NSEL);
	I2C_WRITE(sc, sc->sc_runtime_reg, val);

	I2C_UNLOCK(sc);

	/* Time to delay is based on the number of voltage steps */
	if (sc->sc_ramp_delay)
		delay((abs(cur_uvol - min_uvol) / sc->sc_step) * sc->sc_ramp_delay);

	return 0;
}

static int
fan53555_get_voltage(device_t dev, u_int *puvol)
{
	struct fan53555_softc * const sc = device_private(dev);
	uint8_t val;

	I2C_LOCK(sc);
	val = I2C_READ(sc, sc->sc_runtime_reg);
	I2C_UNLOCK(sc);

	*puvol = __SHIFTOUT(val, VSEL_NSEL) * sc->sc_step + sc->sc_base;

	return 0;
}

static struct fdtbus_regulator_controller_func fan53555_funcs = {
	.acquire = fan53555_acquire,
	.release = fan53555_release,
	.enable = fan53555_enable,
	.set_voltage = fan53555_set_voltage,
	.get_voltage = fan53555_get_voltage,
};

static int
fan53555_init(struct fan53555_softc *sc, enum fan53555_vendor vendor)
{
	uint8_t id1, control;
	int n;

	I2C_LOCK(sc);
	id1 = I2C_READ(sc, ID1_REG);
	I2C_UNLOCK(sc);

	const u_int die_id = __SHIFTOUT(id1, ID1_DIE_ID);

	aprint_naive("\n");
	switch (vendor) {
	case FAN_VENDOR_SILERGY:
		switch (die_id) {
		case SILERGY_DIE_ID_SYR82X:
			aprint_normal(": Silergy SYR82X\n");
			sc->sc_base = 712500;
			sc->sc_step = 12500;
			break;
		case SILERGY_DIE_ID_SYR83X:
			aprint_normal(": Silergy SYR83X\n");
			sc->sc_base = 712500;
			sc->sc_step = 12500;
			break;
		default:
			aprint_error(": Unsupported Silergy chip (0x%x)\n", die_id);
			return ENXIO;
		}
		break;
	default:
		aprint_error(": Unsupported vendor (%d)\n", vendor);
		return ENXIO;
	}

	sc->sc_suspend_voltage_selector = -1;
	of_getprop_uint32(sc->sc_phandle, "fcs,suspend-voltage-selector",
	    &sc->sc_suspend_voltage_selector);
	switch (sc->sc_suspend_voltage_selector) {
	case 0:
		sc->sc_suspend_reg = VSEL0_REG;
		sc->sc_runtime_reg = VSEL1_REG;
		break;
	case 1:
		sc->sc_suspend_reg = VSEL1_REG;
		sc->sc_runtime_reg = VSEL0_REG;
		break;
	default:
		aprint_error_dev(sc->sc_dev, "unsupported 'fcs,suspend-voltage-selector' value %u\n", sc->sc_suspend_voltage_selector);
		return EINVAL;
	}

	of_getprop_uint32(sc->sc_phandle, "regulator-ramp-delay",
	    &sc->sc_ramp_delay);
	if (sc->sc_ramp_delay) {
		for (n = 0; n < __arraycount(fan53555_slew_rates); n++)
			if (sc->sc_ramp_delay > fan53555_slew_rates[n])
				break;
		if (n == __arraycount(fan53555_slew_rates)) {
			aprint_error_dev(sc->sc_dev, "unsupported 'regulator-ramp-delay' value %u\n", sc->sc_ramp_delay);
			return EINVAL;
		}
		I2C_LOCK(sc);
		control = I2C_READ(sc, CONTROL_REG);
		control &= ~CONTROL_SLEW;
		control |= __SHIFTIN(fan53555_slew_rates[n], CONTROL_SLEW);
		I2C_WRITE(sc, CONTROL_REG, control);
		I2C_UNLOCK(sc);
	}

	return 0;
}

static int
fan53555_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;

	return 0;
}

static void
fan53555_attach(device_t parent, device_t self, void *aux)
{
	struct fan53555_softc * const sc = device_private(self);
	const struct device_compatible_entry *compat;
	struct i2c_attach_args *ia = aux;

	sc->sc_dev = self;
	sc->sc_i2c = ia->ia_tag;
	sc->sc_addr = ia->ia_addr;
	sc->sc_phandle = ia->ia_cookie;

	compat = iic_compatible_lookup(ia, compat_data);
	KASSERT(compat != NULL);

	if (fan53555_init(sc, compat->value) != 0)
		return;

	fdtbus_register_regulator_controller(self, sc->sc_phandle,
	    &fan53555_funcs);
}

CFATTACH_DECL_NEW(fan53555reg, sizeof(struct fan53555_softc),
    fan53555_match, fan53555_attach, NULL, NULL);