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

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

cxgb4: Add debugfs options to dump the rss key, config for PF, VF, etc 



Adds support to dump the rss table, rss_config, rss_key, rss_pf_config and
rss_vf_config

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

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

+10 −0
Original line number Diff line number Diff line
@@ -1038,6 +1038,16 @@ int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid, 
			int start, int n, const u16 *rspq, unsigned int nrspq);

int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode,

		       unsigned int flags);

int t4_read_rss(struct adapter *adapter, u16 *entries);

void t4_read_rss_key(struct adapter *adapter, u32 *key);

void t4_write_rss_key(struct adapter *adap, const u32 *key, int idx);

void t4_read_rss_pf_config(struct adapter *adapter, unsigned int index,

			   u32 *valp);

void t4_read_rss_vf_config(struct adapter *adapter, unsigned int index,

			   u32 *vfl, u32 *vfh);

u32 t4_read_rss_pf_map(struct adapter *adapter);

u32 t4_read_rss_pf_mask(struct adapter *adapter);



int t4_mc_read(struct adapter *adap, int idx, u32 addr, __be32 *data,

	       u64 *parity);

int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data,

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

+407 −0
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ 
#include <linux/debugfs.h>

#include <linux/string_helpers.h>

#include <linux/sort.h>

#include <linux/ctype.h>



#include "cxgb4.h"

#include "t4_regs.h"
@@ -624,6 +625,407 @@ static const struct file_operations clip_tbl_debugfs_fops = { 
};

#endif



/*RSS Table.

 */



static int rss_show(struct seq_file *seq, void *v, int idx)

{

	u16 *entry = v;



	seq_printf(seq, "%4d:  %4u  %4u  %4u  %4u  %4u  %4u  %4u  %4u\n",

		   idx * 8, entry[0], entry[1], entry[2], entry[3], entry[4],

		   entry[5], entry[6], entry[7]);

	return 0;

}



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

{

	int ret;

	struct seq_tab *p;

	struct adapter *adap = inode->i_private;



	p = seq_open_tab(file, RSS_NENTRIES / 8, 8 * sizeof(u16), 0, rss_show);

	if (!p)

		return -ENOMEM;



	ret = t4_read_rss(adap, (u16 *)p->data);

	if (ret)

		seq_release_private(inode, file);



	return ret;

}



static const struct file_operations rss_debugfs_fops = {

	.owner   = THIS_MODULE,

	.open    = rss_open,

	.read    = seq_read,

	.llseek  = seq_lseek,

	.release = seq_release_private

};



/* RSS Configuration.

 */



/* Small utility function to return the strings "yes" or "no" if the supplied

 * argument is non-zero.

 */

static const char *yesno(int x)

{

	static const char *yes = "yes";

	static const char *no = "no";



	return x ? yes : no;

}



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

