qca-nss-drv/nss_edma_strings.c

/*
 **************************************************************************
 * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
 * Permission to use, copy, modify, and/or distribute this software for
 * any purpose with or without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all copies.
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 **************************************************************************
 */

#include "nss_stats.h"
#include "nss_core.h"
#include <nss_edma.h>
#include "nss_strings.h"

/*
 * nss_edma_strings_stats_node
 *	EDMA statistics strings.
 */
struct nss_stats_info nss_edma_strings_stats_node[NSS_STATS_NODE_MAX] = {
	{"rx_pkts"		, NSS_STATS_TYPE_COMMON},
	{"rx_byts"		, NSS_STATS_TYPE_COMMON},
	{"tx_pkts"		, NSS_STATS_TYPE_COMMON},
	{"tx_byts"		, NSS_STATS_TYPE_COMMON},
	{"rx_queue[0]_drops"	, NSS_STATS_TYPE_DROP},
	{"rx_queue[1]_drops"	, NSS_STATS_TYPE_DROP},
	{"rx_queue[2]_drops"	, NSS_STATS_TYPE_DROP},
	{"rx_queue[3]_drops"	, NSS_STATS_TYPE_DROP}
};

/*
 * nss_edma_common_stats_strings_read()
 *	Read EDMA common node statistics names.
 */
static ssize_t nss_edma_common_stats_strings_read(struct file *fp, char __user *ubuf, size_t sz, loff_t *ppos)
{
	return nss_strings_print(ubuf, sz, ppos, nss_edma_strings_stats_node, NSS_STATS_NODE_MAX);
}

/*
 * nss_edma_common_stats_strings_ops
 */
NSS_STRINGS_DECLARE_FILE_OPERATIONS(edma_common_stats);

/*
 * nss_edma_strings_stats_tx
 */
struct nss_stats_info nss_edma_strings_stats_tx[NSS_EDMA_STATS_TX_MAX] = {
	{"tx_err"	, NSS_STATS_TYPE_ERROR},
	{"tx_drops"	, NSS_STATS_TYPE_DROP},
	{"desc_cnt"	, NSS_STATS_TYPE_SPECIAL}
};

/*
 * nss_edma_txring_strings_read()
 *      Read EDMA txring names.
 */
static ssize_t nss_edma_txring_strings_read(struct file *fp, char __user *ubuf, size_t sz, loff_t *ppos)
{
	return nss_strings_print(ubuf, sz, ppos, nss_edma_strings_stats_tx, NSS_EDMA_STATS_TX_MAX);
}

/*
 * edma_txring_strings_ops
 */
NSS_STRINGS_DECLARE_FILE_OPERATIONS(edma_txring);

/*
 * nss_edma_strings_stats_rx
 */
struct nss_stats_info nss_edma_strings_stats_rx[NSS_EDMA_STATS_RX_MAX] = {
	{"rx_csum_err"		, NSS_STATS_TYPE_ERROR},
	{"desc_cnt"		, NSS_STATS_TYPE_SPECIAL},
	{"qos_err"		, NSS_STATS_TYPE_DROP},
	{"rx_src_port_invalid"	, NSS_STATS_TYPE_DROP},
	{"rx_src_interface_invalid"	, NSS_STATS_TYPE_DROP}
};

/*
 * nss_edma_rxring_strings_read()
 *      Read EDMA rxring names.
 */
static ssize_t nss_edma_rxring_strings_read(struct file *fp, char __user *ubuf, size_t sz, loff_t *ppos)
{
	return nss_strings_print(ubuf, sz, ppos, nss_edma_strings_stats_rx, NSS_EDMA_STATS_RX_MAX);
}

/*
 * edma_rxring_strings_ops
 */
NSS_STRINGS_DECLARE_FILE_OPERATIONS(edma_rxring);

/*
 * nss_edma_strings_stats_txcmpl
 */
struct nss_stats_info nss_edma_strings_stats_txcmpl[NSS_EDMA_STATS_TXCMPL_MAX] = {
	{"desc_cnt"	, NSS_STATS_TYPE_SPECIAL}
};

/*
 * nss_edma_txcmplring_strings_read()
 *      Read EDMA txcmplring names.
 */
static ssize_t nss_edma_txcmplring_strings_read(struct file *fp, char __user *ubuf, size_t sz, loff_t *ppos)
{
	return nss_strings_print(ubuf, sz, ppos, nss_edma_strings_stats_txcmpl, NSS_EDMA_STATS_TXCMPL_MAX);
}

