/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2024 The FreeBSD Foundation
 *
 * This software was developed by Konstantin Belousov <kib@FreeBSD.org>
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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 "opt_acpi.h"

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/kernel.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/memdesc.h>
#include <sys/module.h>
#include <sys/mutex.h>
#include <sys/rman.h>
#include <sys/rwlock.h>
#include <sys/smp.h>
#include <sys/taskqueue.h>
#include <sys/tree.h>
#include <sys/vmem.h>
#include <vm/vm.h>
#include <vm/vm_extern.h>
#include <vm/vm_object.h>
#include <vm/vm_page.h>
#include <vm/vm_pageout.h>
#include <vm/vm_pager.h>
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <dev/acpica/acpivar.h>
#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
#include <machine/bus.h>
#include <machine/pci_cfgreg.h>
#include "pcib_if.h"
#include <machine/intr_machdep.h>
#include <machine/md_var.h>
#include <machine/cputypes.h>
#include <x86/apicreg.h>
#include <x86/apicvar.h>
#include <dev/iommu/iommu.h>
#include <dev/iommu/busdma_iommu.h>
#include <x86/iommu/amd_reg.h>
#include <x86/iommu/x86_iommu.h>
#include <x86/iommu/amd_iommu.h>

static void
amdiommu_event_rearm_intr(struct amdiommu_unit *unit)
{
        amdiommu_write8(unit, AMDIOMMU_CMDEV_STATUS,
            AMDIOMMU_CMDEVS_EVLOGINT);
}

static void
amdiommu_event_log_inc_head(struct amdiommu_unit *unit)
{
        unit->event_log_head++;
        if (unit->event_log_head >= unit->event_log_size)
                unit->event_log_head = 0;
}

static void
amdiommu_event_log_print(struct amdiommu_unit *unit,
    const struct amdiommu_event_generic *evp, bool fancy)
{
        printf("amdiommu%d: event type 0x%x 0x%08x 0x%08x 0x%08x 0x%08x\n",
            unit->iommu.unit, evp->code, evp->w0, evp->ww1, evp->w2, evp->w3);
        if (!fancy)
                return;

        AMDIOMMU_ASSERT_LOCKED(unit);
        if (evp->code == AMDIOMMU_EV_ILL_DEV_TABLE_ENTRY) {
                const struct amdiommu_event_ill_dev_table_entry *ev_dte_p;
                const struct amdiommu_dte *dte;
                const uint32_t *x;
                int i;

                ev_dte_p = (const struct
                    amdiommu_event_ill_dev_table_entry *)evp;
                dte = &unit->dev_tbl[ev_dte_p->devid];

                printf("\tIllegal Dev Tab Entry dte@%p:", dte);
                for (i = 0, x = (const uint32_t *)dte; i < sizeof(*dte) /
                    sizeof(uint32_t); i++, x++)
                        printf(" 0x%08x", *x);
                printf("\n");
        } else if (evp->code == AMDIOMMU_EV_IO_PAGE_FAULT) {
                const struct amdiommu_event_io_page_fault_entry *ev_iopf_p;
                struct amdiommu_ctx *ctx;
                device_t dev;

                ev_iopf_p = (const struct
                    amdiommu_event_io_page_fault_entry *)evp;
                printf("\tPage Fault rid %#x dom %d",
                    ev_iopf_p->devid, ev_iopf_p->pasid);
                ctx = amdiommu_find_ctx_locked(unit, ev_iopf_p->devid);
                if (ctx != NULL) {
                        dev = ctx->context.tag->owner;
                        if (dev != NULL)
                                printf(" %s", device_get_nameunit(dev));
                }
                printf("\n\t"
                    "gn %d nx %d us %d i %d pr %d rw %d pe %d rz %d tr %d"
                    "\n\tgaddr %#jx\n",
                    ev_iopf_p->gn, ev_iopf_p->nx, ev_iopf_p->us, ev_iopf_p->i,
                    ev_iopf_p->pr, ev_iopf_p->rw, ev_iopf_p->pe, ev_iopf_p->rz,
                    ev_iopf_p->tr,
                    (((uintmax_t)(ev_iopf_p->addr2)) << 32) |
                    ev_iopf_p->addr1);
        }
}

