drivers/mempool/octeontx2/otx2_mempool_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_common.h>
   8 #include <rte_bus_pci.h>
   9
  10 #include "otx2_common.h"
  11 #include "otx2_irq.h"
  12 #include "otx2_mempool.h"
  13
  14 static void
  15 npa_lf_err_irq(void *param)
  16 {
  17         struct otx2_npa_lf *lf = (struct otx2_npa_lf *)param;
  18         uint64_t intr;
  19
  20         intr = otx2_read64(lf->base + NPA_LF_ERR_INT);
  21         if (intr == 0)
  22                 return;
  23
  24         otx2_err("Err_intr=0x%" PRIx64 "", intr);
  25
  26         /* Clear interrupt */
  27         otx2_write64(intr, lf->base + NPA_LF_ERR_INT);
  28 }
  29
  30 static int
  31 npa_lf_register_err_irq(struct otx2_npa_lf *lf)
  32 {
  33         struct rte_intr_handle *handle = lf->intr_handle;
  34         int rc, vec;
  35
  36         vec = lf->npa_msixoff + NPA_LF_INT_VEC_ERR_INT;
  37
  38         /* Clear err interrupt */
  39         otx2_write64(~0ull, lf->base + NPA_LF_ERR_INT_ENA_W1C);
  40         /* Register err interrupt vector */
  41         rc = otx2_register_irq(handle, npa_lf_err_irq, lf, vec);
  42
  43         /* Enable hw interrupt */
  44         otx2_write64(~0ull, lf->base + NPA_LF_ERR_INT_ENA_W1S);
  45
  46         return rc;
  47 }
  48
  49 static void
  50 npa_lf_unregister_err_irq(struct otx2_npa_lf *lf)
  51 {
  52         struct rte_intr_handle *handle = lf->intr_handle;
  53         int vec;
  54
  55         vec = lf->npa_msixoff + NPA_LF_INT_VEC_ERR_INT;
  56
  57         /* Clear err interrupt */
  58         otx2_write64(~0ull, lf->base + NPA_LF_ERR_INT_ENA_W1C);
  59         otx2_unregister_irq(handle, npa_lf_err_irq, lf, vec);
  60 }
  61
  62 static void
  63 npa_lf_ras_irq(void *param)
  64 {
  65         struct otx2_npa_lf *lf = (struct otx2_npa_lf *)param;
  66         uint64_t intr;
  67
  68         intr = otx2_read64(lf->base + NPA_LF_RAS);
  69         if (intr == 0)
  70                 return;
  71
  72         otx2_err("Ras_intr=0x%" PRIx64 "", intr);
  73
  74         /* Clear interrupt */
  75         otx2_write64(intr, lf->base + NPA_LF_RAS);
  76 }
  77
  78 static int
  79 npa_lf_register_ras_irq(struct otx2_npa_lf *lf)
  80 {
  81         struct rte_intr_handle *handle = lf->intr_handle;
  82         int rc, vec;
  83
  84         vec = lf->npa_msixoff + NPA_LF_INT_VEC_POISON;
  85
  86         /* Clear err interrupt */
  87         otx2_write64(~0ull, lf->base + NPA_LF_RAS_ENA_W1C);
  88         /* Set used interrupt vectors */
  89         rc = otx2_register_irq(handle, npa_lf_ras_irq, lf, vec);
  90         /* Enable hw interrupt */
  91         otx2_write64(~0ull, lf->base + NPA_LF_RAS_ENA_W1S);
  92
  93         return rc;
  94 }
  95
  96 static void
  97 npa_lf_unregister_ras_irq(struct otx2_npa_lf *lf)
  98 {
  99         int vec;
 100         struct rte_intr_handle *handle = lf->intr_handle;
 101
 102         vec = lf->npa_msixoff + NPA_LF_INT_VEC_POISON;
 103
 104         /* Clear err interrupt */
 105         otx2_write64(~0ull, lf->base + NPA_LF_RAS_ENA_W1C);
 106         otx2_unregister_irq(handle, npa_lf_ras_irq, lf, vec);
 107 }
 108
 109 static inline uint8_t
 110 npa_lf_q_irq_get_and_clear(struct otx2_npa_lf *lf, uint32_t q,
 111                         uint32_t off, uint64_t mask)
 112 {
 113         uint64_t reg, wdata;
 114         uint8_t qint;
 115
 116         wdata = (uint64_t)q << 44;
 117         reg = otx2_atomic64_add_nosync(wdata, (int64_t *)(lf->base + off));
 118
 119         if (reg & BIT_ULL(42) /* OP_ERR */) {
 120                 otx2_err("Failed execute irq get off=0x%x", off);
 121                 return 0;
 122         }
 123
 124         qint = reg & 0xff;
 125         wdata &= mask;
 126         otx2_write64(wdata, lf->base + off);
 127
 128         return qint;
 129 }
 130
 131 static inline uint8_t
 132 npa_lf_pool_irq_get_and_clear(struct otx2_npa_lf *lf, uint32_t p)
 133 {
 134         return npa_lf_q_irq_get_and_clear(lf, p, NPA_LF_POOL_OP_INT, ~0xff00);
 135 }
 136
 137 static inline uint8_t
 138 npa_lf_aura_irq_get_and_clear(struct otx2_npa_lf *lf, uint32_t a)
 139 {
 140         return npa_lf_q_irq_get_and_clear(lf, a, NPA_LF_AURA_OP_INT, ~0xff00);
 141 }
 142
 143 static void
 144 npa_lf_q_irq(void *param)
 145 {
 146         struct otx2_npa_qint *qint = (struct otx2_npa_qint *)param;
 147         struct otx2_npa_lf *lf = qint->lf;
 148         uint8_t irq, qintx = qint->qintx;
 149         uint32_t q, pool, aura;
 150         uint64_t intr;
 151
 152         intr = otx2_read64(lf->base + NPA_LF_QINTX_INT(qintx));
 153         if (intr == 0)
 154                 return;
 155
 156         otx2_err("queue_intr=0x%" PRIx64 " qintx=%d", intr, qintx);
 157
 158         /* Handle pool queue interrupts */
 159         for (q = 0; q < lf->nr_pools; q++) {
 160                 /* Skip disabled POOL */
 161                 if (rte_bitmap_get(lf->npa_bmp, q))
 162                         continue;
 163
 164                 pool = q % lf->qints;
 165                 irq = npa_lf_pool_irq_get_and_clear(lf, pool);
 166
 167                 if (irq & BIT_ULL(NPA_POOL_ERR_INT_OVFLS))
 168                         otx2_err("Pool=%d NPA_POOL_ERR_INT_OVFLS", pool);
 169
 170                 if (irq & BIT_ULL(NPA_POOL_ERR_INT_RANGE))
 171                         otx2_err("Pool=%d NPA_POOL_ERR_INT_RANGE", pool);
 172
 173                 if (irq & BIT_ULL(NPA_POOL_ERR_INT_PERR))
 174                         otx2_err("Pool=%d NPA_POOL_ERR_INT_PERR", pool);
 175         }
 176
 177         /* Handle aura queue interrupts */
 178         for (q = 0; q < lf->nr_pools; q++) {
 179
 180                 /* Skip disabled AURA */
 181                 if (rte_bitmap_get(lf->npa_bmp, q))
 182                         continue;
 183
 184                 aura = q % lf->qints;
 185                 irq = npa_lf_aura_irq_get_and_clear(lf, aura);
 186
 187                 if (irq & BIT_ULL(NPA_AURA_ERR_INT_AURA_ADD_OVER))
 188                         otx2_err("Aura=%d NPA_AURA_ERR_INT_ADD_OVER", aura);
 189
 190                 if (irq & BIT_ULL(NPA_AURA_ERR_INT_AURA_ADD_UNDER))
 191                         otx2_err("Aura=%d NPA_AURA_ERR_INT_ADD_UNDER", aura);
 192
 193                 if (irq & BIT_ULL(NPA_AURA_ERR_INT_AURA_FREE_UNDER))
 194                         otx2_err("Aura=%d NPA_AURA_ERR_INT_FREE_UNDER", aura);
 195
 196                 if (irq & BIT_ULL(NPA_AURA_ERR_INT_POOL_DIS))
 197                         otx2_err("Aura=%d NPA_AURA_ERR_POOL_DIS", aura);
 198         }
 199
 200         /* Clear interrupt */
 201         otx2_write64(intr, lf->base + NPA_LF_QINTX_INT(qintx));
 202 }
 203
 204 static int
 205 npa_lf_register_queue_irqs(struct otx2_npa_lf *lf)
 206 {
 207         struct rte_intr_handle *handle = lf->intr_handle;
 208         int vec, q, qs, rc = 0;
 209
 210         /* Figure out max qintx required */
 211         qs = RTE_MIN(lf->qints, lf->nr_pools);
 212
 213         for (q = 0; q < qs; q++) {
 214                 vec = lf->npa_msixoff + NPA_LF_INT_VEC_QINT_START + q;
 215
 216                 /* Clear QINT CNT */
 217                 otx2_write64(0, lf->base + NPA_LF_QINTX_CNT(q));
 218
 219                 /* Clear interrupt */
 220                 otx2_write64(~0ull, lf->base + NPA_LF_QINTX_ENA_W1C(q));
 221
 222                 struct otx2_npa_qint *qintmem = lf->npa_qint_mem;
 223                 qintmem += q;
 224
 225                 qintmem->lf = lf;
 226                 qintmem->qintx = q;
 227
 228                 /* Sync qints_mem update */
 229                 rte_smp_wmb();
 230
 231                 /* Register queue irq vector */
 232                 rc = otx2_register_irq(handle, npa_lf_q_irq, qintmem, vec);
 233                 if (rc)
 234                         break;
 235
 236                 otx2_write64(0, lf->base + NPA_LF_QINTX_CNT(q));
 237                 otx2_write64(0, lf->base + NPA_LF_QINTX_INT(q));
 238                 /* Enable QINT interrupt */
 239                 otx2_write64(~0ull, lf->base + NPA_LF_QINTX_ENA_W1S(q));
 240         }
 241
 242         return rc;
 243 }
 244
 245 static void
 246 npa_lf_unregister_queue_irqs(struct otx2_npa_lf *lf)
 247 {
 248         struct rte_intr_handle *handle = lf->intr_handle;
 249         int vec, q, qs;
 250
 251         /* Figure out max qintx required */
 252         qs = RTE_MIN(lf->qints, lf->nr_pools);
 253
 254         for (q = 0; q < qs; q++) {
 255                 vec = lf->npa_msixoff + NPA_LF_INT_VEC_QINT_START + q;
 256
 257                 /* Clear QINT CNT */
 258                 otx2_write64(0, lf->base + NPA_LF_QINTX_CNT(q));
 259                 otx2_write64(0, lf->base + NPA_LF_QINTX_INT(q));
 260
 261                 /* Clear interrupt */
 262                 otx2_write64(~0ull, lf->base + NPA_LF_QINTX_ENA_W1C(q));
 263
 264                 struct otx2_npa_qint *qintmem = lf->npa_qint_mem;
 265                 qintmem += q;
 266
 267                 /* Unregister queue irq vector */
 268                 otx2_unregister_irq(handle, npa_lf_q_irq, qintmem, vec);
 269
 270                 qintmem->lf = NULL;
 271                 qintmem->qintx = 0;
 272         }
 273 }
 274
 275 int
 276 otx2_npa_register_irqs(struct otx2_npa_lf *lf)
 277 {
 278         int rc;
 279
 280         if (lf->npa_msixoff == MSIX_VECTOR_INVALID) {
 281                 otx2_err("Invalid NPALF MSIX vector offset vector: 0x%x",
 282                         lf->npa_msixoff);
 283                 return -EINVAL;
 284         }
 285
 286         /* Register lf err interrupt */
 287         rc = npa_lf_register_err_irq(lf);
 288         /* Register RAS interrupt */
 289         rc |= npa_lf_register_ras_irq(lf);
 290         /* Register queue interrupts */
 291         rc |= npa_lf_register_queue_irqs(lf);
 292
 293         return rc;
 294 }
 295
 296 void
 297 otx2_npa_unregister_irqs(struct otx2_npa_lf *lf)
 298 {
 299         npa_lf_unregister_err_irq(lf);
 300         npa_lf_unregister_ras_irq(lf);
 301         npa_lf_unregister_queue_irqs(lf);
 302 }