Commit cc98419a authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'mvpp2-add-debugfs-interface' 



Maxime Chevallier says:

====================
net: mvpp2: add debugfs interface

The PPv2 Header Parser and Classifier are not straightforward to debug,
having easy access to some of the many lookup tables configuration is
helpful during development and debug.

This series adds a basic debugfs interface, allowing to read data from
the Header Parser and some of the Classifier tables.

For now, the interface is read-only, and contains only some basic info.

This was actually used during RSS development, and might be useful to
troubleshoot some issues we might find.

The first patch of the series converts the mvpp2 files to SPDX, which
eases adding the new debugfs dedicated file.

The second patch adds the interface, and exposes basic Header Parser data.

The 3rd patch adds a hit counter for the Header Parser TCAM.

The 4th patch exposes classifier info.

The 5th patch adds some hit counters for some of the classifier engines.

Changes since V1:
- Rebased on the lastest net-next
- Made cls_flow_get non static so that it can be used in mvpp2_debugfs
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 2aa4a337 f9d30d5b

drivers/net/ethernet/marvell/mvpp2/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -4,4 +4,4 @@ 
#

obj-$(CONFIG_MVPP2) := mvpp2.o



mvpp2-objs := mvpp2_main.o mvpp2_prs.o mvpp2_cls.o
 
mvpp2-objs := mvpp2_main.o mvpp2_prs.o mvpp2_cls.o mvpp2_debugfs.o

drivers/net/ethernet/marvell/mvpp2/mvpp2.h

+19 −4
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Definitions for Marvell PPv2 network controller for Armada 375 SoC.

 *

 * Copyright (C) 2014 Marvell

 *

 * Marcin Wojtas <mw@semihalf.com>

 *

 * This file is licensed under the terms of the GNU General Public

 * License version 2. This program is licensed "as is" without any

 * warranty of any kind, whether express or implied.

 */

#ifndef _MVPP2_H_

#define _MVPP2_H_
@@ -67,6 +64,9 @@ 
#define MVPP2_PRS_SRAM_DATA_REG(idx)		(0x1204 + (idx) * 4)

#define MVPP2_PRS_TCAM_CTRL_REG			0x1230

#define     MVPP2_PRS_TCAM_EN_MASK		BIT(0)

#define MVPP2_PRS_TCAM_HIT_IDX_REG		0x1240

#define MVPP2_PRS_TCAM_HIT_CNT_REG		0x1244

#define     MVPP2_PRS_TCAM_HIT_CNT_MASK		GENMASK(15, 0)



/* RSS Registers */

#define MVPP22_RSS_INDEX			0x1500
@@ -124,6 +124,7 @@ 
#define MVPP22_CLS_C2_TCAM_DATA3		0x1b1c

#define MVPP22_CLS_C2_TCAM_DATA4		0x1b20

#define     MVPP22_CLS_C2_PORT_ID(port)		((port) << 8)

#define MVPP22_CLS_C2_HIT_CTR			0x1b50

#define MVPP22_CLS_C2_ACT			0x1b60

#define     MVPP22_CLS_C2_ACT_RSS_EN(act)	(((act) & 0x3) << 19)

#define     MVPP22_CLS_C2_ACT_FWD(act)		(((act) & 0x7) << 13)
@@ -132,8 +133,10 @@ 
#define MVPP22_CLS_C2_ATTR0			0x1b64

#define     MVPP22_CLS_C2_ATTR0_QHIGH(qh)	(((qh) & 0x1f) << 24)

#define     MVPP22_CLS_C2_ATTR0_QHIGH_MASK	0x1f

#define     MVPP22_CLS_C2_ATTR0_QHIGH_OFFS	24

#define     MVPP22_CLS_C2_ATTR0_QLOW(ql)	(((ql) & 0x7) << 21)

#define     MVPP22_CLS_C2_ATTR0_QLOW_MASK	0x7

#define     MVPP22_CLS_C2_ATTR0_QLOW_OFFS	21

#define MVPP22_CLS_C2_ATTR1			0x1b68

#define MVPP22_CLS_C2_ATTR2			0x1b6c

