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 static int
  10 sso_lf_alloc(struct roc_sso *roc_sso, enum sso_lf_type lf_type, uint16_t nb_lf,
  11              void **rsp)
  12 {
  13         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
  14         int rc = -ENOSPC;
  15
  16         switch (lf_type) {
  17         case SSO_LF_TYPE_HWS: {
  18                 struct ssow_lf_alloc_req *req;
  19
  20                 req = mbox_alloc_msg_ssow_lf_alloc(dev->mbox);
  21                 if (req == NULL)
  22                         return rc;
  23                 req->hws = nb_lf;
  24         } break;
  25         case SSO_LF_TYPE_HWGRP: {
  26                 struct sso_lf_alloc_req *req;
  27
  28                 req = mbox_alloc_msg_sso_lf_alloc(dev->mbox);
  29                 if (req == NULL)
  30                         return rc;
  31                 req->hwgrps = nb_lf;
  32         } break;
  33         default:
  34                 break;
  35         }
  36
  37         rc = mbox_process_msg(dev->mbox, rsp);
  38         if (rc < 0)
  39                 return rc;
  40
  41         return 0;
  42 }
  43
  44 static int
  45 sso_lf_free(struct roc_sso *roc_sso, enum sso_lf_type lf_type, uint16_t nb_lf)
  46 {
  47         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
  48         int rc = -ENOSPC;
  49
  50         switch (lf_type) {
  51         case SSO_LF_TYPE_HWS: {
  52                 struct ssow_lf_free_req *req;
  53
  54                 req = mbox_alloc_msg_ssow_lf_free(dev->mbox);
  55                 if (req == NULL)
  56                         return rc;
  57                 req->hws = nb_lf;
  58         } break;
  59         case SSO_LF_TYPE_HWGRP: {
  60                 struct sso_lf_free_req *req;
  61
  62                 req = mbox_alloc_msg_sso_lf_free(dev->mbox);
  63                 if (req == NULL)
  64                         return rc;
  65                 req->hwgrps = nb_lf;
  66         } break;
  67         default:
  68                 break;
  69         }
  70
  71         rc = mbox_process(dev->mbox);
  72         if (rc < 0)
  73                 return rc;
  74
  75         return 0;
  76 }
  77
  78 static int
  79 sso_rsrc_attach(struct roc_sso *roc_sso, enum sso_lf_type lf_type,
  80                 uint16_t nb_lf)
  81 {
  82         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
  83         struct rsrc_attach_req *req;
  84         int rc = -ENOSPC;
  85
  86         req = mbox_alloc_msg_attach_resources(dev->mbox);
  87         if (req == NULL)
  88                 return rc;
  89         switch (lf_type) {
  90         case SSO_LF_TYPE_HWS:
  91                 req->ssow = nb_lf;
  92                 break;
  93         case SSO_LF_TYPE_HWGRP:
  94                 req->sso = nb_lf;
  95                 break;
  96         default:
  97                 return SSO_ERR_PARAM;
  98         }
  99
 100         req->modify = true;
 101         if (mbox_process(dev->mbox) < 0)
 102                 return -EIO;
 103
 104         return 0;
 105 }
 106
 107 static int
 108 sso_rsrc_detach(struct roc_sso *roc_sso, enum sso_lf_type lf_type)
 109 {
 110         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 111         struct rsrc_detach_req *req;
 112         int rc = -ENOSPC;
 113
 114         req = mbox_alloc_msg_detach_resources(dev->mbox);
 115         if (req == NULL)
 116                 return rc;
 117         switch (lf_type) {
 118         case SSO_LF_TYPE_HWS:
 119                 req->ssow = true;
 120                 break;
 121         case SSO_LF_TYPE_HWGRP:
 122                 req->sso = true;
 123                 break;
 124         default:
 125                 return SSO_ERR_PARAM;
 126         }
 127
 128         req->partial = true;
 129         if (mbox_process(dev->mbox) < 0)
 130                 return -EIO;
 131
 132         return 0;
 133 }
 134
 135 static int
 136 sso_rsrc_get(struct roc_sso *roc_sso)
 137 {
 138         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 139         struct free_rsrcs_rsp *rsrc_cnt;
 140         int rc;
 141
 142         mbox_alloc_msg_free_rsrc_cnt(dev->mbox);
 143         rc = mbox_process_msg(dev->mbox, (void **)&rsrc_cnt);
 144         if (rc < 0) {
 145                 plt_err("Failed to get free resource count\n");
 146                 return rc;
 147         }
 148
 149         roc_sso->max_hwgrp = rsrc_cnt->sso;
 150         roc_sso->max_hws = rsrc_cnt->ssow;
 151
 152         return 0;
 153 }
 154
 155 static void
 156 sso_hws_link_modify(uint8_t hws, uintptr_t base, struct plt_bitmap *bmp,
 157                     uint16_t hwgrp[], uint16_t n, uint16_t enable)
 158 {
 159         uint64_t reg;
 160         int i, j, k;
 161
 162         i = 0;
 163         while (n) {
 164                 uint64_t mask[4] = {
 165                         0x8000,
 166                         0x8000,
 167                         0x8000,
 168                         0x8000,
 169                 };
 170
 171                 k = n % 4;
 172                 k = k ? k : 4;
 173                 for (j = 0; j < k; j++) {
 174                         mask[j] = hwgrp[i + j] | enable << 14;
 175                         enable ? plt_bitmap_set(bmp, hwgrp[i + j]) :
 176                                  plt_bitmap_clear(bmp, hwgrp[i + j]);
 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 /* Public Functions. */
 189 uintptr_t
 190 roc_sso_hws_base_get(struct roc_sso *roc_sso, uint8_t hws)
 191 {
 192         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 193
 194         return dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 | hws << 12);
 195 }
 196
 197 uint64_t
 198 roc_sso_ns_to_gw(struct roc_sso *roc_sso, uint64_t ns)
 199 {
 200         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 201         uint64_t current_us, current_ns, new_ns;
 202         uintptr_t base;
 203
 204         base = dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20);
 205         current_us = plt_read64(base + SSOW_LF_GWS_NW_TIM);
 206         /* From HRM, table 14-19:
 207          * The SSOW_LF_GWS_NW_TIM[NW_TIM] period is specified in n-1 notation.
 208          */
 209         current_us += 1;
 210
 211         /* From HRM, table 14-1:
 212          * SSOW_LF_GWS_NW_TIM[NW_TIM] specifies the minimum timeout. The SSO
 213          * hardware times out a GET_WORK request within 2 usec of the minimum
 214          * timeout specified by SSOW_LF_GWS_NW_TIM[NW_TIM].
 215          */
 216         current_us += 2;
 217         current_ns = current_us * 1E3;
 218         new_ns = (ns - PLT_MIN(ns, current_ns));
 219         new_ns = !new_ns ? 1 : new_ns;
 220         return (new_ns * plt_tsc_hz()) / 1E9;
 221 }
 222
 223 int
 224 roc_sso_hws_link(struct roc_sso *roc_sso, uint8_t hws, uint16_t hwgrp[],
 225                  uint16_t nb_hwgrp)
 226 {
 227         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 228         struct sso *sso;
 229         uintptr_t base;
 230
 231         sso = roc_sso_to_sso_priv(roc_sso);
 232         base = dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 | hws << 12);
 233         sso_hws_link_modify(hws, base, sso->link_map[hws], hwgrp, nb_hwgrp, 1);
 234
 235         return nb_hwgrp;
 236 }
 237
 238 int
 239 roc_sso_hws_unlink(struct roc_sso *roc_sso, uint8_t hws, uint16_t hwgrp[],
 240                    uint16_t nb_hwgrp)
 241 {
 242         struct dev *dev = &roc_sso_to_sso_priv(roc_sso)->dev;
 243         struct sso *sso;
 244         uintptr_t base;
 245
 246         sso = roc_sso_to_sso_priv(roc_sso);
 247         base = dev->bar2 + (RVU_BLOCK_ADDR_SSOW << 20 | hws << 12);
 248         sso_hws_link_modify(hws, base, sso->link_map[hws], hwgrp, nb_hwgrp, 0);
 249
 250         return nb_hwgrp;
 251 }
 252
 253 int
 254 roc_sso_rsrc_init(struct roc_sso *roc_sso, uint8_t nb_hws, uint16_t nb_hwgrp)
 255 {
 256         struct sso_lf_alloc_rsp *rsp_hwgrp;
 257         int rc;
 258
 259         if (roc_sso->max_hwgrp < nb_hwgrp)
 260                 return -ENOENT;
 261         if (roc_sso->max_hws < nb_hws)
 262                 return -ENOENT;
 263
 264         rc = sso_rsrc_attach(roc_sso, SSO_LF_TYPE_HWS, nb_hws);
 265         if (rc < 0) {
 266                 plt_err("Unable to attach SSO HWS LFs");
 267                 return rc;
 268         }
 269
 270         rc = sso_rsrc_attach(roc_sso, SSO_LF_TYPE_HWGRP, nb_hwgrp);
 271         if (rc < 0) {
 272                 plt_err("Unable to attach SSO HWGRP LFs");
 273                 goto hwgrp_atch_fail;
 274         }
 275
 276         rc = sso_lf_alloc(roc_sso, SSO_LF_TYPE_HWS, nb_hws, NULL);
 277         if (rc < 0) {
 278                 plt_err("Unable to alloc SSO HWS LFs");
 279                 goto hws_alloc_fail;
 280         }
 281
 282         rc = sso_lf_alloc(roc_sso, SSO_LF_TYPE_HWGRP, nb_hwgrp,
 283                           (void **)&rsp_hwgrp);
 284         if (rc < 0) {
 285                 plt_err("Unable to alloc SSO HWGRP Lfs");
 286                 goto hwgrp_alloc_fail;
 287         }
 288
 289         roc_sso->xaq_buf_size = rsp_hwgrp->xaq_buf_size;
 290         roc_sso->xae_waes = rsp_hwgrp->xaq_wq_entries;
 291         roc_sso->iue = rsp_hwgrp->in_unit_entries;
 292
 293         roc_sso->nb_hwgrp = nb_hwgrp;
 294         roc_sso->nb_hws = nb_hws;
 295
 296         return 0;
 297 hwgrp_alloc_fail:
 298         sso_lf_free(roc_sso, SSO_LF_TYPE_HWS, nb_hws);
 299 hws_alloc_fail:
 300         sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWGRP);
 301 hwgrp_atch_fail:
 302         sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWS);
 303         return rc;
 304 }
 305
 306 void
 307 roc_sso_rsrc_fini(struct roc_sso *roc_sso)
 308 {
 309         if (!roc_sso->nb_hws && !roc_sso->nb_hwgrp)
 310                 return;
 311
 312         sso_lf_free(roc_sso, SSO_LF_TYPE_HWS, roc_sso->nb_hws);
 313         sso_lf_free(roc_sso, SSO_LF_TYPE_HWGRP, roc_sso->nb_hwgrp);
 314
 315         sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWS);
 316         sso_rsrc_detach(roc_sso, SSO_LF_TYPE_HWGRP);
 317
 318         roc_sso->nb_hwgrp = 0;
 319         roc_sso->nb_hws = 0;
 320 }
 321
 322 int
 323 roc_sso_dev_init(struct roc_sso *roc_sso)
 324 {
 325         struct plt_pci_device *pci_dev;
 326         uint32_t link_map_sz;
 327         struct sso *sso;
 328         void *link_mem;
 329         int i, rc;
 330
 331         if (roc_sso == NULL || roc_sso->pci_dev == NULL)
 332                 return SSO_ERR_PARAM;
 333
 334         PLT_STATIC_ASSERT(sizeof(struct sso) <= ROC_SSO_MEM_SZ);
 335         sso = roc_sso_to_sso_priv(roc_sso);
 336         memset(sso, 0, sizeof(*sso));
 337         pci_dev = roc_sso->pci_dev;
 338
 339         rc = dev_init(&sso->dev, pci_dev);
 340         if (rc < 0) {
 341                 plt_err("Failed to init roc device");
 342                 goto fail;
 343         }
 344
 345         rc = sso_rsrc_get(roc_sso);
 346         if (rc < 0) {
 347                 plt_err("Failed to get SSO resources");
 348                 goto rsrc_fail;
 349         }
 350         rc = -ENOMEM;
 351
 352         sso->link_map =
 353                 plt_zmalloc(sizeof(struct plt_bitmap *) * roc_sso->max_hws, 0);
 354         if (sso->link_map == NULL) {
 355                 plt_err("Failed to allocate memory for link_map array");
 356                 goto rsrc_fail;
 357         }
 358
 359         link_map_sz = plt_bitmap_get_memory_footprint(roc_sso->max_hwgrp);
 360         sso->link_map_mem = plt_zmalloc(link_map_sz * roc_sso->max_hws, 0);
 361         if (sso->link_map_mem == NULL) {
 362                 plt_err("Failed to get link_map memory");
 363                 goto rsrc_fail;
 364         }
 365
 366         link_mem = sso->link_map_mem;
 367         for (i = 0; i < roc_sso->max_hws; i++) {
 368                 sso->link_map[i] = plt_bitmap_init(roc_sso->max_hwgrp, link_mem,
 369                                                    link_map_sz);
 370                 if (sso->link_map[i] == NULL) {
 371                         plt_err("Failed to allocate link map");
 372                         goto link_mem_free;
 373                 }
 374                 link_mem = PLT_PTR_ADD(link_mem, link_map_sz);
 375         }
 376         idev_sso_pffunc_set(sso->dev.pf_func);
 377         sso->pci_dev = pci_dev;
 378         sso->dev.drv_inited = true;
 379         roc_sso->lmt_base = sso->dev.lmt_base;
 380
 381         return 0;
 382 link_mem_free:
 383         plt_free(sso->link_map_mem);
 384 rsrc_fail:
 385         rc |= dev_fini(&sso->dev, pci_dev);
 386 fail:
 387         return rc;
 388 }
 389
 390 int
 391 roc_sso_dev_fini(struct roc_sso *roc_sso)
 392 {
 393         struct sso *sso;
 394
 395         sso = roc_sso_to_sso_priv(roc_sso);
 396         sso->dev.drv_inited = false;
 397
 398         return dev_fini(&sso->dev, sso->pci_dev);
 399 }