drivers/net/ethernet/qualcomm/ppe/ppe_debugfs.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 */

/* PPE debugfs routines for display of PPE counters useful for debug. */

#include <linux/bitfield.h>
#include <linux/debugfs.h>
#include <linux/dev_printk.h>
#include <linux/device.h>
#include <linux/regmap.h>
#include <linux/seq_file.h>

#include "ppe.h"
#include "ppe_config.h"
#include "ppe_debugfs.h"
#include "ppe_regs.h"

#define PPE_PKT_CNT_TBL_SIZE				3
#define PPE_DROP_PKT_CNT_TBL_SIZE			5

#define PPE_W0_PKT_CNT					GENMASK(31, 0)
#define PPE_W2_DROP_PKT_CNT_LOW				GENMASK(31, 8)
#define PPE_W3_DROP_PKT_CNT_HIGH			GENMASK(7, 0)

#define PPE_GET_PKT_CNT(tbl_cnt)			\
	FIELD_GET(PPE_W0_PKT_CNT, *(tbl_cnt))
#define PPE_GET_DROP_PKT_CNT_LOW(tbl_cnt)		\
	FIELD_GET(PPE_W2_DROP_PKT_CNT_LOW, *((tbl_cnt) + 0x2))
#define PPE_GET_DROP_PKT_CNT_HIGH(tbl_cnt)		\
	FIELD_GET(PPE_W3_DROP_PKT_CNT_HIGH, *((tbl_cnt) + 0x3))

/**
 * enum ppe_cnt_size_type - PPE counter size type
 * @PPE_PKT_CNT_SIZE_1WORD: Counter size with single register
 * @PPE_PKT_CNT_SIZE_3WORD: Counter size with table of 3 words
 * @PPE_PKT_CNT_SIZE_5WORD: Counter size with table of 5 words
 *
 * PPE takes the different register size to record the packet counters.
 * It uses single register, or register table with 3 words or 5 words.
 * The counter with table size 5 words also records the drop counter.
 * There are also some other counter types occupying sizes less than 32
 * bits, which is not covered by this enumeration type.
 */
enum ppe_cnt_size_type {
	PPE_PKT_CNT_SIZE_1WORD,
	PPE_PKT_CNT_SIZE_3WORD,
	PPE_PKT_CNT_SIZE_5WORD,
};

/**
 * enum ppe_cnt_type - PPE counter type.
 * @PPE_CNT_BM: Packet counter processed by BM.
 * @PPE_CNT_PARSE: Packet counter parsed on ingress.
 * @PPE_CNT_PORT_RX: Packet counter on the ingress port.
 * @PPE_CNT_VLAN_RX: VLAN packet counter received.
 * @PPE_CNT_L2_FWD: Packet counter processed by L2 forwarding.
 * @PPE_CNT_CPU_CODE: Packet counter marked with various CPU codes.
 * @PPE_CNT_VLAN_TX: VLAN packet counter transmitted.
 * @PPE_CNT_PORT_TX: Packet counter on the egress port.
 * @PPE_CNT_QM: Packet counter processed by QM.
 */
enum ppe_cnt_type {
	PPE_CNT_BM,
	PPE_CNT_PARSE,
	PPE_CNT_PORT_RX,
	PPE_CNT_VLAN_RX,
	PPE_CNT_L2_FWD,
	PPE_CNT_CPU_CODE,
	PPE_CNT_VLAN_TX,
	PPE_CNT_PORT_TX,
	PPE_CNT_QM,
};

/**
 * struct ppe_debugfs_entry - PPE debugfs entry.
 * @name: Debugfs file name.
 * @counter_type: PPE packet counter type.
 * @ppe: PPE device.
 *
 * The PPE debugfs entry is used to create the debugfs file and passed
 * to debugfs_create_file() as private data.
 */
struct ppe_debugfs_entry {
	const char *name;
	enum ppe_cnt_type counter_type;
	struct ppe_device *ppe;
};

