/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2020 Ruslan Bukin <br@bsdpad.com>
 *
 * This software was developed by SRI International and the University of
 * Cambridge Computer Laboratory (Department of Computer Science and
 * Technology) under DARPA contract HR0011-18-C-0016 ("ECATS"), as part of the
 * DARPA SSITH research programme.
 *
 * 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/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/rman.h>
#include <sys/kernel.h>
#include <sys/lock.h>
#include <sys/module.h>
#include <sys/mutex.h>
#include <sys/uuid.h>
#include <machine/bus.h>

#include <contrib/dev/acpica/include/acpi.h>
#include <dev/acpica/acpivar.h>

#include <arm64/coresight/coresight.h>

#define ACPI_CORESIGHT_LINK_OUTPUT      1
#define ACPI_CORESIGHT_LINK_INPUT       0

static const struct uuid acpi_graph_uuid = {
        0xab02a46b, 0x74c7, 0x45a2, 0xbd, 0x68,
        { 0xf7, 0xd3, 0x44, 0xef, 0x21, 0x53 },
};

static const struct uuid coresight_graph_uuid = {
        0x3ecbc8b6, 0x1d0e, 0x4fb3, 0x81, 0x07,
        { 0xe6, 0x27, 0xf8, 0x05, 0xc6, 0xcd },
};

static inline bool
cs_acpi_validate_dsd_graph(const union acpi_object *graph)
{
        const union acpi_object *rev, *nr_graphs;
        const union acpi_object *obj;
        int i, n;

        if (graph->Package.Count < 2)
                return (false);

        rev = &graph->Package.Elements[0];
        nr_graphs = &graph->Package.Elements[1];

        if (rev->Type != ACPI_TYPE_INTEGER ||
            nr_graphs->Type != ACPI_TYPE_INTEGER)
                return (false);

        /* Revision 0 supported only. */
        if (rev->Integer.Value != 0)
                return (false);

        /* We are looking for a single graph. */
        n = nr_graphs->Integer.Value;
        if (n != 1)
                return (false);

        /* Check the number of elements. */
        if (graph->Package.Count != (n + 2))
                return (false);

        for (i = 2; i < n + 2; i++) {
                obj = &graph->Package.Elements[i];
                if (obj->Type != ACPI_TYPE_PACKAGE || obj->Package.Count < 3)
                        return (false);
        }

        return (true);
}

static inline bool
cs_is_acpi_guid(const union acpi_object *obj)
{

        return (obj->Type == ACPI_TYPE_BUFFER) && (obj->Buffer.Length == 16);
}

static inline bool
cs_guid_equal(const struct uuid *u1, const struct uuid *u2)
{

        if (memcmp(u1, u2, 16) == 0)
                return (true);

        return (false);
}

static inline bool
cs_acpi_guid_matches(const union acpi_object *obj, const struct uuid *guid)
{

        if (cs_is_acpi_guid(obj) &&
            cs_guid_equal((struct uuid *)obj->Buffer.Pointer, guid))
                return (true);

        return (false);
}

static inline bool
is_acpi_dsd_graph_guid(const union acpi_object *obj)
{

        return (cs_acpi_guid_matches(obj, &acpi_graph_uuid));
}

static inline bool
cs_is_acpi_coresight_graph_guid(const union acpi_object *obj)
{

        return (cs_acpi_guid_matches(obj, &coresight_graph_uuid));
}

static inline bool
cs_is_acpi_coresight_graph(const union acpi_object *obj)
{
        const union acpi_object *graphid, *guid, *links;

        if (obj->Type != ACPI_TYPE_PACKAGE ||
            obj->Package.Count < 3)
                return (false);

        graphid = &obj->Package.Elements[0];
        guid = &obj->Package.Elements[1];
        links = &obj->Package.Elements[2];

        if (graphid->Type != ACPI_TYPE_INTEGER ||
            links->Type != ACPI_TYPE_INTEGER)
                return (false);

        if (cs_is_acpi_coresight_graph_guid(guid))
                return (true);

        return (false);
}

static const union acpi_object *
cs_get_dsd_graph(device_t dev)
{
        const union acpi_object *guid, *package;
        union acpi_object *dsd;
        ACPI_STATUS status;
        ACPI_BUFFER buf;
        device_t bus;
        int i;

        buf.Length = PAGE_SIZE;
        buf.Pointer = malloc(buf.Length, M_TEMP, M_NOWAIT | M_ZERO);
        if (buf.Pointer == NULL) {
                printf("Failed to allocate memory.\n");
                return (NULL);
        }

        bus = device_get_parent(dev);
        status = ACPI_EVALUATE_OBJECT(bus, dev, "_DSD", NULL, &buf);
        if (ACPI_FAILURE(status)) {
                printf("Failed to evaluate object.\n");
                return (NULL);
        }

        dsd = buf.Pointer;

        for (i = 0; i + 1 < dsd->Package.Count; i += 2) {
                guid = &dsd->Package.Elements[i];
                package = &dsd->Package.Elements[i + 1];

                if (!cs_is_acpi_guid(guid) ||
                    package->Type != ACPI_TYPE_PACKAGE)
                        break;

                if (!is_acpi_dsd_graph_guid(guid))
                        continue;

                if (cs_acpi_validate_dsd_graph(package))
                        return (package);
        }

        return (NULL);
}

