mirror of https://github.com/F-Stack/f-stack.git
304 lines
6.9 KiB
C
304 lines
6.9 KiB
C
/* SPDX-License-Identifier: BSD-3-Clause
|
|
* Copyright(C) 2019 Marvell International Ltd.
|
|
*/
|
|
|
|
#include <inttypes.h>
|
|
|
|
#include <rte_common.h>
|
|
#include <rte_bus_pci.h>
|
|
|
|
#include "otx2_common.h"
|
|
#include "otx2_irq.h"
|
|
#include "otx2_mempool.h"
|
|
|
|
static void
|
|
npa_lf_err_irq(void *param)
|
|
{
|
|
struct otx2_npa_lf *lf = (struct otx2_npa_lf *)param;
|
|
uint64_t intr;
|
|
|
|
intr = otx2_read64(lf->base + NPA_LF_ERR_INT);
|
|
if (intr == 0)
|
|
return;
|
|
|
|
otx2_err("Err_intr=0x%" PRIx64 "", intr);
|
|
|
|
/* Clear interrupt */
|
|
otx2_write64(intr, lf->base + NPA_LF_ERR_INT);
|
|
}
|
|
|
|
static int
|
|
npa_lf_register_err_irq(struct otx2_npa_lf *lf)
|
|
{
|
|
struct rte_intr_handle *handle = lf->intr_handle;
|
|
int rc, vec;
|
|
|
|
vec = lf->npa_msixoff + NPA_LF_INT_VEC_ERR_INT;
|
|
|
|
/* Clear err interrupt */
|
|
otx2_write64(~0ull, lf->base + NPA_LF_ERR_INT_ENA_W1C);
|
|
/* Register err interrupt vector */
|
|
rc = otx2_register_irq(handle, npa_lf_err_irq, lf, vec);
|
|
|
|
/* Enable hw interrupt */
|
|
otx2_write64(~0ull, lf->base + NPA_LF_ERR_INT_ENA_W1S);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static void
|
|
npa_lf_unregister_err_irq(struct otx2_npa_lf *lf)
|
|
{
|
|
struct rte_intr_handle *handle = lf->intr_handle;
|
|
int vec;
|
|
|
|
vec = lf->npa_msixoff + NPA_LF_INT_VEC_ERR_INT;
|
|
|
|
/* Clear err interrupt */
|
|
otx2_write64(~0ull, lf->base + NPA_LF_ERR_INT_ENA_W1C);
|
|
otx2_unregister_irq(handle, npa_lf_err_irq, lf, vec);
|
|
}
|
|
|
|
static void
|
|
npa_lf_ras_irq(void *param)
|
|
{
|
|
struct otx2_npa_lf *lf = (struct otx2_npa_lf *)param;
|
|
uint64_t intr;
|
|
|
|
intr = otx2_read64(lf->base + NPA_LF_RAS);
|
|
if (intr == 0)
|
|
return;
|
|
|
|
otx2_err("Ras_intr=0x%" PRIx64 "", intr);
|
|
|
|
/* Clear interrupt */
|
|
otx2_write64(intr, lf->base + NPA_LF_RAS);
|
|
}
|
|
|
|
static int
|
|
npa_lf_register_ras_irq(struct otx2_npa_lf *lf)
|
|
{
|
|
struct rte_intr_handle *handle = lf->intr_handle;
|
|
int rc, vec;
|
|
|
|
vec = lf->npa_msixoff + NPA_LF_INT_VEC_POISON;
|
|
|
|
/* Clear err interrupt */
|
|
otx2_write64(~0ull, lf->base + NPA_LF_RAS_ENA_W1C);
|
|
/* Set used interrupt vectors */
|
|
rc = otx2_register_irq(handle, npa_lf_ras_irq, lf, vec);
|
|
/* Enable hw interrupt */
|
|
otx2_write64(~0ull, lf->base + NPA_LF_RAS_ENA_W1S);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static void
|
|
npa_lf_unregister_ras_irq(struct otx2_npa_lf *lf)
|
|
{
|
|
int vec;
|
|
struct rte_intr_handle *handle = lf->intr_handle;
|
|
|
|
vec = lf->npa_msixoff + NPA_LF_INT_VEC_POISON;
|
|
|
|
/* Clear err interrupt */
|
|
otx2_write64(~0ull, lf->base + NPA_LF_RAS_ENA_W1C);
|
|
otx2_unregister_irq(handle, npa_lf_ras_irq, lf, vec);
|
|
}
|
|
|
|
static inline uint8_t
|
|
npa_lf_q_irq_get_and_clear(struct otx2_npa_lf *lf, uint32_t q,
|
|
uint32_t off, uint64_t mask)
|
|
{
|
|
uint64_t reg, wdata;
|
|
uint8_t qint;
|
|
|
|
wdata = (uint64_t)q << 44;
|
|
reg = otx2_atomic64_add_nosync(wdata, (int64_t *)(lf->base + off));
|
|
|
|
if (reg & BIT_ULL(42) /* OP_ERR */) {
|
|
otx2_err("Failed execute irq get off=0x%x", off);
|
|
return 0;
|
|
}
|
|
|
|
qint = reg & 0xff;
|
|
wdata &= mask;
|
|
otx2_write64(wdata | qint, lf->base + off);
|
|
|
|
return qint;
|
|
}
|
|
|
|
static inline uint8_t
|
|
npa_lf_pool_irq_get_and_clear(struct otx2_npa_lf *lf, uint32_t p)
|
|
{
|
|
return npa_lf_q_irq_get_and_clear(lf, p, NPA_LF_POOL_OP_INT, ~0xff00);
|
|
}
|
|
|
|
static inline uint8_t
|
|
npa_lf_aura_irq_get_and_clear(struct otx2_npa_lf *lf, uint32_t a)
|
|
{
|
|
return npa_lf_q_irq_get_and_clear(lf, a, NPA_LF_AURA_OP_INT, ~0xff00);
|
|
}
|
|
|
|
static void
|
|
npa_lf_q_irq(void *param)
|
|
{
|
|
struct otx2_npa_qint *qint = (struct otx2_npa_qint *)param;
|
|
struct otx2_npa_lf *lf = qint->lf;
|
|
uint8_t irq, qintx = qint->qintx;
|
|
uint32_t q, pool, aura;
|
|
uint64_t intr;
|
|
|
|
intr = otx2_read64(lf->base + NPA_LF_QINTX_INT(qintx));
|
|
if (intr == 0)
|
|
return;
|
|
|
|
otx2_err("queue_intr=0x%" PRIx64 " qintx=%d", intr, qintx);
|
|
|
|
/* Handle pool queue interrupts */
|
|
for (q = 0; q < lf->nr_pools; q++) {
|
|
/* Skip disabled POOL */
|
|
if (rte_bitmap_get(lf->npa_bmp, q))
|
|
continue;
|
|
|
|
pool = q % lf->qints;
|
|
irq = npa_lf_pool_irq_get_and_clear(lf, pool);
|
|
|
|
if (irq & BIT_ULL(NPA_POOL_ERR_INT_OVFLS))
|
|
otx2_err("Pool=%d NPA_POOL_ERR_INT_OVFLS", pool);
|
|
|
|
if (irq & BIT_ULL(NPA_POOL_ERR_INT_RANGE))
|
|
otx2_err("Pool=%d NPA_POOL_ERR_INT_RANGE", pool);
|
|
|
|
if (irq & BIT_ULL(NPA_POOL_ERR_INT_PERR))
|
|
otx2_err("Pool=%d NPA_POOL_ERR_INT_PERR", pool);
|
|
}
|
|
|
|
/* Handle aura queue interrupts */
|
|
for (q = 0; q < lf->nr_pools; q++) {
|
|
|
|
/* Skip disabled AURA */
|
|
if (rte_bitmap_get(lf->npa_bmp, q))
|
|
continue;
|
|
|
|
aura = q % lf->qints;
|
|
irq = npa_lf_aura_irq_get_and_clear(lf, aura);
|
|
|
|
if (irq & BIT_ULL(NPA_AURA_ERR_INT_AURA_ADD_OVER))
|
|
otx2_err("Aura=%d NPA_AURA_ERR_INT_ADD_OVER", aura);
|
|
|
|
if (irq & BIT_ULL(NPA_AURA_ERR_INT_AURA_ADD_UNDER))
|
|
otx2_err("Aura=%d NPA_AURA_ERR_INT_ADD_UNDER", aura);
|
|
|
|
if (irq & BIT_ULL(NPA_AURA_ERR_INT_AURA_FREE_UNDER))
|
|
otx2_err("Aura=%d NPA_AURA_ERR_INT_FREE_UNDER", aura);
|
|
|
|
if (irq & BIT_ULL(NPA_AURA_ERR_INT_POOL_DIS))
|
|
otx2_err("Aura=%d NPA_AURA_ERR_POOL_DIS", aura);
|
|
}
|
|
|
|
/* Clear interrupt */
|
|
otx2_write64(intr, lf->base + NPA_LF_QINTX_INT(qintx));
|
|
otx2_mempool_ctx_dump(lf);
|
|
}
|
|
|
|
static int
|
|
npa_lf_register_queue_irqs(struct otx2_npa_lf *lf)
|
|
{
|
|
struct rte_intr_handle *handle = lf->intr_handle;
|
|
int vec, q, qs, rc = 0;
|
|
|
|
/* Figure out max qintx required */
|
|
qs = RTE_MIN(lf->qints, lf->nr_pools);
|
|
|
|
for (q = 0; q < qs; q++) {
|
|
vec = lf->npa_msixoff + NPA_LF_INT_VEC_QINT_START + q;
|
|
|
|
/* Clear QINT CNT */
|
|
otx2_write64(0, lf->base + NPA_LF_QINTX_CNT(q));
|
|
|
|
/* Clear interrupt */
|
|
otx2_write64(~0ull, lf->base + NPA_LF_QINTX_ENA_W1C(q));
|
|
|
|
struct otx2_npa_qint *qintmem = lf->npa_qint_mem;
|
|
qintmem += q;
|
|
|
|
qintmem->lf = lf;
|
|
qintmem->qintx = q;
|
|
|
|
/* Sync qints_mem update */
|
|
rte_smp_wmb();
|
|
|
|
/* Register queue irq vector */
|
|
rc = otx2_register_irq(handle, npa_lf_q_irq, qintmem, vec);
|
|
if (rc)
|
|
break;
|
|
|
|
otx2_write64(0, lf->base + NPA_LF_QINTX_CNT(q));
|
|
otx2_write64(0, lf->base + NPA_LF_QINTX_INT(q));
|
|
/* Enable QINT interrupt */
|
|
otx2_write64(~0ull, lf->base + NPA_LF_QINTX_ENA_W1S(q));
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
static void
|
|
npa_lf_unregister_queue_irqs(struct otx2_npa_lf *lf)
|
|
{
|
|
struct rte_intr_handle *handle = lf->intr_handle;
|
|
int vec, q, qs;
|
|
|
|
/* Figure out max qintx required */
|
|
qs = RTE_MIN(lf->qints, lf->nr_pools);
|
|
|
|
for (q = 0; q < qs; q++) {
|
|
vec = lf->npa_msixoff + NPA_LF_INT_VEC_QINT_START + q;
|
|
|
|
/* Clear QINT CNT */
|
|
otx2_write64(0, lf->base + NPA_LF_QINTX_CNT(q));
|
|
otx2_write64(0, lf->base + NPA_LF_QINTX_INT(q));
|
|
|
|
/* Clear interrupt */
|
|
otx2_write64(~0ull, lf->base + NPA_LF_QINTX_ENA_W1C(q));
|
|
|
|
struct otx2_npa_qint *qintmem = lf->npa_qint_mem;
|
|
qintmem += q;
|
|
|
|
/* Unregister queue irq vector */
|
|
otx2_unregister_irq(handle, npa_lf_q_irq, qintmem, vec);
|
|
|
|
qintmem->lf = NULL;
|
|
qintmem->qintx = 0;
|
|
}
|
|
}
|
|
|
|
int
|
|
otx2_npa_register_irqs(struct otx2_npa_lf *lf)
|
|
{
|
|
int rc;
|
|
|
|
if (lf->npa_msixoff == MSIX_VECTOR_INVALID) {
|
|
otx2_err("Invalid NPALF MSIX vector offset vector: 0x%x",
|
|
lf->npa_msixoff);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Register lf err interrupt */
|
|
rc = npa_lf_register_err_irq(lf);
|
|
/* Register RAS interrupt */
|
|
rc |= npa_lf_register_ras_irq(lf);
|
|
/* Register queue interrupts */
|
|
rc |= npa_lf_register_queue_irqs(lf);
|
|
|
|
return rc;
|
|
}
|
|
|
|
void
|
|
otx2_npa_unregister_irqs(struct otx2_npa_lf *lf)
|
|
{
|
|
npa_lf_unregister_err_irq(lf);
|
|
npa_lf_unregister_ras_irq(lf);
|
|
npa_lf_unregister_queue_irqs(lf);
|
|
}
|