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

#ifndef DPAA_COMMON_H
#define DPAA_COMMON_H

#include <machine/atomic.h>

int     dpaa_map_private_memory(device_t dev, int idx, const char *compat,
    vm_paddr_t *addrp, size_t *sizep);

struct dpaa_fd {
        uint64_t liodn:8;
        uint64_t bpid:8;
        uint64_t eliodn:4;
        uint64_t _rsvd1:4;
        uint64_t addr:40;
        uint32_t format:3;
        uint32_t offset:9;
        uint32_t length:20;
        uint32_t cmd_stat;
} __packed;

#define DPAA_FD_FORMAT_SHORT_MBSF       4

#define DPAA_FD_RX_STATUS_DCL4C         0x10000000
#define DPAA_FD_RX_STATUS_DME           0x01000000
#define DPAA_FD_RX_STATUS_IPRE_M        0x00300000
#define DPAA_FD_RX_STATUS_FPE           0x00080000
#define DPAA_FD_RX_STATUS_FSE           0x00040000
#define DPAA_FD_RX_STATUS_DIS           0x00020000
#define DPAA_FD_RX_STATUS_EOF           0x00008000
#define DPAA_FD_RX_STATUS_NSS           0x00004000
#define DPAA_FD_RX_STATUS_KSO           0x00002000
#define DPAA_FD_RX_STATUS_FCL_M         0x00000c00
#define DPAA_FD_RX_STATUS_IPP           0x00000200
#define DPAA_FD_RX_STATUS_FLM           0x00000100
#define DPAA_FD_RX_STATUS_PTE           0x00000080
#define DPAA_FD_RX_STATUS_ISP           0x00000040
#define DPAA_FD_RX_STATUS_PHE           0x00000020
#define DPAA_FD_RX_STATUS_FRDR          0x00000010
#define DPAA_FD_RX_STATUS_BLE           0x00000008
#define DPAA_FD_RX_STATUS_L4CV          0x00000004
#define DPAA_FD_RX_STATUS_IPR           0x00000001

#define DPAA_FD_TX_CMD_RPD              0x40000000
#define DPAA_FD_TX_CMD_DTC              0x10000000
#define DPAA_FD_TX_STATUS_UFD           0x04000000
#define DPAA_FD_TX_STATUS_LGE           0x02000000
#define DPAA_FD_TX_STATUS_DME           0x01000000

/* Most of the above are error flags, but some aren't */
#define DPAA_FD_CMD_STAT_ERR_M          0x010ce3e8
#define DPAA_FD_TX_STAT_ERR_M           0x03000000

#define DPAA_FD_GET_ADDR(fd)    ((void *)PHYS_TO_DMAP(fd->addr))

struct dpaa_sgte {
        uint64_t addr;
        uint32_t extension:1;
        uint32_t final:1;
        uint32_t length:30;
        uint16_t bpid;
        uint16_t offset;
} __packed;
struct qman_fqr;


#define DPAA_NUM_OF_SG_TABLE_ENTRY      16

/*
 * Ring API infrastructure
 *
 * BMan and QMan both use cache-enabled rings.  Abstract this away to a more
 * generalized interface to reduce code copying.
 *
 * Requirements:
 * - Before calling <ring>_init() the ring base (ring->ring) must be initialized
 *   to the base of the ring.
 */
#define DPAA_RING_DECLARE(pfx)                  \
        struct pfx##_ring {                     \
                struct pfx##_entry *ring;       \
                struct pfx##_entry *cursor;     \
                uint8_t vbit;                   \
                uint8_t avail;                  \
                uint8_t ci;                     \
                uint8_t ithresh;                \
        }

/*
 * Ring functions:
 *
 * ring_cyc_diff() -- get the (circular) difference of `l - f`
 * ring_ring_init() -- Set up the ring structures. Portal must be
 *                     initialized beforehand, and ring->ring must be nonzero.
 * ring_CARRYCLEAR() -- stealth math to do circular roll-over
 * ring_INC() -- Increment the cursor within the ring
 * ring_update() -- Update ring entry availability count
 * ring_start() -- Reserve the next entry in the ring if available.
 * ring_commit() -- Commit the reserved ring entry by setting the verb and
 *                  AVB bit
 */
