[linux-2.6-block.git] / drivers / net / ethernet / intel / ixgbe / ixgbe_debugfs.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 1999 - 2018 Intel Corporation. */

#include <linux/debugfs.h>
#include <linux/module.h>

#include "ixgbe.h"

static struct dentry *ixgbe_dbg_root;

static char ixgbe_dbg_reg_ops_buf[256] = "";

static ssize_t ixgbe_dbg_common_ops_read(struct file *filp, char __user *buffer,
					 size_t count, loff_t *ppos,
					 char *dbg_buf)
{
	struct ixgbe_adapter *adapter = filp->private_data;
	char *buf;
	int len;

	/* don't allow partial reads */
	if (*ppos != 0)
		return 0;

	buf = kasprintf(GFP_KERNEL, "%s: %s\n",
			adapter->netdev->name, dbg_buf);
	if (!buf)
		return -ENOMEM;

	if (count < strlen(buf)) {
		kfree(buf);
		return -ENOSPC;
	}

	len = simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));

	kfree(buf);
	return len;
}

/**
 * ixgbe_dbg_reg_ops_read - read for reg_ops datum
 * @filp: the opened file
 * @buffer: where to write the data for the user to read
 * @count: the size of the user's buffer
 * @ppos: file position offset
 **/
static ssize_t ixgbe_dbg_reg_ops_read(struct file *filp, char __user *buffer,
				      size_t count, loff_t *ppos)
{
	return ixgbe_dbg_common_ops_read(filp, buffer, count, ppos,
					 ixgbe_dbg_reg_ops_buf);
}

/**
 * ixgbe_dbg_reg_ops_write - write into reg_ops datum
 * @filp: the opened file
 * @buffer: where to find the user's data
 * @count: the length of the user's data
 * @ppos: file position offset
 **/
static ssize_t ixgbe_dbg_reg_ops_write(struct file *filp,
				     const char __user *buffer,
				     size_t count, loff_t *ppos)
{
	struct ixgbe_adapter *adapter = filp->private_data;
	int len;

	/* don't allow partial writes */
	if (*ppos != 0)
		return 0;
	if (count >= sizeof(ixgbe_dbg_reg_ops_buf))
		return -ENOSPC;

	len = simple_write_to_buffer(ixgbe_dbg_reg_ops_buf,
				     sizeof(ixgbe_dbg_reg_ops_buf)-1,
				     ppos,
				     buffer,
				     count);
	if (len < 0)
		return len;

	ixgbe_dbg_reg_ops_buf[len] = '\0';

	if (strncmp(ixgbe_dbg_reg_ops_buf, "write", 5) == 0) {
		u32 reg, value;
		int cnt;
		cnt = sscanf(&ixgbe_dbg_reg_ops_buf[5], "%x %x", &reg, &value);
		if (cnt == 2) {
			IXGBE_WRITE_REG(&adapter->hw, reg, value);
			value = IXGBE_READ_REG(&adapter->hw, reg);
			e_dev_info("write: 0x%08x = 0x%08x\n", reg, value);
		} else {
			e_dev_info("write <reg> <value>\n");
		}
	} else if (strncmp(ixgbe_dbg_reg_ops_buf, "read", 4) == 0) {
		u32 reg, value;
		int cnt;
		cnt = sscanf(&ixgbe_dbg_reg_ops_buf[4], "%x", &reg);
		if (cnt == 1) {
			value = IXGBE_READ_REG(&adapter->hw, reg);
			e_dev_info("read 0x%08x = 0x%08x\n", reg, value);
		} else {
			e_dev_info("read <reg>\n");
		}
	} else {
		e_dev_info("Unknown command %s\n", ixgbe_dbg_reg_ops_buf);
		e_dev_info("Available commands:\n");
		e_dev_info("   read <reg>\n");
		e_dev_info("   write <reg> <value>\n");
	}
	return count;
}

static const struct file_operations ixgbe_dbg_reg_ops_fops = {
	.owner = THIS_MODULE,
	.open = simple_open,
	.read =  ixgbe_dbg_reg_ops_read,
	.write = ixgbe_dbg_reg_ops_write,
};

static char ixgbe_dbg_netdev_ops_buf[256] = "";

/**
 * ixgbe_dbg_netdev_ops_read - read for netdev_ops datum
 * @filp: the opened file
 * @buffer: where to write the data for the user to read
 * @count: the size of the user's buffer
 * @ppos: file position offset
 **/
static ssize_t ixgbe_dbg_netdev_ops_read(struct file *filp, char __user *buffer,
					 size_t count, loff_t *ppos)
{
	return ixgbe_dbg_common_ops_read(filp, buffer, count, ppos,
					 ixgbe_dbg_netdev_ops_buf);
}

