octeontx2-af: add debugfs entries for CPT block

Add entries to debugfs at /sys/kernel/debug/octeontx2/cpt.

cpt_pc: dump cpt performance HW registers.
Usage:
cat /sys/kernel/debug/octeontx2/cpt/cpt_pc

cpt_ae_sts: show cpt asymmetric engines current state
Usage:
cat /sys/kernel/debug/octeontx2/cpt/cpt_ae_sts

cpt_se_sts: show cpt symmetric engines current state
Usage:
cat /sys/kernel/debug/octeontx2/cpt/cpt_se_sts

cpt_engines_info: dump cpt engine control registers.
Usage:
cat /sys/kernel/debug/octeontx2/cpt/cpt_engines_info

cpt_lfs_info: dump cpt lfs control registers.
Usage:
cat /sys/kernel/debug/octeontx2/cpt/cpt_lfs_info

cpt_err_info: dump cpt error registers.
Usage:
cat /sys/kernel/debug/octeontx2/cpt/cpt_err_info

Signed-off-by: Suheil Chandran <schandran@marvell.com>
Signed-off-by: Srujana Challa <schalla@marvell.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/drivers/net/ethernet/marvell/octeontx2/af/rvu.h b/drivers/net/ethernet/marvell/octeontx2/af/rvu.h
index 37774ba..b6c0977 100644 (file)
--- a/drivers/net/ethernet/marvell/octeontx2/af/rvu.h
+++ b/drivers/net/ethernet/marvell/octeontx2/af/rvu.h
@@ -52,6 +52,7 @@ struct rvu_debugfs {
        struct dentry *npa;
        struct dentry *nix;
        struct dentry *npc;
+       struct dentry *cpt;
        struct dump_ctx npa_aura_ctx;
        struct dump_ctx npa_pool_ctx;
        struct dump_ctx nix_cq_ctx;

diff --git a/drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c b/drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c
index 39e1a61..c383efc 100644 (file)
--- a/drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c
+++ b/drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c
@@ -109,6 +109,12 @@ static char *cgx_tx_stats_fields[] = {
        [CGX_STAT17]    = "Control/PAUSE packets sent",
 };
 
+enum cpt_eng_type {
+       CPT_AE_TYPE = 1,
+       CPT_SE_TYPE = 2,
+       CPT_IE_TYPE = 3,
+};
+
 #define NDC_MAX_BANK(rvu, blk_addr) (rvu_read64(rvu, \
                                                blk_addr, NDC_AF_CONST) & 0xFF)
 
@@ -1993,6 +1999,271 @@ create_failed:
        debugfs_remove_recursive(rvu->rvu_dbg.npc);
 }
 