static const struct ppe_debugfs_entry debugfs_files[] = {
	{
		.name			= "bm",
		.counter_type		= PPE_CNT_BM,
	},
	{
		.name			= "parse",
		.counter_type		= PPE_CNT_PARSE,
	},
	{
		.name			= "port_rx",
		.counter_type		= PPE_CNT_PORT_RX,
	},
	{
		.name			= "vlan_rx",
		.counter_type		= PPE_CNT_VLAN_RX,
	},
	{
		.name			= "l2_forward",
		.counter_type		= PPE_CNT_L2_FWD,
	},
	{
		.name			= "cpu_code",
		.counter_type		= PPE_CNT_CPU_CODE,
	},
	{
		.name			= "vlan_tx",
		.counter_type		= PPE_CNT_VLAN_TX,
	},
	{
		.name			= "port_tx",
		.counter_type		= PPE_CNT_PORT_TX,
	},
	{
		.name			= "qm",
		.counter_type		= PPE_CNT_QM,
	},
};

static int ppe_pkt_cnt_get(struct ppe_device *ppe_dev, u32 reg,
			   enum ppe_cnt_size_type cnt_type,
			   u32 *cnt, u32 *drop_cnt)
{
	u32 drop_pkt_cnt[PPE_DROP_PKT_CNT_TBL_SIZE];
	u32 pkt_cnt[PPE_PKT_CNT_TBL_SIZE];
	u32 value;
	int ret;

	switch (cnt_type) {
	case PPE_PKT_CNT_SIZE_1WORD:
		ret = regmap_read(ppe_dev->regmap, reg, &value);
		if (ret)
			return ret;

		*cnt = value;
		break;
	case PPE_PKT_CNT_SIZE_3WORD:
		ret = regmap_bulk_read(ppe_dev->regmap, reg,
				       pkt_cnt, ARRAY_SIZE(pkt_cnt));
		if (ret)
			return ret;

		*cnt = PPE_GET_PKT_CNT(pkt_cnt);
		break;
	case PPE_PKT_CNT_SIZE_5WORD:
		ret = regmap_bulk_read(ppe_dev->regmap, reg,
				       drop_pkt_cnt, ARRAY_SIZE(drop_pkt_cnt));
		if (ret)
			return ret;

		*cnt = PPE_GET_PKT_CNT(drop_pkt_cnt);

		/* Drop counter with low 24 bits. */
		value  = PPE_GET_DROP_PKT_CNT_LOW(drop_pkt_cnt);
		*drop_cnt = FIELD_PREP(GENMASK(23, 0), value);

		/* Drop counter with high 8 bits. */
		value  = PPE_GET_DROP_PKT_CNT_HIGH(drop_pkt_cnt);
		*drop_cnt |= FIELD_PREP(GENMASK(31, 24), value);
		break;
	}

	return 0;
}

static void ppe_tbl_pkt_cnt_clear(struct ppe_device *ppe_dev, u32 reg,
				  enum ppe_cnt_size_type cnt_type)
{
	u32 drop_pkt_cnt[PPE_DROP_PKT_CNT_TBL_SIZE] = {};
	u32 pkt_cnt[PPE_PKT_CNT_TBL_SIZE] = {};

	switch (cnt_type) {
	case PPE_PKT_CNT_SIZE_1WORD:
		regmap_write(ppe_dev->regmap, reg, 0);
		break;
	case PPE_PKT_CNT_SIZE_3WORD:
		regmap_bulk_write(ppe_dev->regmap, reg,
				  pkt_cnt, ARRAY_SIZE(pkt_cnt));
		break;
	case PPE_PKT_CNT_SIZE_5WORD:
		regmap_bulk_write(ppe_dev->regmap, reg,
				  drop_pkt_cnt, ARRAY_SIZE(drop_pkt_cnt));
		break;
	}
}

