drivers/common/cnxk/roc_nix_inl.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4
   5 #include "roc_api.h"
   6 #include "roc_priv.h"
   7
   8 PLT_STATIC_ASSERT(ROC_NIX_INL_ONF_IPSEC_INB_SA_SZ ==
   9                   1UL << ROC_NIX_INL_ONF_IPSEC_INB_SA_SZ_LOG2);
  10 PLT_STATIC_ASSERT(ROC_NIX_INL_ONF_IPSEC_INB_SA_SZ == 512);
  11 PLT_STATIC_ASSERT(ROC_NIX_INL_ONF_IPSEC_OUTB_SA_SZ ==
  12                   1UL << ROC_NIX_INL_ONF_IPSEC_OUTB_SA_SZ_LOG2);
  13 PLT_STATIC_ASSERT(ROC_NIX_INL_OT_IPSEC_INB_SA_SZ ==
  14                   1UL << ROC_NIX_INL_OT_IPSEC_INB_SA_SZ_LOG2);
  15 PLT_STATIC_ASSERT(ROC_NIX_INL_OT_IPSEC_INB_SA_SZ == 1024);
  16 PLT_STATIC_ASSERT(ROC_NIX_INL_OT_IPSEC_OUTB_SA_SZ ==
  17                   1UL << ROC_NIX_INL_OT_IPSEC_OUTB_SA_SZ_LOG2);
  18
  19 static int
  20 nix_inl_inb_sa_tbl_setup(struct roc_nix *roc_nix)
  21 {
  22         uint16_t ipsec_in_max_spi = roc_nix->ipsec_in_max_spi;
  23         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
  24         struct roc_nix_ipsec_cfg cfg;
  25         size_t inb_sa_sz;
  26         int rc, i;
  27         void *sa;
  28
  29         /* CN9K SA size is different */
  30         if (roc_model_is_cn9k())
  31                 inb_sa_sz = ROC_NIX_INL_ONF_IPSEC_INB_SA_SZ;
  32         else
  33                 inb_sa_sz = ROC_NIX_INL_OT_IPSEC_INB_SA_SZ;
  34
  35         /* Alloc contiguous memory for Inbound SA's */
  36         nix->inb_sa_sz = inb_sa_sz;
  37         nix->inb_sa_base = plt_zmalloc(inb_sa_sz * ipsec_in_max_spi,
  38                                        ROC_NIX_INL_SA_BASE_ALIGN);
  39         if (!nix->inb_sa_base) {
  40                 plt_err("Failed to allocate memory for Inbound SA");
  41                 return -ENOMEM;
  42         }
  43         if (roc_model_is_cn10k()) {
  44                 for (i = 0; i < ipsec_in_max_spi; i++) {
  45                         sa = ((uint8_t *)nix->inb_sa_base) + (i * inb_sa_sz);
  46                         roc_ot_ipsec_inb_sa_init(sa, true);
  47                 }
  48         }
  49
  50         memset(&cfg, 0, sizeof(cfg));
  51         cfg.sa_size = inb_sa_sz;
  52         cfg.iova = (uintptr_t)nix->inb_sa_base;
  53         cfg.max_sa = ipsec_in_max_spi + 1;
  54         cfg.tt = SSO_TT_ORDERED;
  55
  56         /* Setup device specific inb SA table */
  57         rc = roc_nix_lf_inl_ipsec_cfg(roc_nix, &cfg, true);
  58         if (rc) {
  59                 plt_err("Failed to setup NIX Inbound SA conf, rc=%d", rc);
  60                 goto free_mem;
  61         }
  62
  63         return 0;
  64 free_mem:
  65         plt_free(nix->inb_sa_base);
  66         nix->inb_sa_base = NULL;
  67         return rc;
  68 }
  69
  70 static int
  71 nix_inl_sa_tbl_release(struct roc_nix *roc_nix)
  72 {
  73         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
  74         int rc;
  75
  76         rc = roc_nix_lf_inl_ipsec_cfg(roc_nix, NULL, false);
  77         if (rc) {
  78                 plt_err("Failed to disable Inbound inline ipsec, rc=%d", rc);
  79                 return rc;
  80         }
  81
  82         plt_free(nix->inb_sa_base);
  83         nix->inb_sa_base = NULL;
  84         return 0;
  85 }
  86
  87 struct roc_cpt_lf *
  88 roc_nix_inl_outb_lf_base_get(struct roc_nix *roc_nix)
  89 {
  90         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
  91
  92         /* NIX Inline config needs to be done */
  93         if (!nix->inl_outb_ena || !nix->cpt_lf_base)
  94                 return NULL;
  95
  96         return (struct roc_cpt_lf *)nix->cpt_lf_base;
  97 }
  98
  99 uintptr_t
 100 roc_nix_inl_outb_sa_base_get(struct roc_nix *roc_nix)
 101 {
 102         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 103
 104         return (uintptr_t)nix->outb_sa_base;
 105 }
 106
 107 uintptr_t
 108 roc_nix_inl_inb_sa_base_get(struct roc_nix *roc_nix, bool inb_inl_dev)
 109 {
 110         struct idev_cfg *idev = idev_get_cfg();
 111         struct nix_inl_dev *inl_dev;
 112         struct nix *nix = NULL;
 113
 114         if (idev == NULL)
 115                 return 0;
 116
 117         if (!inb_inl_dev && roc_nix == NULL)
 118                 return -EINVAL;
 119
 120         if (roc_nix) {
 121                 nix = roc_nix_to_nix_priv(roc_nix);
 122                 if (!nix->inl_inb_ena)
 123                         return 0;
 124         }
 125
 126         if (inb_inl_dev) {
 127                 inl_dev = idev->nix_inl_dev;
 128                 /* Return inline dev sa base */
 129                 if (inl_dev)
 130                         return (uintptr_t)inl_dev->inb_sa_base;
 131                 return 0;
 132         }
 133
 134         return (uintptr_t)nix->inb_sa_base;
 135 }
 136
 137 uint32_t
 138 roc_nix_inl_inb_sa_max_spi(struct roc_nix *roc_nix, bool inb_inl_dev)
 139 {
 140         struct idev_cfg *idev = idev_get_cfg();
 141         struct nix_inl_dev *inl_dev;
 142         struct nix *nix;
 143
 144         if (idev == NULL)
 145                 return 0;
 146
 147         if (!inb_inl_dev && roc_nix == NULL)
 148                 return -EINVAL;
 149
 150         if (roc_nix) {
 151                 nix = roc_nix_to_nix_priv(roc_nix);
 152                 if (!nix->inl_inb_ena)
 153                         return 0;
 154         }
 155
 156         if (inb_inl_dev) {
 157                 inl_dev = idev->nix_inl_dev;
 158                 if (inl_dev)
 159                         return inl_dev->ipsec_in_max_spi;
 160                 return 0;
 161         }
 162
 163         return roc_nix->ipsec_in_max_spi;
 164 }
 165
 166 uint32_t
 167 roc_nix_inl_inb_sa_sz(struct roc_nix *roc_nix, bool inl_dev_sa)
 168 {
 169         struct idev_cfg *idev = idev_get_cfg();
 170         struct nix_inl_dev *inl_dev;
 171         struct nix *nix;
 172
 173         if (idev == NULL)
 174                 return 0;
 175
 176         if (!inl_dev_sa && roc_nix == NULL)
 177                 return -EINVAL;
 178
 179         if (roc_nix) {
 180                 nix = roc_nix_to_nix_priv(roc_nix);
 181                 if (!inl_dev_sa)
 182                         return nix->inb_sa_sz;
 183         }
 184
 185         if (inl_dev_sa) {
 186                 inl_dev = idev->nix_inl_dev;
 187                 if (inl_dev)
 188                         return inl_dev->inb_sa_sz;
 189         }
 190
 191         return 0;
 192 }
 193
 194 uintptr_t
 195 roc_nix_inl_inb_sa_get(struct roc_nix *roc_nix, bool inb_inl_dev, uint32_t spi)
 196 {
 197         uintptr_t sa_base;
 198         uint32_t max_spi;
 199         uint64_t sz;
 200
 201         sa_base = roc_nix_inl_inb_sa_base_get(roc_nix, inb_inl_dev);
 202         /* Check if SA base exists */
 203         if (!sa_base)
 204                 return 0;
 205
 206         /* Check if SPI is in range */
 207         max_spi = roc_nix_inl_inb_sa_max_spi(roc_nix, inb_inl_dev);
 208         if (spi > max_spi) {
 209                 plt_err("Inbound SA SPI %u exceeds max %u", spi, max_spi);
 210                 return 0;
 211         }
 212
 213         /* Get SA size */
 214         sz = roc_nix_inl_inb_sa_sz(roc_nix, inb_inl_dev);
 215         if (!sz)
 216                 return 0;
 217
 218         /* Basic logic of SPI->SA for now */
 219         return (sa_base + (spi * sz));
 220 }
 221
 222 int
 223 roc_nix_inl_inb_init(struct roc_nix *roc_nix)
 224 {
 225         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 226         struct idev_cfg *idev = idev_get_cfg();
 227         struct roc_cpt *roc_cpt;
 228         uint16_t param1;
 229         int rc;
 230
 231         if (idev == NULL)
 232                 return -ENOTSUP;
 233
 234         /* Unless we have another mechanism to trigger
 235          * onetime Inline config in CPTPF, we cannot
 236          * support without CPT being probed.
 237          */
 238         roc_cpt = idev->cpt;
 239         if (!roc_cpt) {
 240                 plt_err("Cannot support inline inbound, cryptodev not probed");
 241                 return -ENOTSUP;
 242         }
 243
 244         if (roc_model_is_cn9k()) {
 245                 param1 = ROC_ONF_IPSEC_INB_MAX_L2_SZ;
 246         } else {
 247                 union roc_ot_ipsec_inb_param1 u;
 248
 249                 u.u16 = 0;
 250                 u.s.esp_trailer_disable = 1;
 251                 param1 = u.u16;
 252         }
 253
 254         /* Do onetime Inbound Inline config in CPTPF */
 255         rc = roc_cpt_inline_ipsec_inb_cfg(roc_cpt, param1, 0);
 256         if (rc && rc != -EEXIST) {
 257                 plt_err("Failed to setup inbound lf, rc=%d", rc);
 258                 return rc;
 259         }
 260
 261         /* Setup Inbound SA table */
 262         rc = nix_inl_inb_sa_tbl_setup(roc_nix);
 263         if (rc)
 264                 return rc;
 265
 266         nix->inl_inb_ena = true;
 267         return 0;
 268 }
 269
 270 int
 271 roc_nix_inl_inb_fini(struct roc_nix *roc_nix)
 272 {
 273         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 274
 275         if (!nix->inl_inb_ena)
 276                 return 0;
 277
 278         nix->inl_inb_ena = false;
 279
 280         /* Flush Inbound CTX cache entries */
 281         roc_nix_cpt_ctx_cache_sync(roc_nix);
 282
 283         /* Disable Inbound SA */
 284         return nix_inl_sa_tbl_release(roc_nix);
 285 }
 286
 287 int
 288 roc_nix_inl_outb_init(struct roc_nix *roc_nix)
 289 {
 290         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 291         struct idev_cfg *idev = idev_get_cfg();
 292         struct roc_cpt_lf *lf_base, *lf;
 293         struct dev *dev = &nix->dev;
 294         struct msix_offset_rsp *rsp;
 295         struct nix_inl_dev *inl_dev;
 296         uint16_t sso_pffunc;
 297         uint8_t eng_grpmask;
 298         uint64_t blkaddr;
 299         uint16_t nb_lf;
 300         void *sa_base;
 301         size_t sa_sz;
 302         int i, j, rc;
 303         void *sa;
 304
 305         if (idev == NULL)
 306                 return -ENOTSUP;
 307
 308         nb_lf = roc_nix->outb_nb_crypto_qs;
 309         blkaddr = nix->is_nix1 ? RVU_BLOCK_ADDR_CPT1 : RVU_BLOCK_ADDR_CPT0;
 310
 311         /* Retrieve inline device if present */
 312         inl_dev = idev->nix_inl_dev;
 313         sso_pffunc = inl_dev ? inl_dev->dev.pf_func : idev_sso_pffunc_get();
 314         if (!sso_pffunc) {
 315                 plt_err("Failed to setup inline outb, need either "
 316                         "inline device or sso device");
 317                 return -ENOTSUP;
 318         }
 319
 320         /* Attach CPT LF for outbound */
 321         rc = cpt_lfs_attach(dev, blkaddr, true, nb_lf);
 322         if (rc) {
 323                 plt_err("Failed to attach CPT LF for inline outb, rc=%d", rc);
 324                 return rc;
 325         }
 326
 327         /* Alloc CPT LF */
 328         eng_grpmask = (1ULL << ROC_CPT_DFLT_ENG_GRP_SE |
 329                        1ULL << ROC_CPT_DFLT_ENG_GRP_SE_IE |
 330                        1ULL << ROC_CPT_DFLT_ENG_GRP_AE);
 331         rc = cpt_lfs_alloc(dev, eng_grpmask, blkaddr, true);
 332         if (rc) {
 333                 plt_err("Failed to alloc CPT LF resources, rc=%d", rc);
 334                 goto lf_detach;
 335         }
 336
 337         /* Get msix offsets */
 338         rc = cpt_get_msix_offset(dev, &rsp);
 339         if (rc) {
 340                 plt_err("Failed to get CPT LF msix offset, rc=%d", rc);
 341                 goto lf_free;
 342         }
 343
 344         mbox_memcpy(nix->cpt_msixoff,
 345                     nix->is_nix1 ? rsp->cpt1_lf_msixoff : rsp->cptlf_msixoff,
 346                     sizeof(nix->cpt_msixoff));
 347
 348         /* Alloc required num of cpt lfs */
 349         lf_base = plt_zmalloc(nb_lf * sizeof(struct roc_cpt_lf), 0);
 350         if (!lf_base) {
 351                 plt_err("Failed to alloc cpt lf memory");
 352                 rc = -ENOMEM;
 353                 goto lf_free;
 354         }
 355
 356         /* Initialize CPT LF's */
 357         for (i = 0; i < nb_lf; i++) {
 358                 lf = &lf_base[i];
 359
 360                 lf->lf_id = i;
 361                 lf->nb_desc = roc_nix->outb_nb_desc;
 362                 lf->dev = &nix->dev;
 363                 lf->msixoff = nix->cpt_msixoff[i];
 364                 lf->pci_dev = nix->pci_dev;
 365
 366                 /* Setup CPT LF instruction queue */
 367                 rc = cpt_lf_init(lf);
 368                 if (rc) {
 369                         plt_err("Failed to initialize CPT LF, rc=%d", rc);
 370                         goto lf_fini;
 371                 }
 372
 373                 /* Associate this CPT LF with NIX PFFUNC */
 374                 rc = cpt_lf_outb_cfg(dev, sso_pffunc, nix->dev.pf_func, i,
 375                                      true);
 376                 if (rc) {
 377                         plt_err("Failed to setup CPT LF->(NIX,SSO) link, rc=%d",
 378                                 rc);
 379                         goto lf_fini;
 380                 }
 381
 382                 /* Enable IQ */
 383                 roc_cpt_iq_enable(lf);
 384         }
 385
 386         if (!roc_nix->ipsec_out_max_sa)
 387                 goto skip_sa_alloc;
 388
 389         /* CN9K SA size is different */
 390         if (roc_model_is_cn9k())
 391                 sa_sz = ROC_NIX_INL_ONF_IPSEC_OUTB_SA_SZ;
 392         else
 393                 sa_sz = ROC_NIX_INL_OT_IPSEC_OUTB_SA_SZ;
 394         /* Alloc contiguous memory of outbound SA */
 395         sa_base = plt_zmalloc(sa_sz * roc_nix->ipsec_out_max_sa,
 396                               ROC_NIX_INL_SA_BASE_ALIGN);
 397         if (!sa_base) {
 398                 plt_err("Outbound SA base alloc failed");
 399                 goto lf_fini;
 400         }
 401         if (roc_model_is_cn10k()) {
 402                 for (i = 0; i < roc_nix->ipsec_out_max_sa; i++) {
 403                         sa = ((uint8_t *)sa_base) + (i * sa_sz);
 404                         roc_ot_ipsec_outb_sa_init(sa);
 405                 }
 406         }
 407         nix->outb_sa_base = sa_base;
 408         nix->outb_sa_sz = sa_sz;
 409
 410 skip_sa_alloc:
 411
 412         nix->cpt_lf_base = lf_base;
 413         nix->nb_cpt_lf = nb_lf;
 414         nix->outb_err_sso_pffunc = sso_pffunc;
 415         nix->inl_outb_ena = true;
 416         return 0;
 417
 418 lf_fini:
 419         for (j = i - 1; j >= 0; j--)
 420                 cpt_lf_fini(&lf_base[j]);
 421         plt_free(lf_base);
 422 lf_free:
 423         rc |= cpt_lfs_free(dev);
 424 lf_detach:
 425         rc |= cpt_lfs_detach(dev);
 426         return rc;
 427 }
 428
 429 int
 430 roc_nix_inl_outb_fini(struct roc_nix *roc_nix)
 431 {
 432         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 433         struct roc_cpt_lf *lf_base = nix->cpt_lf_base;
 434         struct dev *dev = &nix->dev;
 435         int i, rc, ret = 0;
 436
 437         if (!nix->inl_outb_ena)
 438                 return 0;
 439
 440         nix->inl_outb_ena = false;
 441
 442         /* Cleanup CPT LF instruction queue */
 443         for (i = 0; i < nix->nb_cpt_lf; i++)
 444                 cpt_lf_fini(&lf_base[i]);
 445
 446         /* Free LF resources */
 447         rc = cpt_lfs_free(dev);
 448         if (rc)
 449                 plt_err("Failed to free CPT LF resources, rc=%d", rc);
 450         ret |= rc;
 451
 452         /* Detach LF */
 453         rc = cpt_lfs_detach(dev);
 454         if (rc)
 455                 plt_err("Failed to detach CPT LF, rc=%d", rc);
 456
 457         /* Free LF memory */
 458         plt_free(lf_base);
 459         nix->cpt_lf_base = NULL;
 460         nix->nb_cpt_lf = 0;
 461
 462         /* Free outbound SA base */
 463         plt_free(nix->outb_sa_base);
 464         nix->outb_sa_base = NULL;
 465
 466         ret |= rc;
 467         return ret;
 468 }
 469
 470 bool
 471 roc_nix_inl_dev_is_probed(void)
 472 {
 473         struct idev_cfg *idev = idev_get_cfg();
 474
 475         if (idev == NULL)
 476                 return 0;
 477
 478         return !!idev->nix_inl_dev;
 479 }
 480
 481 bool
 482 roc_nix_inl_inb_is_enabled(struct roc_nix *roc_nix)
 483 {
 484         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 485
 486         return nix->inl_inb_ena;
 487 }
 488
 489 bool
 490 roc_nix_inl_outb_is_enabled(struct roc_nix *roc_nix)
 491 {
 492         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 493
 494         return nix->inl_outb_ena;
 495 }
 496
 497 int
 498 roc_nix_inl_dev_rq_get(struct roc_nix_rq *rq)
 499 {
 500         struct idev_cfg *idev = idev_get_cfg();
 501         struct nix_inl_dev *inl_dev;
 502         struct roc_nix_rq *inl_rq;
 503         struct dev *dev;
 504         int rc;
 505
 506         if (idev == NULL)
 507                 return 0;
 508
 509         inl_dev = idev->nix_inl_dev;
 510         /* Nothing to do if no inline device */
 511         if (!inl_dev)
 512                 return 0;
 513
 514         /* Just take reference if already inited */
 515         if (inl_dev->rq_refs) {
 516                 inl_dev->rq_refs++;
 517                 rq->inl_dev_ref = true;
 518                 return 0;
 519         }
 520
 521         dev = &inl_dev->dev;
 522         inl_rq = &inl_dev->rq;
 523         memset(inl_rq, 0, sizeof(struct roc_nix_rq));
 524
 525         /* Take RQ pool attributes from the first ethdev RQ */
 526         inl_rq->qid = 0;
 527         inl_rq->aura_handle = rq->aura_handle;
 528         inl_rq->first_skip = rq->first_skip;
 529         inl_rq->later_skip = rq->later_skip;
 530         inl_rq->lpb_size = rq->lpb_size;
 531         inl_rq->lpb_drop_ena = true;
 532         inl_rq->spb_ena = rq->spb_ena;
 533         inl_rq->spb_aura_handle = rq->spb_aura_handle;
 534         inl_rq->spb_size = rq->spb_size;
 535         inl_rq->spb_drop_ena = !!rq->spb_ena;
 536
 537         if (!roc_model_is_cn9k()) {
 538                 uint64_t aura_limit =
 539                         roc_npa_aura_op_limit_get(inl_rq->aura_handle);
 540                 uint64_t aura_shift = plt_log2_u32(aura_limit);
 541                 uint64_t aura_drop, drop_pc;
 542
 543                 if (aura_shift < 8)
 544                         aura_shift = 0;
 545                 else
 546                         aura_shift = aura_shift - 8;
 547
 548                 /* Set first pass RQ to drop after part of buffers are in
 549                  * use to avoid metabuf alloc failure. This is needed as long
 550                  * as we cannot use different aura.
 551                  */
 552                 drop_pc = inl_dev->lpb_drop_pc;
 553                 aura_drop = ((aura_limit * drop_pc) / 100) >> aura_shift;
 554                 roc_npa_aura_drop_set(inl_rq->aura_handle, aura_drop, true);
 555         }
 556
 557         if (inl_rq->spb_ena) {
 558                 uint64_t aura_limit =
 559                         roc_npa_aura_op_limit_get(inl_rq->spb_aura_handle);
 560                 uint64_t aura_shift = plt_log2_u32(aura_limit);
 561                 uint64_t aura_drop, drop_pc;
 562
 563                 if (aura_shift < 8)
 564                         aura_shift = 0;
 565                 else
 566                         aura_shift = aura_shift - 8;
 567
 568                 /* Set first pass RQ to drop after part of buffers are in
 569                  * use to avoid metabuf alloc failure. This is needed as long
 570                  * as we cannot use different aura.
 571                  */
 572                 drop_pc = inl_dev->spb_drop_pc;
 573                 aura_drop = ((aura_limit * drop_pc) / 100) >> aura_shift;
 574                 roc_npa_aura_drop_set(inl_rq->spb_aura_handle, aura_drop, true);
 575         }
 576
 577         /* Enable IPSec */
 578         inl_rq->ipsech_ena = true;
 579
 580         inl_rq->flow_tag_width = 20;
 581         /* Special tag mask */
 582         inl_rq->tag_mask = 0xFFF00000;
 583         inl_rq->tt = SSO_TT_ORDERED;
 584         inl_rq->hwgrp = 0;
 585         inl_rq->wqe_skip = inl_dev->wqe_skip;
 586         inl_rq->sso_ena = true;
 587
 588         /* Prepare and send RQ init mbox */
 589         if (roc_model_is_cn9k())
 590                 rc = nix_rq_cn9k_cfg(dev, inl_rq, inl_dev->qints, false, true);
 591         else
 592                 rc = nix_rq_cfg(dev, inl_rq, inl_dev->qints, false, true);
 593         if (rc) {
 594                 plt_err("Failed to prepare aq_enq msg, rc=%d", rc);
 595                 return rc;
 596         }
 597
 598         rc = mbox_process(dev->mbox);
 599         if (rc) {
 600                 plt_err("Failed to send aq_enq msg, rc=%d", rc);
 601                 return rc;
 602         }
 603
 604         inl_dev->rq_refs++;
 605         rq->inl_dev_ref = true;
 606         return 0;
 607 }
 608
 609 int
 610 roc_nix_inl_dev_rq_put(struct roc_nix_rq *rq)
 611 {
 612         struct idev_cfg *idev = idev_get_cfg();
 613         struct nix_inl_dev *inl_dev;
 614         struct roc_nix_rq *inl_rq;
 615         struct dev *dev;
 616         int rc;
 617
 618         if (idev == NULL)
 619                 return 0;
 620
 621         if (!rq->inl_dev_ref)
 622                 return 0;
 623
 624         inl_dev = idev->nix_inl_dev;
 625         /* Inline device should be there if we have ref */
 626         if (!inl_dev) {
 627                 plt_err("Failed to find inline device with refs");
 628                 return -EFAULT;
 629         }
 630
 631         rq->inl_dev_ref = false;
 632         inl_dev->rq_refs--;
 633         if (inl_dev->rq_refs)
 634                 return 0;
 635
 636         dev = &inl_dev->dev;
 637         inl_rq = &inl_dev->rq;
 638         /* There are no more references, disable RQ */
 639         rc = nix_rq_ena_dis(dev, inl_rq, false);
 640         if (rc)
 641                 plt_err("Failed to disable inline device rq, rc=%d", rc);
 642
 643         roc_npa_aura_drop_set(inl_rq->aura_handle, 0, false);
 644         if (inl_rq->spb_ena)
 645                 roc_npa_aura_drop_set(inl_rq->spb_aura_handle, 0, false);
 646
 647         /* Flush NIX LF for CN10K */
 648         nix_rq_vwqe_flush(rq, inl_dev->vwqe_interval);
 649
 650         return rc;
 651 }
 652
 653 uint64_t
 654 roc_nix_inl_dev_rq_limit_get(void)
 655 {
 656         struct idev_cfg *idev = idev_get_cfg();
 657         struct nix_inl_dev *inl_dev;
 658         struct roc_nix_rq *inl_rq;
 659
 660         if (!idev || !idev->nix_inl_dev)
 661                 return 0;
 662
 663         inl_dev = idev->nix_inl_dev;
 664         if (!inl_dev->rq_refs)
 665                 return 0;
 666
 667         inl_rq = &inl_dev->rq;
 668
 669         return roc_npa_aura_op_limit_get(inl_rq->aura_handle);
 670 }
 671
 672 void
 673 roc_nix_inb_mode_set(struct roc_nix *roc_nix, bool use_inl_dev)
 674 {
 675         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 676
 677         /* Info used by NPC flow rule add */
 678         nix->inb_inl_dev = use_inl_dev;
 679 }
 680
 681 bool
 682 roc_nix_inb_is_with_inl_dev(struct roc_nix *roc_nix)
 683 {
 684         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 685
 686         return nix->inb_inl_dev;
 687 }
 688
 689 struct roc_nix_rq *
 690 roc_nix_inl_dev_rq(void)
 691 {
 692         struct idev_cfg *idev = idev_get_cfg();
 693         struct nix_inl_dev *inl_dev;
 694
 695         if (idev != NULL) {
 696                 inl_dev = idev->nix_inl_dev;
 697                 if (inl_dev != NULL && inl_dev->rq_refs)
 698                         return &inl_dev->rq;
 699         }
 700
 701         return NULL;
 702 }
 703
 704 uint16_t __roc_api
 705 roc_nix_inl_outb_sso_pffunc_get(struct roc_nix *roc_nix)
 706 {
 707         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 708
 709         return nix->outb_err_sso_pffunc;
 710 }
 711
 712 int
 713 roc_nix_inl_cb_register(roc_nix_inl_sso_work_cb_t cb, void *args)
 714 {
 715         struct idev_cfg *idev = idev_get_cfg();
 716         struct nix_inl_dev *inl_dev;
 717
 718         if (idev == NULL)
 719                 return -EIO;
 720
 721         inl_dev = idev->nix_inl_dev;
 722         if (!inl_dev)
 723                 return -EIO;
 724
 725         /* Be silent if registration called with same cb and args */
 726         if (inl_dev->work_cb == cb && inl_dev->cb_args == args)
 727                 return 0;
 728
 729         /* Don't allow registration again if registered with different cb */
 730         if (inl_dev->work_cb)
 731                 return -EBUSY;
 732
 733         inl_dev->work_cb = cb;
 734         inl_dev->cb_args = args;
 735         return 0;
 736 }
 737
 738 int
 739 roc_nix_inl_cb_unregister(roc_nix_inl_sso_work_cb_t cb, void *args)
 740 {
 741         struct idev_cfg *idev = idev_get_cfg();
 742         struct nix_inl_dev *inl_dev;
 743
 744         if (idev == NULL)
 745                 return -ENOENT;
 746
 747         inl_dev = idev->nix_inl_dev;
 748         if (!inl_dev)
 749                 return -ENOENT;
 750
 751         if (inl_dev->work_cb != cb || inl_dev->cb_args != args)
 752                 return -EINVAL;
 753
 754         inl_dev->work_cb = NULL;
 755         inl_dev->cb_args = NULL;
 756         return 0;
 757 }
 758
 759 int
 760 roc_nix_inl_inb_tag_update(struct roc_nix *roc_nix, uint32_t tag_const,
 761                            uint8_t tt)
 762 {
 763         struct nix *nix = roc_nix_to_nix_priv(roc_nix);
 764         struct roc_nix_ipsec_cfg cfg;
 765
 766         /* Be silent if inline inbound not enabled */
 767         if (!nix->inl_inb_ena)
 768                 return 0;
 769
 770         memset(&cfg, 0, sizeof(cfg));
 771         cfg.sa_size = nix->inb_sa_sz;
 772         cfg.iova = (uintptr_t)nix->inb_sa_base;
 773         cfg.max_sa = roc_nix->ipsec_in_max_spi + 1;
 774         cfg.tt = tt;
 775         cfg.tag_const = tag_const;
 776
 777         return roc_nix_lf_inl_ipsec_cfg(roc_nix, &cfg, true);
 778 }
 779
 780 int
 781 roc_nix_inl_sa_sync(struct roc_nix *roc_nix, void *sa, bool inb,
 782                     enum roc_nix_inl_sa_sync_op op)
 783 {
 784         struct idev_cfg *idev = idev_get_cfg();
 785         struct nix_inl_dev *inl_dev = NULL;
 786         struct roc_cpt_lf *outb_lf = NULL;
 787         union cpt_lf_ctx_reload reload;
 788         union cpt_lf_ctx_flush flush;
 789         bool get_inl_lf = true;
 790         uintptr_t rbase;
 791         struct nix *nix;
 792
 793         /* Nothing much to do on cn9k */
 794         if (roc_model_is_cn9k()) {
 795                 plt_atomic_thread_fence(__ATOMIC_ACQ_REL);
 796                 return 0;
 797         }
 798
 799         if (idev)
 800                 inl_dev = idev->nix_inl_dev;
 801
 802         if (!inl_dev && roc_nix == NULL)
 803                 return -EINVAL;
 804
 805         if (roc_nix) {
 806                 nix = roc_nix_to_nix_priv(roc_nix);
 807                 outb_lf = nix->cpt_lf_base;
 808                 if (inb && !nix->inb_inl_dev)
 809                         get_inl_lf = false;
 810         }
 811
 812         if (inb && get_inl_lf) {
 813                 outb_lf = NULL;
 814                 if (inl_dev && inl_dev->attach_cptlf)
 815                         outb_lf = &inl_dev->cpt_lf;
 816         }
 817
 818         if (outb_lf) {
 819                 rbase = outb_lf->rbase;
 820
 821                 flush.u = 0;
 822                 reload.u = 0;
 823                 switch (op) {
 824                 case ROC_NIX_INL_SA_OP_FLUSH_INVAL:
 825                         flush.s.inval = 1;
 826                         /* fall through */
 827                 case ROC_NIX_INL_SA_OP_FLUSH:
 828                         flush.s.cptr = ((uintptr_t)sa) >> 7;
 829                         plt_write64(flush.u, rbase + CPT_LF_CTX_FLUSH);
 830                         break;
 831                 case ROC_NIX_INL_SA_OP_RELOAD:
 832                         reload.s.cptr = ((uintptr_t)sa) >> 7;
 833                         plt_write64(reload.u, rbase + CPT_LF_CTX_RELOAD);
 834                         break;
 835                 default:
 836                         return -EINVAL;
 837                 }
 838                 return 0;
 839         }
 840         plt_err("Could not get CPT LF for SA sync");
 841         return -ENOTSUP;
 842 }
 843
 844 int
 845 roc_nix_inl_ctx_write(struct roc_nix *roc_nix, void *sa_dptr, void *sa_cptr,
 846                       bool inb, uint16_t sa_len)
 847 {
 848         struct idev_cfg *idev = idev_get_cfg();
 849         struct nix_inl_dev *inl_dev = NULL;
 850         struct roc_cpt_lf *outb_lf = NULL;
 851         union cpt_lf_ctx_flush flush;
 852         bool get_inl_lf = true;
 853         uintptr_t rbase;
 854         struct nix *nix;
 855         int rc;
 856
 857         /* Nothing much to do on cn9k */
 858         if (roc_model_is_cn9k()) {
 859                 plt_atomic_thread_fence(__ATOMIC_ACQ_REL);
 860                 return 0;
 861         }
 862
 863         if (idev)
 864                 inl_dev = idev->nix_inl_dev;
 865
 866         if (!inl_dev && roc_nix == NULL)
 867                 return -EINVAL;
 868
 869         if (roc_nix) {
 870                 nix = roc_nix_to_nix_priv(roc_nix);
 871                 outb_lf = nix->cpt_lf_base;
 872
 873                 if (inb && !nix->inb_inl_dev)
 874                         get_inl_lf = false;
 875         }
 876
 877         if (inb && get_inl_lf) {
 878                 outb_lf = NULL;
 879                 if (inl_dev && inl_dev->attach_cptlf)
 880                         outb_lf = &inl_dev->cpt_lf;
 881         }
 882
 883         if (outb_lf) {
 884                 rbase = outb_lf->rbase;
 885                 flush.u = 0;
 886
 887                 rc = roc_cpt_ctx_write(outb_lf, sa_dptr, sa_cptr, sa_len);
 888                 if (rc)
 889                         return rc;
 890                 /* Trigger CTX flush to write dirty data back to DRAM */
 891                 flush.s.cptr = ((uintptr_t)sa_cptr) >> 7;
 892                 plt_write64(flush.u, rbase + CPT_LF_CTX_FLUSH);
 893
 894                 return 0;
 895         }
 896         plt_nix_dbg("Could not get CPT LF for CTX write");
 897         return -ENOTSUP;
 898 }
 899
 900 void
 901 roc_nix_inl_dev_lock(void)
 902 {
 903         struct idev_cfg *idev = idev_get_cfg();
 904
 905         if (idev != NULL)
 906                 plt_spinlock_lock(&idev->nix_inl_dev_lock);
 907 }
 908
 909 void
 910 roc_nix_inl_dev_unlock(void)
 911 {
 912         struct idev_cfg *idev = idev_get_cfg();
 913
 914         if (idev != NULL)
 915                 plt_spinlock_unlock(&idev->nix_inl_dev_lock);
 916 }