Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dc9daab2 authored by Hariprasad Shenai's avatar Hariprasad Shenai Committed by David S. Miller
Browse files

cxgb4: Added support in debugfs to dump sge_qinfo 



Signed-off-by: default avatarHariprasad Shenai <hariprasad@chelsio.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent b8665c6c

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h

+2 −0
Original line number Diff line number Diff line
@@ -1029,6 +1029,8 @@ int cxgb4_t4_bar2_sge_qregs(struct adapter *adapter, 
		      u64 *pbar2_qoffset,

		      unsigned int *pbar2_qid);



unsigned int qtimer_val(const struct adapter *adap,

			const struct sge_rspq *q);

int t4_init_sge_params(struct adapter *adapter);

int t4_init_tp_params(struct adapter *adap);

int t4_filter_field_shift(const struct adapter *adap, int filter_sel);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

+211 −0
Original line number Diff line number Diff line
@@ -1026,6 +1026,216 @@ static const struct file_operations rss_vf_config_debugfs_fops = { 
	.release = seq_release_private

};



static int sge_qinfo_show(struct seq_file *seq, void *v)

{

	struct adapter *adap = seq->private;

	int eth_entries = DIV_ROUND_UP(adap->sge.ethqsets, 4);

	int toe_entries = DIV_ROUND_UP(adap->sge.ofldqsets, 4);

	int rdma_entries = DIV_ROUND_UP(adap->sge.rdmaqs, 4);

	int ciq_entries = DIV_ROUND_UP(adap->sge.rdmaciqs, 4);

	int ctrl_entries = DIV_ROUND_UP(MAX_CTRL_QUEUES, 4);

	int i, r = (uintptr_t)v - 1;

	int toe_idx = r - eth_entries;

	int rdma_idx = toe_idx - toe_entries;

	int ciq_idx = rdma_idx - rdma_entries;

	int ctrl_idx =  ciq_idx - ciq_entries;

	int fq_idx =  ctrl_idx - ctrl_entries;



	if (r)

		seq_putc(seq, '\n');



#define S3(fmt_spec, s, v) \

do { \

	seq_printf(seq, "%-12s", s); \

	for (i = 0; i < n; ++i) \

		seq_printf(seq, " %16" fmt_spec, v); \

		seq_putc(seq, '\n'); \

} while (0)

#define S(s, v) S3("s", s, v)

#define T(s, v) S3("u", s, tx[i].v)

#define R(s, v) S3("u", s, rx[i].v)



	if (r < eth_entries) {

		int base_qset = r * 4;

		const struct sge_eth_rxq *rx = &adap->sge.ethrxq[base_qset];

		const struct sge_eth_txq *tx = &adap->sge.ethtxq[base_qset];

		int n = min(4, adap->sge.ethqsets - 4 * r);



		S("QType:", "Ethernet");

		S("Interface:",

		  rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A");

		T("TxQ ID:", q.cntxt_id);

		T("TxQ size:", q.size);

		T("TxQ inuse:", q.in_use);

		T("TxQ CIDX:", q.cidx);

		T("TxQ PIDX:", q.pidx);

#ifdef CONFIG_CXGB4_DCB

		T("DCB Prio:", dcb_prio);

		S3("u", "DCB PGID:",

		   (ethqset2pinfo(adap, base_qset + i)->dcb.pgid >>

		    4*(7-tx[i].dcb_prio)) & 0xf);

		S3("u", "DCB PFC:",

		   (ethqset2pinfo(adap, base_qset + i)->dcb.pfcen >>

		    1*(7-tx[i].dcb_prio)) & 0x1);

#endif

		R("RspQ ID:", rspq.abs_id);

		R("RspQ size:", rspq.size);

		R("RspQE size:", rspq.iqe_len);

		R("RspQ CIDX:", rspq.cidx);

		R("RspQ Gen:", rspq.gen);

		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));

		S3("u", "Intr pktcnt:",

		   adap->sge.counter_val[rx[i].rspq.pktcnt_idx]);

		R("FL ID:", fl.cntxt_id);

		R("FL size:", fl.size - 8);

		R("FL pend:", fl.pend_cred);

		R("FL avail:", fl.avail);

		R("FL PIDX:", fl.pidx);

		R("FL CIDX:", fl.cidx);

	} else if (toe_idx < toe_entries) {

		const struct sge_ofld_rxq *rx = &adap->sge.ofldrxq[toe_idx * 4];

		const struct sge_ofld_txq *tx = &adap->sge.ofldtxq[toe_idx * 4];

		int n = min(4, adap->sge.ofldqsets - 4 * toe_idx);



		S("QType:", "TOE");

		T("TxQ ID:", q.cntxt_id);

		T("TxQ size:", q.size);

		T("TxQ inuse:", q.in_use);

		T("TxQ CIDX:", q.cidx);

		T("TxQ PIDX:", q.pidx);

		R("RspQ ID:", rspq.abs_id);

		R("RspQ size:", rspq.size);

		R("RspQE size:", rspq.iqe_len);

		R("RspQ CIDX:", rspq.cidx);

		R("RspQ Gen:", rspq.gen);

		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));

		S3("u", "Intr pktcnt:",

		   adap->sge.counter_val[rx[i].rspq.pktcnt_idx]);

		R("FL ID:", fl.cntxt_id);

		R("FL size:", fl.size - 8);

		R("FL pend:", fl.pend_cred);

		R("FL avail:", fl.avail);

		R("FL PIDX:", fl.pidx);

		R("FL CIDX:", fl.cidx);

	} else if (rdma_idx < rdma_entries) {

		const struct sge_ofld_rxq *rx =

				&adap->sge.rdmarxq[rdma_idx * 4];

		int n = min(4, adap->sge.rdmaqs - 4 * rdma_idx);



		S("QType:", "RDMA-CPL");

		R("RspQ ID:", rspq.abs_id);

		R("RspQ size:", rspq.size);

		R("RspQE size:", rspq.iqe_len);

		R("RspQ CIDX:", rspq.cidx);

		R("RspQ Gen:", rspq.gen);

		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));

		S3("u", "Intr pktcnt:",

		   adap->sge.counter_val[rx[i].rspq.pktcnt_idx]);

		R("FL ID:", fl.cntxt_id);

		R("FL size:", fl.size - 8);

		R("FL pend:", fl.pend_cred);

		R("FL avail:", fl.avail);

		R("FL PIDX:", fl.pidx);

		R("FL CIDX:", fl.cidx);

	} else if (ciq_idx < ciq_entries) {

		const struct sge_ofld_rxq *rx = &adap->sge.rdmaciq[ciq_idx * 4];

		int n = min(4, adap->sge.rdmaciqs - 4 * ciq_idx);



		S("QType:", "RDMA-CIQ");

		R("RspQ ID:", rspq.abs_id);

		R("RspQ size:", rspq.size);

		R("RspQE size:", rspq.iqe_len);

		R("RspQ CIDX:", rspq.cidx);

		R("RspQ Gen:", rspq.gen);

		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));

		S3("u", "Intr pktcnt:",

		   adap->sge.counter_val[rx[i].rspq.pktcnt_idx]);

	} else if (ctrl_idx < ctrl_entries) {

		const struct sge_ctrl_txq *tx = &adap->sge.ctrlq[ctrl_idx * 4];

		int n = min(4, adap->params.nports - 4 * ctrl_idx);



		S("QType:", "Control");

		T("TxQ ID:", q.cntxt_id);

		T("TxQ size:", q.size);

		T("TxQ inuse:", q.in_use);

		T("TxQ CIDX:", q.cidx);

		T("TxQ PIDX:", q.pidx);

	} else if (fq_idx == 0) {

		const struct sge_rspq *evtq = &adap->sge.fw_evtq;



		seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue");

		seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id);

		seq_printf(seq, "%-12s %16u\n", "RspQ size:", evtq->size);

		seq_printf(seq, "%-12s %16u\n", "RspQE size:", evtq->iqe_len);

		seq_printf(seq, "%-12s %16u\n", "RspQ CIDX:", evtq->cidx);

		seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen);

		seq_printf(seq, "%-12s %16u\n", "Intr delay:",

			   qtimer_val(adap, evtq));

		seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",

			   adap->sge.counter_val[evtq->pktcnt_idx]);

	}

