324 lines
8.3 KiB
C
324 lines
8.3 KiB
C
/* $NetBSD: fan53555.c,v 1.9 2021/01/27 02:29:48 thorpej Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2018 Jared McNeill <jmcneill@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,
|
|
®, 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);
|