[PATCH net-next v2 11/11] cxgb4: extend debugfs support for T7 adapters

@@ -17,6 +17,7 @@
 #include <net/addrconf.h>
 #include "cxgb4.h"
 #include "clip_tbl.h"
+#include "cxgb4_debugfs.h"
 
 static inline unsigned int ipv4_clip_hash(struct clip_tbl *c, const u32 *key)
 {

@@ -249,12 +250,17 @@ EXPORT_SYMBOL(cxgb4_update_root_dev_clip);
 
 int clip_tbl_show(struct seq_file *seq, void *v)
 {
-	struct adapter *adapter = seq->private;
-	struct clip_tbl *ctbl = adapter->clipt;
+	struct t4_linux_debugfs_data *d = seq->private;
+	struct adapter *adapter = d->adap;
+	struct clip_tbl *ctbl;
 	struct clip_entry *ce;
 	char ip[60];
 	int i;
 
+	ctbl = adapter->clipt;
+	if (!ctbl)
+		return 0;
+
 	read_lock_bh(&ctbl->lock);
 
 	seq_puts(seq, "IP Address                  Users\n");

@@ -455,7 +455,6 @@ struct adapter_params {
 	struct vpd_params vpd;
 	struct pf_resources pfres;
 	struct pci_params pci;
-	struct devlog_params devlogs;
 	struct devlog_params devlog[MAX_UP_CORES];
 	enum pcie_memwin drv_memwin;
 

@@ -1957,12 +1956,8 @@ u8 t4_cim_num_ibq(struct adapter *adap);
 u8 t4_cim_num_obq(struct adapter *adap);
 void t4_read_cimq_cfg_core(struct adapter *adap, u8 coreid, u16 *base,
 			   u16 *size, u16 *thres);
-int t4_read_cim_ibq(struct adapter *adap, unsigned int qid, u32 *data,
-		    size_t n);
 int t4_read_cim_obq_core(struct adapter *adap, u8 coreid, u32 qid, u32 *data,
 			 size_t n);
-int t4_read_cim_obq(struct adapter *adap, unsigned int qid, u32 *data,
-		    size_t n);
 int t4_cim_read_core(struct adapter *adap, u8 group, u8 coreid,
 		     unsigned int addr, unsigned int n, unsigned int *valp);
 int t4_cim_read(struct adapter *adap, unsigned int addr, unsigned int n,

@@ -1970,11 +1965,8 @@ int t4_cim_read(struct adapter *adap, unsigned int addr, unsigned int n,
 int t4_cim_write_core(struct adapter *adap, u8 group, u8 coreid,
 		      unsigned int addr, unsigned int n,
 		      const unsigned int *valp);
-int t4_cim_write(struct adapter *adap, unsigned int addr, unsigned int n,
-		 const unsigned int *valp);
 int t4_cim_read_la_core(struct adapter *adap, u8 coreid, u32 *la_buf,
 			u32 *wrptr);
-int t4_cim_read_la(struct adapter *adap, u32 *la_buf, unsigned int *wrptr);
 void t4_cim_read_pif_la(struct adapter *adap, u32 *pif_req, u32 *pif_rsp,
 			unsigned int *pif_req_wrptr,
 			unsigned int *pif_rsp_wrptr);

@@ -196,21 +196,22 @@ static int cim_la_show_pc_t6(struct seq_file *seq, void *v, int idx)
 
 static int cim_la_open(struct inode *inode, struct file *file)
 {
-	int ret;
-	unsigned int cfg;
+	struct t4_linux_debugfs_data *d = inode->i_private;
+	struct adapter *adap = d->adap;
+	u8 coreid = d->coreid;
 	struct seq_tab *p;
-	struct adapter *adap = inode->i_private;
+	unsigned int cfg;
+	int ret;
 
-	ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg);
+	ret = t4_cim_read_core(adap, 1, coreid, UP_UP_DBG_LA_CFG_A, 1, &cfg);
 	if (ret)
 		return ret;
 
-	if (is_t6(adap->params.chip)) {
-		/* +1 to account for integer division of CIMLA_SIZE/10 */
-		p = seq_open_tab(file, (adap->params.cim_la_size / 10) + 1,
+	if (CHELSIO_CHIP_VERSION(adap->params.chip) >= CHELSIO_T6) {
+		p = seq_open_tab(file, adap->params.cim_la_size / 10,
 				 10 * sizeof(u32), 1,
 				 cfg & UPDBGLACAPTPCONLY_F ?
-					cim_la_show_pc_t6 : cim_la_show_t6);
+				 cim_la_show_pc_t6 : cim_la_show_t6);
 	} else {
 		p = seq_open_tab(file, adap->params.cim_la_size / 8,
 				 8 * sizeof(u32), 1,

@@ -220,7 +221,7 @@ static int cim_la_open(struct inode *inode, struct file *file)
 	if (!p)
 		return -ENOMEM;
 
-	ret = t4_cim_read_la(adap, (u32 *)p->data, NULL);
+	ret = t4_cim_read_la_core(adap, coreid, (u32 *)p->data, NULL);
 	if (ret)
 		seq_release_private(inode, file);
 	return ret;

@@ -256,8 +257,9 @@ static int cim_pif_la_show(struct seq_file *seq, void *v, int idx)
 
 static int cim_pif_la_open(struct inode *inode, struct file *file)
 {
+	struct t4_linux_debugfs_data *d = inode->i_private;
+	struct adapter *adap = d->adap;
 	struct seq_tab *p;
-	struct adapter *adap = inode->i_private;
 
 	p = seq_open_tab(file, 2 * CIM_PIFLA_SIZE, 6 * sizeof(u32), 1,
 			 cim_pif_la_show);

@@ -302,8 +304,9 @@ static int cim_ma_la_show(struct seq_file *seq, void *v, int idx)
 
 static int cim_ma_la_open(struct inode *inode, struct file *file)
 {
+	struct t4_linux_debugfs_data *d = inode->i_private;
+	struct adapter *adap = d->adap;
 	struct seq_tab *p;
-	struct adapter *adap = inode->i_private;
 
 	p = seq_open_tab(file, 2 * CIM_MALA_SIZE, 5 * sizeof(u32), 1,
 			 cim_ma_la_show);

@@ -323,8 +326,112 @@ static const struct file_operations cim_ma_la_fops = {
 	.release = seq_release_private
 };
 
+static int cim_qcfg_show_t7(struct seq_file *seq, struct adapter *adap,
+			    u8 coreid)
+{
+	static const char *const qname_t7[] = {
+		/* IBQ */
+		"TP0",
+		"TP1",
+		"TP2",
+		"TP3",
+		"ULP",
+		"SGE0",
+		"PCIE",
+		"NC-SI",
+		"RSVD",
+		"IPC1",
+		"IPC2",
+		"IPC3",
+		"IPC4",
+		"IPC5",
+		"IPC6",
+		"IPC7",
+		/* OBQ */
+		"ULP0",
+		"ULP1",
+		"ULP2",
+		"ULP3",
+		"SGE",
+		"NC-SI",
+		"SGE0-RX",
+		"RSVD",
+		"RSVD",
+		"IPC1",
+		"IPC2",
+		"IPC3",
+		"IPC4",
+		"IPC5",
+		"IPC6",
+		"IPC7",
+	};
+	u32 stat[(4 * (CIM_NUM_IBQ_T7 + CIM_NUM_OBQ_T7))];
+	u16 base[CIM_NUM_IBQ_T7 + CIM_NUM_OBQ_T7];
+	u16 size[CIM_NUM_IBQ_T7 + CIM_NUM_OBQ_T7];
+	u32 obq_wr[2 * CIM_NUM_OBQ_T7];
+	u16 thres[CIM_NUM_IBQ_T7];
+	u32 *wr = obq_wr;
+	u32 *p = stat;
+	u32 addr;
+	int ret;
+	u8 i;
+
+	ret = t4_cim_read_core(adap, 1, coreid, T7_UP_IBQ_0_SHADOW_RDADDR_A,
+			       4 * CIM_NUM_IBQ_T7, stat);
+	if (ret < 0)
+		return ret;
+
+	ret = t4_cim_read_core(adap, 1, coreid, T7_UP_OBQ_0_SHADOW_RDADDR_A,
+			       4 * CIM_NUM_OBQ_T7, &stat[4 * CIM_NUM_IBQ_T7]);
+	if (ret < 0)
+		return ret;
+
+	addr = T7_UP_OBQ_0_SHADOW_REALADDR_A;
+	for (i = 0; i < CIM_NUM_OBQ_T7 * 2; i++, addr += 8) {
+		ret = t4_cim_read_core(adap, 1, coreid, addr, 1, &obq_wr[i]);
+		if (ret < 0)
+			return ret;
+	}
+
+	t4_read_cimq_cfg_core(adap, coreid, base, size, thres);
+
+	seq_printf(seq,
+		   "  Queue  Base  Size Thres  RdPtr WrPtr  SOP  EOP Avail\n");
+
+	for (i = 0; i < CIM_NUM_IBQ_T7; i++, p += 4) {
+		if (!size[i])
+			continue;
+
+		seq_printf(seq, "%7s %5x %5u %5u %6x  %4x %4u %4u %5u\n",
+			   qname_t7[i], base[i], size[i], thres[i],
+			   IBQRDADDR_G(p[0]) & 0xfff, IBQWRADDR_G(p[1]) & 0xfff,
+			   QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]),
+			   T7_QUEREMFLITS_G(p[2]) * 16);
+	}
+
+	for ( ; i < CIM_NUM_IBQ_T7 + CIM_NUM_OBQ_T7; i++, p += 4, wr += 2) {
+		if (!size[i])
+			continue;
+
+		seq_printf(seq, "%7s %5x %5u %12x  %4x %4u %4u %5u\n",
+			   qname_t7[i], base[i], size[i],
+			   QUERDADDR_G(p[0]) & 0xfff, (wr[0] << 1),
+			   QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]),
+			   T7_QUEREMFLITS_G(p[2]) * 16);
+	}
+
+	return 0;
+}
+
 static int cim_qcfg_show(struct seq_file *seq, void *v)
 {
+	struct t4_linux_debugfs_data *d = seq->private;
+	struct adapter *adap = d->adap;
+	u8 coreid = d->coreid;
+
+	if (CHELSIO_CHIP_VERSION(adap->params.chip) >= CHELSIO_T7)
+		return cim_qcfg_show_t7(seq, adap, coreid);
+
 	static const char * const qname[] = {
 		"TP0", "TP1", "ULP", "SGE0", "SGE1", "NC-SI",
 		"ULP0", "ULP1", "ULP2", "ULP3", "SGE", "NC-SI",

@@ -332,7 +439,6 @@ static int cim_qcfg_show(struct seq_file *seq, void *v)
 	};
 
 	int i;
-	struct adapter *adap = seq->private;
 	u16 base[CIM_NUM_IBQ + CIM_NUM_OBQ_T5];
 	u16 size[CIM_NUM_IBQ + CIM_NUM_OBQ_T5];
 	u32 stat[(4 * (CIM_NUM_IBQ + CIM_NUM_OBQ_T5))];

@@ -391,16 +497,19 @@ static int cimq_show(struct seq_file *seq, void *v, int idx)
 
 static int cim_ibq_open(struct inode *inode, struct file *file)
 {
-	int ret;
+	struct t4_linux_debugfs_data *d = inode->i_private;
+	struct adapter *adap = d->adap;
+	unsigned int qid = d->data;
+	u8 coreid = d->coreid;
 	struct seq_tab *p;
-	unsigned int qid = (uintptr_t)inode->i_private & 7;
-	struct adapter *adap = inode->i_private - qid;
+	int ret;
 
 	p = seq_open_tab(file, CIM_IBQ_SIZE, 4 * sizeof(u32), 0, cimq_show);
 	if (!p)
 		return -ENOMEM;
 
-	ret = t4_read_cim_ibq(adap, qid, (u32 *)p->data, CIM_IBQ_SIZE * 4);
+	ret = t4_read_cim_ibq_core(adap, coreid, qid, (u32 *)p->data,
+				   CIM_IBQ_SIZE * 4);
 	if (ret < 0)
 		seq_release_private(inode, file);
 	else

@@ -418,16 +527,19 @@ static const struct file_operations cim_ibq_fops = {
 
 static int cim_obq_open(struct inode *inode, struct file *file)
 {
-	int ret;
+	struct t4_linux_debugfs_data *d = inode->i_private;
+	struct adapter *adap = d->adap;
+	unsigned int qid = d->data;
+	u8 coreid = d->coreid;
 	struct seq_tab *p;
-	unsigned int qid = (uintptr_t)inode->i_private & 7;
-	struct adapter *adap = inode->i_private - qid;
+	int ret;
 
 	p = seq_open_tab(file, 6 * CIM_OBQ_SIZE, 4 * sizeof(u32), 0, cimq_show);
 	if (!p)
 		return -ENOMEM;
 
-	ret = t4_read_cim_obq(adap, qid, (u32 *)p->data, 6 * CIM_OBQ_SIZE * 4);
+	ret = t4_read_cim_obq_core(adap, coreid, qid, (u32 *)p->data,
+				   6 * CIM_OBQ_SIZE * 4);
 	if (ret < 0) {
 		seq_release_private(inode, file);
 	} else {

@@ -638,8 +750,9 @@ static int tp_la_show3(struct seq_file *seq, void *v, int idx)
 
 static int tp_la_open(struct inode *inode, struct file *file)
 {
+	struct t4_linux_debugfs_data *d = inode->i_private;
+	struct adapter *adap = d->adap;
 	struct seq_tab *p;
-	struct adapter *adap = inode->i_private;
 
 	switch (DBGLAMODE_G(t4_read_reg(adap, TP_DBG_LA_CONFIG_A))) {
 	case 2:

@@ -663,11 +776,14 @@ static int tp_la_open(struct inode *inode, struct file *file)
 static ssize_t tp_la_write(struct file *file, const char __user *buf,
 			   size_t count, loff_t *pos)
 {
-	int err;
-	char s[32];
+	struct t4_linux_debugfs_data *d = file_inode(file)->i_private;
+	struct adapter *adap = d->adap;
 	unsigned long val;
-	size_t size = min(sizeof(s) - 1, count);
-	struct adapter *adap = file_inode(file)->i_private;
+	size_t size;
+	char s[32];
+	int err;
+
+	size = min(sizeof(s) - 1, count);
 
 	if (copy_from_user(s, buf, size))
 		return -EFAULT;

@@ -707,8 +823,9 @@ static int ulprx_la_show(struct seq_file *seq, void *v, int idx)
 
 static int ulprx_la_open(struct inode *inode, struct file *file)
 {
+	struct t4_linux_debugfs_data *d = inode->i_private;
+	struct adapter *adap = d->adap;
 	struct seq_tab *p;
-	struct adapter *adap = inode->i_private;
 
 	p = seq_open_tab(file, ULPRX_LA_SIZE, 8 * sizeof(u32), 1,
 			 ulprx_la_show);

@@ -748,10 +865,11 @@ static int pm_stats_show(struct seq_file *seq, void *v)
 		"Read:", "Write bypass:", "Write mem:", "Flush:"
 	};
 
-	int i;
 	u32 tx_cnt[T6_PM_NSTATS], rx_cnt[T6_PM_NSTATS];
 	u64 tx_cyc[T6_PM_NSTATS], rx_cyc[T6_PM_NSTATS];
-	struct adapter *adap = seq->private;
+	struct t4_linux_debugfs_data *d = seq->private;
+	struct adapter *adap = d->adap;
+	int i;
 
 	t4_pmtx_get_stats(adap, tx_cnt, tx_cyc);
 	t4_pmrx_get_stats(adap, rx_cnt, rx_cyc);

@@ -791,6 +909,61 @@ static int pm_stats_show(struct seq_file *seq, void *v)
 		seq_printf(seq, "Rx latency    %10u  %20llu\n",
 			   rx_cnt[i], rx_cyc[i]);
 	}
+
+	if (CHELSIO_CHIP_VERSION(adap->params.chip) >= CHELSIO_T7) {
+		u32 stats[T7_PM_RX_CACHE_NSTATS];
+
+		t4_pmrx_cache_get_stats(adap, stats);
+
+		i = 0;
+		seq_puts(seq, "\n\nPM RX Cache Stats\n");
+		seq_printf(seq, "%-40s    %u\n", "ReqWrite", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "ReqReadInv", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "ReqReadNoInv", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Write Split Request",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n",
+			   "Normal Read Split (Read Invalidate)", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n",
+			   "Feedback Read Split (Read NoInvalidate)",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Write Hit", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Normal Read Hit", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Feedback Read Hit",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Normal Read Hit Full Avail",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Normal Read Hit Full UnAvail",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n",
+			   "Normal Read Hit Partial Avail", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "FB Read Hit Full Avail",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "FB Read Hit Full UnAvail",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "FB Read Hit Partial Avail",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Normal Read Full Free",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n",
+			   "Normal Read Part-avail Mul-Regions", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n",
+			   "FB Read Part-avail Mul-Regions", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Write Miss FL Used",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Write Miss LRU Used",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n",
+			   "Write Miss LRU-Multiple Evict", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Write Hit Increasing Islands",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n",
+			   "Normal Read Island Read split", stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Write Overflow Eviction",
+			   stats[i++]);
+		seq_printf(seq, "%-40s    %u\n", "Read Overflow Eviction",
+			   stats[i++]);
+	}
 	return 0;
 }
 

@@ -802,7 +975,8 @@ static int pm_stats_open(struct inode *inode, struct file *file)
 static ssize_t pm_stats_clear(struct file *file, const char __user *buf,
 			      size_t count, loff_t *pos)
 {
-	struct adapter *adap = file_inode(file)->i_private;
+	struct t4_linux_debugfs_data *d = file_inode(file)->i_private;
+	struct adapter *adap = d->adap;
 
 	t4_write_reg(adap, PM_RX_STAT_CONFIG_A, 0);
 	t4_write_reg(adap, PM_TX_STAT_CONFIG_A, 0);

@@ -820,8 +994,9 @@ static const struct file_operations pm_stats_debugfs_fops = {
 
 static int tx_rate_show(struct seq_file *seq, void *v)
 {
+	struct t4_linux_debugfs_data *d = seq->private;
+	struct adapter *adap = d->adap;
 	u64 nrate[NCHAN], orate[NCHAN];
-	struct adapter *adap = seq->private;
 
 	t4_get_chan_txrate(adap, nrate, orate);
 	if (adap->params.arch.nchan == NCHAN) {

@@ -856,9 +1031,10 @@ static int cctrl_tbl_show(struct seq_file *seq, void *v)
 		"0.5", "0.5625", "0.625", "0.6875", "0.75", "0.8125", "0.875",
 		"0.9375" };
 
-	int i;
+	struct t4_linux_debugfs_data *d = seq->private;
+	struct adapter *adap = d->adap;
 	u16 (*incr)[NCCTRL_WIN];
-	struct adapter *adap = seq->private;
+	int i;
 
 	incr = kmalloc_objs(*incr, NMTUS);
 	if (!incr)

@@ -902,13 +1078,16 @@ static char *unit_conv(char *buf, size_t len, unsigned int val,
 
 static int clk_show(struct seq_file *seq, void *v)
 {
+	struct t4_linux_debugfs_data *d = seq->private;
+	unsigned int cclk_ps, tre, dack_re, res;
+	struct adapter *adap = d->adap;
+	unsigned long long tp_tick_us;
 	char buf[32];
-	struct adapter *adap = seq->private;
-	unsigned int cclk_ps = 1000000000 / adap->params.vpd.cclk;  /* in ps */
-	u32 res = t4_read_reg(adap, TP_TIMER_RESOLUTION_A);
-	unsigned int tre = TIMERRESOLUTION_G(res);
-	unsigned int dack_re = DELAYEDACKRESOLUTION_G(res);
-	unsigned long long tp_tick_us = (cclk_ps << tre) / 1000000; /* in us */
+	cclk_ps = 1000000000 / adap->params.vpd.cclk;  /* in ps */
+	res = t4_read_reg(adap, TP_TIMER_RESOLUTION_A);
+	tre = TIMERRESOLUTION_G(res);
+	dack_re = DELAYEDACKRESOLUTION_G(res);
+	tp_tick_us = (cclk_ps << tre) / 1000000; /* in us */
 
 	seq_printf(seq, "Core clock period: %s ns\n",
 		   unit_conv(buf, sizeof(buf), cclk_ps, 1000));

@@ -1080,13 +1259,17 @@ static const struct seq_operations devlog_seq_ops = {
  */
 static int devlog_open(struct inode *inode, struct file *file)
 {
-	struct adapter *adap = inode->i_private;
-	struct devlog_params *dparams = &adap->params.devlogs;
+	struct t4_linux_debugfs_data *d = inode->i_private;
+	struct adapter *adap = d->adap;
+	struct devlog_params *dparams;
 	struct devlog_info *dinfo;
+	u8 coreid = d->coreid;
 	unsigned int index;
 	u32 fseqno;
 	int ret;
 
+	dparams = &adap->params.devlog[coreid];
+
 	/* If we don't know where the log is we can't do anything.
 	 */
 	if (dparams->start == 0)

@@ -1153,11 +1336,13 @@ static const struct file_operations devlog_fops = {
  */
 static int mboxlog_show(struct seq_file *seq, void *v)
 {
-	struct adapter *adapter = seq->private;
-	struct mbox_cmd_log *log = adapter->mbox_log;
+	struct t4_linux_debugfs_data *d = seq->private;
+	struct adapter *adap = d->adap;
+	struct mbox_cmd_log *log;
 	struct mbox_cmd *entry;
 	int entry_idx, i;
 
+	log = adap->mbox_log;
 	if (v == SEQ_START_TOKEN) {
 		seq_printf(seq,
 			   "%10s  %15s  %5s  %5s  %s\n",

@@ -1191,10 +1376,11 @@ static int mboxlog_show(struct seq_file *seq, void *v)
 
 static inline void *mboxlog_get_idx(struct seq_file *seq, loff_t pos)
 {
-	struct adapter *adapter = seq->private;
-	struct mbox_cmd_log *log = adapter->mbox_log;
+	struct t4_linux_debugfs_data *d = seq->private;
+	struct adapter *adap = d->adap;
 
-	return ((pos <= log->size) ? (void *)(uintptr_t)(pos + 1) : NULL);
+	return ((pos <= adap->mbox_log->size) ?
+			(void *)(uintptr_t)(pos + 1) : NULL);
 }
 
 static void *mboxlog_start(struct seq_file *seq, loff_t *pos)

@@ -1241,14 +1427,16 @@ static const struct file_operations mboxlog_fops = {
 
 static int mbox_show(struct seq_file *seq, void *v)
 {
-	static const char * const owner[] = { "none", "FW", "driver",
-					      "unknown", "<unread>" };
-
+	static const char * const owner[] = {
+		"none", "FW", "driver", "FW Deferred", "<unread>"
+	};
+	struct t4_linux_debugfs_data *d = seq->private;
+	struct adapter *adap = d->adap;
+	unsigned int mbox = d->data;
+	void __iomem *addr;
 	int i;
-	unsigned int mbox = (uintptr_t)seq->private & 7;
-	struct adapter *adap = seq->private - mbox;
-	void __iomem *addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A);
 
+	addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A);
 	/* For T4 we don't have a shadow copy of the Mailbox Control register.
 	 * And since reading that real register causes a side effect of
 	 * granting ownership, we're best of simply not reading it at all.

@@ -1278,14 +1466,14 @@ static int mbox_open(struct inode *inode, struct file *file)
 static ssize_t mbox_write(struct file *file, const char __user *buf,
 			  size_t count, loff_t *pos)
 {
-	int i;
-	char c = '\n', s[256];
+	struct t4_linux_debugfs_data *d = file_inode(file)->i_private;
+	struct adapter *adap = d->adap;
+	unsigned int mbox = d->data;
 	unsigned long long data[8];
-	const struct inode *ino;
-	unsigned int mbox;
-	struct adapter *adap;
+	char s[256], c = '\n';
 	void __iomem *addr;
 	void __iomem *ctrl;
+	int i;
 
 	if (count > sizeof(s) - 1 || !count)
 		return -EINVAL;

@@ -1298,9 +1486,6 @@ static ssize_t mbox_write(struct file *file, const char __user *buf,
 		   &data[7], &c) < 8 || c != '\n')
 		return -EINVAL;
 
-	ino = file_inode(file);
-	mbox = (uintptr_t)ino->i_private & 7;
-	adap = ino->i_private - mbox;
 	addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A);
 	ctrl = addr + MBOX_LEN;
 

@@ -1325,10 +1510,11 @@ static const struct file_operations mbox_debugfs_fops = {
 
 static int mps_trc_show(struct seq_file *seq, void *v)
 {
-	int enabled, i;
+	struct t4_linux_debugfs_data *d = seq->private;
+	struct adapter *adap = d->adap;
+	unsigned int trcidx = d->data;
 	struct trace_params tp;
-	unsigned int trcidx = (uintptr_t)seq->private & 3;
-	struct adapter *adap = seq->private - trcidx;
+	int enabled, i;
 
 	t4_get_trace_filter(adap, &tp, trcidx, &enabled);
 	if (!enabled) {

@@ -1411,18 +1597,13 @@ static unsigned int xdigit2int(unsigned char c)
 static ssize_t mps_trc_write(struct file *file, const char __user *buf,
 			     size_t count, loff_t *pos)
 {
-	int i, enable, ret;
-	u32 *data, *mask;
-	struct trace_params tp;
-	const struct inode *ino;
-	unsigned int trcidx;
+	struct t4_linux_debugfs_data *d = file_inode(file)->i_private;
+	struct adapter *adap = d->adap;
+	unsigned int trcidx = d->data;
 	char *s, *p, *word, *end;
-	struct adapter *adap;
-	u32 j;
-
-	ino = file_inode(file);
-	trcidx = (uintptr_t)ino->i_private & 3;
-	adap = ino->i_private - trcidx;
+	struct trace_params tp;
+	int i, enable, ret;
+	u32 *data, *mask, j;
 
 	/* Don't accept input more than 1K, can't be anything valid except lots
 	 * of whitespace.  Well, use less.

@@ -1619,9 +1800,10 @@ static const struct file_operations mps_trc_debugfs_fops = {
 static ssize_t flash_read(struct file *file, char __user *buf, size_t count,
 			  loff_t *ppos)
 {
-	loff_t pos = *ppos;
+	struct t4_linux_debugfs_data *d = file->private_data;
 	loff_t avail = file_inode(file)->i_size;
-	struct adapter *adap = file->private_data;
+	struct adapter *adap = d->adap;
+	loff_t pos = *ppos;
 
 	if (pos < 0)
 		return -EINVAL;

@@ -1671,8 +1853,11 @@ static inline void tcamxy2valmask(u64 x, u64 y, u8 *addr, u64 *mask)
 
 static int mps_tcam_show(struct seq_file *seq, void *v)
 {
-	struct adapter *adap = seq->private;
-	unsigned int chip_ver = CHELSIO_CHIP_VERSION(adap->params.chip);
+	struct t4_linux_debugfs_data *d = seq->private;
+	struct adapter *adap = d->adap;
+	unsigned int chip_ver;
+
+	chip_ver = CHELSIO_CHIP_VERSION(adap->params.chip);
 	if (v == SEQ_START_TOKEN) {
 		if (chip_ver > CHELSIO_T5) {
 			seq_puts(seq, "Idx  Ethernet address     Mask     "

@@ -1683,27 +1868,91 @@ static int mps_tcam_show(struct seq_file *seq, void *v)
 				 "    P0 P1 P2 P3  ML\n");
 		} else {
 			if (adap->params.arch.mps_rplc_size > 128)
-				seq_puts(seq, "Idx  Ethernet address     Mask     "
+				seq_puts(seq,
+					 "Idx  Ethernet address     Mask     "
 					 "Vld Ports PF  VF                           "
 					 "Replication                                "
 					 "    P0 P1 P2 P3  ML\n");
 			else
-				seq_puts(seq, "Idx  Ethernet address     Mask     "
+				seq_puts(seq,
+					 "Idx  Ethernet address     Mask     "
 					 "Vld Ports PF  VF              Replication"
 					 "	         P0 P1 P2 P3  ML\n");
 		}
 	} else {
-		u64 mask;
-		u8 addr[ETH_ALEN];
+		u32 cls_lo, cls_hi, ctl, data2, vnix = 0, vniy = 0;
 		bool replicate, dip_hit = false, vlan_vld = false;
 		unsigned int idx = (uintptr_t)v - 2;
+		u8 lookup_type = 0, port_num = 0;
 		u64 tcamy, tcamx, val;
-		u32 cls_lo, cls_hi, ctl, data2, vnix = 0, vniy = 0;
+		u8 addr[ETH_ALEN];
 		u32 rplc[8] = {0};
-		u8 lookup_type = 0, port_num = 0;
 		u16 ivlan = 0;
+		u64 mask;
 
-		if (chip_ver > CHELSIO_T5) {
+		if (chip_ver >= CHELSIO_T7) {
+			/* CtlReqID   - 1: use Host Driver Requester ID
+			 * CtlCmdType - 0: Read, 1: Write
+			 * CtlXYBitSel- 0: Y bit, 1: X bit
+			  ####### for T6 ######
+			 * CtlTcamSel   - 26:25  Control bit. 0: TCAM0, 1: TCAM1
+			 * CtlTcamIndex - 24:17  Control bits. Index of TCAM location to be accessed
+			  ####### for T7B ######
+			 * CtlTcamSel   - 27:26  Control bit. 0: TCAM0, 1: TCAM1, 2: TCAM2
+			 * CtlTcamIndex - 25:17  Control bits. Index of TCAM location to be accessed
+			 */
+
+			/* Read tcamy */
+			ctl = (CTLREQID_V(1) |
+					CTLCMDTYPE_V(0) | CTLXYBITSEL_V(0));
+
+			if (idx < 512)
+				ctl |= T7_1_CTLTCAMINDEX_V(idx) | T7_CTLTCAMSEL_V(0);
+			else if (idx < 1024)
+				ctl |= T7_1_CTLTCAMINDEX_V(idx - 512) |
+					T7_CTLTCAMSEL_V(1);
+			else /* idx 1024 to 1535 */
+				ctl |= T7_1_CTLTCAMINDEX_V(idx - 1024) |
+					T7_CTLTCAMSEL_V(2);
+
+			t4_write_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A, ctl);
+			val = t4_read_reg(adap, MPS_CLS_TCAM0_RDATA1_REQ_ID1_A);
+			tcamy = DMACH_G(val) << 32;
+			tcamy |= t4_read_reg(adap,
+					     MPS_CLS_TCAM0_RDATA0_REQ_ID1_A);
+			data2 = t4_read_reg(adap, MPS_CLS_TCAM0_RDATA2_REQ_ID1_A);
+			lookup_type = DATALKPTYPE_G(data2);
+			/* 0 - Outer header, 1 - Inner header
+			 * [71:48] bit locations are overloaded for
+			 * outer vs. inner lookup types.
+			 */
+			if (lookup_type && lookup_type != DATALKPTYPE_M) {
+				/* Inner header VNI */
+				vniy = (((data2 & DATAVIDH2_F) |
+							DATAVIDH1_G(data2)) << 16) |
+					VIDL_G(val);
+				dip_hit = data2 & DATADIPHIT_F;
+			} else {
+				vlan_vld = data2 & DATAVIDH2_F;
+				ivlan = VIDL_G(val);
+			}
+			port_num = DATAPORTNUM_G(data2);
+
+			/* Read tcamx. Change the control param */
+			vnix = 0;
+			ctl |= CTLXYBITSEL_V(1);
+			t4_write_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A, ctl);
+			val = t4_read_reg(adap, MPS_CLS_TCAM0_RDATA1_REQ_ID1_A);
+			tcamx = DMACH_G(val) << 32;
+			tcamx |= t4_read_reg(adap, MPS_CLS_TCAM0_RDATA0_REQ_ID1_A);
+			data2 = t4_read_reg(adap, MPS_CLS_TCAM0_RDATA2_REQ_ID1_A);
+			if (lookup_type && lookup_type != DATALKPTYPE_M) {
+				/* Inner header VNI mask */
+				vnix = (((data2 & DATAVIDH2_F) |
+							DATAVIDH1_G(data2)) << 16) |
+					VIDL_G(val);
+			}
+		} else if (chip_ver > CHELSIO_T5) {
 			/* CtlCmdType - 0: Read, 1: Write
 			 * CtlTcamSel - 0: TCAM0, 1: TCAM1
 			 * CtlXYBitSel- 0: Y bit, 1: X bit