/* $NetBSD: gicv3_acpi.c,v 1.8 2020/12/23 11:05:08 jmcneill Exp $ */

/*-
 * Copyright (c) 2018 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Jared McNeill <jmcneill@invisible.ca>.
 *
 * 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 "pci.h"

#define _INTR_PRIVATE

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: gicv3_acpi.c,v 1.8 2020/12/23 11:05:08 jmcneill Exp $");

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/cpu.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/kmem.h>

#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>

#include <dev/fdt/fdtvar.h>

#include <arm/cortex/gicv3.h>
#include <arm/cortex/gicv3_its.h>
#include <arm/cortex/gic_reg.h>

#include <arm/acpi/gic_v2m_acpi.h>

#define GICD_SIZE       0x10000
#define GICR_SIZE       0x20000
#define GITS_SIZE       0x20000

extern struct bus_space arm_generic_bs_tag;
extern struct arm32_bus_dma_tag arm_generic_dma_tag;

struct gicv3_acpi_softc {
        struct gicv3_softc      sc_gic;

        ACPI_MADT_GENERIC_DISTRIBUTOR *sc_madt_gicd;
};

static int      gicv3_acpi_match(device_t, cfdata_t, void *);
static void     gicv3_acpi_attach(device_t, device_t, void *);

static int      gicv3_acpi_map_dist(struct gicv3_acpi_softc *);
static int      gicv3_acpi_map_redist(struct gicv3_acpi_softc *);
#if NPCI > 0
static int      gicv3_acpi_map_msi(struct gicv3_acpi_softc *);
#endif

CFATTACH_DECL_NEW(gicv3_acpi, sizeof(struct gicv3_acpi_softc), gicv3_acpi_match, gicv3_acpi_attach, NULL, NULL);

static int
gicv3_acpi_match(device_t parent, cfdata_t cf, void *aux)
{
        ACPI_SUBTABLE_HEADER *hdrp = aux;
        ACPI_MADT_GENERIC_DISTRIBUTOR *gicd;

        if (hdrp->Type != ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR)
                return 0;

        gicd = (ACPI_MADT_GENERIC_DISTRIBUTOR *)hdrp;

        switch (gicd->Version) {
        case ACPI_MADT_GIC_VERSION_NONE:
                return __SHIFTOUT(reg_id_aa64pfr0_el1_read(), ID_AA64PFR0_EL1_GIC) != 0;
        case ACPI_MADT_GIC_VERSION_V3:
        case ACPI_MADT_GIC_VERSION_V4:
                return 1;
        default:
                return 0;
        }
}

static void
gicv3_acpi_attach(device_t parent, device_t self, void *aux)
{
        struct gicv3_acpi_softc * const sc = device_private(self);
        ACPI_MADT_GENERIC_DISTRIBUTOR *gicd = aux;
        int error;

        sc->sc_gic.sc_dev = self;
        sc->sc_gic.sc_bst = &arm_generic_bs_tag;
        sc->sc_gic.sc_dmat = &arm_generic_dma_tag;
        sc->sc_madt_gicd = gicd;

        aprint_naive("\n");
        aprint_normal(": GICv3\n");

        error = gicv3_acpi_map_dist(sc);
        if (error) {
                aprint_error_dev(self, "failed to map distributor: %d\n", error);
                return;
        }

        error = gicv3_acpi_map_redist(sc);
        if (error) {
                aprint_error_dev(self, "failed to map redistributor: %d\n", error);
                return;
        }

        error = gicv3_init(&sc->sc_gic);
        if (error) {
                aprint_error_dev(self, "failed to initialize GIC: %d\n", error);
                return;
        }

#if NPCI > 0
        gicv3_acpi_map_msi(sc);
#endif

        arm_fdt_irq_set_handler(gicv3_irq_handler);
}

static int
gicv3_acpi_map_dist(struct gicv3_acpi_softc *sc)
{
        const bus_addr_t addr = sc->sc_madt_gicd->BaseAddress;
        const bus_size_t size = GICD_SIZE;
        int error;

        error = bus_space_map(sc->sc_gic.sc_bst, addr, size, 0, &sc->sc_gic.sc_bsh_d);
        if (error)
                return error;

        return 0;
}

static ACPI_STATUS
gicv3_acpi_count_gicr(ACPI_SUBTABLE_HEADER *hdrp, void *aux)
{
        ACPI_MADT_GENERIC_REDISTRIBUTOR *gicr;
        int *count = aux;

        if (hdrp->Type == ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR) {
                gicr = (ACPI_MADT_GENERIC_REDISTRIBUTOR *)hdrp;
                *count += howmany(gicr->Length, GICR_SIZE);
        }

        return AE_OK;
}

static ACPI_STATUS
gicv3_acpi_map_gicr(ACPI_SUBTABLE_HEADER *hdrp, void *aux)
{
        struct gicv3_acpi_softc * const sc = aux;
        ACPI_MADT_GENERIC_REDISTRIBUTOR *gicr;
        bus_space_handle_t bsh;
        bus_size_t off;

        if (hdrp->Type != ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR)
                return AE_OK;

        gicr = (ACPI_MADT_GENERIC_REDISTRIBUTOR *)hdrp;

        if (bus_space_map(sc->sc_gic.sc_bst, gicr->BaseAddress, gicr->Length, 0, &bsh) != 0) {
                aprint_error_dev(sc->sc_gic.sc_dev, "failed to map redistributor at 0x%" PRIx64 " len %#x\n",
                    gicr->BaseAddress, gicr->Length);
                return AE_OK;
        }

        for (off = 0; off < gicr->Length; off += GICR_SIZE) {
                const int redist = sc->sc_gic.sc_bsh_r_count;
                if (bus_space_subregion(sc->sc_gic.sc_bst, bsh, off, GICR_SIZE, &sc->sc_gic.sc_bsh_r[redist]) != 0) {
                        aprint_error_dev(sc->sc_gic.sc_dev, "couldn't subregion redistributor registers\n");
                        return AE_OK;
                }

                aprint_debug_dev(sc->sc_gic.sc_dev, "redist at 0x%" PRIx64 " [GICR]\n", gicr->BaseAddress + off);

                sc->sc_gic.sc_bsh_r_count++;

                /* If this is the last redist in this region, skip to the next one */
                const uint32_t typer = bus_space_read_4(sc->sc_gic.sc_bst, sc->sc_gic.sc_bsh_r[redist], GICR_TYPER);
                if (typer & GICR_TYPER_Last)
                        break;

                /* If the redistributor supports virtual LPIs, skip the VLPI register region */
                if (typer & GICR_TYPER_VLPIS)
                        off += GICR_SIZE;
        }

        return AE_OK;
}

