drivers/mempool/octeontx2/otx2_mempool.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include <rte_atomic.h>
   6 #include <rte_bus_pci.h>
   7 #include <rte_common.h>
   8 #include <rte_eal.h>
   9 #include <rte_io.h>
  10 #include <rte_malloc.h>
  11 #include <rte_mbuf_pool_ops.h>
  12 #include <rte_pci.h>
  13
  14 #include "otx2_common.h"
  15 #include "otx2_dev.h"
  16 #include "otx2_mempool.h"
  17
  18 #define OTX2_NPA_DEV_NAME       RTE_STR(otx2_npa_dev_)
  19 #define OTX2_NPA_DEV_NAME_LEN   (sizeof(OTX2_NPA_DEV_NAME) + PCI_PRI_STR_SIZE)
  20
  21 static inline int
  22 npa_lf_alloc(struct otx2_npa_lf *lf)
  23 {
  24         struct otx2_mbox *mbox = lf->mbox;
  25         struct npa_lf_alloc_req *req;
  26         struct npa_lf_alloc_rsp *rsp;
  27         int rc;
  28
  29         req = otx2_mbox_alloc_msg_npa_lf_alloc(mbox);
  30         req->aura_sz = lf->aura_sz;
  31         req->nr_pools = lf->nr_pools;
  32
  33         rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
  34         if (rc)
  35                 return NPA_LF_ERR_ALLOC;
  36
  37         lf->stack_pg_ptrs = rsp->stack_pg_ptrs;
  38         lf->stack_pg_bytes = rsp->stack_pg_bytes;
  39         lf->qints = rsp->qints;
  40
  41         return 0;
  42 }
  43
  44 static int
  45 npa_lf_free(struct otx2_mbox *mbox)
  46 {
  47         otx2_mbox_alloc_msg_npa_lf_free(mbox);
  48
  49         return otx2_mbox_process(mbox);
  50 }
  51
  52 static int
  53 npa_lf_init(struct otx2_npa_lf *lf, uintptr_t base, uint8_t aura_sz,
  54             uint32_t nr_pools, struct otx2_mbox *mbox)
  55 {
  56         uint32_t i, bmp_sz;
  57         int rc;
  58
  59         /* Sanity checks */
  60         if (!lf || !base || !mbox || !nr_pools)
  61                 return NPA_LF_ERR_PARAM;
  62
  63         if (base & AURA_ID_MASK)
  64                 return NPA_LF_ERR_BASE_INVALID;
  65
  66         if (aura_sz == NPA_AURA_SZ_0 || aura_sz >= NPA_AURA_SZ_MAX)
  67                 return NPA_LF_ERR_PARAM;
  68
  69         memset(lf, 0x0, sizeof(*lf));
  70         lf->base = base;
  71         lf->aura_sz = aura_sz;
  72         lf->nr_pools = nr_pools;
  73         lf->mbox = mbox;
  74
  75         rc = npa_lf_alloc(lf);
  76         if (rc)
  77                 goto exit;
  78
  79         bmp_sz = rte_bitmap_get_memory_footprint(nr_pools);
  80
  81         /* Allocate memory for bitmap */
  82         lf->npa_bmp_mem = rte_zmalloc("npa_bmp_mem", bmp_sz,
  83                                         RTE_CACHE_LINE_SIZE);
  84         if (lf->npa_bmp_mem == NULL) {
  85                 rc = -ENOMEM;
  86                 goto lf_free;
  87         }
  88
  89         /* Initialize pool resource bitmap array */
  90         lf->npa_bmp = rte_bitmap_init(nr_pools, lf->npa_bmp_mem, bmp_sz);
  91         if (lf->npa_bmp == NULL) {
  92                 rc = -EINVAL;
  93                 goto bmap_mem_free;
  94         }
  95
  96         /* Mark all pools available */
  97         for (i = 0; i < nr_pools; i++)
  98                 rte_bitmap_set(lf->npa_bmp, i);
  99
 100         /* Allocate memory for qint context */
 101         lf->npa_qint_mem = rte_zmalloc("npa_qint_mem",
 102                         sizeof(struct otx2_npa_qint) * nr_pools, 0);
 103         if (lf->npa_qint_mem == NULL) {
 104                 rc = -ENOMEM;
 105                 goto bmap_free;
 106         }
 107
 108         return 0;
 109
 110 bmap_free:
 111         rte_bitmap_free(lf->npa_bmp);
 112 bmap_mem_free:
 113         rte_free(lf->npa_bmp_mem);
 114 lf_free:
 115         npa_lf_free(lf->mbox);
 116 exit:
 117         return rc;
 118 }
 119
 120 static int
 121 npa_lf_fini(struct otx2_npa_lf *lf)
 122 {
 123         if (!lf)
 124                 return NPA_LF_ERR_PARAM;
 125
 126         rte_free(lf->npa_qint_mem);
 127         rte_bitmap_free(lf->npa_bmp);
 128         rte_free(lf->npa_bmp_mem);
 129
 130         return npa_lf_free(lf->mbox);
 131
 132 }
 133
 134 static inline uint32_t
 135 otx2_aura_size_to_u32(uint8_t val)
 136 {
 137         if (val == NPA_AURA_SZ_0)
 138                 return 128;
 139         if (val >= NPA_AURA_SZ_MAX)
 140                 return BIT_ULL(20);
 141
 142         return 1 << (val + 6);
 143 }
 144
 145 static inline int
 146 npa_lf_attach(struct otx2_mbox *mbox)
 147 {
 148         struct rsrc_attach_req *req;
 149
 150         req = otx2_mbox_alloc_msg_attach_resources(mbox);
 151         req->npalf = true;
 152
 153         return otx2_mbox_process(mbox);
 154 }
 155
 156 static inline int
 157 npa_lf_detach(struct otx2_mbox *mbox)
 158 {
 159         struct rsrc_detach_req *req;
 160
 161         req = otx2_mbox_alloc_msg_detach_resources(mbox);
 162         req->npalf = true;
 163
 164         return otx2_mbox_process(mbox);
 165 }
 166
 167 static inline int
 168 npa_lf_get_msix_offset(struct otx2_mbox *mbox, uint16_t *npa_msixoff)
 169 {
 170         struct msix_offset_rsp *msix_rsp;
 171         int rc;
 172
 173         /* Get NPA and NIX MSIX vector offsets */
 174         otx2_mbox_alloc_msg_msix_offset(mbox);
 175
 176         rc = otx2_mbox_process_msg(mbox, (void *)&msix_rsp);
 177
 178         *npa_msixoff = msix_rsp->npa_msixoff;
 179
 180         return rc;
 181 }
 182
 183 /**
 184  * @internal
 185  * Finalize NPA LF.
 186  */
 187 int
 188 otx2_npa_lf_fini(void)
 189 {
 190         struct otx2_idev_cfg *idev;
 191         int rc = 0;
 192
 193         idev = otx2_intra_dev_get_cfg();
 194         if (idev == NULL)
 195                 return -ENOMEM;
 196
 197         if (rte_atomic16_add_return(&idev->npa_refcnt, -1) == 0) {
 198                 otx2_npa_unregister_irqs(idev->npa_lf);
 199                 rc |= npa_lf_fini(idev->npa_lf);
 200                 rc |= npa_lf_detach(idev->npa_lf->mbox);
 201                 otx2_npa_set_defaults(idev);
 202         }
 203
 204         return rc;
 205 }
 206
 207 /**
 208  * @internal
 209  * Initialize NPA LF.
 210  */
 211 int
 212 otx2_npa_lf_init(struct rte_pci_device *pci_dev, void *otx2_dev)
 213 {
 214         struct otx2_dev *dev = otx2_dev;
 215         struct otx2_idev_cfg *idev;
 216         struct otx2_npa_lf *lf;
 217         uint16_t npa_msixoff;
 218         uint32_t nr_pools;
 219         uint8_t aura_sz;
 220         int rc;
 221
 222         idev = otx2_intra_dev_get_cfg();
 223         if (idev == NULL)
 224                 return -ENOMEM;
 225
 226         /* Is NPA LF initialized by any another driver? */
 227         if (rte_atomic16_add_return(&idev->npa_refcnt, 1) == 1) {
 228
 229                 rc = npa_lf_attach(dev->mbox);
 230                 if (rc)
 231                         goto fail;
 232
 233                 rc = npa_lf_get_msix_offset(dev->mbox, &npa_msixoff);
 234                 if (rc)
 235                         goto npa_detach;
 236
 237                 aura_sz = NPA_AURA_SZ_128;
 238                 nr_pools = otx2_aura_size_to_u32(aura_sz);
 239
 240                 lf = &dev->npalf;
 241                 rc = npa_lf_init(lf, dev->bar2 + (RVU_BLOCK_ADDR_NPA << 20),
 242                                         aura_sz, nr_pools, dev->mbox);
 243
 244                 if (rc)
 245                         goto npa_detach;
 246
 247                 lf->pf_func = dev->pf_func;
 248                 lf->npa_msixoff = npa_msixoff;
 249                 lf->intr_handle = &pci_dev->intr_handle;
 250                 lf->pci_dev = pci_dev;
 251
 252                 idev->npa_pf_func = dev->pf_func;
 253                 idev->npa_lf = lf;
 254                 rte_smp_wmb();
 255                 rc = otx2_npa_register_irqs(lf);
 256                 if (rc)
 257                         goto npa_fini;
 258
 259                 rte_mbuf_set_platform_mempool_ops("octeontx2_npa");
 260                 otx2_npa_dbg("npa_lf=%p pools=%d sz=%d pf_func=0x%x msix=0x%x",
 261                              lf, nr_pools, aura_sz, lf->pf_func, npa_msixoff);
 262         }
 263
 264         return 0;
 265
 266 npa_fini:
 267         npa_lf_fini(idev->npa_lf);
 268 npa_detach:
 269         npa_lf_detach(dev->mbox);
 270 fail:
 271         rte_atomic16_dec(&idev->npa_refcnt);
 272         return rc;
 273 }
 274
 275 static inline char*
 276 otx2_npa_dev_to_name(struct rte_pci_device *pci_dev, char *name)
 277 {
 278         snprintf(name, OTX2_NPA_DEV_NAME_LEN,
 279                  OTX2_NPA_DEV_NAME  PCI_PRI_FMT,
 280                  pci_dev->addr.domain, pci_dev->addr.bus,
 281                  pci_dev->addr.devid, pci_dev->addr.function);
 282
 283         return name;
 284 }
 285
 286 static int
 287 otx2_npa_init(struct rte_pci_device *pci_dev)
 288 {
 289         char name[OTX2_NPA_DEV_NAME_LEN];
 290         const struct rte_memzone *mz;
 291         struct otx2_dev *dev;
 292         int rc = -ENOMEM;
 293
 294         mz = rte_memzone_reserve_aligned(otx2_npa_dev_to_name(pci_dev, name),
 295                                          sizeof(*dev), SOCKET_ID_ANY,
 296                                          0, OTX2_ALIGN);
 297         if (mz == NULL)
 298                 goto error;
 299
 300         dev = mz->addr;
 301
 302         /* Initialize the base otx2_dev object */
 303         rc = otx2_dev_init(pci_dev, dev);
 304         if (rc)
 305                 goto malloc_fail;
 306
 307         /* Grab the NPA LF if required */
 308         rc = otx2_npa_lf_init(pci_dev, dev);
 309         if (rc)
 310                 goto dev_uninit;
 311
 312         dev->drv_inited = true;
 313         return 0;
 314
 315 dev_uninit:
 316         otx2_npa_lf_fini();
 317         otx2_dev_fini(pci_dev, dev);
 318 malloc_fail:
 319         rte_memzone_free(mz);
 320 error:
 321         otx2_err("Failed to initialize npa device rc=%d", rc);
 322         return rc;
 323 }
 324
 325 static int
 326 otx2_npa_fini(struct rte_pci_device *pci_dev)
 327 {
 328         char name[OTX2_NPA_DEV_NAME_LEN];
 329         const struct rte_memzone *mz;
 330         struct otx2_dev *dev;
 331
 332         mz = rte_memzone_lookup(otx2_npa_dev_to_name(pci_dev, name));
 333         if (mz == NULL)
 334                 return -EINVAL;
 335
 336         dev = mz->addr;
 337         if (!dev->drv_inited)
 338                 goto dev_fini;
 339
 340         dev->drv_inited = false;
 341         otx2_npa_lf_fini();
 342
 343 dev_fini:
 344         if (otx2_npa_lf_active(dev)) {
 345                 otx2_info("%s: common resource in use by other devices",
 346                           pci_dev->name);
 347                 return -EAGAIN;
 348         }
 349
 350         otx2_dev_fini(pci_dev, dev);
 351         rte_memzone_free(mz);
 352
 353         return 0;
 354 }
 355
 356 static int
 357 npa_remove(struct rte_pci_device *pci_dev)
 358 {
 359         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 360                 return 0;
 361
 362         return otx2_npa_fini(pci_dev);
 363 }
 364
 365 static int
 366 npa_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
 367 {
 368         RTE_SET_USED(pci_drv);
 369
 370         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 371                 return 0;
 372
 373         return otx2_npa_init(pci_dev);
 374 }
 375
 376 static const struct rte_pci_id pci_npa_map[] = {
 377         {
 378                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM,
 379                                         PCI_DEVID_OCTEONTX2_RVU_NPA_PF)
 380         },
 381         {
 382                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM,
 383                                         PCI_DEVID_OCTEONTX2_RVU_NPA_VF)
 384         },
 385         {
 386                 .vendor_id = 0,
 387         },
 388 };
 389
 390 static struct rte_pci_driver pci_npa = {
 391         .id_table = pci_npa_map,
 392         .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_IOVA_AS_VA,
 393         .probe = npa_probe,
 394         .remove = npa_remove,
 395 };
 396
 397 RTE_PMD_REGISTER_PCI(mempool_octeontx2, pci_npa);
 398 RTE_PMD_REGISTER_PCI_TABLE(mempool_octeontx2, pci_npa_map);
 399 RTE_PMD_REGISTER_KMOD_DEP(mempool_octeontx2, "vfio-pci");