/*
 * edma_txcmplring_strings_ops
 */
NSS_STRINGS_DECLARE_FILE_OPERATIONS(edma_txcmplring);

/*
 * nss_edma_strings_stats_rxfill
 */
struct nss_stats_info nss_edma_strings_stats_rxfill[NSS_EDMA_STATS_RXFILL_MAX] = {
	{"desc_cnt"	, NSS_STATS_TYPE_SPECIAL}
};

/*
 * nss_edma_rxfillring_strings_read()
 *      Read EDMA rxfillring names.
 */
static ssize_t nss_edma_rxfillring_strings_read(struct file *fp, char __user *ubuf, size_t sz, loff_t *ppos)
{
	return nss_strings_print(ubuf, sz, ppos, nss_edma_strings_stats_rxfill, NSS_EDMA_STATS_RXFILL_MAX);
}

/*
 * edma_rxfillring_strings_ops
 */
NSS_STRINGS_DECLARE_FILE_OPERATIONS(edma_rxfillring);

/*
 * nss_edma_strings_stats_port_type
 */
struct nss_stats_info nss_edma_strings_stats_port_type[NSS_EDMA_PORT_TYPE_MAX] = {
	{"physical_port", NSS_STATS_TYPE_SPECIAL},
	{"virtual_port" , NSS_STATS_TYPE_SPECIAL}
};

/*
 * nss_edma_port_type_strings_read()
 *      Read EDMA port type names.
 */
static ssize_t nss_edma_port_type_strings_read(struct file *fp, char __user *ubuf, size_t sz, loff_t *ppos)
{
	return nss_strings_print(ubuf, sz, ppos, nss_edma_strings_stats_port_type, NSS_EDMA_PORT_TYPE_MAX);
}

/*
 * edma_port_type_strings_ops
 */
NSS_STRINGS_DECLARE_FILE_OPERATIONS(edma_port_type);

/*
 * nss_edma_strings_stats_port_ring_map
 */
struct nss_stats_info nss_edma_strings_stats_port_ring_map[NSS_EDMA_PORT_RING_MAP_MAX] = {
	{"rx_ring"	, NSS_STATS_TYPE_SPECIAL},
	{"tx_ring"	, NSS_STATS_TYPE_SPECIAL}
};

/*
 * nss_edma_port_ring_map_strings_read()
 *	Read EDMA port ring map names.
 */
static ssize_t nss_edma_port_ring_map_strings_read(struct file *fp, char __user *ubuf, size_t sz, loff_t *ppos)
{
	return nss_strings_print(ubuf, sz, ppos, nss_edma_strings_stats_port_ring_map, NSS_EDMA_PORT_RING_MAP_MAX);
}

/*
 * edma_port_ring_map_strings_ops
 */
NSS_STRINGS_DECLARE_FILE_OPERATIONS(edma_port_ring_map);

/*
 * nss_edma_strings_stats_err_map
 */
struct nss_stats_info nss_edma_strings_stats_err_map[NSS_EDMA_ERR_STATS_MAX] = {
	{"axi_rd_err"		, NSS_STATS_TYPE_ERROR},
	{"axi_wr_err"		, NSS_STATS_TYPE_ERROR},
	{"rx_desc_fifo_full_err", NSS_STATS_TYPE_ERROR},
	{"rx_buf_size_err"	, NSS_STATS_TYPE_ERROR},
	{"tx_sram_full_err"	, NSS_STATS_TYPE_ERROR},
	{"tx_cmpl_buf_full_err"	, NSS_STATS_TYPE_ERROR},
	{"pkt_len_la64k_err"	, NSS_STATS_TYPE_ERROR},
	{"pkt_len_le33_err"	, NSS_STATS_TYPE_ERROR},
	{"data_len_err"		, NSS_STATS_TYPE_ERROR},
	{"alloc_fail_cnt"	, NSS_STATS_TYPE_ERROR},
	{"qos_inval_dst_drops"	, NSS_STATS_TYPE_DROP}
};

/*
 * nss_edma_err_strings_read()
 *      Read EDMA error names.
 */
static ssize_t nss_edma_err_strings_read(struct file *fp, char __user *ubuf, size_t sz, loff_t *ppos)
{
	return nss_strings_print(ubuf, sz, ppos, nss_edma_strings_stats_err_map, NSS_EDMA_ERR_STATS_MAX);
}