#define     MVPP22_CLS_C2_ATTR2_RSS_EN		BIT(30)
@@ -316,6 +319,11 @@ 
#define     MVPP22_BM_ADDR_HIGH_VIRT_RLS_MASK	0xff00

#define     MVPP22_BM_ADDR_HIGH_VIRT_RLS_SHIFT	8



/* Hit counters registers */

#define MVPP2_CTRS_IDX				0x7040

#define MVPP2_CLS_DEC_TBL_HIT_CTR		0x7700

#define MVPP2_CLS_FLOW_TBL_HIT_CTR		0x7704



/* TX Scheduler registers */

#define MVPP2_TXP_SCHED_PORT_INDEX_REG		0x8000

#define MVPP2_TXP_SCHED_Q_CMD_REG		0x8004
@@ -749,6 +757,9 @@ struct mvpp2 { 
	/* Workqueue to gather hardware statistics */

	char queue_name[30];

	struct workqueue_struct *stats_queue;



	/* Debugfs root entry */

	struct dentry *dbgfs_dir;

};



struct mvpp2_pcpu_stats {
@@ -1092,4 +1103,8 @@ u32 mvpp2_percpu_read(struct mvpp2 *priv, int cpu, u32 offset); 
void mvpp2_percpu_write_relaxed(struct mvpp2 *priv, int cpu, u32 offset,

				u32 data);



void mvpp2_dbgfs_init(struct mvpp2 *priv, const char *name);



void mvpp2_dbgfs_cleanup(struct mvpp2 *priv);



#endif

drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c

+45 −9
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * RSS and Classifier helpers for Marvell PPv2 Network Controller

 *

 * Copyright (C) 2014 Marvell

 *

 * Marcin Wojtas <mw@semihalf.com>

 *

 * This file is licensed under the terms of the GNU General Public

 * License version 2. This program is licensed "as is" without any

 * warranty of any kind, whether express or implied.

 */



#include "mvpp2.h"
@@ -325,7 +322,14 @@ static struct mvpp2_cls_flow cls_flows[MVPP2_N_FLOWS] = { 
		       0, 0),

};