/**
 * ixgbe_dbg_netdev_ops_write - write into netdev_ops datum
 * @filp: the opened file
 * @buffer: where to find the user's data
 * @count: the length of the user's data
 * @ppos: file position offset
 **/
static ssize_t ixgbe_dbg_netdev_ops_write(struct file *filp,
					  const char __user *buffer,
					  size_t count, loff_t *ppos)
{
	struct ixgbe_adapter *adapter = filp->private_data;
	int len;

	/* don't allow partial writes */
	if (*ppos != 0)
		return 0;
	if (count >= sizeof(ixgbe_dbg_netdev_ops_buf))
		return -ENOSPC;

	len = simple_write_to_buffer(ixgbe_dbg_netdev_ops_buf,
				     sizeof(ixgbe_dbg_netdev_ops_buf)-1,
				     ppos,
				     buffer,
				     count);
	if (len < 0)
		return len;

	ixgbe_dbg_netdev_ops_buf[len] = '\0';

	if (strncmp(ixgbe_dbg_netdev_ops_buf, "tx_timeout", 10) == 0) {
		/* TX Queue number below is wrong, but ixgbe does not use it */
		adapter->netdev->netdev_ops->ndo_tx_timeout(adapter->netdev,
							    UINT_MAX);
		e_dev_info("tx_timeout called\n");
	} else {
		e_dev_info("Unknown command: %s\n", ixgbe_dbg_netdev_ops_buf);
		e_dev_info("Available commands:\n");
		e_dev_info("    tx_timeout\n");
	}
	return count;
}

static const struct file_operations ixgbe_dbg_netdev_ops_fops = {
	.owner = THIS_MODULE,
	.open = simple_open,
	.read = ixgbe_dbg_netdev_ops_read,
	.write = ixgbe_dbg_netdev_ops_write,
};

/**
 * ixgbe_dbg_adapter_init - setup the debugfs directory for the adapter
 * @adapter: the adapter that is starting up
 **/
void ixgbe_dbg_adapter_init(struct ixgbe_adapter *adapter)
{
	const char *name = pci_name(adapter->pdev);

	adapter->ixgbe_dbg_adapter = debugfs_create_dir(name, ixgbe_dbg_root);
	debugfs_create_file("reg_ops", 0600, adapter->ixgbe_dbg_adapter,
			    adapter, &ixgbe_dbg_reg_ops_fops);
	debugfs_create_file("netdev_ops", 0600, adapter->ixgbe_dbg_adapter,
			    adapter, &ixgbe_dbg_netdev_ops_fops);
}

/**
 * ixgbe_dbg_adapter_exit - clear out the adapter's debugfs entries
 * @adapter: the adapter that is exiting
 **/
void ixgbe_dbg_adapter_exit(struct ixgbe_adapter *adapter)
{
	debugfs_remove_recursive(adapter->ixgbe_dbg_adapter);
	adapter->ixgbe_dbg_adapter = NULL;
}

/**
 * ixgbe_dbg_init - start up debugfs for the driver
 **/
void ixgbe_dbg_init(void)
{
	ixgbe_dbg_root = debugfs_create_dir(ixgbe_driver_name, NULL);
}

/**
 * ixgbe_dbg_exit - clean out the driver's debugfs entries
 **/
void ixgbe_dbg_exit(void)
{
	debugfs_remove_recursive(ixgbe_dbg_root);
}
Commit	Line	Data
51dce24b JK	1	// SPDX-License-Identifier: GPL-2.0
51dce24b JK	2	/* Copyright(c) 1999 - 2018 Intel Corporation. */
00949167	3
00949167 CS	4	#include <linux/debugfs.h>
	5	#include <linux/module.h>
	6
	7	#include "ixgbe.h"
	8
	9	static struct dentry *ixgbe_dbg_root;
	10
91fbd8f0 CS	11	static char ixgbe_dbg_reg_ops_buf[256] = "";
91fbd8f0 CS	12
e9c72183 Y	13	static ssize_t ixgbe_dbg_common_ops_read(struct file filp, char __user buffer,
	14	size_t count, loff_t *ppos,
	15	char *dbg_buf)
91fbd8f0 CS	16	{
91fbd8f0 CS	17	struct ixgbe_adapter *adapter = filp->private_data;
3288d735	18	char *buf;
91fbd8f0 CS	19	int len;
	20
	21	/* don't allow partial reads */
	22	if (*ppos != 0)
	23	return 0;
	24
3288d735	25	buf = kasprintf(GFP_KERNEL, "%s: %s\n",
e9c72183	26	adapter->netdev->name, dbg_buf);
3288d735	27	if (!buf)
	28	return -ENOMEM;
	29
	30	if (count < strlen(buf)) {
	31	kfree(buf);
91fbd8f0	32	return -ENOSPC;
3288d735	33	}
	34
	35	len = simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
91fbd8f0	36
3288d735	37	kfree(buf);
91fbd8f0 CS	38	return len;
	39	}
	40
e9c72183 Y	41	/**
	42	* ixgbe_dbg_reg_ops_read - read for reg_ops datum
	43	* @filp: the opened file
	44	* @buffer: where to write the data for the user to read
	45	* @count: the size of the user's buffer
	46	* @ppos: file position offset
	47	**/
	48	static ssize_t ixgbe_dbg_reg_ops_read(struct file filp, char __user buffer,
	49	size_t count, loff_t *ppos)
	50	{
	51	return ixgbe_dbg_common_ops_read(filp, buffer, count, ppos,
	52	ixgbe_dbg_reg_ops_buf);
	53	}
	54
91fbd8f0 CS	55	/**
	56	* ixgbe_dbg_reg_ops_write - write into reg_ops datum
	57	* @filp: the opened file
	58	* @buffer: where to find the user's data
	59	* @count: the length of the user's data
	60	* @ppos: file position offset
	61	**/
	62	static ssize_t ixgbe_dbg_reg_ops_write(struct file *filp,
	63	const char __user *buffer,
	64	size_t count, loff_t *ppos)
	65	{
	66	struct ixgbe_adapter *adapter = filp->private_data;
3288d735	67	int len;
91fbd8f0 CS	68
	69	/* don't allow partial writes */
	70	if (*ppos != 0)
	71	return 0;
	72	if (count >= sizeof(ixgbe_dbg_reg_ops_buf))
	73	return -ENOSPC;
	74
3288d735	75	len = simple_write_to_buffer(ixgbe_dbg_reg_ops_buf,
	76	sizeof(ixgbe_dbg_reg_ops_buf)-1,
	77	ppos,
	78	buffer,
	79	count);
	80	if (len < 0)
	81	return len;
	82
	83	ixgbe_dbg_reg_ops_buf[len] = '\0';
91fbd8f0 CS	84
	85	if (strncmp(ixgbe_dbg_reg_ops_buf, "write", 5) == 0) {
	86	u32 reg, value;
	87	int cnt;
	88	cnt = sscanf(&ixgbe_dbg_reg_ops_buf[5], "%x %x", &reg, &value);
	89	if (cnt == 2) {
	90	IXGBE_WRITE_REG(&adapter->hw, reg, value);
	91	value = IXGBE_READ_REG(&adapter->hw, reg);
	92	e_dev_info("write: 0x%08x = 0x%08x\n", reg, value);
	93	} else {
	94	e_dev_info("write <reg> <value>\n");
	95	}
	96	} else if (strncmp(ixgbe_dbg_reg_ops_buf, "read", 4) == 0) {
	97	u32 reg, value;
	98	int cnt;
	99	cnt = sscanf(&ixgbe_dbg_reg_ops_buf[4], "%x", &reg);
	100	if (cnt == 1) {
	101	value = IXGBE_READ_REG(&adapter->hw, reg);
	102	e_dev_info("read 0x%08x = 0x%08x\n", reg, value);
	103	} else {
	104	e_dev_info("read <reg>\n");
	105	}
	106	} else {
	107	e_dev_info("Unknown command %s\n", ixgbe_dbg_reg_ops_buf);
	108	e_dev_info("Available commands:\n");
	109	e_dev_info(" read <reg>\n");
	110	e_dev_info(" write <reg> <value>\n");
	111	}
	112	return count;
	113	}
	114
	115	static const struct file_operations ixgbe_dbg_reg_ops_fops = {
	116	.owner = THIS_MODULE,
21cc57fb	117	.open = simple_open,
91fbd8f0 CS	118	.read = ixgbe_dbg_reg_ops_read,
	119	.write = ixgbe_dbg_reg_ops_write,
	120	};
	121
826ff0de CS	122	static char ixgbe_dbg_netdev_ops_buf[256] = "";
826ff0de CS	123
826ff0de CS	124	/**
	125	* ixgbe_dbg_netdev_ops_read - read for netdev_ops datum
	126	* @filp: the opened file
	127	* @buffer: where to write the data for the user to read
	128	* @count: the size of the user's buffer
	129	* @ppos: file position offset
	130	**/
e9c72183	131	static ssize_t ixgbe_dbg_netdev_ops_read(struct file filp, char __user buffer,
826ff0de CS	132	size_t count, loff_t *ppos)
826ff0de CS	133	{
e9c72183 Y	134	return ixgbe_dbg_common_ops_read(filp, buffer, count, ppos,
e9c72183 Y	135	ixgbe_dbg_netdev_ops_buf);
826ff0de CS	136	}
	137
	138	/**
	139	* ixgbe_dbg_netdev_ops_write - write into netdev_ops datum
	140	* @filp: the opened file
	141	* @buffer: where to find the user's data
	142	* @count: the length of the user's data
	143	* @ppos: file position offset
	144	**/
	145	static ssize_t ixgbe_dbg_netdev_ops_write(struct file *filp,
	146	const char __user *buffer,
	147	size_t count, loff_t *ppos)
	148	{
	149	struct ixgbe_adapter *adapter = filp->private_data;
3288d735	150	int len;
826ff0de CS	151
	152	/* don't allow partial writes */
	153	if (*ppos != 0)
	154	return 0;
	155	if (count >= sizeof(ixgbe_dbg_netdev_ops_buf))
	156	return -ENOSPC;
	157
3288d735	158	len = simple_write_to_buffer(ixgbe_dbg_netdev_ops_buf,
	159	sizeof(ixgbe_dbg_netdev_ops_buf)-1,
	160	ppos,
	161	buffer,
	162	count);
	163	if (len < 0)
	164	return len;
	165
	166	ixgbe_dbg_netdev_ops_buf[len] = '\0';
826ff0de CS	167
826ff0de CS	168	if (strncmp(ixgbe_dbg_netdev_ops_buf, "tx_timeout", 10) == 0) {
0290bd29 MT	169	/* TX Queue number below is wrong, but ixgbe does not use it */
	170	adapter->netdev->netdev_ops->ndo_tx_timeout(adapter->netdev,
	171	UINT_MAX);
826ff0de CS	172	e_dev_info("tx_timeout called\n");
	173	} else {
	174	e_dev_info("Unknown command: %s\n", ixgbe_dbg_netdev_ops_buf);
	175	e_dev_info("Available commands:\n");
	176	e_dev_info(" tx_timeout\n");
	177	}
	178	return count;
	179	}
	180
	181	static const struct file_operations ixgbe_dbg_netdev_ops_fops = {
	182	.owner = THIS_MODULE,
21cc57fb	183	.open = simple_open,
826ff0de CS	184	.read = ixgbe_dbg_netdev_ops_read,
	185	.write = ixgbe_dbg_netdev_ops_write,
	186	};
	187
00949167 CS	188	/**
	189	* ixgbe_dbg_adapter_init - setup the debugfs directory for the adapter
	190	* @adapter: the adapter that is starting up
	191	**/
	192	void ixgbe_dbg_adapter_init(struct ixgbe_adapter *adapter)
	193	{
	194	const char *name = pci_name(adapter->pdev);
35dc61eb	195
00949167	196	adapter->ixgbe_dbg_adapter = debugfs_create_dir(name, ixgbe_dbg_root);
35dc61eb GKH	197	debugfs_create_file("reg_ops", 0600, adapter->ixgbe_dbg_adapter,
	198	adapter, &ixgbe_dbg_reg_ops_fops);
	199	debugfs_create_file("netdev_ops", 0600, adapter->ixgbe_dbg_adapter,
	200	adapter, &ixgbe_dbg_netdev_ops_fops);
00949167 CS	201	}
	202
	203	/**
	204	* ixgbe_dbg_adapter_exit - clear out the adapter's debugfs entries
5ba643c6	205	* @adapter: the adapter that is exiting
00949167 CS	206	**/
	207	void ixgbe_dbg_adapter_exit(struct ixgbe_adapter *adapter)
	208	{
ec73942c	209	debugfs_remove_recursive(adapter->ixgbe_dbg_adapter);
00949167 CS	210	adapter->ixgbe_dbg_adapter = NULL;
	211	}
	212
	213	/**
	214	* ixgbe_dbg_init - start up debugfs for the driver
	215	**/
	216	void ixgbe_dbg_init(void)
	217	{
	218	ixgbe_dbg_root = debugfs_create_dir(ixgbe_driver_name, NULL);
00949167 CS	219	}
	220
	221	/**
	222	* ixgbe_dbg_exit - clean out the driver's debugfs entries
	223	**/
	224	void ixgbe_dbg_exit(void)
	225	{
	226	debugfs_remove_recursive(ixgbe_dbg_root);
	227	}