static ACPI_STATUS
gicv3_acpi_count_gicc(ACPI_SUBTABLE_HEADER *hdrp, void *aux)
{
        ACPI_MADT_GENERIC_INTERRUPT *gicc;
        int *count = aux;

        if (hdrp->Type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) {
                gicc = (ACPI_MADT_GENERIC_INTERRUPT *)hdrp;
                if ((gicc->Flags & ACPI_MADT_ENABLED) != 0)
                        (*count)++;
        }

        return AE_OK;
}

static ACPI_STATUS
gicv3_acpi_map_gicc(ACPI_SUBTABLE_HEADER *hdrp, void *aux)
{
        struct gicv3_acpi_softc * const sc = aux;
        ACPI_MADT_GENERIC_INTERRUPT *gicc;

        if (hdrp->Type != ACPI_MADT_TYPE_GENERIC_INTERRUPT)
                return AE_OK;

        gicc = (ACPI_MADT_GENERIC_INTERRUPT *)hdrp;
        if ((gicc->Flags & ACPI_MADT_ENABLED) == 0)
                return AE_OK;

        const int redist = sc->sc_gic.sc_bsh_r_count;
        if (bus_space_map(sc->sc_gic.sc_bst, gicc->GicrBaseAddress, GICR_SIZE, 0, &sc->sc_gic.sc_bsh_r[redist]) != 0) {
                aprint_error_dev(sc->sc_gic.sc_dev, "failed to map redistributor at 0x%" PRIx64 " len %#x\n",
                    gicc->GicrBaseAddress, GICR_SIZE);
                return AE_OK;
        }

        aprint_debug_dev(sc->sc_gic.sc_dev, "redist at 0x%" PRIx64 " [GICC]\n", gicc->GicrBaseAddress);

        sc->sc_gic.sc_bsh_r_count++;

        return AE_OK;
}

static int
gicv3_acpi_map_redist(struct gicv3_acpi_softc *sc)
{
        bool use_gicr = false;
        int max_redist = 0;

        /*
         * Try to use GICR structures to describe redistributors. If no GICR
         * subtables are found, use the GICR address from the GICC subtables.
         */
        acpi_madt_walk(gicv3_acpi_count_gicr, &max_redist);
        if (max_redist != 0)
                use_gicr = true;
        else
                acpi_madt_walk(gicv3_acpi_count_gicc, &max_redist);

        if (max_redist == 0)
                return ENODEV;

        sc->sc_gic.sc_bsh_r = kmem_alloc(sizeof(bus_space_handle_t) * max_redist, KM_SLEEP);
        if (use_gicr)
                acpi_madt_walk(gicv3_acpi_map_gicr, sc);
        else
                acpi_madt_walk(gicv3_acpi_map_gicc, sc);

        if (sc->sc_gic.sc_bsh_r_count == 0)
                return ENXIO;

        return 0;
}

#if NPCI > 0
static ACPI_STATUS
gicv3_acpi_map_gits(ACPI_SUBTABLE_HEADER *hdrp, void *aux)
{
        struct gicv3_acpi_softc * const sc = aux;
        ACPI_MADT_GENERIC_TRANSLATOR *gits;
        bus_space_handle_t bsh;

        if (hdrp->Type != ACPI_MADT_TYPE_GENERIC_TRANSLATOR)
                return AE_OK;

        gits = (ACPI_MADT_GENERIC_TRANSLATOR *)hdrp;

        if (bus_space_map(sc->sc_gic.sc_bst, gits->BaseAddress, GITS_SIZE, 0, &bsh) != 0) {
                aprint_error_dev(sc->sc_gic.sc_dev, "failed to map ITS at 0x%" PRIx64 " len %#x\n",
                    gits->BaseAddress, GITS_SIZE);
                return AE_OK;
        }

        aprint_normal_dev(sc->sc_gic.sc_dev, "ITS #%d at 0x%" PRIx64 "\n",
            gits->TranslationId, gits->BaseAddress);

        gicv3_its_init(&sc->sc_gic, bsh, gits->BaseAddress, gits->TranslationId);

        return AE_OK;
}

static int
gicv3_acpi_map_msi(struct gicv3_acpi_softc *sc)
{
        acpi_madt_walk(gicv3_acpi_map_gits, sc);
        acpi_madt_walk(gic_v2m_acpi_find_msi_frame, sc->sc_gic.sc_dev);

        return 0;
}

#endif