static void mvpp2_cls_flow_read(struct mvpp2 *priv, int index,

u32 mvpp2_cls_flow_hits(struct mvpp2 *priv, int index)

{

	mvpp2_write(priv, MVPP2_CTRS_IDX, index);



	return mvpp2_read(priv, MVPP2_CLS_FLOW_TBL_HIT_CTR);

}



void mvpp2_cls_flow_read(struct mvpp2 *priv, int index,

			 struct mvpp2_cls_flow_entry *fe)

{

	fe->index = index;
@@ -345,6 +349,25 @@ static void mvpp2_cls_flow_write(struct mvpp2 *priv, 
	mvpp2_write(priv, MVPP2_CLS_FLOW_TBL2_REG,  fe->data[2]);

}



u32 mvpp2_cls_lookup_hits(struct mvpp2 *priv, int index)

{

	mvpp2_write(priv, MVPP2_CTRS_IDX, index);



	return mvpp2_read(priv, MVPP2_CLS_DEC_TBL_HIT_CTR);

}



void mvpp2_cls_lookup_read(struct mvpp2 *priv, int lkpid, int way,

			   struct mvpp2_cls_lookup_entry *le)

{

	u32 val;



	val = (way << MVPP2_CLS_LKP_INDEX_WAY_OFFS) | lkpid;

	mvpp2_write(priv, MVPP2_CLS_LKP_INDEX_REG, val);

	le->way = way;

	le->lkpid = lkpid;

	le->data = mvpp2_read(priv, MVPP2_CLS_LKP_TBL_REG);

}



/* Update classification lookup table register */

static void mvpp2_cls_lookup_write(struct mvpp2 *priv,

				   struct mvpp2_cls_lookup_entry *le)
@@ -391,6 +414,12 @@ static void mvpp2_cls_flow_eng_set(struct mvpp2_cls_flow_entry *fe, 
	fe->data[0] |= MVPP2_CLS_FLOW_TBL0_ENG(engine);

}



int mvpp2_cls_flow_eng_get(struct mvpp2_cls_flow_entry *fe)

{

	return (fe->data[0] >> MVPP2_CLS_FLOW_TBL0_OFFS) &

		MVPP2_CLS_FLOW_TBL0_ENG_MASK;

}



static void mvpp2_cls_flow_port_id_sel(struct mvpp2_cls_flow_entry *fe,

				       bool from_packet)

{
@@ -557,7 +586,7 @@ static int mvpp2_flow_set_hek_fields(struct mvpp2_cls_flow_entry *fe, 
	return 0;

}



static struct mvpp2_cls_flow *mvpp2_cls_flow_get(int flow)

struct mvpp2_cls_flow *mvpp2_cls_flow_get(int flow)

{

	if (flow >= MVPP2_N_FLOWS)

		return NULL;
@@ -728,7 +757,7 @@ static void mvpp2_cls_c2_write(struct mvpp2 *priv, 
	mvpp2_write(priv, MVPP22_CLS_C2_ATTR3, c2->attr[3]);

}



static void mvpp2_cls_c2_read(struct mvpp2 *priv, int index,

void mvpp2_cls_c2_read(struct mvpp2 *priv, int index,

		       struct mvpp2_cls_c2_entry *c2)

{

	mvpp2_write(priv, MVPP22_CLS_C2_TCAM_IDX, index);
@@ -844,6 +873,13 @@ void mvpp2_cls_port_config(struct mvpp2_port *port) 
	mvpp2_port_c2_cls_init(port);

}



u32 mvpp2_cls_c2_hit_count(struct mvpp2 *priv, int c2_index)

{

	mvpp2_write(priv, MVPP22_CLS_C2_TCAM_IDX, c2_index);



	return mvpp2_read(priv, MVPP22_CLS_C2_HIT_CTR);

}



static void mvpp2_rss_port_c2_enable(struct mvpp2_port *port)

{

	struct mvpp2_cls_c2_entry c2;

drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.h

+22 −4
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * RSS and Classifier definitions for Marvell PPv2 Network Controller

 *

 * Copyright (C) 2014 Marvell

 *

 * Marcin Wojtas <mw@semihalf.com>

 *

 * This file is licensed under the terms of the GNU General Public

 * License version 2. This program is licensed "as is" without any

 * warranty of any kind, whether express or implied.

 */



#ifndef _MVPP2_CLS_H_
@@ -212,4 +209,25 @@ void mvpp2_cls_port_config(struct mvpp2_port *port); 


void mvpp2_cls_oversize_rxq_set(struct mvpp2_port *port);



int mvpp2_cls_flow_eng_get(struct mvpp2_cls_flow_entry *fe);



u16 mvpp2_flow_get_hek_fields(struct mvpp2_cls_flow_entry *fe);



struct mvpp2_cls_flow *mvpp2_cls_flow_get(int flow);



u32 mvpp2_cls_flow_hits(struct mvpp2 *priv, int index);



void mvpp2_cls_flow_read(struct mvpp2 *priv, int index,

			 struct mvpp2_cls_flow_entry *fe);



u32 mvpp2_cls_lookup_hits(struct mvpp2 *priv, int index);



void mvpp2_cls_lookup_read(struct mvpp2 *priv, int lkpid, int way,

			   struct mvpp2_cls_lookup_entry *le);



u32 mvpp2_cls_c2_hit_count(struct mvpp2 *priv, int c2_index);



void mvpp2_cls_c2_read(struct mvpp2 *priv, int index,

		       struct mvpp2_cls_c2_entry *c2);



#endif

drivers/net/ethernet/marvell/mvpp2/mvpp2_debugfs.c

0 → 100644
+703 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Driver for Marvell PPv2 network controller for Armada 375 SoC.

 *

 * Copyright (C) 2018 Marvell

 */



#include <linux/kernel.h>

#include <linux/slab.h>

#include <linux/debugfs.h>



#include "mvpp2.h"

#include "mvpp2_prs.h"

#include "mvpp2_cls.h"



struct mvpp2_dbgfs_prs_entry {

	int tid;

	struct mvpp2 *priv;

};



struct mvpp2_dbgfs_flow_entry {

	int flow;

	struct mvpp2 *priv;

};



struct mvpp2_dbgfs_port_flow_entry {

	struct mvpp2_port *port;

	struct mvpp2_dbgfs_flow_entry *dbg_fe;

};



static int mvpp2_dbgfs_flow_flt_hits_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_flow_entry *entry = s->private;

	int id = MVPP2_FLOW_C2_ENTRY(entry->flow);



	u32 hits = mvpp2_cls_flow_hits(entry->priv, id);



	seq_printf(s, "%u\n", hits);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_flt_hits);



static int mvpp2_dbgfs_flow_dec_hits_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_flow_entry *entry = s->private;



	u32 hits = mvpp2_cls_lookup_hits(entry->priv, entry->flow);



	seq_printf(s, "%u\n", hits);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_dec_hits);



static int mvpp2_dbgfs_flow_type_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_flow_entry *entry = s->private;

	struct mvpp2_cls_flow *f;

	const char *flow_name;



	f = mvpp2_cls_flow_get(entry->flow);

	if (!f)

		return -EINVAL;



	switch (f->flow_type) {

	case IPV4_FLOW:

		flow_name = "ipv4";

		break;

	case IPV6_FLOW:

		flow_name = "ipv6";

		break;

	case TCP_V4_FLOW:

		flow_name = "tcp4";

		break;

	case TCP_V6_FLOW:

		flow_name = "tcp6";

		break;

	case UDP_V4_FLOW:

		flow_name = "udp4";

		break;

	case UDP_V6_FLOW:

		flow_name = "udp6";

		break;

	default:

		flow_name = "other";

	}



	seq_printf(s, "%s\n", flow_name);



	return 0;

}



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

{

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

}



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

{

	struct seq_file *seq = file->private_data;

	struct mvpp2_dbgfs_flow_entry *flow_entry = seq->private;



	kfree(flow_entry);

	return single_release(inode, file);

}



static const struct file_operations mvpp2_dbgfs_flow_type_fops = {

	.open = mvpp2_dbgfs_flow_type_open,

	.read = seq_read,

	.release = mvpp2_dbgfs_flow_type_release,

};



static int mvpp2_dbgfs_flow_id_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_flow_entry *entry = s->private;

	struct mvpp2_cls_flow *f;



	f = mvpp2_cls_flow_get(entry->flow);

	if (!f)

		return -EINVAL;



	seq_printf(s, "%d\n", f->flow_id);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_id);



static int mvpp2_dbgfs_port_flow_hash_opt_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_port_flow_entry *entry = s->private;

	struct mvpp2_port *port = entry->port;

	struct mvpp2_cls_flow_entry fe;

	struct mvpp2_cls_flow *f;

	int flow_index;

	u16 hash_opts;



	f = mvpp2_cls_flow_get(entry->dbg_fe->flow);

	if (!f)

		return -EINVAL;



	flow_index = MVPP2_PORT_FLOW_HASH_ENTRY(entry->port->id, f->flow_id);



	mvpp2_cls_flow_read(port->priv, flow_index, &fe);



	hash_opts = mvpp2_flow_get_hek_fields(&fe);



	seq_printf(s, "0x%04x\n", hash_opts);



	return 0;

}



static int mvpp2_dbgfs_port_flow_hash_opt_open(struct inode *inode,

					       struct file *file)

{

	return single_open(file, mvpp2_dbgfs_port_flow_hash_opt_show,

			   inode->i_private);

}



static int mvpp2_dbgfs_port_flow_hash_opt_release(struct inode *inode,

						  struct file *file)

{

	struct seq_file *seq = file->private_data;

	struct mvpp2_dbgfs_port_flow_entry *flow_entry = seq->private;



	kfree(flow_entry);

	return single_release(inode, file);

}



static const struct file_operations mvpp2_dbgfs_port_flow_hash_opt_fops = {

	.open = mvpp2_dbgfs_port_flow_hash_opt_open,

	.read = seq_read,

	.release = mvpp2_dbgfs_port_flow_hash_opt_release,

};



static int mvpp2_dbgfs_port_flow_engine_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_port_flow_entry *entry = s->private;

	struct mvpp2_port *port = entry->port;

	struct mvpp2_cls_flow_entry fe;

	struct mvpp2_cls_flow *f;

	int flow_index, engine;



	f = mvpp2_cls_flow_get(entry->dbg_fe->flow);

	if (!f)

		return -EINVAL;



	flow_index = MVPP2_PORT_FLOW_HASH_ENTRY(entry->port->id, f->flow_id);



	mvpp2_cls_flow_read(port->priv, flow_index, &fe);



	engine = mvpp2_cls_flow_eng_get(&fe);



	seq_printf(s, "%d\n", engine);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_flow_engine);