static inline bool
cs_acpi_validate_coresight_graph(const union acpi_object *cs_graph)
{
        int nlinks;

        nlinks = cs_graph->Package.Elements[2].Integer.Value;
        if (cs_graph->Package.Count != (nlinks + 3))
                return (false);

        return (true);
}

static const union acpi_object *
cs_get_coresight_graph(device_t dev)
{
        const union acpi_object *graph_list, *graph;
        int i, nr_graphs;

        graph_list = cs_get_dsd_graph(dev);
        if (!graph_list) {
                printf("failed to get graph list\n");
                return (NULL);
        }

        nr_graphs = graph_list->Package.Elements[1].Integer.Value;
        for (i = 2; i < nr_graphs + 2; i++) {
                graph = &graph_list->Package.Elements[i];
                if (!cs_is_acpi_coresight_graph(graph))
                        continue;
                if (cs_acpi_validate_coresight_graph(graph))
                        return (graph);
                break;
        }

        return (NULL);
}

static int
cs_acpi_record_endpoint(device_t dev,
    struct coresight_platform_data *pdata,
    const union acpi_object *link)
{
        const union acpi_object *fields;
        struct endpoint *endp;
        ACPI_HANDLE handle;
        int dir;

        if (link->Type != ACPI_TYPE_PACKAGE ||
            link->Package.Count != 4)
                return (ENXIO);

        fields = link->Package.Elements;
        if (fields[0].Type != ACPI_TYPE_INTEGER ||
            fields[1].Type != ACPI_TYPE_INTEGER ||
            fields[2].Type != ACPI_TYPE_LOCAL_REFERENCE ||
            fields[3].Type != ACPI_TYPE_INTEGER)
                return (ENXIO);

        handle = fields[2].Reference.Handle;
        dir = fields[3].Integer.Value;

        endp = malloc(sizeof(struct endpoint),
            M_CORESIGHT, M_WAITOK | M_ZERO);
        if (endp == NULL) {
                device_printf(dev, "Failed to allocate memory.\n");
                return (ENXIO);
        }

        endp->their_handle = handle;
        endp->my_handle = acpi_get_handle(dev);

        mtx_lock(&pdata->mtx_lock);
        TAILQ_INSERT_TAIL(&pdata->endpoints, endp, link);
        mtx_unlock(&pdata->mtx_lock);

        if (dir == ACPI_CORESIGHT_LINK_OUTPUT) {
                pdata->out_ports++;
        } else {
                endp->input = true;
                pdata->in_ports++;
        }

        return (0);
}

static int
coresight_acpi_get_ports(device_t dev,
    struct coresight_platform_data *pdata)
{
        const union acpi_object *graph;
        const union acpi_object *link;
        int nlinks;
        int error;
        int i;

        graph = cs_get_coresight_graph(dev);
        if (graph == NULL) {
                device_printf(dev, "Coresight graph not found.\n");
                return (ENXIO);
        }

        nlinks = graph->Package.Elements[2].Integer.Value;
        if (!nlinks)
                return (0);

        for (i = 0; i < nlinks; i++) {
                link = &graph->Package.Elements[3 + i];
                error = cs_acpi_record_endpoint(dev, pdata, link);
                if (error < 0)
                        return (error);
        }

        return (0);
}

static int
coresight_acpi_get_cpu(device_t dev, struct coresight_platform_data *pdata)
{
        ACPI_HANDLE handle, parent;
        ACPI_STATUS status;
        int cpuid;

        handle = acpi_get_handle(dev);

        status = AcpiGetParent(handle, &parent);
        if (!ACPI_SUCCESS(status))
                return (ENXIO);

        if (!acpi_MatchHid(parent, "ACPI0007"))
                return (ENXIO);

        status = acpi_GetInteger(parent, "_UID", &cpuid);
        if (ACPI_SUCCESS(status)) {
                pdata->cpu = cpuid;
                return (0);
        }

        return (ENXIO);
}

struct coresight_platform_data *
coresight_acpi_get_platform_data(device_t dev)
{
        struct coresight_platform_data *pdata;

        pdata = malloc(sizeof(struct coresight_platform_data),
            M_CORESIGHT, M_WAITOK | M_ZERO);
        pdata->bus_type = CORESIGHT_BUS_ACPI;

        mtx_init(&pdata->mtx_lock, "Coresight Platform Data", NULL, MTX_DEF);
        TAILQ_INIT(&pdata->endpoints);

        coresight_acpi_get_cpu(dev, pdata);
        coresight_acpi_get_ports(dev, pdata);

        if (bootverbose)
                printf("Total ports: in %d out %d\n",
                    pdata->in_ports, pdata->out_ports);

        return (pdata);
}