{

	struct adapter *adapter = seq->private;

	static const char * const keymode[] = {

		"global",

		"global and per-VF scramble",

		"per-PF and per-VF scramble",

		"per-VF and per-VF scramble",

	};

	u32 rssconf;



	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_A);

	seq_printf(seq, "TP_RSS_CONFIG: %#x\n", rssconf);

	seq_printf(seq, "  Tnl4TupEnIpv6: %3s\n", yesno(rssconf &

							TNL4TUPENIPV6_F));

	seq_printf(seq, "  Tnl2TupEnIpv6: %3s\n", yesno(rssconf &

							TNL2TUPENIPV6_F));

	seq_printf(seq, "  Tnl4TupEnIpv4: %3s\n", yesno(rssconf &

							TNL4TUPENIPV4_F));

	seq_printf(seq, "  Tnl2TupEnIpv4: %3s\n", yesno(rssconf &

							TNL2TUPENIPV4_F));

	seq_printf(seq, "  TnlTcpSel:     %3s\n", yesno(rssconf & TNLTCPSEL_F));

	seq_printf(seq, "  TnlIp6Sel:     %3s\n", yesno(rssconf & TNLIP6SEL_F));

	seq_printf(seq, "  TnlVrtSel:     %3s\n", yesno(rssconf & TNLVRTSEL_F));

	seq_printf(seq, "  TnlMapEn:      %3s\n", yesno(rssconf & TNLMAPEN_F));

	seq_printf(seq, "  OfdHashSave:   %3s\n", yesno(rssconf &

							OFDHASHSAVE_F));

	seq_printf(seq, "  OfdVrtSel:     %3s\n", yesno(rssconf & OFDVRTSEL_F));

	seq_printf(seq, "  OfdMapEn:      %3s\n", yesno(rssconf & OFDMAPEN_F));

	seq_printf(seq, "  OfdLkpEn:      %3s\n", yesno(rssconf & OFDLKPEN_F));

	seq_printf(seq, "  Syn4TupEnIpv6: %3s\n", yesno(rssconf &

							SYN4TUPENIPV6_F));

	seq_printf(seq, "  Syn2TupEnIpv6: %3s\n", yesno(rssconf &

							SYN2TUPENIPV6_F));

	seq_printf(seq, "  Syn4TupEnIpv4: %3s\n", yesno(rssconf &

							SYN4TUPENIPV4_F));

	seq_printf(seq, "  Syn2TupEnIpv4: %3s\n", yesno(rssconf &

							SYN2TUPENIPV4_F));

	seq_printf(seq, "  Syn4TupEnIpv6: %3s\n", yesno(rssconf &

							SYN4TUPENIPV6_F));

	seq_printf(seq, "  SynIp6Sel:     %3s\n", yesno(rssconf & SYNIP6SEL_F));

	seq_printf(seq, "  SynVrt6Sel:    %3s\n", yesno(rssconf & SYNVRTSEL_F));

	seq_printf(seq, "  SynMapEn:      %3s\n", yesno(rssconf & SYNMAPEN_F));

	seq_printf(seq, "  SynLkpEn:      %3s\n", yesno(rssconf & SYNLKPEN_F));

	seq_printf(seq, "  ChnEn:         %3s\n", yesno(rssconf &

							CHANNELENABLE_F));

	seq_printf(seq, "  PrtEn:         %3s\n", yesno(rssconf &

							PORTENABLE_F));

	seq_printf(seq, "  TnlAllLkp:     %3s\n", yesno(rssconf &

							TNLALLLOOKUP_F));

	seq_printf(seq, "  VrtEn:         %3s\n", yesno(rssconf &

							VIRTENABLE_F));

	seq_printf(seq, "  CngEn:         %3s\n", yesno(rssconf &

							CONGESTIONENABLE_F));

	seq_printf(seq, "  HashToeplitz:  %3s\n", yesno(rssconf &

							HASHTOEPLITZ_F));

	seq_printf(seq, "  Udp4En:        %3s\n", yesno(rssconf & UDPENABLE_F));

	seq_printf(seq, "  Disable:       %3s\n", yesno(rssconf & DISABLE_F));



	seq_puts(seq, "\n");



	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_TNL_A);

	seq_printf(seq, "TP_RSS_CONFIG_TNL: %#x\n", rssconf);

	seq_printf(seq, "  MaskSize:      %3d\n", MASKSIZE_G(rssconf));

	seq_printf(seq, "  MaskFilter:    %3d\n", MASKFILTER_G(rssconf));

	if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) {

		seq_printf(seq, "  HashAll:     %3s\n",

			   yesno(rssconf & HASHALL_F));

		seq_printf(seq, "  HashEth:     %3s\n",

			   yesno(rssconf & HASHETH_F));

	}

	seq_printf(seq, "  UseWireCh:     %3s\n", yesno(rssconf & USEWIRECH_F));



	seq_puts(seq, "\n");



	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_OFD_A);

	seq_printf(seq, "TP_RSS_CONFIG_OFD: %#x\n", rssconf);

	seq_printf(seq, "  MaskSize:      %3d\n", MASKSIZE_G(rssconf));

	seq_printf(seq, "  RRCplMapEn:    %3s\n", yesno(rssconf &

							RRCPLMAPEN_F));

	seq_printf(seq, "  RRCplQueWidth: %3d\n", RRCPLQUEWIDTH_G(rssconf));



	seq_puts(seq, "\n");



	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_SYN_A);

	seq_printf(seq, "TP_RSS_CONFIG_SYN: %#x\n", rssconf);

	seq_printf(seq, "  MaskSize:      %3d\n", MASKSIZE_G(rssconf));

	seq_printf(seq, "  UseWireCh:     %3s\n", yesno(rssconf & USEWIRECH_F));



	seq_puts(seq, "\n");



	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_VRT_A);

	seq_printf(seq, "TP_RSS_CONFIG_VRT: %#x\n", rssconf);

	if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) {

		seq_printf(seq, "  KeyWrAddrX:     %3d\n",

			   KEYWRADDRX_G(rssconf));

		seq_printf(seq, "  KeyExtend:      %3s\n",

			   yesno(rssconf & KEYEXTEND_F));

	}

	seq_printf(seq, "  VfRdRg:        %3s\n", yesno(rssconf & VFRDRG_F));

	seq_printf(seq, "  VfRdEn:        %3s\n", yesno(rssconf & VFRDEN_F));

	seq_printf(seq, "  VfPerrEn:      %3s\n", yesno(rssconf & VFPERREN_F));

	seq_printf(seq, "  KeyPerrEn:     %3s\n", yesno(rssconf & KEYPERREN_F));

	seq_printf(seq, "  DisVfVlan:     %3s\n", yesno(rssconf &

							DISABLEVLAN_F));

	seq_printf(seq, "  EnUpSwt:       %3s\n", yesno(rssconf & ENABLEUP0_F));

	seq_printf(seq, "  HashDelay:     %3d\n", HASHDELAY_G(rssconf));

	if (CHELSIO_CHIP_VERSION(adapter->params.chip) <= CHELSIO_T5)

		seq_printf(seq, "  VfWrAddr:      %3d\n", VFWRADDR_G(rssconf));

	seq_printf(seq, "  KeyMode:       %s\n", keymode[KEYMODE_G(rssconf)]);

	seq_printf(seq, "  VfWrEn:        %3s\n", yesno(rssconf & VFWREN_F));

	seq_printf(seq, "  KeyWrEn:       %3s\n", yesno(rssconf & KEYWREN_F));

	seq_printf(seq, "  KeyWrAddr:     %3d\n", KEYWRADDR_G(rssconf));



	seq_puts(seq, "\n");



	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_CNG_A);

	seq_printf(seq, "TP_RSS_CONFIG_CNG: %#x\n", rssconf);

	seq_printf(seq, "  ChnCount3:     %3s\n", yesno(rssconf & CHNCOUNT3_F));

	seq_printf(seq, "  ChnCount2:     %3s\n", yesno(rssconf & CHNCOUNT2_F));

	seq_printf(seq, "  ChnCount1:     %3s\n", yesno(rssconf & CHNCOUNT1_F));

	seq_printf(seq, "  ChnCount0:     %3s\n", yesno(rssconf & CHNCOUNT0_F));

	seq_printf(seq, "  ChnUndFlow3:   %3s\n", yesno(rssconf &

							CHNUNDFLOW3_F));

	seq_printf(seq, "  ChnUndFlow2:   %3s\n", yesno(rssconf &

							CHNUNDFLOW2_F));

	seq_printf(seq, "  ChnUndFlow1:   %3s\n", yesno(rssconf &

							CHNUNDFLOW1_F));

	seq_printf(seq, "  ChnUndFlow0:   %3s\n", yesno(rssconf &

							CHNUNDFLOW0_F));

	seq_printf(seq, "  RstChn3:       %3s\n", yesno(rssconf & RSTCHN3_F));

	seq_printf(seq, "  RstChn2:       %3s\n", yesno(rssconf & RSTCHN2_F));

	seq_printf(seq, "  RstChn1:       %3s\n", yesno(rssconf & RSTCHN1_F));

	seq_printf(seq, "  RstChn0:       %3s\n", yesno(rssconf & RSTCHN0_F));

	seq_printf(seq, "  UpdVld:        %3s\n", yesno(rssconf & UPDVLD_F));

	seq_printf(seq, "  Xoff:          %3s\n", yesno(rssconf & XOFF_F));

	seq_printf(seq, "  UpdChn3:       %3s\n", yesno(rssconf & UPDCHN3_F));

	seq_printf(seq, "  UpdChn2:       %3s\n", yesno(rssconf & UPDCHN2_F));

	seq_printf(seq, "  UpdChn1:       %3s\n", yesno(rssconf & UPDCHN1_F));

	seq_printf(seq, "  UpdChn0:       %3s\n", yesno(rssconf & UPDCHN0_F));

	seq_printf(seq, "  Queue:         %3d\n", QUEUE_G(rssconf));



	return 0;

}