static int mvpp2_dbgfs_flow_c2_hits_show(struct seq_file *s, void *unused)

{

	struct mvpp2_port *port = s->private;

	u32 hits;



	hits = mvpp2_cls_c2_hit_count(port->priv,

				      MVPP22_CLS_C2_RSS_ENTRY(port->id));



	seq_printf(s, "%u\n", hits);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_c2_hits);



static int mvpp2_dbgfs_flow_c2_rxq_show(struct seq_file *s, void *unused)

{

	struct mvpp2_port *port = s->private;

	struct mvpp2_cls_c2_entry c2;

	u8 qh, ql;



	mvpp2_cls_c2_read(port->priv, MVPP22_CLS_C2_RSS_ENTRY(port->id), &c2);



	qh = (c2.attr[0] >> MVPP22_CLS_C2_ATTR0_QHIGH_OFFS) &

	     MVPP22_CLS_C2_ATTR0_QHIGH_MASK;



	ql = (c2.attr[0] >> MVPP22_CLS_C2_ATTR0_QLOW_OFFS) &

	     MVPP22_CLS_C2_ATTR0_QLOW_MASK;



	seq_printf(s, "%d\n", (qh << 3 | ql));



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_c2_rxq);



static int mvpp2_dbgfs_flow_c2_enable_show(struct seq_file *s, void *unused)

