[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / wireless / b43legacy / debugfs.c

/*

  Broadcom B43legacy wireless driver

  debugfs driver debugging code

  Copyright (c) 2005-2007 Michael Buesch <m@bues.ch>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  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; see the file COPYING.  If not, write to
  the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
  Boston, MA 02110-1301, USA.

*/

#include <linux/fs.h>
#include <linux/debugfs.h>
#include <linux/slab.h>
#include <linux/netdevice.h>
#include <linux/pci.h>
#include <linux/mutex.h>

#include "b43legacy.h"
#include "main.h"
#include "debugfs.h"
#include "dma.h"
#include "pio.h"
#include "xmit.h"


/* The root directory. */
static struct dentry *rootdir;

struct b43legacy_debugfs_fops {
	ssize_t (*read)(struct b43legacy_wldev *dev, char *buf, size_t bufsize);
	int (*write)(struct b43legacy_wldev *dev, const char *buf, size_t count);
	struct file_operations fops;
	/* Offset of struct b43legacy_dfs_file in struct b43legacy_dfsentry */
	size_t file_struct_offset;
	/* Take wl->irq_lock before calling read/write? */
	bool take_irqlock;
};

static inline
struct b43legacy_dfs_file * fops_to_dfs_file(struct b43legacy_wldev *dev,
				       const struct b43legacy_debugfs_fops *dfops)
{
	void *p;

	p = dev->dfsentry;
	p += dfops->file_struct_offset;

	return p;
}


#define fappend(fmt, x...)	\
	do {							\
		if (bufsize - count)				\
			count += snprintf(buf + count,		\
					  bufsize - count,	\
					  fmt , ##x);		\
		else						\
			printk(KERN_ERR "b43legacy: fappend overflow\n"); \
	} while (0)


/* wl->irq_lock is locked */
static ssize_t tsf_read_file(struct b43legacy_wldev *dev, char *buf, size_t bufsize)
{
	ssize_t count = 0;
	u64 tsf;

	b43legacy_tsf_read(dev, &tsf);
	fappend("0x%08x%08x\n",
		(unsigned int)((tsf & 0xFFFFFFFF00000000ULL) >> 32),
		(unsigned int)(tsf & 0xFFFFFFFFULL));

	return count;
}

/* wl->irq_lock is locked */
static int tsf_write_file(struct b43legacy_wldev *dev, const char *buf, size_t count)
{
	u64 tsf;

	if (sscanf(buf, "%llu", (unsigned long long *)(&tsf)) != 1)
		return -EINVAL;
	b43legacy_tsf_write(dev, tsf);

	return 0;
}

/* wl->irq_lock is locked */
static ssize_t ucode_regs_read_file(struct b43legacy_wldev *dev, char *buf, size_t bufsize)
{
	ssize_t count = 0;
	int i;

	for (i = 0; i < 64; i++) {
		fappend("r%d = 0x%04x\n", i,
			b43legacy_shm_read16(dev, B43legacy_SHM_WIRELESS, i));
	}

	return count;
}

/* wl->irq_lock is locked */
static ssize_t shm_read_file(struct b43legacy_wldev *dev, char *buf, size_t bufsize)
{
	ssize_t count = 0;
	int i;
	u16 tmp;
	__le16 *le16buf = (__le16 *)buf;

	for (i = 0; i < 0x1000; i++) {
		if (bufsize < sizeof(tmp))
			break;
		tmp = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED, 2 * i);
		le16buf[i] = cpu_to_le16(tmp);
		count += sizeof(tmp);
		bufsize -= sizeof(tmp);
	}

	return count;
}

static ssize_t txstat_read_file(struct b43legacy_wldev *dev, char *buf, size_t bufsize)
{
	struct b43legacy_txstatus_log *log = &dev->dfsentry->txstatlog;
	ssize_t count = 0;
	unsigned long flags;
	int i, idx;
	struct b43legacy_txstatus *stat;

	spin_lock_irqsave(&log->lock, flags);
	if (log->end < 0) {
		fappend("Nothing transmitted, yet\n");
		goto out_unlock;
	}
	fappend("b43legacy TX status reports:\n\n"
		"index | cookie | seq | phy_stat | frame_count | "
		"rts_count | supp_reason | pm_indicated | "
		"intermediate | for_ampdu | acked\n" "---\n");
	i = log->end + 1;
	idx = 0;
	while (1) {
		if (i == B43legacy_NR_LOGGED_TXSTATUS)
			i = 0;
		stat = &(log->log[i]);
		if (stat->cookie) {
			fappend("%03d | "
				"0x%04X | 0x%04X | 0x%02X | "
				"0x%X | 0x%X | "
				"%u | %u | "
				"%u | %u | %u\n",
				idx,
				stat->cookie, stat->seq, stat->phy_stat,
				stat->frame_count, stat->rts_count,
				stat->supp_reason, stat->pm_indicated,
				stat->intermediate, stat->for_ampdu,
				stat->acked);
			idx++;
		}
		if (i == log->end)
			break;
		i++;
	}
out_unlock:
	spin_unlock_irqrestore(&log->lock, flags);

	return count;
}

/* wl->irq_lock is locked */
static int restart_write_file(struct b43legacy_wldev *dev, const char *buf, size_t count)
{
	int err = 0;

	if (count > 0 && buf[0] == '1') {
		b43legacy_controller_restart(dev, "manually restarted");
	} else
		err = -EINVAL;

	return err;
}

#undef fappend

static int b43legacy_debugfs_open(struct inode *inode, struct file *file)
{
	file->private_data = inode->i_private;
	return 0;
}

static ssize_t b43legacy_debugfs_read(struct file *file, char __user *userbuf,
				size_t count, loff_t *ppos)
{
	struct b43legacy_wldev *dev;
	struct b43legacy_debugfs_fops *dfops;
	struct b43legacy_dfs_file *dfile;
	ssize_t uninitialized_var(ret);
	char *buf;
	const size_t bufsize = 1024 * 16; /* 16 KiB buffer */
	const size_t buforder = get_order(bufsize);
	int err = 0;

	if (!count)
		return 0;
	dev = file->private_data;
	if (!dev)
		return -ENODEV;

	mutex_lock(&dev->wl->mutex);
	if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED) {
		err = -ENODEV;
		goto out_unlock;
	}

	dfops = container_of(file->f_op, struct b43legacy_debugfs_fops, fops);
	if (!dfops->read) {
		err = -ENOSYS;
		goto out_unlock;
	}
	dfile = fops_to_dfs_file(dev, dfops);

	if (!dfile->buffer) {
		buf = (char *)__get_free_pages(GFP_KERNEL, buforder);
		if (!buf) {
			err = -ENOMEM;
			goto out_unlock;
		}
		memset(buf, 0, bufsize);
		if (dfops->take_irqlock) {
			spin_lock_irq(&dev->wl->irq_lock);
			ret = dfops->read(dev, buf, bufsize);
			spin_unlock_irq(&dev->wl->irq_lock);
		} else
			ret = dfops->read(dev, buf, bufsize);
		if (ret <= 0) {
			free_pages((unsigned long)buf, buforder);
			err = ret;
			goto out_unlock;
		}
		dfile->data_len = ret;
		dfile->buffer = buf;
	}

	ret = simple_read_from_buffer(userbuf, count, ppos,
				      dfile->buffer,
				      dfile->data_len);
	if (*ppos >= dfile->data_len) {
		free_pages((unsigned long)dfile->buffer, buforder);
		dfile->buffer = NULL;
		dfile->data_len = 0;
	}
out_unlock:
	mutex_unlock(&dev->wl->mutex);

	return err ? err : ret;
}