DEFINE_SIMPLE_DEBUGFS_FILE(rss_config);



/* RSS Secret Key.

 */



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

{

	u32 key[10];



	t4_read_rss_key(seq->private, key);

	seq_printf(seq, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n",

		   key[9], key[8], key[7], key[6], key[5], key[4], key[3],

		   key[2], key[1], key[0]);

	return 0;

}



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

{

	return single_open(file, rss_key_show, inode->i_private);

}



static ssize_t rss_key_write(struct file *file, const char __user *buf,

			     size_t count, loff_t *pos)

{

	int i, j;

	u32 key[10];

	char s[100], *p;

	struct adapter *adap = FILE_DATA(file)->i_private;



	if (count > sizeof(s) - 1)

		return -EINVAL;

	if (copy_from_user(s, buf, count))

		return -EFAULT;

	for (i = count; i > 0 && isspace(s[i - 1]); i--)

		;

	s[i] = '\0';



	for (p = s, i = 9; i >= 0; i--) {

		key[i] = 0;

		for (j = 0; j < 8; j++, p++) {

			if (!isxdigit(*p))

				return -EINVAL;

			key[i] = (key[i] << 4) | hex2val(*p);

		}

	}



	t4_write_rss_key(adap, key, -1);

	return count;

}



static const struct file_operations rss_key_debugfs_fops = {

	.owner   = THIS_MODULE,

	.open    = rss_key_open,

	.read    = seq_read,

	.llseek  = seq_lseek,

	.release = single_release,

	.write   = rss_key_write

};