#define DPAA_RING(pfx,sz,pi_e,ci_e,pi_i,ci_i)                           \
static inline int                                                       \
pfx##_cyc_diff(uint8_t size, uint8_t f, uint8_t l)                      \
{                                                                       \
        if (f <= l)                                                     \
                return (uint8_t)(l - f);                                \
        return (uint8_t)(l + size - f);                                 \
}                                                                       \
static inline void                                                      \
pfx##_ring_init(struct pfx##_ring *ring, struct dpaa_portal_softc *portal)\
{                                                                       \
        uint32_t pi = *(uint32_t*)(portal->sc_ci_va + pi_i) & (sz - 1); \
        uint32_t ci = *(uint32_t*)(portal->sc_ci_va + ci_i);            \
        ring->ci = ci & (sz - 1);                                       \
        ring->vbit = !!(ci & sz) << 7;                                  \
        ring->cursor = ring->ring + pi;                                 \
        ring->avail = sz - 1 - pfx##_cyc_diff(sz, ring->ci, pi);        \
}                                                                       \
static inline void *                                                    \
pfx##_CARRYCLEAR(struct pfx##_entry *p)                                 \
{                                                                       \
        return ((void *)((uintptr_t)p & (~(uintptr_t)(sz << 6))));      \
}                                                                       \
static inline void                                                      \
pfx##_INC(struct pfx##_ring *ring)                                      \
{                                                                       \
        struct pfx##_entry *partial = ring->cursor + 1;                 \
        ring->cursor = pfx##_CARRYCLEAR(partial);                       \
        if (partial != ring->cursor)                                    \
                ring->vbit ^= 0x80;                                     \
}                                                                       \
static inline uint8_t                                                   \
pfx##_update(struct pfx##_ring *ring, struct dpaa_portal_softc *portal) \
{                                                                       \
        uint8_t diff, old_ci = ring->ci;                                \
        ring->ci = *(uint32_t*)(portal->sc_ci_va + ci_i) & (sz - 1);    \
        diff = pfx##_cyc_diff(sz, old_ci, ring->ci);                    \
        ring->avail += diff;                                            \
        return (diff);                                                  \
}                                                                       \
static inline struct pfx##_entry * __unused                             \
pfx##_start(struct pfx##_ring *ring, struct dpaa_portal_softc *portal)  \
{                                                                       \
        if (ring->avail <= 1) {                                         \
                pfx##_update(ring, portal);                             \
                if (ring->avail == 0)                                   \
                        return (NULL);                                  \
        }                                                               \
        dpaa_zero_line(ring->cursor);                                   \
        return (ring->cursor);                                          \
}                                                                       \
static inline void __unused                                             \
pfx##_commit(struct pfx##_ring *ring, uint8_t verb)                     \
{                                                                       \
        struct pfx##_entry *entry = ring->cursor;                       \
        dpaa_lw_barrier();                                              \
        entry->verb = verb | ring->vbit;                                \
        dpaa_flush_line(entry);                                         \
        pfx##_INC(ring);                                                \
        ring->avail--;                                                  \
} struct hack

#ifdef  __powerpc__
static inline void
dpaa_flush_line(void *line)
{
        __asm __volatile ("dcbf 0, %0" :: "r"(line) : "memory");
}

static inline void
dpaa_zero_line(void *line)
{
        __asm __volatile ("dcbz 0, %0" :: "r"(line) : "memory");
}

static inline void
dpaa_touch_line(void *line)
{
        __asm __volatile ("dcbt 0, %0" :: "r"(line) : "memory");
}

static inline void
dpaa_lw_barrier(void)
{
        powerpc_lwsync();
}
#endif

#endif