1 /*
2  * Copyright (c) 2012-2014 Qualcomm Atheros, Inc.
3  *
4  * Permission to use, copy, modify, and/or distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <linux/module.h>
18 #include <linux/debugfs.h>
19 #include <linux/seq_file.h>
20 #include <linux/pci.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/power_supply.h>
23 
24 #include "wil6210.h"
25 #include "wmi.h"
26 #include "txrx.h"
27 
28 /* Nasty hack. Better have per device instances */
29 static u32 mem_addr;
30 static u32 dbg_txdesc_index;
31 static u32 dbg_vring_index; /* 24+ for Rx, 0..23 for Tx */
32 
33 enum dbg_off_type {
34 	doff_u32 = 0,
35 	doff_x32 = 1,
36 	doff_ulong = 2,
37 	doff_io32 = 3,
38 };
39 
40 /* offset to "wil" */
41 struct dbg_off {
42 	const char *name;
43 	umode_t mode;
44 	ulong off;
45 	enum dbg_off_type type;
46 };
47 
48 static void wil_print_vring(struct seq_file *s, struct wil6210_priv *wil,
49 			    const char *name, struct vring *vring,
50 			    char _s, char _h)
51 {
52 	void __iomem *x = wmi_addr(wil, vring->hwtail);
53 
54 	seq_printf(s, "VRING %s = {\n", name);
55 	seq_printf(s, "  pa     = %pad\n", &vring->pa);
56 	seq_printf(s, "  va     = 0x%p\n", vring->va);
57 	seq_printf(s, "  size   = %d\n", vring->size);
58 	seq_printf(s, "  swtail = %d\n", vring->swtail);
59 	seq_printf(s, "  swhead = %d\n", vring->swhead);
60 	seq_printf(s, "  hwtail = [0x%08x] -> ", vring->hwtail);
61 	if (x)
62 		seq_printf(s, "0x%08x\n", ioread32(x));
63 	else
64 		seq_puts(s, "???\n");
65 
66 	if (vring->va && (vring->size < 1025)) {
67 		uint i;
68 
69 		for (i = 0; i < vring->size; i++) {
70 			volatile struct vring_tx_desc *d = &vring->va[i].tx;
71 
72 			if ((i % 64) == 0 && (i != 0))
73 				seq_puts(s, "\n");
74 			seq_printf(s, "%c", (d->dma.status & BIT(0)) ?
75 					_s : (vring->ctx[i].skb ? _h : 'h'));
76 		}
77 		seq_puts(s, "\n");
78 	}
79 	seq_puts(s, "}\n");
80 }
81 
82 static int wil_vring_debugfs_show(struct seq_file *s, void *data)
83 {
84 	uint i;
85 	struct wil6210_priv *wil = s->private;
86 
87 	wil_print_vring(s, wil, "rx", &wil->vring_rx, 'S', '_');
88 
89 	for (i = 0; i < ARRAY_SIZE(wil->vring_tx); i++) {
90 		struct vring *vring = &wil->vring_tx[i];
91 		struct vring_tx_data *txdata = &wil->vring_tx_data[i];
92 
93 		if (vring->va) {
94 			int cid = wil->vring2cid_tid[i][0];
95 			int tid = wil->vring2cid_tid[i][1];
96 			u32 swhead = vring->swhead;
97 			u32 swtail = vring->swtail;
98 			int used = (vring->size + swhead - swtail)
99 				   % vring->size;
100 			int avail = vring->size - used - 1;
101 			char name[10];
102 			/* performance monitoring */
103 			cycles_t now = get_cycles();
104 			cycles_t idle = txdata->idle * 100;
105 			cycles_t total = now - txdata->begin;
106 
107 			do_div(idle, total);
108 			txdata->begin = now;
109 			txdata->idle = 0ULL;
110 
111 			snprintf(name, sizeof(name), "tx_%2d", i);
112 
113 			seq_printf(s, "\n%pM CID %d TID %d [%3d|%3d] idle %3d%%\n",
114 				   wil->sta[cid].addr, cid, tid, used, avail,
115 				   (int)idle);
116 
117 			wil_print_vring(s, wil, name, vring, '_', 'H');
118 		}
119 	}
120 
121 	return 0;
122 }
123 
124 static int wil_vring_seq_open(struct inode *inode, struct file *file)
125 {
126 	return single_open(file, wil_vring_debugfs_show, inode->i_private);
127 }
128 
129 static const struct file_operations fops_vring = {
130 	.open		= wil_vring_seq_open,
131 	.release	= single_release,
132 	.read		= seq_read,
133 	.llseek		= seq_lseek,
134 };
135 
136 static void wil_print_ring(struct seq_file *s, const char *prefix,
137 			   void __iomem *off)
138 {
139 	struct wil6210_priv *wil = s->private;
140 	struct wil6210_mbox_ring r;
141 	int rsize;
142 	uint i;
143 
144 	wil_memcpy_fromio_32(&r, off, sizeof(r));
145 	wil_mbox_ring_le2cpus(&r);
146 	/*
147 	 * we just read memory block from NIC. This memory may be
148 	 * garbage. Check validity before using it.
149 	 */
150 	rsize = r.size / sizeof(struct wil6210_mbox_ring_desc);
151 
152 	seq_printf(s, "ring %s = {\n", prefix);
153 	seq_printf(s, "  base = 0x%08x\n", r.base);
154 	seq_printf(s, "  size = 0x%04x bytes -> %d entries\n", r.size, rsize);
155 	seq_printf(s, "  tail = 0x%08x\n", r.tail);
156 	seq_printf(s, "  head = 0x%08x\n", r.head);
157 	seq_printf(s, "  entry size = %d\n", r.entry_size);
158 
159 	if (r.size % sizeof(struct wil6210_mbox_ring_desc)) {
160 		seq_printf(s, "  ??? size is not multiple of %zd, garbage?\n",
161 			   sizeof(struct wil6210_mbox_ring_desc));
162 		goto out;
163 	}
164 
165 	if (!wmi_addr(wil, r.base) ||
166 	    !wmi_addr(wil, r.tail) ||
167 	    !wmi_addr(wil, r.head)) {
168 		seq_puts(s, "  ??? pointers are garbage?\n");
169 		goto out;
170 	}
171 
172 	for (i = 0; i < rsize; i++) {
173 		struct wil6210_mbox_ring_desc d;
174 		struct wil6210_mbox_hdr hdr;
175 		size_t delta = i * sizeof(d);
176 		void __iomem *x = wil->csr + HOSTADDR(r.base) + delta;
177 
178 		wil_memcpy_fromio_32(&d, x, sizeof(d));
179 
180 		seq_printf(s, "  [%2x] %s %s%s 0x%08x", i,
181 			   d.sync ? "F" : "E",
182 			   (r.tail - r.base == delta) ? "t" : " ",
183 			   (r.head - r.base == delta) ? "h" : " ",
184 			   le32_to_cpu(d.addr));
185 		if (0 == wmi_read_hdr(wil, d.addr, &hdr)) {
186 			u16 len = le16_to_cpu(hdr.len);
187 
188 			seq_printf(s, " -> %04x %04x %04x %02x\n",
189 				   le16_to_cpu(hdr.seq), len,
190 				   le16_to_cpu(hdr.type), hdr.flags);
191 			if (len <= MAX_MBOXITEM_SIZE) {
192 				int n = 0;
193 				char printbuf[16 * 3 + 2];
194 				unsigned char databuf[MAX_MBOXITEM_SIZE];
195 				void __iomem *src = wmi_buffer(wil, d.addr) +
196 					sizeof(struct wil6210_mbox_hdr);
197 				/*
198 				 * No need to check @src for validity -
199 				 * we already validated @d.addr while
200 				 * reading header
201 				 */
202 				wil_memcpy_fromio_32(databuf, src, len);
203 				while (n < len) {
204 					int l = min(len - n, 16);
205 
206 					hex_dump_to_buffer(databuf + n, l,
207 							   16, 1, printbuf,
208 							   sizeof(printbuf),
209 							   false);
210 					seq_printf(s, "      : %s\n", printbuf);
211 					n += l;
212 				}
213 			}
214 		} else {
215 			seq_puts(s, "\n");
216 		}
217 	}
218  out:
219 	seq_puts(s, "}\n");
220 }
221 
222 static int wil_mbox_debugfs_show(struct seq_file *s, void *data)
223 {
224 	struct wil6210_priv *wil = s->private;
225 
226 	wil_print_ring(s, "tx", wil->csr + HOST_MBOX +
227 		       offsetof(struct wil6210_mbox_ctl, tx));
228 	wil_print_ring(s, "rx", wil->csr + HOST_MBOX +
229 		       offsetof(struct wil6210_mbox_ctl, rx));
230 
231 	return 0;
232 }
233 
234 static int wil_mbox_seq_open(struct inode *inode, struct file *file)
235 {
236 	return single_open(file, wil_mbox_debugfs_show, inode->i_private);
237 }
238 
239 static const struct file_operations fops_mbox = {
240 	.open		= wil_mbox_seq_open,
241 	.release	= single_release,
242 	.read		= seq_read,
243 	.llseek		= seq_lseek,
244 };
245 
246 static int wil_debugfs_iomem_x32_set(void *data, u64 val)
247 {
248 	iowrite32(val, (void __iomem *)data);
249 	wmb(); /* make sure write propagated to HW */
250 
251 	return 0;
252 }
253 
254 static int wil_debugfs_iomem_x32_get(void *data, u64 *val)
255 {
256 	*val = ioread32((void __iomem *)data);
257 
258 	return 0;
259 }
260 
261 DEFINE_SIMPLE_ATTRIBUTE(fops_iomem_x32, wil_debugfs_iomem_x32_get,
262 			wil_debugfs_iomem_x32_set, "0x%08llx\n");
263 
264 static struct dentry *wil_debugfs_create_iomem_x32(const char *name,
265 						   umode_t mode,
266 						   struct dentry *parent,
267 						   void *value)
268 {
269 	return debugfs_create_file(name, mode, parent, value,
270 				   &fops_iomem_x32);
271 }
272 
273 static int wil_debugfs_ulong_set(void *data, u64 val)
274 {
275 	*(ulong *)data = val;
276 	return 0;
277 }
278 
279 static int wil_debugfs_ulong_get(void *data, u64 *val)
280 {
281 	*val = *(ulong *)data;
282 	return 0;
283 }
284 
285 DEFINE_SIMPLE_ATTRIBUTE(wil_fops_ulong, wil_debugfs_ulong_get,
286 			wil_debugfs_ulong_set, "%llu\n");
287 
288 static struct dentry *wil_debugfs_create_ulong(const char *name, umode_t mode,
289 					       struct dentry *parent,
290 					       ulong *value)
291 {
292 	return debugfs_create_file(name, mode, parent, value, &wil_fops_ulong);
293 }
294 
295 /**
296  * wil6210_debugfs_init_offset - create set of debugfs files
297  * @wil - driver's context, used for printing
298  * @dbg - directory on the debugfs, where files will be created
299  * @base - base address used in address calculation
300  * @tbl - table with file descriptions. Should be terminated with empty element.
301  *
302  * Creates files accordingly to the @tbl.
303  */
304 static void wil6210_debugfs_init_offset(struct wil6210_priv *wil,
305 					struct dentry *dbg, void *base,
306 					const struct dbg_off * const tbl)
307 {
308 	int i;
309 
310 	for (i = 0; tbl[i].name; i++) {
311 		struct dentry *f;
312 
313 		switch (tbl[i].type) {
314 		case doff_u32:
315 			f = debugfs_create_u32(tbl[i].name, tbl[i].mode, dbg,
316 					       base + tbl[i].off);
317 			break;
318 		case doff_x32:
319 			f = debugfs_create_x32(tbl[i].name, tbl[i].mode, dbg,
320 					       base + tbl[i].off);
321 			break;
322 		case doff_ulong:
323 			f = wil_debugfs_create_ulong(tbl[i].name, tbl[i].mode,
324 						     dbg, base + tbl[i].off);
325 			break;
326 		case doff_io32:
327 			f = wil_debugfs_create_iomem_x32(tbl[i].name,
328 							 tbl[i].mode, dbg,
329 							 base + tbl[i].off);
330 			break;
331 		default:
332 			f = ERR_PTR(-EINVAL);
333 		}
334 		if (IS_ERR_OR_NULL(f))
335 			wil_err(wil, "Create file \"%s\": err %ld\n",
336 				tbl[i].name, PTR_ERR(f));
337 	}
338 }
339 
340 static const struct dbg_off isr_off[] = {
341 	{"ICC", S_IRUGO | S_IWUSR, offsetof(struct RGF_ICR, ICC), doff_io32},
342 	{"ICR", S_IRUGO | S_IWUSR, offsetof(struct RGF_ICR, ICR), doff_io32},
343 	{"ICM", S_IRUGO | S_IWUSR, offsetof(struct RGF_ICR, ICM), doff_io32},
344 	{"ICS",		  S_IWUSR, offsetof(struct RGF_ICR, ICS), doff_io32},
345 	{"IMV", S_IRUGO | S_IWUSR, offsetof(struct RGF_ICR, IMV), doff_io32},
346 	{"IMS",		  S_IWUSR, offsetof(struct RGF_ICR, IMS), doff_io32},
347 	{"IMC",		  S_IWUSR, offsetof(struct RGF_ICR, IMC), doff_io32},
348 	{},
349 };
350 
351 static int wil6210_debugfs_create_ISR(struct wil6210_priv *wil,
352 				      const char *name,
353 				      struct dentry *parent, u32 off)
354 {
355 	struct dentry *d = debugfs_create_dir(name, parent);
356 
357 	if (IS_ERR_OR_NULL(d))
358 		return -ENODEV;
359 
360 	wil6210_debugfs_init_offset(wil, d, (void * __force)wil->csr + off,
361 				    isr_off);
362 
363 	return 0;
364 }
365 
366 static const struct dbg_off pseudo_isr_off[] = {
367 	{"CAUSE",   S_IRUGO, HOSTADDR(RGF_DMA_PSEUDO_CAUSE), doff_io32},
368 	{"MASK_SW", S_IRUGO, HOSTADDR(RGF_DMA_PSEUDO_CAUSE_MASK_SW), doff_io32},
369 	{"MASK_FW", S_IRUGO, HOSTADDR(RGF_DMA_PSEUDO_CAUSE_MASK_FW), doff_io32},
370 	{},
371 };
372 
373 static int wil6210_debugfs_create_pseudo_ISR(struct wil6210_priv *wil,
374 					     struct dentry *parent)
375 {
376 	struct dentry *d = debugfs_create_dir("PSEUDO_ISR", parent);
377 
378 	if (IS_ERR_OR_NULL(d))
379 		return -ENODEV;
380 
381 	wil6210_debugfs_init_offset(wil, d, (void * __force)wil->csr,
382 				    pseudo_isr_off);
383 
384 	return 0;
385 }
386 
387 static const struct dbg_off itr_cnt_off[] = {
388 	{"TRSH", S_IRUGO | S_IWUSR, HOSTADDR(RGF_DMA_ITR_CNT_TRSH), doff_io32},
389 	{"DATA", S_IRUGO | S_IWUSR, HOSTADDR(RGF_DMA_ITR_CNT_DATA), doff_io32},
390 	{"CTL",  S_IRUGO | S_IWUSR, HOSTADDR(RGF_DMA_ITR_CNT_CRL), doff_io32},
391 	{},
392 };
393 
394 static int wil6210_debugfs_create_ITR_CNT(struct wil6210_priv *wil,
395 					  struct dentry *parent)
396 {
397 	struct dentry *d = debugfs_create_dir("ITR_CNT", parent);
398 
399 	if (IS_ERR_OR_NULL(d))
400 		return -ENODEV;
401 
402 	wil6210_debugfs_init_offset(wil, d, (void * __force)wil->csr,
403 				    itr_cnt_off);
404 
405 	return 0;
406 }
407 
408 static int wil_memread_debugfs_show(struct seq_file *s, void *data)
409 {
410 	struct wil6210_priv *wil = s->private;
411 	void __iomem *a = wmi_buffer(wil, cpu_to_le32(mem_addr));
412 
413 	if (a)
414 		seq_printf(s, "[0x%08x] = 0x%08x\n", mem_addr, ioread32(a));
415 	else
416 		seq_printf(s, "[0x%08x] = INVALID\n", mem_addr);
417 
418 	return 0;
419 }
420 
421 static int wil_memread_seq_open(struct inode *inode, struct file *file)
422 {
423 	return single_open(file, wil_memread_debugfs_show, inode->i_private);
424 }
425 
426 static const struct file_operations fops_memread = {
427 	.open		= wil_memread_seq_open,
428 	.release	= single_release,
429 	.read		= seq_read,
430 	.llseek		= seq_lseek,
431 };
432 
433 static ssize_t wil_read_file_ioblob(struct file *file, char __user *user_buf,
434 				    size_t count, loff_t *ppos)
435 {
436 	enum { max_count = 4096 };
437 	struct debugfs_blob_wrapper *blob = file->private_data;
438 	loff_t pos = *ppos;
439 	size_t available = blob->size;
440 	void *buf;
441 	size_t ret;
442 
443 	if (pos < 0)
444 		return -EINVAL;
445 
446 	if (pos >= available || !count)
447 		return 0;
448 
449 	if (count > available - pos)
450 		count = available - pos;
451 	if (count > max_count)
452 		count = max_count;
453 
454 	buf = kmalloc(count, GFP_KERNEL);
455 	if (!buf)
456 		return -ENOMEM;
457 
458 	wil_memcpy_fromio_32(buf, (const volatile void __iomem *)blob->data +
459 			     pos, count);
460 
461 	ret = copy_to_user(user_buf, buf, count);
462 	kfree(buf);
463 	if (ret == count)
464 		return -EFAULT;
465 
466 	count -= ret;
467 	*ppos = pos + count;
468 
469 	return count;
470 }
471 
472 static const struct file_operations fops_ioblob = {
473 	.read =		wil_read_file_ioblob,
474 	.open =		simple_open,
475 	.llseek =	default_llseek,
476 };
477 
478 static
479 struct dentry *wil_debugfs_create_ioblob(const char *name,
480 					 umode_t mode,
481 					 struct dentry *parent,
482 					 struct debugfs_blob_wrapper *blob)
483 {
484 	return debugfs_create_file(name, mode, parent, blob, &fops_ioblob);
485 }
486 
487 /*---reset---*/
488 static ssize_t wil_write_file_reset(struct file *file, const char __user *buf,
489 				    size_t len, loff_t *ppos)
490 {
491 	struct wil6210_priv *wil = file->private_data;
492 	struct net_device *ndev = wil_to_ndev(wil);
493 
494 	/**
495 	 * BUG:
496 	 * this code does NOT sync device state with the rest of system
497 	 * use with care, debug only!!!
498 	 */
499 	rtnl_lock();
500 	dev_close(ndev);
501 	ndev->flags &= ~IFF_UP;
502 	rtnl_unlock();
503 	wil_reset(wil);
504 
505 	return len;
506 }
507 
508 static const struct file_operations fops_reset = {
509 	.write = wil_write_file_reset,
510 	.open  = simple_open,
511 };
512 
513 /*---write channel 1..4 to rxon for it, 0 to rxoff---*/
514 static ssize_t wil_write_file_rxon(struct file *file, const char __user *buf,
515 				   size_t len, loff_t *ppos)
516 {
517 	struct wil6210_priv *wil = file->private_data;
518 	int rc;
519 	long channel;
520 	bool on;
521 
522 	char *kbuf = kmalloc(len + 1, GFP_KERNEL);
523 
524 	if (!kbuf)
525 		return -ENOMEM;
526 	if (copy_from_user(kbuf, buf, len)) {
527 		kfree(kbuf);
528 		return -EIO;
529 	}
530 
531 	kbuf[len] = '\0';
532 	rc = kstrtol(kbuf, 0, &channel);
533 	kfree(kbuf);
534 	if (rc)
535 		return rc;
536 
537 	if ((channel < 0) || (channel > 4)) {
538 		wil_err(wil, "Invalid channel %ld\n", channel);
539 		return -EINVAL;
540 	}
541 	on = !!channel;
542 
543 	if (on) {
544 		rc = wmi_set_channel(wil, (int)channel);
545 		if (rc)
546 			return rc;
547 	}
548 
549 	rc = wmi_rxon(wil, on);
550 	if (rc)
551 		return rc;
552 
553 	return len;
554 }
555 
556 static const struct file_operations fops_rxon = {
557 	.write = wil_write_file_rxon,
558 	.open  = simple_open,
559 };
560 
561 /*---tx_mgmt---*/
562 /* Write mgmt frame to this file to send it */
563 static ssize_t wil_write_file_txmgmt(struct file *file, const char __user *buf,
564 				     size_t len, loff_t *ppos)
565 {
566 	struct wil6210_priv *wil = file->private_data;
567 	struct wiphy *wiphy = wil_to_wiphy(wil);
568 	struct wireless_dev *wdev = wil_to_wdev(wil);
569 	struct cfg80211_mgmt_tx_params params;
570 	int rc;
571 	void *frame = kmalloc(len, GFP_KERNEL);
572 
573 	if (!frame)
574 		return -ENOMEM;
575 
576 	if (copy_from_user(frame, buf, len)) {
577 		kfree(frame);
578 		return -EIO;
579 	}
580 
581 	params.buf = frame;
582 	params.len = len;
583 	params.chan = wdev->preset_chandef.chan;
584 
585 	rc = wil_cfg80211_mgmt_tx(wiphy, wdev, &params, NULL);
586 
587 	kfree(frame);
588 	wil_info(wil, "%s() -> %d\n", __func__, rc);
589 
590 	return len;
591 }
592 
593 static const struct file_operations fops_txmgmt = {
594 	.write = wil_write_file_txmgmt,
595 	.open  = simple_open,
596 };
597 
598 /* Write WMI command (w/o mbox header) to this file to send it
599  * WMI starts from wil6210_mbox_hdr_wmi header
600  */
601 static ssize_t wil_write_file_wmi(struct file *file, const char __user *buf,
602 				  size_t len, loff_t *ppos)
603 {
604 	struct wil6210_priv *wil = file->private_data;
605 	struct wil6210_mbox_hdr_wmi *wmi;
606 	void *cmd;
607 	int cmdlen = len - sizeof(struct wil6210_mbox_hdr_wmi);
608 	u16 cmdid;
609 	int rc, rc1;
610 
611 	if (cmdlen <= 0)
612 		return -EINVAL;
613 
614 	wmi = kmalloc(len, GFP_KERNEL);
615 	if (!wmi)
616 		return -ENOMEM;
617 
618 	rc = simple_write_to_buffer(wmi, len, ppos, buf, len);
619 	if (rc < 0) {
620 		kfree(wmi);
621 		return rc;
622 	}
623 
624 	cmd = &wmi[1];
625 	cmdid = le16_to_cpu(wmi->id);
626 
627 	rc1 = wmi_send(wil, cmdid, cmd, cmdlen);
628 	kfree(wmi);
629 
630 	wil_info(wil, "%s(0x%04x[%d]) -> %d\n", __func__, cmdid, cmdlen, rc1);
631 
632 	return rc;
633 }
634 
635 static const struct file_operations fops_wmi = {
636 	.write = wil_write_file_wmi,
637 	.open  = simple_open,
638 };
639 
640 static void wil_seq_hexdump(struct seq_file *s, void *p, int len,
641 			    const char *prefix)
642 {
643 	char printbuf[16 * 3 + 2];
644 	int i = 0;
645 
646 	while (i < len) {
647 		int l = min(len - i, 16);
648 
649 		hex_dump_to_buffer(p + i, l, 16, 1, printbuf,
650 				   sizeof(printbuf), false);
651 		seq_printf(s, "%s%s\n", prefix, printbuf);
652 		i += l;
653 	}
654 }
655 
656 static void wil_seq_print_skb(struct seq_file *s, struct sk_buff *skb)
657 {
658 	int i = 0;
659 	int len = skb_headlen(skb);
660 	void *p = skb->data;
661 	int nr_frags = skb_shinfo(skb)->nr_frags;
662 
663 	seq_printf(s, "    len = %d\n", len);
664 	wil_seq_hexdump(s, p, len, "      : ");
665 
666 	if (nr_frags) {
667 		seq_printf(s, "    nr_frags = %d\n", nr_frags);
668 		for (i = 0; i < nr_frags; i++) {
669 			const struct skb_frag_struct *frag =
670 					&skb_shinfo(skb)->frags[i];
671 
672 			len = skb_frag_size(frag);
673 			p = skb_frag_address_safe(frag);
674 			seq_printf(s, "    [%2d] : len = %d\n", i, len);
675 			wil_seq_hexdump(s, p, len, "      : ");
676 		}
677 	}
678 }
679 
680 /*---------Tx/Rx descriptor------------*/
681 static int wil_txdesc_debugfs_show(struct seq_file *s, void *data)
682 {
683 	struct wil6210_priv *wil = s->private;
684 	struct vring *vring;
685 	bool tx = (dbg_vring_index < WIL6210_MAX_TX_RINGS);
686 
687 	vring = tx ? &wil->vring_tx[dbg_vring_index] : &wil->vring_rx;
688 
689 	if (!vring->va) {
690 		if (tx)
691 			seq_printf(s, "No Tx[%2d] VRING\n", dbg_vring_index);
692 		else
693 			seq_puts(s, "No Rx VRING\n");
694 		return 0;
695 	}
696 
697 	if (dbg_txdesc_index < vring->size) {
698 		/* use struct vring_tx_desc for Rx as well,
699 		 * only field used, .dma.length, is the same
700 		 */
701 		volatile struct vring_tx_desc *d =
702 				&vring->va[dbg_txdesc_index].tx;
703 		volatile u32 *u = (volatile u32 *)d;
704 		struct sk_buff *skb = vring->ctx[dbg_txdesc_index].skb;
705 
706 		if (tx)
707 			seq_printf(s, "Tx[%2d][%3d] = {\n", dbg_vring_index,
708 				   dbg_txdesc_index);
709 		else
710 			seq_printf(s, "Rx[%3d] = {\n", dbg_txdesc_index);
711 		seq_printf(s, "  MAC = 0x%08x 0x%08x 0x%08x 0x%08x\n",
712 			   u[0], u[1], u[2], u[3]);
713 		seq_printf(s, "  DMA = 0x%08x 0x%08x 0x%08x 0x%08x\n",
714 			   u[4], u[5], u[6], u[7]);
715 		seq_printf(s, "  SKB = 0x%p\n", skb);
716 
717 		if (skb) {
718 			skb_get(skb);
719 			wil_seq_print_skb(s, skb);
720 			kfree_skb(skb);
721 		}
722 		seq_puts(s, "}\n");
723 	} else {
724 		if (tx)
725 			seq_printf(s, "[%2d] TxDesc index (%d) >= size (%d)\n",
726 				   dbg_vring_index, dbg_txdesc_index,
727 				   vring->size);
728 		else
729 			seq_printf(s, "RxDesc index (%d) >= size (%d)\n",
730 				   dbg_txdesc_index, vring->size);
731 	}
732 
733 	return 0;
734 }
735 
736 static int wil_txdesc_seq_open(struct inode *inode, struct file *file)
737 {
738 	return single_open(file, wil_txdesc_debugfs_show, inode->i_private);
739 }
740 
741 static const struct file_operations fops_txdesc = {
742 	.open		= wil_txdesc_seq_open,
743 	.release	= single_release,
744 	.read		= seq_read,
745 	.llseek		= seq_lseek,
746 };
747 
748 /*---------beamforming------------*/
749 static char *wil_bfstatus_str(u32 status)
750 {
751 	switch (status) {
752 	case 0:
753 		return "Failed";
754 	case 1:
755 		return "OK";
756 	case 2:
757 		return "Retrying";
758 	default:
759 		return "??";
760 	}
761 }
762 
763 static bool is_all_zeros(void * const x_, size_t sz)
764 {
765 	/* if reply is all-0, ignore this CID */
766 	u32 *x = x_;
767 	int n;
768 
769 	for (n = 0; n < sz / sizeof(*x); n++)
770 		if (x[n])
771 			return false;
772 
773 	return true;
774 }
775 
776 static int wil_bf_debugfs_show(struct seq_file *s, void *data)
777 {
778 	int rc;
779 	int i;
780 	struct wil6210_priv *wil = s->private;
781 	struct wmi_notify_req_cmd cmd = {
782 		.interval_usec = 0,
783 	};
784 	struct {
785 		struct wil6210_mbox_hdr_wmi wmi;
786 		struct wmi_notify_req_done_event evt;
787 	} __packed reply;
788 
789 	for (i = 0; i < ARRAY_SIZE(wil->sta); i++) {
790 		u32 status;
791 
792 		cmd.cid = i;
793 		rc = wmi_call(wil, WMI_NOTIFY_REQ_CMDID, &cmd, sizeof(cmd),
794 			      WMI_NOTIFY_REQ_DONE_EVENTID, &reply,
795 			      sizeof(reply), 20);
796 		/* if reply is all-0, ignore this CID */
797 		if (rc || is_all_zeros(&reply.evt, sizeof(reply.evt)))
798 			continue;
799 
800 		status = le32_to_cpu(reply.evt.status);
801 		seq_printf(s, "CID %d {\n"
802 			   "  TSF = 0x%016llx\n"
803 			   "  TxMCS = %2d TxTpt = %4d\n"
804 			   "  SQI = %4d\n"
805 			   "  Status = 0x%08x %s\n"
806 			   "  Sectors(rx:tx) my %2d:%2d peer %2d:%2d\n"
807 			   "  Goodput(rx:tx) %4d:%4d\n"
808 			   "}\n",
809 			   i,
810 			   le64_to_cpu(reply.evt.tsf),
811 			   le16_to_cpu(reply.evt.bf_mcs),
812 			   le32_to_cpu(reply.evt.tx_tpt),
813 			   reply.evt.sqi,
814 			   status, wil_bfstatus_str(status),
815 			   le16_to_cpu(reply.evt.my_rx_sector),
816 			   le16_to_cpu(reply.evt.my_tx_sector),
817 			   le16_to_cpu(reply.evt.other_rx_sector),
818 			   le16_to_cpu(reply.evt.other_tx_sector),
819 			   le32_to_cpu(reply.evt.rx_goodput),
820 			   le32_to_cpu(reply.evt.tx_goodput));
821 	}
822 	return 0;
823 }
824 
825 static int wil_bf_seq_open(struct inode *inode, struct file *file)
826 {
827 	return single_open(file, wil_bf_debugfs_show, inode->i_private);
828 }
829 
830 static const struct file_operations fops_bf = {
831 	.open		= wil_bf_seq_open,
832 	.release	= single_release,
833 	.read		= seq_read,
834 	.llseek		= seq_lseek,
835 };
836 
837 /*---------SSID------------*/
838 static ssize_t wil_read_file_ssid(struct file *file, char __user *user_buf,
839 				  size_t count, loff_t *ppos)
840 {
841 	struct wil6210_priv *wil = file->private_data;
842 	struct wireless_dev *wdev = wil_to_wdev(wil);
843 
844 	return simple_read_from_buffer(user_buf, count, ppos,
845 				       wdev->ssid, wdev->ssid_len);
846 }
847 
848 static ssize_t wil_write_file_ssid(struct file *file, const char __user *buf,
849 				   size_t count, loff_t *ppos)
850 {
851 	struct wil6210_priv *wil = file->private_data;
852 	struct wireless_dev *wdev = wil_to_wdev(wil);
853 	struct net_device *ndev = wil_to_ndev(wil);
854 
855 	if (*ppos != 0) {
856 		wil_err(wil, "Unable to set SSID substring from [%d]\n",
857 			(int)*ppos);
858 		return -EINVAL;
859 	}
860 
861 	if (count > sizeof(wdev->ssid)) {
862 		wil_err(wil, "SSID too long, len = %d\n", (int)count);
863 		return -EINVAL;
864 	}
865 	if (netif_running(ndev)) {
866 		wil_err(wil, "Unable to change SSID on running interface\n");
867 		return -EINVAL;
868 	}
869 
870 	wdev->ssid_len = count;
871 	return simple_write_to_buffer(wdev->ssid, wdev->ssid_len, ppos,
872 				      buf, count);
873 }
874 
875 static const struct file_operations fops_ssid = {
876 	.read = wil_read_file_ssid,
877 	.write = wil_write_file_ssid,
878 	.open  = simple_open,
879 };
880 
881 /*---------temp------------*/
882 static void print_temp(struct seq_file *s, const char *prefix, u32 t)
883 {
884 	switch (t) {
885 	case 0:
886 	case ~(u32)0:
887 		seq_printf(s, "%s N/A\n", prefix);
888 	break;
889 	default:
890 		seq_printf(s, "%s %d.%03d\n", prefix, t / 1000, t % 1000);
891 		break;
892 	}
893 }
894 
895 static int wil_temp_debugfs_show(struct seq_file *s, void *data)
896 {
897 	struct wil6210_priv *wil = s->private;
898 	u32 t_m, t_r;
899 	int rc = wmi_get_temperature(wil, &t_m, &t_r);
900 
901 	if (rc) {
902 		seq_puts(s, "Failed\n");
903 		return 0;
904 	}
905 
906 	print_temp(s, "T_mac   =", t_m);
907 	print_temp(s, "T_radio =", t_r);
908 
909 	return 0;
910 }
911 
912 static int wil_temp_seq_open(struct inode *inode, struct file *file)
913 {
914 	return single_open(file, wil_temp_debugfs_show, inode->i_private);
915 }
916 
917 static const struct file_operations fops_temp = {
918 	.open		= wil_temp_seq_open,
919 	.release	= single_release,
920 	.read		= seq_read,
921 	.llseek		= seq_lseek,
922 };
923 
924 /*---------freq------------*/
925 static int wil_freq_debugfs_show(struct seq_file *s, void *data)
926 {
927 	struct wil6210_priv *wil = s->private;
928 	struct wireless_dev *wdev = wil_to_wdev(wil);
929 	u16 freq = wdev->chandef.chan ? wdev->chandef.chan->center_freq : 0;
930 
931 	seq_printf(s, "Freq = %d\n", freq);
932 
933 	return 0;
934 }
935 
936 static int wil_freq_seq_open(struct inode *inode, struct file *file)
937 {
938 	return single_open(file, wil_freq_debugfs_show, inode->i_private);
939 }
940 
941 static const struct file_operations fops_freq = {
942 	.open		= wil_freq_seq_open,
943 	.release	= single_release,
944 	.read		= seq_read,
945 	.llseek		= seq_lseek,
946 };
947 
948 /*---------link------------*/
949 static int wil_link_debugfs_show(struct seq_file *s, void *data)
950 {
951 	struct wil6210_priv *wil = s->private;
952 	struct station_info sinfo;
953 	int i, rc;
954 
955 	for (i = 0; i < ARRAY_SIZE(wil->sta); i++) {
956 		struct wil_sta_info *p = &wil->sta[i];
957 		char *status = "unknown";
958 
959 		switch (p->status) {
960 		case wil_sta_unused:
961 			status = "unused   ";
962 			break;
963 		case wil_sta_conn_pending:
964 			status = "pending  ";
965 			break;
966 		case wil_sta_connected:
967 			status = "connected";
968 			break;
969 		}
970 		seq_printf(s, "[%d] %pM %s%s\n", i, p->addr, status,
971 			   (p->data_port_open ? " data_port_open" : ""));
972 
973 		if (p->status == wil_sta_connected) {
974 			rc = wil_cid_fill_sinfo(wil, i, &sinfo);
975 			if (rc)
976 				return rc;
977 
978 			seq_printf(s, "  Tx_mcs = %d\n", sinfo.txrate.mcs);
979 			seq_printf(s, "  Rx_mcs = %d\n", sinfo.rxrate.mcs);
980 			seq_printf(s, "  SQ     = %d\n", sinfo.signal);
981 		}
982 	}
983 
984 	return 0;
985 }
986 
987 static int wil_link_seq_open(struct inode *inode, struct file *file)
988 {
989 	return single_open(file, wil_link_debugfs_show, inode->i_private);
990 }
991 
992 static const struct file_operations fops_link = {
993 	.open		= wil_link_seq_open,
994 	.release	= single_release,
995 	.read		= seq_read,
996 	.llseek		= seq_lseek,
997 };
998 
999 /*---------info------------*/
1000 static int wil_info_debugfs_show(struct seq_file *s, void *data)
1001 {
1002 	struct wil6210_priv *wil = s->private;
1003 	struct net_device *ndev = wil_to_ndev(wil);
1004 	int is_ac = power_supply_is_system_supplied();
1005 	int rx = atomic_xchg(&wil->isr_count_rx, 0);
1006 	int tx = atomic_xchg(&wil->isr_count_tx, 0);
1007 	static ulong rxf_old, txf_old;
1008 	ulong rxf = ndev->stats.rx_packets;
1009 	ulong txf = ndev->stats.tx_packets;
1010 	unsigned int i;
1011 
1012 	/* >0 : AC; 0 : battery; <0 : error */
1013 	seq_printf(s, "AC powered : %d\n", is_ac);
1014 	seq_printf(s, "Rx irqs:packets : %8d : %8ld\n", rx, rxf - rxf_old);
1015 	seq_printf(s, "Tx irqs:packets : %8d : %8ld\n", tx, txf - txf_old);
1016 	rxf_old = rxf;
1017 	txf_old = txf;
1018 
1019 #define CHECK_QSTATE(x) (state & BIT(__QUEUE_STATE_ ## x)) ? \
1020 	" " __stringify(x) : ""
1021 
1022 	for (i = 0; i < ndev->num_tx_queues; i++) {
1023 		struct netdev_queue *txq = netdev_get_tx_queue(ndev, i);
1024 		unsigned long state = txq->state;
1025 
1026 		seq_printf(s, "Tx queue[%i] state : 0x%lx%s%s%s\n", i, state,
1027 			   CHECK_QSTATE(DRV_XOFF),
1028 			   CHECK_QSTATE(STACK_XOFF),
1029 			   CHECK_QSTATE(FROZEN)
1030 			  );
1031 	}
1032 #undef CHECK_QSTATE
1033 	return 0;
1034 }
1035 
1036 static int wil_info_seq_open(struct inode *inode, struct file *file)
1037 {
1038 	return single_open(file, wil_info_debugfs_show, inode->i_private);
1039 }
1040 
1041 static const struct file_operations fops_info = {
1042 	.open		= wil_info_seq_open,
1043 	.release	= single_release,
1044 	.read		= seq_read,
1045 	.llseek		= seq_lseek,
1046 };
1047 
1048 /*---------recovery------------*/
1049 /* mode = [manual|auto]
1050  * state = [idle|pending|running]
1051  */
1052 static ssize_t wil_read_file_recovery(struct file *file, char __user *user_buf,
1053 				      size_t count, loff_t *ppos)
1054 {
1055 	struct wil6210_priv *wil = file->private_data;
1056 	char buf[80];
1057 	int n;
1058 	static const char * const sstate[] = {"idle", "pending", "running"};
1059 
1060 	n = snprintf(buf, sizeof(buf), "mode = %s\nstate = %s\n",
1061 		     no_fw_recovery ? "manual" : "auto",
1062 		     sstate[wil->recovery_state]);
1063 
1064 	n = min_t(int, n, sizeof(buf));
1065 
1066 	return simple_read_from_buffer(user_buf, count, ppos,
1067 				       buf, n);
1068 }
1069 
1070 static ssize_t wil_write_file_recovery(struct file *file,
1071 				       const char __user *buf_,
1072 				       size_t count, loff_t *ppos)
1073 {
1074 	struct wil6210_priv *wil = file->private_data;
1075 	static const char run_command[] = "run";
1076 	char buf[sizeof(run_command) + 1]; /* to detect "runx" */
1077 	ssize_t rc;
1078 
1079 	if (wil->recovery_state != fw_recovery_pending) {
1080 		wil_err(wil, "No recovery pending\n");
1081 		return -EINVAL;
1082 	}
1083 
1084 	if (*ppos != 0) {
1085 		wil_err(wil, "Offset [%d]\n", (int)*ppos);
1086 		return -EINVAL;
1087 	}
1088 
1089 	if (count > sizeof(buf)) {
1090 		wil_err(wil, "Input too long, len = %d\n", (int)count);
1091 		return -EINVAL;
1092 	}
1093 
1094 	rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, buf_, count);
1095 	if (rc < 0)
1096 		return rc;
1097 
1098 	buf[rc] = '\0';
1099 	if (0 == strcmp(buf, run_command))
1100 		wil_set_recovery_state(wil, fw_recovery_running);
1101 	else
1102 		wil_err(wil, "Bad recovery command \"%s\"\n", buf);
1103 
1104 	return rc;
1105 }
1106 
1107 static const struct file_operations fops_recovery = {
1108 	.read = wil_read_file_recovery,
1109 	.write = wil_write_file_recovery,
1110 	.open  = simple_open,
1111 };
1112 
1113 /*---------Station matrix------------*/
1114 static void wil_print_rxtid(struct seq_file *s, struct wil_tid_ampdu_rx *r)
1115 {
1116 	int i;
1117 	u16 index = ((r->head_seq_num - r->ssn) & 0xfff) % r->buf_size;
1118 
1119 	seq_printf(s, "0x%03x [", r->head_seq_num);
1120 	for (i = 0; i < r->buf_size; i++) {
1121 		if (i == index)
1122 			seq_printf(s, "%c", r->reorder_buf[i] ? 'O' : '|');
1123 		else
1124 			seq_printf(s, "%c", r->reorder_buf[i] ? '*' : '_');
1125 	}
1126 	seq_printf(s, "] last drop 0x%03x\n", r->ssn_last_drop);
1127 }
1128 
1129 static int wil_sta_debugfs_show(struct seq_file *s, void *data)
1130 {
1131 	struct wil6210_priv *wil = s->private;
1132 	int i, tid;
1133 	unsigned long flags;
1134 
1135 	for (i = 0; i < ARRAY_SIZE(wil->sta); i++) {
1136 		struct wil_sta_info *p = &wil->sta[i];
1137 		char *status = "unknown";
1138 
1139 		switch (p->status) {
1140 		case wil_sta_unused:
1141 			status = "unused   ";
1142 			break;
1143 		case wil_sta_conn_pending:
1144 			status = "pending  ";
1145 			break;
1146 		case wil_sta_connected:
1147 			status = "connected";
1148 			break;
1149 		}
1150 		seq_printf(s, "[%d] %pM %s%s\n", i, p->addr, status,
1151 			   (p->data_port_open ? " data_port_open" : ""));
1152 
1153 		if (p->status == wil_sta_connected) {
1154 			spin_lock_irqsave(&p->tid_rx_lock, flags);
1155 			for (tid = 0; tid < WIL_STA_TID_NUM; tid++) {
1156 				struct wil_tid_ampdu_rx *r = p->tid_rx[tid];
1157 
1158 				if (r) {
1159 					seq_printf(s, "[%2d] ", tid);
1160 					wil_print_rxtid(s, r);
1161 				}
1162 			}
1163 			spin_unlock_irqrestore(&p->tid_rx_lock, flags);
1164 		}
1165 	}
1166 
1167 	return 0;
1168 }
1169 
1170 static int wil_sta_seq_open(struct inode *inode, struct file *file)
1171 {
1172 	return single_open(file, wil_sta_debugfs_show, inode->i_private);
1173 }
1174 
1175 static const struct file_operations fops_sta = {
1176 	.open		= wil_sta_seq_open,
1177 	.release	= single_release,
1178 	.read		= seq_read,
1179 	.llseek		= seq_lseek,
1180 };
1181 
1182 /*----------------*/
1183 static void wil6210_debugfs_init_blobs(struct wil6210_priv *wil,
1184 				       struct dentry *dbg)
1185 {
1186 	int i;
1187 	char name[32];
1188 
1189 	for (i = 0; i < ARRAY_SIZE(fw_mapping); i++) {
1190 		struct debugfs_blob_wrapper *blob = &wil->blobs[i];
1191 		const struct fw_map *map = &fw_mapping[i];
1192 
1193 		if (!map->name)
1194 			continue;
1195 
1196 		blob->data = (void * __force)wil->csr + HOSTADDR(map->host);
1197 		blob->size = map->to - map->from;
1198 		snprintf(name, sizeof(name), "blob_%s", map->name);
1199 		wil_debugfs_create_ioblob(name, S_IRUGO, dbg, blob);
1200 	}
1201 }
1202 
1203 /* misc files */
1204 static const struct {
1205 	const char *name;
1206 	umode_t mode;
1207 	const struct file_operations *fops;
1208 } dbg_files[] = {
1209 	{"mbox",	S_IRUGO,		&fops_mbox},
1210 	{"vrings",	S_IRUGO,		&fops_vring},
1211 	{"stations",	S_IRUGO,		&fops_sta},
1212 	{"desc",	S_IRUGO,		&fops_txdesc},
1213 	{"bf",		S_IRUGO,		&fops_bf},
1214 	{"ssid",	S_IRUGO | S_IWUSR,	&fops_ssid},
1215 	{"mem_val",	S_IRUGO,		&fops_memread},
1216 	{"reset",		  S_IWUSR,	&fops_reset},
1217 	{"rxon",		  S_IWUSR,	&fops_rxon},
1218 	{"tx_mgmt",		  S_IWUSR,	&fops_txmgmt},
1219 	{"wmi_send",		  S_IWUSR,	&fops_wmi},
1220 	{"temp",	S_IRUGO,		&fops_temp},
1221 	{"freq",	S_IRUGO,		&fops_freq},
1222 	{"link",	S_IRUGO,		&fops_link},
1223 	{"info",	S_IRUGO,		&fops_info},
1224 	{"recovery",	S_IRUGO | S_IWUSR,	&fops_recovery},
1225 };
1226 
1227 static void wil6210_debugfs_init_files(struct wil6210_priv *wil,
1228 				       struct dentry *dbg)
1229 {
1230 	int i;
1231 
1232 	for (i = 0; i < ARRAY_SIZE(dbg_files); i++)
1233 		debugfs_create_file(dbg_files[i].name, dbg_files[i].mode, dbg,
1234 				    wil, dbg_files[i].fops);
1235 }
1236 
1237 /* interrupt control blocks */
1238 static const struct {
1239 	const char *name;
1240 	u32 icr_off;
1241 } dbg_icr[] = {
1242 	{"USER_ICR",		HOSTADDR(RGF_USER_USER_ICR)},
1243 	{"DMA_EP_TX_ICR",	HOSTADDR(RGF_DMA_EP_TX_ICR)},
1244 	{"DMA_EP_RX_ICR",	HOSTADDR(RGF_DMA_EP_RX_ICR)},
1245 	{"DMA_EP_MISC_ICR",	HOSTADDR(RGF_DMA_EP_MISC_ICR)},
1246 };
1247 
1248 static void wil6210_debugfs_init_isr(struct wil6210_priv *wil,
1249 				     struct dentry *dbg)
1250 {
1251 	int i;
1252 
1253 	for (i = 0; i < ARRAY_SIZE(dbg_icr); i++)
1254 		wil6210_debugfs_create_ISR(wil, dbg_icr[i].name, dbg,
1255 					   dbg_icr[i].icr_off);
1256 }
1257 
1258 #define WIL_FIELD(name, mode, type) { __stringify(name), mode, \
1259 	offsetof(struct wil6210_priv, name), type}
1260 
1261 /* fields in struct wil6210_priv */
1262 static const struct dbg_off dbg_wil_off[] = {
1263 	WIL_FIELD(secure_pcp,	S_IRUGO | S_IWUSR,	doff_u32),
1264 	WIL_FIELD(status,	S_IRUGO | S_IWUSR,	doff_ulong),
1265 	WIL_FIELD(fw_version,	S_IRUGO,		doff_u32),
1266 	WIL_FIELD(hw_version,	S_IRUGO,		doff_x32),
1267 	WIL_FIELD(recovery_count, S_IRUGO,		doff_u32),
1268 	{},
1269 };
1270 
1271 static const struct dbg_off dbg_wil_regs[] = {
1272 	{"RGF_MAC_MTRL_COUNTER_0", S_IRUGO, HOSTADDR(RGF_MAC_MTRL_COUNTER_0),
1273 		doff_io32},
1274 	{"RGF_USER_USAGE_1", S_IRUGO, HOSTADDR(RGF_USER_USAGE_1), doff_io32},
1275 	{},
1276 };
1277 
1278 /* static parameters */
1279 static const struct dbg_off dbg_statics[] = {
1280 	{"desc_index",	S_IRUGO | S_IWUSR, (ulong)&dbg_txdesc_index, doff_u32},
1281 	{"vring_index",	S_IRUGO | S_IWUSR, (ulong)&dbg_vring_index, doff_u32},
1282 	{"mem_addr",	S_IRUGO | S_IWUSR, (ulong)&mem_addr, doff_u32},
1283 	{},
1284 };
1285 
1286 int wil6210_debugfs_init(struct wil6210_priv *wil)
1287 {
1288 	struct dentry *dbg = wil->debug = debugfs_create_dir(WIL_NAME,
1289 			wil_to_wiphy(wil)->debugfsdir);
1290 
1291 	if (IS_ERR_OR_NULL(dbg))
1292 		return -ENODEV;
1293 
1294 	wil6210_debugfs_init_files(wil, dbg);
1295 	wil6210_debugfs_init_isr(wil, dbg);
1296 	wil6210_debugfs_init_blobs(wil, dbg);
1297 	wil6210_debugfs_init_offset(wil, dbg, wil, dbg_wil_off);
1298 	wil6210_debugfs_init_offset(wil, dbg, (void * __force)wil->csr,
1299 				    dbg_wil_regs);
1300 	wil6210_debugfs_init_offset(wil, dbg, NULL, dbg_statics);
1301 
1302 	wil6210_debugfs_create_pseudo_ISR(wil, dbg);
1303 
1304 	wil6210_debugfs_create_ITR_CNT(wil, dbg);
1305 
1306 	return 0;
1307 }
1308 
1309 void wil6210_debugfs_remove(struct wil6210_priv *wil)
1310 {
1311 	debugfs_remove_recursive(wil->debug);
1312 	wil->debug = NULL;
1313 }
1314