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 SSO_XAQ_CACHE_CNT (0x3) 9 #define SSO_XAQ_RSVD_CNT (0x4) 10 #define SSO_XAQ_SLACK (16) 11 12 /* Private functions. */ 13 int 14 sso_lf_alloc(struct dev *dev, enum sso_lf_type lf_type, uint16_t nb_lf, 15 void **rsp) 16 { 17 struct mbox *mbox = mbox_get(dev->mbox); 18 int rc = -ENOSPC; 19 20 if (!nb_lf) { 21 mbox_put(mbox); 22 return 0; 23 } 24 25 switch (lf_type) { 26 case SSO_LF_TYPE_HWS: { 27 struct ssow_lf_alloc_req *req; 28 29 req = mbox_alloc_msg_ssow_lf_alloc(mbox); 30 if (req == NULL) 31 goto exit; 32 req->hws = nb_lf; 33 } break; 34 case SSO_LF_TYPE_HWGRP: { 35 struct sso_lf_alloc_req *req; 36 37 req = mbox_alloc_msg_sso_lf_alloc(mbox); 38 if (req == NULL) 39 goto exit; 40 req->hwgrps = nb_lf; 41 } break; 42 default: 43 break; 44 } 45 46 rc = mbox_process_msg(mbox, rsp); 47 if (rc) { 48 rc = -EIO; 49 goto exit; 50 } 51 52 rc = 0; 53 exit: 54 mbox_put(mbox); 55 return rc; 56 } 57 58 int 59 sso_lf_free(struct dev *dev, enum sso_lf_type lf_type, uint16_t nb_lf) 60 { 61 struct mbox *mbox = mbox_get(dev->mbox); 62 int rc = -ENOSPC; 63 64 if (!nb_lf) { 65 mbox_put(mbox); 66 return 0; 67 } 68 69 switch (lf_type) { 70 case SSO_LF_TYPE_HWS: { 71 struct ssow_lf_free_req *req; 72 73 req = mbox_alloc_msg_ssow_lf_free(mbox); 74 if (req == NULL) 75 goto exit; 76 req->hws = nb_lf; 77 } break; 78 case SSO_LF_TYPE_HWGRP: { 79 struct sso_lf_free_req *req; 80 81 req = mbox_alloc_msg_sso_lf_free(mbox); 82 if (req == NULL) 83 goto exit; 84 req->hwgrps = nb_lf; 85 } break; 86 default: 87 break; 88 } 89 90 rc = mbox_process(mbox); 91 if (rc) { 92 rc = -EIO; 93 goto exit; 94 } 95 96 rc = 0; 97 exit: 98 mbox_put(mbox); 99 return rc; 100 } 101 102 static int 103 sso_rsrc_attach(struct roc_sso *roc_sso, enum sso_lf_type lf_type, 104 uint16_t nb_lf) 105 { 106 struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev; 107 struct mbox *mbox = mbox_get(dev->mbox); 108 struct rsrc_attach_req *req; 109 int rc = -ENOSPC; 110 111 if (!nb_lf) { 112 mbox_put(mbox); 113 return 0; 114 } 115 116 req = mbox_alloc_msg_attach_resources(mbox); 117 if (req == NULL) 118 goto exit; 119 switch (lf_type) { 120 case SSO_LF_TYPE_HWS: 121 req->ssow = nb_lf; 122 break; 123 case SSO_LF_TYPE_HWGRP: 124 req->sso = nb_lf; 125 break; 126 default: 127 rc = SSO_ERR_PARAM; 128 goto exit; 129 } 130 131 req->modify = true; 132 if (mbox_process(mbox)) { 133 rc = -EIO; 134 goto exit; 135 } 136 137 rc = 0; 138 exit: 139 mbox_put(mbox); 140 return rc; 141 } 142 143 static int 144 sso_rsrc_detach(struct roc_sso *roc_sso, enum sso_lf_type lf_type) 145 { 146 struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev; 147 struct rsrc_detach_req *req; 148 struct mbox *mbox = mbox_get(dev->mbox); 149 int rc = -ENOSPC; 150 151 req = mbox_alloc_msg_detach_resources(mbox); 152 if (req == NULL) 153 goto exit; 154 switch (lf_type) { 155 case SSO_LF_TYPE_HWS: 156 req->ssow = true; 157 break; 158 case SSO_LF_TYPE_HWGRP: 159 req->sso = true; 160 break; 161 default: 162 rc = SSO_ERR_PARAM; 163 goto exit; 164 } 165 166 req->partial = true; 167 if (mbox_process(mbox)) { 168 rc = -EIO; 169 goto exit; 170 } 171 172 rc = 0; 173 exit: 174 mbox_put(mbox); 175 return rc; 176 } 177 178 static int 179 sso_rsrc_get(struct roc_sso *roc_sso) 180 { 181 struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev; 182 struct free_rsrcs_rsp *rsrc_cnt; 183 struct mbox *mbox = mbox_get(dev->mbox); 184 int rc; 185 186 mbox_alloc_msg_free_rsrc_cnt(mbox); 187 rc = mbox_process_msg(mbox, (void **)&rsrc_cnt); 188 if (rc) { 189 plt_err("Failed to get free resource count\n"); 190 rc = -EIO; 191 goto exit; 192 } 193 194 roc_sso->max_hwgrp = rsrc_cnt->sso; 195 roc_sso->max_hws = rsrc_cnt->ssow; 196 197 rc = 0; 198 exit: 199 mbox_put(mbox); 200 return rc; 201 } 202 203 void 204 sso_hws_link_modify(uint8_t hws, uintptr_t base, struct plt_bitmap *bmp, uint16_t hwgrp[], 205 uint16_t n, uint8_t set, uint16_t enable) 206 { 207 uint64_t reg; 208 int i, j, k; 209 210 i = 0; 211 while (n) { 212 uint64_t mask[4] = { 213 0x8000, 214 0x8000, 215 0x8000, 216 0x8000, 217 }; 218 219 k = n % 4; 220 k = k ? k : 4; 221 for (j = 0; j < k; j++) { 222 mask[j] = hwgrp[i + j] | (uint32_t)set << 12 | enable << 14; 223 if (bmp) { 224 enable ? plt_bitmap_set(bmp, hwgrp[i + j]) : 225 plt_bitmap_clear(bmp, hwgrp[i + j]); 226 } 227 plt_sso_dbg("HWS %d Linked to HWGRP %d", hws, 228 hwgrp[i + j]); 229 } 230 231 n -= j; 232 i += j; 233 reg = mask[0] | mask[1] << 16 | mask[2] << 32 | mask[3] << 48; 234 plt_write64(reg, base + SSOW_LF_GWS_GRPMSK_CHG); 235 } 236 } 237 238 static int 239 sso_hws_link_modify_af(struct dev *dev, uint8_t hws, struct plt_bitmap *bmp, uint16_t hwgrp[], 240 uint16_t n, uint8_t set, uint16_t enable) 241 { 242 struct mbox *mbox = mbox_get(dev->mbox); 243 struct ssow_chng_mship *req; 244 int rc, i; 245 246 req = mbox_alloc_msg_ssow_chng_mship(mbox); 247 if (req == NULL) { 248 rc = mbox_process(mbox); 249 if (rc) { 250 mbox_put(mbox); 251 return -EIO; 252 } 253 req = mbox_alloc_msg_ssow_chng_mship(mbox); 254 if (req == NULL) { 255 mbox_put(mbox); 256 return -ENOSPC; 257 } 258 } 259 req->enable = enable; 260 req->set = set; 261 req->hws = hws; 262 req->nb_hwgrps = n; 263 for (i = 0; i < n; i++) 264 req->hwgrps[i] = hwgrp[i]; 265 rc = mbox_process(mbox); 266 mbox_put(mbox); 267 if (rc == MBOX_MSG_INVALID) 268 return rc; 269 if (rc) 270 return -EIO; 271 272 for (i = 0; i < n; i++) 273 enable ? plt_bitmap_set(bmp, hwgrp[i]) : 274 plt_bitmap_clear(bmp, hwgrp[i]); 275 276 return 0; 277 } 278 279 static int 280 sso_msix_fill(struct roc_sso *roc_sso, uint16_t nb_hws, uint16_t nb_hwgrp) 281 { 282 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 283 struct msix_offset_rsp *rsp; 284 struct dev *dev = &sso->dev; 285 int i, rc; 286 287 mbox_alloc_msg_msix_offset(mbox_get(dev->mbox)); 288 rc = mbox_process_msg(dev->mbox, (void **)&rsp); 289 if (rc) { 290 rc = -EIO; 291 goto exit; 292 } 293 294 for (i = 0; i < nb_hws; i++) 295 sso->hws_msix_offset[i] = rsp->ssow_msixoff[i]; 296 for (i = 0; i < nb_hwgrp; i++) 297 sso->hwgrp_msix_offset[i] = rsp->sso_msixoff[i]; 298 299 rc = 0; 300 exit: 301 mbox_put(dev->mbox); 302 return rc; 303 } 304 305 /* Public Functions. */ 306 uintptr_t 307 roc_sso_hws_base_get(struct roc_sso *roc_sso, uint8_t hws) 308 { 309 struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev; 310 311 return dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 | hws << 12); 312 } 313 314 uintptr_t 315 roc_sso_hwgrp_base_get(struct roc_sso *roc_sso, uint16_t hwgrp) 316 { 317 struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev; 318 319 return dev->bar2 + (RVU_BLOCK_ADDR_SSO << 20 | hwgrp << 12); 320 } 321 322 uint64_t 323 roc_sso_ns_to_gw(uint64_t base, uint64_t ns) 324 { 325 uint64_t current_us; 326 327 current_us = plt_read64(base + SSOW_LF_GWS_NW_TIM); 328 /* From HRM, table 14-19: 329 * The SSOW_LF_GWS_NW_TIM[NW_TIM] period is specified in n-1 notation. 330 */ 331 current_us += 1; 332 333 /* From HRM, table 14-1: 334 * SSOW_LF_GWS_NW_TIM[NW_TIM] specifies the minimum timeout. The SSO 335 * hardware times out a GET_WORK request within 1 usec of the minimum 336 * timeout specified by SSOW_LF_GWS_NW_TIM[NW_TIM]. 337 */ 338 current_us += 1; 339 return PLT_MAX(1UL, (uint64_t)PLT_DIV_CEIL(ns, (current_us * 1E3))); 340 } 341 342 int 343 roc_sso_hws_link(struct roc_sso *roc_sso, uint8_t hws, uint16_t hwgrp[], uint16_t nb_hwgrp, 344 uint8_t set, bool use_mbox) 345 { 346 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 347 struct dev *dev = &sso->dev; 348 uintptr_t base; 349 int rc; 350 351 if (!nb_hwgrp) 352 return 0; 353 354 if (use_mbox && roc_model_is_cn10k()) { 355 rc = sso_hws_link_modify_af(dev, hws, sso->link_map[hws], hwgrp, nb_hwgrp, set, 1); 356 if (rc == MBOX_MSG_INVALID) 357 goto lf_access; 358 if (rc < 0) 359 return 0; 360 goto done; 361 } 362 lf_access: 363 base = dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 | hws << 12); 364 sso_hws_link_modify(hws, base, sso->link_map[hws], hwgrp, nb_hwgrp, set, 1); 365 done: 366 return nb_hwgrp; 367 } 368 369 int 370 roc_sso_hws_unlink(struct roc_sso *roc_sso, uint8_t hws, uint16_t hwgrp[], 371 uint16_t nb_hwgrp, uint8_t set, bool use_mbox) 372 { 373 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 374 struct dev *dev = &sso->dev; 375 uintptr_t base; 376 int rc; 377 378 if (!nb_hwgrp) 379 return 0; 380 381 if (use_mbox && roc_model_is_cn10k()) { 382 rc = sso_hws_link_modify_af(dev, hws, sso->link_map[hws], hwgrp, nb_hwgrp, set, 0); 383 if (rc == MBOX_MSG_INVALID) 384 goto lf_access; 385 if (rc < 0) 386 return 0; 387 goto done; 388 } 389 lf_access: 390 base = dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 | hws << 12); 391 sso_hws_link_modify(hws, base, sso->link_map[hws], hwgrp, nb_hwgrp, set, 0); 392 done: 393 return nb_hwgrp; 394 } 395 396 int 397 roc_sso_hws_stats_get(struct roc_sso *roc_sso, uint8_t hws, 398 struct roc_sso_hws_stats *stats) 399 { 400 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 401 struct sso_hws_stats *req_rsp; 402 struct dev *dev = &sso->dev; 403 struct mbox *mbox; 404 int rc; 405 406 mbox = mbox_get(dev->mbox); 407 req_rsp = (struct sso_hws_stats *)mbox_alloc_msg_sso_hws_get_stats( 408 mbox); 409 if (req_rsp == NULL) { 410 rc = mbox_process(mbox); 411 if (rc) { 412 rc = -EIO; 413 goto fail; 414 } 415 req_rsp = (struct sso_hws_stats *) 416 mbox_alloc_msg_sso_hws_get_stats(mbox); 417 if (req_rsp == NULL) { 418 rc = -ENOSPC; 419 goto fail; 420 } 421 } 422 req_rsp->hws = hws; 423 rc = mbox_process_msg(mbox, (void **)&req_rsp); 424 if (rc) { 425 rc = -EIO; 426 goto fail; 427 } 428 429 stats->arbitration = req_rsp->arbitration; 430 fail: 431 mbox_put(mbox); 432 return rc; 433 } 434 435 void 436 roc_sso_hws_gwc_invalidate(struct roc_sso *roc_sso, uint8_t *hws, 437 uint8_t nb_hws) 438 { 439 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 440 struct ssow_lf_inv_req *req; 441 struct dev *dev = &sso->dev; 442 struct mbox *mbox; 443 int i; 444 445 if (!nb_hws) 446 return; 447 448 mbox = mbox_get(dev->mbox); 449 req = mbox_alloc_msg_sso_ws_cache_inv(mbox); 450 if (req == NULL) { 451 mbox_process(mbox); 452 req = mbox_alloc_msg_sso_ws_cache_inv(mbox); 453 if (req == NULL) { 454 mbox_put(mbox); 455 return; 456 } 457 } 458 req->hdr.ver = SSOW_INVAL_SELECTIVE_VER; 459 req->nb_hws = nb_hws; 460 for (i = 0; i < nb_hws; i++) 461 req->hws[i] = hws[i]; 462 mbox_process(mbox); 463 mbox_put(mbox); 464 } 465 466 int 467 roc_sso_hwgrp_stats_get(struct roc_sso *roc_sso, uint8_t hwgrp, 468 struct roc_sso_hwgrp_stats *stats) 469 { 470 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 471 struct sso_grp_stats *req_rsp; 472 struct dev *dev = &sso->dev; 473 struct mbox *mbox; 474 int rc; 475 476 mbox = mbox_get(dev->mbox); 477 req_rsp = (struct sso_grp_stats *)mbox_alloc_msg_sso_grp_get_stats( 478 mbox); 479 if (req_rsp == NULL) { 480 rc = mbox_process(mbox); 481 if (rc) { 482 rc = -EIO; 483 goto fail; 484 } 485 req_rsp = (struct sso_grp_stats *) 486 mbox_alloc_msg_sso_grp_get_stats(mbox); 487 if (req_rsp == NULL) { 488 rc = -ENOSPC; 489 goto fail; 490 } 491 } 492 req_rsp->grp = hwgrp; 493 rc = mbox_process_msg(mbox, (void **)&req_rsp); 494 if (rc) { 495 rc = -EIO; 496 goto fail; 497 } 498 499 stats->aw_status = req_rsp->aw_status; 500 stats->dq_pc = req_rsp->dq_pc; 501 stats->ds_pc = req_rsp->ds_pc; 502 stats->ext_pc = req_rsp->ext_pc; 503 stats->page_cnt = req_rsp->page_cnt; 504 stats->ts_pc = req_rsp->ts_pc; 505 stats->wa_pc = req_rsp->wa_pc; 506 stats->ws_pc = req_rsp->ws_pc; 507 508 fail: 509 mbox_put(mbox); 510 return rc; 511 } 512 513 int 514 roc_sso_hwgrp_hws_link_status(struct roc_sso *roc_sso, uint8_t hws, 515 uint16_t hwgrp) 516 { 517 struct sso *sso; 518 519 sso = roc_sso_to_sso_priv(roc_sso); 520 return plt_bitmap_get(sso->link_map[hws], hwgrp); 521 } 522 523 int 524 roc_sso_hwgrp_qos_config(struct roc_sso *roc_sso, struct roc_sso_hwgrp_qos *qos, uint16_t nb_qos) 525 { 526 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 527 struct dev *dev = &sso->dev; 528 struct sso_grp_qos_cfg *req; 529 struct mbox *mbox; 530 int i, rc; 531 532 if (!nb_qos) 533 return 0; 534 535 mbox = mbox_get(dev->mbox); 536 for (i = 0; i < nb_qos; i++) { 537 uint8_t iaq_prcnt = qos[i].iaq_prcnt; 538 uint8_t taq_prcnt = qos[i].taq_prcnt; 539 540 req = mbox_alloc_msg_sso_grp_qos_config(mbox); 541 if (req == NULL) { 542 rc = mbox_process(mbox); 543 if (rc) { 544 rc = -EIO; 545 goto fail; 546 } 547 548 req = mbox_alloc_msg_sso_grp_qos_config(mbox); 549 if (req == NULL) { 550 rc = -ENOSPC; 551 goto fail; 552 } 553 } 554 req->grp = qos[i].hwgrp; 555 req->iaq_thr = (SSO_HWGRP_IAQ_MAX_THR_MASK * 556 (iaq_prcnt ? iaq_prcnt : 100)) / 557 100; 558 req->taq_thr = (SSO_HWGRP_TAQ_MAX_THR_MASK * 559 (taq_prcnt ? taq_prcnt : 100)) / 560 100; 561 } 562 563 rc = mbox_process(mbox); 564 if (rc) 565 rc = -EIO; 566 fail: 567 mbox_put(mbox); 568 return rc; 569 } 570 571 int 572 sso_hwgrp_init_xaq_aura(struct dev *dev, struct roc_sso_xaq_data *xaq, 573 uint32_t nb_xae, uint32_t xae_waes, 574 uint32_t xaq_buf_size, uint16_t nb_hwgrp) 575 { 576 struct npa_pool_s pool; 577 struct npa_aura_s aura; 578 plt_iova_t iova; 579 uint32_t i; 580 int rc; 581 582 if (xaq->mem != NULL) { 583 rc = sso_hwgrp_release_xaq(dev, nb_hwgrp); 584 if (rc < 0) { 585 plt_err("Failed to release XAQ %d", rc); 586 return rc; 587 } 588 roc_npa_pool_destroy(xaq->aura_handle); 589 plt_free(xaq->fc); 590 plt_free(xaq->mem); 591 memset(xaq, 0, sizeof(struct roc_sso_xaq_data)); 592 } 593 594 xaq->fc = plt_zmalloc(ROC_ALIGN, ROC_ALIGN); 595 if (xaq->fc == NULL) { 596 plt_err("Failed to allocate XAQ FC"); 597 rc = -ENOMEM; 598 goto fail; 599 } 600 601 xaq->nb_xae = nb_xae; 602 603 /** SSO will reserve up to 0x4 XAQ buffers per group when GetWork engine 604 * is inactive and it might prefetch an additional 0x3 buffers due to 605 * pipelining. 606 */ 607 xaq->nb_xaq = (SSO_XAQ_CACHE_CNT * nb_hwgrp); 608 xaq->nb_xaq += (SSO_XAQ_RSVD_CNT * nb_hwgrp); 609 xaq->nb_xaq += PLT_MAX(1 + ((xaq->nb_xae - 1) / xae_waes), xaq->nb_xaq); 610 xaq->nb_xaq += SSO_XAQ_SLACK; 611 612 xaq->mem = plt_zmalloc(xaq_buf_size * xaq->nb_xaq, xaq_buf_size); 613 if (xaq->mem == NULL) { 614 plt_err("Failed to allocate XAQ mem"); 615 rc = -ENOMEM; 616 goto free_fc; 617 } 618 619 memset(&pool, 0, sizeof(struct npa_pool_s)); 620 pool.nat_align = 1; 621 622 memset(&aura, 0, sizeof(aura)); 623 aura.fc_ena = 1; 624 aura.fc_addr = (uint64_t)xaq->fc; 625 aura.fc_hyst_bits = 0; /* Store count on all updates */ 626 rc = roc_npa_pool_create(&xaq->aura_handle, xaq_buf_size, xaq->nb_xaq, 627 &aura, &pool, 0); 628 if (rc) { 629 plt_err("Failed to create XAQ pool"); 630 goto npa_fail; 631 } 632 633 iova = (uint64_t)xaq->mem; 634 for (i = 0; i < xaq->nb_xaq; i++) { 635 roc_npa_aura_op_free(xaq->aura_handle, 0, iova); 636 iova += xaq_buf_size; 637 } 638 roc_npa_pool_op_range_set(xaq->aura_handle, (uint64_t)xaq->mem, iova); 639 640 if (roc_npa_aura_op_available_wait(xaq->aura_handle, xaq->nb_xaq, 0) != 641 xaq->nb_xaq) { 642 plt_err("Failed to free all pointers to the pool"); 643 rc = -ENOMEM; 644 goto npa_fill_fail; 645 } 646 647 /* When SW does addwork (enqueue) check if there is space in XAQ by 648 * comparing fc_addr above against the xaq_lmt calculated below. 649 * There should be a minimum headroom of 7 XAQs per HWGRP for SSO 650 * to request XAQ to cache them even before enqueue is called. 651 */ 652 xaq->xaq_lmt = xaq->nb_xaq - (nb_hwgrp * SSO_XAQ_CACHE_CNT) - SSO_XAQ_SLACK; 653 654 return 0; 655 npa_fill_fail: 656 roc_npa_pool_destroy(xaq->aura_handle); 657 npa_fail: 658 plt_free(xaq->mem); 659 free_fc: 660 plt_free(xaq->fc); 661 fail: 662 memset(xaq, 0, sizeof(struct roc_sso_xaq_data)); 663 return rc; 664 } 665 666 int 667 roc_sso_hwgrp_init_xaq_aura(struct roc_sso *roc_sso, uint32_t nb_xae) 668 { 669 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 670 struct dev *dev = &sso->dev; 671 int rc; 672 673 rc = sso_hwgrp_init_xaq_aura(dev, &roc_sso->xaq, nb_xae, 674 roc_sso->xae_waes, roc_sso->xaq_buf_size, 675 roc_sso->nb_hwgrp); 676 return rc; 677 } 678 679 int 680 sso_hwgrp_free_xaq_aura(struct dev *dev, struct roc_sso_xaq_data *xaq, 681 uint16_t nb_hwgrp) 682 { 683 int rc; 684 685 if (xaq->mem != NULL) { 686 if (nb_hwgrp) { 687 rc = sso_hwgrp_release_xaq(dev, nb_hwgrp); 688 if (rc < 0) { 689 plt_err("Failed to release XAQ %d", rc); 690 return rc; 691 } 692 } 693 roc_npa_pool_destroy(xaq->aura_handle); 694 plt_free(xaq->fc); 695 plt_free(xaq->mem); 696 } 697 memset(xaq, 0, sizeof(struct roc_sso_xaq_data)); 698 699 return 0; 700 } 701 702 int 703 roc_sso_hwgrp_free_xaq_aura(struct roc_sso *roc_sso, uint16_t nb_hwgrp) 704 { 705 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 706 struct dev *dev = &sso->dev; 707 int rc; 708 709 rc = sso_hwgrp_free_xaq_aura(dev, &roc_sso->xaq, nb_hwgrp); 710 return rc; 711 } 712 713 int 714 sso_hwgrp_alloc_xaq(struct dev *dev, uint32_t npa_aura_id, uint16_t hwgrps) 715 { 716 struct sso_hw_setconfig *req; 717 struct mbox *mbox = mbox_get(dev->mbox); 718 int rc = -ENOSPC; 719 720 req = mbox_alloc_msg_sso_hw_setconfig(mbox); 721 if (req == NULL) 722 goto exit; 723 req->npa_pf_func = idev_npa_pffunc_get(); 724 req->npa_aura_id = npa_aura_id; 725 req->hwgrps = hwgrps; 726 727 if (mbox_process(dev->mbox)) { 728 rc = -EIO; 729 goto exit; 730 } 731 732 rc = 0; 733 exit: 734 mbox_put(mbox); 735 return rc; 736 } 737 738 int 739 roc_sso_hwgrp_alloc_xaq(struct roc_sso *roc_sso, uint32_t npa_aura_id, 740 uint16_t hwgrps) 741 { 742 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 743 struct dev *dev = &sso->dev; 744 int rc; 745 746 rc = sso_hwgrp_alloc_xaq(dev, npa_aura_id, hwgrps); 747 return rc; 748 } 749 750 int 751 sso_hwgrp_release_xaq(struct dev *dev, uint16_t hwgrps) 752 { 753 struct sso_hw_xaq_release *req; 754 struct mbox *mbox = mbox_get(dev->mbox); 755 int rc; 756 757 req = mbox_alloc_msg_sso_hw_release_xaq_aura(mbox); 758 if (req == NULL) { 759 rc = -EINVAL; 760 goto exit; 761 } 762 req->hwgrps = hwgrps; 763 764 if (mbox_process(mbox)) { 765 rc = -EIO; 766 goto exit; 767 } 768 769 rc = 0; 770 exit: 771 mbox_put(mbox); 772 return rc; 773 } 774 775 int 776 roc_sso_hwgrp_release_xaq(struct roc_sso *roc_sso, uint16_t hwgrps) 777 { 778 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 779 struct dev *dev = &sso->dev; 780 int rc; 781 782 if (!hwgrps) 783 return 0; 784 785 rc = sso_hwgrp_release_xaq(dev, hwgrps); 786 return rc; 787 } 788 789 int 790 roc_sso_hwgrp_set_priority(struct roc_sso *roc_sso, uint16_t hwgrp, 791 uint8_t weight, uint8_t affinity, uint8_t priority) 792 { 793 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 794 struct dev *dev = &sso->dev; 795 struct sso_grp_priority *req; 796 struct mbox *mbox; 797 int rc = -ENOSPC; 798 799 mbox = mbox_get(dev->mbox); 800 req = mbox_alloc_msg_sso_grp_set_priority(mbox); 801 if (req == NULL) 802 goto fail; 803 req->grp = hwgrp; 804 req->weight = weight; 805 req->affinity = affinity; 806 req->priority = priority; 807 808 rc = mbox_process(mbox); 809 if (rc) { 810 rc = -EIO; 811 goto fail; 812 } 813 mbox_put(mbox); 814 plt_sso_dbg("HWGRP %d weight %d affinity %d priority %d", hwgrp, weight, 815 affinity, priority); 816 817 return 0; 818 fail: 819 mbox_put(mbox); 820 return rc; 821 } 822 823 static int 824 sso_update_msix_vec_count(struct roc_sso *roc_sso, uint16_t sso_vec_cnt) 825 { 826 struct plt_pci_device *pci_dev = roc_sso->pci_dev; 827 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 828 uint16_t mbox_vec_cnt, npa_vec_cnt; 829 struct dev *dev = &sso->dev; 830 struct idev_cfg *idev; 831 int rc; 832 833 idev = idev_get_cfg(); 834 if (idev == NULL) 835 return -ENODEV; 836 837 mbox_vec_cnt = RVU_PF_INT_VEC_AFPF_MBOX + 1; 838 839 /* Allocating vectors for the first time */ 840 if (plt_intr_max_intr_get(pci_dev->intr_handle) == 0) { 841 npa_vec_cnt = idev->npa_refcnt ? 0 : NPA_LF_INT_VEC_POISON + 1; 842 return dev_irq_reconfigure(pci_dev->intr_handle, mbox_vec_cnt + npa_vec_cnt); 843 } 844 845 npa_vec_cnt = (dev->npa.pci_dev == pci_dev) ? NPA_LF_INT_VEC_POISON + 1 : 0; 846 847 /* Re-configure to include SSO vectors */ 848 rc = dev_irq_reconfigure(pci_dev->intr_handle, mbox_vec_cnt + npa_vec_cnt + sso_vec_cnt); 849 if (rc) 850 return rc; 851 852 rc = dev_mbox_register_irq(pci_dev, dev); 853 if (rc) 854 return rc; 855 856 if (!dev_is_vf(dev)) { 857 rc = dev_vf_flr_register_irqs(pci_dev, dev); 858 if (rc) 859 return rc; 860 } 861 862 if (npa_vec_cnt) 863 rc = npa_register_irqs(&dev->npa); 864 865 return rc; 866 } 867 868 int 869 roc_sso_hwgrp_stash_config(struct roc_sso *roc_sso, struct roc_sso_hwgrp_stash *stash, 870 uint16_t nb_stash) 871 { 872 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 873 struct sso_grp_stash_cfg *req; 874 struct dev *dev = &sso->dev; 875 struct mbox *mbox; 876 int i, rc; 877 878 if (!nb_stash) 879 return 0; 880 881 mbox = mbox_get(dev->mbox); 882 for (i = 0; i < nb_stash; i++) { 883 req = mbox_alloc_msg_sso_grp_stash_config(mbox); 884 if (req == NULL) { 885 rc = mbox_process(mbox); 886 if (rc) { 887 rc = -EIO; 888 goto fail; 889 } 890 891 req = mbox_alloc_msg_sso_grp_stash_config(mbox); 892 if (req == NULL) { 893 rc = -ENOSPC; 894 goto fail; 895 } 896 } 897 req->ena = true; 898 req->grp = stash[i].hwgrp; 899 req->offset = stash[i].stash_offset; 900 req->num_linesm1 = stash[i].stash_count - 1; 901 } 902 903 rc = mbox_process(mbox); 904 if (rc) 905 rc = -EIO; 906 fail: 907 mbox_put(mbox); 908 return rc; 909 } 910 911 int 912 roc_sso_rsrc_init(struct roc_sso *roc_sso, uint8_t nb_hws, uint16_t nb_hwgrp, uint16_t nb_tim_lfs) 913 { 914 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 915 struct sso_lf_alloc_rsp *rsp_hwgrp; 916 uint16_t sso_vec_cnt, free_tim_lfs; 917 int rc; 918 919 if (!nb_hwgrp || roc_sso->max_hwgrp < nb_hwgrp) 920 return -ENOENT; 921 if (!nb_hws || roc_sso->max_hws < nb_hws) 922 return -ENOENT; 923 924 rc = sso_rsrc_attach(roc_sso, SSO_LF_TYPE_HWS, nb_hws); 925 if (rc < 0) { 926 plt_err("Unable to attach SSO HWS LFs"); 927 goto fail; 928 } 929 930 rc = sso_rsrc_attach(roc_sso, SSO_LF_TYPE_HWGRP, nb_hwgrp); 931 if (rc < 0) { 932 plt_err("Unable to attach SSO HWGRP LFs"); 933 goto hwgrp_atch_fail; 934 } 935 936 rc = sso_lf_alloc(&sso->dev, SSO_LF_TYPE_HWS, nb_hws, NULL); 937 if (rc < 0) { 938 plt_err("Unable to alloc SSO HWS LFs"); 939 goto hws_alloc_fail; 940 } 941 942 rc = sso_lf_alloc(&sso->dev, SSO_LF_TYPE_HWGRP, nb_hwgrp, 943 (void **)&rsp_hwgrp); 944 if (rc < 0) { 945 plt_err("Unable to alloc SSO HWGRP Lfs"); 946 goto hwgrp_alloc_fail; 947 } 948 949 roc_sso->xaq_buf_size = rsp_hwgrp->xaq_buf_size; 950 roc_sso->xae_waes = rsp_hwgrp->xaq_wq_entries; 951 roc_sso->iue = rsp_hwgrp->in_unit_entries; 952 953 rc = sso_msix_fill(roc_sso, nb_hws, nb_hwgrp); 954 if (rc < 0) { 955 plt_err("Unable to get MSIX offsets for SSO LFs"); 956 goto sso_msix_fail; 957 } 958 959 /* 1 error interrupt per SSO HWS/HWGRP */ 960 sso_vec_cnt = nb_hws + nb_hwgrp; 961 962 if (sso->dev.roc_tim) { 963 nb_tim_lfs = ((struct roc_tim *)sso->dev.roc_tim)->nb_lfs; 964 } else { 965 rc = tim_free_lf_count_get(&sso->dev, &free_tim_lfs); 966 if (rc < 0) { 967 plt_err("Failed to get TIM resource count"); 968 goto sso_msix_fail; 969 } 970 971 nb_tim_lfs = PLT_MIN(nb_tim_lfs, free_tim_lfs); 972 } 973 974 /* 2 error interrupt per TIM LF */ 975 sso_vec_cnt += 2 * nb_tim_lfs; 976 977 rc = sso_update_msix_vec_count(roc_sso, sso_vec_cnt); 978 if (rc < 0) { 979 plt_err("Failed to update SSO MSIX vector count"); 980 goto sso_msix_fail; 981 } 982 983 rc = sso_register_irqs_priv(roc_sso, sso->pci_dev->intr_handle, nb_hws, 984 nb_hwgrp); 985 if (rc < 0) { 986 plt_err("Failed to register SSO LF IRQs"); 987 goto sso_msix_fail; 988 } 989 990 roc_sso->nb_hwgrp = nb_hwgrp; 991 roc_sso->nb_hws = nb_hws; 992 993 return 0; 994 sso_msix_fail: 995 sso_lf_free(&sso->dev, SSO_LF_TYPE_HWGRP, nb_hwgrp); 996 hwgrp_alloc_fail: 997 sso_lf_free(&sso->dev, SSO_LF_TYPE_HWS, nb_hws); 998 hws_alloc_fail: 999 sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWGRP); 1000 hwgrp_atch_fail: 1001 sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWS); 1002 fail: 1003 return rc; 1004 } 1005 1006 void 1007 roc_sso_rsrc_fini(struct roc_sso *roc_sso) 1008 { 1009 struct sso *sso = roc_sso_to_sso_priv(roc_sso); 1010 1011 if (!roc_sso->nb_hws && !roc_sso->nb_hwgrp) 1012 return; 1013 1014 sso_unregister_irqs_priv(roc_sso, sso->pci_dev->intr_handle, 1015 roc_sso->nb_hws, roc_sso->nb_hwgrp); 1016 sso_lf_free(&sso->dev, SSO_LF_TYPE_HWS, roc_sso->nb_hws); 1017 sso_lf_free(&sso->dev, SSO_LF_TYPE_HWGRP, roc_sso->nb_hwgrp); 1018 1019 sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWS); 1020 sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWGRP); 1021 1022 roc_sso->nb_hwgrp = 0; 1023 roc_sso->nb_hws = 0; 1024 } 1025 1026 int 1027 roc_sso_dev_init(struct roc_sso *roc_sso) 1028 { 1029 struct plt_pci_device *pci_dev; 1030 uint32_t link_map_sz; 1031 struct sso *sso; 1032 void *link_mem; 1033 int i, rc; 1034 1035 if (roc_sso == NULL || roc_sso->pci_dev == NULL) 1036 return SSO_ERR_PARAM; 1037 1038 PLT_STATIC_ASSERT(sizeof(struct sso) <= ROC_SSO_MEM_SZ); 1039 sso = roc_sso_to_sso_priv(roc_sso); 1040 memset(sso, 0, sizeof(*sso)); 1041 pci_dev = roc_sso->pci_dev; 1042 1043 rc = sso_update_msix_vec_count(roc_sso, 0); 1044 if (rc < 0) { 1045 plt_err("Failed to set SSO MSIX vector count"); 1046 return rc; 1047 } 1048 1049 rc = dev_init(&sso->dev, pci_dev); 1050 if (rc < 0) { 1051 plt_err("Failed to init roc device"); 1052 goto fail; 1053 } 1054 1055 rc = sso_rsrc_get(roc_sso); 1056 if (rc < 0) { 1057 plt_err("Failed to get SSO resources"); 1058 goto rsrc_fail; 1059 } 1060 rc = -ENOMEM; 1061 1062 if (roc_sso->max_hws) { 1063 sso->link_map = plt_zmalloc( 1064 sizeof(struct plt_bitmap *) * roc_sso->max_hws, 0); 1065 if (sso->link_map == NULL) { 1066 plt_err("Failed to allocate memory for link_map array"); 1067 goto rsrc_fail; 1068 } 1069 1070 link_map_sz = 1071 plt_bitmap_get_memory_footprint(roc_sso->max_hwgrp); 1072 sso->link_map_mem = 1073 plt_zmalloc(link_map_sz * roc_sso->max_hws, 0); 1074 if (sso->link_map_mem == NULL) { 1075 plt_err("Failed to get link_map memory"); 1076 goto rsrc_fail; 1077 } 1078 1079 link_mem = sso->link_map_mem; 1080 1081 for (i = 0; i < roc_sso->max_hws; i++) { 1082 sso->link_map[i] = plt_bitmap_init( 1083 roc_sso->max_hwgrp, link_mem, link_map_sz); 1084 if (sso->link_map[i] == NULL) { 1085 plt_err("Failed to allocate link map"); 1086 goto link_mem_free; 1087 } 1088 link_mem = PLT_PTR_ADD(link_mem, link_map_sz); 1089 } 1090 } 1091 idev_sso_pffunc_set(sso->dev.pf_func); 1092 idev_sso_set(roc_sso); 1093 sso->pci_dev = pci_dev; 1094 sso->dev.drv_inited = true; 1095 roc_sso->lmt_base = sso->dev.lmt_base; 1096 1097 return 0; 1098 link_mem_free: 1099 plt_free(sso->link_map_mem); 1100 rsrc_fail: 1101 rc |= dev_fini(&sso->dev, pci_dev); 1102 fail: 1103 return rc; 1104 } 1105 1106 int 1107 roc_sso_dev_fini(struct roc_sso *roc_sso) 1108 { 1109 struct sso *sso; 1110 1111 sso = roc_sso_to_sso_priv(roc_sso); 1112 sso->dev.drv_inited = false; 1113 1114 return dev_fini(&sso->dev, sso->pci_dev); 1115 } 1116