Commit 0f3ce484 authored by Rakesh Babu's avatar Rakesh Babu Committed by Jakub Kicinski
Browse files

octeontx2-af: Display NIX1 also in debugfs 



If NIX1 block is also implemented then add a new
directory for NIX1 in debugfs root. Stats of
NIX1 block can be read/writen from/to the files
in directory "/sys/kernel/debug/octeontx2/nix1/".

Signed-off-by: default avatarRakesh Babu <rsaladi2@marvell.com>
Signed-off-by: default avatarSubbaraya Sundeep <sbhatta@marvell.com>
Signed-off-by: default avatarSunil Goutham <sgoutham@marvell.com>
Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent 8bcf5ced

drivers/net/ethernet/marvell/octeontx2/af/common.h

+2 −0
Original line number Diff line number Diff line
@@ -210,6 +210,8 @@ enum ndc_idx_e { 
	NIX0_RX = 0x0,

	NIX0_TX = 0x1,

	NPA0_U  = 0x2,

	NIX1_RX = 0x4,

	NIX1_TX = 0x5,

};



enum ndc_ctype_e {

drivers/net/ethernet/marvell/octeontx2/af/rvu_debugfs.c

+123 −43
Original line number Diff line number Diff line
@@ -224,18 +224,11 @@ static ssize_t rvu_dbg_rsrc_attach_status(struct file *filp, 


RVU_DEBUG_FOPS(rsrc_status, rsrc_attach_status, NULL);



static bool rvu_dbg_is_valid_lf(struct rvu *rvu, int blktype, int lf,

static bool rvu_dbg_is_valid_lf(struct rvu *rvu, int blkaddr, int lf,

				u16 *pcifunc)

{

	struct rvu_block *block;

	struct rvu_hwinfo *hw;

	int blkaddr;



	blkaddr = rvu_get_blkaddr(rvu, blktype, 0);

	if (blkaddr < 0) {

		dev_warn(rvu->dev, "Invalid blktype\n");

		return false;

	}



	hw = rvu->hw;

	block = &hw->block[blkaddr];
@@ -291,10 +284,12 @@ static int rvu_dbg_qsize_display(struct seq_file *filp, void *unsused, 
{

	void (*print_qsize)(struct seq_file *filp,

			    struct rvu_pfvf *pfvf) = NULL;

	struct dentry *current_dir;

	struct rvu_pfvf *pfvf;

	struct rvu *rvu;

	int qsize_id;

	u16 pcifunc;

	int blkaddr;



	rvu = filp->private;

	switch (blktype) {
@@ -312,7 +307,15 @@ static int rvu_dbg_qsize_display(struct seq_file *filp, void *unsused, 
		return -EINVAL;

	}



	if (!rvu_dbg_is_valid_lf(rvu, blktype, qsize_id, &pcifunc))

	if (blktype == BLKTYPE_NPA) {

		blkaddr = BLKADDR_NPA;

	} else {

		current_dir = filp->file->f_path.dentry->d_parent;

		blkaddr = (!strcmp(current_dir->d_name.name, "nix1") ?

				   BLKADDR_NIX1 : BLKADDR_NIX0);

	}



	if (!rvu_dbg_is_valid_lf(rvu, blkaddr, qsize_id, &pcifunc))

		return -EINVAL;



	pfvf = rvu_get_pfvf(rvu, pcifunc);
@@ -329,6 +332,8 @@ static ssize_t rvu_dbg_qsize_write(struct file *filp, 
	struct seq_file *seqfile = filp->private_data;

	char *cmd_buf, *cmd_buf_tmp, *subtoken;

	struct rvu *rvu = seqfile->private;

	struct dentry *current_dir;

	int blkaddr;

	u16 pcifunc;

	int ret, lf;
@@ -355,7 +360,15 @@ static ssize_t rvu_dbg_qsize_write(struct file *filp, 
		goto qsize_write_done;

	}



	if (!rvu_dbg_is_valid_lf(rvu, blktype, lf, &pcifunc)) {

	if (blktype == BLKTYPE_NPA) {

		blkaddr = BLKADDR_NPA;

	} else {

		current_dir = filp->f_path.dentry->d_parent;

		blkaddr = (!strcmp(current_dir->d_name.name, "nix1") ?

				   BLKADDR_NIX1 : BLKADDR_NIX0);

	}



	if (!rvu_dbg_is_valid_lf(rvu, blkaddr, lf, &pcifunc)) {

		ret = -EINVAL;

		goto qsize_write_done;

	}
@@ -498,7 +511,7 @@ static int rvu_dbg_npa_ctx_display(struct seq_file *m, void *unused, int ctype) 
		return -EINVAL;

	}



	if (!rvu_dbg_is_valid_lf(rvu, BLKTYPE_NPA, npalf, &pcifunc))

	if (!rvu_dbg_is_valid_lf(rvu, BLKADDR_NPA, npalf, &pcifunc))

		return -EINVAL;



	pfvf = rvu_get_pfvf(rvu, pcifunc);
@@ -556,7 +569,7 @@ static int write_npa_ctx(struct rvu *rvu, bool all, 
	int max_id = 0;

	u16 pcifunc;



	if (!rvu_dbg_is_valid_lf(rvu, BLKTYPE_NPA, npalf, &pcifunc))

	if (!rvu_dbg_is_valid_lf(rvu, BLKADDR_NPA, npalf, &pcifunc))

		return -EINVAL;



	pfvf = rvu_get_pfvf(rvu, pcifunc);
@@ -704,9 +717,17 @@ static void ndc_cache_stats(struct seq_file *s, int blk_addr, 
			    int ctype, int transaction)

{

	u64 req, out_req, lat, cant_alloc;

	struct rvu *rvu = s->private;

	struct nix_hw *nix_hw;

	struct rvu *rvu;

	int port;



	if (blk_addr == BLKADDR_NDC_NPA0) {

		rvu = s->private;

	} else {

		nix_hw = s->private;

		rvu = nix_hw->rvu;

	}



	for (port = 0; port < NDC_MAX_PORT; port++) {

		req = rvu_read64(rvu, blk_addr, NDC_AF_PORTX_RTX_RWX_REQ_PC

						(port, ctype, transaction));
@@ -749,9 +770,17 @@ RVU_DEBUG_SEQ_FOPS(npa_ndc_cache, npa_ndc_cache_display, NULL); 


static int ndc_blk_hits_miss_stats(struct seq_file *s, int idx, int blk_addr)

{

	struct rvu *rvu = s->private;

	struct nix_hw *nix_hw;

	struct rvu *rvu;

	int bank, max_bank;



	if (blk_addr == BLKADDR_NDC_NPA0) {

		rvu = s->private;

	} else {

		nix_hw = s->private;

		rvu = nix_hw->rvu;

	}



	max_bank = NDC_MAX_BANK(rvu, blk_addr);

	for (bank = 0; bank < max_bank; bank++) {

		seq_printf(s, "BANK:%d\n", bank);
@@ -767,16 +796,30 @@ static int ndc_blk_hits_miss_stats(struct seq_file *s, int idx, int blk_addr) 


static int rvu_dbg_nix_ndc_rx_cache_display(struct seq_file *filp, void *unused)

{

	return ndc_blk_cache_stats(filp, NIX0_RX,

				   BLKADDR_NDC_NIX0_RX);

	struct nix_hw *nix_hw = filp->private;

	int blkaddr = 0;

	int ndc_idx = 0;



	blkaddr = (nix_hw->blkaddr == BLKADDR_NIX1 ?

		   BLKADDR_NDC_NIX1_RX : BLKADDR_NDC_NIX0_RX);

	ndc_idx = (nix_hw->blkaddr == BLKADDR_NIX1 ? NIX1_RX : NIX0_RX);



	return ndc_blk_cache_stats(filp, ndc_idx, blkaddr);

}



RVU_DEBUG_SEQ_FOPS(nix_ndc_rx_cache, nix_ndc_rx_cache_display, NULL);



static int rvu_dbg_nix_ndc_tx_cache_display(struct seq_file *filp, void *unused)

{

	return ndc_blk_cache_stats(filp, NIX0_TX,

				   BLKADDR_NDC_NIX0_TX);

	struct nix_hw *nix_hw = filp->private;

	int blkaddr = 0;

	int ndc_idx = 0;



	blkaddr = (nix_hw->blkaddr == BLKADDR_NIX1 ?

		   BLKADDR_NDC_NIX1_TX : BLKADDR_NDC_NIX0_TX);

	ndc_idx = (nix_hw->blkaddr == BLKADDR_NIX1 ? NIX1_TX : NIX0_TX);



	return ndc_blk_cache_stats(filp, ndc_idx, blkaddr);

}



RVU_DEBUG_SEQ_FOPS(nix_ndc_tx_cache, nix_ndc_tx_cache_display, NULL);
@@ -792,8 +835,14 @@ RVU_DEBUG_SEQ_FOPS(npa_ndc_hits_miss, npa_ndc_hits_miss_display, NULL); 
static int rvu_dbg_nix_ndc_rx_hits_miss_display(struct seq_file *filp,

						void *unused)

{

	return ndc_blk_hits_miss_stats(filp,

				      NPA0_U, BLKADDR_NDC_NIX0_RX);

	struct nix_hw *nix_hw = filp->private;

	int ndc_idx = NPA0_U;

	int blkaddr = 0;



	blkaddr = (nix_hw->blkaddr == BLKADDR_NIX1 ?

		   BLKADDR_NDC_NIX1_RX : BLKADDR_NDC_NIX0_RX);



	return ndc_blk_hits_miss_stats(filp, ndc_idx, blkaddr);

}



RVU_DEBUG_SEQ_FOPS(nix_ndc_rx_hits_miss, nix_ndc_rx_hits_miss_display, NULL);
@@ -801,8 +850,14 @@ RVU_DEBUG_SEQ_FOPS(nix_ndc_rx_hits_miss, nix_ndc_rx_hits_miss_display, NULL); 
static int rvu_dbg_nix_ndc_tx_hits_miss_display(struct seq_file *filp,

						void *unused)

{

	return ndc_blk_hits_miss_stats(filp,

				      NPA0_U, BLKADDR_NDC_NIX0_TX);

	struct nix_hw *nix_hw = filp->private;

	int ndc_idx = NPA0_U;

	int blkaddr = 0;



	blkaddr = (nix_hw->blkaddr == BLKADDR_NIX1 ?

		   BLKADDR_NDC_NIX1_TX : BLKADDR_NDC_NIX0_TX);



	return ndc_blk_hits_miss_stats(filp, ndc_idx, blkaddr);

}



RVU_DEBUG_SEQ_FOPS(nix_ndc_tx_hits_miss, nix_ndc_tx_hits_miss_display, NULL);
@@ -969,7 +1024,8 @@ static int rvu_dbg_nix_queue_ctx_display(struct seq_file *filp, 
{

	void (*print_nix_ctx)(struct seq_file *filp,

			      struct nix_aq_enq_rsp *rsp) = NULL;

	struct rvu *rvu = filp->private;

	struct nix_hw *nix_hw = filp->private;

	struct rvu *rvu = nix_hw->rvu;

	struct nix_aq_enq_req aq_req;

	struct nix_aq_enq_rsp rsp;

	char *ctype_string = NULL;
@@ -1001,7 +1057,7 @@ static int rvu_dbg_nix_queue_ctx_display(struct seq_file *filp, 
		return -EINVAL;

	}



	if (!rvu_dbg_is_valid_lf(rvu, BLKTYPE_NIX, nixlf, &pcifunc))

	if (!rvu_dbg_is_valid_lf(rvu, nix_hw->blkaddr, nixlf, &pcifunc))

		return -EINVAL;



	pfvf = rvu_get_pfvf(rvu, pcifunc);
@@ -1053,13 +1109,15 @@ static int rvu_dbg_nix_queue_ctx_display(struct seq_file *filp, 
}



static int write_nix_queue_ctx(struct rvu *rvu, bool all, int nixlf,

			       int id, int ctype, char *ctype_string)

			       int id, int ctype, char *ctype_string,

			       struct seq_file *m)

{

	struct nix_hw *nix_hw = m->private;

	struct rvu_pfvf *pfvf;

	int max_id = 0;

	u16 pcifunc;



	if (!rvu_dbg_is_valid_lf(rvu, BLKTYPE_NIX, nixlf, &pcifunc))

	if (!rvu_dbg_is_valid_lf(rvu, nix_hw->blkaddr, nixlf, &pcifunc))

		return -EINVAL;



	pfvf = rvu_get_pfvf(rvu, pcifunc);
@@ -1119,7 +1177,8 @@ static ssize_t rvu_dbg_nix_queue_ctx_write(struct file *filp, 
					   int ctype)

{

	struct seq_file *m = filp->private_data;

	struct rvu *rvu = m->private;

	struct nix_hw *nix_hw = m->private;

	struct rvu *rvu = nix_hw->rvu;

	char *cmd_buf, *ctype_string;

	int nixlf, id = 0, ret;

	bool all = false;
@@ -1155,7 +1214,7 @@ static ssize_t rvu_dbg_nix_queue_ctx_write(struct file *filp, 
		goto done;

	} else {

		ret = write_nix_queue_ctx(rvu, all, nixlf, id, ctype,

					  ctype_string);

					  ctype_string, m);

	}

done:

	kfree(cmd_buf);
@@ -1259,49 +1318,67 @@ static int rvu_dbg_nix_qsize_display(struct seq_file *filp, void *unused) 


RVU_DEBUG_SEQ_FOPS(nix_qsize, nix_qsize_display, nix_qsize_write);



static void rvu_dbg_nix_init(struct rvu *rvu)

static void rvu_dbg_nix_init(struct rvu *rvu, int blkaddr)

{

	const struct device *dev = &rvu->pdev->dev;

	struct nix_hw *nix_hw;

	struct dentry *pfile;



	if (!is_block_implemented(rvu->hw, blkaddr))

		return;



	if (blkaddr == BLKADDR_NIX0) {

		rvu->rvu_dbg.nix = debugfs_create_dir("nix", rvu->rvu_dbg.root);

		if (!rvu->rvu_dbg.nix) {

			dev_err(rvu->dev, "create debugfs dir failed for nix\n");

			return;

		}

		nix_hw = &rvu->hw->nix[0];

	} else {

		rvu->rvu_dbg.nix = debugfs_create_dir("nix1",

						      rvu->rvu_dbg.root);

		if (!rvu->rvu_dbg.nix) {

			dev_err(rvu->dev,

				"create debugfs dir failed for nix1\n");

			return;

		}

		nix_hw = &rvu->hw->nix[1];

	}



	pfile = debugfs_create_file("sq_ctx", 0600, rvu->rvu_dbg.nix, rvu,

	pfile = debugfs_create_file("sq_ctx", 0600, rvu->rvu_dbg.nix, nix_hw,

				    &rvu_dbg_nix_sq_ctx_fops);

	if (!pfile)

		goto create_failed;



	pfile = debugfs_create_file("rq_ctx", 0600, rvu->rvu_dbg.nix, rvu,

	pfile = debugfs_create_file("rq_ctx", 0600, rvu->rvu_dbg.nix, nix_hw,

				    &rvu_dbg_nix_rq_ctx_fops);

	if (!pfile)

		goto create_failed;



	pfile = debugfs_create_file("cq_ctx", 0600, rvu->rvu_dbg.nix, rvu,

	pfile = debugfs_create_file("cq_ctx", 0600, rvu->rvu_dbg.nix, nix_hw,

				    &rvu_dbg_nix_cq_ctx_fops);

	if (!pfile)

		goto create_failed;



	pfile = debugfs_create_file("ndc_tx_cache", 0600, rvu->rvu_dbg.nix, rvu,

				    &rvu_dbg_nix_ndc_tx_cache_fops);

	pfile = debugfs_create_file("ndc_tx_cache", 0600, rvu->rvu_dbg.nix,

				    nix_hw, &rvu_dbg_nix_ndc_tx_cache_fops);

	if (!pfile)

		goto create_failed;



	pfile = debugfs_create_file("ndc_rx_cache", 0600, rvu->rvu_dbg.nix, rvu,

				    &rvu_dbg_nix_ndc_rx_cache_fops);

	pfile = debugfs_create_file("ndc_rx_cache", 0600, rvu->rvu_dbg.nix,

				    nix_hw, &rvu_dbg_nix_ndc_rx_cache_fops);

	if (!pfile)

		goto create_failed;



	pfile = debugfs_create_file("ndc_tx_hits_miss", 0600, rvu->rvu_dbg.nix,

				    rvu, &rvu_dbg_nix_ndc_tx_hits_miss_fops);

				    nix_hw,

				    &rvu_dbg_nix_ndc_tx_hits_miss_fops);

	if (!pfile)

		goto create_failed;



	pfile = debugfs_create_file("ndc_rx_hits_miss", 0600, rvu->rvu_dbg.nix,

				    rvu, &rvu_dbg_nix_ndc_rx_hits_miss_fops);

				    nix_hw,

				    &rvu_dbg_nix_ndc_rx_hits_miss_fops);

	if (!pfile)

		goto create_failed;
@@ -1312,7 +1389,8 @@ static void rvu_dbg_nix_init(struct rvu *rvu) 


	return;

create_failed:

	dev_err(dev, "Failed to create debugfs dir/file for NIX\n");

	dev_err(dev,

		"Failed to create debugfs dir/file for NIX blk\n");

	debugfs_remove_recursive(rvu->rvu_dbg.nix);

}
@@ -1692,7 +1770,9 @@ void rvu_dbg_init(struct rvu *rvu) 
		goto create_failed;



	rvu_dbg_npa_init(rvu);

	rvu_dbg_nix_init(rvu);

	rvu_dbg_nix_init(rvu, BLKADDR_NIX0);



	rvu_dbg_nix_init(rvu, BLKADDR_NIX1);

	rvu_dbg_cgx_init(rvu);

	rvu_dbg_npc_init(rvu);