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

#include "opt_platform.h"

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

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

#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>

#include <powerpc/mpc85xx/mpc85xx.h>

#include "bman.h"
#include "bman_var.h"
#include "portals.h"

#define BCSP_CFG        0x0100
#define   CFG_RPM_M       0x00000003
#define   CFG_RPM_PI      0x00000000
#define   CFG_RPM_PE      0x00000001
#define   CFG_RPM_VBM     0x00000002
#define BCSP_SCN0       0x0200
#define BCSP_SCN1       0x0204
#define BCSP_ISR        0x0e00
#define BCSP_IER        0x0e04
#define BCSP_ISDR       0x0e08
#define   INTR_RCDI       0x00000004
#define   INTR_RCRI       0x00000002
#define   INTR_BSCN       0x00000001

#define BMAN_CE_CR      0x0000
#define BMAN_CE_RR0     0x0100
#define BMAN_CE_RR1     0x0140
#define BMAN_CE_RR(n)   (BMAN_CE_RR0 + 0x40 * (n))
#define BMAN_CE_RCR     0x1000
#define BCSP_RCR_PI_CENA        0x3000
#define BCSP_RCR_CI_CENA        0x3100
#define BCSP_RCR_PI_CINH        0x000
#define BCSP_RCR_CI_CINH        0x004

#define BMAN_MC_VERB_VBIT               0x80
#define BMAN_MC_VERB_ACQUIRE            0x10
#define BMAN_MC_VERB_QUERY              0x40
#define BMAN_RCR_VERB_BPID0             0x20
#define BMAN_RCR_VERB_BPID_BUF          0x30

struct bman_mc_command {
        uint8_t verb;
        uint8_t cd;
        uint8_t rsvd[62];
};

union bman_mc_result {
        struct {
                uint8_t verb;
                uint8_t cd;
                uint8_t rsvd[62];
        };
        struct {
                uint64_t rsvd_q1[5];
                uint64_t bp_as;
                uint64_t rsvd_q2;
                uint64_t bp_ds;
        };
        struct bman_buffer bufs[8];
};

struct bman_rcr_entry {
        union {
        struct {
                uint8_t verb;
                uint8_t bpid;
                uint8_t rsvd[62];
        };
        struct bman_buffer bufs[8];
        };
};

static void bman_portal_isr(void *arg);

static union bman_mc_result *bman_mc_send(struct bman_portal_softc *p,
    uint8_t verb, uint8_t cd);

DPCPU_DEFINE(struct bman_portal_softc *, bman_affine_portal);

DPAA_RING(bman_rcr, 8, BCSP_RCR_PI_CENA, BCSP_RCR_CI_CENA,
    BCSP_RCR_PI_CINH, BCSP_RCR_CI_CINH);

static uint32_t
bm_ci_read(struct bman_portal_softc *sc, bus_size_t off)
{
        return (bus_read_4(sc->sc_base.sc_mres[1], off));
}

static void
bm_ci_write(struct bman_portal_softc *sc, bus_size_t off, uint32_t val)
{
        bus_write_4(sc->sc_base.sc_mres[1], off, val);
}

int
bman_portal_attach(device_t dev, int cpu)
{
        struct bman_portal_softc *sc = device_get_softc(dev);

        sc->sc_base.sc_cpu = cpu;
        dpaa_portal_alloc_res(dev, cpu);

        bm_ci_write(sc, BCSP_ISDR, 0);
        bm_ci_write(sc, BCSP_IER, INTR_RCRI | INTR_BSCN);
        bus_setup_intr(dev, sc->sc_base.sc_ires, INTR_TYPE_NET | INTR_MPSAFE,
            NULL, bman_portal_isr, sc, &sc->sc_base.sc_intr_cookie);
        bus_bind_intr(dev, sc->sc_base.sc_ires, cpu);

        /* Select valid-bit mode for rings */
        bus_write_4(sc->sc_base.sc_mres[1], BCSP_CFG, CFG_RPM_VBM);
        /* Disable pool depletion notifications. */
        bm_ci_write(sc, BCSP_SCN0, 0);
        bm_ci_write(sc, BCSP_SCN1, 0);

        DPCPU_ID_SET(cpu, bman_affine_portal, sc);

        sc->sc_rcr.ring =
            (struct bman_rcr_entry *)(sc->sc_base.sc_ce_va + BMAN_CE_RCR);
        bman_rcr_ring_init(&sc->sc_rcr, &sc->sc_base);
        /* Starting MC polarity is always 1 */
        sc->mc.polarity = BMAN_MC_VERB_VBIT;

        return (0);
}

int
bman_portal_detach(device_t dev)
{
        struct bman_portal_softc *sc;
        int i;

        sc = device_get_softc(dev);


        /* TODO: Unmap TLB regions */
        thread_lock(curthread);
        sched_bind(curthread, sc->sc_base.sc_cpu);
        thread_unlock(curthread);

        if (sc->sc_base.sc_ires != NULL)
                bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_base.sc_ires);

        for (i = 0; i < nitems(sc->sc_base.sc_mres); i++) {
                if (sc->sc_base.sc_mres[i] != NULL)
                        bus_release_resource(dev, SYS_RES_MEMORY,
                            i, sc->sc_base.sc_mres[i]);
        }
        thread_lock(curthread);
        sched_unbind(curthread);
        thread_unlock(curthread);


        return (0);
}

