drivers/net/octeontx2/otx2_ethdev_irq.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include <inttypes.h>
   6
   7 #include <rte_bus_pci.h>
   8 #include <rte_malloc.h>
   9
  10 #include "otx2_ethdev.h"
  11
  12 static void
  13 nix_lf_err_irq(void *param)
  14 {
  15         struct rte_eth_dev *eth_dev = (struct rte_eth_dev *)param;
  16         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
  17         uint64_t intr;
  18
  19         intr = otx2_read64(dev->base + NIX_LF_ERR_INT);
  20         if (intr == 0)
  21                 return;
  22
  23         otx2_err("Err_intr=0x%" PRIx64 " pf=%d, vf=%d", intr, dev->pf, dev->vf);
  24
  25         /* Clear interrupt */
  26         otx2_write64(intr, dev->base + NIX_LF_ERR_INT);
  27
  28         /* Dump registers to std out */
  29         otx2_nix_reg_dump(dev, NULL);
  30         otx2_nix_queues_ctx_dump(eth_dev);
  31 }
  32
  33 static int
  34 nix_lf_register_err_irq(struct rte_eth_dev *eth_dev)
  35 {
  36         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
  37         struct rte_intr_handle *handle = &pci_dev->intr_handle;
  38         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
  39         int rc, vec;
  40
  41         vec = dev->nix_msixoff + NIX_LF_INT_VEC_ERR_INT;
  42
  43         /* Clear err interrupt */
  44         otx2_write64(~0ull, dev->base + NIX_LF_ERR_INT_ENA_W1C);
  45         /* Set used interrupt vectors */
  46         rc = otx2_register_irq(handle, nix_lf_err_irq, eth_dev, vec);
  47         /* Enable all dev interrupt except for RQ_DISABLED */
  48         otx2_write64(~BIT_ULL(11), dev->base + NIX_LF_ERR_INT_ENA_W1S);
  49
  50         return rc;
  51 }
  52
  53 static void
  54 nix_lf_unregister_err_irq(struct rte_eth_dev *eth_dev)
  55 {
  56         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
  57         struct rte_intr_handle *handle = &pci_dev->intr_handle;
  58         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
  59         int vec;
  60
  61         vec = dev->nix_msixoff + NIX_LF_INT_VEC_ERR_INT;
  62
  63         /* Clear err interrupt */
  64         otx2_write64(~0ull, dev->base + NIX_LF_ERR_INT_ENA_W1C);
  65         otx2_unregister_irq(handle, nix_lf_err_irq, eth_dev, vec);
  66 }
  67
  68 static void
  69 nix_lf_ras_irq(void *param)
  70 {
  71         struct rte_eth_dev *eth_dev = (struct rte_eth_dev *)param;
  72         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
  73         uint64_t intr;
  74
  75         intr = otx2_read64(dev->base + NIX_LF_RAS);
  76         if (intr == 0)
  77                 return;
  78
  79         otx2_err("Ras_intr=0x%" PRIx64 " pf=%d, vf=%d", intr, dev->pf, dev->vf);
  80
  81         /* Clear interrupt */
  82         otx2_write64(intr, dev->base + NIX_LF_RAS);
  83
  84         /* Dump registers to std out */
  85         otx2_nix_reg_dump(dev, NULL);
  86         otx2_nix_queues_ctx_dump(eth_dev);
  87 }
  88
  89 static int
  90 nix_lf_register_ras_irq(struct rte_eth_dev *eth_dev)
  91 {
  92         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
  93         struct rte_intr_handle *handle = &pci_dev->intr_handle;
  94         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
  95         int rc, vec;
  96
  97         vec = dev->nix_msixoff + NIX_LF_INT_VEC_POISON;
  98
  99         /* Clear err interrupt */
 100         otx2_write64(~0ull, dev->base + NIX_LF_RAS_ENA_W1C);
 101         /* Set used interrupt vectors */
 102         rc = otx2_register_irq(handle, nix_lf_ras_irq, eth_dev, vec);
 103         /* Enable dev interrupt */
 104         otx2_write64(~0ull, dev->base + NIX_LF_RAS_ENA_W1S);
 105
 106         return rc;
 107 }
 108
 109 static void
 110 nix_lf_unregister_ras_irq(struct rte_eth_dev *eth_dev)
 111 {
 112         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 113         struct rte_intr_handle *handle = &pci_dev->intr_handle;
 114         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 115         int vec;
 116
 117         vec = dev->nix_msixoff + NIX_LF_INT_VEC_POISON;
 118
 119         /* Clear err interrupt */
 120         otx2_write64(~0ull, dev->base + NIX_LF_RAS_ENA_W1C);
 121         otx2_unregister_irq(handle, nix_lf_ras_irq, eth_dev, vec);
 122 }
 123
 124 static inline uint8_t
 125 nix_lf_q_irq_get_and_clear(struct otx2_eth_dev *dev, uint16_t q,
 126                            uint32_t off, uint64_t mask)
 127 {
 128         uint64_t reg, wdata;
 129         uint8_t qint;
 130
 131         wdata = (uint64_t)q << 44;
 132         reg = otx2_atomic64_add_nosync(wdata, (int64_t *)(dev->base + off));
 133
 134         if (reg & BIT_ULL(42) /* OP_ERR */) {
 135                 otx2_err("Failed execute irq get off=0x%x", off);
 136                 return 0;
 137         }
 138
 139         qint = reg & 0xff;
 140         wdata &= mask;
 141         otx2_write64(wdata | qint, dev->base + off);
 142
 143         return qint;
 144 }
 145
 146 static inline uint8_t
 147 nix_lf_rq_irq_get_and_clear(struct otx2_eth_dev *dev, uint16_t rq)
 148 {
 149         return nix_lf_q_irq_get_and_clear(dev, rq, NIX_LF_RQ_OP_INT, ~0xff00);
 150 }
 151
 152 static inline uint8_t
 153 nix_lf_cq_irq_get_and_clear(struct otx2_eth_dev *dev, uint16_t cq)
 154 {
 155         return nix_lf_q_irq_get_and_clear(dev, cq, NIX_LF_CQ_OP_INT, ~0xff00);
 156 }
 157
 158 static inline uint8_t
 159 nix_lf_sq_irq_get_and_clear(struct otx2_eth_dev *dev, uint16_t sq)
 160 {
 161         return nix_lf_q_irq_get_and_clear(dev, sq, NIX_LF_SQ_OP_INT, ~0x1ff00);
 162 }
 163
 164 static inline void
 165 nix_lf_sq_debug_reg(struct otx2_eth_dev *dev, uint32_t off)
 166 {
 167         uint64_t reg;
 168
 169         reg = otx2_read64(dev->base + off);
 170         if (reg & BIT_ULL(44))
 171                 otx2_err("SQ=%d err_code=0x%x",
 172                          (int)((reg >> 8) & 0xfffff), (uint8_t)(reg & 0xff));
 173 }
 174
 175 static void
 176 nix_lf_cq_irq(void *param)
 177 {
 178         struct otx2_qint *cint = (struct otx2_qint *)param;
 179         struct rte_eth_dev *eth_dev = cint->eth_dev;
 180         struct otx2_eth_dev *dev;
 181
 182         dev = otx2_eth_pmd_priv(eth_dev);
 183         /* Clear interrupt */
 184         otx2_write64(BIT_ULL(0), dev->base + NIX_LF_CINTX_INT(cint->qintx));
 185 }
 186
 187 static void
 188 nix_lf_q_irq(void *param)
 189 {
 190         struct otx2_qint *qint = (struct otx2_qint *)param;
 191         struct rte_eth_dev *eth_dev = qint->eth_dev;
 192         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 193         uint8_t irq, qintx = qint->qintx;
 194         int q, cq, rq, sq;
 195         uint64_t intr;
 196
 197         intr = otx2_read64(dev->base + NIX_LF_QINTX_INT(qintx));
 198         if (intr == 0)
 199                 return;
 200
 201         otx2_err("Queue_intr=0x%" PRIx64 " qintx=%d pf=%d, vf=%d",
 202                  intr, qintx, dev->pf, dev->vf);
 203
 204         /* Handle RQ interrupts */
 205         for (q = 0; q < eth_dev->data->nb_rx_queues; q++) {
 206                 rq = q % dev->qints;
 207                 irq = nix_lf_rq_irq_get_and_clear(dev, rq);
 208
 209                 if (irq & BIT_ULL(NIX_RQINT_DROP))
 210                         otx2_err("RQ=%d NIX_RQINT_DROP", rq);
 211
 212                 if (irq & BIT_ULL(NIX_RQINT_RED))
 213                         otx2_err("RQ=%d NIX_RQINT_RED", rq);
 214         }
 215
 216         /* Handle CQ interrupts */
 217         for (q = 0; q < eth_dev->data->nb_rx_queues; q++) {
 218                 cq = q % dev->qints;
 219                 irq = nix_lf_cq_irq_get_and_clear(dev, cq);
 220
 221                 if (irq & BIT_ULL(NIX_CQERRINT_DOOR_ERR))
 222                         otx2_err("CQ=%d NIX_CQERRINT_DOOR_ERR", cq);
 223
 224                 if (irq & BIT_ULL(NIX_CQERRINT_WR_FULL))
 225                         otx2_err("CQ=%d NIX_CQERRINT_WR_FULL", cq);
 226
 227                 if (irq & BIT_ULL(NIX_CQERRINT_CQE_FAULT))
 228                         otx2_err("CQ=%d NIX_CQERRINT_CQE_FAULT", cq);
 229         }
 230
 231         /* Handle SQ interrupts */
 232         for (q = 0; q < eth_dev->data->nb_tx_queues; q++) {
 233                 sq = q % dev->qints;
 234                 irq = nix_lf_sq_irq_get_and_clear(dev, sq);
 235
 236                 if (irq & BIT_ULL(NIX_SQINT_LMT_ERR)) {
 237                         otx2_err("SQ=%d NIX_SQINT_LMT_ERR", sq);
 238                         nix_lf_sq_debug_reg(dev, NIX_LF_SQ_OP_ERR_DBG);
 239                 }
 240                 if (irq & BIT_ULL(NIX_SQINT_MNQ_ERR)) {
 241                         otx2_err("SQ=%d NIX_SQINT_MNQ_ERR", sq);
 242                         nix_lf_sq_debug_reg(dev, NIX_LF_MNQ_ERR_DBG);
 243                 }
 244                 if (irq & BIT_ULL(NIX_SQINT_SEND_ERR)) {
 245                         otx2_err("SQ=%d NIX_SQINT_SEND_ERR", sq);
 246                         nix_lf_sq_debug_reg(dev, NIX_LF_SEND_ERR_DBG);
 247                 }
 248                 if (irq & BIT_ULL(NIX_SQINT_SQB_ALLOC_FAIL)) {
 249                         otx2_err("SQ=%d NIX_SQINT_SQB_ALLOC_FAIL", sq);
 250                         nix_lf_sq_debug_reg(dev, NIX_LF_SEND_ERR_DBG);
 251                 }
 252         }
 253
 254         /* Clear interrupt */
 255         otx2_write64(intr, dev->base + NIX_LF_QINTX_INT(qintx));
 256
 257         /* Dump registers to std out */
 258         otx2_nix_reg_dump(dev, NULL);
 259         otx2_nix_queues_ctx_dump(eth_dev);
 260 }
 261
 262 int
 263 oxt2_nix_register_queue_irqs(struct rte_eth_dev *eth_dev)
 264 {
 265         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 266         struct rte_intr_handle *handle = &pci_dev->intr_handle;
 267         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 268         int vec, q, sqs, rqs, qs, rc = 0;
 269
 270         /* Figure out max qintx required */
 271         rqs = RTE_MIN(dev->qints, eth_dev->data->nb_rx_queues);
 272         sqs = RTE_MIN(dev->qints, eth_dev->data->nb_tx_queues);
 273         qs  = RTE_MAX(rqs, sqs);
 274
 275         dev->configured_qints = qs;
 276
 277         for (q = 0; q < qs; q++) {
 278                 vec = dev->nix_msixoff + NIX_LF_INT_VEC_QINT_START + q;
 279
 280                 /* Clear QINT CNT */
 281                 otx2_write64(0, dev->base + NIX_LF_QINTX_CNT(q));
 282
 283                 /* Clear interrupt */
 284                 otx2_write64(~0ull, dev->base + NIX_LF_QINTX_ENA_W1C(q));
 285
 286                 dev->qints_mem[q].eth_dev = eth_dev;
 287                 dev->qints_mem[q].qintx = q;
 288
 289                 /* Sync qints_mem update */
 290                 rte_smp_wmb();
 291
 292                 /* Register queue irq vector */
 293                 rc = otx2_register_irq(handle, nix_lf_q_irq,
 294                                        &dev->qints_mem[q], vec);
 295                 if (rc)
 296                         break;
 297
 298                 otx2_write64(0, dev->base + NIX_LF_QINTX_CNT(q));
 299                 otx2_write64(0, dev->base + NIX_LF_QINTX_INT(q));
 300                 /* Enable QINT interrupt */
 301                 otx2_write64(~0ull, dev->base + NIX_LF_QINTX_ENA_W1S(q));
 302         }
 303
 304         return rc;
 305 }
 306
 307 void
 308 oxt2_nix_unregister_queue_irqs(struct rte_eth_dev *eth_dev)
 309 {
 310         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 311         struct rte_intr_handle *handle = &pci_dev->intr_handle;
 312         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 313         int vec, q;
 314
 315         for (q = 0; q < dev->configured_qints; q++) {
 316                 vec = dev->nix_msixoff + NIX_LF_INT_VEC_QINT_START + q;
 317
 318                 /* Clear QINT CNT */
 319                 otx2_write64(0, dev->base + NIX_LF_QINTX_CNT(q));
 320                 otx2_write64(0, dev->base + NIX_LF_QINTX_INT(q));
 321
 322                 /* Clear interrupt */
 323                 otx2_write64(~0ull, dev->base + NIX_LF_QINTX_ENA_W1C(q));
 324
 325                 /* Unregister queue irq vector */
 326                 otx2_unregister_irq(handle, nix_lf_q_irq,
 327                                     &dev->qints_mem[q], vec);
 328         }
 329 }
 330
 331 int
 332 oxt2_nix_register_cq_irqs(struct rte_eth_dev *eth_dev)
 333 {
 334         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 335         struct rte_intr_handle *handle = &pci_dev->intr_handle;
 336         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 337         uint8_t rc = 0, vec, q;
 338
 339         dev->configured_cints = RTE_MIN(dev->cints,
 340                                         eth_dev->data->nb_rx_queues);
 341
 342         for (q = 0; q < dev->configured_cints; q++) {
 343                 vec = dev->nix_msixoff + NIX_LF_INT_VEC_CINT_START + q;
 344
 345                 /* Clear CINT CNT */
 346                 otx2_write64(0, dev->base + NIX_LF_CINTX_CNT(q));
 347
 348                 /* Clear interrupt */
 349                 otx2_write64(BIT_ULL(0), dev->base + NIX_LF_CINTX_ENA_W1C(q));
 350
 351                 dev->cints_mem[q].eth_dev = eth_dev;
 352                 dev->cints_mem[q].qintx = q;
 353
 354                 /* Sync cints_mem update */
 355                 rte_smp_wmb();
 356
 357                 /* Register queue irq vector */
 358                 rc = otx2_register_irq(handle, nix_lf_cq_irq,
 359                                        &dev->cints_mem[q], vec);
 360                 if (rc) {
 361                         otx2_err("Fail to register CQ irq, rc=%d", rc);
 362                         return rc;
 363                 }
 364
 365                 if (!handle->intr_vec) {
 366                         handle->intr_vec = rte_zmalloc("intr_vec",
 367                                             dev->configured_cints *
 368                                             sizeof(int), 0);
 369                         if (!handle->intr_vec) {
 370                                 otx2_err("Failed to allocate %d rx intr_vec",
 371                                          dev->configured_cints);
 372                                 return -ENOMEM;
 373                         }
 374                 }
 375                 /* VFIO vector zero is resereved for misc interrupt so
 376                  * doing required adjustment. (b13bfab4cd)
 377                  */
 378                 handle->intr_vec[q] = RTE_INTR_VEC_RXTX_OFFSET + vec;
 379
 380                 /* Configure CQE interrupt coalescing parameters */
 381                 otx2_write64(((CQ_CQE_THRESH_DEFAULT) |
 382                               (CQ_CQE_THRESH_DEFAULT << 32) |
 383                               (CQ_TIMER_THRESH_DEFAULT << 48)),
 384                              dev->base + NIX_LF_CINTX_WAIT((q)));
 385
 386                 /* Keeping the CQ interrupt disabled as the rx interrupt
 387                  * feature needs to be enabled/disabled on demand.
 388                  */
 389         }
 390
 391         return rc;
 392 }
 393
 394 void
 395 oxt2_nix_unregister_cq_irqs(struct rte_eth_dev *eth_dev)
 396 {
 397         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 398         struct rte_intr_handle *handle = &pci_dev->intr_handle;
 399         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 400         int vec, q;
 401
 402         for (q = 0; q < dev->configured_cints; q++) {
 403                 vec = dev->nix_msixoff + NIX_LF_INT_VEC_CINT_START + q;
 404
 405                 /* Clear CINT CNT */
 406                 otx2_write64(0, dev->base + NIX_LF_CINTX_CNT(q));
 407
 408                 /* Clear interrupt */
 409                 otx2_write64(BIT_ULL(0), dev->base + NIX_LF_CINTX_ENA_W1C(q));
 410
 411                 /* Unregister queue irq vector */
 412                 otx2_unregister_irq(handle, nix_lf_cq_irq,
 413                                     &dev->cints_mem[q], vec);
 414         }
 415 }
 416
 417 int
 418 otx2_nix_register_irqs(struct rte_eth_dev *eth_dev)
 419 {
 420         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 421         int rc;
 422
 423         if (dev->nix_msixoff == MSIX_VECTOR_INVALID) {
 424                 otx2_err("Invalid NIXLF MSIX vector offset vector: 0x%x",
 425                          dev->nix_msixoff);
 426                 return -EINVAL;
 427         }
 428
 429         /* Register lf err interrupt */
 430         rc = nix_lf_register_err_irq(eth_dev);
 431         /* Register RAS interrupt */
 432         rc |= nix_lf_register_ras_irq(eth_dev);
 433
 434         return rc;
 435 }
 436
 437 void
 438 otx2_nix_unregister_irqs(struct rte_eth_dev *eth_dev)
 439 {
 440         nix_lf_unregister_err_irq(eth_dev);
 441         nix_lf_unregister_ras_irq(eth_dev);
 442 }
 443
 444 int
 445 otx2_nix_rx_queue_intr_enable(struct rte_eth_dev *eth_dev,
 446                               uint16_t rx_queue_id)
 447 {
 448         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 449
 450         /* Enable CINT interrupt */
 451         otx2_write64(BIT_ULL(0), dev->base +
 452                      NIX_LF_CINTX_ENA_W1S(rx_queue_id));
 453
 454         return 0;
 455 }
 456
 457 int
 458 otx2_nix_rx_queue_intr_disable(struct rte_eth_dev *eth_dev,
 459                                uint16_t rx_queue_id)
 460 {
 461         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 462
 463         /* Clear and disable CINT interrupt */
 464         otx2_write64(BIT_ULL(0), dev->base +
 465                      NIX_LF_CINTX_ENA_W1C(rx_queue_id));
 466
 467         return 0;
 468 }