/* $OpenBSD: imxiic_acpi.c,v 1.4 2022/04/06 18:59:27 naddy Exp $ */
/*
 * Copyright (c) 2015, 2016 joshua stein <jcs@openbsd.org>
 * Copyright (c) 2020 Patrick Wildt <patrick@blueri.se>
 *
 * Permission to use, copy, modify, and/or 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/kernel.h>

#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>
#include <dev/acpi/acpidev.h>
#include <dev/acpi/amltypes.h>
#include <dev/acpi/dsdt.h>

#include <dev/ic/imxiicvar.h>

struct imxiic_acpi_softc {
        struct imxiic_softc     ac_sc;
        struct acpi_softc       *ac_acpi;
        struct aml_node         *ac_devnode;
        struct device           *ac_iic;
};

struct imxiic_crs {
        uint16_t i2c_addr;
        struct aml_node *devnode;
};

int     imxiic_acpi_match(struct device *, void *, void *);
void    imxiic_acpi_attach(struct device *, struct device *, void *);

int     imxiic_acpi_parse_crs(int, union acpi_resource *, void *);
void    imxiic_acpi_bus_scan(struct device *, struct i2cbus_attach_args *,
            void *);
int     imxiic_acpi_found_hid(struct aml_node *, void *);

const struct cfattach imxiic_acpi_ca = {
        sizeof(struct imxiic_acpi_softc),
        imxiic_acpi_match,
        imxiic_acpi_attach,
        NULL,
        NULL,
};

const char *imxiic_hids[] = {
        "NXP0001",
        NULL
};

int
imxiic_acpi_match(struct device *parent, void *match, void *aux)
{
        struct acpi_attach_args *aaa = aux;
        struct cfdata *cf = match;

        if (aaa->aaa_naddr < 1)
                return 0;
        return acpi_matchhids(aaa, imxiic_hids, cf->cf_driver->cd_name);
}

void
imxiic_acpi_attach(struct device *parent, struct device *self, void *aux)
{
        struct imxiic_acpi_softc *ac = (struct imxiic_acpi_softc *)self;
        struct imxiic_softc *sc = &ac->ac_sc;
        struct acpi_attach_args *aaa = aux;
        struct i2cbus_attach_args iba;

        ac->ac_acpi = (struct acpi_softc *)parent;
        ac->ac_devnode = aaa->aaa_node;

        printf(" %s", ac->ac_devnode->name);

        printf(" addr 0x%llx/0x%llx", aaa->aaa_addr[0], aaa->aaa_size[0]);

        sc->sc_iot = aaa->aaa_bst[0];
        if (bus_space_map(sc->sc_iot, aaa->aaa_addr[0], aaa->aaa_size[0],
            0, &sc->sc_ioh)) {
                printf(": can't map registers\n");
                return;
        }

        sc->sc_reg_shift = 0;
        sc->sc_clk_div = imxiic_vf610_clk_div;
        sc->sc_clk_ndiv = nitems(imxiic_vf610_clk_div);
        sc->sc_type = I2C_TYPE_VF610;

        /*
         * Older versions of the ACPI tables for this device had the naming for
         * the clkrate and bitrate confused.  For those, keep the old value of
         * 100 kHz.
         */
        sc->sc_clkrate = acpi_getpropint(ac->ac_devnode,
            "uefi-clock-frequency", 0) / 1000;
        sc->sc_bitrate = acpi_getpropint(ac->ac_devnode,
            "clock-frequency", 0) / 1000;
        if (sc->sc_clkrate == 0) {
                sc->sc_clkrate = acpi_getpropint(ac->ac_devnode,
                    "clock-frequency", 0) / 1000;
                sc->sc_bitrate = 100000 / 1000;
        }
        if (sc->sc_clkrate == 0) {
                printf(": clock frequency unknown\n");
                return;
        }

        printf("\n");

        imxiic_setspeed(sc, sc->sc_bitrate);
        imxiic_enable(sc, 0);

        sc->stopped = 1;
        rw_init(&sc->sc_buslock, sc->sc_dev.dv_xname);

        sc->i2c_tag.ic_cookie = sc;
        sc->i2c_tag.ic_acquire_bus = imxiic_i2c_acquire_bus;
        sc->i2c_tag.ic_release_bus = imxiic_i2c_release_bus;
        sc->i2c_tag.ic_exec = imxiic_i2c_exec;

        bzero(&iba, sizeof iba);
        iba.iba_name = "iic";
        iba.iba_tag = &sc->i2c_tag;
        iba.iba_bus_scan = imxiic_acpi_bus_scan;
        iba.iba_bus_scan_arg = sc;
        config_found(&sc->sc_dev, &iba, iicbus_print);