/*
 * edma_err_strings_ops
 */
NSS_STRINGS_DECLARE_FILE_OPERATIONS(edma_err);

/*
 * nss_edma_strings_dentry_create()
 *      Create EDMA statistics strings debug entry.
 */
void nss_edma_strings_dentry_create(void)
{
	struct dentry *edma_d;
	struct dentry *edma_port_dir_d;
	struct dentry *edma_rings_dir_d;
	struct dentry *edma_rx_dir_d;
	struct dentry *edma_tx_dir_d;
	struct dentry *edma_rxfill_dir_d;
	struct dentry *edma_txcmpl_dir_d;
	struct dentry *file_d;

	if (!nss_top_main.strings_dentry) {
		nss_warning("qca-nss-drv/strings is not present");
		return;
	}

	edma_d = debugfs_create_dir("edma", nss_top_main.strings_dentry);
	if (!edma_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma directory");
		return;
	}

	/*
	 * EDMA port stats.
	 */
	edma_port_dir_d = debugfs_create_dir("ports", edma_d);
	if (!edma_port_dir_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/ports directory");
		goto fail;
	}

	file_d = debugfs_create_file("common_stats_str", 0400, edma_port_dir_d, &nss_top_main, &nss_edma_common_stats_strings_ops);
	if (!file_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/ports/common_stats_str file");
		goto fail;
	}

	file_d = debugfs_create_file("type", 0400, edma_port_dir_d, &nss_top_main, &nss_edma_port_type_strings_ops);
	if (!file_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/ports/type file");
		goto fail;
	}

	file_d = debugfs_create_file("ring_map", 0400, edma_port_dir_d, &nss_top_main, &nss_edma_port_ring_map_strings_ops);
	if (!file_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/ports/ring_map file");
		goto fail;
	}

	/*
	 *  edma error stats
	 */
	file_d = debugfs_create_file("err_stats", 0400, edma_d, &nss_top_main, &nss_edma_err_strings_ops);
	if (!file_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/err_stats file");
		goto fail;
	}

	/*
	 * edma ring stats
	 */
	edma_rings_dir_d = debugfs_create_dir("rings", edma_d);
	if (!edma_rings_dir_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/rings directory");
		goto fail;
	}

	/*
	 * edma tx ring stats
	 */
	edma_tx_dir_d = debugfs_create_dir("tx", edma_rings_dir_d);
	if (!edma_tx_dir_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/rings/tx directory");
		goto fail;
	}

	file_d = debugfs_create_file("tx_str", 0400, edma_tx_dir_d, &nss_top_main, &nss_edma_txring_strings_ops);
	if (!file_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/rings/tx file");
		goto fail;
	}

	/*
	 * edma rx ring stats
	 */
	edma_rx_dir_d = debugfs_create_dir("rx", edma_rings_dir_d);
	if (!edma_rx_dir_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/rings/rx directory");
		goto fail;
	}

	file_d = debugfs_create_file("rx_str", 0400, edma_rx_dir_d, &nss_top_main, &nss_edma_rxring_strings_ops);
	if (!file_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/rings/rx file");
		goto fail;
	}

	/*
	 * edma tx cmpl ring stats
	 */
	edma_txcmpl_dir_d = debugfs_create_dir("txcmpl", edma_rings_dir_d);
	if (!edma_txcmpl_dir_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/rings/txcmpl directory");
		goto fail;
	}

	file_d = debugfs_create_file("txcmpl_str", 0400, edma_txcmpl_dir_d, &nss_top_main, &nss_edma_txcmplring_strings_ops);
	if (!file_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/rings/txcmpl file");
		goto fail;
	}

	/*
	 * edma rx fill ring stats
	 */
	edma_rxfill_dir_d = debugfs_create_dir("rxfill", edma_rings_dir_d);
	if (!edma_rxfill_dir_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/rings/rxfill directory");
		goto fail;
	}

	file_d = debugfs_create_file("rxfill_str", 0400, edma_rxfill_dir_d, &nss_top_main, &nss_edma_rxfillring_strings_ops);
	if (!file_d) {
		nss_warning("Failed to create qca-nss-drv/strings/edma/rings/rxfill file");
		goto fail;
	}

	return;
fail:
	debugfs_remove_recursive(edma_d);
}