/*      $OpenBSD: bd718x7.c,v 1.5 2022/06/28 23:43:12 naddy Exp $       */
/*
 * Copyright (c) 2019 Patrick Wildt <patrick@blueri.se>
 * Copyright (c) 2017 Mark Kettenis <kettenis@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/malloc.h>

#include <dev/ofw/openfirm.h>
#include <dev/ofw/ofw_regulator.h>
#include <dev/ofw/fdt.h>

#include <dev/i2c/i2cvar.h>

#define BDPMIC_REGLOCK                  0x2f
#define  BDPMIC_REGLOCK_PWRSEQ                  (1 << 0)
#define  BDPMIC_REGLOCK_VREG                    (1 << 4)

struct bdpmic_regdata {
        const char *name;
        uint8_t reg, mask;
        uint32_t base, delta;
};

const struct bdpmic_regdata bd71837_regdata[] = {
        { "BUCK2", 0x10, 0x3f, 700000, 10000 },
        { }
};

const struct bdpmic_regdata bd71847_regdata[] = {
        { "BUCK2", 0x10, 0x3f, 700000, 10000 },
        { }
};

struct bdpmic_softc {
        struct device   sc_dev;
        i2c_tag_t       sc_tag;
        i2c_addr_t      sc_addr;

        const struct bdpmic_regdata *sc_regdata;
};

int     bdpmic_match(struct device *, void *, void *);
void    bdpmic_attach(struct device *, struct device *, void *);

void    bdpmic_attach_regulator(struct bdpmic_softc *, int);
uint8_t bdpmic_reg_read(struct bdpmic_softc *, int);
void    bdpmic_reg_write(struct bdpmic_softc *, int, uint8_t);

const struct cfattach bdpmic_ca = {
        sizeof(struct bdpmic_softc), bdpmic_match, bdpmic_attach
};

struct cfdriver bdpmic_cd = {
        NULL, "bdpmic", DV_DULL
};

int
bdpmic_match(struct device *parent, void *match, void *aux)
{
        struct i2c_attach_args *ia = aux;

        return (strcmp(ia->ia_name, "rohm,bd71837") == 0 ||
            strcmp(ia->ia_name, "rohm,bd71847") == 0);
}

void
bdpmic_attach(struct device *parent, struct device *self, void *aux)
{
        struct bdpmic_softc *sc = (struct bdpmic_softc *)self;
        struct i2c_attach_args *ia = aux;
        int node = *(int *)ia->ia_cookie;
        const char *chip;

        sc->sc_tag = ia->ia_tag;
        sc->sc_addr = ia->ia_addr;

        if (OF_is_compatible(node, "rohm,bd71837")) {
                chip = "BD71837";
                sc->sc_regdata = bd71837_regdata;
        } else {
                chip = "BD71847";
                sc->sc_regdata = bd71847_regdata;
        }
        printf(": %s\n", chip);

        node = OF_getnodebyname(node, "regulators");
        if (node == 0)
                return;
        for (node = OF_child(node); node; node = OF_peer(node))
                bdpmic_attach_regulator(sc, node);
}

struct bdpmic_regulator {
        struct bdpmic_softc *bd_sc;

        uint8_t bd_reg, bd_mask;
        uint32_t bd_base, bd_delta;

        struct regulator_device bd_rd;
};

uint32_t bdpmic_get_voltage(void *);
int     bdpmic_set_voltage(void *, uint32_t);

void
bdpmic_attach_regulator(struct bdpmic_softc *sc, int node)
{
        struct bdpmic_regulator *bd;
        char name[32];
        int i;

        name[0] = 0;
        OF_getprop(node, "name", name, sizeof(name));
        name[sizeof(name) - 1] = 0;
        for (i = 0; sc->sc_regdata[i].name; i++) {
                if (strcmp(sc->sc_regdata[i].name, name) == 0)
                        break;
        }
        if (sc->sc_regdata[i].name == NULL)
                return;

        bd = malloc(sizeof(*bd), M_DEVBUF, M_WAITOK | M_ZERO);
        bd->bd_sc = sc;

        bd->bd_reg = sc->sc_regdata[i].reg;
        bd->bd_mask = sc->sc_regdata[i].mask;
        bd->bd_base = sc->sc_regdata[i].base;
        bd->bd_delta = sc->sc_regdata[i].delta;

        bd->bd_rd.rd_node = node;
        bd->bd_rd.rd_cookie = bd;
        bd->bd_rd.rd_get_voltage = bdpmic_get_voltage;
        bd->bd_rd.rd_set_voltage = bdpmic_set_voltage;
        regulator_register(&bd->bd_rd);
}

uint32_t
bdpmic_get_voltage(void *cookie)
{
        struct bdpmic_regulator *bd = cookie;
        uint8_t vsel;

        vsel = bdpmic_reg_read(bd->bd_sc, bd->bd_reg);
        return bd->bd_base + (vsel & bd->bd_mask) * bd->bd_delta;
}

int
bdpmic_set_voltage(void *cookie, uint32_t voltage)
{
        struct bdpmic_regulator *bd = cookie;
        uint32_t vmin = bd->bd_base;
        uint32_t vmax = vmin + bd->bd_mask * bd->bd_delta;
        uint8_t vsel;

        if (voltage < vmin || voltage > vmax)
                return EINVAL;

        /* Unlock */
        bdpmic_reg_write(bd->bd_sc, BDPMIC_REGLOCK,
            BDPMIC_REGLOCK_PWRSEQ);

        vsel = bdpmic_reg_read(bd->bd_sc, bd->bd_reg);
        vsel &= ~bd->bd_mask;
        vsel |= (voltage - bd->bd_base) / bd->bd_delta;
        bdpmic_reg_write(bd->bd_sc, bd->bd_reg, vsel);

        /* Lock */
        bdpmic_reg_write(bd->bd_sc, BDPMIC_REGLOCK,
            BDPMIC_REGLOCK_PWRSEQ | BDPMIC_REGLOCK_VREG);

        return 0;
}

uint8_t
bdpmic_reg_read(struct bdpmic_softc *sc, int reg)
{
        uint8_t cmd = reg;
        uint8_t val;
        int error;

        iic_acquire_bus(sc->sc_tag, I2C_F_POLL);
        error = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr,
            &cmd, sizeof cmd, &val, sizeof val, I2C_F_POLL);
        iic_release_bus(sc->sc_tag, I2C_F_POLL);

        if (error) {
                printf("%s: can't read register 0x%02x\n",
                    sc->sc_dev.dv_xname, reg);
                val = 0xff;
        }

        return val;
}

void
bdpmic_reg_write(struct bdpmic_softc *sc, int reg, uint8_t val)
{
        uint8_t cmd = reg;
        int error;

        iic_acquire_bus(sc->sc_tag, I2C_F_POLL);
        error = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_addr,
            &cmd, sizeof cmd, &val, sizeof val, I2C_F_POLL);
        iic_release_bus(sc->sc_tag, I2C_F_POLL);

        if (error) {
                printf("%s: can't write register 0x%02x\n",
                    sc->sc_dev.dv_xname, reg);
        }
}