#ifndef SMALL_KERNEL
        ac->ac_devnode->i2c = &sc->i2c_tag;
        acpi_register_gsb(ac->ac_acpi, ac->ac_devnode);
#endif
}

int
imxiic_acpi_parse_crs(int crsidx, union acpi_resource *crs, void *arg)
{
        struct imxiic_crs *sc_crs = arg;

        switch (AML_CRSTYPE(crs)) {
        case LR_SERBUS:
                if (crs->lr_serbus.type == LR_SERBUS_I2C)
                        sc_crs->i2c_addr = crs->lr_i2cbus._adr;
                break;
        case SR_IRQ:
        case LR_EXTIRQ:
        case LR_MEM32:
        case LR_MEM32FIXED:
                break;
        default:
                printf("%s: unknown resource type %d\n", __func__,
                    AML_CRSTYPE(crs));
        }

        return 0;
}

void
imxiic_acpi_bus_scan(struct device *iic, struct i2cbus_attach_args *iba,
    void *aux)
{
        struct imxiic_acpi_softc *ac = (struct imxiic_acpi_softc *)aux;

        ac->ac_iic = iic;
        aml_find_node(ac->ac_devnode, "_HID", imxiic_acpi_found_hid, ac);
}

int
imxiic_acpi_found_hid(struct aml_node *node, void *arg)
{
        struct imxiic_acpi_softc *ac = (struct imxiic_acpi_softc *)arg;
        struct imxiic_softc *sc = &ac->ac_sc;
        struct imxiic_crs crs;
        struct aml_value res;
        int64_t sta;
        char cdev[16], dev[16];
        struct i2c_attach_args ia;

        /* Skip our own _HID. */
        if (node->parent == ac->ac_devnode)
                return 0;

        /* Only direct descendants, because of possible muxes. */
        if (node->parent && node->parent->parent != ac->ac_devnode)
                return 0;

        if (acpi_parsehid(node, arg, cdev, dev, 16) != 0)
                return 0;

        sta = acpi_getsta(acpi_softc, node->parent);
        if ((sta & STA_PRESENT) == 0)
                return 0;

        if (aml_evalname(acpi_softc, node->parent, "_CRS", 0, NULL, &res))
                return 0;

        if (res.type != AML_OBJTYPE_BUFFER || res.length < 5) {
                printf("%s: invalid _CRS object (type %d len %d)\n",
                    sc->sc_dev.dv_xname, res.type, res.length);
                aml_freevalue(&res);
                return (0);
        }
        memset(&crs, 0, sizeof(crs));
        crs.devnode = ac->ac_devnode;
        aml_parse_resource(&res, imxiic_acpi_parse_crs, &crs);
        aml_freevalue(&res);

        acpi_attach_deps(acpi_softc, node->parent);

        memset(&ia, 0, sizeof(ia));
        ia.ia_tag = &sc->i2c_tag;
        ia.ia_name = dev;
        ia.ia_addr = crs.i2c_addr;
        ia.ia_cookie = node->parent;

        config_found(ac->ac_iic, &ia, iicbus_print);
        node->parent->attached = 1;

        return 0;
}