{

	struct mvpp2_port *port = s->private;

	struct mvpp2_cls_c2_entry c2;

	int enabled;



	mvpp2_cls_c2_read(port->priv, MVPP22_CLS_C2_RSS_ENTRY(port->id), &c2);



	enabled = !!(c2.attr[2] | MVPP22_CLS_C2_ATTR2_RSS_EN);



	seq_printf(s, "%d\n", enabled);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_c2_enable);



static int mvpp2_dbgfs_port_vid_show(struct seq_file *s, void *unused)

{

	struct mvpp2_port *port = s->private;

	unsigned char byte[2], enable[2];

	struct mvpp2 *priv = port->priv;

	struct mvpp2_prs_entry pe;

	unsigned long pmap;

	u16 rvid;

	int tid;



	for (tid = MVPP2_PRS_VID_PORT_FIRST(port->id);

	     tid <= MVPP2_PRS_VID_PORT_LAST(port->id); tid++) {

		mvpp2_prs_init_from_hw(priv, &pe, tid);



		pmap = mvpp2_prs_tcam_port_map_get(&pe);



		if (!priv->prs_shadow[tid].valid)

			continue;



		if (!test_bit(port->id, &pmap))

			continue;



		mvpp2_prs_tcam_data_byte_get(&pe, 2, &byte[0], &enable[0]);

		mvpp2_prs_tcam_data_byte_get(&pe, 3, &byte[1], &enable[1]);



		rvid = ((byte[0] & 0xf) << 8) + byte[1];



		seq_printf(s, "%u\n", rvid);

	}



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_vid);



static int mvpp2_dbgfs_port_parser_show(struct seq_file *s, void *unused)

{

	struct mvpp2_port *port = s->private;

	struct mvpp2 *priv = port->priv;

	struct mvpp2_prs_entry pe;

	unsigned long pmap;

	int i;



	for (i = 0; i < MVPP2_PRS_TCAM_SRAM_SIZE; i++) {

		mvpp2_prs_init_from_hw(port->priv, &pe, i);



		pmap = mvpp2_prs_tcam_port_map_get(&pe);

		if (priv->prs_shadow[i].valid && test_bit(port->id, &pmap))

			seq_printf(s, "%03d\n", i);

	}



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_parser);



