drivers/common/cnxk/roc_cpt.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 #define CPT_IQ_FC_LEN  128
   9 #define CPT_IQ_GRP_LEN 16
  10
  11 #define CPT_IQ_NB_DESC_MULTIPLIER 40
  12
  13 /* The effective queue size to software is (CPT_LF_Q_SIZE[SIZE_DIV40] - 1 - 8).
  14  *
  15  * CPT requires 320 free entries (+8). And 40 entries are required for
  16  * allowing CPT to discard packet when the queues are full (+1).
  17  */
  18 #define CPT_IQ_NB_DESC_SIZE_DIV40(nb_desc)                                     \
  19         (PLT_DIV_CEIL(nb_desc, CPT_IQ_NB_DESC_MULTIPLIER) + 1 + 8)
  20
  21 #define CPT_IQ_GRP_SIZE(nb_desc)                                               \
  22         (CPT_IQ_NB_DESC_SIZE_DIV40(nb_desc) * CPT_IQ_GRP_LEN)
  23
  24 #define CPT_LF_MAX_NB_DESC     128000
  25 #define CPT_LF_DEFAULT_NB_DESC 1024
  26
  27 static void
  28 cpt_lf_misc_intr_enb_dis(struct roc_cpt_lf *lf, bool enb)
  29 {
  30         /* Enable all cpt lf error irqs except RQ_DISABLED and CQ_DISABLED */
  31         if (enb)
  32                 plt_write64((BIT_ULL(6) | BIT_ULL(5) | BIT_ULL(3) | BIT_ULL(2) |
  33                              BIT_ULL(1)),
  34                             lf->rbase + CPT_LF_MISC_INT_ENA_W1S);
  35         else
  36                 plt_write64((BIT_ULL(6) | BIT_ULL(5) | BIT_ULL(3) | BIT_ULL(2) |
  37                              BIT_ULL(1)),
  38                             lf->rbase + CPT_LF_MISC_INT_ENA_W1C);
  39 }
  40
  41 static void
  42 cpt_lf_misc_irq(void *param)
  43 {
  44         struct roc_cpt_lf *lf = (struct roc_cpt_lf *)param;
  45         struct dev *dev = lf->dev;
  46         uint64_t intr;
  47
  48         intr = plt_read64(lf->rbase + CPT_LF_MISC_INT);
  49         if (intr == 0)
  50                 return;
  51
  52         plt_err("Err_irq=0x%" PRIx64 " pf=%d, vf=%d", intr, dev->pf, dev->vf);
  53
  54         /* Clear interrupt */
  55         plt_write64(intr, lf->rbase + CPT_LF_MISC_INT);
  56 }
  57
  58 static int
  59 cpt_lf_register_misc_irq(struct roc_cpt_lf *lf)
  60 {
  61         struct plt_pci_device *pci_dev = lf->pci_dev;
  62         struct plt_intr_handle *handle;
  63         int rc, vec;
  64
  65         handle = &pci_dev->intr_handle;
  66
  67         vec = lf->msixoff + CPT_LF_INT_VEC_MISC;
  68         /* Clear err interrupt */
  69         cpt_lf_misc_intr_enb_dis(lf, false);
  70         /* Set used interrupt vectors */
  71         rc = dev_irq_register(handle, cpt_lf_misc_irq, lf, vec);
  72         /* Enable all dev interrupt except for RQ_DISABLED */
  73         cpt_lf_misc_intr_enb_dis(lf, true);
  74
  75         return rc;
  76 }
  77
  78 static void
  79 cpt_lf_unregister_misc_irq(struct roc_cpt_lf *lf)
  80 {
  81         struct plt_pci_device *pci_dev = lf->pci_dev;
  82         struct plt_intr_handle *handle;
  83         int vec;
  84
  85         handle = &pci_dev->intr_handle;
  86
  87         vec = lf->msixoff + CPT_LF_INT_VEC_MISC;
  88         /* Clear err interrupt */
  89         cpt_lf_misc_intr_enb_dis(lf, false);
  90         dev_irq_unregister(handle, cpt_lf_misc_irq, lf, vec);
  91 }
  92
  93 static void
  94 cpt_lf_done_intr_enb_dis(struct roc_cpt_lf *lf, bool enb)
  95 {
  96         if (enb)
  97                 plt_write64(0x1, lf->rbase + CPT_LF_DONE_INT_ENA_W1S);
  98         else
  99                 plt_write64(0x1, lf->rbase + CPT_LF_DONE_INT_ENA_W1C);
 100 }
 101
 102 static void
 103 cpt_lf_done_irq(void *param)
 104 {
 105         struct roc_cpt_lf *lf = param;
 106         uint64_t done_wait;
 107         uint64_t intr;
 108
 109         /* Read the number of completed requests */
 110         intr = plt_read64(lf->rbase + CPT_LF_DONE);
 111         if (intr == 0)
 112                 return;
 113
 114         done_wait = plt_read64(lf->rbase + CPT_LF_DONE_WAIT);
 115
 116         /* Acknowledge the number of completed requests */
 117         plt_write64(intr, lf->rbase + CPT_LF_DONE_ACK);
 118
 119         plt_write64(done_wait, lf->rbase + CPT_LF_DONE_WAIT);
 120 }
 121
 122 static int
 123 cpt_lf_register_done_irq(struct roc_cpt_lf *lf)
 124 {
 125         struct plt_pci_device *pci_dev = lf->pci_dev;
 126         struct plt_intr_handle *handle;
 127         int rc, vec;
 128
 129         handle = &pci_dev->intr_handle;
 130
 131         vec = lf->msixoff + CPT_LF_INT_VEC_DONE;
 132
 133         /* Clear done interrupt */
 134         cpt_lf_done_intr_enb_dis(lf, false);
 135
 136         /* Set used interrupt vectors */
 137         rc = dev_irq_register(handle, cpt_lf_done_irq, lf, vec);
 138
 139         /* Enable done interrupt */
 140         cpt_lf_done_intr_enb_dis(lf, true);
 141
 142         return rc;
 143 }
 144
 145 static void
 146 cpt_lf_unregister_done_irq(struct roc_cpt_lf *lf)
 147 {
 148         struct plt_pci_device *pci_dev = lf->pci_dev;
 149         struct plt_intr_handle *handle;
 150         int vec;
 151
 152         handle = &pci_dev->intr_handle;
 153
 154         vec = lf->msixoff + CPT_LF_INT_VEC_DONE;
 155
 156         /* Clear done interrupt */
 157         cpt_lf_done_intr_enb_dis(lf, false);
 158         dev_irq_unregister(handle, cpt_lf_done_irq, lf, vec);
 159 }
 160
 161 static int
 162 cpt_lf_register_irqs(struct roc_cpt_lf *lf)
 163 {
 164         int rc;
 165
 166         if (lf->msixoff == MSIX_VECTOR_INVALID) {
 167                 plt_err("Invalid CPTLF MSIX vector offset vector: 0x%x",
 168                         lf->msixoff);
 169                 return -EINVAL;
 170         }
 171
 172         /* Register lf err interrupt */
 173         rc = cpt_lf_register_misc_irq(lf);
 174         if (rc)
 175                 plt_err("Error registering IRQs");
 176
 177         rc = cpt_lf_register_done_irq(lf);
 178         if (rc)
 179                 plt_err("Error registering IRQs");
 180
 181         return rc;
 182 }
 183
 184 static void
 185 cpt_lf_unregister_irqs(struct roc_cpt_lf *lf)
 186 {
 187         cpt_lf_unregister_misc_irq(lf);
 188         cpt_lf_unregister_done_irq(lf);
 189 }
 190
 191 static void
 192 cpt_lf_dump(struct roc_cpt_lf *lf)
 193 {
 194         plt_cpt_dbg("CPT LF");
 195         plt_cpt_dbg("RBASE: 0x%016" PRIx64, lf->rbase);
 196         plt_cpt_dbg("LMT_BASE: 0x%016" PRIx64, lf->lmt_base);
 197         plt_cpt_dbg("MSIXOFF: 0x%x", lf->msixoff);
 198         plt_cpt_dbg("LF_ID: 0x%x", lf->lf_id);
 199         plt_cpt_dbg("NB DESC: %d", lf->nb_desc);
 200         plt_cpt_dbg("FC_ADDR: 0x%016" PRIx64, (uintptr_t)lf->fc_addr);
 201         plt_cpt_dbg("CQ.VADDR: 0x%016" PRIx64, (uintptr_t)lf->iq_vaddr);
 202
 203         plt_cpt_dbg("CPT LF REG:");
 204         plt_cpt_dbg("LF_CTL[0x%016llx]: 0x%016" PRIx64, CPT_LF_CTL,
 205                     plt_read64(lf->rbase + CPT_LF_CTL));
 206         plt_cpt_dbg("Q_SIZE[0x%016llx]: 0x%016" PRIx64, CPT_LF_INPROG,
 207                     plt_read64(lf->rbase + CPT_LF_INPROG));
 208
 209         plt_cpt_dbg("Q_BASE[0x%016llx]: 0x%016" PRIx64, CPT_LF_Q_BASE,
 210                     plt_read64(lf->rbase + CPT_LF_Q_BASE));
 211         plt_cpt_dbg("Q_SIZE[0x%016llx]: 0x%016" PRIx64, CPT_LF_Q_SIZE,
 212                     plt_read64(lf->rbase + CPT_LF_Q_SIZE));
 213         plt_cpt_dbg("Q_INST_PTR[0x%016llx]: 0x%016" PRIx64, CPT_LF_Q_INST_PTR,
 214                     plt_read64(lf->rbase + CPT_LF_Q_INST_PTR));
 215         plt_cpt_dbg("Q_GRP_PTR[0x%016llx]: 0x%016" PRIx64, CPT_LF_Q_GRP_PTR,
 216                     plt_read64(lf->rbase + CPT_LF_Q_GRP_PTR));
 217 }
 218
 219 int
 220 roc_cpt_rxc_time_cfg(struct roc_cpt *roc_cpt, struct roc_cpt_rxc_time_cfg *cfg)
 221 {
 222         struct cpt *cpt = roc_cpt_to_cpt_priv(roc_cpt);
 223         struct cpt_rxc_time_cfg_req *req;
 224         struct dev *dev = &cpt->dev;
 225
 226         req = mbox_alloc_msg_cpt_rxc_time_cfg(dev->mbox);
 227         if (req == NULL)
 228                 return -ENOSPC;
 229
 230         req->blkaddr = 0;
 231
 232         /* The step value is in microseconds. */
 233         req->step = cfg->step;
 234
 235         /* The timeout will be: limit * step microseconds */
 236         req->zombie_limit = cfg->zombie_limit;
 237         req->zombie_thres = cfg->zombie_thres;
 238
 239         /* The timeout will be: limit * step microseconds */
 240         req->active_limit = cfg->active_limit;
 241         req->active_thres = cfg->active_thres;
 242
 243         return mbox_process(dev->mbox);
 244 }
 245
 246 int
 247 cpt_get_msix_offset(struct dev *dev, struct msix_offset_rsp **msix_rsp)
 248 {
 249         struct mbox *mbox = dev->mbox;
 250         int rc;
 251
 252         /* Get MSIX vector offsets */
 253         mbox_alloc_msg_msix_offset(mbox);
 254         rc = mbox_process_msg(mbox, (void *)msix_rsp);
 255
 256         return rc;
 257 }
 258
 259 int
 260 cpt_lfs_attach(struct dev *dev, uint8_t blkaddr, bool modify, uint16_t nb_lf)
 261 {
 262         struct mbox *mbox = dev->mbox;
 263         struct rsrc_attach_req *req;
 264
 265         if (blkaddr != RVU_BLOCK_ADDR_CPT0 && blkaddr != RVU_BLOCK_ADDR_CPT1)
 266                 return -EINVAL;
 267
 268         /* Attach CPT(lf) */
 269         req = mbox_alloc_msg_attach_resources(mbox);
 270         if (req == NULL)
 271                 return -ENOSPC;
 272
 273         req->cptlfs = nb_lf;
 274         req->modify = modify;
 275         req->cpt_blkaddr = blkaddr;
 276
 277         return mbox_process(mbox);
 278 }
 279
 280 int
 281 cpt_lfs_detach(struct dev *dev)
 282 {
 283         struct mbox *mbox = dev->mbox;
 284         struct rsrc_detach_req *req;
 285
 286         req = mbox_alloc_msg_detach_resources(mbox);
 287         if (req == NULL)
 288                 return -ENOSPC;
 289
 290         req->cptlfs = 1;
 291         req->partial = 1;
 292
 293         return mbox_process(mbox);
 294 }
 295
 296 static int
 297 cpt_available_lfs_get(struct dev *dev, uint16_t *nb_lf)
 298 {
 299         struct mbox *mbox = dev->mbox;
 300         struct free_rsrcs_rsp *rsp;
 301         int rc;
 302
 303         mbox_alloc_msg_free_rsrc_cnt(mbox);
 304
 305         rc = mbox_process_msg(mbox, (void *)&rsp);
 306         if (rc)
 307                 return -EIO;
 308
 309         *nb_lf = rsp->cpt;
 310         return 0;
 311 }
 312
 313 int
 314 cpt_lfs_alloc(struct dev *dev, uint8_t eng_grpmsk, uint8_t blkaddr,
 315               bool inl_dev_sso)
 316 {
 317         struct cpt_lf_alloc_req_msg *req;
 318         struct mbox *mbox = dev->mbox;
 319
 320         if (blkaddr != RVU_BLOCK_ADDR_CPT0 && blkaddr != RVU_BLOCK_ADDR_CPT1)
 321                 return -EINVAL;
 322
 323         PLT_SET_USED(inl_dev_sso);
 324
 325         req = mbox_alloc_msg_cpt_lf_alloc(mbox);
 326         req->nix_pf_func = 0;
 327         req->sso_pf_func = idev_sso_pffunc_get();
 328         req->eng_grpmsk = eng_grpmsk;
 329         req->blkaddr = blkaddr;
 330
 331         return mbox_process(mbox);
 332 }
 333
 334 int
 335 cpt_lfs_free(struct dev *dev)
 336 {
 337         mbox_alloc_msg_cpt_lf_free(dev->mbox);
 338
 339         return mbox_process(dev->mbox);
 340 }
 341
 342 static int
 343 cpt_hardware_caps_get(struct dev *dev, union cpt_eng_caps *hw_caps)
 344 {
 345         struct cpt_caps_rsp_msg *rsp;
 346         int ret;
 347
 348         mbox_alloc_msg_cpt_caps_get(dev->mbox);
 349
 350         ret = mbox_process_msg(dev->mbox, (void *)&rsp);
 351         if (ret)
 352                 return -EIO;
 353
 354         mbox_memcpy(hw_caps, rsp->eng_caps,
 355                     sizeof(union cpt_eng_caps) * CPT_MAX_ENG_TYPES);
 356
 357         return 0;
 358 }
 359
 360 static uint32_t
 361 cpt_lf_iq_mem_calc(uint32_t nb_desc)
 362 {
 363         uint32_t len;
 364
 365         /* Space for instruction group memory */
 366         len = CPT_IQ_GRP_SIZE(nb_desc);
 367
 368         /* Align to 128B */
 369         len = PLT_ALIGN(len, ROC_ALIGN);
 370
 371         /* Space for FC */
 372         len += CPT_IQ_FC_LEN;
 373
 374         /* For instruction queues */
 375         len += CPT_IQ_NB_DESC_SIZE_DIV40(nb_desc) * CPT_IQ_NB_DESC_MULTIPLIER *
 376                sizeof(struct cpt_inst_s);
 377
 378         return len;
 379 }
 380
 381 static inline void
 382 cpt_iq_init(struct roc_cpt_lf *lf)
 383 {
 384         union cpt_lf_q_size lf_q_size = {.u = 0x0};
 385         union cpt_lf_q_base lf_q_base = {.u = 0x0};
 386         union cpt_lf_inprog lf_inprog;
 387         union cpt_lf_ctl lf_ctl;
 388         uintptr_t addr;
 389
 390         lf->io_addr = lf->rbase + CPT_LF_NQX(0);
 391
 392         /* Disable command queue */
 393         roc_cpt_iq_disable(lf);
 394
 395         /* Set command queue base address */
 396         addr = (uintptr_t)lf->iq_vaddr +
 397                PLT_ALIGN(CPT_IQ_GRP_SIZE(lf->nb_desc), ROC_ALIGN);
 398
 399         lf_q_base.u = addr;
 400
 401         plt_write64(lf_q_base.u, lf->rbase + CPT_LF_Q_BASE);
 402
 403         /* Set command queue size */
 404         lf_q_size.s.size_div40 = CPT_IQ_NB_DESC_SIZE_DIV40(lf->nb_desc);
 405         plt_write64(lf_q_size.u, lf->rbase + CPT_LF_Q_SIZE);
 406
 407         /* Enable command queue execution */
 408         lf_inprog.u = plt_read64(lf->rbase + CPT_LF_INPROG);
 409         lf_inprog.s.eena = 1;
 410         plt_write64(lf_inprog.u, lf->rbase + CPT_LF_INPROG);
 411
 412         /* Enable instruction queue enqueuing */
 413         lf_ctl.u = plt_read64(lf->rbase + CPT_LF_CTL);
 414         lf_ctl.s.ena = 1;
 415         lf_ctl.s.fc_ena = 1;
 416         lf_ctl.s.fc_up_crossing = 1;
 417         lf_ctl.s.fc_hyst_bits = CPT_FC_NUM_HYST_BITS;
 418         plt_write64(lf_ctl.u, lf->rbase + CPT_LF_CTL);
 419
 420         lf->fc_addr = (uint64_t *)addr;
 421 }
 422
 423 int
 424 roc_cpt_dev_configure(struct roc_cpt *roc_cpt, int nb_lf)
 425 {
 426         struct cpt *cpt = roc_cpt_to_cpt_priv(roc_cpt);
 427         uint8_t blkaddr = RVU_BLOCK_ADDR_CPT0;
 428         struct msix_offset_rsp *rsp;
 429         uint8_t eng_grpmsk;
 430         int rc, i;
 431
 432         /* Request LF resources */
 433         rc = cpt_lfs_attach(&cpt->dev, blkaddr, false, nb_lf);
 434         if (rc)
 435                 return rc;
 436
 437         eng_grpmsk = (1 << roc_cpt->eng_grp[CPT_ENG_TYPE_AE]) |
 438                      (1 << roc_cpt->eng_grp[CPT_ENG_TYPE_SE]) |
 439                      (1 << roc_cpt->eng_grp[CPT_ENG_TYPE_IE]);
 440
 441         rc = cpt_lfs_alloc(&cpt->dev, eng_grpmsk, blkaddr, false);
 442         if (rc)
 443                 goto lfs_detach;
 444
 445         rc = cpt_get_msix_offset(&cpt->dev, &rsp);
 446         if (rc)
 447                 goto lfs_free;
 448
 449         for (i = 0; i < nb_lf; i++)
 450                 cpt->lf_msix_off[i] =
 451                         (cpt->lf_blkaddr[i] == RVU_BLOCK_ADDR_CPT1) ?
 452                                 rsp->cpt1_lf_msixoff[i] :
 453                                 rsp->cptlf_msixoff[i];
 454
 455         roc_cpt->nb_lf = nb_lf;
 456
 457         return 0;
 458
 459 lfs_free:
 460         cpt_lfs_free(&cpt->dev);
 461 lfs_detach:
 462         cpt_lfs_detach(&cpt->dev);
 463         return rc;
 464 }
 465
 466 uint64_t
 467 cpt_get_blkaddr(struct dev *dev)
 468 {
 469         uint64_t reg;
 470         uint64_t off;
 471
 472         /* Reading the discovery register to know which CPT is the LF
 473          * attached to. Assume CPT LF's of only one block are attached
 474          * to a pffunc.
 475          */
 476         if (dev_is_vf(dev))
 477                 off = RVU_VF_BLOCK_ADDRX_DISC(RVU_BLOCK_ADDR_CPT1);
 478         else
 479                 off = RVU_PF_BLOCK_ADDRX_DISC(RVU_BLOCK_ADDR_CPT1);
 480
 481         reg = plt_read64(dev->bar2 + off);
 482
 483         return reg & 0x1FFULL ? RVU_BLOCK_ADDR_CPT1 : RVU_BLOCK_ADDR_CPT0;
 484 }
 485
 486 int
 487 cpt_lf_init(struct roc_cpt_lf *lf)
 488 {
 489         struct dev *dev = lf->dev;
 490         uint64_t blkaddr;
 491         void *iq_mem;
 492         int rc;
 493
 494         if (lf->nb_desc == 0 || lf->nb_desc > CPT_LF_MAX_NB_DESC)
 495                 lf->nb_desc = CPT_LF_DEFAULT_NB_DESC;
 496
 497         /* Allocate memory for instruction queue for CPT LF. */
 498         iq_mem = plt_zmalloc(cpt_lf_iq_mem_calc(lf->nb_desc), ROC_ALIGN);
 499         if (iq_mem == NULL)
 500                 return -ENOMEM;
 501
 502         blkaddr = cpt_get_blkaddr(dev);
 503         lf->rbase = dev->bar2 + ((blkaddr << 20) | (lf->lf_id << 12));
 504         lf->iq_vaddr = iq_mem;
 505         lf->lmt_base = dev->lmt_base;
 506         lf->pf_func = dev->pf_func;
 507
 508         /* Initialize instruction queue */
 509         cpt_iq_init(lf);
 510
 511         rc = cpt_lf_register_irqs(lf);
 512         if (rc)
 513                 goto disable_iq;
 514
 515         cpt_lf_dump(lf);
 516         return 0;
 517
 518 disable_iq:
 519         roc_cpt_iq_disable(lf);
 520         plt_free(iq_mem);
 521         return rc;
 522 }
 523
 524 int
 525 roc_cpt_lf_init(struct roc_cpt *roc_cpt, struct roc_cpt_lf *lf)
 526 {
 527         struct cpt *cpt = roc_cpt_to_cpt_priv(roc_cpt);
 528         int rc;
 529
 530         lf->dev = &cpt->dev;
 531         lf->roc_cpt = roc_cpt;
 532         lf->msixoff = cpt->lf_msix_off[lf->lf_id];
 533         lf->pci_dev = cpt->pci_dev;
 534
 535         rc = cpt_lf_init(lf);
 536         if (rc)
 537                 return rc;
 538
 539         /* LF init successful */
 540         roc_cpt->lf[lf->lf_id] = lf;
 541         return rc;
 542 }
 543
 544 int
 545 roc_cpt_dev_init(struct roc_cpt *roc_cpt)
 546 {
 547         struct plt_pci_device *pci_dev;
 548         uint16_t nb_lf_avail;
 549         struct dev *dev;
 550         struct cpt *cpt;
 551         int rc;
 552
 553         if (roc_cpt == NULL || roc_cpt->pci_dev == NULL)
 554                 return -EINVAL;
 555
 556         PLT_STATIC_ASSERT(sizeof(struct cpt) <= ROC_CPT_MEM_SZ);
 557
 558         cpt = roc_cpt_to_cpt_priv(roc_cpt);
 559         memset(cpt, 0, sizeof(*cpt));
 560         pci_dev = roc_cpt->pci_dev;
 561         dev = &cpt->dev;
 562
 563         /* Initialize device  */
 564         rc = dev_init(dev, pci_dev);
 565         if (rc) {
 566                 plt_err("Failed to init roc device");
 567                 goto fail;
 568         }
 569
 570         cpt->pci_dev = pci_dev;
 571         roc_cpt->lmt_base = dev->lmt_base;
 572
 573         rc = cpt_hardware_caps_get(dev, roc_cpt->hw_caps);
 574         if (rc) {
 575                 plt_err("Could not determine hardware capabilities");
 576                 goto fail;
 577         }
 578
 579         rc = cpt_available_lfs_get(&cpt->dev, &nb_lf_avail);
 580         if (rc) {
 581                 plt_err("Could not get available lfs");
 582                 goto fail;
 583         }
 584
 585         /* Reserve 1 CPT LF for inline inbound */
 586         nb_lf_avail = PLT_MIN(nb_lf_avail, ROC_CPT_MAX_LFS - 1);
 587
 588         roc_cpt->nb_lf_avail = nb_lf_avail;
 589
 590         dev->roc_cpt = roc_cpt;
 591
 592         /* Set it to idev if not already present */
 593         if (!roc_idev_cpt_get())
 594                 roc_idev_cpt_set(roc_cpt);
 595
 596         return 0;
 597
 598 fail:
 599         return rc;
 600 }
 601
 602 int
 603 roc_cpt_lf_ctx_flush(struct roc_cpt_lf *lf, uint64_t cptr)
 604 {
 605         union cpt_lf_ctx_flush reg;
 606
 607         if (lf == NULL)
 608                 return -ENOTSUP;
 609
 610         reg.u = 0;
 611         reg.s.pf_func = lf->pf_func;
 612         reg.s.inval = 1;
 613         reg.s.cptr = cptr;
 614
 615         plt_write64(reg.u, lf->rbase + CPT_LF_CTX_FLUSH);
 616
 617         return 0;
 618 }
 619
 620 void
 621 cpt_lf_fini(struct roc_cpt_lf *lf)
 622 {
 623         /* Unregister IRQ's */
 624         cpt_lf_unregister_irqs(lf);
 625
 626         /* Disable IQ */
 627         roc_cpt_iq_disable(lf);
 628
 629         /* Free memory */
 630         plt_free(lf->iq_vaddr);
 631         lf->iq_vaddr = NULL;
 632 }
 633
 634 void
 635 roc_cpt_lf_fini(struct roc_cpt_lf *lf)
 636 {
 637         if (lf == NULL)
 638                 return;
 639         lf->roc_cpt->lf[lf->lf_id] = NULL;
 640         cpt_lf_fini(lf);
 641 }
 642
 643 int
 644 roc_cpt_dev_fini(struct roc_cpt *roc_cpt)
 645 {
 646         struct cpt *cpt = roc_cpt_to_cpt_priv(roc_cpt);
 647
 648         if (cpt == NULL)
 649                 return -EINVAL;
 650
 651         /* Remove idev references */
 652         if (roc_idev_cpt_get() == roc_cpt)
 653                 roc_idev_cpt_set(NULL);
 654
 655         roc_cpt->nb_lf_avail = 0;
 656
 657         roc_cpt->lmt_base = 0;
 658
 659         return dev_fini(&cpt->dev, cpt->pci_dev);
 660 }
 661
 662 void
 663 roc_cpt_dev_clear(struct roc_cpt *roc_cpt)
 664 {
 665         struct cpt *cpt = roc_cpt_to_cpt_priv(roc_cpt);
 666         int i;
 667
 668         if (cpt == NULL)
 669                 return;
 670
 671         for (i = 0; i < roc_cpt->nb_lf; i++)
 672                 cpt->lf_msix_off[i] = 0;
 673
 674         roc_cpt->nb_lf = 0;
 675
 676         cpt_lfs_free(&cpt->dev);
 677
 678         cpt_lfs_detach(&cpt->dev);
 679 }
 680
 681 int
 682 roc_cpt_eng_grp_add(struct roc_cpt *roc_cpt, enum cpt_eng_type eng_type)
 683 {
 684         struct cpt *cpt = roc_cpt_to_cpt_priv(roc_cpt);
 685         struct dev *dev = &cpt->dev;
 686         struct cpt_eng_grp_req *req;
 687         struct cpt_eng_grp_rsp *rsp;
 688         int ret;
 689
 690         req = mbox_alloc_msg_cpt_eng_grp_get(dev->mbox);
 691         if (req == NULL)
 692                 return -EIO;
 693
 694         switch (eng_type) {
 695         case CPT_ENG_TYPE_AE:
 696         case CPT_ENG_TYPE_SE:
 697         case CPT_ENG_TYPE_IE:
 698                 break;
 699         default:
 700                 return -EINVAL;
 701         }
 702
 703         req->eng_type = eng_type;
 704         ret = mbox_process_msg(dev->mbox, (void *)&rsp);
 705         if (ret)
 706                 return -EIO;
 707
 708         if (rsp->eng_grp_num > 8) {
 709                 plt_err("Invalid CPT engine group");
 710                 return -ENOTSUP;
 711         }
 712
 713         roc_cpt->eng_grp[eng_type] = rsp->eng_grp_num;
 714
 715         return rsp->eng_grp_num;
 716 }
 717
 718 void
 719 roc_cpt_iq_disable(struct roc_cpt_lf *lf)
 720 {
 721         union cpt_lf_ctl lf_ctl = {.u = 0x0};
 722         union cpt_lf_inprog lf_inprog;
 723         int timeout = 20;
 724
 725         /* Disable instructions enqueuing */
 726         plt_write64(lf_ctl.u, lf->rbase + CPT_LF_CTL);
 727
 728         /* Wait for instruction queue to become empty */
 729         do {
 730                 lf_inprog.u = plt_read64(lf->rbase + CPT_LF_INPROG);
 731                 if (!lf_inprog.s.inflight)
 732                         break;
 733
 734                 plt_delay_ms(20);
 735                 if (timeout-- < 0) {
 736                         plt_err("CPT LF %d is still busy", lf->lf_id);
 737                         break;
 738                 }
 739
 740         } while (1);
 741
 742         /* Disable executions in the LF's queue.
 743          * The queue should be empty at this point
 744          */
 745         lf_inprog.s.eena = 0x0;
 746         plt_write64(lf_inprog.u, lf->rbase + CPT_LF_INPROG);
 747 }