static u_int
amdiommu_event_log_tail(struct amdiommu_unit *unit)
{
        return (amdiommu_read8(unit, AMDIOMMU_EVNTLOG_TAIL) >>
            AMDIOMMU_EV_SZ_SHIFT);
}

static u_int
amdiommu_event_copy_log_inc(u_int idx)
{
        idx++;
        if (idx == nitems(((struct amdiommu_unit *)NULL)->event_copy_log))
                idx = 0;
        return (idx);
}

static bool
amdiommu_event_copy_log_hasspace(struct amdiommu_unit *unit)
{
        return (unit->event_copy_tail != amdiommu_event_copy_log_inc(
            unit->event_copy_head));
}

void
amdiommu_event_intr(struct amdiommu_unit *unit, uint64_t status)
{
        struct amdiommu_event_generic *evp;
        u_int hw_tail, hw_tail1;
        bool enqueue;

        enqueue = (status & AMDIOMMU_CMDEVS_EVOVRFLW) != 0;

        hw_tail1 = amdiommu_event_log_tail(unit);
        do {
                hw_tail = hw_tail1;
                for (; hw_tail != unit->event_log_head;
                     amdiommu_event_log_inc_head(unit)) {
                        evp = &unit->event_log[unit->event_log_head];
                        mtx_lock_spin(&unit->event_lock);
                        if (amdiommu_event_copy_log_hasspace(unit)) {
                                unit->event_copy_log[unit->event_copy_head] =
                                    *evp;
                                unit->event_copy_head =
                                    amdiommu_event_copy_log_inc(unit->
                                    event_copy_head);
                                enqueue = true;
                        } else {
                                amdiommu_event_log_print(unit, evp, false);
                        }
                        mtx_unlock_spin(&unit->event_lock);
                }
                amdiommu_write8(unit, AMDIOMMU_EVNTLOG_HEAD,
                    unit->event_log_head << AMDIOMMU_EV_SZ_SHIFT);
                hw_tail1 = amdiommu_event_log_tail(unit);
        } while (hw_tail1 != hw_tail);
        amdiommu_event_rearm_intr(unit);

        if (enqueue)
                taskqueue_enqueue(unit->event_taskqueue, &unit->event_task);
}

static void
amdiommu_event_task(void *arg, int pending __unused)
{
        struct amdiommu_unit *unit;
        uint64_t hwev_status, status;
        struct amdiommu_event_generic hwev;

        unit = arg;
        AMDIOMMU_LOCK(unit);

        if ((unit->efr & AMDIOMMU_EFR_HWEV_SUP) != 0) {
                hwev_status = amdiommu_read8(unit, AMDIOMMU_HWEV_STATUS);
                if ((hwev_status & AMDIOMMU_HWEVS_HEV) != 0) {
                        *(uint64_t *)&hwev = amdiommu_read8(unit,
                            AMDIOMMU_HWEV_LOWER);
                        *((uint64_t *)&hwev + 1) = amdiommu_read8(unit,
                            AMDIOMMU_HWEV_UPPER);
                        printf("amdiommu%d: hw event%s\n", unit->iommu.unit,
                            (hwev_status & AMDIOMMU_HWEVS_HEO) != 0 ?
                            " (overflown)" : "");
                        amdiommu_event_log_print(unit, &hwev, true);
                        amdiommu_write8(unit, AMDIOMMU_HWEV_STATUS,
                            hwev_status);
                }
        }

        status = amdiommu_read8(unit, AMDIOMMU_CMDEV_STATUS);
        if ((status & AMDIOMMU_CMDEVS_EVOVRFLW) != 0) {
                printf("amdiommu%d: event log overflow\n", unit->iommu.unit);

                while ((status & AMDIOMMU_CMDEVS_EVLOGRUN) != 0) {
                        DELAY(1);
                        status = amdiommu_read8(unit, AMDIOMMU_CMDEV_STATUS);
                }

                unit->hw_ctrl &= ~AMDIOMMU_CTRL_EVNTLOG_EN;
                amdiommu_write8(unit, AMDIOMMU_CTRL, unit->hw_ctrl);

                unit->event_log_head = 0;
                amdiommu_write8(unit, AMDIOMMU_EVNTLOG_HEAD, 0);

                amdiommu_write8(unit, AMDIOMMU_CMDEV_STATUS,
                    AMDIOMMU_CMDEVS_EVOVRFLW);          /* RW1C */

                unit->hw_ctrl |= AMDIOMMU_CTRL_EVNTLOG_EN;
                amdiommu_write8(unit, AMDIOMMU_CTRL, unit->hw_ctrl);

                amdiommu_event_rearm_intr(unit);
        }

        mtx_lock_spin(&unit->event_lock);
        while (unit->event_copy_head != unit->event_copy_tail) {
                mtx_unlock_spin(&unit->event_lock);
                amdiommu_event_log_print(unit, &unit->event_copy_log[
                    unit->event_copy_tail], true);
                mtx_lock_spin(&unit->event_lock);
                unit->event_copy_tail = amdiommu_event_copy_log_inc(unit->
                    event_copy_tail);
        }
        mtx_unlock_spin(&unit->event_lock);

        AMDIOMMU_UNLOCK(unit);
}

int
amdiommu_init_event(struct amdiommu_unit *unit)
{
        uint64_t base_reg;

        mtx_init(&unit->event_lock, "amdevl", NULL, MTX_SPIN);

        /*  event log entries */
        unit->event_log_size = AMDIOMMU_EVNTLOG_MIN;
        TUNABLE_INT_FETCH("hw.amdiommu.event_log_size", &unit->event_log_size);
        if (unit->event_log_size < AMDIOMMU_EVNTLOG_MIN ||
            unit->event_log_size > AMDIOMMU_EVNTLOG_MAX ||
            !powerof2(unit->event_log_size))
                panic("invalid hw.amdiommu.event_log_size");
        unit->event_log = kmem_alloc_contig(AMDIOMMU_EV_SZ *
            unit->event_log_size, M_WAITOK | M_ZERO, 0, ~0ull, PAGE_SIZE,
            0, VM_MEMATTR_DEFAULT);

        TASK_INIT(&unit->event_task, 0, amdiommu_event_task, unit);
        unit->event_taskqueue = taskqueue_create_fast("amdiommuff", M_WAITOK,
            taskqueue_thread_enqueue, &unit->event_taskqueue);
        taskqueue_start_threads(&unit->event_taskqueue, 1, PI_AV,
            "amdiommu%d event taskq", unit->iommu.unit);

        base_reg = pmap_kextract((vm_offset_t)unit->event_log) |
            (((uint64_t)0x8 + ilog2(unit->event_log_size /
            AMDIOMMU_EVNTLOG_MIN)) << AMDIOMMU_EVNTLOG_BASE_SZSHIFT);
        AMDIOMMU_LOCK(unit);
        /*
         * Re-arm before enabling interrupt, to not loose it when
         * re-arming in the interrupt handler.
         */
        amdiommu_event_rearm_intr(unit);
        amdiommu_write8(unit, AMDIOMMU_EVNTLOG_BASE, base_reg);
        unit->hw_ctrl |= AMDIOMMU_CTRL_EVNTLOG_EN | AMDIOMMU_CTRL_EVENTINT_EN;
        amdiommu_write8(unit, AMDIOMMU_CTRL, unit->hw_ctrl);
        AMDIOMMU_UNLOCK(unit);

        return (0);
}

void
amdiommu_fini_event(struct amdiommu_unit *unit)
{
        AMDIOMMU_LOCK(unit);
        unit->hw_ctrl &= ~(AMDIOMMU_CTRL_EVNTLOG_EN |
            AMDIOMMU_CTRL_EVENTINT_EN);
        amdiommu_write8(unit, AMDIOMMU_CTRL, unit->hw_ctrl);
        amdiommu_write8(unit, AMDIOMMU_EVNTLOG_BASE, 0);
        AMDIOMMU_UNLOCK(unit);

        taskqueue_drain(unit->event_taskqueue, &unit->event_task);
        taskqueue_free(unit->event_taskqueue);
        unit->event_taskqueue = NULL;

        kmem_free(unit->event_log, unit->event_log_size * AMDIOMMU_EV_SZ);
        unit->event_log = NULL;
        unit->event_log_head = unit->event_log_tail = 0;

        mtx_destroy(&unit->event_lock);
}