/* PF RSS Configuration.

 */



struct rss_pf_conf {

	u32 rss_pf_map;

	u32 rss_pf_mask;

	u32 rss_pf_config;

};



static int rss_pf_config_show(struct seq_file *seq, void *v, int idx)

{

	struct rss_pf_conf *pfconf;



	if (v == SEQ_START_TOKEN) {

		/* use the 0th entry to dump the PF Map Index Size */

		pfconf = seq->private + offsetof(struct seq_tab, data);

		seq_printf(seq, "PF Map Index Size = %d\n\n",

			   LKPIDXSIZE_G(pfconf->rss_pf_map));



		seq_puts(seq, "     RSS              PF   VF    Hash Tuple Enable         Default\n");

		seq_puts(seq, "     Enable       IPF Mask Mask  IPv6      IPv4      UDP   Queue\n");

		seq_puts(seq, " PF  Map Chn Prt  Map Size Size  Four Two  Four Two  Four  Ch1  Ch0\n");

	} else {

		#define G_PFnLKPIDX(map, n) \

			(((map) >> PF1LKPIDX_S*(n)) & PF0LKPIDX_M)

		#define G_PFnMSKSIZE(mask, n) \

			(((mask) >> PF1MSKSIZE_S*(n)) & PF1MSKSIZE_M)



		pfconf = v;

		seq_printf(seq, "%3d  %3s %3s %3s  %3d  %3d  %3d   %3s %3s   %3s %3s   %3s  %3d  %3d\n",

			   idx,

			   yesno(pfconf->rss_pf_config & MAPENABLE_F),

			   yesno(pfconf->rss_pf_config & CHNENABLE_F),

			   yesno(pfconf->rss_pf_config & PRTENABLE_F),

			   G_PFnLKPIDX(pfconf->rss_pf_map, idx),

			   G_PFnMSKSIZE(pfconf->rss_pf_mask, idx),

			   IVFWIDTH_G(pfconf->rss_pf_config),

			   yesno(pfconf->rss_pf_config & IP6FOURTUPEN_F),

			   yesno(pfconf->rss_pf_config & IP6TWOTUPEN_F),

			   yesno(pfconf->rss_pf_config & IP4FOURTUPEN_F),

			   yesno(pfconf->rss_pf_config & IP4TWOTUPEN_F),

			   yesno(pfconf->rss_pf_config & UDPFOURTUPEN_F),

			   CH1DEFAULTQUEUE_G(pfconf->rss_pf_config),

			   CH0DEFAULTQUEUE_G(pfconf->rss_pf_config));



		#undef G_PFnLKPIDX

		#undef G_PFnMSKSIZE

	}

	return 0;

}



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

