drivers/net/octeontx/base/octeontx_pkovf.c

   1 /*
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (C) Cavium Inc. 2017. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above copyright
  13  *       notice, this list of conditions and the following disclaimer in
  14  *       the documentation and/or other materials provided with the
  15  *       distribution.
  16  *     * Neither the name of Cavium networks nor the names of its
  17  *       contributors may be used to endorse or promote products derived
  18  *       from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32 #include <stdbool.h>
  33 #include <string.h>
  34 #include <stdio.h>
  35
  36 #include <rte_eal.h>
  37 #include <rte_cycles.h>
  38 #include <rte_malloc.h>
  39 #include <rte_memory.h>
  40 #include <rte_bus_pci.h>
  41 #include <rte_spinlock.h>
  42
  43 #include "../octeontx_logs.h"
  44 #include "octeontx_io.h"
  45 #include "octeontx_pkovf.h"
  46
  47 struct octeontx_pko_iomem {
  48         uint8_t         *va;
  49         phys_addr_t     iova;
  50         size_t          size;
  51 };
  52
  53 #define PKO_IOMEM_NULL (struct octeontx_pko_iomem){0, 0, 0}
  54
  55 struct octeontx_pko_fc_ctl_s {
  56         int64_t buf_cnt;
  57         int64_t padding[(PKO_DQ_FC_STRIDE / 8) - 1];
  58 };
  59
  60 struct octeontx_pkovf {
  61         uint8_t         *bar0;
  62         uint8_t         *bar2;
  63         uint16_t        domain;
  64         uint16_t        vfid;
  65 };
  66
  67 struct octeontx_pko_vf_ctl_s {
  68         rte_spinlock_t lock;
  69
  70         struct octeontx_pko_iomem fc_iomem;
  71         struct octeontx_pko_fc_ctl_s *fc_ctl;
  72         struct octeontx_pkovf pko[PKO_VF_MAX];
  73         struct {
  74                 uint64_t chanid;
  75         } dq_map[PKO_VF_MAX * PKO_VF_NUM_DQ];
  76 };
  77
  78 static struct octeontx_pko_vf_ctl_s pko_vf_ctl;
  79
  80 static void *
  81 octeontx_pko_dq_vf_bar0(uint16_t txq)
  82 {
  83         int vf_ix;
  84
  85         vf_ix = txq / PKO_VF_NUM_DQ;
  86         return pko_vf_ctl.pko[vf_ix].bar0;
  87 }
  88
  89 static int
  90 octeontx_pko_dq_gdq(uint16_t txq)
  91 {
  92         return txq % PKO_VF_NUM_DQ;
  93 }
  94
  95 /**
  96  * Open a PKO DQ.
  97  */
  98 static inline
  99 int octeontx_pko_dq_open(uint16_t txq)
 100 {
 101         unsigned int reg_off;
 102         uint8_t *vf_bar0;
 103         uint64_t rtn;
 104         int gdq;
 105
 106         vf_bar0 = octeontx_pko_dq_vf_bar0(txq);
 107         gdq = octeontx_pko_dq_gdq(txq);
 108
 109         if (unlikely(gdq < 0 || vf_bar0 == NULL))
 110                 return -EINVAL;
 111         *(volatile int64_t*)(pko_vf_ctl.fc_ctl + txq) =
 112                 PKO_DQ_FC_DEPTH_PAGES - PKO_DQ_FC_SKID;
 113
 114         rte_wmb();
 115
 116         octeontx_write64(PKO_DQ_FC_DEPTH_PAGES,
 117                          vf_bar0 + PKO_VF_DQ_FC_STATUS(gdq));
 118
 119         /* Set the register to return descriptor (packet) count as DEPTH */
 120         /* KIND=1, NCB_QUERY_RSP=0 */
 121         octeontx_write64(1ull << PKO_DQ_KIND_BIT,
 122                                 vf_bar0 + PKO_VF_DQ_WM_CTL(gdq));
 123         reg_off = PKO_VF_DQ_OP_OPEN(gdq);
 124
 125         rtn = octeontx_reg_ldadd_u64(vf_bar0 + reg_off, 0);
 126
 127         /* PKO_DQOP_E::OPEN */
 128         if (((rtn >> PKO_DQ_OP_BIT) & 0x3) != 0x1)
 129                 return -EIO;
 130
 131         switch (rtn >> PKO_DQ_STATUS_BIT) {
 132         case 0xC:       /* DQALREADYCREATED */
 133         case 0x0:       /* PASS */
 134                 break;
 135         default:
 136                 return -EIO;
 137         }
 138
 139         /* DRAIN=0, DRAIN_NULL_LINK=0, SW_XOFF=0 */
 140         octeontx_write64(0, vf_bar0 + PKO_VF_DQ_SW_XOFF(gdq));
 141
 142         return rtn & ((1ull << PKO_DQ_OP_BIT) - 1);
 143 }
 144
 145 /**
 146  * Close a PKO DQ
 147  * Flush all packets pending.
 148  */
 149 static inline
 150 int octeontx_pko_dq_close(uint16_t txq)
 151 {
 152         unsigned int reg_off;
 153         uint8_t *vf_bar0;
 154         uint64_t rtn;
 155         int res;
 156
 157         vf_bar0 = octeontx_pko_dq_vf_bar0(txq);
 158         res = octeontx_pko_dq_gdq(txq);
 159
 160         if (unlikely(res < 0 || vf_bar0 == NULL))
 161                 return -EINVAL;
 162
 163         reg_off = PKO_VF_DQ_OP_CLOSE(res);
 164
 165         rtn = octeontx_reg_ldadd_u64(vf_bar0 + reg_off, 0);
 166
 167         /* PKO_DQOP_E::CLOSE */
 168         if (((rtn >> PKO_DQ_OP_BIT) & 0x3) != 0x2)
 169                 return -EIO;
 170
 171         switch (rtn >> PKO_DQ_STATUS_BIT) {
 172         case 0xD:       /* DQNOTCREATED */
 173         case 0x0:       /* PASS */
 174                 break;
 175         default:
 176                 return -EIO;
 177         }
 178
 179         res = rtn & ((1ull << PKO_DQ_OP_BIT) - 1); /* DEPTH */
 180         return res;
 181 }
 182
 183 /* Flush all packets pending on a DQ */
 184 static inline
 185 int octeontx_pko_dq_drain(uint16_t txq)
 186 {
 187         unsigned int gdq;
 188         uint8_t *vf_bar0;
 189         uint64_t reg;
 190         int res, timo = PKO_DQ_DRAIN_TO;
 191
 192         vf_bar0 = octeontx_pko_dq_vf_bar0(txq);
 193         res = octeontx_pko_dq_gdq(txq);
 194         gdq = res;
 195
 196          /* DRAIN=1, DRAIN_NULL_LINK=0, SW_XOFF=1 */
 197          octeontx_write64(0x3, vf_bar0 + PKO_VF_DQ_SW_XOFF(gdq));
 198         /* Wait until buffers leave DQs */
 199         reg = octeontx_read64(vf_bar0 + PKO_VF_DQ_WM_CNT(gdq));
 200         while (reg && timo > 0) {
 201                 rte_delay_us(100);
 202                 timo--;
 203                 reg = octeontx_read64(vf_bar0 + PKO_VF_DQ_WM_CNT(gdq));
 204         }
 205         /* DRAIN=0, DRAIN_NULL_LINK=0, SW_XOFF=0 */
 206         octeontx_write64(0, vf_bar0 + PKO_VF_DQ_SW_XOFF(gdq));
 207
 208         return reg;
 209 }
 210
 211 static inline int
 212 octeontx_pko_dq_range_lookup(struct octeontx_pko_vf_ctl_s *ctl, uint64_t chanid,
 213                              unsigned int dq_num, unsigned int dq_from)
 214 {
 215         unsigned int dq, dq_cnt;
 216         unsigned int dq_base;
 217
 218         dq_cnt = 0;
 219         dq = dq_from;
 220         while (dq < RTE_DIM(ctl->dq_map)) {
 221                 dq_base = dq;
 222                 dq_cnt = 0;
 223                 while (ctl->dq_map[dq].chanid == ~chanid &&
 224                         dq < RTE_DIM(ctl->dq_map)) {
 225                         dq_cnt++;
 226                         if (dq_cnt == dq_num)
 227                                 return dq_base;
 228                         dq++;
 229                 }
 230                 dq++;
 231         }
 232         return -1;
 233 }
 234
 235 static inline void
 236 octeontx_pko_dq_range_assign(struct octeontx_pko_vf_ctl_s *ctl, uint64_t chanid,
 237                              unsigned int dq_base, unsigned int dq_num)
 238 {
 239         unsigned int dq, dq_cnt;
 240
 241         dq_cnt = 0;
 242         while (dq_cnt < dq_num) {
 243                 dq = dq_base + dq_cnt;
 244
 245                 octeontx_log_dbg("DQ# %u assigned to CHAN# %" PRIx64 "", dq,
 246                         chanid);
 247
 248                 ctl->dq_map[dq].chanid = ~chanid;
 249                 dq_cnt++;
 250         }
 251 }
 252
 253 static inline int
 254 octeontx_pko_dq_claim(struct octeontx_pko_vf_ctl_s *ctl, unsigned int dq_base,
 255                       unsigned int dq_num, uint64_t chanid)
 256 {
 257         const uint64_t null_chanid = ~0ull;
 258         int dq;
 259
 260         rte_spinlock_lock(&ctl->lock);
 261
 262         dq = octeontx_pko_dq_range_lookup(ctl, null_chanid, dq_num, dq_base);
 263         if (dq < 0 || (unsigned int)dq != dq_base) {
 264                 rte_spinlock_unlock(&ctl->lock);
 265                 return -1;
 266         }
 267         octeontx_pko_dq_range_assign(ctl, chanid, dq_base, dq_num);
 268
 269         rte_spinlock_unlock(&ctl->lock);
 270
 271         return 0;
 272 }
 273
 274 static inline int
 275 octeontx_pko_dq_free(struct octeontx_pko_vf_ctl_s *ctl, uint64_t chanid)
 276 {
 277         const uint64_t null_chanid = ~0ull;
 278         unsigned int dq = 0, dq_cnt = 0;
 279
 280         rte_spinlock_lock(&ctl->lock);
 281         while (dq < RTE_DIM(ctl->dq_map)) {
 282                 if (ctl->dq_map[dq].chanid == ~chanid) {
 283                         ctl->dq_map[dq].chanid = ~null_chanid;
 284                         dq_cnt++;
 285                 }
 286                 dq++;
 287         }
 288         rte_spinlock_unlock(&ctl->lock);
 289
 290         return dq_cnt > 0 ? 0 : -EINVAL;
 291 }
 292
 293 int
 294 octeontx_pko_channel_open(int dq_base, int dq_num, int chanid)
 295 {
 296         struct octeontx_pko_vf_ctl_s *ctl = &pko_vf_ctl;
 297         int res;
 298
 299         res = octeontx_pko_dq_claim(ctl, dq_base, dq_num, chanid);
 300         if (res < 0)
 301                 return -1;
 302
 303         return 0;
 304 }
 305
 306 int
 307 octeontx_pko_channel_close(int chanid)
 308 {
 309         struct octeontx_pko_vf_ctl_s *ctl = &pko_vf_ctl;
 310         int res;
 311
 312         res = octeontx_pko_dq_free(ctl, chanid);
 313         if (res < 0)
 314                 return -1;
 315
 316         return 0;
 317 }
 318
 319 static inline int
 320 octeontx_pko_chan_start(struct octeontx_pko_vf_ctl_s *ctl, uint64_t chanid)
 321 {
 322         unsigned int dq_vf;
 323         unsigned int dq, dq_cnt;
 324
 325         dq_cnt = 0;
 326         dq = 0;
 327         while (dq < RTE_DIM(ctl->dq_map)) {
 328                 dq_vf = dq / PKO_VF_NUM_DQ;
 329
 330                 if (!ctl->pko[dq_vf].bar0) {
 331                         dq += PKO_VF_NUM_DQ;
 332                         continue;
 333                 }
 334
 335                 if (ctl->dq_map[dq].chanid != ~chanid) {
 336                         dq++;
 337                         continue;
 338                 }
 339
 340                 if (octeontx_pko_dq_open(dq) < 0)
 341                         break;
 342
 343                 dq_cnt++;
 344                 dq++;
 345         }
 346
 347         return dq_cnt;
 348 }
 349
 350 int
 351 octeontx_pko_channel_start(int chanid)
 352 {
 353         struct octeontx_pko_vf_ctl_s *ctl = &pko_vf_ctl;
 354         int dq_cnt;
 355
 356         dq_cnt = octeontx_pko_chan_start(ctl, chanid);
 357         if (dq_cnt < 0)
 358                 return -1;
 359
 360         return dq_cnt;
 361 }
 362
 363 static inline int
 364 octeontx_pko_chan_stop(struct octeontx_pko_vf_ctl_s *ctl, uint64_t chanid)
 365 {
 366         unsigned int dq, dq_cnt, dq_vf;
 367         int res;
 368
 369         dq_cnt = 0;
 370         dq = 0;
 371         while (dq < RTE_DIM(ctl->dq_map)) {
 372                 dq_vf = dq / PKO_VF_NUM_DQ;
 373
 374                 if (!ctl->pko[dq_vf].bar0) {
 375                         dq += PKO_VF_NUM_DQ;
 376                         continue;
 377                 }
 378
 379                 if (ctl->dq_map[dq].chanid != ~chanid) {
 380                         dq++;
 381                         continue;
 382                 }
 383
 384                 res = octeontx_pko_dq_drain(dq);
 385                 if (res > 0)
 386                         octeontx_log_err("draining DQ%d, buffers left: %x",
 387                                          dq, res);
 388
 389                 res = octeontx_pko_dq_close(dq);
 390                 if (res < 0)
 391                         octeontx_log_err("closing DQ%d failed\n", dq);
 392
 393                 dq_cnt++;
 394                 dq++;
 395         }
 396         return dq_cnt;
 397 }
 398
 399 int
 400 octeontx_pko_channel_stop(int chanid)
 401 {
 402         struct octeontx_pko_vf_ctl_s *ctl = &pko_vf_ctl;
 403
 404         octeontx_pko_chan_stop(ctl, chanid);
 405         return 0;
 406 }
 407
 408 static inline int
 409 octeontx_pko_channel_query(struct octeontx_pko_vf_ctl_s *ctl, uint64_t chanid,
 410                            void *out, size_t out_elem_size,
 411                            size_t dq_num, octeontx_pko_dq_getter_t getter)
 412 {
 413         octeontx_dq_t curr;
 414         unsigned int dq_vf;
 415         unsigned int dq;
 416
 417         RTE_SET_USED(out_elem_size);
 418         memset(&curr, 0, sizeof(octeontx_dq_t));
 419
 420         dq_vf = dq_num / PKO_VF_NUM_DQ;
 421         dq = dq_num % PKO_VF_NUM_DQ;
 422
 423         if (!ctl->pko[dq_vf].bar0)
 424                 return -EINVAL;
 425
 426         if (ctl->dq_map[dq_num].chanid != ~chanid)
 427                 return -EINVAL;
 428
 429         uint8_t *iter = (uint8_t *)out;
 430         curr.lmtline_va = ctl->pko[dq_vf].bar2;
 431         curr.ioreg_va = (void *)((uintptr_t)ctl->pko[dq_vf].bar0
 432                 + PKO_VF_DQ_OP_SEND((dq), 0));
 433         curr.fc_status_va = ctl->fc_ctl + dq;
 434
 435         octeontx_log_dbg("lmtline=%p ioreg_va=%p fc_status_va=%p",
 436                          curr.lmtline_va, curr.ioreg_va,
 437                          curr.fc_status_va);
 438
 439         getter(&curr, (void *)iter);
 440         return 0;
 441 }
 442
 443 int
 444 octeontx_pko_channel_query_dqs(int chanid, void *out, size_t out_elem_size,
 445                                 size_t dq_num, octeontx_pko_dq_getter_t getter)
 446 {
 447         struct octeontx_pko_vf_ctl_s *ctl = &pko_vf_ctl;
 448         int dq_cnt;
 449
 450         dq_cnt = octeontx_pko_channel_query(ctl, chanid, out, out_elem_size,
 451                                                 dq_num, getter);
 452         if (dq_cnt < 0)
 453                 return -1;
 454
 455         return dq_cnt;
 456 }
 457
 458 int
 459 octeontx_pko_vf_count(void)
 460 {
 461         int vf_cnt;
 462
 463         vf_cnt = 0;
 464         while (pko_vf_ctl.pko[vf_cnt].bar0)
 465                 vf_cnt++;
 466
 467         return vf_cnt;
 468 }
 469
 470 int
 471 octeontx_pko_init_fc(const size_t pko_vf_count)
 472 {
 473         int dq_ix;
 474         uint64_t reg;
 475         uint8_t *vf_bar0;
 476         size_t vf_idx;
 477         size_t fc_mem_size;
 478
 479         fc_mem_size = sizeof(struct octeontx_pko_fc_ctl_s) *
 480                         pko_vf_count * PKO_VF_NUM_DQ;
 481
 482         pko_vf_ctl.fc_iomem.va = rte_malloc(NULL, fc_mem_size, 128);
 483         if (unlikely(!pko_vf_ctl.fc_iomem.va)) {
 484                 octeontx_log_err("fc_iomem: not enough memory");
 485                 return -ENOMEM;
 486         }
 487
 488         pko_vf_ctl.fc_iomem.iova = rte_malloc_virt2phy((void *)
 489                                                         pko_vf_ctl.fc_iomem.va);
 490         pko_vf_ctl.fc_iomem.size = fc_mem_size;
 491
 492         pko_vf_ctl.fc_ctl =
 493                 (struct octeontx_pko_fc_ctl_s *)pko_vf_ctl.fc_iomem.va;
 494
 495         /* Configure Flow-Control feature for all DQs of open VFs */
 496         for (vf_idx = 0; vf_idx < pko_vf_count; vf_idx++) {
 497                 dq_ix = vf_idx * PKO_VF_NUM_DQ;
 498
 499                 vf_bar0 = pko_vf_ctl.pko[vf_idx].bar0;
 500
 501                 reg = (pko_vf_ctl.fc_iomem.iova +
 502                         (sizeof(struct octeontx_pko_fc_ctl_s) * dq_ix)) & ~0x7F;
 503                 reg |=                  /* BASE */
 504                     (0x2 << 3) |        /* HYST_BITS */
 505                     (((PKO_DQ_FC_STRIDE == PKO_DQ_FC_STRIDE_16) ? 1 : 0) << 2) |
 506                     (0x1 << 0);         /* ENABLE */
 507
 508                 octeontx_write64(reg, vf_bar0 + PKO_VF_DQ_FC_CONFIG);
 509
 510                 octeontx_log_dbg("PKO: bar0 %p VF_idx %d DQ_FC_CFG=%" PRIx64 "",
 511                                  vf_bar0, (int)vf_idx, reg);
 512         }
 513         return 0;
 514 }
 515
 516 void
 517 octeontx_pko_fc_free(void)
 518 {
 519         rte_free(pko_vf_ctl.fc_iomem.va);
 520 }
 521
 522 static void
 523 octeontx_pkovf_setup(void)
 524 {
 525         static bool init_once;
 526
 527         if (!init_once) {
 528                 unsigned int i;
 529
 530                 rte_spinlock_init(&pko_vf_ctl.lock);
 531
 532                 pko_vf_ctl.fc_iomem = PKO_IOMEM_NULL;
 533                 pko_vf_ctl.fc_ctl = NULL;
 534
 535                 for (i = 0; i < PKO_VF_MAX; i++) {
 536                         pko_vf_ctl.pko[i].bar0 = NULL;
 537                         pko_vf_ctl.pko[i].bar2 = NULL;
 538                         pko_vf_ctl.pko[i].domain = ~(uint16_t)0;
 539                         pko_vf_ctl.pko[i].vfid = ~(uint16_t)0;
 540                 }
 541
 542                 for (i = 0; i < (PKO_VF_MAX * PKO_VF_NUM_DQ); i++)
 543                         pko_vf_ctl.dq_map[i].chanid = 0;
 544
 545                 init_once = true;
 546         }
 547 }
 548
 549 /* PKOVF pcie device*/
 550 static int
 551 pkovf_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
 552 {
 553         uint64_t val;
 554         uint16_t vfid;
 555         uint16_t domain;
 556         uint8_t *bar0;
 557         uint8_t *bar2;
 558         struct octeontx_pkovf *res;
 559
 560         RTE_SET_USED(pci_drv);
 561
 562         /* For secondary processes, the primary has done all the work */
 563         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 564                 return 0;
 565
 566         if (pci_dev->mem_resource[0].addr == NULL ||
 567             pci_dev->mem_resource[2].addr == NULL) {
 568                 octeontx_log_err("Empty bars %p %p",
 569                         pci_dev->mem_resource[0].addr,
 570                         pci_dev->mem_resource[2].addr);
 571                 return -ENODEV;
 572         }
 573         bar0 = pci_dev->mem_resource[0].addr;
 574         bar2 = pci_dev->mem_resource[2].addr;
 575
 576         octeontx_pkovf_setup();
 577
 578         /* get vfid and domain */
 579         val = octeontx_read64(bar0 + PKO_VF_DQ_FC_CONFIG);
 580         domain = (val >> 7) & 0xffff;
 581         vfid = (val >> 23) & 0xffff;
 582
 583         if (unlikely(vfid >= PKO_VF_MAX)) {
 584                 octeontx_log_err("pko: Invalid vfid %d", vfid);
 585                 return -EINVAL;
 586         }
 587
 588         res = &pko_vf_ctl.pko[vfid];
 589         res->vfid = vfid;
 590         res->domain = domain;
 591         res->bar0 = bar0;
 592         res->bar2 = bar2;
 593
 594         octeontx_log_dbg("Domain=%d group=%d", res->domain, res->vfid);
 595         return 0;
 596 }
 597
 598 #define PCI_VENDOR_ID_CAVIUM               0x177D
 599 #define PCI_DEVICE_ID_OCTEONTX_PKO_VF      0xA049
 600
 601 static const struct rte_pci_id pci_pkovf_map[] = {
 602         {
 603                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM,
 604                                 PCI_DEVICE_ID_OCTEONTX_PKO_VF)
 605         },
 606         {
 607                 .vendor_id = 0,
 608         },
 609 };
 610
 611 static struct rte_pci_driver pci_pkovf = {
 612         .id_table = pci_pkovf_map,
 613         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
 614         .probe = pkovf_probe,
 615 };
 616
 617 RTE_PMD_REGISTER_PCI(octeontx_pkovf, pci_pkovf);