static int mvpp2_dbgfs_filter_show(struct seq_file *s, void *unused)

{

	struct mvpp2_port *port = s->private;

	struct mvpp2 *priv = port->priv;

	struct mvpp2_prs_entry pe;

	unsigned long pmap;

	int index, tid;



	for (tid = MVPP2_PE_MAC_RANGE_START;

	     tid <= MVPP2_PE_MAC_RANGE_END; tid++) {

		unsigned char da[ETH_ALEN], da_mask[ETH_ALEN];



		if (!priv->prs_shadow[tid].valid ||

		    priv->prs_shadow[tid].lu != MVPP2_PRS_LU_MAC ||

		    priv->prs_shadow[tid].udf != MVPP2_PRS_UDF_MAC_DEF)

			continue;



		mvpp2_prs_init_from_hw(priv, &pe, tid);



		pmap = mvpp2_prs_tcam_port_map_get(&pe);



		/* We only want entries active on this port */

		if (!test_bit(port->id, &pmap))

			continue;



		/* Read mac addr from entry */

		for (index = 0; index < ETH_ALEN; index++)

			mvpp2_prs_tcam_data_byte_get(&pe, index, &da[index],

						     &da_mask[index]);



		seq_printf(s, "%pM\n", da);

	}



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_filter);



static int mvpp2_dbgfs_prs_lu_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_prs_entry *entry = s->private;

	struct mvpp2 *priv = entry->priv;



	seq_printf(s, "%x\n", priv->prs_shadow[entry->tid].lu);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_lu);



static int mvpp2_dbgfs_prs_pmap_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_prs_entry *entry = s->private;

	struct mvpp2_prs_entry pe;

	unsigned int pmap;



	mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid);



	pmap = mvpp2_prs_tcam_port_map_get(&pe);

	pmap &= MVPP2_PRS_PORT_MASK;



	seq_printf(s, "%02x\n", pmap);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_pmap);



static int mvpp2_dbgfs_prs_ai_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_prs_entry *entry = s->private;

	struct mvpp2_prs_entry pe;

	unsigned char ai, ai_mask;



	mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid);



	ai = pe.tcam[MVPP2_PRS_TCAM_AI_WORD] & MVPP2_PRS_AI_MASK;

	ai_mask = (pe.tcam[MVPP2_PRS_TCAM_AI_WORD] >> 16) & MVPP2_PRS_AI_MASK;



	seq_printf(s, "%02x %02x\n", ai, ai_mask);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_ai);



static int mvpp2_dbgfs_prs_hdata_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_prs_entry *entry = s->private;

	struct mvpp2_prs_entry pe;

	unsigned char data[8], mask[8];

	int i;



	mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid);



	for (i = 0; i < 8; i++)

		mvpp2_prs_tcam_data_byte_get(&pe, i, &data[i], &mask[i]);



	seq_printf(s, "%*phN %*phN\n", 8, data, 8, mask);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_hdata);



static int mvpp2_dbgfs_prs_sram_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_prs_entry *entry = s->private;

	struct mvpp2_prs_entry pe;



	mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid);



	seq_printf(s, "%*phN\n", 14, pe.sram);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_sram);



static int mvpp2_dbgfs_prs_hits_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_prs_entry *entry = s->private;

	int val;



	val = mvpp2_prs_hits(entry->priv, entry->tid);

	if (val < 0)

		return val;



	seq_printf(s, "%d\n", val);



	return 0;

}



DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_hits);



static int mvpp2_dbgfs_prs_valid_show(struct seq_file *s, void *unused)

{

	struct mvpp2_dbgfs_prs_entry *entry = s->private;

	struct mvpp2 *priv = entry->priv;

	int tid = entry->tid;



	seq_printf(s, "%d\n", priv->prs_shadow[tid].valid ? 1 : 0);



	return 0;

}



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

{

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

}



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