{

	struct adapter *adapter = inode->i_private;

	struct seq_tab *p;

	u32 rss_pf_map, rss_pf_mask;

	struct rss_pf_conf *pfconf;

	int pf;



	p = seq_open_tab(file, 8, sizeof(*pfconf), 1, rss_pf_config_show);

	if (!p)

		return -ENOMEM;



	pfconf = (struct rss_pf_conf *)p->data;

	rss_pf_map = t4_read_rss_pf_map(adapter);

	rss_pf_mask = t4_read_rss_pf_mask(adapter);

	for (pf = 0; pf < 8; pf++) {

		pfconf[pf].rss_pf_map = rss_pf_map;

		pfconf[pf].rss_pf_mask = rss_pf_mask;

		t4_read_rss_pf_config(adapter, pf, &pfconf[pf].rss_pf_config);

	}

	return 0;

}



static const struct file_operations rss_pf_config_debugfs_fops = {

	.owner   = THIS_MODULE,

	.open    = rss_pf_config_open,

	.read    = seq_read,

	.llseek  = seq_lseek,

	.release = seq_release_private

};



/* VF RSS Configuration.

 */



struct rss_vf_conf {

	u32 rss_vf_vfl;

	u32 rss_vf_vfh;

};



static int rss_vf_config_show(struct seq_file *seq, void *v, int idx)

{

	if (v == SEQ_START_TOKEN) {

		seq_puts(seq, "     RSS                     Hash Tuple Enable\n");

		seq_puts(seq, "     Enable   IVF  Dis  Enb  IPv6      IPv4      UDP    Def  Secret Key\n");

		seq_puts(seq, " VF  Chn Prt  Map  VLAN  uP  Four Two  Four Two  Four   Que  Idx       Hash\n");

	} else {

		struct rss_vf_conf *vfconf = v;



		seq_printf(seq, "%3d  %3s %3s  %3d   %3s %3s   %3s %3s   %3s  %3s   %3s  %4d  %3d %#10x\n",

			   idx,

			   yesno(vfconf->rss_vf_vfh & VFCHNEN_F),

			   yesno(vfconf->rss_vf_vfh & VFPRTEN_F),

			   VFLKPIDX_G(vfconf->rss_vf_vfh),

			   yesno(vfconf->rss_vf_vfh & VFVLNEX_F),

			   yesno(vfconf->rss_vf_vfh & VFUPEN_F),

			   yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F),

			   yesno(vfconf->rss_vf_vfh & VFIP6TWOTUPEN_F),

			   yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F),

			   yesno(vfconf->rss_vf_vfh & VFIP4TWOTUPEN_F),

			   yesno(vfconf->rss_vf_vfh & ENABLEUDPHASH_F),

			   DEFAULTQUEUE_G(vfconf->rss_vf_vfh),

			   KEYINDEX_G(vfconf->rss_vf_vfh),

			   vfconf->rss_vf_vfl);

	}

	return 0;

}



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

