[mirror_ubuntu-eoan-kernel.git] / drivers / net / ethernet / qualcomm / qca_debug.c

/*
 *   Copyright (c) 2011, 2012, Qualcomm Atheros Communications Inc.
 *   Copyright (c) 2014, I2SE GmbH
 *
 *   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.
 */

/*   This file contains debugging routines for use in the QCA7K driver.
 */

#include <linux/debugfs.h>
#include <linux/ethtool.h>
#include <linux/seq_file.h>
#include <linux/types.h>

#include "qca_7k.h"
#include "qca_debug.h"

#define QCASPI_MAX_REGS 0x20

static const u16 qcaspi_spi_regs[] = {
	SPI_REG_BFR_SIZE,
	SPI_REG_WRBUF_SPC_AVA,
	SPI_REG_RDBUF_BYTE_AVA,
	SPI_REG_SPI_CONFIG,
	SPI_REG_SPI_STATUS,
	SPI_REG_INTR_CAUSE,
	SPI_REG_INTR_ENABLE,
	SPI_REG_RDBUF_WATERMARK,
	SPI_REG_WRBUF_WATERMARK,
	SPI_REG_SIGNATURE,
	SPI_REG_ACTION_CTRL
};

/* The order of these strings must match the order of the fields in
 * struct qcaspi_stats
 * See qca_spi.h
 */
static const char qcaspi_gstrings_stats[][ETH_GSTRING_LEN] = {
	"Triggered resets",
	"Device resets",
	"Reset timeouts",
	"Read errors",
	"Write errors",
	"Read buffer errors",
	"Write buffer errors",
	"Out of memory",
	"Write buffer misses",
	"Transmit ring full",
	"SPI errors",
};

#ifdef CONFIG_DEBUG_FS

static int
qcaspi_info_show(struct seq_file *s, void *what)
{
	struct qcaspi *qca = s->private;

	seq_printf(s, "RX buffer size   : %lu\n",
		   (unsigned long)qca->buffer_size);

	seq_puts(s, "TX ring state    : ");

	if (qca->txr.skb[qca->txr.head] == NULL)
		seq_puts(s, "empty");
	else if (qca->txr.skb[qca->txr.tail])
		seq_puts(s, "full");
	else
		seq_puts(s, "in use");

	seq_puts(s, "\n");

	seq_printf(s, "TX ring size     : %u\n",
		   qca->txr.size);

	seq_printf(s, "Sync state       : %u (",
		   (unsigned int)qca->sync);
	switch (qca->sync) {
	case QCASPI_SYNC_UNKNOWN:
		seq_puts(s, "QCASPI_SYNC_UNKNOWN");
		break;
	case QCASPI_SYNC_RESET:
		seq_puts(s, "QCASPI_SYNC_RESET");
		break;
	case QCASPI_SYNC_READY:
		seq_puts(s, "QCASPI_SYNC_READY");
		break;
	default:
		seq_puts(s, "INVALID");
		break;
	}
	seq_puts(s, ")\n");

	seq_printf(s, "IRQ              : %d\n",
		   qca->spi_dev->irq);
	seq_printf(s, "INTR REQ         : %u\n",
		   qca->intr_req);
	seq_printf(s, "INTR SVC         : %u\n",
		   qca->intr_svc);

	seq_printf(s, "SPI max speed    : %lu\n",
		   (unsigned long)qca->spi_dev->max_speed_hz);
	seq_printf(s, "SPI mode         : %x\n",
		   qca->spi_dev->mode);
	seq_printf(s, "SPI chip select  : %u\n",
		   (unsigned int)qca->spi_dev->chip_select);
	seq_printf(s, "SPI legacy mode  : %u\n",
		   (unsigned int)qca->legacy_mode);
	seq_printf(s, "SPI burst length : %u\n",
		   (unsigned int)qca->burst_len);

	return 0;
}

static int
qcaspi_info_open(struct inode *inode, struct file *file)
{
	return single_open(file, qcaspi_info_show, inode->i_private);
}

static const struct file_operations qcaspi_info_ops = {
	.open = qcaspi_info_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};

