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