{

	struct adapter *adapter = inode->i_private;

	struct seq_tab *p;

	struct rss_vf_conf *vfconf;

	int vf;



	p = seq_open_tab(file, 128, sizeof(*vfconf), 1, rss_vf_config_show);

	if (!p)

		return -ENOMEM;



	vfconf = (struct rss_vf_conf *)p->data;

	for (vf = 0; vf < 128; vf++) {

		t4_read_rss_vf_config(adapter, vf, &vfconf[vf].rss_vf_vfl,

				      &vfconf[vf].rss_vf_vfh);

	}

	return 0;

}



static const struct file_operations rss_vf_config_debugfs_fops = {

	.owner   = THIS_MODULE,

	.open    = rss_vf_config_open,

	.read    = seq_read,

	.llseek  = seq_lseek,

	.release = seq_release_private

};



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

{

	unsigned int mem;
@@ -728,6 +1130,11 @@ int t4_setup_debugfs(struct adapter *adap) 
		{ "devlog", &devlog_fops, S_IRUSR, 0 },

		{ "l2t", &t4_l2t_fops, S_IRUSR, 0},

		{ "mps_tcam", &mps_tcam_debugfs_fops, S_IRUSR, 0 },

		{ "rss", &rss_debugfs_fops, S_IRUSR, 0 },

		{ "rss_config", &rss_config_debugfs_fops, S_IRUSR, 0 },

		{ "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 },

#if IS_ENABLED(CONFIG_IPV6)

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

#endif

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

+18 −0
Original line number Diff line number Diff line
@@ -39,6 +39,19 @@ 


#define FILE_DATA(_file) ((_file)->f_path.dentry->d_inode)



#define DEFINE_SIMPLE_DEBUGFS_FILE(name) \

static int name##_open(struct inode *inode, struct file *file) \

{ \

	return single_open(file, name##_show, inode->i_private); \

} \

static const struct file_operations name##_debugfs_fops = { \

	.owner   = THIS_MODULE, \

	.open    = name##_open, \

	.read    = seq_read, \

	.llseek  = seq_lseek, \

	.release = single_release \

}



struct t4_debugfs_entry {

	const char *name;

	const struct file_operations *ops;
@@ -54,6 +67,11 @@ struct seq_tab { 
	char data[0];             /* the table data */

};



static inline unsigned int hex2val(char c)

{

	return isdigit(c) ? c - '0' : tolower(c) - 'a' + 10;

}



struct seq_tab *seq_open_tab(struct file *f, unsigned int rows,

			     unsigned int width, unsigned int have_header,

			     int (*show)(struct seq_file *seq, void *v, int i));

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

+141 −0
Original line number Diff line number Diff line
@@ -2200,6 +2200,147 @@ int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode, 
	return t4_wr_mbox(adapter, mbox, &c, sizeof(c), NULL);

}



/* Read an RSS table row */

static int rd_rss_row(struct adapter *adap, int row, u32 *val)

{

	t4_write_reg(adap, TP_RSS_LKP_TABLE_A, 0xfff00000 | row);

	return t4_wait_op_done_val(adap, TP_RSS_LKP_TABLE_A, LKPTBLROWVLD_F, 1,

				   5, 0, val);

}



/**

 *	t4_read_rss - read the contents of the RSS mapping table

 *	@adapter: the adapter

 *	@map: holds the contents of the RSS mapping table

 *

 *	Reads the contents of the RSS hash->queue mapping table.

 */

int t4_read_rss(struct adapter *adapter, u16 *map)

{

	u32 val;

	int i, ret;



	for (i = 0; i < RSS_NENTRIES / 2; ++i) {

		ret = rd_rss_row(adapter, i, &val);

		if (ret)

			return ret;

		*map++ = LKPTBLQUEUE0_G(val);

		*map++ = LKPTBLQUEUE1_G(val);

	}

	return 0;

}



/**

 *	t4_read_rss_key - read the global RSS key

 *	@adap: the adapter

 *	@key: 10-entry array holding the 320-bit RSS key

 *

 *	Reads the global 320-bit RSS key.

 */

void t4_read_rss_key(struct adapter *adap, u32 *key)

{

	t4_read_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A, key, 10,

			 TP_RSS_SECRET_KEY0_A);

}



/**

 *	t4_write_rss_key - program one of the RSS keys

 *	@adap: the adapter

 *	@key: 10-entry array holding the 320-bit RSS key

 *	@idx: which RSS key to write

 *

 *	Writes one of the RSS keys with the given 320-bit value.  If @idx is

 *	0..15 the corresponding entry in the RSS key table is written,

 *	otherwise the global RSS key is written.

 */

void t4_write_rss_key(struct adapter *adap, const u32 *key, int idx)

{

	t4_write_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A, key, 10,

			  TP_RSS_SECRET_KEY0_A);

	if (idx >= 0 && idx < 16)

		t4_write_reg(adap, TP_RSS_CONFIG_VRT_A,

			     KEYWRADDR_V(idx) | KEYWREN_F);

}