static int ppe_bm_counter_get(struct ppe_device *ppe_dev, struct seq_file *seq)
{
	u32 reg, val, pkt_cnt, pkt_cnt1;
	int ret, i, tag;

	seq_printf(seq, "%-24s", "BM SILENT_DROP:");
	tag = 0;
	for (i = 0; i < PPE_DROP_CNT_TBL_ENTRIES; i++) {
		reg = PPE_DROP_CNT_TBL_ADDR + i * PPE_DROP_CNT_TBL_INC;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_1WORD,
				      &pkt_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (pkt_cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u(%s=%04d)", pkt_cnt, "port", i);
		}
	}

	seq_putc(seq, '\n');

	/* The number of packets dropped because hardware buffers were
	 * available only partially for the packet.
	 */
	seq_printf(seq, "%-24s", "BM OVERFLOW_DROP:");
	tag = 0;
	for (i = 0; i < PPE_DROP_STAT_TBL_ENTRIES; i++) {
		reg = PPE_DROP_STAT_TBL_ADDR + PPE_DROP_STAT_TBL_INC * i;

		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
				      &pkt_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (pkt_cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u(%s=%04d)", pkt_cnt, "port", i);
		}
	}

	seq_putc(seq, '\n');

	/* The number of currently occupied buffers, that can't be flushed. */
	seq_printf(seq, "%-24s", "BM USED/REACT:");
	tag = 0;
	for (i = 0; i < PPE_BM_USED_CNT_TBL_ENTRIES; i++) {
		reg = PPE_BM_USED_CNT_TBL_ADDR + i * PPE_BM_USED_CNT_TBL_INC;
		ret = regmap_read(ppe_dev->regmap, reg, &val);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		/* The number of PPE buffers used for caching the received
		 * packets before the pause frame sent.
		 */
		pkt_cnt = FIELD_GET(PPE_BM_USED_CNT_VAL, val);

		reg = PPE_BM_REACT_CNT_TBL_ADDR + i * PPE_BM_REACT_CNT_TBL_INC;
		ret = regmap_read(ppe_dev->regmap, reg, &val);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		/* The number of PPE buffers used for caching the received
		 * packets after pause frame sent out.
		 */
		pkt_cnt1 = FIELD_GET(PPE_BM_REACT_CNT_VAL, val);

		if (pkt_cnt > 0 || pkt_cnt1 > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u/%u(%s=%04d)", pkt_cnt, pkt_cnt1,
				   "port", i);
		}
	}

	seq_putc(seq, '\n');

	return 0;
}

/* The number of packets processed by the ingress parser module of PPE. */
static int ppe_parse_pkt_counter_get(struct ppe_device *ppe_dev,
				     struct seq_file *seq)
{
	u32 reg, cnt = 0, tunnel_cnt = 0;
	int i, ret, tag = 0;

	seq_printf(seq, "%-24s", "PARSE TPRX/IPRX:");
	for (i = 0; i < PPE_IPR_PKT_CNT_TBL_ENTRIES; i++) {
		reg = PPE_TPR_PKT_CNT_TBL_ADDR + i * PPE_TPR_PKT_CNT_TBL_INC;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_1WORD,
				      &tunnel_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		reg = PPE_IPR_PKT_CNT_TBL_ADDR + i * PPE_IPR_PKT_CNT_TBL_INC;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_1WORD,
				      &cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (tunnel_cnt > 0 || cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u/%u(%s=%04d)", tunnel_cnt, cnt,
				   "port", i);
		}
	}

	seq_putc(seq, '\n');

	return 0;
}

/* The number of packets received or dropped on the ingress port. */
static int ppe_port_rx_counter_get(struct ppe_device *ppe_dev,
				   struct seq_file *seq)
{
	u32 reg, pkt_cnt = 0, drop_cnt = 0;
	int ret, i, tag;

	seq_printf(seq, "%-24s", "PORT RX/RX_DROP:");
	tag = 0;
	for (i = 0; i < PPE_PHY_PORT_RX_CNT_TBL_ENTRIES; i++) {
		reg = PPE_PHY_PORT_RX_CNT_TBL_ADDR + PPE_PHY_PORT_RX_CNT_TBL_INC * i;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_5WORD,
				      &pkt_cnt, &drop_cnt);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (pkt_cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u/%u(%s=%04d)", pkt_cnt, drop_cnt,
				   "port", i);
		}
	}

	seq_putc(seq, '\n');

	seq_printf(seq, "%-24s", "VPORT RX/RX_DROP:");
	tag = 0;
	for (i = 0; i < PPE_PORT_RX_CNT_TBL_ENTRIES; i++) {
		reg = PPE_PORT_RX_CNT_TBL_ADDR + PPE_PORT_RX_CNT_TBL_INC * i;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_5WORD,
				      &pkt_cnt, &drop_cnt);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (pkt_cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u/%u(%s=%04d)", pkt_cnt, drop_cnt,
				   "port", i);
		}
	}

	seq_putc(seq, '\n');

	return 0;
}