#undef R

#undef T

#undef S

#undef S3

return 0;

}



static int sge_queue_entries(const struct adapter *adap)

{

	return DIV_ROUND_UP(adap->sge.ethqsets, 4) +

	       DIV_ROUND_UP(adap->sge.ofldqsets, 4) +

	       DIV_ROUND_UP(adap->sge.rdmaqs, 4) +

	       DIV_ROUND_UP(adap->sge.rdmaciqs, 4) +

	       DIV_ROUND_UP(MAX_CTRL_QUEUES, 4) + 1;

}



static void *sge_queue_start(struct seq_file *seq, loff_t *pos)

{

	int entries = sge_queue_entries(seq->private);



	return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;

}



static void sge_queue_stop(struct seq_file *seq, void *v)

{

}



static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos)

{

	int entries = sge_queue_entries(seq->private);



	++*pos;

	return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;

}



static const struct seq_operations sge_qinfo_seq_ops = {

	.start = sge_queue_start,

	.next  = sge_queue_next,

	.stop  = sge_queue_stop,

	.show  = sge_qinfo_show

};



static int sge_qinfo_open(struct inode *inode, struct file *file)

{

	int res = seq_open(file, &sge_qinfo_seq_ops);



	if (!res) {

		struct seq_file *seq = file->private_data;



		seq->private = inode->i_private;

	}

	return res;

}



static const struct file_operations sge_qinfo_debugfs_fops = {

	.owner   = THIS_MODULE,

	.open    = sge_qinfo_open,

	.read    = seq_read,

	.llseek  = seq_lseek,

	.release = seq_release,

};



int mem_open(struct inode *inode, struct file *file)

{

	unsigned int mem;
@@ -1135,6 +1345,7 @@ int t4_setup_debugfs(struct adapter *adap) 
		{ "rss_key", &rss_key_debugfs_fops, S_IRUSR, 0 },

		{ "rss_pf_config", &rss_pf_config_debugfs_fops, S_IRUSR, 0 },

		{ "rss_vf_config", &rss_vf_config_debugfs_fops, S_IRUSR, 0 },

		{ "sge_qinfo", &sge_qinfo_debugfs_fops, S_IRUSR, 0 },

#if IS_ENABLED(CONFIG_IPV6)

		{ "clip_tbl", &clip_tbl_debugfs_fops, S_IRUSR, 0 },

#endif

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

+2 −2
Original line number Diff line number Diff line
@@ -2500,7 +2500,7 @@ static int closest_thres(const struct sge *s, int thres) 
/*

 * Return a queue's interrupt hold-off time in us.  0 means no timer.

 */

static unsigned int qtimer_val(const struct adapter *adap,

unsigned int qtimer_val(const struct adapter *adap,

			const struct sge_rspq *q)

{

	unsigned int idx = q->intr_params >> 1;