void
qcaspi_init_device_debugfs(struct qcaspi *qca)
{
	struct dentry *device_root;

	device_root = debugfs_create_dir(dev_name(&qca->net_dev->dev), NULL);
	qca->device_root = device_root;

	if (IS_ERR(device_root) || !device_root) {
		pr_warn("failed to create debugfs directory for %s\n",
			dev_name(&qca->net_dev->dev));
		return;
	}
	debugfs_create_file("info", S_IFREG | 0444, device_root, qca,
			    &qcaspi_info_ops);
}

void
qcaspi_remove_device_debugfs(struct qcaspi *qca)
{
	debugfs_remove_recursive(qca->device_root);
}

#else /* CONFIG_DEBUG_FS */

void
qcaspi_init_device_debugfs(struct qcaspi *qca)
{
}

void
qcaspi_remove_device_debugfs(struct qcaspi *qca)
{
}

#endif

static void
qcaspi_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *p)
{
	struct qcaspi *qca = netdev_priv(dev);

	strlcpy(p->driver, QCASPI_DRV_NAME, sizeof(p->driver));
	strlcpy(p->version, QCASPI_DRV_VERSION, sizeof(p->version));
	strlcpy(p->fw_version, "QCA7000", sizeof(p->fw_version));
	strlcpy(p->bus_info, dev_name(&qca->spi_dev->dev),
		sizeof(p->bus_info));
}

static int
qcaspi_get_link_ksettings(struct net_device *dev,
			  struct ethtool_link_ksettings *cmd)
{
	ethtool_link_ksettings_zero_link_mode(cmd, supported);
	ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half);

	cmd->base.speed = SPEED_10;
	cmd->base.duplex = DUPLEX_HALF;
	cmd->base.port = PORT_OTHER;
	cmd->base.autoneg = AUTONEG_DISABLE;

	return 0;
}

static void
qcaspi_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *estats, u64 *data)
{
	struct qcaspi *qca = netdev_priv(dev);
	struct qcaspi_stats *st = &qca->stats;

	memcpy(data, st, ARRAY_SIZE(qcaspi_gstrings_stats) * sizeof(u64));
}

static void
qcaspi_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
{
	switch (stringset) {
	case ETH_SS_STATS:
		memcpy(buf, &qcaspi_gstrings_stats,
		       sizeof(qcaspi_gstrings_stats));
		break;
	default:
		WARN_ON(1);
		break;
	}
}

static int
qcaspi_get_sset_count(struct net_device *dev, int sset)
{
	switch (sset) {
	case ETH_SS_STATS:
		return ARRAY_SIZE(qcaspi_gstrings_stats);
	default:
		return -EINVAL;
	}
}

static int
qcaspi_get_regs_len(struct net_device *dev)
{
	return sizeof(u32) * QCASPI_MAX_REGS;
}

static void
qcaspi_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
{
	struct qcaspi *qca = netdev_priv(dev);
	u32 *regs_buff = p;
	unsigned int i;

	regs->version = 1;
	memset(regs_buff, 0, sizeof(u32) * QCASPI_MAX_REGS);

	for (i = 0; i < ARRAY_SIZE(qcaspi_spi_regs); i++) {
		u16 offset, value;

		qcaspi_read_register(qca, qcaspi_spi_regs[i], &value);
		offset = qcaspi_spi_regs[i] >> 8;
		regs_buff[offset] = value;
	}
}

static void
qcaspi_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
{
	struct qcaspi *qca = netdev_priv(dev);

	ring->rx_max_pending = 4;
	ring->tx_max_pending = TX_RING_MAX_LEN;
	ring->rx_pending = 4;
	ring->tx_pending = qca->txr.count;
}

static int
qcaspi_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
{
	const struct net_device_ops *ops = dev->netdev_ops;
	struct qcaspi *qca = netdev_priv(dev);

	if ((ring->rx_pending) ||
	    (ring->rx_mini_pending) ||
	    (ring->rx_jumbo_pending))
		return -EINVAL;

	if (netif_running(dev))
		ops->ndo_stop(dev);

	qca->txr.count = max_t(u32, ring->tx_pending, TX_RING_MIN_LEN);
	qca->txr.count = min_t(u16, qca->txr.count, TX_RING_MAX_LEN);

	if (netif_running(dev))
		ops->ndo_open(dev);

	return 0;
}

static const struct ethtool_ops qcaspi_ethtool_ops = {
	.get_drvinfo = qcaspi_get_drvinfo,
	.get_link = ethtool_op_get_link,
	.get_ethtool_stats = qcaspi_get_ethtool_stats,
	.get_strings = qcaspi_get_strings,
	.get_sset_count = qcaspi_get_sset_count,
	.get_regs_len = qcaspi_get_regs_len,
	.get_regs = qcaspi_get_regs,
	.get_ringparam = qcaspi_get_ringparam,
	.set_ringparam = qcaspi_set_ringparam,
	.get_link_ksettings = qcaspi_get_link_ksettings,
};

void qcaspi_set_ethtool_ops(struct net_device *dev)
{
	dev->ethtool_ops = &qcaspi_ethtool_ops;
}
Commit	Line	Data
291ab06e SW	1	/*
	2	* Copyright (c) 2011, 2012, Qualcomm Atheros Communications Inc.
	3	* Copyright (c) 2014, I2SE GmbH
	4	*
	5	* Permission to use, copy, modify, and/or distribute this software
	6	* for any purpose with or without fee is hereby granted, provided
	7	* that the above copyright notice and this permission notice appear
	8	* in all copies.
	9	*
	10	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
	11	* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
	12	* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
	13	* THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
	14	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
	15	* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
	16	* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
	17	* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	18	*/
	19
	20	/* This file contains debugging routines for use in the QCA7K driver.
	21	*/
	22
	23	#include <linux/debugfs.h>
	24	#include <linux/ethtool.h>
	25	#include <linux/seq_file.h>
	26	#include <linux/types.h>
	27
	28	#include "qca_7k.h"
	29	#include "qca_debug.h"
	30
	31	#define QCASPI_MAX_REGS 0x20
	32
	33	static const u16 qcaspi_spi_regs[] = {
	34	SPI_REG_BFR_SIZE,
	35	SPI_REG_WRBUF_SPC_AVA,
	36	SPI_REG_RDBUF_BYTE_AVA,
	37	SPI_REG_SPI_CONFIG,
	38	SPI_REG_SPI_STATUS,
	39	SPI_REG_INTR_CAUSE,
	40	SPI_REG_INTR_ENABLE,
	41	SPI_REG_RDBUF_WATERMARK,
	42	SPI_REG_WRBUF_WATERMARK,
	43	SPI_REG_SIGNATURE,
	44	SPI_REG_ACTION_CTRL
	45	};
	46
	47	/* The order of these strings must match the order of the fields in
	48	* struct qcaspi_stats
	49	* See qca_spi.h
	50	*/
	51	static const char qcaspi_gstrings_stats[][ETH_GSTRING_LEN] = {
	52	"Triggered resets",
	53	"Device resets",
	54	"Reset timeouts",
	55	"Read errors",
	56	"Write errors",
	57	"Read buffer errors",
	58	"Write buffer errors",
	59	"Out of memory",
	60	"Write buffer misses",
	61	"Transmit ring full",
	62	"SPI errors",
	63	};
	64