{

	struct seq_file *seq = file->private_data;

	struct mvpp2_dbgfs_prs_entry *entry = seq->private;



	kfree(entry);

	return single_release(inode, file);

}



static const struct file_operations mvpp2_dbgfs_prs_valid_fops = {

	.open = mvpp2_dbgfs_prs_valid_open,

	.read = seq_read,

	.release = mvpp2_dbgfs_prs_valid_release,

};



static int mvpp2_dbgfs_flow_port_init(struct dentry *parent,

				      struct mvpp2_port *port,

				      struct mvpp2_dbgfs_flow_entry *entry)

{

	struct mvpp2_dbgfs_port_flow_entry *port_entry;

	struct dentry *port_dir;



	port_dir = debugfs_create_dir(port->dev->name, parent);

	if (IS_ERR(port_dir))

		return PTR_ERR(port_dir);



	/* This will be freed by 'hash_opts' release op */

	port_entry = kmalloc(sizeof(*port_entry), GFP_KERNEL);

	if (!port_entry)

		return -ENOMEM;



	port_entry->port = port;

	port_entry->dbg_fe = entry;



	debugfs_create_file("hash_opts", 0444, port_dir, port_entry,

			    &mvpp2_dbgfs_port_flow_hash_opt_fops);



	debugfs_create_file("engine", 0444, port_dir, port_entry,

			    &mvpp2_dbgfs_port_flow_engine_fops);



	return 0;

}



static int mvpp2_dbgfs_flow_entry_init(struct dentry *parent,

				       struct mvpp2 *priv, int flow)

{

	struct mvpp2_dbgfs_flow_entry *entry;

	struct dentry *flow_entry_dir;

	char flow_entry_name[10];

	int i, ret;



	sprintf(flow_entry_name, "%02d", flow);



	flow_entry_dir = debugfs_create_dir(flow_entry_name, parent);

	if (!flow_entry_dir)

		return -ENOMEM;



	/* This will be freed by 'type' release op */

	entry = kmalloc(sizeof(*entry), GFP_KERNEL);

	if (!entry)

		return -ENOMEM;



	entry->flow = flow;

	entry->priv = priv;



	debugfs_create_file("flow_hits", 0444, flow_entry_dir, entry,

			    &mvpp2_dbgfs_flow_flt_hits_fops);



	debugfs_create_file("dec_hits", 0444, flow_entry_dir, entry,

			    &mvpp2_dbgfs_flow_dec_hits_fops);



	debugfs_create_file("type", 0444, flow_entry_dir, entry,

			    &mvpp2_dbgfs_flow_type_fops);



	debugfs_create_file("id", 0444, flow_entry_dir, entry,

			    &mvpp2_dbgfs_flow_id_fops);



	/* Create entry for each port */

	for (i = 0; i < priv->port_count; i++) {

		ret = mvpp2_dbgfs_flow_port_init(flow_entry_dir,

						 priv->port_list[i], entry);

		if (ret)

			return ret;

	}

	return 0;

}



static int mvpp2_dbgfs_flow_init(struct dentry *parent, struct mvpp2 *priv)

{

	struct dentry *flow_dir;

	int i, ret;



	flow_dir = debugfs_create_dir("flows", parent);

	if (!flow_dir)

		return -ENOMEM;



	for (i = 0; i < MVPP2_N_FLOWS; i++) {

		ret = mvpp2_dbgfs_flow_entry_init(flow_dir, priv, i);

		if (ret)

			return ret;

	}



	return 0;

}



static int mvpp2_dbgfs_prs_entry_init(struct dentry *parent,

				      struct mvpp2 *priv, int tid)

{

	struct mvpp2_dbgfs_prs_entry *entry;

	struct dentry *prs_entry_dir;

	char prs_entry_name[10];



	if (tid >= MVPP2_PRS_TCAM_SRAM_SIZE)

		return -EINVAL;



	sprintf(prs_entry_name, "%03d", tid);



	prs_entry_dir = debugfs_create_dir(prs_entry_name, parent);

	if (!prs_entry_dir)

		return -ENOMEM;



