drivers/mempool/cnxk/cn10k_mempool_ops.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4
   5 #include <rte_mempool.h>
   6
   7 #include "roc_api.h"
   8 #include "cnxk_mempool.h"
   9
  10 #define BATCH_ALLOC_SZ              ROC_CN10K_NPA_BATCH_ALLOC_MAX_PTRS
  11 #define BATCH_OP_DATA_TABLE_MZ_NAME "batch_op_data_table_mz"
  12
  13 enum batch_op_status {
  14         BATCH_ALLOC_OP_NOT_ISSUED = 0,
  15         BATCH_ALLOC_OP_ISSUED = 1,
  16         BATCH_ALLOC_OP_DONE
  17 };
  18
  19 struct batch_op_mem {
  20         unsigned int sz;
  21         enum batch_op_status status;
  22         uint64_t objs[BATCH_ALLOC_SZ] __rte_aligned(ROC_ALIGN);
  23 };
  24
  25 struct batch_op_data {
  26         uint64_t lmt_addr;
  27         struct batch_op_mem mem[RTE_MAX_LCORE] __rte_aligned(ROC_ALIGN);
  28 };
  29
  30 static struct batch_op_data **batch_op_data_tbl;
  31
  32 static int
  33 batch_op_data_table_create(void)
  34 {
  35         const struct rte_memzone *mz;
  36
  37         /* If table is already set, nothing to do */
  38         if (batch_op_data_tbl)
  39                 return 0;
  40
  41         mz = rte_memzone_lookup(BATCH_OP_DATA_TABLE_MZ_NAME);
  42         if (mz == NULL) {
  43                 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
  44                         unsigned int maxpools, sz;
  45
  46                         maxpools = roc_idev_npa_maxpools_get();
  47                         sz = maxpools * sizeof(struct batch_op_data *);
  48
  49                         mz = rte_memzone_reserve_aligned(
  50                                 BATCH_OP_DATA_TABLE_MZ_NAME, sz, SOCKET_ID_ANY,
  51                                 0, ROC_ALIGN);
  52                 }
  53                 if (mz == NULL) {
  54                         plt_err("Failed to reserve batch op data table");
  55                         return -ENOMEM;
  56                 }
  57         }
  58         batch_op_data_tbl = mz->addr;
  59         rte_wmb();
  60         return 0;
  61 }
  62
  63 static inline struct batch_op_data *
  64 batch_op_data_get(uint64_t pool_id)
  65 {
  66         uint64_t aura = roc_npa_aura_handle_to_aura(pool_id);
  67
  68         return batch_op_data_tbl[aura];
  69 }
  70
  71 static inline void
  72 batch_op_data_set(uint64_t pool_id, struct batch_op_data *op_data)
  73 {
  74         uint64_t aura = roc_npa_aura_handle_to_aura(pool_id);
  75
  76         batch_op_data_tbl[aura] = op_data;
  77 }
  78
  79 static int
  80 batch_op_init(struct rte_mempool *mp)
  81 {
  82         struct batch_op_data *op_data;
  83         int i;
  84
  85         op_data = batch_op_data_get(mp->pool_id);
  86         /* The data should not have been allocated previously */
  87         RTE_ASSERT(op_data == NULL);
  88
  89         op_data = rte_zmalloc(NULL, sizeof(struct batch_op_data), ROC_ALIGN);
  90         if (op_data == NULL)
  91                 return -ENOMEM;
  92
  93         for (i = 0; i < RTE_MAX_LCORE; i++) {
  94                 op_data->mem[i].sz = 0;
  95                 op_data->mem[i].status = BATCH_ALLOC_OP_NOT_ISSUED;
  96         }
  97
  98         op_data->lmt_addr = roc_idev_lmt_base_addr_get();
  99         batch_op_data_set(mp->pool_id, op_data);
 100         rte_wmb();
 101
 102         return 0;
 103 }
 104
 105 static void
 106 batch_op_fini(struct rte_mempool *mp)
 107 {
 108         struct batch_op_data *op_data;
 109         int i;
 110
 111         op_data = batch_op_data_get(mp->pool_id);
 112
 113         rte_wmb();
 114         for (i = 0; i < RTE_MAX_LCORE; i++) {
 115                 struct batch_op_mem *mem = &op_data->mem[i];
 116
 117                 if (mem->status == BATCH_ALLOC_OP_ISSUED) {
 118                         mem->sz = roc_npa_aura_batch_alloc_extract(
 119                                 mem->objs, mem->objs, BATCH_ALLOC_SZ);
 120                         mem->status = BATCH_ALLOC_OP_DONE;
 121                 }
 122                 if (mem->status == BATCH_ALLOC_OP_DONE) {
 123                         roc_npa_aura_op_bulk_free(mp->pool_id, mem->objs,
 124                                                   mem->sz, 1);
 125                         mem->status = BATCH_ALLOC_OP_NOT_ISSUED;
 126                 }
 127         }
 128
 129         rte_free(op_data);
 130         batch_op_data_set(mp->pool_id, NULL);
 131         rte_wmb();
 132 }
 133
 134 static int __rte_hot
 135 cn10k_mempool_enq(struct rte_mempool *mp, void *const *obj_table,
 136                   unsigned int n)
 137 {
 138         const uint64_t *ptr = (const uint64_t *)obj_table;
 139         uint64_t lmt_addr = 0, lmt_id = 0;
 140         struct batch_op_data *op_data;
 141
 142         /* Ensure mbuf init changes are written before the free pointers are
 143          * enqueued to the stack.
 144          */
 145         rte_io_wmb();
 146
 147         if (n == 1) {
 148                 roc_npa_aura_op_free(mp->pool_id, 1, ptr[0]);
 149                 return 0;
 150         }
 151
 152         op_data = batch_op_data_get(mp->pool_id);
 153         lmt_addr = op_data->lmt_addr;
 154         ROC_LMT_BASE_ID_GET(lmt_addr, lmt_id);
 155         roc_npa_aura_op_batch_free(mp->pool_id, ptr, n, 1, lmt_addr, lmt_id);
 156
 157         return 0;
 158 }
 159
 160 static unsigned int
 161 cn10k_mempool_get_count(const struct rte_mempool *mp)
 162 {
 163         struct batch_op_data *op_data;
 164         unsigned int count = 0;
 165         int i;
 166
 167         op_data = batch_op_data_get(mp->pool_id);
 168
 169         rte_wmb();
 170         for (i = 0; i < RTE_MAX_LCORE; i++) {
 171                 struct batch_op_mem *mem = &op_data->mem[i];
 172
 173                 if (mem->status == BATCH_ALLOC_OP_ISSUED)
 174                         count += roc_npa_aura_batch_alloc_count(mem->objs,
 175                                                                 BATCH_ALLOC_SZ);
 176
 177                 if (mem->status == BATCH_ALLOC_OP_DONE)
 178                         count += mem->sz;
 179         }
 180
 181         count += cnxk_mempool_get_count(mp);
 182
 183         return count;
 184 }
 185
 186 static int
 187 cn10k_mempool_alloc(struct rte_mempool *mp)
 188 {
 189         uint32_t block_size;
 190         size_t padding;
 191         int rc;
 192
 193         block_size = mp->elt_size + mp->header_size + mp->trailer_size;
 194         /* Align header size to ROC_ALIGN */
 195         if (mp->header_size % ROC_ALIGN != 0) {
 196                 padding = RTE_ALIGN_CEIL(mp->header_size, ROC_ALIGN) -
 197                           mp->header_size;
 198                 mp->header_size += padding;
 199                 block_size += padding;
 200         }
 201
 202         /* Align block size to ROC_ALIGN */
 203         if (block_size % ROC_ALIGN != 0) {
 204                 padding = RTE_ALIGN_CEIL(block_size, ROC_ALIGN) - block_size;
 205                 mp->trailer_size += padding;
 206                 block_size += padding;
 207         }
 208
 209         rc = cnxk_mempool_alloc(mp);
 210         if (rc)
 211                 return rc;
 212
 213         rc = batch_op_init(mp);
 214         if (rc) {
 215                 plt_err("Failed to init batch alloc mem rc=%d", rc);
 216                 goto error;
 217         }
 218
 219         return 0;
 220 error:
 221         cnxk_mempool_free(mp);
 222         return rc;
 223 }
 224
 225 static void
 226 cn10k_mempool_free(struct rte_mempool *mp)
 227 {
 228         batch_op_fini(mp);
 229         cnxk_mempool_free(mp);
 230 }
 231
 232 int
 233 cn10k_mempool_plt_init(void)
 234 {
 235         return batch_op_data_table_create();
 236 }
 237
 238 static struct rte_mempool_ops cn10k_mempool_ops = {
 239         .name = "cn10k_mempool_ops",
 240         .alloc = cn10k_mempool_alloc,
 241         .free = cn10k_mempool_free,
 242         .enqueue = cn10k_mempool_enq,
 243         .dequeue = cnxk_mempool_deq,
 244         .get_count = cn10k_mempool_get_count,
 245         .calc_mem_size = cnxk_mempool_calc_mem_size,
 246         .populate = cnxk_mempool_populate,
 247 };
 248
 249 MEMPOOL_REGISTER_OPS(cn10k_mempool_ops);