static ssize_t b43legacy_debugfs_write(struct file *file,
				 const char __user *userbuf,
				 size_t count, loff_t *ppos)
{
	struct b43legacy_wldev *dev;
	struct b43legacy_debugfs_fops *dfops;
	char *buf;
	int err = 0;

	if (!count)
		return 0;
	if (count > PAGE_SIZE)
		return -E2BIG;
	dev = file->private_data;
	if (!dev)
		return -ENODEV;

	mutex_lock(&dev->wl->mutex);
	if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED) {
		err = -ENODEV;
		goto out_unlock;
	}

	dfops = container_of(file->f_op, struct b43legacy_debugfs_fops, fops);
	if (!dfops->write) {
		err = -ENOSYS;
		goto out_unlock;
	}

	buf = (char *)get_zeroed_page(GFP_KERNEL);
	if (!buf) {
		err = -ENOMEM;
		goto out_unlock;
	}
	if (copy_from_user(buf, userbuf, count)) {
		err = -EFAULT;
		goto out_freepage;
	}
	if (dfops->take_irqlock) {
		spin_lock_irq(&dev->wl->irq_lock);
		err = dfops->write(dev, buf, count);
		spin_unlock_irq(&dev->wl->irq_lock);
	} else
		err = dfops->write(dev, buf, count);
	if (err)
		goto out_freepage;

out_freepage:
	free_page((unsigned long)buf);
out_unlock:
	mutex_unlock(&dev->wl->mutex);

	return err ? err : count;
}


#define B43legacy_DEBUGFS_FOPS(name, _read, _write, _take_irqlock)	\
	static struct b43legacy_debugfs_fops fops_##name = {		\
		.read	= _read,				\
		.write	= _write,				\
		.fops	= {					\
			.open	= b43legacy_debugfs_open,		\
			.read	= b43legacy_debugfs_read,		\
			.write	= b43legacy_debugfs_write,		\
			.llseek = generic_file_llseek,			\
		},						\
		.file_struct_offset = offsetof(struct b43legacy_dfsentry, \
					       file_##name),	\
		.take_irqlock	= _take_irqlock,		\
	}

B43legacy_DEBUGFS_FOPS(tsf, tsf_read_file, tsf_write_file, 1);
B43legacy_DEBUGFS_FOPS(ucode_regs, ucode_regs_read_file, NULL, 1);
B43legacy_DEBUGFS_FOPS(shm, shm_read_file, NULL, 1);
B43legacy_DEBUGFS_FOPS(txstat, txstat_read_file, NULL, 0);
B43legacy_DEBUGFS_FOPS(restart, NULL, restart_write_file, 1);


int b43legacy_debug(struct b43legacy_wldev *dev, enum b43legacy_dyndbg feature)
{
	return !!(dev->dfsentry && dev->dfsentry->dyn_debug[feature]);
}

static void b43legacy_remove_dynamic_debug(struct b43legacy_wldev *dev)
{
	struct b43legacy_dfsentry *e = dev->dfsentry;
	int i;

	for (i = 0; i < __B43legacy_NR_DYNDBG; i++)
		debugfs_remove(e->dyn_debug_dentries[i]);
}

static void b43legacy_add_dynamic_debug(struct b43legacy_wldev *dev)
{
	struct b43legacy_dfsentry *e = dev->dfsentry;
	struct dentry *d;

#define add_dyn_dbg(name, id, initstate) do {		\
	e->dyn_debug[id] = (initstate);			\
	d = debugfs_create_bool(name, 0600, e->subdir,	\
				&(e->dyn_debug[id]));	\
	if (!IS_ERR(d))					\
		e->dyn_debug_dentries[id] = d;		\
				} while (0)

	add_dyn_dbg("debug_xmitpower", B43legacy_DBG_XMITPOWER, 0);
	add_dyn_dbg("debug_dmaoverflow", B43legacy_DBG_DMAOVERFLOW, 0);
	add_dyn_dbg("debug_dmaverbose", B43legacy_DBG_DMAVERBOSE, 0);
	add_dyn_dbg("debug_pwork_fast", B43legacy_DBG_PWORK_FAST, 0);
	add_dyn_dbg("debug_pwork_stop", B43legacy_DBG_PWORK_STOP, 0);

#undef add_dyn_dbg
}