	/* The 'valid' entry's ops will free that */

	entry = kmalloc(sizeof(*entry), GFP_KERNEL);

	if (!entry)

		return -ENOMEM;



	entry->tid = tid;

	entry->priv = priv;



	/* Create each attr */

	debugfs_create_file("sram", 0444, prs_entry_dir, entry,

			    &mvpp2_dbgfs_prs_sram_fops);



	debugfs_create_file("valid", 0644, prs_entry_dir, entry,

			    &mvpp2_dbgfs_prs_valid_fops);



	debugfs_create_file("lookup_id", 0644, prs_entry_dir, entry,

			    &mvpp2_dbgfs_prs_lu_fops);



	debugfs_create_file("ai", 0644, prs_entry_dir, entry,

			    &mvpp2_dbgfs_prs_ai_fops);



	debugfs_create_file("header_data", 0644, prs_entry_dir, entry,

			    &mvpp2_dbgfs_prs_hdata_fops);



	debugfs_create_file("hits", 0444, prs_entry_dir, entry,

			    &mvpp2_dbgfs_prs_hits_fops);



	return 0;

}



static int mvpp2_dbgfs_prs_init(struct dentry *parent, struct mvpp2 *priv)

{

	struct dentry *prs_dir;

	int i, ret;



	prs_dir = debugfs_create_dir("parser", parent);

	if (!prs_dir)

		return -ENOMEM;



	for (i = 0; i < MVPP2_PRS_TCAM_SRAM_SIZE; i++) {

		ret = mvpp2_dbgfs_prs_entry_init(prs_dir, priv, i);

		if (ret)

			return ret;

	}



	return 0;

}



static int mvpp2_dbgfs_port_init(struct dentry *parent,

				 struct mvpp2_port *port)

{

	struct dentry *port_dir;



	port_dir = debugfs_create_dir(port->dev->name, parent);

	if (IS_ERR(port_dir))

		return PTR_ERR(port_dir);



	debugfs_create_file("parser_entries", 0444, port_dir, port,

			    &mvpp2_dbgfs_port_parser_fops);



	debugfs_create_file("mac_filter", 0444, port_dir, port,

			    &mvpp2_dbgfs_filter_fops);



	debugfs_create_file("vid_filter", 0444, port_dir, port,

			    &mvpp2_dbgfs_port_vid_fops);



	debugfs_create_file("c2_hits", 0444, port_dir, port,

			    &mvpp2_dbgfs_flow_c2_hits_fops);



	debugfs_create_file("default_rxq", 0444, port_dir, port,

			    &mvpp2_dbgfs_flow_c2_rxq_fops);



	debugfs_create_file("rss_enable", 0444, port_dir, port,

			    &mvpp2_dbgfs_flow_c2_enable_fops);



	return 0;

}



void mvpp2_dbgfs_cleanup(struct mvpp2 *priv)

{

	debugfs_remove_recursive(priv->dbgfs_dir);

}



void mvpp2_dbgfs_init(struct mvpp2 *priv, const char *name)

{

	struct dentry *mvpp2_dir, *mvpp2_root;

	int ret, i;



	mvpp2_root = debugfs_lookup(MVPP2_DRIVER_NAME, NULL);

	if (!mvpp2_root) {

		mvpp2_root = debugfs_create_dir(MVPP2_DRIVER_NAME, NULL);

		if (IS_ERR(mvpp2_root))

			return;

	}



	mvpp2_dir = debugfs_create_dir(name, mvpp2_root);

	if (IS_ERR(mvpp2_dir))

		return;



	priv->dbgfs_dir = mvpp2_dir;



	ret = mvpp2_dbgfs_prs_init(mvpp2_dir, priv);

	if (ret)

		goto err;



	for (i = 0; i < priv->port_count; i++) {

		ret = mvpp2_dbgfs_port_init(mvpp2_dir, priv->port_list[i]);

		if (ret)

			goto err;

	}



	ret = mvpp2_dbgfs_flow_init(mvpp2_dir, priv);

	if (ret)

		goto err;



	return;

err:

	mvpp2_dbgfs_cleanup(priv);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE