PageRenderTime 53ms CodeModel.GetById 9ms app.highlight 38ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/net/wireless/b43/debugfs.c

http://github.com/mirrors/linux
C | 826 lines | 673 code | 122 blank | 31 comment | 126 complexity | 221909fe0140e874b566b2e004088591 MD5 | raw file
  1/*
  2
  3  Broadcom B43 wireless driver
  4
  5  debugfs driver debugging code
  6
  7  Copyright (c) 2005-2007 Michael Buesch <m@bues.ch>
  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 "b43.h"
 34#include "main.h"
 35#include "debugfs.h"
 36#include "dma.h"
 37#include "xmit.h"
 38
 39
 40/* The root directory. */
 41static struct dentry *rootdir;
 42
 43struct b43_debugfs_fops {
 44	ssize_t (*read)(struct b43_wldev *dev, char *buf, size_t bufsize);
 45	int (*write)(struct b43_wldev *dev, const char *buf, size_t count);
 46	struct file_operations fops;
 47	/* Offset of struct b43_dfs_file in struct b43_dfsentry */
 48	size_t file_struct_offset;
 49};
 50
 51static inline
 52struct b43_dfs_file *fops_to_dfs_file(struct b43_wldev *dev,
 53				      const struct b43_debugfs_fops *dfops)
 54{
 55	void *p;
 56
 57	p = dev->dfsentry;
 58	p += dfops->file_struct_offset;
 59
 60	return p;
 61}
 62
 63
 64#define fappend(fmt, x...)	\
 65	do {							\
 66		if (bufsize - count)				\
 67			count += snprintf(buf + count,		\
 68					  bufsize - count,	\
 69					  fmt , ##x);		\
 70		else						\
 71			printk(KERN_ERR "b43: fappend overflow\n"); \
 72	} while (0)
 73
 74
 75/* The biggest address values for SHM access from the debugfs files. */
 76#define B43_MAX_SHM_ROUTING	4
 77#define B43_MAX_SHM_ADDR	0xFFFF
 78
 79static ssize_t shm16read__read_file(struct b43_wldev *dev,
 80				    char *buf, size_t bufsize)
 81{
 82	ssize_t count = 0;
 83	unsigned int routing, addr;
 84	u16 val;
 85
 86	routing = dev->dfsentry->shm16read_routing_next;
 87	addr = dev->dfsentry->shm16read_addr_next;
 88	if ((routing > B43_MAX_SHM_ROUTING) ||
 89	    (addr > B43_MAX_SHM_ADDR))
 90		return -EDESTADDRREQ;
 91
 92	val = b43_shm_read16(dev, routing, addr);
 93	fappend("0x%04X\n", val);
 94
 95	return count;
 96}
 97
 98static int shm16read__write_file(struct b43_wldev *dev,
 99				 const char *buf, size_t count)
100{
101	unsigned int routing, addr;
102	int res;
103
104	res = sscanf(buf, "0x%X 0x%X", &routing, &addr);
105	if (res != 2)
106		return -EINVAL;
107	if (routing > B43_MAX_SHM_ROUTING)
108		return -EADDRNOTAVAIL;
109	if (addr > B43_MAX_SHM_ADDR)
110		return -EADDRNOTAVAIL;
111	if (routing == B43_SHM_SHARED) {
112		if ((addr % 2) != 0)
113			return -EADDRNOTAVAIL;
114	}
115
116	dev->dfsentry->shm16read_routing_next = routing;
117	dev->dfsentry->shm16read_addr_next = addr;
118
119	return 0;
120}
121
122static int shm16write__write_file(struct b43_wldev *dev,
123				  const char *buf, size_t count)
124{
125	unsigned int routing, addr, mask, set;
126	u16 val;
127	int res;
128
129	res = sscanf(buf, "0x%X 0x%X 0x%X 0x%X",
130		     &routing, &addr, &mask, &set);
131	if (res != 4)
132		return -EINVAL;
133	if (routing > B43_MAX_SHM_ROUTING)
134		return -EADDRNOTAVAIL;
135	if (addr > B43_MAX_SHM_ADDR)
136		return -EADDRNOTAVAIL;
137	if (routing == B43_SHM_SHARED) {
138		if ((addr % 2) != 0)
139			return -EADDRNOTAVAIL;
140	}
141	if ((mask > 0xFFFF) || (set > 0xFFFF))
142		return -E2BIG;
143
144	if (mask == 0)
145		val = 0;
146	else
147		val = b43_shm_read16(dev, routing, addr);
148	val &= mask;
149	val |= set;
150	b43_shm_write16(dev, routing, addr, val);
151
152	return 0;
153}
154
155static ssize_t shm32read__read_file(struct b43_wldev *dev,
156				    char *buf, size_t bufsize)
157{
158	ssize_t count = 0;
159	unsigned int routing, addr;
160	u32 val;
161
162	routing = dev->dfsentry->shm32read_routing_next;
163	addr = dev->dfsentry->shm32read_addr_next;
164	if ((routing > B43_MAX_SHM_ROUTING) ||
165	    (addr > B43_MAX_SHM_ADDR))
166		return -EDESTADDRREQ;
167
168	val = b43_shm_read32(dev, routing, addr);
169	fappend("0x%08X\n", val);
170
171	return count;
172}
173
174static int shm32read__write_file(struct b43_wldev *dev,
175				 const char *buf, size_t count)
176{
177	unsigned int routing, addr;
178	int res;
179
180	res = sscanf(buf, "0x%X 0x%X", &routing, &addr);
181	if (res != 2)
182		return -EINVAL;
183	if (routing > B43_MAX_SHM_ROUTING)
184		return -EADDRNOTAVAIL;
185	if (addr > B43_MAX_SHM_ADDR)
186		return -EADDRNOTAVAIL;
187	if (routing == B43_SHM_SHARED) {
188		if ((addr % 2) != 0)
189			return -EADDRNOTAVAIL;
190	}
191
192	dev->dfsentry->shm32read_routing_next = routing;
193	dev->dfsentry->shm32read_addr_next = addr;
194
195	return 0;
196}
197
198static int shm32write__write_file(struct b43_wldev *dev,
199				  const char *buf, size_t count)
200{
201	unsigned int routing, addr, mask, set;
202	u32 val;
203	int res;
204
205	res = sscanf(buf, "0x%X 0x%X 0x%X 0x%X",
206		     &routing, &addr, &mask, &set);
207	if (res != 4)
208		return -EINVAL;
209	if (routing > B43_MAX_SHM_ROUTING)
210		return -EADDRNOTAVAIL;
211	if (addr > B43_MAX_SHM_ADDR)
212		return -EADDRNOTAVAIL;
213	if (routing == B43_SHM_SHARED) {
214		if ((addr % 2) != 0)
215			return -EADDRNOTAVAIL;
216	}
217	if ((mask > 0xFFFFFFFF) || (set > 0xFFFFFFFF))
218		return -E2BIG;
219
220	if (mask == 0)
221		val = 0;
222	else
223		val = b43_shm_read32(dev, routing, addr);
224	val &= mask;
225	val |= set;
226	b43_shm_write32(dev, routing, addr, val);
227
228	return 0;
229}
230
231/* The biggest MMIO address that we allow access to from the debugfs files. */
232#define B43_MAX_MMIO_ACCESS	(0xF00 - 1)
233
234static ssize_t mmio16read__read_file(struct b43_wldev *dev,
235				     char *buf, size_t bufsize)
236{
237	ssize_t count = 0;
238	unsigned int addr;
239	u16 val;
240
241	addr = dev->dfsentry->mmio16read_next;
242	if (addr > B43_MAX_MMIO_ACCESS)
243		return -EDESTADDRREQ;
244
245	val = b43_read16(dev, addr);
246	fappend("0x%04X\n", val);
247
248	return count;
249}
250
251static int mmio16read__write_file(struct b43_wldev *dev,
252				  const char *buf, size_t count)
253{
254	unsigned int addr;
255	int res;
256
257	res = sscanf(buf, "0x%X", &addr);
258	if (res != 1)
259		return -EINVAL;
260	if (addr > B43_MAX_MMIO_ACCESS)
261		return -EADDRNOTAVAIL;
262	if ((addr % 2) != 0)
263		return -EINVAL;
264
265	dev->dfsentry->mmio16read_next = addr;
266
267	return 0;
268}
269
270static int mmio16write__write_file(struct b43_wldev *dev,
271				   const char *buf, size_t count)
272{
273	unsigned int addr, mask, set;
274	int res;
275	u16 val;
276
277	res = sscanf(buf, "0x%X 0x%X 0x%X", &addr, &mask, &set);
278	if (res != 3)
279		return -EINVAL;
280	if (addr > B43_MAX_MMIO_ACCESS)
281		return -EADDRNOTAVAIL;
282	if ((mask > 0xFFFF) || (set > 0xFFFF))
283		return -E2BIG;
284	if ((addr % 2) != 0)
285		return -EINVAL;
286
287	if (mask == 0)
288		val = 0;
289	else
290		val = b43_read16(dev, addr);
291	val &= mask;
292	val |= set;
293	b43_write16(dev, addr, val);
294
295	return 0;
296}
297
298static ssize_t mmio32read__read_file(struct b43_wldev *dev,
299				     char *buf, size_t bufsize)
300{
301	ssize_t count = 0;
302	unsigned int addr;
303	u32 val;
304
305	addr = dev->dfsentry->mmio32read_next;
306	if (addr > B43_MAX_MMIO_ACCESS)
307		return -EDESTADDRREQ;
308
309	val = b43_read32(dev, addr);
310	fappend("0x%08X\n", val);
311
312	return count;
313}
314
315static int mmio32read__write_file(struct b43_wldev *dev,
316				  const char *buf, size_t count)
317{
318	unsigned int addr;
319	int res;
320
321	res = sscanf(buf, "0x%X", &addr);
322	if (res != 1)
323		return -EINVAL;
324	if (addr > B43_MAX_MMIO_ACCESS)
325		return -EADDRNOTAVAIL;
326	if ((addr % 4) != 0)
327		return -EINVAL;
328
329	dev->dfsentry->mmio32read_next = addr;
330
331	return 0;
332}
333
334static int mmio32write__write_file(struct b43_wldev *dev,
335				   const char *buf, size_t count)
336{
337	unsigned int addr, mask, set;
338	int res;
339	u32 val;
340
341	res = sscanf(buf, "0x%X 0x%X 0x%X", &addr, &mask, &set);
342	if (res != 3)
343		return -EINVAL;
344	if (addr > B43_MAX_MMIO_ACCESS)
345		return -EADDRNOTAVAIL;
346	if ((mask > 0xFFFFFFFF) || (set > 0xFFFFFFFF))
347		return -E2BIG;
348	if ((addr % 4) != 0)
349		return -EINVAL;
350
351	if (mask == 0)
352		val = 0;
353	else
354		val = b43_read32(dev, addr);
355	val &= mask;
356	val |= set;
357	b43_write32(dev, addr, val);
358
359	return 0;
360}
361
362static ssize_t txstat_read_file(struct b43_wldev *dev,
363				char *buf, size_t bufsize)
364{
365	struct b43_txstatus_log *log = &dev->dfsentry->txstatlog;
366	ssize_t count = 0;
367	int i, idx;
368	struct b43_txstatus *stat;
369
370	if (log->end < 0) {
371		fappend("Nothing transmitted, yet\n");
372		goto out;
373	}
374	fappend("b43 TX status reports:\n\n"
375		"index | cookie | seq | phy_stat | frame_count | "
376		"rts_count | supp_reason | pm_indicated | "
377		"intermediate | for_ampdu | acked\n" "---\n");
378	i = log->end + 1;
379	idx = 0;
380	while (1) {
381		if (i == B43_NR_LOGGED_TXSTATUS)
382			i = 0;
383		stat = &(log->log[i]);
384		if (stat->cookie) {
385			fappend("%03d | "
386				"0x%04X | 0x%04X | 0x%02X | "
387				"0x%X | 0x%X | "
388				"%u | %u | "
389				"%u | %u | %u\n",
390				idx,
391				stat->cookie, stat->seq, stat->phy_stat,
392				stat->frame_count, stat->rts_count,
393				stat->supp_reason, stat->pm_indicated,
394				stat->intermediate, stat->for_ampdu,
395				stat->acked);
396			idx++;
397		}
398		if (i == log->end)
399			break;
400		i++;
401	}
402out:
403
404	return count;
405}
406
407static int restart_write_file(struct b43_wldev *dev,
408			      const char *buf, size_t count)
409{
410	int err = 0;
411
412	if (count > 0 && buf[0] == '1') {
413		b43_controller_restart(dev, "manually restarted");
414	} else
415		err = -EINVAL;
416
417	return err;
418}
419
420static unsigned long calc_expire_secs(unsigned long now,
421				      unsigned long time,
422				      unsigned long expire)
423{
424	expire = time + expire;
425
426	if (time_after(now, expire))
427		return 0; /* expired */
428	if (expire < now) {
429		/* jiffies wrapped */
430		expire -= MAX_JIFFY_OFFSET;
431		now -= MAX_JIFFY_OFFSET;
432	}
433	B43_WARN_ON(expire < now);
434
435	return (expire - now) / HZ;
436}
437
438static ssize_t loctls_read_file(struct b43_wldev *dev,
439				char *buf, size_t bufsize)
440{
441	ssize_t count = 0;
442	struct b43_txpower_lo_control *lo;
443	int i, err = 0;
444	struct b43_lo_calib *cal;
445	unsigned long now = jiffies;
446	struct b43_phy *phy = &dev->phy;
447
448	if (phy->type != B43_PHYTYPE_G) {
449		fappend("Device is not a G-PHY\n");
450		err = -ENODEV;
451		goto out;
452	}
453	lo = phy->g->lo_control;
454	fappend("-- Local Oscillator calibration data --\n\n");
455	fappend("HW-power-control enabled: %d\n",
456		dev->phy.hardware_power_control);
457	fappend("TX Bias: 0x%02X,  TX Magn: 0x%02X  (expire in %lu sec)\n",
458		lo->tx_bias, lo->tx_magn,
459		calc_expire_secs(now, lo->txctl_measured_time,
460				 B43_LO_TXCTL_EXPIRE));
461	fappend("Power Vector: 0x%08X%08X  (expires in %lu sec)\n",
462		(unsigned int)((lo->power_vector & 0xFFFFFFFF00000000ULL) >> 32),
463		(unsigned int)(lo->power_vector & 0x00000000FFFFFFFFULL),
464		calc_expire_secs(now, lo->pwr_vec_read_time,
465				 B43_LO_PWRVEC_EXPIRE));
466
467	fappend("\nCalibrated settings:\n");
468	list_for_each_entry(cal, &lo->calib_list, list) {
469		bool active;
470
471		active = (b43_compare_bbatt(&cal->bbatt, &phy->g->bbatt) &&
472			  b43_compare_rfatt(&cal->rfatt, &phy->g->rfatt));
473		fappend("BB(%d), RF(%d,%d)  ->  I=%d, Q=%d  "
474			"(expires in %lu sec)%s\n",
475			cal->bbatt.att,
476			cal->rfatt.att, cal->rfatt.with_padmix,
477			cal->ctl.i, cal->ctl.q,
478			calc_expire_secs(now, cal->calib_time,
479					 B43_LO_CALIB_EXPIRE),
480			active ? "  ACTIVE" : "");
481	}
482
483	fappend("\nUsed RF attenuation values:  Value(WithPadmix flag)\n");
484	for (i = 0; i < lo->rfatt_list.len; i++) {
485		fappend("%u(%d), ",
486			lo->rfatt_list.list[i].att,
487			lo->rfatt_list.list[i].with_padmix);
488	}
489	fappend("\n");
490	fappend("\nUsed Baseband attenuation values:\n");
491	for (i = 0; i < lo->bbatt_list.len; i++) {
492		fappend("%u, ",
493			lo->bbatt_list.list[i].att);
494	}
495	fappend("\n");
496
497out:
498	return err ? err : count;
499}
500
501#undef fappend
502
503static ssize_t b43_debugfs_read(struct file *file, char __user *userbuf,
504				size_t count, loff_t *ppos)
505{
506	struct b43_wldev *dev;
507	struct b43_debugfs_fops *dfops;
508	struct b43_dfs_file *dfile;
509	ssize_t uninitialized_var(ret);
510	char *buf;
511	const size_t bufsize = 1024 * 16; /* 16 kiB buffer */
512	const size_t buforder = get_order(bufsize);
513	int err = 0;
514
515	if (!count)
516		return 0;
517	dev = file->private_data;
518	if (!dev)
519		return -ENODEV;
520
521	mutex_lock(&dev->wl->mutex);
522	if (b43_status(dev) < B43_STAT_INITIALIZED) {
523		err = -ENODEV;
524		goto out_unlock;
525	}
526
527	dfops = container_of(file->f_op, struct b43_debugfs_fops, fops);
528	if (!dfops->read) {
529		err = -ENOSYS;
530		goto out_unlock;
531	}
532	dfile = fops_to_dfs_file(dev, dfops);
533
534	if (!dfile->buffer) {
535		buf = (char *)__get_free_pages(GFP_KERNEL, buforder);
536		if (!buf) {
537			err = -ENOMEM;
538			goto out_unlock;
539		}
540		memset(buf, 0, bufsize);
541		ret = dfops->read(dev, buf, bufsize);
542		if (ret <= 0) {
543			free_pages((unsigned long)buf, buforder);
544			err = ret;
545			goto out_unlock;
546		}
547		dfile->data_len = ret;
548		dfile->buffer = buf;
549	}
550
551	ret = simple_read_from_buffer(userbuf, count, ppos,
552				      dfile->buffer,
553				      dfile->data_len);
554	if (*ppos >= dfile->data_len) {
555		free_pages((unsigned long)dfile->buffer, buforder);
556		dfile->buffer = NULL;
557		dfile->data_len = 0;
558	}
559out_unlock:
560	mutex_unlock(&dev->wl->mutex);
561
562	return err ? err : ret;
563}
564
565static ssize_t b43_debugfs_write(struct file *file,
566				 const char __user *userbuf,
567				 size_t count, loff_t *ppos)
568{
569	struct b43_wldev *dev;
570	struct b43_debugfs_fops *dfops;
571	char *buf;
572	int err = 0;
573
574	if (!count)
575		return 0;
576	if (count > PAGE_SIZE)
577		return -E2BIG;
578	dev = file->private_data;
579	if (!dev)
580		return -ENODEV;
581
582	mutex_lock(&dev->wl->mutex);
583	if (b43_status(dev) < B43_STAT_INITIALIZED) {
584		err = -ENODEV;
585		goto out_unlock;
586	}
587
588	dfops = container_of(file->f_op, struct b43_debugfs_fops, fops);
589	if (!dfops->write) {
590		err = -ENOSYS;
591		goto out_unlock;
592	}
593
594	buf = (char *)get_zeroed_page(GFP_KERNEL);
595	if (!buf) {
596		err = -ENOMEM;
597		goto out_unlock;
598	}
599	if (copy_from_user(buf, userbuf, count)) {
600		err = -EFAULT;
601		goto out_freepage;
602	}
603	err = dfops->write(dev, buf, count);
604	if (err)
605		goto out_freepage;
606
607out_freepage:
608	free_page((unsigned long)buf);
609out_unlock:
610	mutex_unlock(&dev->wl->mutex);
611
612	return err ? err : count;
613}
614
615
616#define B43_DEBUGFS_FOPS(name, _read, _write)			\
617	static struct b43_debugfs_fops fops_##name = {		\
618		.read	= _read,				\
619		.write	= _write,				\
620		.fops	= {					\
621			.open	= simple_open,			\
622			.read	= b43_debugfs_read,		\
623			.write	= b43_debugfs_write,		\
624			.llseek = generic_file_llseek,		\
625		},						\
626		.file_struct_offset = offsetof(struct b43_dfsentry, \
627					       file_##name),	\
628	}
629
630B43_DEBUGFS_FOPS(shm16read, shm16read__read_file, shm16read__write_file);
631B43_DEBUGFS_FOPS(shm16write, NULL, shm16write__write_file);
632B43_DEBUGFS_FOPS(shm32read, shm32read__read_file, shm32read__write_file);
633B43_DEBUGFS_FOPS(shm32write, NULL, shm32write__write_file);
634B43_DEBUGFS_FOPS(mmio16read, mmio16read__read_file, mmio16read__write_file);
635B43_DEBUGFS_FOPS(mmio16write, NULL, mmio16write__write_file);
636B43_DEBUGFS_FOPS(mmio32read, mmio32read__read_file, mmio32read__write_file);
637B43_DEBUGFS_FOPS(mmio32write, NULL, mmio32write__write_file);
638B43_DEBUGFS_FOPS(txstat, txstat_read_file, NULL);
639B43_DEBUGFS_FOPS(restart, NULL, restart_write_file);
640B43_DEBUGFS_FOPS(loctls, loctls_read_file, NULL);
641
642
643bool b43_debug(struct b43_wldev *dev, enum b43_dyndbg feature)
644{
645	bool enabled;
646
647	enabled = (dev->dfsentry && dev->dfsentry->dyn_debug[feature]);
648	if (unlikely(enabled)) {
649		/* Force full debugging messages, if the user enabled
650		 * some dynamic debugging feature. */
651		b43_modparam_verbose = B43_VERBOSITY_MAX;
652	}
653
654	return enabled;
655}
656
657static void b43_remove_dynamic_debug(struct b43_wldev *dev)
658{
659	struct b43_dfsentry *e = dev->dfsentry;
660	int i;
661
662	for (i = 0; i < __B43_NR_DYNDBG; i++)
663		debugfs_remove(e->dyn_debug_dentries[i]);
664}
665
666static void b43_add_dynamic_debug(struct b43_wldev *dev)
667{
668	struct b43_dfsentry *e = dev->dfsentry;
669	struct dentry *d;
670
671#define add_dyn_dbg(name, id, initstate) do {		\
672	e->dyn_debug[id] = (initstate);			\
673	d = debugfs_create_bool(name, 0600, e->subdir,	\
674				&(e->dyn_debug[id]));	\
675	if (!IS_ERR(d))					\
676		e->dyn_debug_dentries[id] = d;		\
677				} while (0)
678
679	add_dyn_dbg("debug_xmitpower", B43_DBG_XMITPOWER, 0);
680	add_dyn_dbg("debug_dmaoverflow", B43_DBG_DMAOVERFLOW, 0);
681	add_dyn_dbg("debug_dmaverbose", B43_DBG_DMAVERBOSE, 0);
682	add_dyn_dbg("debug_pwork_fast", B43_DBG_PWORK_FAST, 0);
683	add_dyn_dbg("debug_pwork_stop", B43_DBG_PWORK_STOP, 0);
684	add_dyn_dbg("debug_lo", B43_DBG_LO, 0);
685	add_dyn_dbg("debug_firmware", B43_DBG_FIRMWARE, 0);
686	add_dyn_dbg("debug_keys", B43_DBG_KEYS, 0);
687	add_dyn_dbg("debug_verbose_stats", B43_DBG_VERBOSESTATS, 0);
688
689#undef add_dyn_dbg
690}
691
692void b43_debugfs_add_device(struct b43_wldev *dev)
693{
694	struct b43_dfsentry *e;
695	struct b43_txstatus_log *log;
696	char devdir[16];
697
698	B43_WARN_ON(!dev);
699	e = kzalloc(sizeof(*e), GFP_KERNEL);
700	if (!e) {
701		b43err(dev->wl, "debugfs: add device OOM\n");
702		return;
703	}
704	e->dev = dev;
705	log = &e->txstatlog;
706	log->log = kcalloc(B43_NR_LOGGED_TXSTATUS,
707			   sizeof(struct b43_txstatus), GFP_KERNEL);
708	if (!log->log) {
709		b43err(dev->wl, "debugfs: add device txstatus OOM\n");
710		kfree(e);
711		return;
712	}
713	log->end = -1;
714
715	dev->dfsentry = e;
716
717	snprintf(devdir, sizeof(devdir), "%s", wiphy_name(dev->wl->hw->wiphy));
718	e->subdir = debugfs_create_dir(devdir, rootdir);
719	if (!e->subdir || IS_ERR(e->subdir)) {
720		if (e->subdir == ERR_PTR(-ENODEV)) {
721			b43dbg(dev->wl, "DebugFS (CONFIG_DEBUG_FS) not "
722			       "enabled in kernel config\n");
723		} else {
724			b43err(dev->wl, "debugfs: cannot create %s directory\n",
725			       devdir);
726		}
727		dev->dfsentry = NULL;
728		kfree(log->log);
729		kfree(e);
730		return;
731	}
732
733	e->mmio16read_next = 0xFFFF; /* invalid address */
734	e->mmio32read_next = 0xFFFF; /* invalid address */
735	e->shm16read_routing_next = 0xFFFFFFFF; /* invalid routing */
736	e->shm16read_addr_next = 0xFFFFFFFF; /* invalid address */
737	e->shm32read_routing_next = 0xFFFFFFFF; /* invalid routing */
738	e->shm32read_addr_next = 0xFFFFFFFF; /* invalid address */
739
740#define ADD_FILE(name, mode)	\
741	do {							\
742		struct dentry *d;				\
743		d = debugfs_create_file(__stringify(name),	\
744					mode, e->subdir, dev,	\
745					&fops_##name.fops);	\
746		e->file_##name.dentry = NULL;			\
747		if (!IS_ERR(d))					\
748			e->file_##name.dentry = d;		\
749	} while (0)
750
751
752	ADD_FILE(shm16read, 0600);
753	ADD_FILE(shm16write, 0200);
754	ADD_FILE(shm32read, 0600);
755	ADD_FILE(shm32write, 0200);
756	ADD_FILE(mmio16read, 0600);
757	ADD_FILE(mmio16write, 0200);
758	ADD_FILE(mmio32read, 0600);
759	ADD_FILE(mmio32write, 0200);
760	ADD_FILE(txstat, 0400);
761	ADD_FILE(restart, 0200);
762	ADD_FILE(loctls, 0400);
763
764#undef ADD_FILE
765
766	b43_add_dynamic_debug(dev);
767}
768
769void b43_debugfs_remove_device(struct b43_wldev *dev)
770{
771	struct b43_dfsentry *e;
772
773	if (!dev)
774		return;
775	e = dev->dfsentry;
776	if (!e)
777		return;
778	b43_remove_dynamic_debug(dev);
779
780	debugfs_remove(e->file_shm16read.dentry);
781	debugfs_remove(e->file_shm16write.dentry);
782	debugfs_remove(e->file_shm32read.dentry);
783	debugfs_remove(e->file_shm32write.dentry);
784	debugfs_remove(e->file_mmio16read.dentry);
785	debugfs_remove(e->file_mmio16write.dentry);
786	debugfs_remove(e->file_mmio32read.dentry);
787	debugfs_remove(e->file_mmio32write.dentry);
788	debugfs_remove(e->file_txstat.dentry);
789	debugfs_remove(e->file_restart.dentry);
790	debugfs_remove(e->file_loctls.dentry);
791
792	debugfs_remove(e->subdir);
793	kfree(e->txstatlog.log);
794	kfree(e);
795}
796
797void b43_debugfs_log_txstat(struct b43_wldev *dev,
798			    const struct b43_txstatus *status)
799{
800	struct b43_dfsentry *e = dev->dfsentry;
801	struct b43_txstatus_log *log;
802	struct b43_txstatus *cur;
803	int i;
804
805	if (!e)
806		return;
807	log = &e->txstatlog;
808	i = log->end + 1;
809	if (i == B43_NR_LOGGED_TXSTATUS)
810		i = 0;
811	log->end = i;
812	cur = &(log->log[i]);
813	memcpy(cur, status, sizeof(*cur));
814}
815
816void b43_debugfs_init(void)
817{
818	rootdir = debugfs_create_dir(KBUILD_MODNAME, NULL);
819	if (IS_ERR(rootdir))
820		rootdir = NULL;
821}
822
823void b43_debugfs_exit(void)
824{
825	debugfs_remove(rootdir);
826}