static uint64_t
bman_query(struct bman_portal_softc *sc, bool depletion)
{
        union bman_mc_result *mc_res;
        uint64_t res;

        critical_enter();
        mc_res = bman_mc_send(sc, BMAN_MC_VERB_QUERY, 0);
        if (mc_res == NULL)
                goto err;

        if (depletion)
                res = mc_res->bp_ds;
        else
                res = mc_res->bp_as;
        critical_exit();

        return (res);

err:
        critical_exit();
        device_printf(sc->sc_base.sc_dev, "Timeout querying depltetion\n");
        return (0);
}

static void
bman_portal_isr(void *arg)
{
        struct bman_portal_softc *sc = arg;
        uint32_t intrs;

        intrs = bm_ci_read(sc, BCSP_ISR);

        /* Release Command Ring interrupt. */
        if (intrs & INTR_RCRI) {
                bman_rcr_update(&sc->sc_rcr, &sc->sc_base);
        }
        /* Buffer Pool State Change Notification. */
        if (intrs & INTR_BSCN) {
                struct bman_pool *pool;
                uint64_t res = bman_query(sc, true);
                if (__predict_true(res != 0)) {
                        int idx = flsll(res);
                        pool = sc->sc_pools[64 - idx];
                        KASSERT(pool != NULL,
                            ("state change on unassociated bpid %d\n", idx));
                        pool->dep_cb(pool->arg, true);
                }
        }

        bm_ci_write(sc, BCSP_ISR, intrs);
}

/* RCR */

int
bman_release(struct bman_pool *pool, const struct bman_buffer *bufs,
    uint8_t count)
{
        struct bman_portal_softc *portal;
        struct bman_rcr_entry *rcr;

        if (count > 8)
                return (EINVAL);

        critical_enter();
        portal = DPCPU_GET(bman_affine_portal);
        rcr = bman_rcr_start(&portal->sc_rcr, &portal->sc_base);
        bzero(rcr, sizeof(*rcr));

        /* This should be safe, because bpid must be less than 256. */
        for (int i = 0; i < count; i++)
                rcr->bufs[i] = bufs[i];
        rcr->bufs[0].bpid = pool->bpid;
        bman_rcr_commit(&portal->sc_rcr, BMAN_RCR_VERB_BPID0 | count);
        critical_exit();

        return (0);
}

/* MC commands */
/* Assumes pinned */
static union bman_mc_result *
bman_mc_send(struct bman_portal_softc *p, uint8_t verb, uint8_t cd)
{
        int res_idx;
        struct bman_mc_command *command;
        union bman_mc_result *rr;
        uintptr_t ce_va = p->sc_base.sc_ce_va;

        command = (struct bman_mc_command *)(ce_va + BMAN_CE_CR);
        dpaa_zero_line(command);
        command->cd = cd;
        dpaa_lw_barrier();
        command->verb = verb | p->mc.polarity;
        res_idx = (p->mc.polarity ? 1 : 0);
        p->mc.polarity ^= BMAN_MC_VERB_VBIT;
        dpaa_flush_line(command);

        rr = (union bman_mc_result *)(ce_va + BMAN_CE_RR(res_idx));
        for (;;) {
                if (rr->verb != 0)
                        break;
                dpaa_flush_line(rr);
        }
        return (rr);
}

int
bman_acquire(struct bman_pool *pool, struct bman_buffer *bufs, uint8_t count)
{
        union bman_mc_result *rr;

        if (count > 8 || count == 0)
                return (EINVAL);
        critical_enter();
        rr = bman_mc_send(DPCPU_GET(bman_affine_portal),
            BMAN_MC_VERB_ACQUIRE | count,
            pool->bpid);
        critical_exit();

        if (rr == NULL)
                return (ETIMEDOUT);
        if ((rr->verb & ~BMAN_MC_VERB_VBIT) == 0)
                return (ENOMEM);

        memcpy(bufs, rr, count * sizeof(*bufs));

        return (0);
}

/*
 * Enable pool state change notifications on this portal.  This requires the
 * pool to already be configured with the callback to handle state changes.
 */
void
bman_portal_enable_scn(struct bman_portal_softc *sc, struct bman_pool *pool)
{
        uint32_t reg, reg_ptr;

        if (pool->bpid >= 32)
                reg_ptr = BCSP_SCN1;
        else
                reg_ptr = BCSP_SCN0;
        reg = bm_ci_read(sc, reg_ptr);
        reg |= (1 << (31 - pool->bpid));
        bm_ci_write(sc, reg_ptr, reg);
        sc->sc_pools[pool->bpid] = pool;
}