139 lines
3.4 KiB
C
139 lines
3.4 KiB
C
// 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;
|
|
}
|