/**

 *	t4_read_rss_pf_config - read PF RSS Configuration Table

 *	@adapter: the adapter

 *	@index: the entry in the PF RSS table to read

 *	@valp: where to store the returned value

 *

 *	Reads the PF RSS Configuration Table at the specified index and returns

 *	the value found there.

 */

void t4_read_rss_pf_config(struct adapter *adapter, unsigned int index,

			   u32 *valp)

{

	t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,

			 valp, 1, TP_RSS_PF0_CONFIG_A + index);

}



/**

 *	t4_read_rss_vf_config - read VF RSS Configuration Table

 *	@adapter: the adapter

 *	@index: the entry in the VF RSS table to read

 *	@vfl: where to store the returned VFL

 *	@vfh: where to store the returned VFH

 *

 *	Reads the VF RSS Configuration Table at the specified index and returns

 *	the (VFL, VFH) values found there.

 */

void t4_read_rss_vf_config(struct adapter *adapter, unsigned int index,

			   u32 *vfl, u32 *vfh)

{

	u32 vrt, mask, data;



	mask = VFWRADDR_V(VFWRADDR_M);

	data = VFWRADDR_V(index);



	/* Request that the index'th VF Table values be read into VFL/VFH.

	 */

	vrt = t4_read_reg(adapter, TP_RSS_CONFIG_VRT_A);

	vrt &= ~(VFRDRG_F | VFWREN_F | KEYWREN_F | mask);

	vrt |= data | VFRDEN_F;

	t4_write_reg(adapter, TP_RSS_CONFIG_VRT_A, vrt);



	/* Grab the VFL/VFH values ...

	 */

	t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,

			 vfl, 1, TP_RSS_VFL_CONFIG_A);

	t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,

			 vfh, 1, TP_RSS_VFH_CONFIG_A);

}



/**

 *	t4_read_rss_pf_map - read PF RSS Map

 *	@adapter: the adapter

 *

 *	Reads the PF RSS Map register and returns its value.

 */

u32 t4_read_rss_pf_map(struct adapter *adapter)

{

	u32 pfmap;



	t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,

			 &pfmap, 1, TP_RSS_PF_MAP_A);

	return pfmap;

}



/**

 *	t4_read_rss_pf_mask - read PF RSS Mask

 *	@adapter: the adapter

 *

 *	Reads the PF RSS Mask register and returns its value.

 */

u32 t4_read_rss_pf_mask(struct adapter *adapter)

{

	u32 pfmask;



	t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,

			 &pfmask, 1, TP_RSS_PF_MSK_A);

	return pfmask;

}



/**

 *	t4_tp_get_tcp_stats - read TP's TCP MIB counters

 *	@adap: the adapter

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

+402 −0

File changed.

Preview size limit exceeded, changes collapsed.