drivers/net/wimax/i2400m/debugfs.c - LeafOS-Devices/android_kernel_samsung_gta4xl - Gitiles

 /*
  * Intel Wireless WiMAX Connection 2400m
  * Debugfs interfaces to manipulate driver and device information
  *
  *
  * Copyright (C) 2007 Intel Corporation <linux-wimax@intel.com>
  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version
  * 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  */

 #include <linux/debugfs.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/spinlock.h>
 #include <linux/device.h>
 #include "i2400m.h"


 #define D_SUBMODULE debugfs
 #include "debug-levels.h"

 static
 int debugfs_netdev_queue_stopped_get(void *data, u64 *val)
 {
 	struct i2400m *i2400m = data;
 	*val = netif_queue_stopped(i2400m->wimax_dev.net_dev);
 	return 0;
 }
 DEFINE_SIMPLE_ATTRIBUTE(fops_netdev_queue_stopped,
 			debugfs_netdev_queue_stopped_get,
 			NULL, "%llu\n");


 static
 struct dentry *debugfs_create_netdev_queue_stopped(
 	const char *name, struct dentry *parent, struct i2400m *i2400m)
 {
 	return debugfs_create_file(name, 0400, parent, i2400m,
 				   &fops_netdev_queue_stopped);
 }


 /*
  * inode->i_private has the @data argument to debugfs_create_file()
  */
 static
 int i2400m_stats_open(struct inode *inode, struct file *filp)
 {
 	filp->private_data = inode->i_private;
 	return 0;
 }

 /*
  * We don't allow partial reads of this file, as then the reader would
  * get weirdly confused data as it is updated.
  *
  * So or you read it all or nothing; if you try to read with an offset
  * != 0, we consider you are done reading.
  */
 static
 ssize_t i2400m_rx_stats_read(struct file *filp, char __user *buffer,
 			     size_t count, loff_t *ppos)
 {
 	struct i2400m *i2400m = filp->private_data;
 	char buf[128];
 	unsigned long flags;

 	if (*ppos != 0)
 		return 0;
 	if (count < sizeof(buf))
 		return -ENOSPC;
 	spin_lock_irqsave(&i2400m->rx_lock, flags);
 	snprintf(buf, sizeof(buf), "%u %u %u %u %u %u %u\n",
 		 i2400m->rx_pl_num, i2400m->rx_pl_min,
 		 i2400m->rx_pl_max, i2400m->rx_num,
 		 i2400m->rx_size_acc,
 		 i2400m->rx_size_min, i2400m->rx_size_max);
 	spin_unlock_irqrestore(&i2400m->rx_lock, flags);
 	return simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
 }


 /* Any write clears the stats */
 static
 ssize_t i2400m_rx_stats_write(struct file *filp, const char __user *buffer,
 			      size_t count, loff_t *ppos)
 {
 	struct i2400m *i2400m = filp->private_data;
 	unsigned long flags;

 	spin_lock_irqsave(&i2400m->rx_lock, flags);
 	i2400m->rx_pl_num = 0;
 	i2400m->rx_pl_max = 0;
 	i2400m->rx_pl_min = UINT_MAX;
 	i2400m->rx_num = 0;
 	i2400m->rx_size_acc = 0;
 	i2400m->rx_size_min = UINT_MAX;
 	i2400m->rx_size_max = 0;
 	spin_unlock_irqrestore(&i2400m->rx_lock, flags);
 	return count;
 }

 static
 const struct file_operations i2400m_rx_stats_fops = {
 	.owner =	THIS_MODULE,
 	.open =		i2400m_stats_open,
 	.read =		i2400m_rx_stats_read,
 	.write =	i2400m_rx_stats_write,
 };


 /* See i2400m_rx_stats_read() */
 static
 ssize_t i2400m_tx_stats_read(struct file *filp, char __user *buffer,
 			     size_t count, loff_t *ppos)
 {
 	struct i2400m *i2400m = filp->private_data;
 	char buf[128];
 	unsigned long flags;

 	if (*ppos != 0)
 		return 0;
 	if (count < sizeof(buf))
 		return -ENOSPC;
 	spin_lock_irqsave(&i2400m->tx_lock, flags);
 	snprintf(buf, sizeof(buf), "%u %u %u %u %u %u %u\n",
 		 i2400m->tx_pl_num, i2400m->tx_pl_min,
 		 i2400m->tx_pl_max, i2400m->tx_num,
 		 i2400m->tx_size_acc,
 		 i2400m->tx_size_min, i2400m->tx_size_max);
 	spin_unlock_irqrestore(&i2400m->tx_lock, flags);
 	return simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
 }

 /* Any write clears the stats */
 static
 ssize_t i2400m_tx_stats_write(struct file *filp, const char __user *buffer,
 			      size_t count, loff_t *ppos)
 {
 	struct i2400m *i2400m = filp->private_data;
 	unsigned long flags;

 	spin_lock_irqsave(&i2400m->tx_lock, flags);
 	i2400m->tx_pl_num = 0;
 	i2400m->tx_pl_max = 0;
 	i2400m->tx_pl_min = UINT_MAX;
 	i2400m->tx_num = 0;
 	i2400m->tx_size_acc = 0;
 	i2400m->tx_size_min = UINT_MAX;
 	i2400m->tx_size_max = 0;
 	spin_unlock_irqrestore(&i2400m->tx_lock, flags);
 	return count;
 }

 static
 const struct file_operations i2400m_tx_stats_fops = {
 	.owner =	THIS_MODULE,
 	.open =		i2400m_stats_open,
 	.read =		i2400m_tx_stats_read,
 	.write =	i2400m_tx_stats_write,
 };


 /* Write 1 to ask the device to go into suspend */
 static
 int debugfs_i2400m_suspend_set(void *data, u64 val)
 {
 	int result;
 	struct i2400m *i2400m = data;
 	result = i2400m_cmd_enter_powersave(i2400m);
 	if (result >= 0)
 		result = 0;
 	return result;
 }
 DEFINE_SIMPLE_ATTRIBUTE(fops_i2400m_suspend,
 			NULL, debugfs_i2400m_suspend_set,
 			"%llu\n");

 static
 struct dentry *debugfs_create_i2400m_suspend(
 	const char *name, struct dentry *parent, struct i2400m *i2400m)
 {
 	return debugfs_create_file(name, 0200, parent, i2400m,
 				   &fops_i2400m_suspend);
 }


 /*
  * Reset the device
  *
  * Write 0 to ask the device to soft reset, 1 to cold reset, 2 to bus
  * reset (as defined by enum i2400m_reset_type).
  */
 static
 int debugfs_i2400m_reset_set(void *data, u64 val)
 {
 	int result;
 	struct i2400m *i2400m = data;
 	enum i2400m_reset_type rt = val;
 	switch(rt) {
 	case I2400M_RT_WARM:
 	case I2400M_RT_COLD:
 	case I2400M_RT_BUS:
 		result = i2400m->bus_reset(i2400m, rt);
 		if (result >= 0)
 			result = 0;
 	default:
 		result = -EINVAL;
 	}
 	return result;
 }
 DEFINE_SIMPLE_ATTRIBUTE(fops_i2400m_reset,
 			NULL, debugfs_i2400m_reset_set,
 			"%llu\n");

 static
 struct dentry *debugfs_create_i2400m_reset(
 	const char *name, struct dentry *parent, struct i2400m *i2400m)
 {
 	return debugfs_create_file(name, 0200, parent, i2400m,
 				   &fops_i2400m_reset);
 }

 /*
  * Debug levels control; see debug.h
  */
 struct d_level D_LEVEL[] = {
 	D_SUBMODULE_DEFINE(control),
 	D_SUBMODULE_DEFINE(driver),
 	D_SUBMODULE_DEFINE(debugfs),
 	D_SUBMODULE_DEFINE(fw),
 	D_SUBMODULE_DEFINE(netdev),
 	D_SUBMODULE_DEFINE(rfkill),
 	D_SUBMODULE_DEFINE(rx),
 	D_SUBMODULE_DEFINE(tx),
 };
 size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL);

 #define __debugfs_register(prefix, name, parent)			\
 do {									\
 	result = d_level_register_debugfs(prefix, name, parent);	\
 	if (result < 0)							\
 		goto error;						\
 } while (0)


 int i2400m_debugfs_add(struct i2400m *i2400m)
 {
 	int result;
 	struct device *dev = i2400m_dev(i2400m);
 	struct dentry *dentry = i2400m->wimax_dev.debugfs_dentry;
 	struct dentry *fd;

 	dentry = debugfs_create_dir("i2400m", dentry);
 	result = PTR_ERR(dentry);
 	if (IS_ERR(dentry)) {
 		if (result == -ENODEV)
 			result = 0;	/* No debugfs support */
 		goto error;
 	}
 	i2400m->debugfs_dentry = dentry;
 	__debugfs_register("dl_", control, dentry);
 	__debugfs_register("dl_", driver, dentry);
 	__debugfs_register("dl_", debugfs, dentry);
 	__debugfs_register("dl_", fw, dentry);
 	__debugfs_register("dl_", netdev, dentry);
 	__debugfs_register("dl_", rfkill, dentry);
 	__debugfs_register("dl_", rx, dentry);
 	__debugfs_register("dl_", tx, dentry);

 	fd = debugfs_create_size_t("tx_in", 0400, dentry,
 				   &i2400m->tx_in);
 	result = PTR_ERR(fd);
 	if (IS_ERR(fd) && result != -ENODEV) {
 		dev_err(dev, "Can't create debugfs entry "
 			"tx_in: %d\n", result);
 		goto error;
 	}

 	fd = debugfs_create_size_t("tx_out", 0400, dentry,
 				   &i2400m->tx_out);
 	result = PTR_ERR(fd);
 	if (IS_ERR(fd) && result != -ENODEV) {
 		dev_err(dev, "Can't create debugfs entry "
 			"tx_out: %d\n", result);
 		goto error;
 	}

 	fd = debugfs_create_u32("state", 0600, dentry,
 				&i2400m->state);
 	result = PTR_ERR(fd);
 	if (IS_ERR(fd) && result != -ENODEV) {
 		dev_err(dev, "Can't create debugfs entry "
 			"state: %d\n", result);
 		goto error;
 	}

 	/*
 	 * Trace received messages from user space
 	 *
 	 * In order to tap the bidirectional message stream in the
 	 * 'msg' pipe, user space can read from the 'msg' pipe;
 	 * however, due to limitations in libnl, we can't know what
 	 * the different applications are sending down to the kernel.
 	 *
 	 * So we have this hack where the driver will echo any message
 	 * received on the msg pipe from user space [through a call to
 	 * wimax_dev->op_msg_from_user() into
 	 * i2400m_op_msg_from_user()] into the 'trace' pipe that this
 	 * driver creates.
 	 *
 	 * So then, reading from both the 'trace' and 'msg' pipes in
 	 * user space will provide a full dump of the traffic.
 	 *
 	 * Write 1 to activate, 0 to clear.
 	 *
 	 * It is not really very atomic, but it is also not too
 	 * critical.
 	 */
 	fd = debugfs_create_u8("trace_msg_from_user", 0600, dentry,
 			       &i2400m->trace_msg_from_user);
 	result = PTR_ERR(fd);
 	if (IS_ERR(fd) && result != -ENODEV) {
 		dev_err(dev, "Can't create debugfs entry "
 			"trace_msg_from_user: %d\n", result);
 		goto error;
 	}

 	fd = debugfs_create_netdev_queue_stopped("netdev_queue_stopped",
 						 dentry, i2400m);
 	result = PTR_ERR(fd);
 	if (IS_ERR(fd) && result != -ENODEV) {
 		dev_err(dev, "Can't create debugfs entry "
 			"netdev_queue_stopped: %d\n", result);
 		goto error;
 	}

 	fd = debugfs_create_file("rx_stats", 0600, dentry, i2400m,
 				 &i2400m_rx_stats_fops);
 	result = PTR_ERR(fd);
 	if (IS_ERR(fd) && result != -ENODEV) {
 		dev_err(dev, "Can't create debugfs entry "
 			"rx_stats: %d\n", result);
 		goto error;
 	}

 	fd = debugfs_create_file("tx_stats", 0600, dentry, i2400m,
 				 &i2400m_tx_stats_fops);
 	result = PTR_ERR(fd);
 	if (IS_ERR(fd) && result != -ENODEV) {
 		dev_err(dev, "Can't create debugfs entry "
 			"tx_stats: %d\n", result);
 		goto error;
 	}

 	fd = debugfs_create_i2400m_suspend("suspend", dentry, i2400m);
 	result = PTR_ERR(fd);
 	if (IS_ERR(fd) && result != -ENODEV) {
 		dev_err(dev, "Can't create debugfs entry suspend: %d\n",
 			result);
 		goto error;
 	}

 	fd = debugfs_create_i2400m_reset("reset", dentry, i2400m);
 	result = PTR_ERR(fd);
 	if (IS_ERR(fd) && result != -ENODEV) {
 		dev_err(dev, "Can't create debugfs entry reset: %d\n", result);
 		goto error;
 	}

 	result = 0;
 error:
 	return result;
 }

 void i2400m_debugfs_rm(struct i2400m *i2400m)
 {
 	debugfs_remove_recursive(i2400m->debugfs_dentry);
 }
	/*
	* Intel Wireless WiMAX Connection 2400m
	* Debugfs interfaces to manipulate driver and device information
	*
	*
	* Copyright (C) 2007 Intel Corporation <linux-wimax@intel.com>
	* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License version
	* 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	* 02110-1301, USA.
	*/

	#include <linux/debugfs.h>
	#include <linux/netdevice.h>
	#include <linux/etherdevice.h>
	#include <linux/spinlock.h>
	#include <linux/device.h>
	#include "i2400m.h"


	#define D_SUBMODULE debugfs
	#include "debug-levels.h"

	static
	int debugfs_netdev_queue_stopped_get(void data, u64 val)
	{
	struct i2400m *i2400m = data;
	*val = netif_queue_stopped(i2400m->wimax_dev.net_dev);
	return 0;
	}
	DEFINE_SIMPLE_ATTRIBUTE(fops_netdev_queue_stopped,
	debugfs_netdev_queue_stopped_get,
	NULL, "%llu\n");


	static
	struct dentry *debugfs_create_netdev_queue_stopped(
	const char name, struct dentry parent, struct i2400m *i2400m)
	{
	return debugfs_create_file(name, 0400, parent, i2400m,
	&fops_netdev_queue_stopped);
	}


	/*
	* inode->i_private has the @data argument to debugfs_create_file()
	*/
	static
	int i2400m_stats_open(struct inode inode, struct file filp)
	{
	filp->private_data = inode->i_private;
	return 0;
	}

	/*
	* We don't allow partial reads of this file, as then the reader would
	* get weirdly confused data as it is updated.
	*
	* So or you read it all or nothing; if you try to read with an offset
	* != 0, we consider you are done reading.
	*/
	static
	ssize_t i2400m_rx_stats_read(struct file filp, char __user buffer,
	size_t count, loff_t *ppos)
	{
	struct i2400m *i2400m = filp->private_data;
	char buf[128];
	unsigned long flags;

	if (*ppos != 0)
	return 0;
	if (count < sizeof(buf))
	return -ENOSPC;
	spin_lock_irqsave(&i2400m->rx_lock, flags);
	snprintf(buf, sizeof(buf), "%u %u %u %u %u %u %u\n",
	i2400m->rx_pl_num, i2400m->rx_pl_min,
	i2400m->rx_pl_max, i2400m->rx_num,
	i2400m->rx_size_acc,
	i2400m->rx_size_min, i2400m->rx_size_max);
	spin_unlock_irqrestore(&i2400m->rx_lock, flags);
	return simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
	}


	/* Any write clears the stats */
	static
	ssize_t i2400m_rx_stats_write(struct file filp, const char __user buffer,
	size_t count, loff_t *ppos)
	{
	struct i2400m *i2400m = filp->private_data;
	unsigned long flags;

	spin_lock_irqsave(&i2400m->rx_lock, flags);
	i2400m->rx_pl_num = 0;
	i2400m->rx_pl_max = 0;
	i2400m->rx_pl_min = UINT_MAX;
	i2400m->rx_num = 0;
	i2400m->rx_size_acc = 0;
	i2400m->rx_size_min = UINT_MAX;
	i2400m->rx_size_max = 0;
	spin_unlock_irqrestore(&i2400m->rx_lock, flags);
	return count;
	}

	static
	const struct file_operations i2400m_rx_stats_fops = {
	.owner = THIS_MODULE,
	.open = i2400m_stats_open,
	.read = i2400m_rx_stats_read,
	.write = i2400m_rx_stats_write,
	};


	/* See i2400m_rx_stats_read() */
	static
	ssize_t i2400m_tx_stats_read(struct file filp, char __user buffer,
	size_t count, loff_t *ppos)
	{
	struct i2400m *i2400m = filp->private_data;
	char buf[128];
	unsigned long flags;

	if (*ppos != 0)
	return 0;
	if (count < sizeof(buf))
	return -ENOSPC;
	spin_lock_irqsave(&i2400m->tx_lock, flags);
	snprintf(buf, sizeof(buf), "%u %u %u %u %u %u %u\n",
	i2400m->tx_pl_num, i2400m->tx_pl_min,
	i2400m->tx_pl_max, i2400m->tx_num,
	i2400m->tx_size_acc,
	i2400m->tx_size_min, i2400m->tx_size_max);
	spin_unlock_irqrestore(&i2400m->tx_lock, flags);
	return simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
	}

	/* Any write clears the stats */
	static
	ssize_t i2400m_tx_stats_write(struct file filp, const char __user buffer,
	size_t count, loff_t *ppos)
	{
	struct i2400m *i2400m = filp->private_data;
	unsigned long flags;

	spin_lock_irqsave(&i2400m->tx_lock, flags);
	i2400m->tx_pl_num = 0;
	i2400m->tx_pl_max = 0;
	i2400m->tx_pl_min = UINT_MAX;
	i2400m->tx_num = 0;
	i2400m->tx_size_acc = 0;
	i2400m->tx_size_min = UINT_MAX;
	i2400m->tx_size_max = 0;
	spin_unlock_irqrestore(&i2400m->tx_lock, flags);
	return count;
	}

	static
	const struct file_operations i2400m_tx_stats_fops = {
	.owner = THIS_MODULE,
	.open = i2400m_stats_open,
	.read = i2400m_tx_stats_read,
	.write = i2400m_tx_stats_write,
	};


	/* Write 1 to ask the device to go into suspend */
	static
	int debugfs_i2400m_suspend_set(void *data, u64 val)
	{
	int result;
	struct i2400m *i2400m = data;
	result = i2400m_cmd_enter_powersave(i2400m);
	if (result >= 0)
	result = 0;
	return result;
	}
	DEFINE_SIMPLE_ATTRIBUTE(fops_i2400m_suspend,
	NULL, debugfs_i2400m_suspend_set,
	"%llu\n");

	static
	struct dentry *debugfs_create_i2400m_suspend(
	const char name, struct dentry parent, struct i2400m *i2400m)
	{
	return debugfs_create_file(name, 0200, parent, i2400m,
	&fops_i2400m_suspend);
	}


	/*
	* Reset the device
	*
	* Write 0 to ask the device to soft reset, 1 to cold reset, 2 to bus
	* reset (as defined by enum i2400m_reset_type).
	*/
	static
	int debugfs_i2400m_reset_set(void *data, u64 val)
	{
	int result;
	struct i2400m *i2400m = data;
	enum i2400m_reset_type rt = val;
	switch(rt) {
	case I2400M_RT_WARM:
	case I2400M_RT_COLD:
	case I2400M_RT_BUS:
	result = i2400m->bus_reset(i2400m, rt);
	if (result >= 0)
	result = 0;
	default:
	result = -EINVAL;
	}
	return result;
	}
	DEFINE_SIMPLE_ATTRIBUTE(fops_i2400m_reset,
	NULL, debugfs_i2400m_reset_set,
	"%llu\n");

	static
	struct dentry *debugfs_create_i2400m_reset(
	const char name, struct dentry parent, struct i2400m *i2400m)
	{
	return debugfs_create_file(name, 0200, parent, i2400m,
	&fops_i2400m_reset);
	}

	/*
	* Debug levels control; see debug.h
	*/
	struct d_level D_LEVEL[] = {
	D_SUBMODULE_DEFINE(control),
	D_SUBMODULE_DEFINE(driver),
	D_SUBMODULE_DEFINE(debugfs),
	D_SUBMODULE_DEFINE(fw),
	D_SUBMODULE_DEFINE(netdev),
	D_SUBMODULE_DEFINE(rfkill),
	D_SUBMODULE_DEFINE(rx),
	D_SUBMODULE_DEFINE(tx),
	};
	size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL);

	#define __debugfs_register(prefix, name, parent) \
	do { \
	result = d_level_register_debugfs(prefix, name, parent); \
	if (result < 0) \
	goto error; \
	} while (0)


	int i2400m_debugfs_add(struct i2400m *i2400m)
	{
	int result;
	struct device *dev = i2400m_dev(i2400m);
	struct dentry *dentry = i2400m->wimax_dev.debugfs_dentry;
	struct dentry *fd;

	dentry = debugfs_create_dir("i2400m", dentry);
	result = PTR_ERR(dentry);
	if (IS_ERR(dentry)) {
	if (result == -ENODEV)
	result = 0; /* No debugfs support */
	goto error;
	}
	i2400m->debugfs_dentry = dentry;
	__debugfs_register("dl_", control, dentry);
	__debugfs_register("dl_", driver, dentry);
	__debugfs_register("dl_", debugfs, dentry);
	__debugfs_register("dl_", fw, dentry);
	__debugfs_register("dl_", netdev, dentry);
	__debugfs_register("dl_", rfkill, dentry);
	__debugfs_register("dl_", rx, dentry);
	__debugfs_register("dl_", tx, dentry);

	fd = debugfs_create_size_t("tx_in", 0400, dentry,
	&i2400m->tx_in);
	result = PTR_ERR(fd);
	if (IS_ERR(fd) && result != -ENODEV) {
	dev_err(dev, "Can't create debugfs entry "
	"tx_in: %d\n", result);
	goto error;
	}

	fd = debugfs_create_size_t("tx_out", 0400, dentry,
	&i2400m->tx_out);
	result = PTR_ERR(fd);
	if (IS_ERR(fd) && result != -ENODEV) {
	dev_err(dev, "Can't create debugfs entry "
	"tx_out: %d\n", result);
	goto error;
	}

	fd = debugfs_create_u32("state", 0600, dentry,
	&i2400m->state);
	result = PTR_ERR(fd);
	if (IS_ERR(fd) && result != -ENODEV) {
	dev_err(dev, "Can't create debugfs entry "
	"state: %d\n", result);
	goto error;
	}

	/*
	* Trace received messages from user space
	*
	* In order to tap the bidirectional message stream in the
	* 'msg' pipe, user space can read from the 'msg' pipe;
	* however, due to limitations in libnl, we can't know what
	* the different applications are sending down to the kernel.
	*
	* So we have this hack where the driver will echo any message
	* received on the msg pipe from user space [through a call to
	* wimax_dev->op_msg_from_user() into
	* i2400m_op_msg_from_user()] into the 'trace' pipe that this
	* driver creates.
	*
	* So then, reading from both the 'trace' and 'msg' pipes in
	* user space will provide a full dump of the traffic.
	*
	* Write 1 to activate, 0 to clear.
	*
	* It is not really very atomic, but it is also not too
	* critical.
	*/
	fd = debugfs_create_u8("trace_msg_from_user", 0600, dentry,
	&i2400m->trace_msg_from_user);
	result = PTR_ERR(fd);
	if (IS_ERR(fd) && result != -ENODEV) {
	dev_err(dev, "Can't create debugfs entry "
	"trace_msg_from_user: %d\n", result);
	goto error;
	}

	fd = debugfs_create_netdev_queue_stopped("netdev_queue_stopped",
	dentry, i2400m);
	result = PTR_ERR(fd);
	if (IS_ERR(fd) && result != -ENODEV) {
	dev_err(dev, "Can't create debugfs entry "
	"netdev_queue_stopped: %d\n", result);
	goto error;
	}

	fd = debugfs_create_file("rx_stats", 0600, dentry, i2400m,
	&i2400m_rx_stats_fops);
	result = PTR_ERR(fd);
	if (IS_ERR(fd) && result != -ENODEV) {
	dev_err(dev, "Can't create debugfs entry "
	"rx_stats: %d\n", result);
	goto error;
	}

	fd = debugfs_create_file("tx_stats", 0600, dentry, i2400m,
	&i2400m_tx_stats_fops);
	result = PTR_ERR(fd);
	if (IS_ERR(fd) && result != -ENODEV) {
	dev_err(dev, "Can't create debugfs entry "
	"tx_stats: %d\n", result);
	goto error;
	}

	fd = debugfs_create_i2400m_suspend("suspend", dentry, i2400m);
	result = PTR_ERR(fd);
	if (IS_ERR(fd) && result != -ENODEV) {
	dev_err(dev, "Can't create debugfs entry suspend: %d\n",
	result);
	goto error;
	}

	fd = debugfs_create_i2400m_reset("reset", dentry, i2400m);
	result = PTR_ERR(fd);
	if (IS_ERR(fd) && result != -ENODEV) {
	dev_err(dev, "Can't create debugfs entry reset: %d\n", result);
	goto error;
	}

	result = 0;
	error:
	return result;
	}

	void i2400m_debugfs_rm(struct i2400m *i2400m)
	{
	debugfs_remove_recursive(i2400m->debugfs_dentry);
	}