void b43legacy_debugfs_add_device(struct b43legacy_wldev *dev)
{
	struct b43legacy_dfsentry *e;
	struct b43legacy_txstatus_log *log;
	char devdir[16];

	B43legacy_WARN_ON(!dev);
	e = kzalloc(sizeof(*e), GFP_KERNEL);
	if (!e) {
		b43legacyerr(dev->wl, "debugfs: add device OOM\n");
		return;
	}
	e->dev = dev;
	log = &e->txstatlog;
	log->log = kcalloc(B43legacy_NR_LOGGED_TXSTATUS,
			   sizeof(struct b43legacy_txstatus), GFP_KERNEL);
	if (!log->log) {
		b43legacyerr(dev->wl, "debugfs: add device txstatus OOM\n");
		kfree(e);
		return;
	}
	log->end = -1;
	spin_lock_init(&log->lock);

	dev->dfsentry = e;

	snprintf(devdir, sizeof(devdir), "%s", wiphy_name(dev->wl->hw->wiphy));
	e->subdir = debugfs_create_dir(devdir, rootdir);
	if (!e->subdir || IS_ERR(e->subdir)) {
		if (e->subdir == ERR_PTR(-ENODEV)) {
			b43legacydbg(dev->wl, "DebugFS (CONFIG_DEBUG_FS) not "
			       "enabled in kernel config\n");
		} else {
			b43legacyerr(dev->wl, "debugfs: cannot create %s directory\n",
			       devdir);
		}
		dev->dfsentry = NULL;
		kfree(log->log);
		kfree(e);
		return;
	}

#define ADD_FILE(name, mode)	\
	do {							\
		struct dentry *d;				\
		d = debugfs_create_file(__stringify(name),	\
					mode, e->subdir, dev,	\
					&fops_##name.fops);	\
		e->file_##name.dentry = NULL;			\
		if (!IS_ERR(d))					\
			e->file_##name.dentry = d;		\
	} while (0)


	ADD_FILE(tsf, 0600);
	ADD_FILE(ucode_regs, 0400);
	ADD_FILE(shm, 0400);
	ADD_FILE(txstat, 0400);
	ADD_FILE(restart, 0200);

#undef ADD_FILE

	b43legacy_add_dynamic_debug(dev);
}

void b43legacy_debugfs_remove_device(struct b43legacy_wldev *dev)
{
	struct b43legacy_dfsentry *e;

	if (!dev)
		return;
	e = dev->dfsentry;
	if (!e)
		return;
	b43legacy_remove_dynamic_debug(dev);

	debugfs_remove(e->file_tsf.dentry);
	debugfs_remove(e->file_ucode_regs.dentry);
	debugfs_remove(e->file_shm.dentry);
	debugfs_remove(e->file_txstat.dentry);
	debugfs_remove(e->file_restart.dentry);

	debugfs_remove(e->subdir);
	kfree(e->txstatlog.log);
	kfree(e);
}

void b43legacy_debugfs_log_txstat(struct b43legacy_wldev *dev,
			    const struct b43legacy_txstatus *status)
{
	struct b43legacy_dfsentry *e = dev->dfsentry;
	struct b43legacy_txstatus_log *log;
	struct b43legacy_txstatus *cur;
	int i;

	if (!e)
		return;
	log = &e->txstatlog;
	B43legacy_WARN_ON(!irqs_disabled());
	spin_lock(&log->lock);
	i = log->end + 1;
	if (i == B43legacy_NR_LOGGED_TXSTATUS)
		i = 0;
	log->end = i;
	cur = &(log->log[i]);
	memcpy(cur, status, sizeof(*cur));
	spin_unlock(&log->lock);
}

void b43legacy_debugfs_init(void)
{
	rootdir = debugfs_create_dir(KBUILD_MODNAME, NULL);
	if (IS_ERR(rootdir))
		rootdir = NULL;
}

void b43legacy_debugfs_exit(void)
{
	debugfs_remove(rootdir);
}
Commit	Line	Data
75388acd LF	1	/*
	2
	3	Broadcom B43legacy wireless driver
	4
	5	debugfs driver debugging code
	6
eb032b98	7	Copyright (c) 2005-2007 Michael Buesch <m@bues.ch>
75388acd LF	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; see the file COPYING. If not, write to
	21	the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
	22	Boston, MA 02110-1301, USA.
	23
	24	*/
	25
	26	#include <linux/fs.h>
	27	#include <linux/debugfs.h>
	28	#include <linux/slab.h>
	29	#include <linux/netdevice.h>
	30	#include <linux/pci.h>
	31	#include <linux/mutex.h>
	32
	33	#include "b43legacy.h"
	34	#include "main.h"
	35	#include "debugfs.h"
	36	#include "dma.h"
	37	#include "pio.h"
	38	#include "xmit.h"
	39
	40
	41	/* The root directory. */
	42	static struct dentry *rootdir;
	43
	44	struct b43legacy_debugfs_fops {
	45	ssize_t (read)(struct b43legacy_wldev dev, char *buf, size_t bufsize);
	46	int (write)(struct b43legacy_wldev dev, const char *buf, size_t count);
	47	struct file_operations fops;
	48	/* Offset of struct b43legacy_dfs_file in struct b43legacy_dfsentry */
	49	size_t file_struct_offset;
	50	/* Take wl->irq_lock before calling read/write? */
	51	bool take_irqlock;
	52	};
	53
	54	static inline
	55	struct b43legacy_dfs_file * fops_to_dfs_file(struct b43legacy_wldev *dev,
	56	const struct b43legacy_debugfs_fops *dfops)
	57	{
	58	void *p;
	59
	60	p = dev->dfsentry;
	61	p += dfops->file_struct_offset;
	62
	63	return p;
	64	}
	65
	66
	67	#define fappend(fmt, x...) \
	68	do { \
	69	if (bufsize - count) \
	70	count += snprintf(buf + count, \
	71	bufsize - count, \
72	fmt , ##x); \
73	else \
74	printk(KERN_ERR "b43legacy: fappend overflow\n"); \
75	} while (0)
76
77
78	/* wl->irq_lock is locked */
79	static ssize_t tsf_read_file(struct b43legacy_wldev dev, char buf, size_t bufsize)
80	{
81	ssize_t count = 0;
82	u64 tsf;
83
84	b43legacy_tsf_read(dev, &tsf);
85	fappend("0x%08x%08x\n",
86	(unsigned int)((tsf & 0xFFFFFFFF00000000ULL) >> 32),
87	(unsigned int)(tsf & 0xFFFFFFFFULL));
88
89	return count;
90	}
91
92	/* wl->irq_lock is locked */
93	static int tsf_write_file(struct b43legacy_wldev dev, const char buf, size_t count)
94	{
95	u64 tsf;
96
97	if (sscanf(buf, "%llu", (unsigned long long *)(&tsf)) != 1)
98	return -EINVAL;
99	b43legacy_tsf_write(dev, tsf);
100
101	return 0;
102	}
103
104	/* wl->irq_lock is locked */
105	static ssize_t ucode_regs_read_file(struct b43legacy_wldev dev, char buf, size_t bufsize)
106	{
107	ssize_t count = 0;
108	int i;
109
110	for (i = 0; i < 64; i++) {
111	fappend("r%d = 0x%04x\n", i,
112	b43legacy_shm_read16(dev, B43legacy_SHM_WIRELESS, i));
113	}
114
115	return count;
116	}
117
118	/* wl->irq_lock is locked */
119	static ssize_t shm_read_file(struct b43legacy_wldev dev, char buf, size_t bufsize)
120	{
121	ssize_t count = 0;
122	int i;
123	u16 tmp;
124	__le16 le16buf = (__le16 )buf;
125
126	for (i = 0; i < 0x1000; i++) {
187a9dca	127	if (bufsize < sizeof(tmp))
75388acd LF	128	break;
	129	tmp = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED, 2 * i);
	130	le16buf[i] = cpu_to_le16(tmp);
	131	count += sizeof(tmp);
	132	bufsize -= sizeof(tmp);
	133	}
	134
	135	return count;
	136	}
	137
	138	static ssize_t txstat_read_file(struct b43legacy_wldev dev, char buf, size_t bufsize)
	139	{
	140	struct b43legacy_txstatus_log *log = &dev->dfsentry->txstatlog;
	141	ssize_t count = 0;
	142	unsigned long flags;
	143	int i, idx;
	144	struct b43legacy_txstatus *stat;
	145
	146	spin_lock_irqsave(&log->lock, flags);
	147	if (log->end < 0) {
	148	fappend("Nothing transmitted, yet\n");
	149	goto out_unlock;
	150	}
	151	fappend("b43legacy TX status reports:\n\n"
	152	"index \| cookie \| seq \| phy_stat \| frame_count \| "
	153	"rts_count \| supp_reason \| pm_indicated \| "
	154	"intermediate \| for_ampdu \| acked\n" "---\n");
	155	i = log->end + 1;
	156	idx = 0;
	157	while (1) {
	158	if (i == B43legacy_NR_LOGGED_TXSTATUS)
	159	i = 0;
	160	stat = &(log->log[i]);
	161	if (stat->cookie) {
	162	fappend("%03d \| "
	163	"0x%04X \| 0x%04X \| 0x%02X \| "
	164	"0x%X \| 0x%X \| "
	165	"%u \| %u \| "
	166	"%u \| %u \| %u\n",
	167	idx,
	168	stat->cookie, stat->seq, stat->phy_stat,
	169	stat->frame_count, stat->rts_count,
	170	stat->supp_reason, stat->pm_indicated,
	171	stat->intermediate, stat->for_ampdu,
	172	stat->acked);
	173	idx++;
	174	}
	175	if (i == log->end)
	176	break;
	177	i++;
	178	}
	179	out_unlock:
	180	spin_unlock_irqrestore(&log->lock, flags);
	181
	182	return count;
	183	}
	184
	185	/* wl->irq_lock is locked */
	186	static int restart_write_file(struct b43legacy_wldev dev, const char buf, size_t count)
	187	{
	188	int err = 0;
	189
	190	if (count > 0 && buf[0] == '1') {
	191	b43legacy_controller_restart(dev, "manually restarted");
192	} else
193	err = -EINVAL;
194
195	return err;
196	}
197
198	#undef fappend
199
200	static int b43legacy_debugfs_open(struct inode inode, struct file file)
201	{
202	file->private_data = inode->i_private;
203	return 0;
204	}
205
206	static ssize_t b43legacy_debugfs_read(struct file file, char __user userbuf,
207	size_t count, loff_t *ppos)
208	{
209	struct b43legacy_wldev *dev;
210	struct b43legacy_debugfs_fops *dfops;
211	struct b43legacy_dfs_file *dfile;
125c5cc2	212	ssize_t uninitialized_var(ret);
75388acd	213	char *buf;
d8004cb9	214	const size_t bufsize = 1024 * 16; /* 16 KiB buffer */
75388acd LF	215	const size_t buforder = get_order(bufsize);
	216	int err = 0;
	217
	218	if (!count)
	219	return 0;
	220	dev = file->private_data;
	221	if (!dev)
	222	return -ENODEV;
	223
	224	mutex_lock(&dev->wl->mutex);
	225	if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED) {
	226	err = -ENODEV;
	227	goto out_unlock;
	228	}
	229
	230	dfops = container_of(file->f_op, struct b43legacy_debugfs_fops, fops);
	231	if (!dfops->read) {
	232	err = -ENOSYS;
	233	goto out_unlock;
	234	}
	235	dfile = fops_to_dfs_file(dev, dfops);
	236
	237	if (!dfile->buffer) {
	238	buf = (char *)__get_free_pages(GFP_KERNEL, buforder);
	239	if (!buf) {
	240	err = -ENOMEM;
	241	goto out_unlock;
	242	}
	243	memset(buf, 0, bufsize);
	244	if (dfops->take_irqlock) {
	245	spin_lock_irq(&dev->wl->irq_lock);
	246	ret = dfops->read(dev, buf, bufsize);
	247	spin_unlock_irq(&dev->wl->irq_lock);
	248	} else
	249	ret = dfops->read(dev, buf, bufsize);
	250	if (ret <= 0) {
	251	free_pages((unsigned long)buf, buforder);
	252	err = ret;
	253	goto out_unlock;
	254	}
	255	dfile->data_len = ret;
	256	dfile->buffer = buf;
	257	}
	258
	259	ret = simple_read_from_buffer(userbuf, count, ppos,
	260	dfile->buffer,
	261	dfile->data_len);
	262	if (*ppos >= dfile->data_len) {
	263	free_pages((unsigned long)dfile->buffer, buforder);
	264	dfile->buffer = NULL;
	265	dfile->data_len = 0;
	266	}
	267	out_unlock:
	268	mutex_unlock(&dev->wl->mutex);
	269
	270	return err ? err : ret;
	271	}
	272
	273	static ssize_t b43legacy_debugfs_write(struct file *file,
	274	const char __user *userbuf,
	275	size_t count, loff_t *ppos)
	276	{
	277	struct b43legacy_wldev *dev;
	278	struct b43legacy_debugfs_fops *dfops;
279	char *buf;
280	int err = 0;
281
282	if (!count)
283	return 0;
284	if (count > PAGE_SIZE)
285	return -E2BIG;
286	dev = file->private_data;
287	if (!dev)
288	return -ENODEV;
289
290	mutex_lock(&dev->wl->mutex);
291	if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED) {
292	err = -ENODEV;
293	goto out_unlock;
294	}
295
296	dfops = container_of(file->f_op, struct b43legacy_debugfs_fops, fops);
297	if (!dfops->write) {
298	err = -ENOSYS;
299	goto out_unlock;
300	}
301
302	buf = (char *)get_zeroed_page(GFP_KERNEL);
303	if (!buf) {
304	err = -ENOMEM;
305	goto out_unlock;
306	}
307	if (copy_from_user(buf, userbuf, count)) {
308	err = -EFAULT;
309	goto out_freepage;
310	}
311	if (dfops->take_irqlock) {
312	spin_lock_irq(&dev->wl->irq_lock);
313	err = dfops->write(dev, buf, count);
314	spin_unlock_irq(&dev->wl->irq_lock);
315	} else
316	err = dfops->write(dev, buf, count);
317	if (err)
318	goto out_freepage;
319
320	out_freepage:
321	free_page((unsigned long)buf);
322	out_unlock:
323	mutex_unlock(&dev->wl->mutex);
324
325	return err ? err : count;
326	}
327
328
329	#define B43legacy_DEBUGFS_FOPS(name, _read, _write, _take_irqlock) \
330	static struct b43legacy_debugfs_fops fops_##name = { \
331	.read = _read, \
332	.write = _write, \
333	.fops = { \
334	.open = b43legacy_debugfs_open, \
335	.read = b43legacy_debugfs_read, \
336	.write = b43legacy_debugfs_write, \
2b18ab36	337	.llseek = generic_file_llseek, \
75388acd LF	338	}, \
	339	.file_struct_offset = offsetof(struct b43legacy_dfsentry, \
	340	file_##name), \
	341	.take_irqlock = _take_irqlock, \
	342	}
	343
	344	B43legacy_DEBUGFS_FOPS(tsf, tsf_read_file, tsf_write_file, 1);
	345	B43legacy_DEBUGFS_FOPS(ucode_regs, ucode_regs_read_file, NULL, 1);
	346	B43legacy_DEBUGFS_FOPS(shm, shm_read_file, NULL, 1);
	347	B43legacy_DEBUGFS_FOPS(txstat, txstat_read_file, NULL, 0);
	348	B43legacy_DEBUGFS_FOPS(restart, NULL, restart_write_file, 1);
	349
	350
	351	int b43legacy_debug(struct b43legacy_wldev *dev, enum b43legacy_dyndbg feature)
	352	{
	353	return !!(dev->dfsentry && dev->dfsentry->dyn_debug[feature]);
	354	}
	355
	356	static void b43legacy_remove_dynamic_debug(struct b43legacy_wldev *dev)
	357	{
	358	struct b43legacy_dfsentry *e = dev->dfsentry;
	359	int i;
	360
	361	for (i = 0; i < __B43legacy_NR_DYNDBG; i++)
	362	debugfs_remove(e->dyn_debug_dentries[i]);
	363	}
	364
	365	static void b43legacy_add_dynamic_debug(struct b43legacy_wldev *dev)
	366	{
	367	struct b43legacy_dfsentry *e = dev->dfsentry;
	368	struct dentry *d;
	369
	370	#define add_dyn_dbg(name, id, initstate) do { \
	371	e->dyn_debug[id] = (initstate); \
	372	d = debugfs_create_bool(name, 0600, e->subdir, \
	373	&(e->dyn_debug[id])); \
	374	if (!IS_ERR(d)) \
	375	e->dyn_debug_dentries[id] = d; \
	376	} while (0)
	377
	378	add_dyn_dbg("debug_xmitpower", B43legacy_DBG_XMITPOWER, 0);
	379	add_dyn_dbg("debug_dmaoverflow", B43legacy_DBG_DMAOVERFLOW, 0);
	380	add_dyn_dbg("debug_dmaverbose", B43legacy_DBG_DMAVERBOSE, 0);
	381	add_dyn_dbg("debug_pwork_fast", B43legacy_DBG_PWORK_FAST, 0);
	382	add_dyn_dbg("debug_pwork_stop", B43legacy_DBG_PWORK_STOP, 0);
	383
	384	#undef add_dyn_dbg
	385	}
	386
	387	void b43legacy_debugfs_add_device(struct b43legacy_wldev *dev)
	388	{
	389	struct b43legacy_dfsentry *e;
	390	struct b43legacy_txstatus_log *log;
	391	char devdir[16];
	392
	393	B43legacy_WARN_ON(!dev);
	394	e = kzalloc(sizeof(*e), GFP_KERNEL);
	395	if (!e) {
	396	b43legacyerr(dev->wl, "debugfs: add device OOM\n");
	397	return;
	398	}
	399	e->dev = dev;
	400	log = &e->txstatlog;
	401	log->log = kcalloc(B43legacy_NR_LOGGED_TXSTATUS,
402	sizeof(struct b43legacy_txstatus), GFP_KERNEL);
403	if (!log->log) {
404	b43legacyerr(dev->wl, "debugfs: add device txstatus OOM\n");
405	kfree(e);
406	return;
407	}
408	log->end = -1;
409	spin_lock_init(&log->lock);
410
411	dev->dfsentry = e;
412
413	snprintf(devdir, sizeof(devdir), "%s", wiphy_name(dev->wl->hw->wiphy));
414	e->subdir = debugfs_create_dir(devdir, rootdir);
415	if (!e->subdir \|\| IS_ERR(e->subdir)) {
416	if (e->subdir == ERR_PTR(-ENODEV)) {
417	b43legacydbg(dev->wl, "DebugFS (CONFIG_DEBUG_FS) not "
418	"enabled in kernel config\n");
419	} else {
420	b43legacyerr(dev->wl, "debugfs: cannot create %s directory\n",
421	devdir);
422	}
423	dev->dfsentry = NULL;
424	kfree(log->log);
425	kfree(e);
426	return;
427	}
428
429	#define ADD_FILE(name, mode) \
430	do { \
431	struct dentry *d; \
432	d = debugfs_create_file(__stringify(name), \
433	mode, e->subdir, dev, \
434	&fops_##name.fops); \
435	e->file_##name.dentry = NULL; \
436	if (!IS_ERR(d)) \
437	e->file_##name.dentry = d; \
438	} while (0)
439
440
441	ADD_FILE(tsf, 0600);
442	ADD_FILE(ucode_regs, 0400);
443	ADD_FILE(shm, 0400);
444	ADD_FILE(txstat, 0400);
445	ADD_FILE(restart, 0200);
446
447	#undef ADD_FILE
448
449	b43legacy_add_dynamic_debug(dev);
450	}
451
452	void b43legacy_debugfs_remove_device(struct b43legacy_wldev *dev)
453	{
454	struct b43legacy_dfsentry *e;
455
456	if (!dev)
457	return;
458	e = dev->dfsentry;
459	if (!e)
460	return;
461	b43legacy_remove_dynamic_debug(dev);
462
463	debugfs_remove(e->file_tsf.dentry);
464	debugfs_remove(e->file_ucode_regs.dentry);
465	debugfs_remove(e->file_shm.dentry);
466	debugfs_remove(e->file_txstat.dentry);
467	debugfs_remove(e->file_restart.dentry);
468
469	debugfs_remove(e->subdir);
470	kfree(e->txstatlog.log);
471	kfree(e);
472	}
473
474	void b43legacy_debugfs_log_txstat(struct b43legacy_wldev *dev,
475	const struct b43legacy_txstatus *status)
476	{
477	struct b43legacy_dfsentry *e = dev->dfsentry;
478	struct b43legacy_txstatus_log *log;
479	struct b43legacy_txstatus *cur;
480	int i;
481
482	if (!e)
483	return;
484	log = &e->txstatlog;
485	B43legacy_WARN_ON(!irqs_disabled());
486	spin_lock(&log->lock);
487	i = log->end + 1;
488	if (i == B43legacy_NR_LOGGED_TXSTATUS)
489	i = 0;
490	log->end = i;
491	cur = &(log->log[i]);
492	memcpy(cur, status, sizeof(*cur));
493	spin_unlock(&log->lock);
494	}
495
496	void b43legacy_debugfs_init(void)
497	{
498	rootdir = debugfs_create_dir(KBUILD_MODNAME, NULL);
499	if (IS_ERR(rootdir))
500	rootdir = NULL;
501	}
502
503	void b43legacy_debugfs_exit(void)
504	{
505	debugfs_remove(rootdir);
506	}