/* The number of packets received or dropped by layer 2 processing. */
static int ppe_l2_counter_get(struct ppe_device *ppe_dev,
			      struct seq_file *seq)
{
	u32 reg, pkt_cnt = 0, drop_cnt = 0;
	int ret, i, tag = 0;

	seq_printf(seq, "%-24s", "L2 RX/RX_DROP:");
	for (i = 0; i < PPE_PRE_L2_CNT_TBL_ENTRIES; i++) {
		reg = PPE_PRE_L2_CNT_TBL_ADDR + PPE_PRE_L2_CNT_TBL_INC * i;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_5WORD,
				      &pkt_cnt, &drop_cnt);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (pkt_cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u/%u(%s=%04d)", pkt_cnt, drop_cnt,
				   "vsi", i);
		}
	}

	seq_putc(seq, '\n');

	return 0;
}

/* The number of VLAN packets received by PPE. */
static int ppe_vlan_rx_counter_get(struct ppe_device *ppe_dev,
				   struct seq_file *seq)
{
	u32 reg, pkt_cnt = 0;
	int ret, i, tag = 0;

	seq_printf(seq, "%-24s", "VLAN RX:");
	for (i = 0; i < PPE_VLAN_CNT_TBL_ENTRIES; i++) {
		reg = PPE_VLAN_CNT_TBL_ADDR + PPE_VLAN_CNT_TBL_INC * i;

		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
				      &pkt_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (pkt_cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u(%s=%04d)", pkt_cnt, "vsi", i);
		}
	}

	seq_putc(seq, '\n');

	return 0;
}

/* The number of packets handed to CPU by PPE. */
static int ppe_cpu_code_counter_get(struct ppe_device *ppe_dev,
				    struct seq_file *seq)
{
	u32 reg, pkt_cnt = 0;
	int ret, i;

	seq_printf(seq, "%-24s", "CPU CODE:");
	for (i = 0; i < PPE_DROP_CPU_CNT_TBL_ENTRIES; i++) {
		reg = PPE_DROP_CPU_CNT_TBL_ADDR + PPE_DROP_CPU_CNT_TBL_INC * i;

		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
				      &pkt_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (!pkt_cnt)
			continue;

		/* There are 256 CPU codes saved in the first 256 entries
		 * of register table, and 128 drop codes for each PPE port
		 * (0-7), the total entries is 256 + 8 * 128.
		 */
		if (i < 256)
			seq_printf(seq, "%10u(cpucode:%d)", pkt_cnt, i);
		else
			seq_printf(seq, "%10u(port=%04d),dropcode:%d", pkt_cnt,
				   (i - 256) % 8, (i - 256) / 8);
		seq_putc(seq, '\n');
		seq_printf(seq, "%-24s", "");
	}

	seq_putc(seq, '\n');

	return 0;
}

/* The number of packets forwarded by VLAN on the egress direction. */
static int ppe_vlan_tx_counter_get(struct ppe_device *ppe_dev,
				   struct seq_file *seq)
{
	u32 reg, pkt_cnt = 0;
	int ret, i, tag = 0;

	seq_printf(seq, "%-24s", "VLAN TX:");
	for (i = 0; i < PPE_EG_VSI_COUNTER_TBL_ENTRIES; i++) {
		reg = PPE_EG_VSI_COUNTER_TBL_ADDR + PPE_EG_VSI_COUNTER_TBL_INC * i;

		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
				      &pkt_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (pkt_cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u(%s=%04d)", pkt_cnt, "vsi", i);
		}
	}

	seq_putc(seq, '\n');

	return 0;
}

