/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2019 Ian Lepore <ian@freebsd.org>
 * Copyright (c) 2020-2021 Andriy Gapon
 * Copyright (c) 2022-2024 Bjoern A. Zeeb
 *
 * 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 AUTHOR 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 AUTHOR 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>
#include "opt_platform.h"

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/systm.h>

#ifdef FDT
#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>
#include <dev/ofw/openfirm.h>
#endif

#include <dev/iicbus/iicbus.h>
#include <dev/iicbus/iiconf.h>
#include "iicbus_if.h"
#include "iicmux_if.h"
#include <dev/iicbus/mux/iicmux.h>

enum pca954x_type {
        PCA954X_MUX,
        PCA954X_SW,
};

struct pca954x_descr {
        const char              *partname;
        const char              *description;
        enum pca954x_type       type;
        uint8_t                 numchannels;
        uint8_t                 enable;
};

static struct pca954x_descr pca9540_descr = {
        .partname = "pca9540",
        .description = "PCA9540B I2C Mux",
        .type = PCA954X_MUX,
        .numchannels = 2,
        .enable = 0x04,
};

static struct pca954x_descr pca9546_descr = {
        .partname = "pca9546",
        .description = "PCA9546 I2C Switch",
        .type = PCA954X_SW,
        .numchannels = 4,
};

static struct pca954x_descr pca9547_descr = {
        .partname = "pca9547",
        .description = "PCA9547 I2C Mux",
        .type = PCA954X_MUX,
        .numchannels = 8,
        .enable = 0x08,
};

static struct pca954x_descr pca9548_descr = {
        .partname = "pca9548",
        .description = "PCA9548A I2C Switch",
        .type = PCA954X_SW,
        .numchannels = 8,
};

#ifdef FDT
static struct ofw_compat_data compat_data[] = {
        { "nxp,pca9540", (uintptr_t)&pca9540_descr },
        { "nxp,pca9546", (uintptr_t)&pca9546_descr },
        { "nxp,pca9547", (uintptr_t)&pca9547_descr },
        { "nxp,pca9548", (uintptr_t)&pca9548_descr },
        { NULL, 0 },
};
#else
static struct pca954x_descr *part_descrs[] = {
        &pca9540_descr,
        &pca9546_descr,
        &pca9547_descr,
        &pca9548_descr,
};
#endif

struct pca954x_softc {
        struct iicmux_softc mux;
        const struct pca954x_descr *descr;
        uint8_t addr;
        bool idle_disconnect;
};

static int
pca954x_bus_select(device_t dev, int busidx, struct iic_reqbus_data *rd)
{
        struct pca954x_softc *sc;
        struct iic_msg msg;
        int error;
        uint8_t busbits;

        sc = device_get_softc(dev);

        /*
         * The iicmux caller ensures busidx is between 0 and the number of buses
         * we passed to iicmux_init_softc(), no need for validation here.  If
         * the fdt data has the idle_disconnect property we idle the bus by
         * selecting no downstream buses, otherwise we just leave the current
         * bus active.
         */
        if (busidx == IICMUX_SELECT_IDLE) {
                if (sc->idle_disconnect)
                        busbits = 0;
                else
                        return (0);
        } else if (sc->descr->type == PCA954X_MUX) {
                uint8_t en;

                en = sc->descr->enable;
                KASSERT(en > 0 && powerof2(en), ("%s: %s enable %#x "
                    "invalid\n", __func__, sc->descr->partname, en));
                busbits = en | (busidx & (en - 1));
        } else if (sc->descr->type == PCA954X_SW) {
                busbits = 1u << busidx;
        } else {
                panic("%s: %s: unsupported type %d\n",
                    __func__, sc->descr->partname, sc->descr->type);
        }

        msg.slave = sc->addr;
        msg.flags = IIC_M_WR;
        msg.len = 1;
        msg.buf = &busbits;
        error = iicbus_transfer(dev, &msg, 1);
        return (error);
}

static const struct pca954x_descr *
pca954x_find_chip(device_t dev)
{
#ifdef FDT
        const struct ofw_compat_data *compat;

        if (!ofw_bus_status_okay(dev))
                return (NULL);

        compat = ofw_bus_search_compatible(dev, compat_data);
        if (compat == NULL)
                return (NULL);
        return ((const struct pca954x_descr *)compat->ocd_data);
#else
        const char *type;
        int i;

        if (resource_string_value(device_get_name(dev), device_get_unit(dev),
            "chip_type", &type) == 0) {
                for (i = 0; i < nitems(part_descrs) - 1; ++i) {
                        if (strcasecmp(type, part_descrs[i]->partname) == 0)
                                return (part_descrs[i]);
                }
        }
        return (NULL);
#endif
}

static int
pca954x_probe(device_t dev)
{
        const struct pca954x_descr *descr;

        descr = pca954x_find_chip(dev);
        if (descr == NULL)
                return (ENXIO);

        device_set_desc(dev, descr->description);
        return (BUS_PROBE_DEFAULT);
}

static int
pca954x_attach(device_t dev)
{
        struct pca954x_softc *sc;
        const struct pca954x_descr *descr;
        int error;

        sc = device_get_softc(dev);
        sc->addr = iicbus_get_addr(dev);
        sc->idle_disconnect = device_has_property(dev, "i2c-mux-idle-disconnect");

        sc->descr = descr = pca954x_find_chip(dev);
        error = iicmux_attach(dev, device_get_parent(dev), descr->numchannels);
        if (error == 0)
                bus_attach_children(dev);

        return (error);
}

static int
pca954x_detach(device_t dev)
{
        int error;

        error = iicmux_detach(dev);
        return (error);
}

static device_method_t pca954x_methods[] = {
        /* device methods */
        DEVMETHOD(device_probe,                 pca954x_probe),
        DEVMETHOD(device_attach,                pca954x_attach),
        DEVMETHOD(device_detach,                pca954x_detach),

        /* iicmux methods */
        DEVMETHOD(iicmux_bus_select,            pca954x_bus_select),

        DEVMETHOD_END
};

DEFINE_CLASS_1(pca954x, pca954x_driver, pca954x_methods,
    sizeof(struct pca954x_softc), iicmux_driver);
DRIVER_MODULE(pca954x, iicbus, pca954x_driver, 0, 0);

#ifdef FDT
DRIVER_MODULE(ofw_iicbus, pca954x, ofw_iicbus_driver, 0, 0);
#else
DRIVER_MODULE(iicbus, pca954x, iicbus_driver, 0, 0);
#endif

MODULE_DEPEND(pca954x, iicmux, 1, 1, 1);
MODULE_DEPEND(pca954x, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
MODULE_VERSION(pca954x, 1);

#ifdef FDT
IICBUS_FDT_PNP_INFO(compat_data);
#endif