/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2026 Dmitry Salychev
 * Copyright (c) 2026 Bjoern A. Zeeb
 *
 * 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 <sys/cdefs.h>

#include <sys/param.h>
#include <sys/errno.h>
#include <sys/endian.h>

#include <vm/vm.h>
#include <vm/pmap.h>

#include <machine/vmparam.h>

#include "dpaa2_types.h"
#include "dpaa2_frame.h"
#include "dpaa2_buf.h"
#include "dpaa2_swp.h"

/**
 * @brief Build a DPAA2 frame descriptor.
 */
int
dpaa2_fd_build(device_t dev, const uint16_t tx_data_off, struct dpaa2_buf *buf,
    bus_dma_segment_t *segs, const int nsegs, struct dpaa2_fd *fd)
{
	struct dpaa2_buf *sgt = buf->sgt;
	struct dpaa2_sg_entry *sge;
	struct dpaa2_swa *swa;
	int i, error;

	if (buf == NULL || segs == NULL || nsegs == 0 || fd == NULL)
		return (EINVAL);

	KASSERT(nsegs <= DPAA2_TX_SEGLIMIT, ("%s: too many segments", __func__));
	KASSERT(buf->opt != NULL, ("%s: no Tx ring?", __func__));
	KASSERT(sgt != NULL, ("%s: no S/G table?", __func__));
	KASSERT(sgt->vaddr != NULL, ("%s: no S/G vaddr?", __func__));

	memset(fd, 0, sizeof(*fd));

	/* Populate and map S/G table */
	if (__predict_true(nsegs <= DPAA2_TX_SEGLIMIT)) {
		sge = (struct dpaa2_sg_entry *)sgt->vaddr + tx_data_off;
		for (i = 0; i < nsegs; i++) {
			sge[i].addr = (uint64_t)segs[i].ds_addr;
			sge[i].len = (uint32_t)segs[i].ds_len;
			sge[i].offset_fmt = 0u;
		}
		sge[i-1].offset_fmt |= 0x8000u; /* set final entry flag */

		KASSERT(sgt->paddr == 0, ("%s: paddr(%#jx) != 0", __func__,
		    sgt->paddr));

		error = bus_dmamap_load(sgt->dmat, sgt->dmap, sgt->vaddr,
		    DPAA2_TX_SGT_SZ, dpaa2_dmamap_oneseg_cb, &sgt->paddr,
		    BUS_DMA_NOWAIT);
		if (__predict_false(error != 0)) {
			device_printf(dev, "%s: bus_dmamap_load() failed: "
			    "error=%d\n", __func__, error);
			return (error);
		}

		buf->paddr = sgt->paddr;
		buf->vaddr = sgt->vaddr;
	} else {
		return (EINVAL);
	}

	swa = (struct dpaa2_swa *)sgt->vaddr;
	swa->magic = DPAA2_MAGIC;
	swa->buf = buf;

	fd->addr = buf->paddr;
	fd->data_length = (uint32_t)buf->m->m_pkthdr.len;
	fd->bpid_ivp_bmt = 0;
	fd->offset_fmt_sl = 0x2000u | tx_data_off;
	fd->ctrl = (0x4u & DPAA2_FD_PTAC_MASK) << DPAA2_FD_PTAC_SHIFT;

	return (0);
}

int
dpaa2_fd_err(struct dpaa2_fd *fd)
{
	return ((fd->ctrl >> DPAA2_FD_ERR_SHIFT) & DPAA2_FD_ERR_MASK);
}

uint32_t
dpaa2_fd_data_len(struct dpaa2_fd *fd)
{
	if (dpaa2_fd_short_len(fd)) {
		return (fd->data_length & DPAA2_FD_LEN_MASK);
	}
	return (fd->data_length);
}

int
dpaa2_fd_format(struct dpaa2_fd *fd)
{
	return ((enum dpaa2_fd_format)((fd->offset_fmt_sl >>
	    DPAA2_FD_FMT_SHIFT) & DPAA2_FD_FMT_MASK));
}

bool
dpaa2_fd_short_len(struct dpaa2_fd *fd)
{
	return (((fd->offset_fmt_sl >> DPAA2_FD_SL_SHIFT)
	    & DPAA2_FD_SL_MASK) == 1);
}

int
dpaa2_fd_offset(struct dpaa2_fd *fd)
{
	return (fd->offset_fmt_sl & DPAA2_FD_OFFSET_MASK);
}

uint32_t
dpaa2_fd_get_frc(struct dpaa2_fd *fd)
{
	/* TODO: Convert endiannes in the other functions as well. */
	return (le32toh(fd->frame_ctx));
}

#ifdef _not_yet_
void
dpaa2_fd_set_frc(struct dpaa2_fd *fd, uint32_t frc)
{
	/* TODO: Convert endiannes in the other functions as well. */
	fd->frame_ctx = htole32(frc);
}
#endif

int
dpaa2_fa_get_swa(struct dpaa2_fd *fd, struct dpaa2_swa **swa)
{
	if (__predict_false(fd == NULL || swa == NULL))
		return (EINVAL);

	if (((fd->ctrl >> DPAA2_FD_PTAC_SHIFT) & DPAA2_FD_PTAC_PTA_MASK) == 0u) {
		*swa = NULL;
		return (ENOENT);
	}

	*swa = (struct dpaa2_swa *)PHYS_TO_DMAP((bus_addr_t)fd->addr);

	return (0);
}

int
dpaa2_fa_get_hwa(struct dpaa2_fd *fd, struct dpaa2_hwa **hwa)
{
	uint8_t *buf;
	uint32_t hwo; /* HW annotation offset */

	if (__predict_false(fd == NULL || hwa == NULL))
		return (EINVAL);

	/*
	 * As soon as the ASAL is in the 64-byte units, we don't need to
	 * calculate the exact length, but make sure that it isn't 0.
	 */
	if (((fd->ctrl >> DPAA2_FD_ASAL_SHIFT) & DPAA2_FD_ASAL_MASK) == 0u) {
		*hwa = NULL;
		return (ENOENT);
	}

	buf = (uint8_t *)PHYS_TO_DMAP((bus_addr_t)fd->addr);
	hwo = ((fd->ctrl >> DPAA2_FD_PTAC_SHIFT) & DPAA2_FD_PTAC_PTA_MASK) > 0u
	    ? DPAA2_FA_SWA_SIZE : 0u;
	*hwa = (struct dpaa2_hwa *)(buf + hwo);

	return (0);
}

int
dpaa2_fa_get_fas(struct dpaa2_fd *fd, struct dpaa2_hwa_fas *fas)
{
	struct dpaa2_hwa *hwa;
	struct dpaa2_hwa_fas *fasp;
	int rc;

	if (__predict_false(fd == NULL || fas == NULL))
		return (EINVAL);

	rc = dpaa2_fa_get_hwa(fd, &hwa);
	if (__predict_false(rc != 0))
		return (rc);

	fasp = (struct dpaa2_hwa_fas *)&hwa->fas;
	*fas = *fasp;

	return (rc);
}

#ifdef _not_yet_
int
dpaa2_fa_set_fas(struct dpaa2_fd *fd, struct dpaa2_hwa_fas *fas)
{
	struct dpaa2_hwa *hwa;
	uint64_t *valp;
	int rc;

	if (__predict_false(fd == NULL || fas == NULL))
		return (EINVAL);

	rc = dpaa2_fa_get_hwa(fd, &hwa);
	if (__predict_false(rc != 0))
		return (rc);

	valp = (uint64_t *)fas;
	hwa->fas = *valp;

	return (rc);
}
#endif