/*      $OpenBSD: acpi_machdep.c,v 1.22 2024/05/22 05:51:49 jsg Exp $   */
/*
 * Copyright (c) 2018 Mark Kettenis
 *
 * 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/device.h>
#include <sys/malloc.h>
#include <sys/systm.h>

#include <uvm/uvm_extern.h>

#include <machine/apmvar.h>
#include <machine/bus.h>
#include <machine/fdt.h>

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

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

#include <arm64/dev/acpiiort.h>

#include "apm.h"

int     pwr_action = 1;

int     acpi_fdt_match(struct device *, void *, void *);
void    acpi_fdt_attach(struct device *, struct device *, void *);

const struct cfattach acpi_fdt_ca = {
        sizeof(struct acpi_softc), acpi_fdt_match, acpi_fdt_attach
};

int
acpi_fdt_match(struct device *parent, void *match, void *aux)
{
        struct fdt_attach_args *faa = aux;

        return OF_is_compatible(faa->fa_node, "openbsd,acpi-5.0");
}

void
acpi_fdt_attach(struct device *parent, struct device *self, void *aux)
{
        struct acpi_softc *sc = (struct acpi_softc *)self;
        struct fdt_attach_args *faa = aux;
        bus_dma_tag_t dmat;

        sc->sc_memt = faa->fa_iot;
        sc->sc_ci_dmat = faa->fa_dmat;

        /* Create coherent DMA tag. */
        dmat = malloc(sizeof(*sc->sc_cc_dmat), M_DEVBUF, M_WAITOK | M_ZERO);
        memcpy(dmat, faa->fa_dmat, sizeof(*dmat));
        dmat->_flags |= BUS_DMA_COHERENT;
        sc->sc_cc_dmat = dmat;

        acpi_attach_common(sc, faa->fa_reg[0].addr);
}

int
acpi_map(paddr_t pa, size_t len, struct acpi_mem_map *handle)
{
        paddr_t pgpa = trunc_page(pa);
        paddr_t endpa = round_page(pa + len);
        vaddr_t va = (vaddr_t)km_alloc(endpa - pgpa, &kv_any, &kp_none,
            &kd_nowait);

        if (va == 0)
                return (ENOMEM);

        handle->baseva = va;
        handle->va = (u_int8_t *)(va + (pa & PGOFSET));
        handle->vsize = endpa - pgpa;
        handle->pa = pa;

        do {
                pmap_kenter_pa(va, pgpa, PROT_READ | PROT_WRITE);
                va += NBPG;
                pgpa += NBPG;
        } while (pgpa < endpa);

        return 0;
}

void
acpi_unmap(struct acpi_mem_map *handle)
{
        pmap_kremove(handle->baseva, handle->vsize);
        km_free((void *)handle->baseva, handle->vsize, &kv_any, &kp_none);
}

int
acpi_bus_space_map(bus_space_tag_t t, bus_addr_t addr, bus_size_t size,
    int flags, bus_space_handle_t *bshp)
{
        return bus_space_map(t, addr, size, flags, bshp);
}

void
acpi_bus_space_unmap(bus_space_tag_t t, bus_space_handle_t bsh,
    bus_size_t size)
{
        bus_space_unmap(t, bsh, size);
}

int
acpi_acquire_glk(uint32_t *lock)
{
        /* No global lock. */
        return 1;
}

int
acpi_release_glk(uint32_t *lock)
{
        /* No global lock. */
        return 0;
}

void
acpi_attach_machdep(struct acpi_softc *sc)
{
#if NAPM > 0
        apm_setinfohook(acpi_apminfo);
#endif
}

void *
acpi_intr_establish(int irq, int flags, int level,
    int (*func)(void *), void *arg, const char *name)
{
        struct interrupt_controller *ic;
        struct machine_intr_handle *aih;
        uint32_t interrupt[3];
        void *cookie;

        extern LIST_HEAD(, interrupt_controller) interrupt_controllers;
        LIST_FOREACH(ic, &interrupt_controllers, ic_list) {
                if (ic->ic_phandle == 1)
                        break;
        }
        if (ic == NULL)
                return NULL;

        interrupt[0] = 0;
        interrupt[1] = irq - 32;
        if (flags & LR_EXTIRQ_MODE) { /* edge */
                if (flags & LR_EXTIRQ_POLARITY)
                        interrupt[2] = 0x2; /* falling */
                else
                        interrupt[2] = 0x1; /* rising */
        } else { /* level */
                if (flags & LR_EXTIRQ_POLARITY)
                        interrupt[2] = 0x8; /* low */
                else
                        interrupt[2] = 0x4; /* high */
        }

        cookie = ic->ic_establish(ic->ic_cookie, interrupt, level, NULL,
            func, arg, (char *)name);
        if (cookie == NULL)
                return NULL;

        aih = malloc(sizeof(*aih), M_DEVBUF, M_WAITOK);
        aih->ih_ic = ic;
        aih->ih_ih = cookie;

        return aih;
}

void
acpi_intr_disestablish(void *cookie)
{
        struct machine_intr_handle *aih = cookie;
        struct interrupt_controller *ic = aih->ih_ic;

        ic->ic_disestablish(aih->ih_ih);
        free(aih, M_DEVBUF, sizeof(*aih));
}

bus_dma_tag_t
acpi_iommu_device_map(struct aml_node *node, bus_dma_tag_t dmat)
{
        return acpiiort_device_map(node, dmat);
}