// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
/* Copyright (c) 2020 Marvell International Ltd. */

#include <linux/dma-mapping.h>
#include <linux/qed/qed_chain.h>
#include <linux/vmalloc.h>

#include "qed_dev_api.h"

static void qed_chain_init(struct qed_chain *chain,
                           const struct qed_chain_init_params *params,
                           u32 page_cnt)
{
        memset(chain, 0, sizeof(*chain));

        chain->elem_size = params->elem_size;
        chain->intended_use = params->intended_use;
        chain->mode = params->mode;
        chain->cnt_type = params->cnt_type;

        chain->elem_per_page = ELEMS_PER_PAGE(params->elem_size,
                                              params->page_size);
        chain->usable_per_page = USABLE_ELEMS_PER_PAGE(params->elem_size,
                                                       params->page_size,
                                                       params->mode);
        chain->elem_unusable = UNUSABLE_ELEMS_PER_PAGE(params->elem_size,
                                                       params->mode);

        chain->elem_per_page_mask = chain->elem_per_page - 1;
        chain->next_page_mask = chain->usable_per_page &
                                chain->elem_per_page_mask;

        chain->page_size = params->page_size;
        chain->page_cnt = page_cnt;
        chain->capacity = chain->usable_per_page * page_cnt;
        chain->size = chain->elem_per_page * page_cnt;

        if (params->ext_pbl_virt) {
                chain->pbl_sp.table_virt = params->ext_pbl_virt;
                chain->pbl_sp.table_phys = params->ext_pbl_phys;

                chain->b_external_pbl = true;
        }
}

static void qed_chain_init_next_ptr_elem(const struct qed_chain *chain,
                                         void *virt_curr, void *virt_next,
                                         dma_addr_t phys_next)
{
        struct qed_chain_next *next;
        u32 size;

        size = chain->elem_size * chain->usable_per_page;
        next = virt_curr + size;

        DMA_REGPAIR_LE(next->next_phys, phys_next);
        next->next_virt = virt_next;
}

static void qed_chain_init_mem(struct qed_chain *chain, void *virt_addr,
                               dma_addr_t phys_addr)
{
        chain->p_virt_addr = virt_addr;
        chain->p_phys_addr = phys_addr;
}

static void qed_chain_free_next_ptr(struct qed_dev *cdev,
                                    struct qed_chain *chain)
{
        struct device *dev = &cdev->pdev->dev;
        struct qed_chain_next *next;
        dma_addr_t phys, phys_next;
        void *virt, *virt_next;
        u32 size, i;

        size = chain->elem_size * chain->usable_per_page;
        virt = chain->p_virt_addr;
        phys = chain->p_phys_addr;

        for (i = 0; i < chain->page_cnt; i++) {
                if (!virt)
                        break;

                next = virt + size;
                virt_next = next->next_virt;
                phys_next = HILO_DMA_REGPAIR(next->next_phys);

                dma_free_coherent(dev, chain->page_size, virt, phys);

                virt = virt_next;
                phys = phys_next;
        }
}

static void qed_chain_free_single(struct qed_dev *cdev,
                                  struct qed_chain *chain)
{
        if (!chain->p_virt_addr)
                return;

        dma_free_coherent(&cdev->pdev->dev, chain->page_size,
                          chain->p_virt_addr, chain->p_phys_addr);
}

static void qed_chain_free_pbl(struct qed_dev *cdev, struct qed_chain *chain)
{
        struct device *dev = &cdev->pdev->dev;
        struct addr_tbl_entry *entry;
        u32 i;

        if (!chain->pbl.pp_addr_tbl)
                return;

        for (i = 0; i < chain->page_cnt; i++) {
                entry = chain->pbl.pp_addr_tbl + i;
                if (!entry->virt_addr)
                        break;

                dma_free_coherent(dev, chain->page_size, entry->virt_addr,
                                  entry->dma_map);
        }

        if (!chain->b_external_pbl)
                dma_free_coherent(dev, chain->pbl_sp.table_size,
                                  chain->pbl_sp.table_virt,
                                  chain->pbl_sp.table_phys);

        vfree(chain->pbl.pp_addr_tbl);
        chain->pbl.pp_addr_tbl = NULL;
}

/**
 * qed_chain_free() - Free chain DMA memory.
 *
 * @cdev: Main device structure.
 * @chain: Chain to free.
 */
void qed_chain_free(struct qed_dev *cdev, struct qed_chain *chain)
{
        switch (chain->mode) {
        case QED_CHAIN_MODE_NEXT_PTR:
                qed_chain_free_next_ptr(cdev, chain);
                break;
        case QED_CHAIN_MODE_SINGLE:
                qed_chain_free_single(cdev, chain);
                break;
        case QED_CHAIN_MODE_PBL:
                qed_chain_free_pbl(cdev, chain);
                break;
        default:
                return;
        }

        qed_chain_init_mem(chain, NULL, 0);
}

static int
qed_chain_alloc_sanity_check(struct qed_dev *cdev,
                             const struct qed_chain_init_params *params,
                             u32 page_cnt)
{
        u64 chain_size;

        chain_size = ELEMS_PER_PAGE(params->elem_size, params->page_size);
        chain_size *= page_cnt;

        if (!chain_size)
                return -EINVAL;

        /* The actual chain size can be larger than the maximal possible value
         * after rounding up the requested elements number to pages, and after
         * taking into account the unusuable elements (next-ptr elements).
         * The size of a "u16" chain can be (U16_MAX + 1) since the chain
         * size/capacity fields are of u32 type.
         */
        switch (params->cnt_type) {
        case QED_CHAIN_CNT_TYPE_U16:
                if (chain_size > U16_MAX + 1)
                        break;

                return 0;
        case QED_CHAIN_CNT_TYPE_U32:
                if (chain_size > U32_MAX)
                        break;

                return 0;
        default:
                return -EINVAL;
        }

        DP_NOTICE(cdev,
                  "The actual chain size (0x%llx) is larger than the maximal possible value\n",
                  chain_size);

        return -EINVAL;
}

