/*
 * Copyright (c) 2025-2026 The FreeBSD Foundation
 *
 * This software was developed by Björn Zeeb under sponsorship from
 * the FreeBSD Foundation.
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <linux/types.h>
#include <linux/dma-mapping.h>
#include <net/page_pool/helpers.h>

struct page_pool *
linuxkpi_page_pool_create(const struct page_pool_params *ppparams)
{
        struct page_pool *pp;
        int error;

#ifndef PAGE_IS_LKPI_PAGE
        WARN_ONCE(1, "\n!!! LinuxKPI page pool not supported yet!!!\n\n");
#endif

        pp = kzalloc_node(sizeof(*pp), GFP_KERNEL, ppparams->nid);
        if (pp == NULL)
                return (ERR_PTR(-ENOMEM));

        pp->params = *ppparams;

        if ((pp->params.flags & PP_FLAG_DMA_MAP) != 0) {
                if (pp->params.dma_dir != DMA_FROM_DEVICE &&
                    pp->params.dma_dir != DMA_BIDIRECTIONAL) {
                        pr_warn_once("%s: invalid dma_dir %#04x\n",
                            __func__, pp->params.dma_dir);
                        error = -EINVAL;
                        goto free_pp;
                }
        }

        if ((pp->params.flags & PP_FLAG_DMA_SYNC_DEV) != 0) {
                if ((pp->params.flags & PP_FLAG_DMA_MAP) == 0) {
                        pr_warn_once("%s: DMA_SYNC_DEV but no DMA_MAP\n",
                            __func__);
                        error = -EINVAL;
                        goto free_pp;
                }

                if (pp->params.max_len == 0) {
                        pr_warn_once("%s: max_len unset\n", __func__);
                        error = -EINVAL;
                        goto free_pp;
                }
        }

        return (pp);

free_pp:
        kfree(pp);
        return (ERR_PTR(error));
}

void
linuxkpi_page_pool_destroy(struct page_pool *pp)
{
        kfree(pp);
}

/* ---------------------------------------------------------------------------- */

struct page *
linuxkpi_page_pool_alloc_frag(struct page_pool *pp, uint32_t *offset,
    size_t size, gfp_t gfp)
{
#ifdef PAGE_IS_LKPI_PAGE
        struct page *p;
        dma_addr_t dma;

        if (size > PAGE_SIZE) {
                pr_warn_once("%s: size %zu > PAGE_SIZE\n", __func__, size);
                return (NULL);
        }

        /*
         * We do not try to be smart on the first cut until 'struct page' work
         * is sorted and settled.  Everyone gets a page for now.
         * XXX in the future deal with page fragments, pool limits, etc.
         */
        p = alloc_page(gfp);
        if (p == NULL)
                return (NULL);

        if (offset != NULL)
                *offset = 0;

        if ((pp->params.flags & PP_FLAG_DMA_MAP) != 0) {
                dma = dma_map_page_attrs(pp->params.dev, p, 0, PAGE_SIZE,
                    pp->params.dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
                if (dma_mapping_error(pp->params.dev, dma)) {
                        put_page(p);
                        return (NULL);
                }

                /* We store the dma address in struct page as well. */
                p->dma_addr = dma;
        }

        if ((pp->params.flags & PP_FLAG_DMA_SYNC_DEV) != 0)
                dma_sync_single_for_device(pp->params.dev, dma, PAGE_SIZE,
                    pp->params.dma_dir);

        /*
         * We may not yet need to track the page pool on the page in order
         * to know where to return it but prepare at least for that.
         */
        p->pp = pp;

        return (p);
#else
        return (NULL);
#endif /* PAGE_IS_LKPI_PAGE */
}

struct page *
linuxkpi_page_pool_dev_alloc_frag(struct page_pool *pp, uint32_t *offset,
    size_t size)
{
        gfp_t gfp;

        gfp = (GFP_ATOMIC | __GFP_NOWARN);
        return (page_pool_alloc_frag(pp, offset, size, gfp));
}

void
linuxkpi_page_pool_put_full_page(struct page_pool *pp, struct page *page,
    bool allow_direct)
{
        /* We just free the full page we handed out for now. */
#ifdef PAGE_IS_LKPI_PAGE
        page->pp = NULL;
        page->dma_addr = 0;
#endif
        put_page(page);
}

dma_addr_t
linuxkpi_page_pool_get_dma_addr(const struct page *page)
{

        KASSERT(page != NULL, ("%s: page %p\n", __func__, page));

#ifdef PAGE_IS_LKPI_PAGE
        return (page->dma_addr);
#else
        return (0);
#endif
}