drivers/common/cnxk/roc_sso.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 /* Private functions. */
   9 int
  10 sso_lf_alloc(struct dev *dev, enum sso_lf_type lf_type, uint16_t nb_lf,
  11              void **rsp)
  12 {
  13         int rc = -ENOSPC;
  14
  15         switch (lf_type) {
  16         case SSO_LF_TYPE_HWS: {
  17                 struct ssow_lf_alloc_req *req;
  18
  19                 req = mbox_alloc_msg_ssow_lf_alloc(dev->mbox);
  20                 if (req == NULL)
  21                         return rc;
  22                 req->hws = nb_lf;
  23         } break;
  24         case SSO_LF_TYPE_HWGRP: {
  25                 struct sso_lf_alloc_req *req;
  26
  27                 req = mbox_alloc_msg_sso_lf_alloc(dev->mbox);
  28                 if (req == NULL)
  29                         return rc;
  30                 req->hwgrps = nb_lf;
  31         } break;
  32         default:
  33                 break;
  34         }
  35
  36         rc = mbox_process_msg(dev->mbox, rsp);
  37         if (rc < 0)
  38                 return rc;
  39
  40         return 0;
  41 }
  42
  43 int
  44 sso_lf_free(struct dev *dev, enum sso_lf_type lf_type, uint16_t nb_lf)
  45 {
  46         int rc = -ENOSPC;
  47
  48         switch (lf_type) {
  49         case SSO_LF_TYPE_HWS: {
  50                 struct ssow_lf_free_req *req;
  51
  52                 req = mbox_alloc_msg_ssow_lf_free(dev->mbox);
  53                 if (req == NULL)
  54                         return rc;
  55                 req->hws = nb_lf;
  56         } break;
  57         case SSO_LF_TYPE_HWGRP: {
  58                 struct sso_lf_free_req *req;
  59
  60                 req = mbox_alloc_msg_sso_lf_free(dev->mbox);
  61                 if (req == NULL)
  62                         return rc;
  63                 req->hwgrps = nb_lf;
  64         } break;
  65         default:
  66                 break;
  67         }
  68
  69         rc = mbox_process(dev->mbox);
  70         if (rc < 0)
  71                 return rc;
  72
  73         return 0;
  74 }
  75
  76 static int
  77 sso_rsrc_attach(struct roc_sso *roc_sso, enum sso_lf_type lf_type,
  78                 uint16_t nb_lf)
  79 {
  80         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
  81         struct rsrc_attach_req *req;
  82         int rc = -ENOSPC;
  83
  84         req = mbox_alloc_msg_attach_resources(dev->mbox);
  85         if (req == NULL)
  86                 return rc;
  87         switch (lf_type) {
  88         case SSO_LF_TYPE_HWS:
  89                 req->ssow = nb_lf;
  90                 break;
  91         case SSO_LF_TYPE_HWGRP:
  92                 req->sso = nb_lf;
  93                 break;
  94         default:
  95                 return SSO_ERR_PARAM;
  96         }
  97
  98         req->modify = true;
  99         if (mbox_process(dev->mbox) < 0)
 100                 return -EIO;
 101
 102         return 0;
 103 }
 104
 105 static int
 106 sso_rsrc_detach(struct roc_sso *roc_sso, enum sso_lf_type lf_type)
 107 {
 108         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 109         struct rsrc_detach_req *req;
 110         int rc = -ENOSPC;
 111
 112         req = mbox_alloc_msg_detach_resources(dev->mbox);
 113         if (req == NULL)
 114                 return rc;
 115         switch (lf_type) {
 116         case SSO_LF_TYPE_HWS:
 117                 req->ssow = true;
 118                 break;
 119         case SSO_LF_TYPE_HWGRP:
 120                 req->sso = true;
 121                 break;
 122         default:
 123                 return SSO_ERR_PARAM;
 124         }
 125
 126         req->partial = true;
 127         if (mbox_process(dev->mbox) < 0)
 128                 return -EIO;
 129
 130         return 0;
 131 }
 132
 133 static int
 134 sso_rsrc_get(struct roc_sso *roc_sso)
 135 {
 136         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 137         struct free_rsrcs_rsp *rsrc_cnt;
 138         int rc;
 139
 140         mbox_alloc_msg_free_rsrc_cnt(dev->mbox);
 141         rc = mbox_process_msg(dev->mbox, (void **)&rsrc_cnt);
 142         if (rc < 0) {
 143                 plt_err("Failed to get free resource count\n");
 144                 return rc;
 145         }
 146
 147         roc_sso->max_hwgrp = rsrc_cnt->sso;
 148         roc_sso->max_hws = rsrc_cnt->ssow;
 149
 150         return 0;
 151 }
 152
 153 void
 154 sso_hws_link_modify(uint8_t hws, uintptr_t base, struct plt_bitmap *bmp,
 155                     uint16_t hwgrp[], uint16_t n, uint16_t enable)
 156 {
 157         uint64_t reg;
 158         int i, j, k;
 159
 160         i = 0;
 161         while (n) {
 162                 uint64_t mask[4] = {
 163                         0x8000,
 164                         0x8000,
 165                         0x8000,
 166                         0x8000,
 167                 };
 168
 169                 k = n % 4;
 170                 k = k ? k : 4;
 171                 for (j = 0; j < k; j++) {
 172                         mask[j] = hwgrp[i + j] | enable << 14;
 173                         if (bmp) {
 174                                 enable ? plt_bitmap_set(bmp, hwgrp[i + j]) :
 175                                          plt_bitmap_clear(bmp, hwgrp[i + j]);
 176                         }
 177                         plt_sso_dbg("HWS %d Linked to HWGRP %d", hws,
 178                                     hwgrp[i + j]);
 179                 }
 180
 181                 n -= j;
 182                 i += j;
 183                 reg = mask[0] | mask[1] << 16 | mask[2] << 32 | mask[3] << 48;
 184                 plt_write64(reg, base + SSOW_LF_GWS_GRPMSK_CHG);
 185         }
 186 }
 187
 188 static int
 189 sso_msix_fill(struct roc_sso *roc_sso, uint16_t nb_hws, uint16_t nb_hwgrp)
 190 {
 191         struct sso *sso = roc_sso_to_sso_priv(roc_sso);
 192         struct msix_offset_rsp *rsp;
 193         struct dev *dev = &sso->dev;
 194         int i, rc;
 195
 196         mbox_alloc_msg_msix_offset(dev->mbox);
 197         rc = mbox_process_msg(dev->mbox, (void **)&rsp);
 198         if (rc < 0)
 199                 return rc;
 200
 201         for (i = 0; i < nb_hws; i++)
 202                 sso->hws_msix_offset[i] = rsp->ssow_msixoff[i];
 203         for (i = 0; i < nb_hwgrp; i++)
 204                 sso->hwgrp_msix_offset[i] = rsp->sso_msixoff[i];
 205
 206         return 0;
 207 }
 208
 209 /* Public Functions. */
 210 uintptr_t
 211 roc_sso_hws_base_get(struct roc_sso *roc_sso, uint8_t hws)
 212 {
 213         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 214
 215         return dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 | hws << 12);
 216 }
 217
 218 uintptr_t
 219 roc_sso_hwgrp_base_get(struct roc_sso *roc_sso, uint16_t hwgrp)
 220 {
 221         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 222
 223         return dev->bar2 + (RVU_BLOCK_ADDR_SSO << 20 | hwgrp << 12);
 224 }
 225
 226 uint64_t
 227 roc_sso_ns_to_gw(struct roc_sso *roc_sso, uint64_t ns)
 228 {
 229         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 230         uint64_t current_us, current_ns, new_ns;
 231         uintptr_t base;
 232
 233         base = dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20);
 234         current_us = plt_read64(base + SSOW_LF_GWS_NW_TIM);
 235         /* From HRM, table 14-19:
 236          * The SSOW_LF_GWS_NW_TIM[NW_TIM] period is specified in n-1 notation.
 237          */
 238         current_us += 1;
 239
 240         /* From HRM, table 14-1:
 241          * SSOW_LF_GWS_NW_TIM[NW_TIM] specifies the minimum timeout. The SSO
 242          * hardware times out a GET_WORK request within 2 usec of the minimum
 243          * timeout specified by SSOW_LF_GWS_NW_TIM[NW_TIM].
 244          */
 245         current_us += 2;
 246         current_ns = current_us * 1E3;
 247         new_ns = (ns - PLT_MIN(ns, current_ns));
 248         new_ns = !new_ns ? 1 : new_ns;
 249         return (new_ns * plt_tsc_hz()) / 1E9;
 250 }
 251
 252 int
 253 roc_sso_hws_link(struct roc_sso *roc_sso, uint8_t hws, uint16_t hwgrp[],
 254                  uint16_t nb_hwgrp)
 255 {
 256         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 257         struct sso *sso;
 258         uintptr_t base;
 259
 260         sso = roc_sso_to_sso_priv(roc_sso);
 261         base = dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 | hws << 12);
 262         sso_hws_link_modify(hws, base, sso->link_map[hws], hwgrp, nb_hwgrp, 1);
 263
 264         return nb_hwgrp;
 265 }
 266
 267 int
 268 roc_sso_hws_unlink(struct roc_sso *roc_sso, uint8_t hws, uint16_t hwgrp[],
 269                    uint16_t nb_hwgrp)
 270 {
 271         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 272         struct sso *sso;
 273         uintptr_t base;
 274
 275         sso = roc_sso_to_sso_priv(roc_sso);
 276         base = dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 | hws << 12);
 277         sso_hws_link_modify(hws, base, sso->link_map[hws], hwgrp, nb_hwgrp, 0);
 278
 279         return nb_hwgrp;
 280 }
 281
 282 int
 283 roc_sso_hws_stats_get(struct roc_sso *roc_sso, uint8_t hws,
 284                       struct roc_sso_hws_stats *stats)
 285 {
 286         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 287         struct sso_hws_stats *req_rsp;
 288         int rc;
 289
 290         req_rsp = (struct sso_hws_stats *)mbox_alloc_msg_sso_hws_get_stats(
 291                 dev->mbox);
 292         if (req_rsp == NULL) {
 293                 rc = mbox_process(dev->mbox);
 294                 if (rc < 0)
 295                         return rc;
 296                 req_rsp = (struct sso_hws_stats *)
 297                         mbox_alloc_msg_sso_hws_get_stats(dev->mbox);
 298                 if (req_rsp == NULL)
 299                         return -ENOSPC;
 300         }
 301         req_rsp->hws = hws;
 302         rc = mbox_process_msg(dev->mbox, (void **)&req_rsp);
 303         if (rc)
 304                 return rc;
 305
 306         stats->arbitration = req_rsp->arbitration;
 307         return 0;
 308 }
 309
 310 int
 311 roc_sso_hwgrp_stats_get(struct roc_sso *roc_sso, uint8_t hwgrp,
 312                         struct roc_sso_hwgrp_stats *stats)
 313 {
 314         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 315         struct sso_grp_stats *req_rsp;
 316         int rc;
 317
 318         req_rsp = (struct sso_grp_stats *)mbox_alloc_msg_sso_grp_get_stats(
 319                 dev->mbox);
 320         if (req_rsp == NULL) {
 321                 rc = mbox_process(dev->mbox);
 322                 if (rc < 0)
 323                         return rc;
 324                 req_rsp = (struct sso_grp_stats *)
 325                         mbox_alloc_msg_sso_grp_get_stats(dev->mbox);
 326                 if (req_rsp == NULL)
 327                         return -ENOSPC;
 328         }
 329         req_rsp->grp = hwgrp;
 330         rc = mbox_process_msg(dev->mbox, (void **)&req_rsp);
 331         if (rc)
 332                 return rc;
 333
 334         stats->aw_status = req_rsp->aw_status;
 335         stats->dq_pc = req_rsp->dq_pc;
 336         stats->ds_pc = req_rsp->ds_pc;
 337         stats->ext_pc = req_rsp->ext_pc;
 338         stats->page_cnt = req_rsp->page_cnt;
 339         stats->ts_pc = req_rsp->ts_pc;
 340         stats->wa_pc = req_rsp->wa_pc;
 341         stats->ws_pc = req_rsp->ws_pc;
 342         return 0;
 343 }
 344
 345 int
 346 roc_sso_hwgrp_hws_link_status(struct roc_sso *roc_sso, uint8_t hws,
 347                               uint16_t hwgrp)
 348 {
 349         struct sso *sso;
 350
 351         sso = roc_sso_to_sso_priv(roc_sso);
 352         return plt_bitmap_get(sso->link_map[hws], hwgrp);
 353 }
 354
 355 int
 356 roc_sso_hwgrp_qos_config(struct roc_sso *roc_sso, struct roc_sso_hwgrp_qos *qos,
 357                          uint8_t nb_qos, uint32_t nb_xaq)
 358 {
 359         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 360         struct sso_grp_qos_cfg *req;
 361         int i, rc;
 362
 363         for (i = 0; i < nb_qos; i++) {
 364                 uint8_t xaq_prcnt = qos[i].xaq_prcnt;
 365                 uint8_t iaq_prcnt = qos[i].iaq_prcnt;
 366                 uint8_t taq_prcnt = qos[i].taq_prcnt;
 367
 368                 req = mbox_alloc_msg_sso_grp_qos_config(dev->mbox);
 369                 if (req == NULL) {
 370                         rc = mbox_process(dev->mbox);
 371                         if (rc < 0)
 372                                 return rc;
 373                         req = mbox_alloc_msg_sso_grp_qos_config(dev->mbox);
 374                         if (req == NULL)
 375                                 return -ENOSPC;
 376                 }
 377                 req->grp = qos[i].hwgrp;
 378                 req->xaq_limit = (nb_xaq * (xaq_prcnt ? xaq_prcnt : 100)) / 100;
 379                 req->taq_thr = (SSO_HWGRP_IAQ_MAX_THR_MASK *
 380                                 (iaq_prcnt ? iaq_prcnt : 100)) /
 381                                100;
 382                 req->iaq_thr = (SSO_HWGRP_TAQ_MAX_THR_MASK *
 383                                 (taq_prcnt ? taq_prcnt : 100)) /
 384                                100;
 385         }
 386
 387         return mbox_process(dev->mbox);
 388 }
 389
 390 int
 391 sso_hwgrp_alloc_xaq(struct dev *dev, uint32_t npa_aura_id, uint16_t hwgrps)
 392 {
 393         struct sso_hw_setconfig *req;
 394         int rc = -ENOSPC;
 395
 396         req = mbox_alloc_msg_sso_hw_setconfig(dev->mbox);
 397         if (req == NULL)
 398                 return rc;
 399         req->npa_pf_func = idev_npa_pffunc_get();
 400         req->npa_aura_id = npa_aura_id;
 401         req->hwgrps = hwgrps;
 402
 403         return mbox_process(dev->mbox);
 404 }
 405
 406 int
 407 roc_sso_hwgrp_alloc_xaq(struct roc_sso *roc_sso, uint32_t npa_aura_id,
 408                         uint16_t hwgrps)
 409 {
 410         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 411
 412         return sso_hwgrp_alloc_xaq(dev, npa_aura_id, hwgrps);
 413 }
 414
 415 int
 416 sso_hwgrp_release_xaq(struct dev *dev, uint16_t hwgrps)
 417 {
 418         struct sso_hw_xaq_release *req;
 419
 420         req = mbox_alloc_msg_sso_hw_release_xaq_aura(dev->mbox);
 421         if (req == NULL)
 422                 return -EINVAL;
 423         req->hwgrps = hwgrps;
 424
 425         return mbox_process(dev->mbox);
 426 }
 427
 428 int
 429 roc_sso_hwgrp_release_xaq(struct roc_sso *roc_sso, uint16_t hwgrps)
 430 {
 431         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 432
 433         return sso_hwgrp_release_xaq(dev, hwgrps);
 434 }
 435
 436 int
 437 roc_sso_hwgrp_set_priority(struct roc_sso *roc_sso, uint16_t hwgrp,
 438                            uint8_t weight, uint8_t affinity, uint8_t priority)
 439 {
 440         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 441         struct sso_grp_priority *req;
 442         int rc = -ENOSPC;
 443
 444         req = mbox_alloc_msg_sso_grp_set_priority(dev->mbox);
 445         if (req == NULL)
 446                 return rc;
 447         req->grp = hwgrp;
 448         req->weight = weight;
 449         req->affinity = affinity;
 450         req->priority = priority;
 451
 452         rc = mbox_process(dev->mbox);
 453         if (rc < 0)
 454                 return rc;
 455         plt_sso_dbg("HWGRP %d weight %d affinity %d priority %d", hwgrp, weight,
 456                     affinity, priority);
 457
 458         return 0;
 459 }
 460
 461 int
 462 roc_sso_rsrc_init(struct roc_sso *roc_sso, uint8_t nb_hws, uint16_t nb_hwgrp)
 463 {
 464         struct sso *sso = roc_sso_to_sso_priv(roc_sso);
 465         struct sso_lf_alloc_rsp *rsp_hwgrp;
 466         int rc;
 467
 468         if (roc_sso->max_hwgrp < nb_hwgrp)
 469                 return -ENOENT;
 470         if (roc_sso->max_hws < nb_hws)
 471                 return -ENOENT;
 472
 473         rc = sso_rsrc_attach(roc_sso, SSO_LF_TYPE_HWS, nb_hws);
 474         if (rc < 0) {
 475                 plt_err("Unable to attach SSO HWS LFs");
 476                 return rc;
 477         }
 478
 479         rc = sso_rsrc_attach(roc_sso, SSO_LF_TYPE_HWGRP, nb_hwgrp);
 480         if (rc < 0) {
 481                 plt_err("Unable to attach SSO HWGRP LFs");
 482                 goto hwgrp_atch_fail;
 483         }
 484
 485         rc = sso_lf_alloc(&sso->dev, SSO_LF_TYPE_HWS, nb_hws, NULL);
 486         if (rc < 0) {
 487                 plt_err("Unable to alloc SSO HWS LFs");
 488                 goto hws_alloc_fail;
 489         }
 490
 491         rc = sso_lf_alloc(&sso->dev, SSO_LF_TYPE_HWGRP, nb_hwgrp,
 492                           (void **)&rsp_hwgrp);
 493         if (rc < 0) {
 494                 plt_err("Unable to alloc SSO HWGRP Lfs");
 495                 goto hwgrp_alloc_fail;
 496         }
 497
 498         roc_sso->xaq_buf_size = rsp_hwgrp->xaq_buf_size;
 499         roc_sso->xae_waes = rsp_hwgrp->xaq_wq_entries;
 500         roc_sso->iue = rsp_hwgrp->in_unit_entries;
 501
 502         rc = sso_msix_fill(roc_sso, nb_hws, nb_hwgrp);
 503         if (rc < 0) {
 504                 plt_err("Unable to get MSIX offsets for SSO LFs");
 505                 goto sso_msix_fail;
 506         }
 507
 508         rc = sso_register_irqs_priv(roc_sso, sso->pci_dev->intr_handle, nb_hws,
 509                                     nb_hwgrp);
 510         if (rc < 0) {
 511                 plt_err("Failed to register SSO LF IRQs");
 512                 goto sso_msix_fail;
 513         }
 514
 515         roc_sso->nb_hwgrp = nb_hwgrp;
 516         roc_sso->nb_hws = nb_hws;
 517
 518         return 0;
 519 sso_msix_fail:
 520         sso_lf_free(&sso->dev, SSO_LF_TYPE_HWGRP, nb_hwgrp);
 521 hwgrp_alloc_fail:
 522         sso_lf_free(&sso->dev, SSO_LF_TYPE_HWS, nb_hws);
 523 hws_alloc_fail:
 524         sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWGRP);
 525 hwgrp_atch_fail:
 526         sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWS);
 527         return rc;
 528 }
 529
 530 void
 531 roc_sso_rsrc_fini(struct roc_sso *roc_sso)
 532 {
 533         struct sso *sso = roc_sso_to_sso_priv(roc_sso);
 534
 535         if (!roc_sso->nb_hws && !roc_sso->nb_hwgrp)
 536                 return;
 537
 538         sso_unregister_irqs_priv(roc_sso, sso->pci_dev->intr_handle,
 539                                  roc_sso->nb_hws, roc_sso->nb_hwgrp);
 540         sso_lf_free(&sso->dev, SSO_LF_TYPE_HWS, roc_sso->nb_hws);
 541         sso_lf_free(&sso->dev, SSO_LF_TYPE_HWGRP, roc_sso->nb_hwgrp);
 542
 543         sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWS);
 544         sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWGRP);
 545
 546         roc_sso->nb_hwgrp = 0;
 547         roc_sso->nb_hws = 0;
 548 }
 549
 550 int
 551 roc_sso_dev_init(struct roc_sso *roc_sso)
 552 {
 553         struct plt_pci_device *pci_dev;
 554         uint32_t link_map_sz;
 555         struct sso *sso;
 556         void *link_mem;
 557         int i, rc;
 558
 559         if (roc_sso == NULL || roc_sso->pci_dev == NULL)
 560                 return SSO_ERR_PARAM;
 561
 562         PLT_STATIC_ASSERT(sizeof(struct sso) <= ROC_SSO_MEM_SZ);
 563         sso = roc_sso_to_sso_priv(roc_sso);
 564         memset(sso, 0, sizeof(*sso));
 565         pci_dev = roc_sso->pci_dev;
 566
 567         rc = dev_init(&sso->dev, pci_dev);
 568         if (rc < 0) {
 569                 plt_err("Failed to init roc device");
 570                 goto fail;
 571         }
 572
 573         rc = sso_rsrc_get(roc_sso);
 574         if (rc < 0) {
 575                 plt_err("Failed to get SSO resources");
 576                 goto rsrc_fail;
 577         }
 578         rc = -ENOMEM;
 579
 580         sso->link_map =
 581                 plt_zmalloc(sizeof(struct plt_bitmap *) * roc_sso->max_hws, 0);
 582         if (sso->link_map == NULL) {
 583                 plt_err("Failed to allocate memory for link_map array");
 584                 goto rsrc_fail;
 585         }
 586
 587         link_map_sz = plt_bitmap_get_memory_footprint(roc_sso->max_hwgrp);
 588         sso->link_map_mem = plt_zmalloc(link_map_sz * roc_sso->max_hws, 0);
 589         if (sso->link_map_mem == NULL) {
 590                 plt_err("Failed to get link_map memory");
 591                 goto rsrc_fail;
 592         }
 593
 594         link_mem = sso->link_map_mem;
 595         for (i = 0; i < roc_sso->max_hws; i++) {
 596                 sso->link_map[i] = plt_bitmap_init(roc_sso->max_hwgrp, link_mem,
 597                                                    link_map_sz);
 598                 if (sso->link_map[i] == NULL) {
 599                         plt_err("Failed to allocate link map");
 600                         goto link_mem_free;
 601                 }
 602                 link_mem = PLT_PTR_ADD(link_mem, link_map_sz);
 603         }
 604         idev_sso_pffunc_set(sso->dev.pf_func);
 605         sso->pci_dev = pci_dev;
 606         sso->dev.drv_inited = true;
 607         roc_sso->lmt_base = sso->dev.lmt_base;
 608
 609         return 0;
 610 link_mem_free:
 611         plt_free(sso->link_map_mem);
 612 rsrc_fail:
 613         rc |= dev_fini(&sso->dev, pci_dev);
 614 fail:
 615         return rc;
 616 }
 617
 618 int
 619 roc_sso_dev_fini(struct roc_sso *roc_sso)
 620 {
 621         struct sso *sso;
 622
 623         sso = roc_sso_to_sso_priv(roc_sso);
 624         sso->dev.drv_inited = false;
 625
 626         return dev_fini(&sso->dev, sso->pci_dev);
 627 }