static int qed_chain_alloc_next_ptr(struct qed_dev *cdev,
                                    struct qed_chain *chain)
{
        struct device *dev = &cdev->pdev->dev;
        void *virt, *virt_prev = NULL;
        dma_addr_t phys;
        u32 i;

        for (i = 0; i < chain->page_cnt; i++) {
                virt = dma_alloc_coherent(dev, chain->page_size, &phys,
                                          GFP_KERNEL);
                if (!virt)
                        return -ENOMEM;

                if (i == 0) {
                        qed_chain_init_mem(chain, virt, phys);
                        qed_chain_reset(chain);
                } else {
                        qed_chain_init_next_ptr_elem(chain, virt_prev, virt,
                                                     phys);
                }

                virt_prev = virt;
        }

        /* Last page's next element should point to the beginning of the
         * chain.
         */
        qed_chain_init_next_ptr_elem(chain, virt_prev, chain->p_virt_addr,
                                     chain->p_phys_addr);

        return 0;
}

static int qed_chain_alloc_single(struct qed_dev *cdev,
                                  struct qed_chain *chain)
{
        dma_addr_t phys;
        void *virt;

        virt = dma_alloc_coherent(&cdev->pdev->dev, chain->page_size,
                                  &phys, GFP_KERNEL);
        if (!virt)
                return -ENOMEM;

        qed_chain_init_mem(chain, virt, phys);
        qed_chain_reset(chain);

        return 0;
}

static int qed_chain_alloc_pbl(struct qed_dev *cdev, struct qed_chain *chain)
{
        struct device *dev = &cdev->pdev->dev;
        struct addr_tbl_entry *addr_tbl;
        dma_addr_t phys, pbl_phys;
        __le64 *pbl_virt;
        u32 page_cnt, i;
        size_t size;
        void *virt;

        page_cnt = chain->page_cnt;

        size = array_size(page_cnt, sizeof(*addr_tbl));
        if (unlikely(size == SIZE_MAX))
                return -EOVERFLOW;

        addr_tbl = vzalloc(size);
        if (!addr_tbl)
                return -ENOMEM;

        chain->pbl.pp_addr_tbl = addr_tbl;

        if (chain->b_external_pbl) {
                pbl_virt = chain->pbl_sp.table_virt;
                goto alloc_pages;
        }

        size = array_size(page_cnt, sizeof(*pbl_virt));
        if (unlikely(size == SIZE_MAX))
                return -EOVERFLOW;

        pbl_virt = dma_alloc_coherent(dev, size, &pbl_phys, GFP_KERNEL);
        if (!pbl_virt)
                return -ENOMEM;

        chain->pbl_sp.table_virt = pbl_virt;
        chain->pbl_sp.table_phys = pbl_phys;
        chain->pbl_sp.table_size = size;

alloc_pages:
        for (i = 0; i < page_cnt; i++) {
                virt = dma_alloc_coherent(dev, chain->page_size, &phys,
                                          GFP_KERNEL);
                if (!virt)
                        return -ENOMEM;

                if (i == 0) {
                        qed_chain_init_mem(chain, virt, phys);
                        qed_chain_reset(chain);
                }

                /* Fill the PBL table with the physical address of the page */
                pbl_virt[i] = cpu_to_le64(phys);

                /* Keep the virtual address of the page */
                addr_tbl[i].virt_addr = virt;
                addr_tbl[i].dma_map = phys;
        }

        return 0;
}

/**
 * qed_chain_alloc() - Allocate and initialize a chain.
 *
 * @cdev: Main device structure.
 * @chain: Chain to be processed.
 * @params: Chain initialization parameters.
 *
 * Return: 0 on success, negative errno otherwise.
 */
int qed_chain_alloc(struct qed_dev *cdev, struct qed_chain *chain,
                    struct qed_chain_init_params *params)
{
        u32 page_cnt;
        int rc;

        if (!params->page_size)
                params->page_size = QED_CHAIN_PAGE_SIZE;

        if (params->mode == QED_CHAIN_MODE_SINGLE)
                page_cnt = 1;
        else
                page_cnt = QED_CHAIN_PAGE_CNT(params->num_elems,
                                              params->elem_size,
                                              params->page_size,
                                              params->mode);

        rc = qed_chain_alloc_sanity_check(cdev, params, page_cnt);
        if (rc) {
                DP_NOTICE(cdev,
                          "Cannot allocate a chain with the given arguments:\n");
                DP_NOTICE(cdev,
                          "[use_mode %d, mode %d, cnt_type %d, num_elems %d, elem_size %zu, page_size %u]\n",
                          params->intended_use, params->mode, params->cnt_type,
                          params->num_elems, params->elem_size,
                          params->page_size);
                return rc;
        }

        qed_chain_init(chain, params, page_cnt);

        switch (params->mode) {
        case QED_CHAIN_MODE_NEXT_PTR:
                rc = qed_chain_alloc_next_ptr(cdev, chain);
                break;
        case QED_CHAIN_MODE_SINGLE:
                rc = qed_chain_alloc_single(cdev, chain);
                break;
        case QED_CHAIN_MODE_PBL:
                rc = qed_chain_alloc_pbl(cdev, chain);
                break;
        default:
                return -EINVAL;
        }

        if (!rc)
                return 0;

        qed_chain_free(cdev, chain);

        return rc;
}