65	#ifdef CONFIG_DEBUG_FS
66
67	static int
68	qcaspi_info_show(struct seq_file s, void what)
69	{
70	struct qcaspi *qca = s->private;
71
72	seq_printf(s, "RX buffer size : %lu\n",
73	(unsigned long)qca->buffer_size);
74
75	seq_puts(s, "TX ring state : ");
76
77	if (qca->txr.skb[qca->txr.head] == NULL)
78	seq_puts(s, "empty");
79	else if (qca->txr.skb[qca->txr.tail])
80	seq_puts(s, "full");
81	else
82	seq_puts(s, "in use");
83
84	seq_puts(s, "\n");
85
86	seq_printf(s, "TX ring size : %u\n",
87	qca->txr.size);
88
89	seq_printf(s, "Sync state : %u (",
90	(unsigned int)qca->sync);
91	switch (qca->sync) {
92	case QCASPI_SYNC_UNKNOWN:
93	seq_puts(s, "QCASPI_SYNC_UNKNOWN");
94	break;
95	case QCASPI_SYNC_RESET:
96	seq_puts(s, "QCASPI_SYNC_RESET");
97	break;
98	case QCASPI_SYNC_READY:
99	seq_puts(s, "QCASPI_SYNC_READY");
100	break;
101	default:
102	seq_puts(s, "INVALID");
103	break;
104	}
105	seq_puts(s, ")\n");
106
107	seq_printf(s, "IRQ : %d\n",
108	qca->spi_dev->irq);
109	seq_printf(s, "INTR REQ : %u\n",
110	qca->intr_req);
111	seq_printf(s, "INTR SVC : %u\n",
112	qca->intr_svc);
113
114	seq_printf(s, "SPI max speed : %lu\n",
115	(unsigned long)qca->spi_dev->max_speed_hz);
116	seq_printf(s, "SPI mode : %x\n",
117	qca->spi_dev->mode);
118	seq_printf(s, "SPI chip select : %u\n",
119	(unsigned int)qca->spi_dev->chip_select);
120	seq_printf(s, "SPI legacy mode : %u\n",
121	(unsigned int)qca->legacy_mode);
122	seq_printf(s, "SPI burst length : %u\n",
123	(unsigned int)qca->burst_len);
124
125	return 0;
126	}
127
128	static int
129	qcaspi_info_open(struct inode inode, struct file file)
130	{
131	return single_open(file, qcaspi_info_show, inode->i_private);
132	}
133
134	static const struct file_operations qcaspi_info_ops = {
135	.open = qcaspi_info_open,
136	.read = seq_read,
137	.llseek = seq_lseek,
138	.release = single_release,
139	};
140
141	void
142	qcaspi_init_device_debugfs(struct qcaspi *qca)
143	{
144	struct dentry *device_root;
145
146	device_root = debugfs_create_dir(dev_name(&qca->net_dev->dev), NULL);
147	qca->device_root = device_root;
148
149	if (IS_ERR(device_root) \|\| !device_root) {
150	pr_warn("failed to create debugfs directory for %s\n",
151	dev_name(&qca->net_dev->dev));
152	return;
153	}
d3757ba4	154	debugfs_create_file("info", S_IFREG \| 0444, device_root, qca,
291ab06e SW	155	&qcaspi_info_ops);
	156	}
	157
	158	void
	159	qcaspi_remove_device_debugfs(struct qcaspi *qca)
	160	{
	161	debugfs_remove_recursive(qca->device_root);
	162	}
	163
	164	#else /* CONFIG_DEBUG_FS */
	165
	166	void
	167	qcaspi_init_device_debugfs(struct qcaspi *qca)
	168	{
	169	}
	170
	171	void
	172	qcaspi_remove_device_debugfs(struct qcaspi *qca)
	173	{
	174	}
	175
	176	#endif
	177
	178	static void
	179	qcaspi_get_drvinfo(struct net_device dev, struct ethtool_drvinfo p)
	180	{
	181	struct qcaspi *qca = netdev_priv(dev);
	182
	183	strlcpy(p->driver, QCASPI_DRV_NAME, sizeof(p->driver));
	184	strlcpy(p->version, QCASPI_DRV_VERSION, sizeof(p->version));
	185	strlcpy(p->fw_version, "QCA7000", sizeof(p->fw_version));
	186	strlcpy(p->bus_info, dev_name(&qca->spi_dev->dev),
	187	sizeof(p->bus_info));
	188	}
	189
	190	static int
2cf8a897 PR	191	qcaspi_get_link_ksettings(struct net_device *dev,
2cf8a897 PR	192	struct ethtool_link_ksettings *cmd)
291ab06e	193	{
2cf8a897 PR	194	ethtool_link_ksettings_zero_link_mode(cmd, supported);
	195	ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half);
	196
	197	cmd->base.speed = SPEED_10;
	198	cmd->base.duplex = DUPLEX_HALF;
	199	cmd->base.port = PORT_OTHER;
	200	cmd->base.autoneg = AUTONEG_DISABLE;