/* The number of packets transmitted or dropped on the egress port. */
static int ppe_port_tx_counter_get(struct ppe_device *ppe_dev,
				   struct seq_file *seq)
{
	u32 reg, pkt_cnt = 0, drop_cnt = 0;
	int ret, i, tag;

	seq_printf(seq, "%-24s", "VPORT TX/TX_DROP:");
	tag = 0;
	for (i = 0; i < PPE_VPORT_TX_COUNTER_TBL_ENTRIES; i++) {
		reg = PPE_VPORT_TX_COUNTER_TBL_ADDR + PPE_VPORT_TX_COUNTER_TBL_INC * i;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
				      &pkt_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		reg = PPE_VPORT_TX_DROP_CNT_TBL_ADDR + PPE_VPORT_TX_DROP_CNT_TBL_INC * i;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
				      &drop_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (pkt_cnt > 0 || drop_cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u/%u(%s=%04d)", pkt_cnt, drop_cnt,
				   "port", i);
		}
	}

	seq_putc(seq, '\n');

	seq_printf(seq, "%-24s", "PORT TX/TX_DROP:");
	tag = 0;
	for (i = 0; i < PPE_PORT_TX_COUNTER_TBL_ENTRIES; i++) {
		reg = PPE_PORT_TX_COUNTER_TBL_ADDR + PPE_PORT_TX_COUNTER_TBL_INC * i;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
				      &pkt_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		reg = PPE_PORT_TX_DROP_CNT_TBL_ADDR + PPE_PORT_TX_DROP_CNT_TBL_INC * i;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
				      &drop_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (pkt_cnt > 0 || drop_cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u/%u(%s=%04d)", pkt_cnt, drop_cnt,
				   "port", i);
		}
	}

	seq_putc(seq, '\n');

	return 0;
}

/* The number of packets transmitted or pending by the PPE queue. */
static int ppe_queue_counter_get(struct ppe_device *ppe_dev,
				 struct seq_file *seq)
{
	u32 reg, val, pkt_cnt = 0, pend_cnt = 0, drop_cnt = 0;
	int ret, i, tag = 0;

	seq_printf(seq, "%-24s", "QUEUE TX/PEND/DROP:");
	for (i = 0; i < PPE_QUEUE_TX_COUNTER_TBL_ENTRIES; i++) {
		reg = PPE_QUEUE_TX_COUNTER_TBL_ADDR + PPE_QUEUE_TX_COUNTER_TBL_INC * i;
		ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
				      &pkt_cnt, NULL);
		if (ret) {
			dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
			return ret;
		}

		if (i < PPE_AC_UNICAST_QUEUE_CFG_TBL_ENTRIES) {
			reg = PPE_AC_UNICAST_QUEUE_CNT_TBL_ADDR +
			      PPE_AC_UNICAST_QUEUE_CNT_TBL_INC * i;
			ret = regmap_read(ppe_dev->regmap, reg, &val);
			if (ret) {
				dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
				return ret;
			}

			pend_cnt = FIELD_GET(PPE_AC_UNICAST_QUEUE_CNT_TBL_PEND_CNT, val);

			reg = PPE_UNICAST_DROP_CNT_TBL_ADDR +
			      PPE_AC_UNICAST_QUEUE_CNT_TBL_INC *
			      (i * PPE_UNICAST_DROP_TYPES + PPE_UNICAST_DROP_FORCE_OFFSET);

			ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
					      &drop_cnt, NULL);
			if (ret) {
				dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
				return ret;
			}
		} else {
			int mq_offset = i - PPE_AC_UNICAST_QUEUE_CFG_TBL_ENTRIES;

			reg = PPE_AC_MULTICAST_QUEUE_CNT_TBL_ADDR +
			      PPE_AC_MULTICAST_QUEUE_CNT_TBL_INC * mq_offset;
			ret = regmap_read(ppe_dev->regmap, reg, &val);
			if (ret) {
				dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
				return ret;
			}

			pend_cnt = FIELD_GET(PPE_AC_MULTICAST_QUEUE_CNT_TBL_PEND_CNT, val);

			if (mq_offset < PPE_P0_MULTICAST_QUEUE_NUM) {
				reg = PPE_CPU_PORT_MULTICAST_FORCE_DROP_CNT_TBL_ADDR(mq_offset);
			} else {
				mq_offset -= PPE_P0_MULTICAST_QUEUE_NUM;

				reg = PPE_P1_MULTICAST_DROP_CNT_TBL_ADDR;
				reg += (mq_offset / PPE_MULTICAST_QUEUE_NUM) *
					PPE_MULTICAST_QUEUE_PORT_ADDR_INC;
				reg += (mq_offset % PPE_MULTICAST_QUEUE_NUM) *
					PPE_MULTICAST_DROP_CNT_TBL_INC *
					PPE_MULTICAST_DROP_TYPES;
			}

			ret = ppe_pkt_cnt_get(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD,
					      &drop_cnt, NULL);
			if (ret) {
				dev_err(ppe_dev->dev, "CNT ERROR %d\n", ret);
				return ret;
			}
		}

		if (pkt_cnt > 0 || pend_cnt > 0 || drop_cnt > 0) {
			if (!((++tag) % 4))
				seq_printf(seq, "\n%-24s", "");

			seq_printf(seq, "%10u/%u/%u(%s=%04d)",
				   pkt_cnt, pend_cnt, drop_cnt, "queue", i);
		}
	}

	seq_putc(seq, '\n');

	return 0;
}

