/*
 * Copyright (c) 2026 Justin Hibbits
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/mutex.h>
#include <sys/proc.h>
#include <sys/pcpu.h>
#include <sys/rman.h>
#include <sys/sched.h>

#include <machine/bus.h>
#include <machine/tlb.h>

#include "bman.h"
#include "dpaa_common.h"
#include "bman_var.h"

#define BMAN_POOL_SWDET(n)      (0x000 + 4 * (n))
#define BMAN_POOL_HWDET(n)      (0x100 + 4 * (n))
#define BMAN_POOL_SWDXT(n)      (0x200 + 4 * (n))
#define BMAN_POOL_HWDXT(n)      (0x300 + 4 * (n))
#define FBPR_FP_LWIT    0x804
#define BMAN_IP_REV_1   0x0bf8
#define   IP_MAJ_S        8
#define   IP_MAJ_M        0x0000ff00
#define   IP_MIN_M        0x000000ff
#define BMAN_IP_REV_2   0x0bfc
#define BMAN_FBPR_BARE  0x0c00
#define BMAN_FBPR_BAR   0x0c04
#define BMAN_FBPR_AR    0x0c10
#define BMAN_LIODNR     0x0d08

#define BMAN_POOL_CONTENT(n)    (0x0600 + 4 * (n))
#define BMAN_ECSR       0x0a00
#define BMAN_ECIR       0x0a04
#define   ECIR_PORTAL(r)  (((r) >> 24) & 0x0f)
#define   ECIR_VERB(r)    (((r) >> 16) & 0x07)
#define   ECIR_R          0x00080000
#define   ECIR_POOL(r)    ((r) & 0x3f)
#define BMAN_CECR       0x0a34  /* Corruption Error Capture Register */
#define BMAN_CEAR       0x0a38  /* Corruption Error Address Register */
#define BMAN_AECR       0x0a34  /* Acces Error Capture Register */
#define BMAN_AEAR       0x0a38  /* Acces Error Address Register */
#define BMAN_ERR_ISR    0x0e00
#define BMAN_ERR_IER    0x0e04
#define BMAN_ERR_ISDR   0x0e08
#define   ERR_EMAI        0x00000040
#define   ERR_EMCI        0x00000020
#define   ERR_IVCI        0x00000010
#define   ERR_FLWI        0x00000008
#define   ERR_MBEI        0x00000004
#define   ERR_SBEI        0x00000002
#define   ERR_BSCN        0x00000001

static MALLOC_DEFINE(M_BMAN, "bman", "DPAA Buffer Manager structures");

static struct bman_softc *bman_sc;

static void
bman_isr(void *arg)
{
        struct bman_softc *sc = arg;
        uint32_t ier, isr, isr_bit;
        uint32_t reg;

        ier = bus_read_4(sc->sc_rres, BMAN_ERR_IER);
        isr = bus_read_4(sc->sc_rres, BMAN_ERR_ISR);

        isr_bit = (isr & ier);
        if (isr_bit == 0)
                goto end;

        if (isr_bit & ERR_EMAI) {
                device_printf(sc->sc_dev, "External memory access error\n");
                reg = bus_read_4(sc->sc_rres, BMAN_AECR);
                if (reg <= 63)
                        device_printf(sc->sc_dev, "  pool %d\n", reg);
                else
                        device_printf(sc->sc_dev, "  FBPR free list\n");
                reg = bus_read_4(sc->sc_rres, BMAN_AEAR);
                device_printf(sc->sc_dev, "  offset: %#x\n", reg);
        }

        if (isr_bit & ERR_EMCI) {
                device_printf(sc->sc_dev, "External memory corruption error\n");
                reg = bus_read_4(sc->sc_rres, BMAN_CECR);
                if (reg <= 63)
                        device_printf(sc->sc_dev, "  pool %d\n", reg);
                else
                        device_printf(sc->sc_dev, "  FBPR free list\n");
                reg = bus_read_4(sc->sc_rres, BMAN_CEAR);
                device_printf(sc->sc_dev, "  offset: %#x\n", reg);
        }
        if (isr_bit & ERR_IVCI) {
                reg = bus_read_4(sc->sc_rres, BMAN_ECIR);
                device_printf(sc->sc_dev, "Invalid verb command\n");
                device_printf(sc->sc_dev, "Portal: %d, ring: %s\n",
                    ECIR_POOL(reg), (reg & ECIR_R) ? "RCR" : "Command");
                device_printf(sc->sc_dev, "verb: 0x%02x, pool: %d\n",
                    ECIR_VERB(reg), ECIR_POOL(reg));
        }
        if (isr_bit & (ERR_MBEI | ERR_SBEI)) {
                if (isr_bit & ERR_MBEI)
                        device_printf(sc->sc_dev, "Multi-bit ECC error\n");
                if (isr_bit & ERR_MBEI)
                        device_printf(sc->sc_dev, "Single-bit ECC error\n");
                /* TODO: Add more error details for ECC errors. */
        }

end:
        bus_write_4(sc->sc_rres, BMAN_ERR_ISR, isr);
}

static void
bman_get_version(struct bman_softc *sc)
{
        uint32_t reg = bus_read_4(sc->sc_rres, BMAN_IP_REV_1);

        sc->sc_major = (reg & IP_MAJ_M) >> IP_MAJ_S;
        sc->sc_minor = (reg & IP_MIN_M);
}

static int
bman_set_memory(struct bman_softc *sc, vm_paddr_t pa, vm_size_t size)
{
        vm_paddr_t bar_pa;
        if ((pa & (size - 1)) != 0 || (size & (size - 1)) != 0) {
                device_printf(sc->sc_dev,
                    "invalid memory configuration: pa: %#jx, size: %#jx\n",
                    (uintmax_t)pa, (uintmax_t)size);
                return (ENXIO);
        }
        bar_pa = bus_read_4(sc->sc_rres, BMAN_FBPR_BARE);
        bar_pa <<= 32;
        bar_pa |= bus_read_4(sc->sc_rres, BMAN_FBPR_BAR);
        if (bar_pa != 0 && bar_pa != pa) {
                device_printf(sc->sc_dev,
                    "attempted to reinitialize BMan with different BAR\n");
                return (ENOMEM);
        } else if (bar_pa == pa)
                return (0);

        bus_write_4(sc->sc_rres, BMAN_FBPR_BARE, pa >> 32);
        bus_write_4(sc->sc_rres, BMAN_FBPR_BAR, pa & 0xffffffff);
        bus_write_4(sc->sc_rres, BMAN_FBPR_AR, ilog2(size) - 1);

        return (0);
}

int
bman_attach(device_t dev)
{
        struct bman_softc *sc;
        vm_paddr_t bp_pa;
        size_t bp_size;
        int bp_count;

        sc = device_get_softc(dev);
        sc->sc_dev = dev;
        bman_sc = sc;

        /* Allocate resources */
        sc->sc_rrid = 0;
        sc->sc_rres = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
            sc->sc_rrid, RF_ACTIVE);
        if (sc->sc_rres == NULL)
                return (ENXIO);

        sc->sc_irid = 0;
        sc->sc_ires = bus_alloc_resource_any(sc->sc_dev, SYS_RES_IRQ,
            &sc->sc_irid, RF_ACTIVE | RF_SHAREABLE);
        if (sc->sc_ires == NULL)
                goto err;

        bman_get_version(sc);
        if (sc->sc_major == 2 && sc->sc_minor == 0)
                bp_count = BMAN_MAX_POOLS_1023;
        else
                bp_count = BMAN_MAX_POOLS;

        /* TODO: LIODN */
        bus_write_4(sc->sc_rres, BMAN_LIODNR, 0);

        sc->sc_vmem = vmem_create("BMan Pools", 0, bp_count, 1, 0, M_WAITOK);

        /* Pool is reserved memory, so no need to track it ourselves. */
        dpaa_map_private_memory(dev, 0, "fsl,bman-fbpr", &bp_pa, &bp_size);
        bman_set_memory(sc, bp_pa, bp_size);

        /* Warn if FBPR drops below 5% total. */
        bus_write_4(sc->sc_rres, FBPR_FP_LWIT, (bp_size / 8) / 20);

        /* Clear interrupt status, and enable all interrupts. */
        bus_write_4(sc->sc_rres, BMAN_ERR_ISR, 0xffffffff);
        bus_write_4(sc->sc_rres, BMAN_ERR_IER, 0xffffffff);
        bus_write_4(sc->sc_rres, BMAN_ERR_ISDR, 0);

        /* Enable the IRQ line now. */
        if (bus_setup_intr(dev, sc->sc_ires, INTR_TYPE_NET, NULL, bman_isr,
            sc, &sc->sc_icookie) != 0)
                goto err;

        return (0);

err:
        bman_detach(dev);
        return (ENXIO);
}

int
bman_detach(device_t dev)
{
        struct bman_softc *sc;

        sc = device_get_softc(dev);

        if (sc->sc_vmem != NULL)
                vmem_destroy(sc->sc_vmem);
        if (sc->sc_icookie != NULL)
                bus_teardown_intr(dev, sc->sc_ires, sc->sc_icookie);
        if (sc->sc_ires != NULL)
                bus_release_resource(dev, SYS_RES_IRQ,
                    sc->sc_irid, sc->sc_ires);

        if (sc->sc_rres != NULL)
                bus_release_resource(dev, SYS_RES_MEMORY,
                    sc->sc_rrid, sc->sc_rres);

        return (0);
}

int
bman_suspend(device_t dev)
{

        return (0);
}

int
bman_resume(device_t dev)
{

        return (0);
}

int
bman_shutdown(device_t dev)
{

        return (0);
}

/*
 * BMAN API
 */

struct bman_pool *
bman_new_pool(void)
{
        struct bman_softc *sc;
        vmem_addr_t bpid;
        struct bman_pool *pool;

        sc = bman_sc;
        pool = NULL;

        if (vmem_alloc(sc->sc_vmem, 1, M_FIRSTFIT | M_NOWAIT, &bpid) != 0)
                return (NULL);

        pool = malloc(sizeof(*pool), M_BMAN, M_WAITOK | M_ZERO);

        pool->bpid = bpid;

        return (pool);
}

struct bman_pool *
bman_pool_create(uint8_t *bpid, uint16_t buffer_size, uint16_t max_buffers,
    uint32_t dep_sw_entry, uint32_t dep_sw_exit,
    uint32_t dep_hw_entry, uint32_t dep_hw_exit,
    bm_depletion_handler dep_cb, void *arg)
{
        struct bman_softc *sc;
        struct bman_pool *bp;

        sc = bman_sc;
        bp = bman_new_pool();
        if (bpid != NULL)
                *bpid = bp->bpid;

        if (dep_cb) {
                bp->dep_cb = dep_cb;
                bus_write_4(sc->sc_rres, BMAN_POOL_SWDET(bp->bpid),
                    dep_sw_entry);
                bus_write_4(sc->sc_rres, BMAN_POOL_SWDXT(bp->bpid),
                    dep_sw_exit);
                bus_write_4(sc->sc_rres, BMAN_POOL_HWDET(bp->bpid),
                    dep_hw_entry);
                bus_write_4(sc->sc_rres, BMAN_POOL_HWDXT(bp->bpid),
                    dep_hw_exit);
                bp->arg = arg;
                bman_portal_enable_scn(DPCPU_GET(bman_affine_portal), bp);
        }

        return (bp);
}

int
bman_pool_destroy(struct bman_pool *pool)
{
        /* Need to error, or print a warning, if the pool isn't empty */
        if (bman_count(pool) != 0)
                return (EBUSY);
        vmem_free(bman_sc->sc_vmem, pool->bpid, 1);
        free(pool, M_BMAN);

        return (0);
}

int
bman_put_buffers(struct bman_pool *pool, struct bman_buffer *buffers, int count)
{
        struct bman_portal_softc *portal;
        int error;

        critical_enter();

        portal = DPCPU_GET(bman_affine_portal);
        if (portal == NULL) {
                critical_exit();
                return (EIO);
        }

        while (count > 0) {
                int c = min(count, 8);
                error = bman_release(pool, buffers, c);
                buffers += c;
                count -= c;
        }

        critical_exit();

        return (error);
}

uint32_t
bman_get_bpid(struct bman_pool *pool)
{
        return (pool->bpid);
}

uint32_t
bman_count(struct bman_pool *pool)
{

        return (bus_read_4(bman_sc->sc_rres, BMAN_POOL_CONTENT(pool->bpid)));
}