// SPDX-License-Identifier: GPL-2.0
// Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.

#include <linux/dma-mapping.h>

#include "hinic3_hwdev.h"
#include "hinic3_wq.h"

#define WQ_MIN_DEPTH            64
#define WQ_MAX_DEPTH            65536
#define WQ_PAGE_ADDR_SIZE       sizeof(u64)
#define WQ_MAX_NUM_PAGES        (HINIC3_MIN_PAGE_SIZE / WQ_PAGE_ADDR_SIZE)

static int wq_init_wq_block(struct hinic3_hwdev *hwdev, struct hinic3_wq *wq)
{
	struct hinic3_queue_pages *qpages = &wq->qpages;
	int i;

	if (hinic3_wq_is_0_level_cla(wq)) {
		wq->wq_block_paddr = qpages->pages[0].align_paddr;
		wq->wq_block_vaddr = qpages->pages[0].align_vaddr;

		return 0;
	}

	if (wq->qpages.num_pages > WQ_MAX_NUM_PAGES) {
		dev_err(hwdev->dev, "wq num_pages exceed limit: %lu\n",
			WQ_MAX_NUM_PAGES);
		return -EFAULT;
	}

	wq->wq_block_vaddr = dma_alloc_coherent(hwdev->dev,
						HINIC3_MIN_PAGE_SIZE,
						&wq->wq_block_paddr,
						GFP_KERNEL);
	if (!wq->wq_block_vaddr)
		return -ENOMEM;

	for (i = 0; i < qpages->num_pages; i++)
		wq->wq_block_vaddr[i] = cpu_to_be64(qpages->pages[i].align_paddr);

	return 0;
}

static int wq_alloc_pages(struct hinic3_hwdev *hwdev, struct hinic3_wq *wq)
{
	int err;

	err = hinic3_queue_pages_alloc(hwdev, &wq->qpages, 0);
	if (err)
		return err;

	err = wq_init_wq_block(hwdev, wq);
	if (err) {
		hinic3_queue_pages_free(hwdev, &wq->qpages);
		return err;
	}

	return 0;
}

static void wq_free_pages(struct hinic3_hwdev *hwdev, struct hinic3_wq *wq)
{
	if (!hinic3_wq_is_0_level_cla(wq))
		dma_free_coherent(hwdev->dev,
				  HINIC3_MIN_PAGE_SIZE,
				  wq->wq_block_vaddr,
				  wq->wq_block_paddr);

	hinic3_queue_pages_free(hwdev, &wq->qpages);
}

int hinic3_wq_create(struct hinic3_hwdev *hwdev, struct hinic3_wq *wq,
		     u32 q_depth, u16 wqebb_size)
{
	u32 wq_page_size;

	if (q_depth < WQ_MIN_DEPTH || q_depth > WQ_MAX_DEPTH ||
	    !is_power_of_2(q_depth) || !is_power_of_2(wqebb_size)) {
		dev_err(hwdev->dev, "Invalid WQ: q_depth %u, wqebb_size %u\n",
			q_depth, wqebb_size);
		return -EINVAL;
	}

	wq_page_size = ALIGN(hwdev->wq_page_size, HINIC3_MIN_PAGE_SIZE);

	memset(wq, 0, sizeof(*wq));
	wq->q_depth = q_depth;
	wq->idx_mask = q_depth - 1;

	hinic3_queue_pages_init(&wq->qpages, q_depth, wq_page_size, wqebb_size);

	return wq_alloc_pages(hwdev, wq);
}

void hinic3_wq_destroy(struct hinic3_hwdev *hwdev, struct hinic3_wq *wq)
{
	wq_free_pages(hwdev, wq);
}

void hinic3_wq_reset(struct hinic3_wq *wq)
{
	struct hinic3_queue_pages *qpages = &wq->qpages;
	u16 pg_idx;

	wq->cons_idx = 0;
	wq->prod_idx = 0;

	for (pg_idx = 0; pg_idx < qpages->num_pages; pg_idx++)
		memset(qpages->pages[pg_idx].align_vaddr, 0, qpages->page_size);
}

void hinic3_wq_get_multi_wqebbs(struct hinic3_wq *wq,
				u16 num_wqebbs, u16 *prod_idx,
				struct hinic3_sq_bufdesc **first_part_wqebbs,
				struct hinic3_sq_bufdesc **second_part_wqebbs,
				u16 *first_part_wqebbs_num)
{
	u32 idx, remaining;

	idx = wq->prod_idx & wq->idx_mask;
	wq->prod_idx += num_wqebbs;
	*prod_idx = idx;
	*first_part_wqebbs = get_q_element(&wq->qpages, idx, &remaining);
	if (likely(remaining >= num_wqebbs)) {
		*first_part_wqebbs_num = num_wqebbs;
		*second_part_wqebbs = NULL;
	} else {
		*first_part_wqebbs_num = remaining;
		idx += remaining;
		*second_part_wqebbs = get_q_element(&wq->qpages, idx, NULL);
	}
}

bool hinic3_wq_is_0_level_cla(const struct hinic3_wq *wq)
{
	return wq->qpages.num_pages == 1;
}