Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2025 Huawei Technologies Co., Ltd
       3                 :            :  */
       4                 :            : 
       5                 :            : #include "hinic3_compat.h"
       6                 :            : #include "hinic3_hwdev.h"
       7                 :            : #include "hinic3_wq.h"
       8                 :            : 
       9                 :            : static void
      10                 :            : free_wq_pages(struct hinic3_wq *wq)
      11                 :            : {
      12                 :          0 :         hinic3_memzone_free(wq->wq_mz);
      13                 :            : 
      14                 :          0 :         wq->queue_buf_paddr = 0;
      15                 :          0 :         wq->queue_buf_vaddr = 0;
      16                 :            : }
      17                 :            : 
      18                 :            : static int
      19                 :          0 : alloc_wq_pages(struct hinic3_hwdev *hwdev, struct hinic3_wq *wq, int qid)
      20                 :            : {
      21                 :            :         const struct rte_memzone *wq_mz;
      22                 :            : 
      23                 :          0 :         wq_mz = hinic3_dma_zone_reserve(hwdev->eth_dev, "hinic3_wq_mz",
      24                 :          0 :                                         qid, wq->wq_buf_size, RTE_PGSIZE_256K, SOCKET_ID_ANY);
      25         [ #  # ]:          0 :         if (!wq_mz) {
      26                 :          0 :                 PMD_DRV_LOG(ERR, "Allocate wq[%d] rq_mz failed", qid);
      27                 :          0 :                 return -ENOMEM;
      28                 :            :         }
      29                 :            : 
      30                 :          0 :         memset(wq_mz->addr, 0, wq->wq_buf_size);
      31                 :          0 :         wq->wq_mz = wq_mz;
      32                 :          0 :         wq->queue_buf_paddr = wq_mz->iova;
      33                 :          0 :         wq->queue_buf_vaddr = (uint64_t)wq_mz->addr;
      34                 :            : 
      35                 :          0 :         return 0;
      36                 :            : }
      37                 :            : 
      38                 :            : void
      39                 :          0 : hinic3_put_wqe(struct hinic3_wq *wq, int num_wqebbs)
      40                 :            : {
      41                 :          0 :         wq->cons_idx += num_wqebbs;
      42                 :          0 :         rte_atomic_fetch_add_explicit(&wq->delta, num_wqebbs,
      43                 :            :                                       rte_memory_order_seq_cst);
      44                 :          0 : }
      45                 :            : 
      46                 :            : void *
      47                 :          0 : hinic3_read_wqe(struct hinic3_wq *wq, int num_wqebbs, uint16_t *cons_idx)
      48                 :            : {
      49                 :            :         uint16_t curr_cons_idx;
      50                 :            : 
      51                 :          0 :         if ((rte_atomic_load_explicit(&wq->delta, rte_memory_order_seq_cst) +
      52         [ #  # ]:          0 :              num_wqebbs) > wq->q_depth)
      53                 :            :                 return NULL;
      54                 :            : 
      55                 :          0 :         curr_cons_idx = (uint16_t)(wq->cons_idx);
      56                 :            : 
      57                 :          0 :         curr_cons_idx = MASKED_WQE_IDX(wq, curr_cons_idx);
      58                 :            : 
      59                 :          0 :         *cons_idx = curr_cons_idx;
      60                 :            : 
      61                 :          0 :         return WQ_WQE_ADDR(wq, (uint32_t)(*cons_idx));
      62                 :            : }
      63                 :            : 
      64                 :            : int
      65                 :          0 : hinic3_cmdq_alloc(struct hinic3_wq *wq, void *dev, int cmdq_blocks,
      66                 :            :                   uint32_t wq_buf_size, uint32_t wqebb_shift, uint16_t q_depth)
      67                 :            : {
      68                 :            :         struct hinic3_hwdev *hwdev = (struct hinic3_hwdev *)dev;
      69                 :            :         int i, j;
      70                 :            :         int err;
      71                 :            : 
      72         [ #  # ]:          0 :         for (i = 0; i < cmdq_blocks; i++) {
      73                 :          0 :                 wq[i].wqebb_size = 1U << wqebb_shift;
      74                 :          0 :                 wq[i].wqebb_shift = wqebb_shift;
      75                 :          0 :                 wq[i].wq_buf_size = wq_buf_size;
      76                 :          0 :                 wq[i].q_depth = q_depth;
      77                 :            : 
      78                 :          0 :                 err = alloc_wq_pages(hwdev, &wq[i], i);
      79         [ #  # ]:          0 :                 if (err) {
      80                 :          0 :                         PMD_DRV_LOG(ERR, "Failed to alloc CMDQ blocks");
      81                 :          0 :                         goto cmdq_block_err;
      82                 :            :                 }
      83                 :            : 
      84                 :          0 :                 wq[i].cons_idx = 0;
      85                 :          0 :                 wq[i].prod_idx = 0;
      86                 :          0 :                 rte_atomic_store_explicit(&wq[i].delta, q_depth,
      87                 :            :                                           rte_memory_order_seq_cst);
      88                 :            : 
      89                 :          0 :                 wq[i].mask = q_depth - 1;
      90                 :            :         }
      91                 :            : 
      92                 :            :         return 0;
      93                 :            : 
      94                 :            : cmdq_block_err:
      95         [ #  # ]:          0 :         for (j = 0; j < i; j++)
      96                 :          0 :                 free_wq_pages(&wq[j]);
      97                 :            : 
      98                 :            :         return err;
      99                 :            : }
     100                 :            : 
     101                 :            : void
     102                 :          0 : hinic3_cmdq_free(struct hinic3_wq *wq, int cmdq_blocks)
     103                 :            : {
     104                 :            :         int i;
     105                 :            : 
     106         [ #  # ]:          0 :         for (i = 0; i < cmdq_blocks; i++)
     107                 :          0 :                 free_wq_pages(&wq[i]);
     108                 :          0 : }
     109                 :            : 
     110                 :            : void
     111                 :          0 : hinic3_wq_wqe_pg_clear(struct hinic3_wq *wq)
     112                 :            : {
     113                 :          0 :         wq->cons_idx = 0;
     114                 :          0 :         wq->prod_idx = 0;
     115                 :            : 
     116                 :          0 :         memset((void *)wq->queue_buf_vaddr, 0, wq->wq_buf_size);
     117                 :          0 : }
     118                 :            : 
     119                 :            : void *
     120                 :          0 : hinic3_get_wqe(struct hinic3_wq *wq, int num_wqebbs, uint16_t *prod_idx)
     121                 :            : {
     122                 :            :         uint16_t curr_prod_idx;
     123                 :            : 
     124                 :          0 :         rte_atomic_fetch_sub_explicit(&wq->delta, num_wqebbs,
     125                 :            :                                       rte_memory_order_seq_cst);
     126                 :          0 :         curr_prod_idx = (uint16_t)(wq->prod_idx);
     127                 :          0 :         wq->prod_idx += num_wqebbs;
     128                 :          0 :         *prod_idx = MASKED_WQE_IDX(wq, curr_prod_idx);
     129                 :            : 
     130                 :          0 :         return WQ_WQE_ADDR(wq, (uint32_t)(*prod_idx));
     131                 :            : }
     132                 :            : 
     133                 :            : void
     134                 :          0 : hinic3_set_sge(struct hinic3_sge *sge, uint64_t addr, uint32_t len)
     135                 :            : {
     136                 :          0 :         sge->hi_addr = upper_32_bits(addr);
     137                 :          0 :         sge->lo_addr = lower_32_bits(addr);
     138                 :          0 :         sge->len = len;
     139                 :          0 : }