1 /*
2 
3   Broadcom B43legacy 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 "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++) {
127 		if (bufsize < sizeof(tmp))
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 ssize_t b43legacy_debugfs_read(struct file *file, char __user *userbuf,
201 				size_t count, loff_t *ppos)
202 {
203 	struct b43legacy_wldev *dev;
204 	struct b43legacy_debugfs_fops *dfops;
205 	struct b43legacy_dfs_file *dfile;
206 	ssize_t uninitialized_var(ret);
207 	char *buf;
208 	const size_t bufsize = 1024 * 16; /* 16 KiB buffer */
209 	const size_t buforder = get_order(bufsize);
210 	int err = 0;
211 
212 	if (!count)
213 		return 0;
214 	dev = file->private_data;
215 	if (!dev)
216 		return -ENODEV;
217 
218 	mutex_lock(&dev->wl->mutex);
219 	if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED) {
220 		err = -ENODEV;
221 		goto out_unlock;
222 	}
223 
224 	dfops = container_of(debugfs_real_fops(file),
225 			     struct b43legacy_debugfs_fops, fops);
226 	if (!dfops->read) {
227 		err = -ENOSYS;
228 		goto out_unlock;
229 	}
230 	dfile = fops_to_dfs_file(dev, dfops);
231 
232 	if (!dfile->buffer) {
233 		buf = (char *)__get_free_pages(GFP_KERNEL, buforder);
234 		if (!buf) {
235 			err = -ENOMEM;
236 			goto out_unlock;
237 		}
238 		memset(buf, 0, bufsize);
239 		if (dfops->take_irqlock) {
240 			spin_lock_irq(&dev->wl->irq_lock);
241 			ret = dfops->read(dev, buf, bufsize);
242 			spin_unlock_irq(&dev->wl->irq_lock);
243 		} else
244 			ret = dfops->read(dev, buf, bufsize);
245 		if (ret <= 0) {
246 			free_pages((unsigned long)buf, buforder);
247 			err = ret;
248 			goto out_unlock;
249 		}
250 		dfile->data_len = ret;
251 		dfile->buffer = buf;
252 	}
253 
254 	ret = simple_read_from_buffer(userbuf, count, ppos,
255 				      dfile->buffer,
256 				      dfile->data_len);
257 	if (*ppos >= dfile->data_len) {
258 		free_pages((unsigned long)dfile->buffer, buforder);
259 		dfile->buffer = NULL;
260 		dfile->data_len = 0;
261 	}
262 out_unlock:
263 	mutex_unlock(&dev->wl->mutex);
264 
265 	return err ? err : ret;
266 }
267 
268 static ssize_t b43legacy_debugfs_write(struct file *file,
269 				 const char __user *userbuf,
270 				 size_t count, loff_t *ppos)
271 {
272 	struct b43legacy_wldev *dev;
273 	struct b43legacy_debugfs_fops *dfops;
274 	char *buf;
275 	int err = 0;
276 
277 	if (!count)
278 		return 0;
279 	if (count > PAGE_SIZE)
280 		return -E2BIG;
281 	dev = file->private_data;
282 	if (!dev)
283 		return -ENODEV;
284 
285 	mutex_lock(&dev->wl->mutex);
286 	if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED) {
287 		err = -ENODEV;
288 		goto out_unlock;
289 	}
290 
291 	dfops = container_of(debugfs_real_fops(file),
292 			     struct b43legacy_debugfs_fops, fops);
293 	if (!dfops->write) {
294 		err = -ENOSYS;
295 		goto out_unlock;
296 	}
297 
298 	buf = (char *)get_zeroed_page(GFP_KERNEL);
299 	if (!buf) {
300 		err = -ENOMEM;
301 		goto out_unlock;
302 	}
303 	if (copy_from_user(buf, userbuf, count)) {
304 		err = -EFAULT;
305 		goto out_freepage;
306 	}
307 	if (dfops->take_irqlock) {
308 		spin_lock_irq(&dev->wl->irq_lock);
309 		err = dfops->write(dev, buf, count);
310 		spin_unlock_irq(&dev->wl->irq_lock);
311 	} else
312 		err = dfops->write(dev, buf, count);
313 	if (err)
314 		goto out_freepage;
315 
316 out_freepage:
317 	free_page((unsigned long)buf);
318 out_unlock:
319 	mutex_unlock(&dev->wl->mutex);
320 
321 	return err ? err : count;
322 }
323 
324 
325 #define B43legacy_DEBUGFS_FOPS(name, _read, _write, _take_irqlock)	\
326 	static struct b43legacy_debugfs_fops fops_##name = {		\
327 		.read	= _read,				\
328 		.write	= _write,				\
329 		.fops	= {					\
330 			.open	= simple_open,				\
331 			.read	= b43legacy_debugfs_read,		\
332 			.write	= b43legacy_debugfs_write,		\
333 			.llseek = generic_file_llseek,			\
334 		},						\
335 		.file_struct_offset = offsetof(struct b43legacy_dfsentry, \
336 					       file_##name),	\
337 		.take_irqlock	= _take_irqlock,		\
338 	}
339 
340 B43legacy_DEBUGFS_FOPS(tsf, tsf_read_file, tsf_write_file, 1);
341 B43legacy_DEBUGFS_FOPS(ucode_regs, ucode_regs_read_file, NULL, 1);
342 B43legacy_DEBUGFS_FOPS(shm, shm_read_file, NULL, 1);
343 B43legacy_DEBUGFS_FOPS(txstat, txstat_read_file, NULL, 0);
344 B43legacy_DEBUGFS_FOPS(restart, NULL, restart_write_file, 1);
345 
346 
347 int b43legacy_debug(struct b43legacy_wldev *dev, enum b43legacy_dyndbg feature)
348 {
349 	return !!(dev->dfsentry && dev->dfsentry->dyn_debug[feature]);
350 }
351 
352 static void b43legacy_remove_dynamic_debug(struct b43legacy_wldev *dev)
353 {
354 	struct b43legacy_dfsentry *e = dev->dfsentry;
355 	int i;
356 
357 	for (i = 0; i < __B43legacy_NR_DYNDBG; i++)
358 		debugfs_remove(e->dyn_debug_dentries[i]);
359 }
360 
361 static void b43legacy_add_dynamic_debug(struct b43legacy_wldev *dev)
362 {
363 	struct b43legacy_dfsentry *e = dev->dfsentry;
364 	struct dentry *d;
365 
366 #define add_dyn_dbg(name, id, initstate) do {		\
367 	e->dyn_debug[id] = (initstate);			\
368 	d = debugfs_create_bool(name, 0600, e->subdir,	\
369 				&(e->dyn_debug[id]));	\
370 	if (!IS_ERR(d))					\
371 		e->dyn_debug_dentries[id] = d;		\
372 				} while (0)
373 
374 	add_dyn_dbg("debug_xmitpower", B43legacy_DBG_XMITPOWER, false);
375 	add_dyn_dbg("debug_dmaoverflow", B43legacy_DBG_DMAOVERFLOW, false);
376 	add_dyn_dbg("debug_dmaverbose", B43legacy_DBG_DMAVERBOSE, false);
377 	add_dyn_dbg("debug_pwork_fast", B43legacy_DBG_PWORK_FAST, false);
378 	add_dyn_dbg("debug_pwork_stop", B43legacy_DBG_PWORK_STOP, false);
379 
380 #undef add_dyn_dbg
381 }
382 
383 void b43legacy_debugfs_add_device(struct b43legacy_wldev *dev)
384 {
385 	struct b43legacy_dfsentry *e;
386 	struct b43legacy_txstatus_log *log;
387 	char devdir[16];
388 
389 	B43legacy_WARN_ON(!dev);
390 	e = kzalloc(sizeof(*e), GFP_KERNEL);
391 	if (!e) {
392 		b43legacyerr(dev->wl, "debugfs: add device OOM\n");
393 		return;
394 	}
395 	e->dev = dev;
396 	log = &e->txstatlog;
397 	log->log = kcalloc(B43legacy_NR_LOGGED_TXSTATUS,
398 			   sizeof(struct b43legacy_txstatus), GFP_KERNEL);
399 	if (!log->log) {
400 		b43legacyerr(dev->wl, "debugfs: add device txstatus OOM\n");
401 		kfree(e);
402 		return;
403 	}
404 	log->end = -1;
405 	spin_lock_init(&log->lock);
406 
407 	dev->dfsentry = e;
408 
409 	snprintf(devdir, sizeof(devdir), "%s", wiphy_name(dev->wl->hw->wiphy));
410 	e->subdir = debugfs_create_dir(devdir, rootdir);
411 	if (!e->subdir || IS_ERR(e->subdir)) {
412 		if (e->subdir == ERR_PTR(-ENODEV)) {
413 			b43legacydbg(dev->wl, "DebugFS (CONFIG_DEBUG_FS) not "
414 			       "enabled in kernel config\n");
415 		} else {
416 			b43legacyerr(dev->wl, "debugfs: cannot create %s directory\n",
417 			       devdir);
418 		}
419 		dev->dfsentry = NULL;
420 		kfree(log->log);
421 		kfree(e);
422 		return;
423 	}
424 
425 #define ADD_FILE(name, mode)	\
426 	do {							\
427 		struct dentry *d;				\
428 		d = debugfs_create_file(__stringify(name),	\
429 					mode, e->subdir, dev,	\
430 					&fops_##name.fops);	\
431 		e->file_##name.dentry = NULL;			\
432 		if (!IS_ERR(d))					\
433 			e->file_##name.dentry = d;		\
434 	} while (0)
435 
436 
437 	ADD_FILE(tsf, 0600);
438 	ADD_FILE(ucode_regs, 0400);
439 	ADD_FILE(shm, 0400);
440 	ADD_FILE(txstat, 0400);
441 	ADD_FILE(restart, 0200);
442 
443 #undef ADD_FILE
444 
445 	b43legacy_add_dynamic_debug(dev);
446 }
447 
448 void b43legacy_debugfs_remove_device(struct b43legacy_wldev *dev)
449 {
450 	struct b43legacy_dfsentry *e;
451 
452 	if (!dev)
453 		return;
454 	e = dev->dfsentry;
455 	if (!e)
456 		return;
457 	b43legacy_remove_dynamic_debug(dev);
458 
459 	debugfs_remove(e->file_tsf.dentry);
460 	debugfs_remove(e->file_ucode_regs.dentry);
461 	debugfs_remove(e->file_shm.dentry);
462 	debugfs_remove(e->file_txstat.dentry);
463 	debugfs_remove(e->file_restart.dentry);
464 
465 	debugfs_remove(e->subdir);
466 	kfree(e->txstatlog.log);
467 	kfree(e);
468 }
469 
470 void b43legacy_debugfs_log_txstat(struct b43legacy_wldev *dev,
471 			    const struct b43legacy_txstatus *status)
472 {
473 	struct b43legacy_dfsentry *e = dev->dfsentry;
474 	struct b43legacy_txstatus_log *log;
475 	struct b43legacy_txstatus *cur;
476 	int i;
477 
478 	if (!e)
479 		return;
480 	log = &e->txstatlog;
481 	B43legacy_WARN_ON(!irqs_disabled());
482 	spin_lock(&log->lock);
483 	i = log->end + 1;
484 	if (i == B43legacy_NR_LOGGED_TXSTATUS)
485 		i = 0;
486 	log->end = i;
487 	cur = &(log->log[i]);
488 	memcpy(cur, status, sizeof(*cur));
489 	spin_unlock(&log->lock);
490 }
491 
492 void b43legacy_debugfs_init(void)
493 {
494 	rootdir = debugfs_create_dir(KBUILD_MODNAME, NULL);
495 	if (IS_ERR(rootdir))
496 		rootdir = NULL;
497 }
498 
499 void b43legacy_debugfs_exit(void)
500 {
501 	debugfs_remove(rootdir);
502 }
503