291ab06e SW	201
	202	return 0;
	203	}
	204
	205	static void
	206	qcaspi_get_ethtool_stats(struct net_device dev, struct ethtool_stats estats, u64 *data)
	207	{
	208	struct qcaspi *qca = netdev_priv(dev);
	209	struct qcaspi_stats *st = &qca->stats;
	210
	211	memcpy(data, st, ARRAY_SIZE(qcaspi_gstrings_stats) * sizeof(u64));
	212	}
	213
	214	static void
	215	qcaspi_get_strings(struct net_device dev, u32 stringset, u8 buf)
	216	{
	217	switch (stringset) {
	218	case ETH_SS_STATS:
	219	memcpy(buf, &qcaspi_gstrings_stats,
	220	sizeof(qcaspi_gstrings_stats));
	221	break;
	222	default:
	223	WARN_ON(1);
	224	break;
	225	}
	226	}
	227
	228	static int
	229	qcaspi_get_sset_count(struct net_device *dev, int sset)
	230	{
	231	switch (sset) {
	232	case ETH_SS_STATS:
	233	return ARRAY_SIZE(qcaspi_gstrings_stats);
	234	default:
	235	return -EINVAL;
	236	}
	237	}
	238
	239	static int
	240	qcaspi_get_regs_len(struct net_device *dev)
	241	{
	242	return sizeof(u32) * QCASPI_MAX_REGS;
	243	}
	244
	245	static void
	246	qcaspi_get_regs(struct net_device dev, struct ethtool_regs regs, void *p)
	247	{
	248	struct qcaspi *qca = netdev_priv(dev);
	249	u32 *regs_buff = p;
	250	unsigned int i;
	251
	252	regs->version = 1;
	253	memset(regs_buff, 0, sizeof(u32) * QCASPI_MAX_REGS);
	254
	255	for (i = 0; i < ARRAY_SIZE(qcaspi_spi_regs); i++) {
	256	u16 offset, value;
	257
	258	qcaspi_read_register(qca, qcaspi_spi_regs[i], &value);
	259	offset = qcaspi_spi_regs[i] >> 8;
	260	regs_buff[offset] = value;
	261	}
	262	}
	263
	264	static void
265	qcaspi_get_ringparam(struct net_device dev, struct ethtool_ringparam ring)
266	{
267	struct qcaspi *qca = netdev_priv(dev);
268
269	ring->rx_max_pending = 4;
270	ring->tx_max_pending = TX_RING_MAX_LEN;
271	ring->rx_pending = 4;
272	ring->tx_pending = qca->txr.count;
273	}
274
275	static int
276	qcaspi_set_ringparam(struct net_device dev, struct ethtool_ringparam ring)
277	{
0324e75d	278	const struct net_device_ops *ops = dev->netdev_ops;
291ab06e SW	279	struct qcaspi *qca = netdev_priv(dev);
	280
	281	if ((ring->rx_pending) \|\|
	282	(ring->rx_mini_pending) \|\|
	283	(ring->rx_jumbo_pending))
	284	return -EINVAL;
	285
	286	if (netif_running(dev))
0324e75d	287	ops->ndo_stop(dev);
291ab06e SW	288
	289	qca->txr.count = max_t(u32, ring->tx_pending, TX_RING_MIN_LEN);
	290	qca->txr.count = min_t(u16, qca->txr.count, TX_RING_MAX_LEN);
	291
	292	if (netif_running(dev))
0324e75d	293	ops->ndo_open(dev);
291ab06e SW	294
	295	return 0;
	296	}
	297
	298	static const struct ethtool_ops qcaspi_ethtool_ops = {
	299	.get_drvinfo = qcaspi_get_drvinfo,
	300	.get_link = ethtool_op_get_link,
291ab06e SW	301	.get_ethtool_stats = qcaspi_get_ethtool_stats,
	302	.get_strings = qcaspi_get_strings,
	303	.get_sset_count = qcaspi_get_sset_count,
	304	.get_regs_len = qcaspi_get_regs_len,
	305	.get_regs = qcaspi_get_regs,
	306	.get_ringparam = qcaspi_get_ringparam,
	307	.set_ringparam = qcaspi_set_ringparam,
2cf8a897	308	.get_link_ksettings = qcaspi_get_link_ksettings,
291ab06e SW	309	};
	310
	311	void qcaspi_set_ethtool_ops(struct net_device *dev)
	312	{
	313	dev->ethtool_ops = &qcaspi_ethtool_ops;
	314	}