2 * Copyright (c) 2012-2016 Qualcomm Atheros, Inc.
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.
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.
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>
29 /* Nasty hack. Better have per device instances */
31 static u32 dbg_txdesc_index
;
32 static u32 dbg_vring_index
; /* 24+ for Rx, 0..23 for Tx */
33 u32 vring_idle_trsh
= 16; /* HW fetches up to 16 descriptors at once */
48 enum dbg_off_type type
;
51 static void wil_print_vring(struct seq_file
*s
, struct wil6210_priv
*wil
,
52 const char *name
, struct vring
*vring
,
55 void __iomem
*x
= wmi_addr(wil
, vring
->hwtail
);
58 seq_printf(s
, "VRING %s = {\n", name
);
59 seq_printf(s
, " pa = %pad\n", &vring
->pa
);
60 seq_printf(s
, " va = 0x%p\n", vring
->va
);
61 seq_printf(s
, " size = %d\n", vring
->size
);
62 seq_printf(s
, " swtail = %d\n", vring
->swtail
);
63 seq_printf(s
, " swhead = %d\n", vring
->swhead
);
64 seq_printf(s
, " hwtail = [0x%08x] -> ", vring
->hwtail
);
67 seq_printf(s
, "0x%08x = %d\n", v
, v
);
72 if (vring
->va
&& (vring
->size
<= (1 << WIL_RING_SIZE_ORDER_MAX
))) {
75 for (i
= 0; i
< vring
->size
; i
++) {
76 volatile struct vring_tx_desc
*d
= &vring
->va
[i
].tx
;
78 if ((i
% 128) == 0 && (i
!= 0))
80 seq_printf(s
, "%c", (d
->dma
.status
& BIT(0)) ?
81 _s
: (vring
->ctx
[i
].skb
? _h
: 'h'));
88 static int wil_vring_debugfs_show(struct seq_file
*s
, void *data
)
91 struct wil6210_priv
*wil
= s
->private;
93 wil_print_vring(s
, wil
, "rx", &wil
->vring_rx
, 'S', '_');
95 for (i
= 0; i
< ARRAY_SIZE(wil
->vring_tx
); i
++) {
96 struct vring
*vring
= &wil
->vring_tx
[i
];
97 struct vring_tx_data
*txdata
= &wil
->vring_tx_data
[i
];
100 int cid
= wil
->vring2cid_tid
[i
][0];
101 int tid
= wil
->vring2cid_tid
[i
][1];
102 u32 swhead
= vring
->swhead
;
103 u32 swtail
= vring
->swtail
;
104 int used
= (vring
->size
+ swhead
- swtail
)
106 int avail
= vring
->size
- used
- 1;
109 /* performance monitoring */
110 cycles_t now
= get_cycles();
111 uint64_t idle
= txdata
->idle
* 100;
112 uint64_t total
= now
- txdata
->begin
;
116 snprintf(sidle
, sizeof(sidle
), "%3d%%",
119 snprintf(sidle
, sizeof(sidle
), "N/A");
124 snprintf(name
, sizeof(name
), "tx_%2d", i
);
126 if (cid
< WIL6210_MAX_CID
)
128 "\n%pM CID %d TID %d 1x%s BACK([%u] %u TU A%s) [%3d|%3d] idle %s\n",
129 wil
->sta
[cid
].addr
, cid
, tid
,
130 txdata
->dot1x_open
? "+" : "-",
133 txdata
->agg_amsdu
? "+" : "-",
137 "\nBroadcast 1x%s [%3d|%3d] idle %s\n",
138 txdata
->dot1x_open
? "+" : "-",
141 wil_print_vring(s
, wil
, name
, vring
, '_', 'H');
148 static int wil_vring_seq_open(struct inode
*inode
, struct file
*file
)
150 return single_open(file
, wil_vring_debugfs_show
, inode
->i_private
);
153 static const struct file_operations fops_vring
= {
154 .open
= wil_vring_seq_open
,
155 .release
= single_release
,
160 static void wil_seq_hexdump(struct seq_file
*s
, void *p
, int len
,
163 seq_hex_dump(s
, prefix
, DUMP_PREFIX_NONE
, 16, 1, p
, len
, false);
166 static void wil_print_ring(struct seq_file
*s
, const char *prefix
,
169 struct wil6210_priv
*wil
= s
->private;
170 struct wil6210_mbox_ring r
;
174 wil_memcpy_fromio_32(&r
, off
, sizeof(r
));
175 wil_mbox_ring_le2cpus(&r
);
177 * we just read memory block from NIC. This memory may be
178 * garbage. Check validity before using it.
180 rsize
= r
.size
/ sizeof(struct wil6210_mbox_ring_desc
);
182 seq_printf(s
, "ring %s = {\n", prefix
);
183 seq_printf(s
, " base = 0x%08x\n", r
.base
);
184 seq_printf(s
, " size = 0x%04x bytes -> %d entries\n", r
.size
, rsize
);
185 seq_printf(s
, " tail = 0x%08x\n", r
.tail
);
186 seq_printf(s
, " head = 0x%08x\n", r
.head
);
187 seq_printf(s
, " entry size = %d\n", r
.entry_size
);
189 if (r
.size
% sizeof(struct wil6210_mbox_ring_desc
)) {
190 seq_printf(s
, " ??? size is not multiple of %zd, garbage?\n",
191 sizeof(struct wil6210_mbox_ring_desc
));
195 if (!wmi_addr(wil
, r
.base
) ||
196 !wmi_addr(wil
, r
.tail
) ||
197 !wmi_addr(wil
, r
.head
)) {
198 seq_puts(s
, " ??? pointers are garbage?\n");
202 for (i
= 0; i
< rsize
; i
++) {
203 struct wil6210_mbox_ring_desc d
;
204 struct wil6210_mbox_hdr hdr
;
205 size_t delta
= i
* sizeof(d
);
206 void __iomem
*x
= wil
->csr
+ HOSTADDR(r
.base
) + delta
;
208 wil_memcpy_fromio_32(&d
, x
, sizeof(d
));
210 seq_printf(s
, " [%2x] %s %s%s 0x%08x", i
,
212 (r
.tail
- r
.base
== delta
) ? "t" : " ",
213 (r
.head
- r
.base
== delta
) ? "h" : " ",
214 le32_to_cpu(d
.addr
));
215 if (0 == wmi_read_hdr(wil
, d
.addr
, &hdr
)) {
216 u16 len
= le16_to_cpu(hdr
.len
);
218 seq_printf(s
, " -> %04x %04x %04x %02x\n",
219 le16_to_cpu(hdr
.seq
), len
,
220 le16_to_cpu(hdr
.type
), hdr
.flags
);
221 if (len
<= MAX_MBOXITEM_SIZE
) {
222 unsigned char databuf
[MAX_MBOXITEM_SIZE
];
223 void __iomem
*src
= wmi_buffer(wil
, d
.addr
) +
224 sizeof(struct wil6210_mbox_hdr
);
226 * No need to check @src for validity -
227 * we already validated @d.addr while
230 wil_memcpy_fromio_32(databuf
, src
, len
);
231 wil_seq_hexdump(s
, databuf
, len
, " : ");
241 static int wil_mbox_debugfs_show(struct seq_file
*s
, void *data
)
243 struct wil6210_priv
*wil
= s
->private;
245 wil_print_ring(s
, "tx", wil
->csr
+ HOST_MBOX
+
246 offsetof(struct wil6210_mbox_ctl
, tx
));
247 wil_print_ring(s
, "rx", wil
->csr
+ HOST_MBOX
+
248 offsetof(struct wil6210_mbox_ctl
, rx
));
253 static int wil_mbox_seq_open(struct inode
*inode
, struct file
*file
)
255 return single_open(file
, wil_mbox_debugfs_show
, inode
->i_private
);
258 static const struct file_operations fops_mbox
= {
259 .open
= wil_mbox_seq_open
,
260 .release
= single_release
,
265 static int wil_debugfs_iomem_x32_set(void *data
, u64 val
)
267 writel(val
, (void __iomem
*)data
);
268 wmb(); /* make sure write propagated to HW */
273 static int wil_debugfs_iomem_x32_get(void *data
, u64
*val
)
275 *val
= readl((void __iomem
*)data
);
280 DEFINE_SIMPLE_ATTRIBUTE(fops_iomem_x32
, wil_debugfs_iomem_x32_get
,
281 wil_debugfs_iomem_x32_set
, "0x%08llx\n");
283 static struct dentry
*wil_debugfs_create_iomem_x32(const char *name
,
285 struct dentry
*parent
,
288 return debugfs_create_file(name
, mode
, parent
, value
,
292 static int wil_debugfs_ulong_set(void *data
, u64 val
)
294 *(ulong
*)data
= val
;
298 static int wil_debugfs_ulong_get(void *data
, u64
*val
)
300 *val
= *(ulong
*)data
;
304 DEFINE_SIMPLE_ATTRIBUTE(wil_fops_ulong
, wil_debugfs_ulong_get
,
305 wil_debugfs_ulong_set
, "0x%llx\n");
307 static struct dentry
*wil_debugfs_create_ulong(const char *name
, umode_t mode
,
308 struct dentry
*parent
,
311 return debugfs_create_file(name
, mode
, parent
, value
, &wil_fops_ulong
);
315 * wil6210_debugfs_init_offset - create set of debugfs files
316 * @wil - driver's context, used for printing
317 * @dbg - directory on the debugfs, where files will be created
318 * @base - base address used in address calculation
319 * @tbl - table with file descriptions. Should be terminated with empty element.
321 * Creates files accordingly to the @tbl.
323 static void wil6210_debugfs_init_offset(struct wil6210_priv
*wil
,
324 struct dentry
*dbg
, void *base
,
325 const struct dbg_off
* const tbl
)
329 for (i
= 0; tbl
[i
].name
; i
++) {
332 switch (tbl
[i
].type
) {
334 f
= debugfs_create_u32(tbl
[i
].name
, tbl
[i
].mode
, dbg
,
338 f
= debugfs_create_x32(tbl
[i
].name
, tbl
[i
].mode
, dbg
,
342 f
= wil_debugfs_create_ulong(tbl
[i
].name
, tbl
[i
].mode
,
343 dbg
, base
+ tbl
[i
].off
);
346 f
= wil_debugfs_create_iomem_x32(tbl
[i
].name
,
351 f
= debugfs_create_u8(tbl
[i
].name
, tbl
[i
].mode
, dbg
,
355 f
= ERR_PTR(-EINVAL
);
357 if (IS_ERR_OR_NULL(f
))
358 wil_err(wil
, "Create file \"%s\": err %ld\n",
359 tbl
[i
].name
, PTR_ERR(f
));
363 static const struct dbg_off isr_off
[] = {
364 {"ICC", S_IRUGO
| S_IWUSR
, offsetof(struct RGF_ICR
, ICC
), doff_io32
},
365 {"ICR", S_IRUGO
| S_IWUSR
, offsetof(struct RGF_ICR
, ICR
), doff_io32
},
366 {"ICM", S_IRUGO
| S_IWUSR
, offsetof(struct RGF_ICR
, ICM
), doff_io32
},
367 {"ICS", S_IWUSR
, offsetof(struct RGF_ICR
, ICS
), doff_io32
},
368 {"IMV", S_IRUGO
| S_IWUSR
, offsetof(struct RGF_ICR
, IMV
), doff_io32
},
369 {"IMS", S_IWUSR
, offsetof(struct RGF_ICR
, IMS
), doff_io32
},
370 {"IMC", S_IWUSR
, offsetof(struct RGF_ICR
, IMC
), doff_io32
},
374 static int wil6210_debugfs_create_ISR(struct wil6210_priv
*wil
,
376 struct dentry
*parent
, u32 off
)
378 struct dentry
*d
= debugfs_create_dir(name
, parent
);
380 if (IS_ERR_OR_NULL(d
))
383 wil6210_debugfs_init_offset(wil
, d
, (void * __force
)wil
->csr
+ off
,
389 static const struct dbg_off pseudo_isr_off
[] = {
390 {"CAUSE", S_IRUGO
, HOSTADDR(RGF_DMA_PSEUDO_CAUSE
), doff_io32
},
391 {"MASK_SW", S_IRUGO
, HOSTADDR(RGF_DMA_PSEUDO_CAUSE_MASK_SW
), doff_io32
},
392 {"MASK_FW", S_IRUGO
, HOSTADDR(RGF_DMA_PSEUDO_CAUSE_MASK_FW
), doff_io32
},
396 static int wil6210_debugfs_create_pseudo_ISR(struct wil6210_priv
*wil
,
397 struct dentry
*parent
)
399 struct dentry
*d
= debugfs_create_dir("PSEUDO_ISR", parent
);
401 if (IS_ERR_OR_NULL(d
))
404 wil6210_debugfs_init_offset(wil
, d
, (void * __force
)wil
->csr
,
410 static const struct dbg_off lgc_itr_cnt_off
[] = {
411 {"TRSH", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_CNT_TRSH
), doff_io32
},
412 {"DATA", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_CNT_DATA
), doff_io32
},
413 {"CTL", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_CNT_CRL
), doff_io32
},
417 static const struct dbg_off tx_itr_cnt_off
[] = {
418 {"TRSH", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_TX_CNT_TRSH
),
420 {"DATA", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_TX_CNT_DATA
),
422 {"CTL", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_TX_CNT_CTL
),
424 {"IDL_TRSH", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_TX_IDL_CNT_TRSH
),
426 {"IDL_DATA", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_TX_IDL_CNT_DATA
),
428 {"IDL_CTL", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_TX_IDL_CNT_CTL
),
433 static const struct dbg_off rx_itr_cnt_off
[] = {
434 {"TRSH", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_RX_CNT_TRSH
),
436 {"DATA", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_RX_CNT_DATA
),
438 {"CTL", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_RX_CNT_CTL
),
440 {"IDL_TRSH", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_RX_IDL_CNT_TRSH
),
442 {"IDL_DATA", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_RX_IDL_CNT_DATA
),
444 {"IDL_CTL", S_IRUGO
| S_IWUSR
, HOSTADDR(RGF_DMA_ITR_RX_IDL_CNT_CTL
),
449 static int wil6210_debugfs_create_ITR_CNT(struct wil6210_priv
*wil
,
450 struct dentry
*parent
)
452 struct dentry
*d
, *dtx
, *drx
;
454 d
= debugfs_create_dir("ITR_CNT", parent
);
455 if (IS_ERR_OR_NULL(d
))
458 dtx
= debugfs_create_dir("TX", d
);
459 drx
= debugfs_create_dir("RX", d
);
460 if (IS_ERR_OR_NULL(dtx
) || IS_ERR_OR_NULL(drx
))
463 wil6210_debugfs_init_offset(wil
, d
, (void * __force
)wil
->csr
,
466 wil6210_debugfs_init_offset(wil
, dtx
, (void * __force
)wil
->csr
,
469 wil6210_debugfs_init_offset(wil
, drx
, (void * __force
)wil
->csr
,
474 static int wil_memread_debugfs_show(struct seq_file
*s
, void *data
)
476 struct wil6210_priv
*wil
= s
->private;
477 void __iomem
*a
= wmi_buffer(wil
, cpu_to_le32(mem_addr
));
480 seq_printf(s
, "[0x%08x] = 0x%08x\n", mem_addr
, readl(a
));
482 seq_printf(s
, "[0x%08x] = INVALID\n", mem_addr
);
487 static int wil_memread_seq_open(struct inode
*inode
, struct file
*file
)
489 return single_open(file
, wil_memread_debugfs_show
, inode
->i_private
);
492 static const struct file_operations fops_memread
= {
493 .open
= wil_memread_seq_open
,
494 .release
= single_release
,
499 static ssize_t
wil_read_file_ioblob(struct file
*file
, char __user
*user_buf
,
500 size_t count
, loff_t
*ppos
)
502 enum { max_count
= 4096 };
503 struct debugfs_blob_wrapper
*blob
= file
->private_data
;
505 size_t available
= blob
->size
;
512 if (pos
>= available
|| !count
)
515 if (count
> available
- pos
)
516 count
= available
- pos
;
517 if (count
> max_count
)
520 buf
= kmalloc(count
, GFP_KERNEL
);
524 wil_memcpy_fromio_32(buf
, (const volatile void __iomem
*)blob
->data
+
527 ret
= copy_to_user(user_buf
, buf
, count
);
538 static const struct file_operations fops_ioblob
= {
539 .read
= wil_read_file_ioblob
,
541 .llseek
= default_llseek
,
545 struct dentry
*wil_debugfs_create_ioblob(const char *name
,
547 struct dentry
*parent
,
548 struct debugfs_blob_wrapper
*blob
)
550 return debugfs_create_file(name
, mode
, parent
, blob
, &fops_ioblob
);
554 static ssize_t
wil_write_file_reset(struct file
*file
, const char __user
*buf
,
555 size_t len
, loff_t
*ppos
)
557 struct wil6210_priv
*wil
= file
->private_data
;
558 struct net_device
*ndev
= wil_to_ndev(wil
);
562 * this code does NOT sync device state with the rest of system
563 * use with care, debug only!!!
567 ndev
->flags
&= ~IFF_UP
;
569 wil_reset(wil
, true);
574 static const struct file_operations fops_reset
= {
575 .write
= wil_write_file_reset
,
579 /*---write channel 1..4 to rxon for it, 0 to rxoff---*/
580 static ssize_t
wil_write_file_rxon(struct file
*file
, const char __user
*buf
,
581 size_t len
, loff_t
*ppos
)
583 struct wil6210_priv
*wil
= file
->private_data
;
588 char *kbuf
= memdup_user_nul(buf
, len
);
591 return PTR_ERR(kbuf
);
592 rc
= kstrtol(kbuf
, 0, &channel
);
597 if ((channel
< 0) || (channel
> 4)) {
598 wil_err(wil
, "Invalid channel %ld\n", channel
);
604 rc
= wmi_set_channel(wil
, (int)channel
);
609 rc
= wmi_rxon(wil
, on
);
616 static const struct file_operations fops_rxon
= {
617 .write
= wil_write_file_rxon
,
621 /* block ack control, write:
622 * - "add <ringid> <agg_size> <timeout>" to trigger ADDBA
623 * - "del_tx <ringid> <reason>" to trigger DELBA for Tx side
624 * - "del_rx <CID> <TID> <reason>" to trigger DELBA for Rx side
626 static ssize_t
wil_write_back(struct file
*file
, const char __user
*buf
,
627 size_t len
, loff_t
*ppos
)
629 struct wil6210_priv
*wil
= file
->private_data
;
631 char *kbuf
= kmalloc(len
+ 1, GFP_KERNEL
);
638 rc
= simple_write_to_buffer(kbuf
, len
, ppos
, buf
, len
);
641 return rc
>= 0 ? -EIO
: rc
;
645 rc
= sscanf(kbuf
, "%8s %d %d %d", cmd
, &p1
, &p2
, &p3
);
653 if (0 == strcmp(cmd
, "add")) {
655 wil_err(wil
, "BACK: add require at least 2 params\n");
660 wmi_addba(wil
, p1
, p2
, p3
);
661 } else if (0 == strcmp(cmd
, "del_tx")) {
663 p2
= WLAN_REASON_QSTA_LEAVE_QBSS
;
664 wmi_delba_tx(wil
, p1
, p2
);
665 } else if (0 == strcmp(cmd
, "del_rx")) {
668 "BACK: del_rx require at least 2 params\n");
672 p3
= WLAN_REASON_QSTA_LEAVE_QBSS
;
673 wmi_delba_rx(wil
, mk_cidxtid(p1
, p2
), p3
);
675 wil_err(wil
, "BACK: Unrecognized command \"%s\"\n", cmd
);
682 static ssize_t
wil_read_back(struct file
*file
, char __user
*user_buf
,
683 size_t count
, loff_t
*ppos
)
685 static const char text
[] = "block ack control, write:\n"
686 " - \"add <ringid> <agg_size> <timeout>\" to trigger ADDBA\n"
687 "If missing, <timeout> defaults to 0\n"
688 " - \"del_tx <ringid> <reason>\" to trigger DELBA for Tx side\n"
689 " - \"del_rx <CID> <TID> <reason>\" to trigger DELBA for Rx side\n"
690 "If missing, <reason> set to \"STA_LEAVING\" (36)\n";
692 return simple_read_from_buffer(user_buf
, count
, ppos
, text
,
696 static const struct file_operations fops_back
= {
697 .read
= wil_read_back
,
698 .write
= wil_write_back
,
702 /* pmc control, write:
703 * - "alloc <num descriptors> <descriptor_size>" to allocate PMC
704 * - "free" to release memory allocated for PMC
706 static ssize_t
wil_write_pmccfg(struct file
*file
, const char __user
*buf
,
707 size_t len
, loff_t
*ppos
)
709 struct wil6210_priv
*wil
= file
->private_data
;
711 char *kbuf
= kmalloc(len
+ 1, GFP_KERNEL
);
713 int num_descs
, desc_size
;
718 rc
= simple_write_to_buffer(kbuf
, len
, ppos
, buf
, len
);
721 return rc
>= 0 ? -EIO
: rc
;
725 rc
= sscanf(kbuf
, "%8s %d %d", cmd
, &num_descs
, &desc_size
);
732 wil_err(wil
, "pmccfg: no params given\n");
736 if (0 == strcmp(cmd
, "alloc")) {
738 wil_err(wil
, "pmccfg: alloc requires 2 params\n");
741 wil_pmc_alloc(wil
, num_descs
, desc_size
);
742 } else if (0 == strcmp(cmd
, "free")) {
744 wil_err(wil
, "pmccfg: free does not have any params\n");
747 wil_pmc_free(wil
, true);
749 wil_err(wil
, "pmccfg: Unrecognized command \"%s\"\n", cmd
);
756 static ssize_t
wil_read_pmccfg(struct file
*file
, char __user
*user_buf
,
757 size_t count
, loff_t
*ppos
)
759 struct wil6210_priv
*wil
= file
->private_data
;
761 char help
[] = "pmc control, write:\n"
762 " - \"alloc <num descriptors> <descriptor_size>\" to allocate pmc\n"
763 " - \"free\" to free memory allocated for pmc\n";
765 sprintf(text
, "Last command status: %d\n\n%s",
766 wil_pmc_last_cmd_status(wil
),
769 return simple_read_from_buffer(user_buf
, count
, ppos
, text
,
773 static const struct file_operations fops_pmccfg
= {
774 .read
= wil_read_pmccfg
,
775 .write
= wil_write_pmccfg
,
779 static const struct file_operations fops_pmcdata
= {
781 .read
= wil_pmc_read
,
782 .llseek
= wil_pmc_llseek
,
786 /* Write mgmt frame to this file to send it */
787 static ssize_t
wil_write_file_txmgmt(struct file
*file
, const char __user
*buf
,
788 size_t len
, loff_t
*ppos
)
790 struct wil6210_priv
*wil
= file
->private_data
;
791 struct wiphy
*wiphy
= wil_to_wiphy(wil
);
792 struct wireless_dev
*wdev
= wil_to_wdev(wil
);
793 struct cfg80211_mgmt_tx_params params
;
795 void *frame
= kmalloc(len
, GFP_KERNEL
);
800 if (copy_from_user(frame
, buf
, len
)) {
807 params
.chan
= wdev
->preset_chandef
.chan
;
809 rc
= wil_cfg80211_mgmt_tx(wiphy
, wdev
, ¶ms
, NULL
);
812 wil_info(wil
, "%s() -> %d\n", __func__
, rc
);
817 static const struct file_operations fops_txmgmt
= {
818 .write
= wil_write_file_txmgmt
,
822 /* Write WMI command (w/o mbox header) to this file to send it
823 * WMI starts from wil6210_mbox_hdr_wmi header
825 static ssize_t
wil_write_file_wmi(struct file
*file
, const char __user
*buf
,
826 size_t len
, loff_t
*ppos
)
828 struct wil6210_priv
*wil
= file
->private_data
;
829 struct wmi_cmd_hdr
*wmi
;
831 int cmdlen
= len
- sizeof(struct wmi_cmd_hdr
);
838 wmi
= kmalloc(len
, GFP_KERNEL
);
842 rc
= simple_write_to_buffer(wmi
, len
, ppos
, buf
, len
);
848 cmd
= (cmdlen
> 0) ? &wmi
[1] : NULL
;
849 cmdid
= le16_to_cpu(wmi
->command_id
);
851 rc1
= wmi_send(wil
, cmdid
, cmd
, cmdlen
);
854 wil_info(wil
, "%s(0x%04x[%d]) -> %d\n", __func__
, cmdid
, cmdlen
, rc1
);
859 static const struct file_operations fops_wmi
= {
860 .write
= wil_write_file_wmi
,
864 static void wil_seq_print_skb(struct seq_file
*s
, struct sk_buff
*skb
)
867 int len
= skb_headlen(skb
);
869 int nr_frags
= skb_shinfo(skb
)->nr_frags
;
871 seq_printf(s
, " len = %d\n", len
);
872 wil_seq_hexdump(s
, p
, len
, " : ");
875 seq_printf(s
, " nr_frags = %d\n", nr_frags
);
876 for (i
= 0; i
< nr_frags
; i
++) {
877 const struct skb_frag_struct
*frag
=
878 &skb_shinfo(skb
)->frags
[i
];
880 len
= skb_frag_size(frag
);
881 p
= skb_frag_address_safe(frag
);
882 seq_printf(s
, " [%2d] : len = %d\n", i
, len
);
883 wil_seq_hexdump(s
, p
, len
, " : ");
888 /*---------Tx/Rx descriptor------------*/
889 static int wil_txdesc_debugfs_show(struct seq_file
*s
, void *data
)
891 struct wil6210_priv
*wil
= s
->private;
893 bool tx
= (dbg_vring_index
< WIL6210_MAX_TX_RINGS
);
895 vring
= tx
? &wil
->vring_tx
[dbg_vring_index
] : &wil
->vring_rx
;
899 seq_printf(s
, "No Tx[%2d] VRING\n", dbg_vring_index
);
901 seq_puts(s
, "No Rx VRING\n");
905 if (dbg_txdesc_index
< vring
->size
) {
906 /* use struct vring_tx_desc for Rx as well,
907 * only field used, .dma.length, is the same
909 volatile struct vring_tx_desc
*d
=
910 &vring
->va
[dbg_txdesc_index
].tx
;
911 volatile u32
*u
= (volatile u32
*)d
;
912 struct sk_buff
*skb
= vring
->ctx
[dbg_txdesc_index
].skb
;
915 seq_printf(s
, "Tx[%2d][%3d] = {\n", dbg_vring_index
,
918 seq_printf(s
, "Rx[%3d] = {\n", dbg_txdesc_index
);
919 seq_printf(s
, " MAC = 0x%08x 0x%08x 0x%08x 0x%08x\n",
920 u
[0], u
[1], u
[2], u
[3]);
921 seq_printf(s
, " DMA = 0x%08x 0x%08x 0x%08x 0x%08x\n",
922 u
[4], u
[5], u
[6], u
[7]);
923 seq_printf(s
, " SKB = 0x%p\n", skb
);
927 wil_seq_print_skb(s
, skb
);
933 seq_printf(s
, "[%2d] TxDesc index (%d) >= size (%d)\n",
934 dbg_vring_index
, dbg_txdesc_index
,
937 seq_printf(s
, "RxDesc index (%d) >= size (%d)\n",
938 dbg_txdesc_index
, vring
->size
);
944 static int wil_txdesc_seq_open(struct inode
*inode
, struct file
*file
)
946 return single_open(file
, wil_txdesc_debugfs_show
, inode
->i_private
);
949 static const struct file_operations fops_txdesc
= {
950 .open
= wil_txdesc_seq_open
,
951 .release
= single_release
,
956 /*---------beamforming------------*/
957 static char *wil_bfstatus_str(u32 status
)
971 static bool is_all_zeros(void * const x_
, size_t sz
)
973 /* if reply is all-0, ignore this CID */
977 for (n
= 0; n
< sz
/ sizeof(*x
); n
++)
984 static int wil_bf_debugfs_show(struct seq_file
*s
, void *data
)
988 struct wil6210_priv
*wil
= s
->private;
989 struct wmi_notify_req_cmd cmd
= {
993 struct wmi_cmd_hdr wmi
;
994 struct wmi_notify_req_done_event evt
;
997 for (i
= 0; i
< ARRAY_SIZE(wil
->sta
); i
++) {
1001 rc
= wmi_call(wil
, WMI_NOTIFY_REQ_CMDID
, &cmd
, sizeof(cmd
),
1002 WMI_NOTIFY_REQ_DONE_EVENTID
, &reply
,
1004 /* if reply is all-0, ignore this CID */
1005 if (rc
|| is_all_zeros(&reply
.evt
, sizeof(reply
.evt
)))
1008 status
= le32_to_cpu(reply
.evt
.status
);
1009 seq_printf(s
, "CID %d {\n"
1010 " TSF = 0x%016llx\n"
1011 " TxMCS = %2d TxTpt = %4d\n"
1013 " Status = 0x%08x %s\n"
1014 " Sectors(rx:tx) my %2d:%2d peer %2d:%2d\n"
1015 " Goodput(rx:tx) %4d:%4d\n"
1018 le64_to_cpu(reply
.evt
.tsf
),
1019 le16_to_cpu(reply
.evt
.bf_mcs
),
1020 le32_to_cpu(reply
.evt
.tx_tpt
),
1022 status
, wil_bfstatus_str(status
),
1023 le16_to_cpu(reply
.evt
.my_rx_sector
),
1024 le16_to_cpu(reply
.evt
.my_tx_sector
),
1025 le16_to_cpu(reply
.evt
.other_rx_sector
),
1026 le16_to_cpu(reply
.evt
.other_tx_sector
),
1027 le32_to_cpu(reply
.evt
.rx_goodput
),
1028 le32_to_cpu(reply
.evt
.tx_goodput
));
1033 static int wil_bf_seq_open(struct inode
*inode
, struct file
*file
)
1035 return single_open(file
, wil_bf_debugfs_show
, inode
->i_private
);
1038 static const struct file_operations fops_bf
= {
1039 .open
= wil_bf_seq_open
,
1040 .release
= single_release
,
1042 .llseek
= seq_lseek
,
1045 /*---------SSID------------*/
1046 static ssize_t
wil_read_file_ssid(struct file
*file
, char __user
*user_buf
,
1047 size_t count
, loff_t
*ppos
)
1049 struct wil6210_priv
*wil
= file
->private_data
;
1050 struct wireless_dev
*wdev
= wil_to_wdev(wil
);
1052 return simple_read_from_buffer(user_buf
, count
, ppos
,
1053 wdev
->ssid
, wdev
->ssid_len
);
1056 static ssize_t
wil_write_file_ssid(struct file
*file
, const char __user
*buf
,
1057 size_t count
, loff_t
*ppos
)
1059 struct wil6210_priv
*wil
= file
->private_data
;
1060 struct wireless_dev
*wdev
= wil_to_wdev(wil
);
1061 struct net_device
*ndev
= wil_to_ndev(wil
);
1064 wil_err(wil
, "Unable to set SSID substring from [%d]\n",
1069 if (count
> sizeof(wdev
->ssid
)) {
1070 wil_err(wil
, "SSID too long, len = %d\n", (int)count
);
1073 if (netif_running(ndev
)) {
1074 wil_err(wil
, "Unable to change SSID on running interface\n");
1078 wdev
->ssid_len
= count
;
1079 return simple_write_to_buffer(wdev
->ssid
, wdev
->ssid_len
, ppos
,
1083 static const struct file_operations fops_ssid
= {
1084 .read
= wil_read_file_ssid
,
1085 .write
= wil_write_file_ssid
,
1086 .open
= simple_open
,
1089 /*---------temp------------*/
1090 static void print_temp(struct seq_file
*s
, const char *prefix
, u32 t
)
1095 seq_printf(s
, "%s N/A\n", prefix
);
1098 seq_printf(s
, "%s %d.%03d\n", prefix
, t
/ 1000, t
% 1000);
1103 static int wil_temp_debugfs_show(struct seq_file
*s
, void *data
)
1105 struct wil6210_priv
*wil
= s
->private;
1107 int rc
= wmi_get_temperature(wil
, &t_m
, &t_r
);
1110 seq_puts(s
, "Failed\n");
1114 print_temp(s
, "T_mac =", t_m
);
1115 print_temp(s
, "T_radio =", t_r
);
1120 static int wil_temp_seq_open(struct inode
*inode
, struct file
*file
)
1122 return single_open(file
, wil_temp_debugfs_show
, inode
->i_private
);
1125 static const struct file_operations fops_temp
= {
1126 .open
= wil_temp_seq_open
,
1127 .release
= single_release
,
1129 .llseek
= seq_lseek
,
1132 /*---------freq------------*/
1133 static int wil_freq_debugfs_show(struct seq_file
*s
, void *data
)
1135 struct wil6210_priv
*wil
= s
->private;
1136 struct wireless_dev
*wdev
= wil_to_wdev(wil
);
1137 u16 freq
= wdev
->chandef
.chan
? wdev
->chandef
.chan
->center_freq
: 0;
1139 seq_printf(s
, "Freq = %d\n", freq
);
1144 static int wil_freq_seq_open(struct inode
*inode
, struct file
*file
)
1146 return single_open(file
, wil_freq_debugfs_show
, inode
->i_private
);
1149 static const struct file_operations fops_freq
= {
1150 .open
= wil_freq_seq_open
,
1151 .release
= single_release
,
1153 .llseek
= seq_lseek
,
1156 /*---------link------------*/
1157 static int wil_link_debugfs_show(struct seq_file
*s
, void *data
)
1159 struct wil6210_priv
*wil
= s
->private;
1160 struct station_info sinfo
;
1163 for (i
= 0; i
< ARRAY_SIZE(wil
->sta
); i
++) {
1164 struct wil_sta_info
*p
= &wil
->sta
[i
];
1165 char *status
= "unknown";
1167 switch (p
->status
) {
1168 case wil_sta_unused
:
1171 case wil_sta_conn_pending
:
1172 status
= "pending ";
1174 case wil_sta_connected
:
1175 status
= "connected";
1178 seq_printf(s
, "[%d] %pM %s\n", i
, p
->addr
, status
);
1180 if (p
->status
== wil_sta_connected
) {
1181 rc
= wil_cid_fill_sinfo(wil
, i
, &sinfo
);
1185 seq_printf(s
, " Tx_mcs = %d\n", sinfo
.txrate
.mcs
);
1186 seq_printf(s
, " Rx_mcs = %d\n", sinfo
.rxrate
.mcs
);
1187 seq_printf(s
, " SQ = %d\n", sinfo
.signal
);
1194 static int wil_link_seq_open(struct inode
*inode
, struct file
*file
)
1196 return single_open(file
, wil_link_debugfs_show
, inode
->i_private
);
1199 static const struct file_operations fops_link
= {
1200 .open
= wil_link_seq_open
,
1201 .release
= single_release
,
1203 .llseek
= seq_lseek
,
1206 /*---------info------------*/
1207 static int wil_info_debugfs_show(struct seq_file
*s
, void *data
)
1209 struct wil6210_priv
*wil
= s
->private;
1210 struct net_device
*ndev
= wil_to_ndev(wil
);
1211 int is_ac
= power_supply_is_system_supplied();
1212 int rx
= atomic_xchg(&wil
->isr_count_rx
, 0);
1213 int tx
= atomic_xchg(&wil
->isr_count_tx
, 0);
1214 static ulong rxf_old
, txf_old
;
1215 ulong rxf
= ndev
->stats
.rx_packets
;
1216 ulong txf
= ndev
->stats
.tx_packets
;
1219 /* >0 : AC; 0 : battery; <0 : error */
1220 seq_printf(s
, "AC powered : %d\n", is_ac
);
1221 seq_printf(s
, "Rx irqs:packets : %8d : %8ld\n", rx
, rxf
- rxf_old
);
1222 seq_printf(s
, "Tx irqs:packets : %8d : %8ld\n", tx
, txf
- txf_old
);
1226 #define CHECK_QSTATE(x) (state & BIT(__QUEUE_STATE_ ## x)) ? \
1227 " " __stringify(x) : ""
1229 for (i
= 0; i
< ndev
->num_tx_queues
; i
++) {
1230 struct netdev_queue
*txq
= netdev_get_tx_queue(ndev
, i
);
1231 unsigned long state
= txq
->state
;
1233 seq_printf(s
, "Tx queue[%i] state : 0x%lx%s%s%s\n", i
, state
,
1234 CHECK_QSTATE(DRV_XOFF
),
1235 CHECK_QSTATE(STACK_XOFF
),
1236 CHECK_QSTATE(FROZEN
)
1243 static int wil_info_seq_open(struct inode
*inode
, struct file
*file
)
1245 return single_open(file
, wil_info_debugfs_show
, inode
->i_private
);
1248 static const struct file_operations fops_info
= {
1249 .open
= wil_info_seq_open
,
1250 .release
= single_release
,
1252 .llseek
= seq_lseek
,
1255 /*---------recovery------------*/
1256 /* mode = [manual|auto]
1257 * state = [idle|pending|running]
1259 static ssize_t
wil_read_file_recovery(struct file
*file
, char __user
*user_buf
,
1260 size_t count
, loff_t
*ppos
)
1262 struct wil6210_priv
*wil
= file
->private_data
;
1265 static const char * const sstate
[] = {"idle", "pending", "running"};
1267 n
= snprintf(buf
, sizeof(buf
), "mode = %s\nstate = %s\n",
1268 no_fw_recovery
? "manual" : "auto",
1269 sstate
[wil
->recovery_state
]);
1271 n
= min_t(int, n
, sizeof(buf
));
1273 return simple_read_from_buffer(user_buf
, count
, ppos
,
1277 static ssize_t
wil_write_file_recovery(struct file
*file
,
1278 const char __user
*buf_
,
1279 size_t count
, loff_t
*ppos
)
1281 struct wil6210_priv
*wil
= file
->private_data
;
1282 static const char run_command
[] = "run";
1283 char buf
[sizeof(run_command
) + 1]; /* to detect "runx" */
1286 if (wil
->recovery_state
!= fw_recovery_pending
) {
1287 wil_err(wil
, "No recovery pending\n");
1292 wil_err(wil
, "Offset [%d]\n", (int)*ppos
);
1296 if (count
> sizeof(buf
)) {
1297 wil_err(wil
, "Input too long, len = %d\n", (int)count
);
1301 rc
= simple_write_to_buffer(buf
, sizeof(buf
) - 1, ppos
, buf_
, count
);
1306 if (0 == strcmp(buf
, run_command
))
1307 wil_set_recovery_state(wil
, fw_recovery_running
);
1309 wil_err(wil
, "Bad recovery command \"%s\"\n", buf
);
1314 static const struct file_operations fops_recovery
= {
1315 .read
= wil_read_file_recovery
,
1316 .write
= wil_write_file_recovery
,
1317 .open
= simple_open
,
1320 /*---------Station matrix------------*/
1321 static void wil_print_rxtid(struct seq_file
*s
, struct wil_tid_ampdu_rx
*r
)
1324 u16 index
= ((r
->head_seq_num
- r
->ssn
) & 0xfff) % r
->buf_size
;
1325 unsigned long long drop_dup
= r
->drop_dup
, drop_old
= r
->drop_old
;
1327 seq_printf(s
, "([%2d] %3d TU) 0x%03x [", r
->buf_size
, r
->timeout
,
1329 for (i
= 0; i
< r
->buf_size
; i
++) {
1331 seq_printf(s
, "%c", r
->reorder_buf
[i
] ? 'O' : '|');
1333 seq_printf(s
, "%c", r
->reorder_buf
[i
] ? '*' : '_');
1336 "] total %llu drop %llu (dup %llu + old %llu) last 0x%03x\n",
1337 r
->total
, drop_dup
+ drop_old
, drop_dup
, drop_old
,
1341 static void wil_print_rxtid_crypto(struct seq_file
*s
, int tid
,
1342 struct wil_tid_crypto_rx
*c
)
1346 for (i
= 0; i
< 4; i
++) {
1347 struct wil_tid_crypto_rx_single
*cc
= &c
->key_id
[i
];
1355 if (tid
< WIL_STA_TID_NUM
)
1356 seq_printf(s
, " [%2d] PN", tid
);
1358 seq_puts(s
, " [GR] PN");
1360 for (i
= 0; i
< 4; i
++) {
1361 struct wil_tid_crypto_rx_single
*cc
= &c
->key_id
[i
];
1363 seq_printf(s
, " [%i%s]%6phN", i
, cc
->key_set
? "+" : "-",
1369 static int wil_sta_debugfs_show(struct seq_file
*s
, void *data
)
1370 __acquires(&p
->tid_rx_lock
) __releases(&p
->tid_rx_lock
)
1372 struct wil6210_priv
*wil
= s
->private;
1375 for (i
= 0; i
< ARRAY_SIZE(wil
->sta
); i
++) {
1376 struct wil_sta_info
*p
= &wil
->sta
[i
];
1377 char *status
= "unknown";
1379 switch (p
->status
) {
1380 case wil_sta_unused
:
1383 case wil_sta_conn_pending
:
1384 status
= "pending ";
1386 case wil_sta_connected
:
1387 status
= "connected";
1390 seq_printf(s
, "[%d] %pM %s\n", i
, p
->addr
, status
);
1392 if (p
->status
== wil_sta_connected
) {
1393 spin_lock_bh(&p
->tid_rx_lock
);
1394 for (tid
= 0; tid
< WIL_STA_TID_NUM
; tid
++) {
1395 struct wil_tid_ampdu_rx
*r
= p
->tid_rx
[tid
];
1396 struct wil_tid_crypto_rx
*c
=
1397 &p
->tid_crypto_rx
[tid
];
1400 seq_printf(s
, " [%2d] ", tid
);
1401 wil_print_rxtid(s
, r
);
1404 wil_print_rxtid_crypto(s
, tid
, c
);
1406 wil_print_rxtid_crypto(s
, WIL_STA_TID_NUM
,
1407 &p
->group_crypto_rx
);
1408 spin_unlock_bh(&p
->tid_rx_lock
);
1410 "Rx invalid frame: non-data %lu, short %lu, large %lu, replay %lu\n",
1411 p
->stats
.rx_non_data_frame
,
1412 p
->stats
.rx_short_frame
,
1413 p
->stats
.rx_large_frame
,
1414 p
->stats
.rx_replay
);
1416 seq_puts(s
, "Rx/MCS:");
1417 for (mcs
= 0; mcs
< ARRAY_SIZE(p
->stats
.rx_per_mcs
);
1419 seq_printf(s
, " %lld",
1420 p
->stats
.rx_per_mcs
[mcs
]);
1428 static int wil_sta_seq_open(struct inode
*inode
, struct file
*file
)
1430 return single_open(file
, wil_sta_debugfs_show
, inode
->i_private
);
1433 static const struct file_operations fops_sta
= {
1434 .open
= wil_sta_seq_open
,
1435 .release
= single_release
,
1437 .llseek
= seq_lseek
,
1440 /*----------------*/
1441 static void wil6210_debugfs_init_blobs(struct wil6210_priv
*wil
,
1447 for (i
= 0; i
< ARRAY_SIZE(fw_mapping
); i
++) {
1448 struct debugfs_blob_wrapper
*blob
= &wil
->blobs
[i
];
1449 const struct fw_map
*map
= &fw_mapping
[i
];
1454 blob
->data
= (void * __force
)wil
->csr
+ HOSTADDR(map
->host
);
1455 blob
->size
= map
->to
- map
->from
;
1456 snprintf(name
, sizeof(name
), "blob_%s", map
->name
);
1457 wil_debugfs_create_ioblob(name
, S_IRUGO
, dbg
, blob
);
1462 static const struct {
1465 const struct file_operations
*fops
;
1467 {"mbox", S_IRUGO
, &fops_mbox
},
1468 {"vrings", S_IRUGO
, &fops_vring
},
1469 {"stations", S_IRUGO
, &fops_sta
},
1470 {"desc", S_IRUGO
, &fops_txdesc
},
1471 {"bf", S_IRUGO
, &fops_bf
},
1472 {"ssid", S_IRUGO
| S_IWUSR
, &fops_ssid
},
1473 {"mem_val", S_IRUGO
, &fops_memread
},
1474 {"reset", S_IWUSR
, &fops_reset
},
1475 {"rxon", S_IWUSR
, &fops_rxon
},
1476 {"tx_mgmt", S_IWUSR
, &fops_txmgmt
},
1477 {"wmi_send", S_IWUSR
, &fops_wmi
},
1478 {"back", S_IRUGO
| S_IWUSR
, &fops_back
},
1479 {"pmccfg", S_IRUGO
| S_IWUSR
, &fops_pmccfg
},
1480 {"pmcdata", S_IRUGO
, &fops_pmcdata
},
1481 {"temp", S_IRUGO
, &fops_temp
},
1482 {"freq", S_IRUGO
, &fops_freq
},
1483 {"link", S_IRUGO
, &fops_link
},
1484 {"info", S_IRUGO
, &fops_info
},
1485 {"recovery", S_IRUGO
| S_IWUSR
, &fops_recovery
},
1488 static void wil6210_debugfs_init_files(struct wil6210_priv
*wil
,
1493 for (i
= 0; i
< ARRAY_SIZE(dbg_files
); i
++)
1494 debugfs_create_file(dbg_files
[i
].name
, dbg_files
[i
].mode
, dbg
,
1495 wil
, dbg_files
[i
].fops
);
1498 /* interrupt control blocks */
1499 static const struct {
1503 {"USER_ICR", HOSTADDR(RGF_USER_USER_ICR
)},
1504 {"DMA_EP_TX_ICR", HOSTADDR(RGF_DMA_EP_TX_ICR
)},
1505 {"DMA_EP_RX_ICR", HOSTADDR(RGF_DMA_EP_RX_ICR
)},
1506 {"DMA_EP_MISC_ICR", HOSTADDR(RGF_DMA_EP_MISC_ICR
)},
1509 static void wil6210_debugfs_init_isr(struct wil6210_priv
*wil
,
1514 for (i
= 0; i
< ARRAY_SIZE(dbg_icr
); i
++)
1515 wil6210_debugfs_create_ISR(wil
, dbg_icr
[i
].name
, dbg
,
1516 dbg_icr
[i
].icr_off
);
1519 #define WIL_FIELD(name, mode, type) { __stringify(name), mode, \
1520 offsetof(struct wil6210_priv, name), type}
1522 /* fields in struct wil6210_priv */
1523 static const struct dbg_off dbg_wil_off
[] = {
1524 WIL_FIELD(privacy
, S_IRUGO
, doff_u32
),
1525 WIL_FIELD(status
[0], S_IRUGO
| S_IWUSR
, doff_ulong
),
1526 WIL_FIELD(fw_version
, S_IRUGO
, doff_u32
),
1527 WIL_FIELD(hw_version
, S_IRUGO
, doff_x32
),
1528 WIL_FIELD(recovery_count
, S_IRUGO
, doff_u32
),
1529 WIL_FIELD(ap_isolate
, S_IRUGO
, doff_u32
),
1530 WIL_FIELD(discovery_mode
, S_IRUGO
| S_IWUSR
, doff_u8
),
1534 static const struct dbg_off dbg_wil_regs
[] = {
1535 {"RGF_MAC_MTRL_COUNTER_0", S_IRUGO
, HOSTADDR(RGF_MAC_MTRL_COUNTER_0
),
1537 {"RGF_USER_USAGE_1", S_IRUGO
, HOSTADDR(RGF_USER_USAGE_1
), doff_io32
},
1541 /* static parameters */
1542 static const struct dbg_off dbg_statics
[] = {
1543 {"desc_index", S_IRUGO
| S_IWUSR
, (ulong
)&dbg_txdesc_index
, doff_u32
},
1544 {"vring_index", S_IRUGO
| S_IWUSR
, (ulong
)&dbg_vring_index
, doff_u32
},
1545 {"mem_addr", S_IRUGO
| S_IWUSR
, (ulong
)&mem_addr
, doff_u32
},
1546 {"vring_idle_trsh", S_IRUGO
| S_IWUSR
, (ulong
)&vring_idle_trsh
,
1551 int wil6210_debugfs_init(struct wil6210_priv
*wil
)
1553 struct dentry
*dbg
= wil
->debug
= debugfs_create_dir(WIL_NAME
,
1554 wil_to_wiphy(wil
)->debugfsdir
);
1556 if (IS_ERR_OR_NULL(dbg
))
1561 wil6210_debugfs_init_files(wil
, dbg
);
1562 wil6210_debugfs_init_isr(wil
, dbg
);
1563 wil6210_debugfs_init_blobs(wil
, dbg
);
1564 wil6210_debugfs_init_offset(wil
, dbg
, wil
, dbg_wil_off
);
1565 wil6210_debugfs_init_offset(wil
, dbg
, (void * __force
)wil
->csr
,
1567 wil6210_debugfs_init_offset(wil
, dbg
, NULL
, dbg_statics
);
1569 wil6210_debugfs_create_pseudo_ISR(wil
, dbg
);
1571 wil6210_debugfs_create_ITR_CNT(wil
, dbg
);
1576 void wil6210_debugfs_remove(struct wil6210_priv
*wil
)
1578 debugfs_remove_recursive(wil
->debug
);
1581 /* free pmc memory without sending command to fw, as it will
1582 * be reset on the way down anyway
1584 wil_pmc_free(wil
, false);