/* $NetBSD: fan53555.c,v 1.9 2021/01/27 02:29:48 thorpej Exp $ */
/*-
* Copyright (c) 2018 Jared McNeill <
[email protected]>
* 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,
®, 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);