+/* CPT debugfs APIs */
+static int cpt_eng_sts_display(struct seq_file *filp, u8 eng_type)
+{
+       struct rvu *rvu = filp->private;
+       u64 busy_sts = 0, free_sts = 0;
+       u32 e_min = 0, e_max = 0, e, i;
+       u16 max_ses, max_ies, max_aes;
+       int blkaddr;
+       u64 reg;
+
+       blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_CPT, 0);
+       if (blkaddr < 0)
+               return -ENODEV;
+
+       reg = rvu_read64(rvu, blkaddr, CPT_AF_CONSTANTS1);
+       max_ses = reg & 0xffff;
+       max_ies = (reg >> 16) & 0xffff;
+       max_aes = (reg >> 32) & 0xffff;
+
+       switch (eng_type) {
+       case CPT_AE_TYPE:
+               e_min = max_ses + max_ies;
+               e_max = max_ses + max_ies + max_aes;
+               break;
+       case CPT_SE_TYPE:
+               e_min = 0;
+               e_max = max_ses;
+               break;
+       case CPT_IE_TYPE:
+               e_min = max_ses;
+               e_max = max_ses + max_ies;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       for (e = e_min, i = 0; e < e_max; e++, i++) {
+               reg = rvu_read64(rvu, blkaddr, CPT_AF_EXEX_STS(e));
+               if (reg & 0x1)
+                       busy_sts |= 1ULL << i;
+
+               if (reg & 0x2)
+                       free_sts |= 1ULL << i;
+       }
+       seq_printf(filp, "FREE STS : 0x%016llx\n", free_sts);
+       seq_printf(filp, "BUSY STS : 0x%016llx\n", busy_sts);
+
+       return 0;
+}
+
+static int rvu_dbg_cpt_ae_sts_display(struct seq_file *filp, void *unused)
+{
+       return cpt_eng_sts_display(filp, CPT_AE_TYPE);
+}
+
+RVU_DEBUG_SEQ_FOPS(cpt_ae_sts, cpt_ae_sts_display, NULL);
+
+static int rvu_dbg_cpt_se_sts_display(struct seq_file *filp, void *unused)
+{
+       return cpt_eng_sts_display(filp, CPT_SE_TYPE);
+}
+
+RVU_DEBUG_SEQ_FOPS(cpt_se_sts, cpt_se_sts_display, NULL);
+
+static int rvu_dbg_cpt_ie_sts_display(struct seq_file *filp, void *unused)
+{
+       return cpt_eng_sts_display(filp, CPT_IE_TYPE);
+}
+
+RVU_DEBUG_SEQ_FOPS(cpt_ie_sts, cpt_ie_sts_display, NULL);
+
+static int rvu_dbg_cpt_engines_info_display(struct seq_file *filp, void *unused)
+{
+       struct rvu *rvu = filp->private;
+       u16 max_ses, max_ies, max_aes;
+       u32 e_max, e;
+       int blkaddr;
+       u64 reg;
+
+       blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_CPT, 0);
+       if (blkaddr < 0)
+               return -ENODEV;
+
+       reg = rvu_read64(rvu, blkaddr, CPT_AF_CONSTANTS1);
+       max_ses = reg & 0xffff;
+       max_ies = (reg >> 16) & 0xffff;
+       max_aes = (reg >> 32) & 0xffff;
+
+       e_max = max_ses + max_ies + max_aes;
+
+       seq_puts(filp, "===========================================\n");
+       for (e = 0; e < e_max; e++) {
+               reg = rvu_read64(rvu, blkaddr, CPT_AF_EXEX_CTL2(e));
+               seq_printf(filp, "CPT Engine[%u] Group Enable   0x%02llx\n", e,
+                          reg & 0xff);
+               reg = rvu_read64(rvu, blkaddr, CPT_AF_EXEX_ACTIVE(e));
+               seq_printf(filp, "CPT Engine[%u] Active Info    0x%llx\n", e,
+                          reg);
+               reg = rvu_read64(rvu, blkaddr, CPT_AF_EXEX_CTL(e));
+               seq_printf(filp, "CPT Engine[%u] Control        0x%llx\n", e,
+                          reg);
+               seq_puts(filp, "===========================================\n");
+       }
+       return 0;
+}
+
+RVU_DEBUG_SEQ_FOPS(cpt_engines_info, cpt_engines_info_display, NULL);
+
+static int rvu_dbg_cpt_lfs_info_display(struct seq_file *filp, void *unused)
+{
+       struct rvu *rvu = filp->private;
+       struct rvu_hwinfo *hw = rvu->hw;
+       struct rvu_block *block;
+       int blkaddr;
+       u64 reg;
+       u32 lf;
+
+       blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_CPT, 0);
+       if (blkaddr < 0)
+               return -ENODEV;
+
+       block = &hw->block[blkaddr];
+       if (!block->lf.bmap)
+               return -ENODEV;
+
+       seq_puts(filp, "===========================================\n");
+       for (lf = 0; lf < block->lf.max; lf++) {
+               reg = rvu_read64(rvu, blkaddr, CPT_AF_LFX_CTL(lf));
+               seq_printf(filp, "CPT Lf[%u] CTL          0x%llx\n", lf, reg);
+               reg = rvu_read64(rvu, blkaddr, CPT_AF_LFX_CTL2(lf));
+               seq_printf(filp, "CPT Lf[%u] CTL2         0x%llx\n", lf, reg);
+               reg = rvu_read64(rvu, blkaddr, CPT_AF_LFX_PTR_CTL(lf));
+               seq_printf(filp, "CPT Lf[%u] PTR_CTL      0x%llx\n", lf, reg);
+               reg = rvu_read64(rvu, blkaddr, block->lfcfg_reg |
+                               (lf << block->lfshift));
+               seq_printf(filp, "CPT Lf[%u] CFG          0x%llx\n", lf, reg);
+               seq_puts(filp, "===========================================\n");
+       }
+       return 0;
+}
+
+RVU_DEBUG_SEQ_FOPS(cpt_lfs_info, cpt_lfs_info_display, NULL);
+
+static int rvu_dbg_cpt_err_info_display(struct seq_file *filp, void *unused)
+{
+       struct rvu *rvu = filp->private;
+       u64 reg0, reg1;
+       int blkaddr;
+
+       blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_CPT, 0);
+       if (blkaddr < 0)
+               return -ENODEV;
+
+       reg0 = rvu_read64(rvu, blkaddr, CPT_AF_FLTX_INT(0));
+       reg1 = rvu_read64(rvu, blkaddr, CPT_AF_FLTX_INT(1));
+       seq_printf(filp, "CPT_AF_FLTX_INT:       0x%llx 0x%llx\n", reg0, reg1);
+       reg0 = rvu_read64(rvu, blkaddr, CPT_AF_PSNX_EXE(0));
+       reg1 = rvu_read64(rvu, blkaddr, CPT_AF_PSNX_EXE(1));
+       seq_printf(filp, "CPT_AF_PSNX_EXE:       0x%llx 0x%llx\n", reg0, reg1);
+       reg0 = rvu_read64(rvu, blkaddr, CPT_AF_PSNX_LF(0));
+       seq_printf(filp, "CPT_AF_PSNX_LF:        0x%llx\n", reg0);
+       reg0 = rvu_read64(rvu, blkaddr, CPT_AF_RVU_INT);
+       seq_printf(filp, "CPT_AF_RVU_INT:        0x%llx\n", reg0);
+       reg0 = rvu_read64(rvu, blkaddr, CPT_AF_RAS_INT);
+       seq_printf(filp, "CPT_AF_RAS_INT:        0x%llx\n", reg0);
+       reg0 = rvu_read64(rvu, blkaddr, CPT_AF_EXE_ERR_INFO);
+       seq_printf(filp, "CPT_AF_EXE_ERR_INFO:   0x%llx\n", reg0);
+
+       return 0;
+}
+
+RVU_DEBUG_SEQ_FOPS(cpt_err_info, cpt_err_info_display, NULL);
+
+static int rvu_dbg_cpt_pc_display(struct seq_file *filp, void *unused)
+{
+       struct rvu *rvu;
+       int blkaddr;
+       u64 reg;
+
+       rvu = filp->private;
+       blkaddr = rvu_get_blkaddr(rvu, BLKTYPE_CPT, 0);
+       if (blkaddr < 0)
+               return -ENODEV;
+
+       reg = rvu_read64(rvu, blkaddr, CPT_AF_INST_REQ_PC);
+       seq_printf(filp, "CPT instruction requests   %llu\n", reg);
+       reg = rvu_read64(rvu, blkaddr, CPT_AF_INST_LATENCY_PC);
+       seq_printf(filp, "CPT instruction latency    %llu\n", reg);
+       reg = rvu_read64(rvu, blkaddr, CPT_AF_RD_REQ_PC);
+       seq_printf(filp, "CPT NCB read requests      %llu\n", reg);
+       reg = rvu_read64(rvu, blkaddr, CPT_AF_RD_LATENCY_PC);
+       seq_printf(filp, "CPT NCB read latency       %llu\n", reg);
+       reg = rvu_read64(rvu, blkaddr, CPT_AF_RD_UC_PC);
+       seq_printf(filp, "CPT read requests caused by UC fills   %llu\n", reg);
+       reg = rvu_read64(rvu, blkaddr, CPT_AF_ACTIVE_CYCLES_PC);
+       seq_printf(filp, "CPT active cycles pc       %llu\n", reg);
+       reg = rvu_read64(rvu, blkaddr, CPT_AF_CPTCLK_CNT);
+       seq_printf(filp, "CPT clock count pc         %llu\n", reg);
+
+       return 0;
+}
+
+RVU_DEBUG_SEQ_FOPS(cpt_pc, cpt_pc_display, NULL);
+
+static void rvu_dbg_cpt_init(struct rvu *rvu)
+{
+       const struct device *dev = &rvu->pdev->dev;
+       struct dentry *pfile;
+
+       if (!is_block_implemented(rvu->hw, BLKADDR_CPT0))
+               return;
+
+       rvu->rvu_dbg.cpt = debugfs_create_dir("cpt", rvu->rvu_dbg.root);
+       if (!rvu->rvu_dbg.cpt)
+               return;
+
+       pfile = debugfs_create_file("cpt_pc", 0600,
+                                   rvu->rvu_dbg.cpt, rvu,
+                                   &rvu_dbg_cpt_pc_fops);
+       if (!pfile)
+               goto create_failed;
+
+       pfile = debugfs_create_file("cpt_ae_sts", 0600,
+                                   rvu->rvu_dbg.cpt, rvu,
+                                   &rvu_dbg_cpt_ae_sts_fops);
+       if (!pfile)
+               goto create_failed;
+
+       pfile = debugfs_create_file("cpt_se_sts", 0600,
+                                   rvu->rvu_dbg.cpt, rvu,
+                                   &rvu_dbg_cpt_se_sts_fops);
+       if (!pfile)
+               goto create_failed;
+
+       pfile = debugfs_create_file("cpt_ie_sts", 0600,
+                                   rvu->rvu_dbg.cpt, rvu,
+                                   &rvu_dbg_cpt_ie_sts_fops);
+       if (!pfile)
+               goto create_failed;
+
+       pfile = debugfs_create_file("cpt_engines_info", 0600,
+                                   rvu->rvu_dbg.cpt, rvu,
+                                   &rvu_dbg_cpt_engines_info_fops);
+       if (!pfile)
+               goto create_failed;
+
+       pfile = debugfs_create_file("cpt_lfs_info", 0600,
+                                   rvu->rvu_dbg.cpt, rvu,
+                                   &rvu_dbg_cpt_lfs_info_fops);
+       if (!pfile)
+               goto create_failed;
+
+       pfile = debugfs_create_file("cpt_err_info", 0600,
+                                   rvu->rvu_dbg.cpt, rvu,
+                                   &rvu_dbg_cpt_err_info_fops);
+       if (!pfile)
+               goto create_failed;
+
+       return;
+
+create_failed:
+       dev_err(dev, "Failed to create debugfs dir/file for CPT\n");
+       debugfs_remove_recursive(rvu->rvu_dbg.cpt);
+}
+
 void rvu_dbg_init(struct rvu *rvu)
 {
        struct device *dev = &rvu->pdev->dev;
@@ -2019,6 +2290,7 @@ void rvu_dbg_init(struct rvu *rvu)
        rvu_dbg_nix_init(rvu, BLKADDR_NIX1);
        rvu_dbg_cgx_init(rvu);
        rvu_dbg_npc_init(rvu);
+       rvu_dbg_cpt_init(rvu);
 
        return;