/* Display the various packet counters of PPE. */
static int ppe_packet_counter_show(struct seq_file *seq, void *v)
{
	struct ppe_debugfs_entry *entry = seq->private;
	struct ppe_device *ppe_dev = entry->ppe;
	int ret;

	switch (entry->counter_type) {
	case PPE_CNT_BM:
		ret = ppe_bm_counter_get(ppe_dev, seq);
		break;
	case PPE_CNT_PARSE:
		ret = ppe_parse_pkt_counter_get(ppe_dev, seq);
		break;
	case PPE_CNT_PORT_RX:
		ret = ppe_port_rx_counter_get(ppe_dev, seq);
		break;
	case PPE_CNT_VLAN_RX:
		ret = ppe_vlan_rx_counter_get(ppe_dev, seq);
		break;
	case PPE_CNT_L2_FWD:
		ret = ppe_l2_counter_get(ppe_dev, seq);
		break;
	case PPE_CNT_CPU_CODE:
		ret = ppe_cpu_code_counter_get(ppe_dev, seq);
		break;
	case PPE_CNT_VLAN_TX:
		ret = ppe_vlan_tx_counter_get(ppe_dev, seq);
		break;
	case PPE_CNT_PORT_TX:
		ret = ppe_port_tx_counter_get(ppe_dev, seq);
		break;
	case PPE_CNT_QM:
		ret = ppe_queue_counter_get(ppe_dev, seq);
		break;
	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

/* Flush the various packet counters of PPE. */
static ssize_t ppe_packet_counter_write(struct file *file,
					const char __user *buf,
					size_t count, loff_t *pos)
{
	struct ppe_debugfs_entry *entry = file_inode(file)->i_private;
	struct ppe_device *ppe_dev = entry->ppe;
	u32 reg;
	int i;

	switch (entry->counter_type) {
	case PPE_CNT_BM:
		for (i = 0; i < PPE_DROP_CNT_TBL_ENTRIES; i++) {
			reg = PPE_DROP_CNT_TBL_ADDR + i * PPE_DROP_CNT_TBL_INC;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_1WORD);
		}

		for (i = 0; i < PPE_DROP_STAT_TBL_ENTRIES; i++) {
			reg = PPE_DROP_STAT_TBL_ADDR + PPE_DROP_STAT_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD);
		}

		break;
	case PPE_CNT_PARSE:
		for (i = 0; i < PPE_IPR_PKT_CNT_TBL_ENTRIES; i++) {
			reg = PPE_IPR_PKT_CNT_TBL_ADDR + i * PPE_IPR_PKT_CNT_TBL_INC;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_1WORD);

			reg = PPE_TPR_PKT_CNT_TBL_ADDR + i * PPE_TPR_PKT_CNT_TBL_INC;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_1WORD);
		}

		break;
	case PPE_CNT_PORT_RX:
		for (i = 0; i < PPE_PORT_RX_CNT_TBL_ENTRIES; i++) {
			reg = PPE_PORT_RX_CNT_TBL_ADDR + PPE_PORT_RX_CNT_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_5WORD);
		}

		for (i = 0; i < PPE_PHY_PORT_RX_CNT_TBL_ENTRIES; i++) {
			reg = PPE_PHY_PORT_RX_CNT_TBL_ADDR + PPE_PHY_PORT_RX_CNT_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_5WORD);
		}

		break;
	case PPE_CNT_VLAN_RX:
		for (i = 0; i < PPE_VLAN_CNT_TBL_ENTRIES; i++) {
			reg = PPE_VLAN_CNT_TBL_ADDR + PPE_VLAN_CNT_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD);
		}

		break;
	case PPE_CNT_L2_FWD:
		for (i = 0; i < PPE_PRE_L2_CNT_TBL_ENTRIES; i++) {
			reg = PPE_PRE_L2_CNT_TBL_ADDR + PPE_PRE_L2_CNT_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_5WORD);
		}

		break;
	case PPE_CNT_CPU_CODE:
		for (i = 0; i < PPE_DROP_CPU_CNT_TBL_ENTRIES; i++) {
			reg = PPE_DROP_CPU_CNT_TBL_ADDR + PPE_DROP_CPU_CNT_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD);
		}

		break;
	case PPE_CNT_VLAN_TX:
		for (i = 0; i < PPE_EG_VSI_COUNTER_TBL_ENTRIES; i++) {
			reg = PPE_EG_VSI_COUNTER_TBL_ADDR + PPE_EG_VSI_COUNTER_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD);
		}

		break;
	case PPE_CNT_PORT_TX:
		for (i = 0; i < PPE_PORT_TX_COUNTER_TBL_ENTRIES; i++) {
			reg = PPE_PORT_TX_DROP_CNT_TBL_ADDR + PPE_PORT_TX_DROP_CNT_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD);

			reg = PPE_PORT_TX_COUNTER_TBL_ADDR + PPE_PORT_TX_COUNTER_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD);
		}

		for (i = 0; i < PPE_VPORT_TX_COUNTER_TBL_ENTRIES; i++) {
			reg = PPE_VPORT_TX_COUNTER_TBL_ADDR + PPE_VPORT_TX_COUNTER_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD);

			reg = PPE_VPORT_TX_DROP_CNT_TBL_ADDR + PPE_VPORT_TX_DROP_CNT_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD);
		}

		break;
	case PPE_CNT_QM:
		for (i = 0; i < PPE_QUEUE_TX_COUNTER_TBL_ENTRIES; i++) {
			reg = PPE_QUEUE_TX_COUNTER_TBL_ADDR + PPE_QUEUE_TX_COUNTER_TBL_INC * i;
			ppe_tbl_pkt_cnt_clear(ppe_dev, reg, PPE_PKT_CNT_SIZE_3WORD);
		}

		break;
	default:
		break;
	}

	return count;
}
DEFINE_SHOW_STORE_ATTRIBUTE(ppe_packet_counter);

void ppe_debugfs_setup(struct ppe_device *ppe_dev)
{
	struct ppe_debugfs_entry *entry;
	int i;

	ppe_dev->debugfs_root = debugfs_create_dir("ppe", NULL);
	if (IS_ERR(ppe_dev->debugfs_root))
		return;

	for (i = 0; i < ARRAY_SIZE(debugfs_files); i++) {
		entry = devm_kzalloc(ppe_dev->dev, sizeof(*entry), GFP_KERNEL);
		if (!entry)
			return;

		entry->ppe = ppe_dev;
		entry->counter_type = debugfs_files[i].counter_type;

		debugfs_create_file(debugfs_files[i].name, 0444,
				    ppe_dev->debugfs_root, entry,
				    &ppe_packet_counter_fops);
	}
}

void ppe_debugfs_teardown(struct ppe_device *ppe_dev)
{
	debugfs_remove_recursive(ppe_dev->debugfs_root);
	ppe_dev->debugfs_root = NULL;
}